1、abs()：取绝对值
num01 = -1
print(abs(num01))
运行结果：
1
2、all()：将参数中的元素进行布尔运算
参数必须为可迭代对象，当参数中的一个元素为False时结果就是False，当参数为空的时候结果为Ture
为False的类型：空的数据类型，0，None
list01 = [1, 2, 3, 0]
print(all(list01))
list02 = []
print(all(list02))
dict01 = {"a":None}
print(all(dict01))
dict02 = {None:"a"}
print(all(dict02))
运行结果：
False
True
True
False
3、any()：将参数中的元素进行布尔运算（和all相反）
当参数中的一个元素为True时结果就是True
list01 = [1, 2, 3, 0]
print(any(list01))
list02 = []
print(any(list02))
dict01 = {"a":None}
print(any(dict01))
dict02 = {None:"a"}
print(any(dict02))
运行结果：
True
False
True
False
4、bin()：将十进制转换为二进制
num01 = 3
print(bin(num01))
运行结果：
0b11
5、bytes()：将字符串转化为字节
在将字符串转换为字节的时候需要指定编码
使用bytes()将字符串转换为字节后可在网络上进行传输
str01 = "你好"
print(bytes(str01, encoding="utf8"))
运行结果：
b'\xe4\xbd\xa0\xe5\xa5\xbd'
解码方法
s_utf8 = bytes(str01, encoding="utf8")
print(s_utf8.decode("utf-8"))
运行结果：
你好
6、divmod()：将两个整数进行整除，输出的结果是商和余数
num01 = 10
num02 = 3
print(divmod(num01, num02))
print("10除3的商数是:", divmod(num01, num02)[0])
print("10除3的余数是:", divmod(num01, num02)[1])
运行结果：
(3, 1)
10除3的商数是: 3
10除3的余数是: 1
7、eval()：将字符串中的数据类型提取出来和将字符串中的数据运算得出结果
str01 = "[0, 1, 2]"
print(eval(str01))
print(type(eval(str01)))
str02 = "{'a':1, 'b':2}"
print(eval(str02))
print(type(eval(str02)))
str03 = "10 + 2"
print(eval(str03))
运行结果：
[0, 1, 2]
{'a': 1, 'b': 2}
2
8、hash()：将参数进行hash运算
在同一个程序中两个相同的值进行hash运算的结果相同
使用hash()可验证代码是否在传输的过程中被进行篡改
str01 = "进行hash运算"
str02 = "进行hash运算"
print(hash(str01))
print(hash(str02))
运行结果：
2031805881
2031805881
9、hex()：将十进制转换为十六进制
print(hex(10))
运行结果：
0xa
10、oct()：将十进制转换为八进制
print(oct(10))
运行结果：
0o12
11、locals()：输出局部变量
最后的输出结果是一个字典类型，key为变量名，value为值
def test():
name = "xm"
print(locals())
test()
运行结果：
{'name': 'xm'}
12、globals()：输出全局变量
13、zip()：将两个参数(序列)一一对应后输出
最后输出的结果是一个可迭代类型，可将其转换为list进行输出
当两个序列的个数不同的时候按照数量小的进行对应
print(list(zip([1,2,3], ("a","b","c"))))
print(list(zip(["a","b","c"],(1,2,3,4,5))))
print(list(zip(["a","b","c","d","e"],(1,2,3))))
运行结果：
[(1, 'a'), (2, 'b'), (3, 'c')]
[('a', 1), ('b', 2), ('c', 3)]
[('a', 1), ('b', 2), ('c', 3)]
14、max()：将可迭代参数中的最大值输出
max()函数是将参数中的元素进行遍历进行一对一的比较
list01 = [1,2,3,4]
print(max(list01))
\# 取出字典中age的最大值
dict01 = {"age1":18,"age2":20,"age3":10}
print(max(zip(dict01.values(),dict01.keys())))
\# 列表套字典的情况下取出age最大的name和age
list02 = [
{"name":"xm", "age":18},
{"name":"xh", "age":20},
{"name":"xb", "age":10}
]
print(max(list02, key=lambda dic:dic["age"]))
运行结果：
4
(20, 'age2')
{'name': 'xh', 'age': 20}
15、min()：将可迭代参数中的最小值输出
用法和max()相同
16、sum()：将可迭代参数中的元素进行累加运算
用法和max()相同
17、pow()：有两个参数的时候将两个参数进行幂运算；有三个参数的时候将前两个参数进行幂运算，将第三个参数进行其余运算
print(pow(2, 3))
print(pow(2, 3, 3))
运行结果：
8
2
18、reversed()：将可跌倒参数进行反转
最后输出的结果是一个可迭代类型，可转换为list进行输出
list01 = [2, 3, 4, 1]
print(list(reversed(list01)))
运行结果：
[1, 4, 3, 2]
19、round()：将一个浮点数进行四舍五入
num01 = 10.6
print(round(num01))
运行结果：
11
20、sorted()：进行排序
默认从小到大排序
list01 = [2, 3, 4, 1]
print(sorted(list01))
\# 对字典按照age进行排序
dict01 = {"age2":18,"age1":20,"age3":10}
print(sorted(zip(dict01.values(), dict01.keys())))
\# 对列表中套的字典中的age进行排序
list02 = [
{"name":"xm", "age":18},
{"name":"xh", "age":20},
{"name":"xb", "age":10}
]
print(sorted(list02, key= lambda dic:dic["age"]))
运行结果：
[1, 2, 3, 4]
[(10, 'age3'), (18, 'age2'), (20, 'age1')]
[{'name': 'xb', 'age': 10}, {'name': 'xm', 'age': 18}, {'name': 'xh', 'age': 20}]
从大到小进行排序
list01 = [2, 3, 4, 1]
print(sorted(list01, reverse=True))
\# 对字典按照age进行排序
dict01 = {"age2":18,"age1":20,"age3":10}
print(sorted(zip(dict01.values(), dict01.keys()), reverse=True))
\# 对列表中套的字典中的age进行排序
list02 = [
{"name":"xm", "age":18},
{"name":"xh", "age":20},
{"name":"xb", "age":10}
]
print(sorted(list02, key= lambda dic:dic["age"], reverse=True))
运行结果：
[4, 3, 2, 1]
[(20, 'age1'), (18, 'age2'), (10, 'age3')]
[{'name': 'xh', 'age': 20}, {'name': 'xm', 'age': 18}, {'name': 'xb', 'age': 10}]
21、import()：当模块是一个字符串的时候可是有该函数进行导入模块
m = "test"
__import__(m)