Python之路Python内置函数、zip()、max()、min()
一、python内置函数
abs()
求绝对值
例子
print(abs（-2）)
all()
把序列中每一个元素做布尔运算，如果全部都是true，就返回true,
但是如果是空字符串、空列表也返回true
例子
print(all([1,2,‘1‘,‘‘]))
输出结果
False
例子2
print(all(‘‘))
输出结果
True
any（）
把序列中每一个元素做布尔运算，如果有一个为true就返回true,
但是有两个false还是false
例子
print(any([0,‘‘])) print(any([0,‘‘,1]))
输出结果
False True
bin()
把十进制转换为二进制
例子
print(bin(3))
输出结果
0b11
分析：其中“0b"代表二进制
bool()
判断布尔类型的，返回True或者False
bytes()
以一个字节的形式输出数据，这里的bytes是不可变数据类型
如果是整数，就输出长度为该整数长度的字节组
例子
print(bytes(0)) print(bytes(2)) print(bytes(5))
输出结果
b‘‘b‘\x00\x00‘b‘\x00\x00\x00\x00\x00‘
如果是字符串，则必须制定编码方式进行编码
例子
name=‘你好‘ print(bytes(name,encoding=‘utf-8‘)) print(bytes(name,encoding=‘utf-8‘).decode(‘utf-8‘))
输出结果
b‘\xe4\xbd\xa0\xe5\xa5\xbd‘<br>你好
分析：这里的第一行输出就是以utf-8的方式对“你好”进行编码，是二进制模式下的十六进制编码，这里是十六进制的形式，utf-8中三个字节代表一个汉字，所以前3个字节代表的是“你”
第二行输出的是对十六进制的字节进行解码，用“utf-8”的形式重新解码，所以这里被还原成“你好”
例子
name=‘你好‘ print(bytes(name,encoding=‘gbk‘)) print(bytes(name,encoding=‘gbk‘).decode(‘gbk‘))
输出结果
b‘\xc4\xe3\xba\xc3‘ 你好
分析：第一行输出是用"gbk"方式对“你好”进行编码，由于gbk是2个字符代表一个汉字，所以这里可以看到，前2个代表一个汉字，后2个代表一个汉字，
同样的这里也可以被解码重新还原为原字符串
bytearray()
以一个字节组的形式输出数据
用法与bytes()类似，但这里这个数组里的元素是可变的，bytes是不可变数据类型，而bytearray像名称一样可使用append等方法；
chr()
参数是（0~255）整数，返回的其实是ASCII码对应的字符
dict()
创建字典的函数
例子
print(dict( a = "1",b = "2" ))
输出结果
{‘a‘: ‘1‘, ‘b‘: ‘2‘}
分析：这种创建字典的方式key只能是字符串，不能是数字、布尔值等，创建出的字典key是写入等式的前面，等式后面写的是value
例子2
print(dict([("a",1),(2,3)]))
输出结果
{‘a‘: 1, 2: 3}
分析：这里是用可迭代对象创造字典，即通过二元组列表创建
dir()
打印某一个对象下面都有哪些方法
例子
print(dir(str))
输出结果
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘capitalize‘, ‘casefold‘, ‘center‘, ‘count‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘, ‘find‘, ‘format‘, ‘format_map‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdecimal‘, ‘isdigit‘, ‘isidentifier‘, ‘islower‘, ‘isnumeric‘, ‘isprintable‘, ‘isspace‘, ‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘maketrans‘, ‘partition‘, ‘replace‘, ‘rfind‘, ‘rindex‘, ‘rjust‘, ‘rpartition‘, ‘rsplit‘, ‘rstrip‘, ‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]
divmod()
实现a除以b，然后返回商与余数的元组。如果两个参数a,b都是整数，那么会采用整数除法，结果相当于（a//b, a % b)。如果a或b是浮点数，相当于（math.floor(a/b), a%b)。
例子
print(divmod(10,3))
输出结果
(3, 1)
enumerate()
将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
语法
enumerate(seq, [start=0])
seq--一个序列或者可迭代对象，start 下标的开始位置
例子
li = ["nicholas","jack","pony"]
for i in enumerate(li,1):
print(i)
输出结果
(1, ‘nicholas‘) (2, ‘jack‘) (3, ‘pony‘)
eval()
将字符串str当成有效的表达式来求值并返回计算结果。
例子
#字符串转换成字典
print(eval(‘{"nick":1,"jack":2}‘))
输出结果
{‘nick‘: 1, ‘jack‘: 2}
计算字符串里的表达式的值
例子
x,y = 1,2 print(eval(‘x + y‘))
输出结果
3
hash()
用来做哈希运算的，只要可hash就是不可变数据类型
不可hash的就是可变数据类型
哈希是一种算法，把文件内容进行一个运算，最终得出一个值
得出的结果长度是固定的，不能根据结果反推原来的内容
本函数返回对象的哈希值。返回的哈希值是使用一个整数表示，通常使用软件校验。
例子
name = "nick" print(hash(name)) name = "nicholas" print(hash(name))
?
输出结果
5166927391536352230
分析：对name进行哈希运算返回一个值，如果中途被修改，哈希值也会变化
help()
查看帮助，查看某个函数怎么用
例子
print(help(dir))
查看dir的用法
hex()、oct()、bin()
bin()将十进制转换为二进制
hex()将十进制转换为十六进制
oct()将十进制转换为八进制
isinstance()
函数来判断一个对象是否是一个已知的类型，类似 type()。
例子
print(isinstance(1,int))
print(isinstance("a",str))
输出
True True
分析：判断1是不是int类型，判断“a”是不是字符串类型
locals()、globals()
这两个函数主要提供，基于字典的访问局部和全局变量的方式。
globals打印全局变量，还有一些系统提供的全局变量
locals打印局部变量
例子
{‘b‘: ‘nick ‘}
----------------
{‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x002EA550>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘D:/06python/exercise/test2.py‘, ‘__cached__‘: None, ‘a‘: 2, ‘test‘: <function test at 0x02116CD8>}
分析：这里print(locals())打印的是{‘b‘: ‘nick ‘}，获取的是局部变量，
print(globals())在输出的最后获取了‘a‘: 2，其他都是系统提供的全局变量
ord()
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值
pow（）
pow(x,y)方法返回 xy（x的y次方） 的值。
pow(x,y,z)方法是x的y次方得到一个值，之后再用这个值对z进行取余
例子
print(pow(2,5,3)) print(pow(2,5))
输出结果
232
reversed()
reversed函数返回一个反转的迭代器。即取反，取反的对象可以是列表、字符串、元组，或者range
例子
print(reversed([1,2,3,4])) print(list(reversed([1,2,3,4])))
输出结果
<list_reverseiterator object at 0x002EA570>[4, 3, 2, 1]
分析：第一行输出，直接打印reversed输出的是一个反转的迭代器，要用list方法可以进行显示列表。
round()
返回浮点数x的四舍五入值。
set()
创建一个集合
slice()
切片对象，主要用在切片操作函数里的参数传递。
语法
slice(start, stop[, step])
例子
l = "hello world !" s1 = slice(0,4) print(l[s1])
输出结果
hell
例子2
l = "aeiou world !" s2 = slice(0,4,2) print(l[s2])
输出结果
1
分析：这里加了步长。
sorted()
对所有可迭代的对象进行排序操作。内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
list 的 sort 方法返回的是对已经存在的列表进行操作
sorted 方法不能针对不同类型进行排序
例子
l = [2,1,3,5,8] print(sorted(l))
输出结果
[1, 2, 3, 5, 8]
sorted()语法
sorted(iterable, key=None, reverse=False)
- iterable -- 可迭代对象。key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中
- reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
?
例子
people=[ {‘name‘:‘nicholas‘,‘age‘:18}, {‘name‘:‘jack‘,‘age‘:53}, {‘name‘:‘pony‘,‘age‘:46}, {‘name‘:‘richard‘,‘age‘:44}, ] print(sorted(people,key = lambda dic:dic["age"]))
输出结果
[{‘name‘: ‘nicholas‘, ‘age‘: 18}, {‘name‘: ‘richard‘, ‘age‘: 44}, {‘name‘: ‘pony‘, ‘age‘: 46}, {‘name‘: ‘jack‘, ‘age‘: 53}]
str()
将任意类型转换为字符串
sum()
对系列进行求和计算。
语法
sum(iterable[, start])
例子
li = [1,2,3,4,5] print(sum(li)) print(sum(li,2))
输出结果
15 17
分析：第二行输出是先对列表求和，再加上参数2再次求和。
type()
查看某一对象的数据类型
例子
msg = "123"
if type(msg) is str :
msg = int(msg)
res = msg + 5
print(res)
vars()
对象object的属性和属性值的字典对象。
查看对象的属性和值，如果没有参数和locals功能一样。
如果有就显示该对象的所有方法名
print(vars(int))
二、zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或者字典。
zip()可以传2个参数，只要是序列就可以(列表、元组、字符串)
例子
print(zip(("a","b","c"),(1,2,3)))
print(list(zip(("a","b","c"),(1,2,3))))
print(list(zip(("a","b","c"),(1,2,3,4))))
print(list(zip(("a","b","c","d"),(1,2,3))))
输出结果
<zip object at 0x0216EB98> [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)] [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)] [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]
分析：第一行输出的是zip的对象，要转换为列表用list的方法
zip的左右两个参数序列是一一对应的关系，如果有多的自动忽略
例子2
p={‘name‘:‘nicholas‘,‘age‘:18,‘gender‘:‘man‘}
print(list(zip(p.keys(),p.values())))
输出结果
[(‘name‘, ‘nicholas‘), (‘age‘, 18), (‘gender‘, ‘man‘)]
分析：这样就可以把字典中的元素提取出来
例子
print(dict(zip(("a","b","c"),(1,2,3))))
输出结果
{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
分析：这里可以直接将zip对象转为字典。
三、max（） 、min()
max()求最大的值
例子
dic = {"age1":18,"age4":25,"age2":19,"age3":28}
print(max(dic))
print(max(dic.values()))
print(max(zip(dic.values(),dic.keys())))
输出结果
age4 28 (28, ‘age3‘)
分析：print(max(dic))语句默认比较的是字典的key，进行字符串的比较，一个字符一个字符的比较，根据字符的ASCII码进行比较
第二行输出print(max(dic.values()))，比较的是字典的value，直接输出最大的value
第三行输出是首先将字典用zip方法将字典的value和key组成一个一一对应的元组，然后直接比较这个元组的大小
具体
dic = {"age1":18,"age4":25,"age2":19,"age3":28}
v = zip(dic.values(),dic.keys())
#这里也是一个可迭代对象
for i in v:
print(i)
输出结果
(18, ‘age1‘) (25, ‘age4‘) (19, ‘age2‘) (28, ‘age3‘)
这里通过for循环可以看出zip(dic.values(),dic.keys())是一个元组
例子2
l = [(5,"a"),(3,"b"),(2,"c")] print(max(l))
输出结果
(5, ‘a‘)
分析：这里是从第一个值进行比较，5、3、2进行比较，如果有结果，后面的就不用比较了
例子3
l = ["a18","b21","c5"] print(max(l))
输出结果
分析：这里也是一个字符一个字符的比较。
max()的高级用法
max(iterable,key = func)
iterable--可迭代对象，func--对对象的元素处理逻辑
例子
people=[
{‘name‘:‘pony‘,‘age‘:1000},
{‘name‘:‘jack‘,‘age‘:10000},
{‘name‘:‘richard‘,‘age‘:9000},
{‘name‘:‘nick‘,‘age‘:18},
]
print(max(people,key = lambda x:x["age"]))
输出结果
{‘name‘: ‘jack‘, ‘age‘: 10000}
分析：这里是对列表中每个元素进行for循环，即字典进行取出“age”对应的value进行比较，同时输出value最大值的元素，与map函数进行for循环类似。
x["age"]是对列表的每个元素进行索引，而非对列表进行索引，因为这个max()函数对要处理的可迭代对象进行了类似for循环处理。
原文地址：https://www.cnblogs.com/insane-Mr-Li/p/9818607.html