python习题，关于匿名函数专场的练习
习题
看代码分析结果:
func_list = []
for i in range(10):
func_list.append(lambda: i)
v1 = func_list[0]()
v2 = func_list[5]()
print(v1, v2)
⾸先for循环中加⼊了2个匿名函数
在执⾏v1执⾏第⼀个匿名函数的时候返回的是i,
因为匿名函数i 在临时空间名称不到,
所以在全局名称空间查，到了i = 9
所以结果是9
v2同上
运⾏结果:
9 9
习题
看代码分析结果:
func_list = []
for i in range(10):
func_list.append(lambda x: x + i)
v1 = func_list[0](2)
v2 = func_list[5](1)
print(v1, v2)
⾸先列表添加了10个匿名函数,
然后在执⾏v1的时候是到列表的第⼀个元素
也即匿名函数然后传⼊2的值，
这时候i也是通过全局名称空间到了i = 9
所以v1 = x + i = 11
v2也同上
v2 = 10
运⾏结果:
11 10
字符串函数模拟注册
习题
看代码分析结果:
func_list = []
for i in range(10):
func_list.append(lambda x: x + i)
for i in range(2, 12):
result = func_list[i-2](i)
print(result)
⾸先列表加⼊了10个匿名函数
然后在执⾏第⼆个循环的时候传⼊值i，
然后匿名函数返回是:2+i,
i通过全局命名空间到2
所以答案是：2+2=4
然后后⾯的同上依次循环最后的值是
6
8
...
22
运⾏结果:
4
6
8
10
12
14
16
18
20
22
习题
看代码写结果(⾯试题):
def func(name):
v = lambda x: x + name
return v
v1 = func('太⽩')
v4 = v2('⾦⾓')
print(v1, v2, v3, v4)
运⾏结果：地址xxxx代表⼗六进制地址
<function func.. at 0x0000000000xxxxxx> <function func.. at 0x0000000000xxxxxx> '银⾓太⽩' '⾦⾓alex'
习题
看代码写结果(⾯试题):
result = []
for i in range(10):
func = lambda: i
result.append(func)
print(i)
print(result)
v1 = result[0]()
v2 = result[9]()
print(v1, v2)
运⾏结果:
9
[<function at 0x0000000000xxxxxx>,...]*10 # 合计10个不同的匿名函数地址
9 9
习题
看代码写结果(⾯试题):
def func(num):
def inner():
print(num)
return inner
result = []
for i in range(10):
f = func(i)
result.append(f)
print(i)
print(result)
v1 = result[0]()
v2 = result[9]()
print(v1, v2)
运⾏结果:
9
[<fuction func..inner at 0x0000000000xxxxxx>]*10 # 10个不同的地址
0 9
None None
习题
看代码写结果(新浪微博⾯试题)
def func():
for num in range(10):
pass
v4 = [lambda: num + 10, lambda: num + 100, lambda: num + 100]
result1 = v4[1]()
result2 = v4[2]()
print(result1, result2)
func()
运⾏结果:
9 9
习题
请编写⼀个函数实现IP地址转换成⼀个整数(⾯试题)。
例如:
10.3.9.12 转换规则为:
⼗进制⼆进制
1000001010
300000011
900001001
1200001100
在将以上⼆进制拼接起来计算⼗进制结果:
00001010 00000011 00001001 00001100 = ?
def fun_bin(ip='192.168.1.1'):
def inner():
nonlocal ip
# 获取列表元素：对应的⼗进制
ip_list = [int(i) for i in ip.split('.')]
# zfill(width) width字符不⾜前⾯会补充0，并且原字符串右对齐
# lstrip() 默认清空左侧空格，加参数会删除填写的字符
result = [bin(i).lstrip('0b').zfill(8) for i in ip_list]
ip_bin = ''
for i in result:
ip_bin += i
return int(f'{ip_bin}', 2), ip_bin # ⼆进制的拼接->⼗进制
return inner
if __name__ == '__main__':
print(f'IP:{ip}\nIP对应拼接后的⼆进制：{y[1]}\nIP对应⼆进制拼接后的对应的⼗进制是:{y[0]}')
# 运⾏结果
# IP:192.168.1.1
# IP对应拼接后的⼆进制：11000000101010000000000100000001
# IP对应⼆进制拼接后的对应的⼗进制是:3232235777
习题
⽤内置函数或者匿名函数结合完成以下习题
9.1 ⽤map来处理字符列表，把列表中所有⼈都变成sb,⽐⽅alex_sb
name = ['oldboy', 'alex', 'wusir']
name = ['oldboy', 'alex', 'wusir']
new_name = list(map(lambda n: n + '_sb', name))
print(new_name) # ['oldboy_sb', 'alex_sb', 'wusir_sb']
9.2 ⽤map来处理下述l，然后⽤list得到⼀个新的列表，列表中的每个⼈的名字都是sb结尾
l = [{'name': 'alex'}, {'name': 'y'}]
l = [{'name': 'alex'}, {'name': 'y'}]
new_l = list(map(lambda x: {'name': x['name'] + '_sb'}, l))
print(new_l) # [{'name': 'alex_sb'}, {'name': 'y_sb'}]
9.3 ⽤filter来处理，得到股票价格⼤于20的股票名字
shares = {'IBM': 36.6, 'Lenovo': 23.2, 'oldboy': 21.2, 'ocean': 10.2}
shares = {'IBM': 36.6, 'Lenovo': 23.2, 'oldboy': 21.2, 'ocean': 10.2}
new_shares = list(filter(lambda x: shares[x] > 20, shares))
print(new_shares) # ['IBM', 'Lenovo', 'oldboy']
9.4 有下⾯字典，得到购买每只股票的总价格，并放在⼀个迭代器中结果:list⼀下[9110.0,27161.0,..]
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}]
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}]
new_portfolio = map(lambda i: i.get('shares') * i.get('price'), portfolio)
print(list(new_portfolio)) # [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
9.5继续题9.4的字典，过滤出单价⼤于100的股票.
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}]
new_portfolio = filter(lambda x: x.get('price') > 100, portfolio)
print(list(new_portfolio))
# [{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]
9.6有下列三种数据类型;
l1 = [1, 2, 3, 4, 5, 6]
l2 = ['oldboy', 'alex', 'wusir', '太⽩', '⽇天']
l3 = ('**', '***', '****', '*******')
写代码，最终得到的是(每个元组第⼀个元组>2，第三*⾄少是4个)
类似：
[(3, 'wusir', '****'), (4, '太⽩', '******')
l1 = [1, 2, 3, 4, 5, 6]
l2 = ['oldboy', 'alex', 'wusir', '太⽩', '⽇天']
l3 = ('**', '***', '****', '*******')
lst = filter(lambda x: x[0] > 2 and len(x[2]) >= 4, zip(l1, l2, l3))
print(list(lst)) # [(3, 'wusir', '****'), (4, '太⽩', '*******')]
9.7有如下数据类型
l1 = [{'sales_volumn': 0},
{'sales_volumn': 108},
{'sales_volumn': 337},
{'sales_volumn': 475},
{'sales_volumn': 396},
{'sales_volumn': 172},
{'sales_volumn': 9},
{'sales_volumn': 58},
{'sales_volumn': 272},
{'sales_volumn': 456},
{'sales_volumn': 440},
{'sales_volumn': 239}]
将l1按照列表中的每个字典的values⼤⼩进⾏排序，形成⼀个新的列表.
new_l1 = sorted(l1, key=lambda x: x['sales_volumn'])
print(new_l1)
# [{'sales_volumn': 0}, {'sales_volumn': 9}, {'sales_volumn': 58}, {'sales_volumn': 108}, {'sales_volumn': 172}, {'sales_volumn': 239}, {'sales_volumn': 272}, {'sales_volumn': 337}, {'sales_volumn': 396}, {'sales_volumn': 440}, {'sales_volumn': 456}, {'sa
习题
求结果(⾯试题).
v = [lambda: x for x in range(10)]
print(v)
print(v[0])
结果:
[<function . at 0x000000000xxxxxxx>]*10 # 10个不同内存地址的匿名函数
<function . at 0x000000000xxxxxxx> # 列表中第⼀个匿名函数的地址
9
习题
求结果(⾯试题).
v = (lambda: x for x in range(10))
print(v)
print(v[0])
print(v[0]())
print(next(v))
print(next(v)())
for i in v:
print(i)
结果:
<generator object at 0x000000000xxxxxxx> # ⽣成器地址
报错TypeError:'generator' object is not subscriptable
习题
map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])输出的是什么?(⾯试题)
结果:<map object at 0x000000000xxxxxxx>
习题
求结果:(⾯试题)
def num():
return [lambda x: i * x for i in range(4)]
print([m(2) for m in num()])
"""
⾸先执⾏num()
[lambda x:i*x for i in range(4)]
4个匿名函数<function <listcomp>.<lambda> at 0x000000000xxxxxxx>
其次[m(2) for m in [4个匿名函数]]
lambda x:i*x = lambda 2:2*i = lambda2:2*3 = 6
4个匿名函数取4次得到4个相同结果
"""
结果:
[6, 6, 6, 6]
习题
有⼀个数组[34, 1, 2, 5, 6, 6, 5, 4, 3, 3]请写⼀个函数，出该数组中没有重复的数的总和(上⾯数据的没有重复的总和:1+2=3)(⾯试题) def fun(args: list):
s = [str(i) for i in args] # 字符串组成的列表
temp = ''.join(s) # 所有元素组成的字符串
s1 = [] # 不重复的字符串列表
result = [] # 不重复的数组列表
# 不重复数字
for i in temp:
unt(i) == 1:
s1.append(i)
for i in s:
for j in i:
if j not in s1:
break
else:
result.append(int(i))
return result, sum(result)
if __name__ == '__main__':
lst = [34, 1, 2, 5, 6, 6, 5, 4, 3, 3]
print(f'排重后的列表:{fun(lst)[0]}\n列表内元素的和为：{fun(lst)[1]}')
#运⾏结果：
# 排重后的列表:[1, 2]
# 列表内元素的和为：3
习题
⽤户模拟登录管理系统:
⽤函数完成下列功能:
⽤户输⼊⽤户名密码注册
注册是要验证⽂件（register）⽤户名是否存在，如果存在则让其重新输⼊，如果不存在，则注册成功
注册成功后，将注册成功的⽤户名，密码写⼊register⽂件，并以|隔开
注册成功后，返回True，否则返回False
完成三次登录功能:
⽤户的⽤户名密码从⼀个⽂件register中取出
register⽂件包含多个⽤户名，密码,⽤户名密码通过|隔开，每个⼈的⽤户名密码占⽤⽂件中⼀⾏
完成三次验证，三次验证不成功则登录失败，登录失败则返回
登录成功返回True
其他功能:
增加了管理员登录界⾯，⽤户登录界⾯
增加了管理界⾯的删、改⽤户信息
增加了⽤户登录界⾯的查看歌词信息
import re
# 注册
def register(file_list: list):
name = input('注册的⽤户名:')
if not re.match(r'[_a-zA-Z][0-9a-zA-Z_]{3,17}$', name):
print('注册格式出错！')
continue
for i in file_list:
('name') == name:
print('该⽤户已存在！')
break
else:
break
while True:
password = input('⽤户密码:')
if not re.match(r'[~!@#$%^&*_a-zA-Z0-9]{6,20}$', password):
print('密码为：特殊字符[~!@#$%^&*_]、数字与字母的组合！⾄少6位及以上！')
continue
print('恭喜你注册成功！')
username = {'name': name, 'password': password}
file_list.append(username)
safe_file(username)
break
# 检测是匹配
def search(login):
def inner(file_list: list):
username = login(file_list)
for name in file_list:
if username == name:
return True, username
else:
return False, None
return inner
# 登录界⾯
@search
def login(file_list: list):
name = get_name()
while True:
password = input('⽤户密码:')
if not re.match(r'[~!@#$%^&*_a-zA-Z0-9]{6,20}$', password):
print('密码为：特殊字符[~!@#$%^&*_]、数字与字母的组合！⾄少6位及以上！')
continue
break
return {'name': name, 'password': password}
# 登录3次验证
def while_longin(n, login, file_list: list):
i = 0
while i < 3:
print(f'第{i + 1}次登录')
result = login(file_list)
if result[0]:
print('登录成功!')
if result[1].get('name') == 'admin':
management(file_list)
else:
users_management()
return True
i += 1
else:
print(f'登录失败达到{n}次！')
return False
# 查看本地存在的⽤户信息
def local_info(file_list: list):
print('***************⽤户信息***************')
for username in enumerate(file_list, start=1):
print(f"序号：{username[0]}\t⽤户名:{username[1].get('name')}\t密码:{username[1].get('password')}") # 存⼊本地⽂件
def safe_file(info):
if isinstance(info, dict):
with open('register', encoding='utf-8', mode='a+') as f1:
f1.write(f"{('name')}|{('password')}\n")
if isinstance(info, list):
with open('register', encoding='utf-8', mode='w') as f1:
for username in info:
f1.write(f"{('name')}|{('password')}\n")
# 删除本地账户
def del_info(name, file_list: list):
for username in file_list:
if name == ('name'):
ve(username)
# 写⼊⽂件
safe_file(file_list)
print('删除成功!')
return True
else:
print('该⽤户不存在!')
return False
# 读取本地⽂件
def load_file():
lst = []
try:
with open('register', encoding='utf-8') as f1:
for line in f1:
name, password = line.strip('\n').split('|')
lst.append({'name': name, 'password': password})
except FileNotFoundError as e:
with open('register', encoding='utf-8', mode='w') as f2:
pass
finally:
return lst
# 获取⽤户名
def get_name():
while True:
name = input('⽤户名:')
if not re.match(r'[_a-zA-Z][0-9a-zA-Z_]{3,17}$', name):
print('注册格式出错！')
continue
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论