###匿名函数与内置函数
'''
匿名函数与内置函数
常用模块
面向对象
'''
'''
def func(x,y,z=1):
return x+y+z
# print(func)
# print(func(1,2,3))
#匿名函数:1、没有名字 2：函数体自带return
#函数体只有一行代码可以这样写
#匿名函数用一次就被释放掉了
'''
lambda x,y,z = 1:x+y+z
'''
实际上就是：
lamdba x,y,z = 1:
return x+y+z
'''
zzz = lambda x,y,z = 1:x+y+z
print(zzz)
#匿名函数的应用场景：
#应用于一次性的场景，临时使用
'''
#内置函数
'''
# print(abs(-1)) #绝对值
#
# print(all([1,2,'a',None]))
# print(all([]))
#bool值为假的情况：None，空，0，False
# # print(any([]))
# print(any([' ',None,False])) #True
# print(any(['',None,False])) #False
# print(any(['',None,False,1])) #True
#
#bin,oct,hex 二进制 八进制 十六进制
# print(bin(10)) #十进制转二进制
# print(oct(10))
# print(hex(10))
#bytes 字节类型
#unicode----encode----->bytes
# print('hello'.encode('utf-8'))
# print(bytes('hello',encoding='utf-8'))
#callable 查询是否是可以被调用的
# print(callable(bytes))
# print(callable(abs))
#chr,ord 根据十进制数字对应ACISS码表中的值 ord相反
# print(chr(65))
# print(chr(90))
#
# print(ord('#'))
#内置函数，又被称为工厂函数，向工厂一样，调用一次产生一个值
# int
# x=1 #x=int(1)
# print(type(x))
# x=int(2) #int 是个class（类），一直往外制造int值
complex
float
str
list
tuple
dict
set #可变集合
frozenset #不可变集合
# s={1,2,3,4} #s=set({1,2,3,4}) #集合 不可变类型
# print(type(s))
#
# s1=frozenset({1,2,3,4}) #集合 不可变集合
# print(type(s1))
#dir
# import sys
# # sys.path #.后指的是属性，path是sys的属性
# # sys.argv
# print(dir(sys)) sys下有哪些可执行的函数 sys.
#divmod 分页展示目录
# print(divmod(10,3)) # 10 除以 3 ， 的到的值和余数放在一个组里
# print(divmod(102,20)) #比如 102条记录，每页20页，该分几页
#enumerate 每个元素前面加一个索引，以元组的形式存储。它是一个迭代器，要访问里面的值，就要next() 或 for循环
# l=['a','b','c']
# res=enumerate(l)
# for i in res:
# print(i)
# for index,item in enumerate(l):
# print(index,item) #索引 索引对应的值
#globals,locals #查看全局作用域和局部作用域
# print(globals()) 查看全局作用域里面的名字，内置的和全局名称空间
#hash #得到hash值
# print(hash('abcdefg123'))
# print(hash('abcdefg123')) 内容一样的到的值就一样
# print(hash('abcdefg123'))
# print(hash('abcdefg123'))
#给函数加文档解释，用到单引号，双引号，三引号
def func():
# '''
# test function
# :return:
# '''
pass
# print(help(func))
#id:是python解释器实现的功能，只是反映了变量在内存的地址
#但并不是真实的内存地址
# x=1
# print(id(x))
# def func():pass
# print(id(func))
# print(func)
#isinstance 可以用赖判断变量是什么类型
# x=1
# print(type(x) is int)
# print(isinstance(x,int)) #x=int(1) X是int的一个实例
#迭代器
iter 可迭代对象变成迭代器对象
next
#len
#max
# print(max([1,2,3,10]))
# print(max(['a','b']))
# print(min([1,2,3,10]))
#pow
# print(pow(3,2,2)) #3**2%2 3的2次方在取2的余数
#range
# #repr，str 两个都是将解析对象转换成字符串
# print(type(str(1)))
# print(type(repr(1)))
#reversed 翻转，产生新值，是一个迭代器
# l=[1,'a',2,'c']
# print(list(reversed(l)))
# print(l)
#round 保留n位小数，四舍五入
#peinr(round(3.478,2)
#peinr(round(3.478,1)
#slice #切片
# l=[1,2,3,4,5,6]
# print(l[0:4:2]) 从0开始，到4结束，步长为2
#
# s=slice(0,4,2)
# print(l[s])
#sorted 从小到大排序，只能同类型之间排序
# l=[1,10,4,3,-1]
# print(sorted(l,reverse=True))
#sum 求和
# print(sum([1, 2,3]))
#
# print(sum(i for i in range(10))) 0 到 9 10个数求和
#vars #如果没参数，就相当于local，如果有参数，相当于字典
# import m1
# print(vars(m1) == m1.__dict__)
#zip:拉链 一一对应，组成一个小元组
# s='hellosssssssssssssssss'
# l=[1,2,3,4,5]
# res=zip(s,l)
# print(list(zip(s,l)))
#__import__
import sys
# m_name=input('module>>: ')
# if m_name == 'sys':
# m=__import__(m_name) 一个函数，调用字符串，负责字符串不能直接被访问
# print(m)
# print(m.path)
#
# sys=__import__('sys')
# print(sys)
#round
print(round(3.565,2))
print(round(3.555,2))
#################3
#与匿名函数结合使用
#max,min,sorted
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
# print(max(salaries))
# print(max(salaries.values()))
# t1=(1,'h',3,4,5,6)
# t2=(1,'y',3)
# print(t1 > t2)
# t1=(10000000,'alex')
# t2=(3000,'egon')
# print(t1 > t2)
# print(max(zip(salaries.values(),salaries.keys()))[1])
# def get_value(name):
# return salaries[name]
# print(max(salaries,key=get_value))
# l=[]
# for name in salaries:
# res=get_value(name)
# l.append(res)
# print(max(l))
# lambda name:salaries[name]
# print(max(salaries,key=lambda name:salaries[name]))
# print(min(salaries,key=lambda name:salaries[name]))
# salaries={
# 'egon':3000,
# 'alex':100000000,
# 'wupeiqi':10000,
# 'yuanhao':2000
# }
# def get_value(name):
# return salaries[name]
# print(sorted(salaries))
# print(sorted(salaries,key=get_value))
# print(sorted(salaries,key=get_value,reverse=True))
#filter,map(映射),reduce
# names=['alex','wupeiqi','yuanhao','yanglei','egon']
#
#把列表每个元素映射后，生成新的列表
# res=map(lambda x:x if x == 'egon' else x+'SB',names) #映射规则，映射名称
# print(res)
# print(list(res))
#def my_map(seq):
# res=[]
# for item in seq:
# item = item + '_SB'
# res.append(item)
# return res
#print(my_map(names))
##生成器就是迭代器，省内存
# def my_map(func,seq):
# for item in seq:
# yield func(item)
#
# res1=my_map(lambda x:x+'_SB',names)
# print(next(res1)) #通过next取值
# print(next(res1))
# print(next(res1))
# from functools import reduce
# print(reduce(lambda x,y:x+y,range(101),100))
# print(reduce(lambda x,y:x+y,range(101)))
#
# l=[1,2,'a','b',3,'c','d']
names=['alex_SB','wupeiqi_SB','yuanhao_SB','yanglei_SB','egon']
print(list(filter(lambda name:name.endswith('SB'),names))) #过滤SB
############33
# cmd='print(x)'
#
#
# x=1
# # eval(cmd,{'x':0},{'x':10000000}) 后者为局部作用域，前者为全局作用域
# # eval(cmd,{'x':0},{'y':10000000})
#eval可以自己制定作用域
#有两个参数
#可以直接执行代码
# s='for i in range(10):print(i,x)'
# code=compile(s,'','exec')
# # print(code)
# exec(code,{},{'x':1111})
#exec需要先编译再执行
