s='sdfsdfsd '
# lista=[ 1，2，3，4，5 ]
# L2=反转(lista ) )
sli=slice (1，4，2 ) ) ) ) ) ) ) ) )。
打印(s [ sli ] ) )。
#打印(lista ) )。
# for i in l2:
#打印(I )是
#调整格式()输出
# print (格式(' test '，' 20 ' ) )
# print (格式(' test '，' 20 ' ) )
# print (格式(' test '，' ^20 ' ) )
# bytearray字节码更改
# s1=bytearray ('你好'，编码=' utf-8 ' ) )
#打印(S1 )。
# s1[0]=128
#打印(S1 )。
# memoryview将片恢复为字节，不占用内存空间，但转换字符串仍然占用内存空间
# str01='sdfsdfvcc '
# str02=str01[:3]
# L2=内存视图(bytes (str 02，encoding='utf-8 ' ) )
#打印(列表(L2 ) ) )
#转生
# ord字符按照unicode旋转数字(可以理解为unicode中字符的位置) () ) ) ) ) ) ) ) ) )。
# chr数字将根据unicode转换为相应的字符
# ascii准入实际进入ascii时打印，否则转换为'uxxxx '
#打印(ord ) ' a ) )
#打印(ord ) '1) )
#打印(ord ) '袁) )
#
#打印(chr ) 34945 ) )
#
#打印(ascii ('袁) ) )
#打印(ascii (a ) ) )
# all (iterable any ) interable ) )。
#all其中一个可迭代对象为false，返回false
#any其中一个可重复对象为True，返回True
# print (全部([ ' a '，'，123] ) )
# print (全部([ ' a '，123] ) )
# print (全部([ 1，123 ] ) )
# print (全部([ 0，123 ] ) )
#
#打印(any ([ '，0，1 ] ) )
#打印(any ({ ' I ' } ) )
#zip拉链必须相等才能传递到目标元素。 如果不一样，匹配一些，就匹配一些
# l=[ 12、14、56、55 ]
# l2=['a '、' b '、' c']
# l3={'k1':1，' k2':55}
#forIinzip(L，l2，l3 ) :
#打印(I )是
#filter执行filter后，结果的合并小于执行前的数量
#过滤器只是过滤不会改变原始值
#defis_odd(x ) :
#返回x %2==1
#ret=filter(is_odd，[ 1，2，4，5，67，7 ]
#打印(ret ) ) )。
#打印(列表) ret ) )
# RETs=[ ifor iin [ 1，2，4，5，67，7 ] ifi %2==1]
#打印(RETs )
#
#
#defis_str(x ) :
#returntype(x )==str
#
# ret 01=过滤器(is _ str，['nihao '，12，' xu '，' yuanniu'] ) ) ) ) ) ) ) ) ) )
# for j in ret01:
#打印(j )是
使用filter ()过滤1-100平方根为整数的数字
#1、4、5、16、25、36、49、64、81、100]
#
#导入匹配
#defsqrt_01(x ) :
#x1=math.sqrt(x ) %1
# # if x1==0:
#打印(x1 ) )。
# #返回x
#print(math.sqrt ) (x ) ) ) )
#返回矩阵. sqrt (x ) %1==0
#
#s=sqrt_01(100
#打印(s )
# rs01=过滤器(sqrt _ 01，range ) ) 1，101 ) ) ) ) ) ) ) )
#打印(列表) RS01 ) )
#map函数执行
前后 元素个数不变 值可能发生变化# ret04=map(abs,[1,-9,8,-90])
# print(ret04)
# # for a in ret04:
# # print(a)
#
# ret05=[abs(a) for a in [1,-9,8,-90]]
# print(ret05)
# print(list(ret04))
#sort和sorted区别
# sort实在元列表的基础上进行排序 不占内存
# sorted是直接重新生成一份列表 不改变原列表，占内存
# listb=[1,2,-6,-8,]
# # # listb.sort(key=abs)
# # # print(listb)
# # # listb1=[1,2,-6,-8,10]
# # # print(sorted(listb1,reverse=True,key=abs))
#列表按照每个一个元素的len排序
# listc=['sdfsdf','524dsf','sdfyydc','abc']
# ret=sorted(listc,key=len)
# print(ret)
#
#
# def sort_01(x):
# ret=sorted(x,key=len)
# return ret
#
# print(sort_01(listc))
匿名函数和内置函数的配合使用
'''
匿名函数
函数名=lambda 入参 ：返回值
参数可以有多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束之后内荣就是返回值
返回值和正常函数一样可以是任意的数据类型
'''
# calc=lambda n:n*n
# print(calc(10))
#
# add01=lambda a,b:a+b
# print(add01(1,2))
'''
带有key参数的 函数 有 min max map filter sorted经常和lambda配合使用,这些函数实现功能首先会对入参做某些操作，
例如sorted(lista,key=len) 一定是先遍历列表lista 在调用len函数计算元素长度
'''
#带有key参数的 函数 有 min max map filter sorted经常和lambda配合使用
#字典排序 max先回判断入参是什么类型 在根据类型采用对应的取值方法判断
# dic={'k1':10,'k2':100,'k3':30}
# print(max(dic,key=lambda k:dic[k]))
# lista=[4,2,3,1]
# print(max(lista,key=lambda x:lista[x-1]))
#
# listb=[3,2,100,888,999,213,1111]
# res=map(lambda x:x**2,[1,2,6,8])
# print(list(res))
#筛选列表中大于10的数字
# res1=filter(lambda n:n>10,listb)
# print(list(res1))
# d=lambda p:p*2
# t=lambda p:p*3
# x=2
# x=d(x)
# x=t(x)
# x=d(x)
# print(x)
#现有两个元组((('a'),('b')),(('c'),('d')))
# 请用python中的匿名函数成成列表[{'a':'c','b':'d'}]
tup_01=zip((('a'),('b')),(('c'),('d')))
print(list(tup_01))
#
# def func_01(tup):
# return {tup[0]:tup[1]}
# #ret=map(func_01,tup_01)
# ret01=map(lambda tup:{tup[0]:tup[1]},tup_01)
# #print(list(ret))
# print(list(ret01))
# # for i in tup_01:
# print(i)
# def multipliers(x):
# return [lambda x:i*x for i in range(4)]
# ret=multipliers(2)
# print((ret))
# #
# for i in ret:
# r=i(4)
# print(r)
#print([i for i in range(4)])
# print((ret))
# print([m(2) for m in multipliers()])
#
#
#
# def multipliers():
# return (lambda x:i*x for i in range(4))
# ret=multipliers()
# print(ret)
# print([m(4) for m in multipliers()])
filter和map函数
# # 1 用map函数来处理字符串列表 把列表中所有人都变成ss例如难过的豆芽_ss
# name=['难过的豆芽','wupeiq','wang','yong','mei']
# print(list(map(lambda x:x+'_ss',name)))
#
# #2 用filter函数处理数字列表，将列表中所有的偶数筛选出来
# num=[1,2,3,5,6,8,10]
# print(list(filter(lambda x:x%2==0,num)))
#3一写一个20行以上的文件
#运行程序，现将内容读取的内容中，用列表储存
#模拟用户输入页码，每页5条，仅输出当前页的内容
# def file_read(filename):
# with open(filename,encoding='utf-8')as f:
# ret=f.readlines()
# return ret
#
#
# def filter_num(ret_num):
# if ret_num>0:
# ret_num=ret_num*5-5
# ret_con=file_read('examtest')
# #ret=[x for x in ret_con lambda x:x[ret_num:ret_num+5]]
# ret=filter(lambda x:ret_con[ret_num::],ret_con)
# return ret
#
# ret=filter_num(2)
# print(list(ret))
# with open('examtest',encoding='utf-8')as f1:
# l=f1.readlines()
# page_num=input('页码')
# page_num=int(page_num)
# pages,mod=divmod(len(l),5)
# if mod:
# pages+=1
# if page_num>pages or page_num<=0:
# print('输入有误')
# elif page_num==pages and mod!=0:
# for i in range(mod):
# print(l[(page_num-1)*5+i].strip())
# else:
# for i in range(5):
# print(l[(page_num-1)*5+i].strip())
# 4 如下 每个小字典的name对应股票名字 shares对应多少股 price对应价格
# portfolio=[{'name':'IBM','shares':100,'price':91.1},
# {'name':'AAPL','shares':50,'price':543.22},
# {'name':'FB','shares':200,'price':21.09},
# {'name':'HPQ','shares':35,'price':31.75},
# {'name':'YHOO','shares':45,'price':16.35},
# {'name':'ACME','shares':75,'price':115.65}]
# # 4.1 计算购买每只股票的的总价
# ret=map(lambda dic:{dic['name']:dic['shares']*dic['price']},portfolio)
# print(list(ret))
#
# #4.2 用filter过滤出 单价大于100的股票有那些
# ret0=filter(lambda dict:dict['price']>100,portfolio)
# print(list(ret0))