内置函数

'''内置函数'''

# abs()取绝对值
print(abs(-12))

# all()判断可迭代对象是否包含布尔值为假的对象及可迭代对象是否为空(为空则判断True)
print(all([1, 2, '3'])) # 全部为真则为真，有一个为假则为假
print(all([1, 2, '']))
print(all([1, 2, 0]))
print(all([1, 2, None]))
print(all([])) # 如果可迭代对象是空，那么返回True
print(all('120')) # 一个字符串为整体，所以判断为真

# any()判断可迭代对象是否包含布尔值为真的对象及可迭代对象是否为空(为空则判断False)
print(any([0, [], '3'])) # 只要有一个为真，那么判断结果则为真
print(any([])) # 如果可迭代对象是空，那么返回False

# bin()把十进制转成二进制，0b代表是二进制表示
print(bin(5))

# hex()把十进制转成十六进制，0x代表十六进制表示
print(hex(10))

# oct()把十进制转成八进制，0o代表八进制表示
print(oct(10))

# bool()判断布尔值，以下情况为假，其他都为真
print(bool(0))
print(bool(None))
print(bool(''))
print(bool([]))
print(bool(()))
print(bool({}))

# bytes()把字符串转换成字节
print(bytes('你好', encoding='utf-8')) # utf-8保存中文是3个字节
print(bytes('你好', encoding='utf-8').decode('utf-8')) # decode默认解码方式为utf-8，但最好还是要带上解码方式，用什么方式编码，就用什么方式解码
print(bytes('你好', encoding='gbk')) # gbk保存中文是2个字节
print(bytes('你好', encoding='gbk').decode('gbk')) # 用什么方式编码，就用什么方式解码
# print(bytes('你好', encoding='ascii')) # 报错，'ascii' codec can't encode，阿斯克码不能对中文进行编码，所以判断中文和英文的方法可以利用字符串方法中的isascii()方法

# chr()根据阿斯克码表进行转换，数字转换成对应的字符
print(chr(48))

# ord()根据字符转换成对应的阿斯克码(直接是数字0会报错，所以得是字符串类型)
print(ord('0'))

# dir()打印某一个对象下面有哪些方法
print(dir(tuple))

# divmod()算除法，取商得余数
print(divmod(59, 10))

# enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons, start=1)))

for i, element in enumerate(seasons):
   print(i, element)

# eval()把字符串中的数据结构提取出来；把字符串中的表达式进行运算
d1 = {'name':'alex'}
dic_str = str(d1)
print(type(dic_str))
d2 = eval(dic_str)
print(type(d2), d2['name'])

express = '1+2*(3/1-2)-6/2'
print(eval(express))

# hash()可哈希是不可变数据类型，不可哈希是可变数据类型；不管传入参数有多长，哈希值长度都是固定的；不能根据哈希值最后结果反推出字符串是什么；变量不变，哈希值也不变
print(hash('123asd'))
print(hash('123asd你好啊kkssla'))

# help()打印方法的使用详细介绍
print(help(all))

# id()打印对象内存地址
name = 'alex'
print(id(name))

# input()输入

# int()将对象转变成整型数字类型

# isinstance()判断对象是否属于什么类型
print(isinstance(1, int))

# globals()打印全局可使用的变量名和值，以键值对方式展示
print(globals())

# locals()打印当前级别的局部变量名和值，以键值对方式展示
def test():
   n = 1
   print(locals())
test()

# zip()俗称拉链，传入两个序列类型，一一对应的关系将元素组成元组类型，生成迭代器，当两边元素不对等时，以最少的对象一一对应取值；
m = list(zip([1, 2, 3], ('a', 'b', 'c', 'c')))
print(m)
print(type(m[0]))

d1 = {'name':'alex', 'age':18, 'gender':'none'}
print(list(zip(d1.keys(), d1.values())))

# max()函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同类型之间不能进行比较；每个元素间进行比较，是从每个元素的第一个位置依次比较，如果这一个位置分出大小，后面的都不需要比较了，直接得出这两元素的大小
d2 = {'alex':30, 'wupeiqi':28, 'yuanhao':33, 'lhf':40}
print(max(d2.values()))
print(max(d2))
print(max(zip(d2.values(), d2.keys())))

l1 = ['alex1', 'alex2', 'alex30', 'alex4']
print(max(l1))

l2 = [
   (12, 'alex'),
   (100, 'wupeiqi'),
   (71, 'yuanhao'),
   (38, 'lhf'),
]
print(max(l2))

l3 = [
   ([1, 2], 'alex'),
   ([2, 3], 'wupeiqi'),
   ([3, 4], 'yuanhao')
]
print(max(l3))

l3 = [
   ([1, 2], 'alex'),
   ([1, 2], 'wupeiqi'),
   ([1, 2], 'yuanhao')
]
print(max(l3))

people = [
   {'name':'alex', 'age':1000},
   {'name':'mike', 'age':2000},
   {'name':'jack', 'age':3000},
   {'name':'mary', 'age':18},
]
# 通过for循环取出每个字典的value值进行比较
res = []
ret = []
for i in people:
   res.append(i['age'])
   ret.append(i['name'])
print(max(zip(res,ret)))
# 通过使用关键字key取出每个字典指定的value值进行比较，且返回整个字典内容
print(max(people, key=lambda x:x['age']))

# min()与max()刚好相反，取最小，用法一样

# pow()必传两个参数，第三个参数默认为None；前两个参数代表计算几次方，第三个参数代表计算几次方的结果除以该参数取余
print(pow(2, 3)) # 2**3=8
print(pow(2, 3, 3)) # 2**3%3=2

# reversed()反转
l = [1, 2, 3]
print(list(reversed(l)))

# round()四舍六入
print(round(4.5))

# slice()切片，还可定义步长
s = 'hello'
s1 = slice(2, 4)
s2 = slice(0, 4, 2)
print(s[2:4])
print(s[s1])
print(s[s2])

# sorted()排序，默认是从小到大排序，加入reverse关键字可反转变成从大到小排序，key关键字和max()用法一样；排序本质就是在比较大小，不同类型之间不可以比较大小
people = [
   {'name':'alex', 'age':1000},
   {'name':'mike', 'age':2000},
   {'name':'jack', 'age':3000},
   {'name':'mary', 'age':18},
]
print(sorted(people, key=lambda x:x['age'], reverse=True))

d1 = {
   'alex':300,
   'yuanhao':900,
   'lhf':490
}
print(sorted(zip(d1.values(), d1.keys()), reverse=True))

# sum()求和
print(sum(range(5)))

# __import__()与import()函数一样，都是导入模块的功能，但是__import__()函数导入的是字符串，import()函数的工作机制其实是import--->sys--->__import()__