python的内置函数：
abs
print(abs(-1)) # 取绝对值
print(abs(0)) # 取绝对值
all
all内部只有一个元素，内部是一个可迭代的对象
元组 列表形式的
print(all([])) # 里面是可迭代对象 空返回true
print(all((1,''))) # 里面是可迭代对象 依次取内部的x进行bool运算，只有所有的全部为True 这里字符串为空，返回false
print(all((1,[]))) # 里面是可迭代对象 依次取内部的 空是false
print(all((1,2,' ',None))) #字符串的空格是True None是false
生成器方式：
(for i in range(100)) # 这是一个生成器对象，
print(all(i for i in range(1,3))) # 内部是生成器，容易出错的是加上括号
any
any是有任何一个的bool值是True，返回值是True，空返回的是false
print(any([]))
print(any([None,0,'',{},1]))
bin
print(bin(10)) # 十进制转换成二进制
bool
空的情况：0、空字符串、空字典、空列表、None、
print(bool(0))
print(bool(''))
print(bool(None))
print(bool([]))
返回值都是false
bytes
print(bytes('hello',encoding='utf-8'))
b'hello'
callable
查看能否被调用
# 可以被调用
def test():
pass
print(callable(test))
能被调用，返回True
chr
print(chr(65))
ord
print(ord('A'))
complex
x = complex(1-2j)
print(x.real) # 复数的实部
print(x.imag) # 复数的虚部
不可变字典 不能增删改查
x = frozenset({1,2,3,4})
print(x)
dir
查看sum可以调用的方法，返回值是列表的形式
print(dir(sum))
print(divmod(10,3)) # 整除和取余数 用于分页，第一个是整除，第二个是取余数
enumerate
# d = enumerate(['a','b','c'])
# d.__iter__()
# d.__next__() # 是迭代器
# for i in enumerate(['a','b','c']): #
# print(i)
hash
s1修改后，hash的值会改变，hash有不同的方法，MD5，SHA
s1 = "123"
print(hash(s1))
s1 = "456"
print(hash(s1))
``
### id ###
```python
print(id("123")) # 身份
x = 'a'
y= 'a'
print(id(x))
print(id(y))
print(x is y)
结果是一样的
hex
十进制转换成16进制
max
max内部是可迭代的对象iternable
slaries ={
"a":10000000,
"b":2000000,
"c":300000,
"d":40000
}
def get_value(k):
return slaries[k] # 针对的是字典的key 返回的是相应key的value
print(get_value("a"))
print(max(slaries,key=get_value)) # 内部是可迭代对象,key的值是一个函数
print(max(slaries)) #这样是返回的的key的字符串的比较，先比较第一个ascii，第一个相同，比较后面的
匿名函数lambda
f = lambda k :slaries[k] # 这一行就是一个返回值 lambda k 就相当于是def+函数名 slaries[k]就是return
print(f("a"))
取出value最大的key
slaries ={
"a":10000000,
"b":2000000,
"c":300000,
"d":40000
}
print((max(slaries,key=lambda k:slaries[k])))
min
取出最小的value
print((min(slaries,key=lambda k:slaries[k])))
zip
形象的解释成拉链，是一个迭代器
l1 = [1,2,3]
s = 'hello'
for i in zip(l1,s):
print(i)
结果：
(1, 'h')
(2, 'e')
(3, 'l')
返回的是数组
取出所有的key并对用所有的value
z = zip(slaries.keys(),slaries.values())
print(max(z)) # 内部是迭代器
sorted 升序
l = [1.2,5,6,8,2,5,]
print(sorted(l,)) # 把列表升序排列
print(sorted(l,reverse=True)) # reverse = True 代表降序排列
slaries ={
"a":10000000,
"b":2000000,
"c":300000,
"d":40000
}
# print(sorted(slaries)) #默认是按照字典的key排序
print(sorted(slaries,key=lambda k:slaries[k])) # 工资按照升序排列
print(sorted(slaries,reverse=True,key=lambda k:slaries[k])) # 工资按照降序排列
print(sorted(slaries,key=lambda k:slaries[k],reverse=True)) # 工资按照降序排列
map 映射
map(func, *iterables) --> map object
map第一个是函数，第二个是可迭代对象
l = [1,2,3,46,7]
m=map(lambda item:item**2,l) # 函数 可迭代对象
# for i in m:
# print(i)
print(list(m)) # 因为m是迭代器，所以转换成列表
reduce合并
from functools import reduce Python3中需要导入
from functools import reduce
l=list(range(100))
# print(l)
m = reduce(lambda x,y:x+y,l)
print(m)
结果：
4950
m=reduce(lambda x,y:x+y,l,100) # 设置初始值
思路理解：
先是初始值给x,从列表中获取第一个值0--y，x+y=100,
100给x 二 1--y,x+y = 101,
默认的时候第一个值是0
filter过滤
name_l=[
{'name':'aaa','age':18},
{'name':'bbb','age':20},
{'name':'ccc','age':5000},
{'name':'dddd','age':100000},
]
f = filter(lambda d:d['age'] > 100,name_l) # 函数lambda中的是进行的布尔运算
print(list(f))
结果：
[{'name': 'ccc', 'age': 5000}, {'name': 'dddd', 'age': 100000}]
oct
把十进制转换成8进制
slice切片
# s=slice(2,5,2) # 开始，结尾 步长
# print(l[s])
# l=[1,2,3,4,5]
# print(l[2:4]) # 顾头不顾尾
vars
prints(vars()) # 此时等同于local()
打印局部空间变量
{'name': 'main', 'doc': None, 'package': None, 'loader': <_frozen_importlib_external.SourceFileLoader object at 0x00000000021D95C0>, 'spec': None, 'annotations': {}, 'builtins': <module 'builtins' (built-in)>, 'file': 'D:/Python_fullstack_s4/day25/test.py', 'cached': None, 'slaries': {'a': 10000000, 'b': 2000000, 'c': 300000, 'd': 40000}}
通过字符串导入
__import__("time")
这种可以用于将读取的字符串作为模块导入