# 内置函数：python给咱们提供了一些他认为你会经常用到的函数。68种。
'''
print() input() len() list() str() max()min() type()
id() dict() next() range() int() dir() set() isinstance()
bool() open() globals() locals() hash() iter() enumrate()tuple()
'''
# 作用域相关
# *** locals ：函数会以字典的类型返回当前位置的全部局部变量。
# *** globals：函数以字典的类型返回全部全局变量。
# 1.2其他相关
# 1.2.1 字符串类型代码的执行 eval，exec，complie 慎用 **
# eval 执行字符串类型的代码，并返回最终结果。
s1 = '1 + 2 +3'
n = 55
s3 = "{'name': 'alex'}"
num = input('>>>')
# print(s1)
print(eval（s1))
print(eval（'n + 16'))
ret = eval（s3)
print(ret,type(ret))
s4 = '''
for i in range(1,5):
print(i)
'''
print(s4)# exec 执行字符串类型的代码流
# exec(s4)
# 1.2.2 输入输出相关 input，print ***
# input:函数接受一个标准输入数据，返回为 string 类型。
# print:打印输出。
print(1,2,3,sep='|') # 设置打印的分隔符
print(1,2,3,end=' ') # 设置结束时的格式
f = open('log','w',encoding='utf-8')
print('写入文件',file=f)# 1.2.3内存相关 hash id ***
# hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
# id:用于获取对象的内存地址。
print(hash('fsdfdsa'))
print(hash('alex'))
print(hash('太白金星'))
print(hash(100))
print(hash(10000))# 1.2.3文件操作相关
#
# open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。 ***
# 1.2.4模块相关__import__ *
# __import__：函数用于动态加载类和函数 。
# 1.2.5帮助
# help：函数用于查看函数或模块用途的详细说明。 ***
# print(help(str))
# 1.2.6调用相关
# callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；
# 但如果返回False，调用对象ojbect绝对不会成功。 ***
def func():
pass
func1 = 77
print(callable(func)) # True
print(callable(func1)) # False# 1.2.7查看内置属性 **
# dir：函数不带参数时，返回当前范围内的变量、
# 方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
# 如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，
# 该方法将最大限度地收集参数信息。
# 1.3 迭代器生成器相关
# range：函数可创建一个整数对象，一般用在 for 循环中。 ***
# next：内部实际使用了__next__方法，返回迭代器的下一个项目。 **
# iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。**
# 1.4.1数字相关（14）
# 数据类型（4）：
#
# bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。 **
#
# int：函数用于将一个字符串或数字转换为整型。 **
print(int('123'))
print(int(3.14)) # 取整 3
print(int(3.94)) # 取整 3
# 二进制转化成十进制
print(int('0100',base=2)) # 4# float：函数用于将整数和字符串转换成浮点数。 **
print(float('3.14'))
print(float(10)) # 10.0# complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。*
# 如果第一个参数为字符串，则不需要指定第二个参数。。
# 3 + 4j
# 进制转换（3）： **
# bin：将十进制转换成二进制并返回。
# oct：将十进制转化成八进制字符串并返回。
# hex：将十进制转化成十六进制字符串并返回。
# 数学运算（7）：
#
# abs：函数返回数字的绝对值。 **
print(abs(-5))# divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。 ***
print(divmod(100,9))# round：保留浮点数的小数位数，默认保留整数。 **
print(round(3.14))
print(round(3.1415926, 3))# pow：求x**y次幂。（三个参数为x**y的结果对z取余） **
print(pow(3,4))
print(pow(3,4,6))# sum：对可迭代对象进行求和计算（可设置初始值）。 ***
l1 = [i for i in range(20)]
print(sum(l1))
print(sum(l1,10))# min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。 ***
l1 = [3, 2, 7, 9, 10]
print(min(l1))
l1 = [3, 2, 7, 9, -10, -1]
print(min(l1,key=abs))
dic = {'a': 3 ,'b': 2,'c': 1}
def func(x):
# x = a # 第一次
# x = b # 第二次
# x = c # 第二次
return dic[x]
# dic['a'] 3
# dic['b'] 2
# dic['c'] 1
print(min(dic)) # 默认比较字典的key 将最小的key返回
print(min(dic,key=func)) # 将dic中的每个键传入函数中，以函数的返回值比较最小。
print(dic[min(dic,key=func)]) # 将dic中的每个键传入函数中，以函数的返回值比较最小。
print(min(dic,key=lambda x: dic[x])) # 将dic中的每个键传入函数中，以函数的返回值比较最小。
print(dic[min(dic,key=func)])
l1 = [('a', 3), ('b', 2), ('c', 1)]
# print(min(l1))
print(min(l1,key=lambda x: x[1]))# max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。 ***
# l1 = [('c', 3), ('b', 2), ('a', 1)] # 按照数字返回最大的元组
# dic = {'c': 3, 'b': 2, 'a': 1} # 按照value 返回最大的值
# list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。 **
# print(list({1,5,6,8}))
# print(list({'a': 1, 'b': 2}))
# tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。 **
# reversed：将一个序列翻转，并返回此翻转序列的迭代器。
l1 = [3, 6, 1, 9]
l1.reverse()
print(l1)
l1 = [3, 6, 1, 9]
s1 = '太白金星'
# iter1 = reversed(l1)
iter2 = reversed(s1)
# print(iter1)
for i in iter2:
print(i)# slice *
li = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
l1 = ['d', 'e', 'f', 'g']
sli_obj = slice(3)
print(li[sli_obj])
print(l1[sli_obj])# format:与具体数据相关，用于计算各种小数，精算等。 *
print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))# str ***
# bytes ***
s1 = 'alex'
# 编解码的第一种方式：
b1 = s1.encode('utf-8')
s2 = b1.decode('utf-8')
print(b1, s2)
# 编解码的第二种方式：
s1 = 'alex'
b1 = bytes(s1,encoding='utf-8') # 编码 unicode ---> utf-8
s3 = str(b1,encoding='utf-8') # 解码：utf-8 ----> unicode
print(b1)
print(s3)# bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。 *
# memoryview *
# ord 输入字符找该字符编码的位置 unicode *
print(ord('a'))
print(ord('中'))# chr 输入位置数字找出其对应的字符 *
print(chr(97))
print(chr(20013))# 是ascii码中的返回该值，不是就返回/u... *
print(ascii('a'))
print(ascii('中'))# repr:返回一个对象的string形式（原形毕露）。
s1 = '太白'
print(s1)
print(repr(s1))
msg = '我叫%s' %('太白')
msg = '我叫%r' %('太白')
print(msg)# dict：创建一个字典。 **
#
# set：创建一个集合。 **
#
# frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 **
#
# 相关内置函数（8）
#
# len:返回一个对象中元素的个数。 ***
# all：可迭代对象中，全都是True才是True **
# any：可迭代对象中，有一个True 就是True **
l1 = [1, 2, 'alex', [1,2,3]]
l2 = [1, '', [], {}]
print(all(l1))
print(any(l1))# min max 可以加key
# sorted：对所有可迭代的对象进行排序操作。 ***
l1 = [1, 6, 5, 3, 10]
l2 = sorted(l1)
print(l2)
l1 = [('b明亮', 25),('a二师兄', 21),('c相爷', 73), ('d三包春', 30),]
# l2 = sorted(l1,key=lambda x: x[1])
l2 = sorted(l1,key=lambda x: x[1],reverse=True)
print(l2)# zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，
# 然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
# 拉链方法 ***
l1 = [1, 2, 3]
l2 = ['a', 'b', 'c', 5]
l3 = ('*', '**', '***')
iter1 = zip(l1, l2, l3)
# print(iter1)
for i in iter1:
print(i)# filter：返回一个迭代器 ***
# 过滤 类似于列表推导式的筛选模式。
l1 = [2, 4, 5, 6, 7, 8, 10]
iter2 = filter(lambda x: x % 2 == 0, l1)
for i in iter2:
print(i)# # map:返回一个迭代器, 循环 类似于列表推导式的循环模式。
l1 = [1, 2, 3, 4, 5]
# print([i**2 for i in l1])
iter3 = map(lambda x: x**2, l1)
print(list(iter3))# reduce lambda
from functools import reduce
l1 = [1, 2, 3, 4, 5]
# l1 = ['alex', 'wusir', 'taibai']
i = reduce(lambda x,y: x + y, l1)
# 3
# 6
# 10
# 15
# i = reduce(lambda x,y: x + y, l1)
print(i)
