一些内置函数
//abs()函数，返回绝对值
a = -1 b = abs(a) print(a,b) 结果 -1 1
//all()函数，传入一个列表或者元组，对每个元素进行bool运算，当全部为真时为真（也就是对元素进行且运算），否则为假 一个参数
a = all([1,2,3,"sdf"]) b = all([1,'s',0]) print(a,b) 结果 True False 迭代其每一个元素，每个元素是一个整体 print(all("1230")) //“1230”是一个整体 不能拆开看，如“1”“2”“3”“0” 结果True 如果可迭代对象为空则返回True print(all([])) 结果 True
//any()函数，一个参数，对可迭代对象进行或运算，即只要有一个为真就ok
a = any([1,0,"",None]) print(a) 结果 True
//bin()函数，将一个数转换成二进制数 一个参数，默认传入的是十进制 hex()转16进制， oct()转8进制
a = bin(10) b = bin(0xb) print(a,b) 结果 0b1010 0b1011
//bool()函数，判断传入的参数的bool值
a = bool(1) b = bool(False) print(a,b) 结果 True False
//bytes()函数，将字符串进行编码，可以选择编码形式
a = bytes("djh",encoding="gbk") print(a,a.decode("gbk")) b = bytes("djh",encoding="utf-8") print(b,b.decode("utf-8")) 结果 b'\xb4\xf7\xbc\xce\xba\xc0' djh b'\xe6\x88\xb4\xe5\x98\x89\xe8\xb1\xaa' djh
//chr()函数，以ascll码为标准将十进制数对应的字符输出 ord()函数刚好相反，给一个字母，输出对应的ascll码
a = chr(99) print(a) 结果 c
//dir()函数 用于查看某个函数的一些属性
print(dir(abs))
//divmod()函数，两个参数，返回一个二元组
a = divmod(10,3) print(a,type(a)) 结果 (3, 1) <class 'tuple'> //10/3 商为3 余1
//enumerate()函数，传入一个可迭代对象，返回一个迭代器 效果自己看啦
a = enumerate(["Aa",'s','f','fgs']) print(list(a)) 结果 [(0, 'Aa'), (1, 's'), (2, 'f'), (3, 'fgs')]
//eval()函数，提取字符串中的数据结构，举例自己感受 也可以将字符串内的数学运算做出来
a = eval("[1,2,3],(1,2,3),{'name':'djh'}") print(a,type(a)) 结果 ([1, 2, 3], (1, 2, 3), {'name': 'djh'}) <class 'tuple'> a = eval("[1,2,3]") print(a,type(a)) 结果 [1, 2, 3] <class 'list'> a = eval("{'name':'djh'}") //里面如果有字典必须用单引号 '' print(a,type(a)) 结果 {'name': 'djh'} <class 'dict'> a = "1+2+3-1*7+8/3" print(eval(a)) 结果 1.6666666666666665
//locals()函数和globals()函数， locals()函数返回一个字典，局部命名空间的所有变量名为其key值，变量名的值为对应的values值 globals()函数和locals()函数一样，不过就是返回全局的而已
def func(args): z=1 a=2 b="a" print(locals()) asd=1 zxc=2 qwe="d" func(10) print(globals()) 结果 {'b': 'a', 'a': 2, 'z': 1, 'args': 10} {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F6F2C5D128>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/python编程/2.py', '__cached__': None, 'func': <function func at 0x000001F6F1052EA0>, 'asd': 1, 'zxc': 2, 'qwe': 'd'}
//hash()函数，得到一个哈希值 啥叫哈希呢？它是一个算法，简单的讲就是计算一个字符串的哈希值，如果一个字符串被修改了其哈希值也被修改，主要用在网络传输数据时用，比如如果有给hacker在你下载软件的时候截取了你的数据包，他在里面修改了数据加入了一段木马程序，那哈希值就变了，那就可以知道数据被恶意篡改过，软件就不安全咯
a = "djh" print(hash(a)) a = "zx" print(hash(a)) 结果 4493107922465005046 -254011192013325394
//help()函数，打印另一个函数的注释部分
print(help(all)) 结果 Help on built-in function all in module builtins: all(iterable, /) Return True if bool(x) is True for all values x in the iterable. If the iterable is empty, return True. None
//isinstance()函数，两个参数，判断第一个参数是否是第二个参数的实列
print(isinstance("a",str)) print(isinstance("a",int)) 结果 True False
//zip()函数，自己感受
a = list(zip([1,23,4,5],"asdfzx",(1,2,"A,s","s"))) //有多少给参数都可以，每个参数必须是序列，返回一个可迭代对象 print(a) 结果 [(1, 'a', 1), (23, 's', 2), (4, 'd', 'A,s'), (5, 'f', 's')]//每个元素都是元组 即每个元素内部不可以修改 a = dict(zip([1,23,4,5],"asdfzx")) //如果要生成字典，那必须只可以是两个参数 print(a) 结果 {1: 'a', 23: 's', 4: 'd', 5: 'f'}
//max()函数，接收一个参数，只要这个参数可for循环 对其迭代判断取出最大的 （如果是列表，元组这些的，元素必须是同个类型的才可以）
比较的是一个一个数字
a = max([1,2,3,4,5]) print(a) 结果 5
比较的是一个序列
a = max("sdagdfd") print(a) 结果 s a = max(((4,1),(2,1),(5,"a"))) print(a) 结果 (5, 'a') 现在有这么给需求，需要从一个字典里找出年纪最大的人 输出他的名字和年纪 people = {"djh":18,"hhh":22,"xxx":33} a = max(zip(people.values(),people.keys())) //这里接收利用了zip()函数生成了上一个例子中的max()函数的参数那样 print(a) 结果 (33, 'xxx')
比较的是一个字典
people=[ {"name":'djh','age':18}, {'name':'xxx','age':22}, {'name':'hhh','age':99} ] a = max(people,key=lambda x:x['age'])//这时候需要再传一个参数key 就是比较的方法，因为字典不可以直接比较 print(a) 结果 {'name': 'hhh', 'age': 99}
//min()函数和max()函数用法一模一样 只不过是要找最小的而已
//pow()函数，三个参数 自己感受
a = pow(4,3)//相当于 4**3 4的3次方 print(a) a = pow(4,3,2)//相当于 （4**3）%2 4的3次方再对2取余数 print(a) 结果 64 0
//reversed()函数，对列表或者元组（当然可能还有其他的也可以）进行翻转，返回一个迭代器， 对原列表或者元组无影响
a = [1,2,3,4] a = reversed(a) print(a,list(a)) 结果 <list_reverseiterator object at 0x00000240C411D1D0> [4, 3, 2, 1]
//round()函数，直接对小数进行四舍五入为整数
print(round(3.753)) 结果 4
//slice()函数，这个函数是切片专用的函数，它不属于任意一个列表，也就是说你可以先定义要从哪切到哪，对应任意一个序列都可以用，记住用切片专用符号[]来接收
a = [1,2,3,4,5,6] b = [2,3,4,5,6,7] s = slice(2,5)//不针对任意一个序列，谁都可以用 print(a[s],b[s])//用切片专用的符号[]来接收s print(s.start) print(s.stop) print(s.step) 结果 [3, 4, 5] [4, 5, 6] 2 5 None
//sorted()函数，排序 同的类型才可以排序，因为排序其实本质就是比较大小嘛
a = [1,4,3,2,5] b = sorted(a) print(a,b) 结果 [1, 4, 3, 2, 5] [1, 2, 3, 4, 5]//不改变原列表 当遇到一些元素直接无法直接比较大小的序列时就需要加多个参数key people=[ {"name":'djh','age':18}, {'name':'hhh','age':99}, {'name':'xxx','age':22}, ] a = sorted(people,key=lambda x:x['age'])//传入的是一个列表，但是列表的元素之间无法之间比较大小，所以就要传多个参数key，因为参数是序列所以排好序之后返回的还是一 个序列，只是元素之间的顺序变了而已 但是如果参数是字典的话就不一样，元素会变，因为返回的是一个学列，所以只可以将key值返回，value丢弃 print(a) 结果 [{'name': 'djh', 'age': 18}, {'name': 'xxx', 'age': 22}, {'name': 'hhh', 'age': 99}] 参数如果是字典时其实是可以直接排序，但是是用key来排序 people = {"djh":18,"hhh":22,"xxx":33} a = sorted(people) print(a) 结果 ['djh', 'hhh', 'xxx'] 如果需要返回年纪的大小排序---->返回的元素是年龄这个数字 people = {"djh":18,"hhh":22,"xxx":33} a = sorted(people.values()) print(a) 结果 [18, 22, 33] 但如果是需要返回年纪的大小排序---->返回的元素是名字的话就需要特殊的写法了 people = {"djh":18,"hhh":22,"xxx":33} a = sorted(people,key=lambda x:people[x])//其实原理就是传入people就是把全部的key打包成列表传入，然后通过for循环（排序本质是比较大小嘛 自然就for循环咯）迭代 key，然后再在后面传入参数key，用key参数的方法去比较大小，但因为你传入的由key组成的列表嘛，所以比较结束之后输出的肯定还是由key组成的列表呀，只是比较的方法是由自己限定的 print(a) 结果 ['djh', 'hhh', 'xxx'] 如果是连名字年纪的全部都要输出则用zip()函数辅助咯 people = {"djh":18,"hhh":22,"xxx":33} a = sorted(zip(people.values(),people.keys())) print(a) 结果 [(18, 'djh'), (22, 'hhh'), (33, 'xxx')]
