p77-
回顾
- 匿名函数，一句话函数
- 内置函数，内部价key的函数，min max sorted map reduce filter
#十进制转八进制
print(oct(3)) #return 0o3
#八进制转十六进制
print(hex(0o3)) #return 0x3
#转utf-8 的2中方式
s1='hello'
print(s1.encode('utf-8')) #return b'hello'
print(repr(s1)) #return 'hello'
s2=b'hello'
print(s2.decode('utf-8')) #return hello
print(bytes(s1,encoding='utf-8')) #return b'hello'
#ord 查找字符编码位置 chr 根据位置得出字符
print(ord('a')) #return 97
print(ord('A')) #return 65
print(ord('#')) #return 35
print(chr(35)) #return #
print(chr(65)) #return A
print(chr(20102)) #return 汉字 ‘了’
#print
print(1,2,3) #return 1 2 3
print(1,2,3,sep='|') #return 1|2|3 #默认都换行 end='\n'
print(1,end=' ')
print(2,end=' ')
print(3,end=' ') #以上三行 按照空格隔开，但是不换行
#sum
l1=[x for x in range(5)]
print(sum(l1)) #return 10
l2=[3,'a']
print(sum(l2)) #return TypeError: unsupported operand type(s) for +: 'int' and 'str'
#判断是否有自由变量，有结果就是闭包
def func1():
l1=[]
def func2(a):
l1.append(a)
return sum(l1)/len(l1)
return func2
g=func1()
print(g(1))
print(g(2))
print(g(3))
print(g.__code__.co_freevars) #判断是否有自由变量，有结果就是闭包
#写一个函数把输入的ip地址转换成二进制，再转换成一个整数
# 如3.3.3.3 -> 00000011 00000011 00000011 00000011 ->到十进制 = 50529027
def change(s2):
l1=[]
s1=int(s2)
if int(s1) == 1:
l1=list('10000000')
else:
while divmod(int(s1),2)[0]!=1:
l1.append(str(divmod(int(s1),2)[1]))
s1=divmod(int(s1),2)[0]
else:
l1.append(str(divmod(int(s1),2)[1]))
l1.append(str(divmod(int(s1),2)[0]))
if len(l1)<8:
l1.extend('0'*(8-len(l1)))
l2=list(reversed(l1))
return ''.join(l2)
def change1(s):
l1=str(s).split('.')
return change(l1[0])+change(l1[0])+change(l1[0])+change(l1[0])
def change2(s):
l1=list(s)
sum = 0
i=0
while i <len(l1):
if int(l1[i]) ==1:
sum += 2**(len(l1)-i-1)
i+=1
print(sum)
change2(change1('3.3.3.3')) #return 50529027
#map 把所有元素字符串都加上'_hi' 比如 tom_hi
l1=['Leo','jerry','tom']
#列表推导式
print([i+'_hi' for i in l1]) #return ['Leo_hi', 'jerry_hi', 'tom_hi'] 列表推导式
#map
print(list(map(lambda x:x+'_hi',l1))) #return ['Leo_hi', 'jerry_hi', 'tom_hi'] 列表推导式
#用map 在每个人名后面加上一个_hello
l1=[{'name':'tom'},{'name':'jerry'}]
print(list(map(lambda x:x['name']+'_hello',l1))) #return ['tom_hello', 'jerry_hello']
#有下面字典，得到每个股票的总价，并放在迭代器中 list 显示出来 [470.0, 22320.0, 12580.0]
gp=[
{'name':'apple','shares':20,'price':23.5},
{'name':'huawei','shares':400,'price':55.8},
{'name':'xiaomi','shares':200,'price':62.9}
]
print(list(map(lambda x:int(x['shares'])*x['price'],gp))) #return [470.0, 22320.0, 12580.0]
#用filter把单价大于25的股票
ret=filter(lambda x:x['price']>25,gp)
print(list(ret))
#return [{'name': 'huawei', 'shares': 400, 'price': 55.8}, {'name': 'xiaomi', 'shares': 200, 'price': 62.9}]
#return filter 只过滤，不改变内部结构，得出来的和迭代器一样的格式
#筛选用zip 拉链，再filter出结果，让第一个元素大于2，切最后一个元素*个数大于4
l1=[1,2,3,4,5]
l2=['tom','jerry','lily','mike']
tu=('**','***','****','*****')
print(list(filter(lambda x:x[0]>2 and len(x[2])>4,zip(l1,l2,tu))))
#return [(4, 'mike', '*****')]
#将l1按照列表中每个字典的score值大小排序，形成一个新的列表
l1=[
{'score':344},
{'score':9},
{'score':74},
{'score':122},
{'score':36},
{'score':55}
]
print(sorted(l1)) #return TypeError: '<' not supported between instances of 'dict' and 'dict'
print(sorted(l1,key=lambda x:x['score']))
#return [{'score': 9}, {'score': 36}, {'score': 55}, {'score': 74}, {'score': 122}, {'score': 344}]
#判断结果
l1 = [lambda :x for x in range(10)]
print(l1) #return [<function <listcomp>.<lambda> at 0x03178F58>, <function <listcomp>.<lambda> at 0x03088778>, 所有函数地址
print(l1[0]) #return <function <listcomp>.<lambda> at 0x03178F58> 只打印第一个函数的地址
print(l1[0]()) #return 9
#首先l1 是个列表推导式产生的列表，列表内部存的是10个匿名函数，都不执行，x最终是9，所以执行l1的第一个函数的时候 x也是9
# lambda 函数的参数是空，但是返回 x
- 生成器什么时候运行？next， for循环和转化成list 的时候
#和上面的对比着看
v = (lambda :x for x in range(10)) #这是一个生成器，生成器每次走一步得到的是一个函数
# print(v) #return <generator object <genexpr> at 0x029AA3E0> 地址
# print(v[0]) #return TypeError: 'generator' object is not subscriptable 报错
print(next(v)) #return <function <genexpr>.<lambda> at 0x034A8FA0> 地址
print(next(v)()) #return 1
生成器表达式
- 生成器表达式和列表推导式语法一样，只是把[]换成了()
- 比如把10 以内的所有数的平方放到生成器表达式中
gen = (i**2 for i in range(10))
print(gen)
生成器表达式和列表推导式的区别
- 列表推导式比较耗内存，素有数据一次加载到内存，生成器就逐个产生元素
- 得到值不一样，列表推导式得到的是列表，生成器表达式得到的是生成器
- 列表推导式一目了然，生成器表达式只是一个内存地址
生成器有惰性
- 只有访问的时候才取值
字典推导式
lst1=['tom','jerry','lucy']
lst2=[55,35,90]
dic = {lst1[i]:lst2[i] for i in range(len(lst1))}
print(dic) #return {'tom': 55, 'jerry': 35, 'lucy': 90}
print(list(map(str,[1,2,3,4,5]))) #return ['1', '2', '3', '4', '5']
#计算列表中没有重复的所有元素之和
l1=[1,2,2,3,3,4,5,5,6,6]
print(sum([i for i in l1 if l1.count(i)==1]))
#return 5
#写一个函数完成三次登录功能：
'''
1、用户的用户名和密码从一个文件register中取
2、register文件包含多个用户名，密码，用户名和密码通过|隔开，每个人的用户名密码占用文件中一行
3、完成三次验证，三次验证不通过，登录失败返回False
4、登录成功返回True
'''
def login():
#取文件放到字典中 [{’name‘：’tom‘，’pwd‘，’123456‘},{’name‘：’jerry‘，’pwd‘，’1111‘}
with open('register.txt', encoding='utf-8', mode='r') as f1:
l1 = f1.readlines()
l2 = [dict(name=l.strip().split('|')[0], pwd=l.strip().split('|')[1]) for l in l1]
f1.close()
c=0
pwd1=''
while c < 3:
c += 1
name = input('Entry a name：')
pwd = input('Entry a password：')
for i in l2:
if name==i['name'] and pwd==i['pwd']:
print('成功')
return True
break
else:
continue
else:
print('失败')
return False
login()
