Python 常用的内置函数一、较简单的内置函数 abs()：求绝对值 all()：在一个可迭代对象中，逐个取出来所有值

一、较简单的内置函数

abs()：求绝对值
```
print(abs(-1))  # 1
```

all()：在一个可迭代对象中，逐个取出来所有值，如果所有取出来的值(x)的布尔运算结果(bool(x))都为True，则返回True

print(all([1, 'aaa', '1']))  # True
print(all([1, 'aaa', '']))   # False 列表的最后一个元素是空字符串
print(all([1, 'aaa', ' ']))  # True 列表的最后一个元素是空格字符
print(all([]))               # True 空列表默认为True(空迭代对象默认为True)

any()：在一个可迭代对象中，逐个取出来所有值，如果任意有一个取出来的值(y)的布尔运算结果(bool(y))为True，则返回True
```
print(any([0, None, 1]))  # True
print(any([]))            # False 空列表默认为False(空迭代对象默认为False)
```
bin()：十进制转二进制
```
print(bin(1))  # 0b1
```
oct()：十进制转八进制
```
print(oct(1))  # 0o1
```
hex()：十进制转十六进制
```
print(hex(1))  # 0x1
```

bool()：布尔运算

print(bool(''))    # False
print(bool(' '))   # True
print(bool(True))  # True

callable()：判断某一个对象是否可以通过后面加括号的方式被调用

def func():
    pass

print(callable(func))  # True


class Foo:
    pass

print(callable(Foo))  # True


x = 10
print(callable(x))  # False


l = [1, 2]
print(callable(l))  # False

chr()：Ascall码转字符
```
print(chr(65))  # A
```
ord()：字符转Ascall码
```
print(ord('@'))  # 64
```

frozenset()：不可变集合

# 不可变集合就没有增删改方法
s = frozenset('hello world')
print(s)  # frozenset({'l', 'h', 'w', 'r', ' ', 'd', 'o', 'e'})

hash()：只能传入不可变数据类型，返回一个哈希值
```
print(hash('hello'))
```

round()：四舍五入

# 第二个参数指定为保留的小数位数，不写默认为0

print(round(0.4))  # 0

# 注意：如果小数末尾正好是5，则使用round函数将会遵循向偶数靠近法则，而不是正常理解的“五入”。
print(round(0.5))       # 0
print(round(1.5))       # 2
print(round(2.555, 2))  # 2.56
print(round(2.545, 2))  # 2.54

pow()：A的B次方对C取余

# 10 ** 2 % 3

print(pow(10, 2, 3))  # 1

print(pow(2, 3))  # 8  # 没有第三个参数则就是算次方

二、需要掌握的内置函数

divmod()：A除B商C余D

# divmod(A, B) --结果--> (C, D)

print(divmod(100, 3))  # (33, 1) 结果是一个元组

dir()

class Foo:
    pass


obj = Foo()
obj.自己加的属性 = 1111

print(dir(obj))  # 查看obj都能“.”(点)哪些东西

# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '自己加的属性']

enumerate()

for i in enumerate(['a','b','c']):
    print(i)  # 结果是一个个由索引和对应值组成的元组
    
# (0, 'a')
# (1, 'b')
# (2, 'c')

# 利用解压赋值取
for i, v in enumerate(['a', 'b', 'c']):
    print(i, v)

# 0 a
# 1 b
# 2 c

eval()：执行字符串中的表达式

res = eval('1+1')
print(res, type(res))  # 2 <class 'int'>

res = eval('{"a":1}')
print(res, type(res))  # {'a': 1} <class 'dict'>

isinstance()：判断一个对象是否为一个类的实例

class Foo:
    pass


obj = Foo()
print(isinstance(obj, Foo))  # True

print(isinstance([], list))  # True
# 类型判断推荐使用isinstance(像上面这样)，而不推荐使用下面这种：
print(type([]) is list)  # True  # 不推荐使用

zip()：拉链函数，将两个可迭代对象的逐个元素两两配对拼到一起，返回一个迭代器。

l1 = ['a', 'b', 'c', 'd', 'e']
l2 = ['aaa', 'bbb', 'ccc', 'ddd', 123]

res = zip(l1, l2)
print(list(res))  # [('a', 'aaa'), ('b', 'bbb'), ('c', 'ccc'), ('d', 'ddd'), ('e', 123)]

# 能凑几对凑几对

l1 = ['a', 'b', 'c', 'd', 'e']
l2 = ['aaa', 'bbb', 'ccc']

res = zip(l1, l2)
print(list(res))  # [('a', 'aaa'), ('b', 'bbb'), ('c', 'ccc')]

_ _import_ _：通过字符串格式的模块名来导入模块
```
time = __import__('time')
time.sleep(3)
```