python 函数名 大写字母 python全部大写函数

python的内置函数大全

针对基础数据类型

字符串

内置函数：upper()
功能：字符串中的内容全部大写
用法：
s = "pl"
s1 = s.upper() 
print(s1)
#>>>PL

内置函数：lower()
功能：字符串中的内容全部小写
用法：
s = "PL"
s1 = s.lower() # 全部小写
print(s1)
#>>>pl

内置函数：startswith()
功能：判断字符串以什么元素开头
用法：
s = "ALEX"
s1 = s.startswith("E",2,6)  #2,6是限定范围
print(s1)
#>>>True

内置函数：endswith()
功能：判断字符串以什么元素结尾
用法：
s = "ALEX"
s1 = s.endswith("E",2,6)
print(s1)
#>>>False

内置函数：count()
功能：统计字符串中元素出现的次数
用法：
s= "alexdxjbx"
s1 = s.count("x")
print(s1)
#>>>3

内置函数：strip()
功能：脱去字符串头尾两端的空格和换行符以及制表符
用法：
s = 'go  d   is  a gril  '
print (s.strip())
#>>>go  d   is  a gril 默认脱掉字符串的开头和末尾的空格
#指定脱元素脱，只能脱第一个元素
print (s.strip("g"))
print(s.lstrip('*')) #从字符串的左边开始脱
print(s.rstrip('*')) #从字符串的右边开始脱

内置函数：split()
功能：分割:以空格和换行符以及制表符进行分割，最终形成一个列表此      列表不含有这个分割的元素。
用法：
s = "aelxlaaa"
s1 = s.split("l",maxsplit=1)  #可以通过指定方式进行切割
s2 = s.split("l",maxsplit=5)  #全切，可以超过所切元素的个数
print(s1)
#>>>['ae', 'xlaaa']
print(s2)
#>>>['ae', 'x', 'aaa']

内置函数：replace()
功能：替换
用法：
s = "小白兔喜欢大灰狼，小白兔喜欢大灰狼"
s1 = s.replace("小白兔","小青蛙")
print(s1)
#>>>小青蛙喜欢大灰狼，小青蛙喜欢大灰狼

内置函数：is 系列
功能：判断字符串
用法：
s = "12"
print(s.isalnum()) # 判断是不是字母,数字,中文
print(s.isalpha())  # 判断是不是字母,中文
print(s.isdigit())  # 判断字符串是不是全都是阿拉伯数字
print(s.isdecimal())  # 判断是否是十进制
#>>>True
#>>>False
#>>>True
#>>>True

内置函数：len()
功能：获取字符串的长度
用法：
name = "pl"
print(len(name))
#>>>2

#首字母大写
s = "god is a girl."
print (s.capitalize())

#每个单词的首字母大写
s = "god is a girl."
print (s.title())

#大小写反转
s = "god is A girl."
print (s.swapcase())

#查找
s = "god is a girl."
print(s.find("s"))  #都是按照元素值查找元素的位置，没有改元素时返回None
print (s.index("d"))   #和find一样的效果，但是找不到元素时会报错

#居中
s = "god is a girl."
print (s.center(20)) #该字符串占据了20个位置，同时处在这20个字符串的中间

#填充
#.format()   %   f
s = "god {} {} {}"
print (s.format("is","a","girl"))  #按照位置顺序填充
s = "god {1} {2} {0}"
print (s.format("is","a","gril"))#按照下标填充
s = "god {a} {b} {c}"
print (s.format(a="is",b="a",c="gril")) #按照关键字填充

#字符串+
s = "god is"
s1 = " a  gril."
print (id(s),id(s1),id(s+s1))   #把s1的字符串追加到s后面
#字符串*
s = "good"
print (s*4)
#注：字符+和*都是开辟新的空间

列表

增

内置函数：append()
功能：追加元素带列表的末尾。
用法：
lst = [1,2,3]
lst.append(4):
#>>>[1,2,3,4]

内置函数：insert()
功能：在列表指定的位置插入元素。(不删除原来的元素)
用法：
lst = [1,2,3]
lst.insert(0,100)：
#>>>[100,1,2,3]
注：一般情况下最好不要用insert，因为当数据量比较大的时候，插入值后面的元素后移就会影响效率的。

内置函数：extend()
功能：将可迭代对象迭代添加到列表的尾部。
用法：
lst = [1,2,3]
lst.extend("pl")：
#>>>[1,2,3,'p','l']

删

内置函数：pop()
功能：通过索引删除列表中的元素，默认情况下删除最后以一个元素，返回值为删除的元素。
用法：
lst = [1,2,3]
lst.pop():
#>>>[1,2]

内置函数：remove()
功能：按照元素值索引并删除索引到的第一个元素。
用法：
lst = [1,2,3]
lst.remove(1):
#>>>[2,3]

内置函数：clear()
功能：清空列表。
用法：
lst = [1,2,3]
lst.clear()
#>>>[]

内置函数：del()
功能：按照索引，切片，步长删除列表中的元素，同时还可以删除列表。
用法：
#索引删除该元素
lst = [1,2,3]
del lst[0]
#>>>[2,3]

# 切片删除该元素
l = ['pl', 'pl1', 'pl2', 'pl3']
del l[1:]
print(l) # ['pl1']

# 切片(步长)删除该元素
l = ['pl', 'pl2', 'pl3', 'pl4']
del l[::2]
print(l) # ['pl2', 'pl4']
#注:这么删除会有坑，后面会遇到

#反转
lst = [1,2,3,4]
#print (lst.reverse())  #这个返回的是None
lst.reverse()
print (lst)

#排序
lst = [1,2,3,45,2,36,5]
lst.sort()    #默认升序
print(lst)

#排序之降序
lst.sort(reverse=True)
print (lst)

#统计
print (lst.count(2))  #统计2出现的次数

字典

增

内置函数：setdefault()
功能：无键添加，有键不变
用法：
dic = {"首都":"北京","a":123,"s":"下"}
dic["name"] = "pl" #暴力添加
dic.setdefault("s","s")  
print (dic)
#>>>{'首都': '北京', 'a': 123, 's': '下', 'name': 'pl'}

删

内置函数：popitem()
功能：在python3.5之前随机删除，在3.6之后删除最后一个，有返回值。
用法：
dic = {"首都":"北京","a":123,"s":"下"}
del dic["s"]  
print (dic)
#>>>{'首都': '北京', 'a': 123}

dic.pop("a")  #按照键去删除，有返回值
print (dic)
#>>>{'首都': '北京'}

dic.clear()   #清空字典
print (dic)
#>>>{}
dic = {"首都":"北京","a":123,"s":"下"}

dic.popitem() 
print (dic)
#>>>{'首都': '北京', 'a': 123}

改

内置函数：update()
功能：更新字典
用法：
dic = {"首都":"北京","a":123,"s":"下"}
dic["s"] = "pl"  #和暴力添加一样，但是各种滋味，细细品味
print (dic)
#>>>{'首都': '北京', 'a': 123, 's': 'pl'}

dic.update({"a":456,"name":"pl"})  
print (dic)
#>>>{'首都': '北京', 'a': 456, 's': 'pl', 'name': 'pl'}

#批量创建字典
dic = {}
dic1 =dic.fromkeys(可迭代数据，所有键公用的值)
#注：共享值最好使用不可变的数据类型，这样可以避免所有的键都使用一片可变的值得空间地址
#这样，在改变其中的某一个值的时候，去其他所有的键的值都会发生改变的，；但是当我们使用的
#不可变的数据类型当作值得时候，就算我们去改变其中的某一个键对应的值得时候，其他的键对应的值
#也不会改变。

集合

增

内置函数：add()
功能：增加一个值
用法：
s = {1,2,3}
s. add(4) 
#>>>{1,2,3,4}

内置函数：update()
功能：迭代添加
用法：
s = {1,2,3}
s.update('pl')  
#>>>{1,2,3,'p','l'}

内置函数大全

常用的

#求绝对值
abs() 

#枚举,返回元组，指定枚举从多少开始计数（默认是0）
print (enumerate([1,2,3],1))

#求最大值
max()

#求最小值
min() 

#求和
sum() 

#过滤（符合条件的留下）
filter() 
lst = [2,3,5,6,8,9,12,1,2,36] 
def func(s):
	return s>3
print (filter(func,lst))  #返回生成器
print (list(filter(func,lst)))

#对象映射
map() 
lst = [1,2,3,4,5,6,7]
print (map(lambda x:x*x,lst))  #返回生成器
print (list(map(lambda x:x*x,lst)))

#打开文件
open() 

#范围，控制数字范围
range() 

#打印函数，第一个参数是设定分隔符
print(sep="",end="\n") 

#通用的计算对象长度，__len__
len() 

#字符串，__str__
str()
#列表
list()
#元组
tuple() 
#字典
dict()
#集合
set()

#转二进制
bin()

#浮点型数据
float() 

#反转，新开辟一片空间
reversed()   #返回迭代器

#排序，新开辟一片空间，默认升序
sorted()

#返回对象类型
type() 

#拉链--按照最少的进行合并，返回的是元组
zip() 

#查看对象的中所有方法
dir() 

#累计算
reduce()
from functools import reduce
print(reduce(lambda x,y:x-y,[1,2,3,4,5]))

#类方法，装饰器装饰在函数的前面
classmethod() 

#反射
#判断文件中是否存在自定字符串的方法，类等
hasattr() 
#取得......
getattr() 
#设置......
setattr() 
#删除......
delattr() 

#判断类名或者对象是否是另一个类的实例化对象
isinstance() 
#判断一个类或者对象是否是另一个类的子类
issubclass() 

#基类
object() 

#属性，装饰器，装饰在方法的前面
property() 

#静态属性，装饰器，装饰在方法的前面
staticmethod() 

#按照类继承的mro调用父类的属性和方法
super()

#返回对象的属性和属性值的字典对象
vars()

#连接对象
join()

不太常用的

# 判断元素是否都为真  相似and
print (all( [1,2,3,False,4,5,6,7]))

# 判断元素是否有真    相似or
print (any( [1,2,3,False,4,5,6,7]))

#把数据类型转换成bytes类型，记得编码
print (bytes("asdf",encoding='utf-8'))

#判断一个对象是否为可被调用
print (callable(obj))

#通过数字找编码中对应的字符
print (chr(65)) 

#通过字符找编码中对应的数字
print (ord(A))

#复数
complex() 

#求商和余数,返回一个元组
print (divmod(5,2)) 

#转换数据类型，坚决不能使用
eval（) 

#动态执行python代码，永远返回None
exec() 

#字符串的格式化
format() 

#集合的冻结
frozenset() 

#查看全局中的变量
globals() 

#查看当前空间的变量（局部的）
locals() 

#做哈希
hash() 

#查看对象的帮助信息
help() 

#查看对象的内存地址
id() 

#输入
input() 

#整形
int() 

#产生生成器
iter() 

#取迭代器，生成器的值
next() 

#八进制
oct() 

#幂
print (pow(2,3))  #2的3次方 

#查看数据的原生类型，__repr__
repr() 

#用十进制数字将一个数字舍入到给定的精度。
print (round(50.2323,2)) #>>>50.23

#比较
cmp(obj1,obj2)

#判断布尔型
bool()