python3-基础10

###匿名函数与内置函数
'''
匿名函数与内置函数
常用模块
面向对象

'''

'''

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需要先编译再执行