内置函数

abs()
取绝对值

print(abs(-1))

all()
将每个元素做布尔运算，全真为真，有假则假
当all()函数内容为空字符串的时候返回真

print(all([1, 2, "1"]))
print(all([0, "", []]))
print(all(""))

any()
将每个元素做布尔运算，有真则真，全假则假

print(any([1, 0, "", {}]))
print(any([0, [], {}, ""]))

bin()
将十进制数转为2进制

print(bin(3))

bool()
判断布尔值

print(bool(0))

bytes()
将对象以指定编码转化bytes类型

name = "你好"
print(bytes(name, encoding="utf - 8"))
print(bytes(name, encoding="utf - 8").decode("utf - 8"))

chr()
ASCII码对应的字符

print(chr(97))

dir()
查看对象的所有类方法

print(dir(dict))

divmod()
得出商和余数

print(divmod(10, 3))

eval()
1.将字符串中的数据提取出来
2.计算字符串中的表达式

dic_str = "{'name':'YY'}"
d = eval(dic_str)
print(d)
print(d['name'])

express = "1 +2*(2+3) - 5"
print(eval(express))

hash()
可hash的数据类型即不可变数据类型
不可hash的数据类型即可变数据类型
hash运算的特点：1.不论对象的长度，hash运算的返回值长度一定 2.hash运算的结果推不回原对象 3.同一程序内，只要对象不发生变化，hash该对象的值就不会发生变化。

name = "YY"
print(hash(name))
name = "MB"
print(hash(name))

help()
对象的使用方法

print(help(all))

hex()
十进制转十六进制

print(hex(12))

oct()
十进制转八进制

print(oct(12))

isinstance()
判断对象是不是某一类型

print(isinstance(1, int))

globals()
所有全局变量

NAME = "MB"


def test():
    name = "yy"
    print(globals())


test()

locals()
所有当前局部变量

NAME = "MB"


def test():
    name = "yy"
    print(globals())
    print(locals())


test()

zip()
将传入的两个序列一一对应，返回的是一迭代器，可用list()函数转为列表，对应元素转为元组的形式。
zip()函数不论传入的参数哪个较多，都会将多的部分略去。
序列包括字符串、元组、列表。
zip()函数也可以传入多个可迭代序列，同样将它们一一对应，返回一个迭代器

d = zip("hello", (1, 2, 3, 4, 5))
print(list(d))

L = {"name": "YY", "age": 5}
d = zip(L.keys(), L.values())
print(list(d))

l1 =["alex", 22, 33, 44]
l2 =["is", 22, 33, 44]
l3 =["good", 22, 33, 44]
l4 =["guy", 22, 33, 44]
res = zip(l1, l2, l3, l4)
print(list(res))

max()
在比较数字时返回最大的数字，在比较字符串时按照ASCII码表定义的先后顺序返回次序最大的字符。
max()函数要求传入的实参可以迭代，相当于for循环遍历每个元素，相互比较，最终得出最大元素。
在字符串比较时，按位比较，如果在某一位已经分出最大元素则不会再考虑剩余位。
max()函数不能比较不同类型数据。
max()函数可以传入一个函数作为key参数，在有key参数的情况下max()函数

d = max(("age5", "age2", "age4", "age12345"))
print(d)

在字典中比较可以借助zip()函数

L = {"MB": 23, "YY": 5, "Lucky": 3}
res = max(zip(L.values(), L.keys()))
print(res)

传入key参数的情况

people = [
    {"name": "MB", "age": 23},
    {"name": "YY", "age": 5},
    {"name": "Lucky", "age": 4}
]
d = max(people, key=lambda x: x['age'])
print(d)

ord()
返回对应字符的ASCII码
作用与chr()函数相反

print(chr(97))
print(ord('a'))

pow()
传入两个参数时做次方运算，传入三个参数时做完次方运算后取余。

print(pow(3, 3))
print(pow(3, 3, 26))

reverse()
反转顺序,返回一个迭代器。

L = [1, 2, 3, 4, 5]
print(list(reversed(L)))

round()
四舍五入

print(round(3.5))

slice()
切片，作用与引索相似。可以设置步长参数。

l = "hello"
S1 = slice(2, 5)
S2 = slice(2, 5, 2)
S3 = l[2:5]
print(l[S1], l[S2], S3)

sorted()
排序
不同类型数据不能一起排序
同max()函数，可以传入key参数，表示按照key参数的返回值排序。

l = [3, 2, 1, 5, 7]
print(sorted(l))

传入key参数的情况

people = [
    {"name": "MB", "age": 23},
    {"name": "YY", "age": 5},
    {"name": "Lucky", "age": 4}
]
print(sorted(people, key=lambda x: x["age"]))

也可以借助zip()函数

age_dict = {"MBage": 23, "YYage": 5, "Luckyage": 4}
print(sorted(zip(age_dict.values(), age_dict.keys())))

type
得出数据类型

l = [1, 2, 3, 4]
print(type(l))

vars()
不传入参数时相当于local()函数，即显示当前作用域的所有局部变量。
传入参数时作用为以字典的形式显示对象的所有方法。

def test():
    name = "MB"
    print(vars())


test()

print(vars(int))

import语句与__impor__()函数
import()函数可以导入一个模块文件（一个.py文件就是一个模块） 形式为 import(模块名)。
_ import_()函数可以将模块名以字符串形式传入。
在底层执行时import()函数调用的也是_ import_()函数。

#已有test.py文件 里面的代码为：def say_hi():
#								print("hi")
#在另一个.py文件中调用say_hi()
import test
test.say_hi()

#已有test.py文件 里面的代码为：def say_hi():
#								print("hi")
#在另一个.py文件中调用say_hi()
m = __import__("test")
m.say_hi()