Python内置函数

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")

这种可以用于将读取的字符串作为模块导入