Day 14 匿名函数 内置函数 面向对象编程
目录
0 上节课复习
0.1 迭代器
0.1.1 可迭代对象
拥有iter方法的对象
str / list / tuple / dict / set / file
0.1.2 迭代器对象
file
拥有iter和next方法的对象
- 迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象（文件是可迭代对象也是迭代器对象
0.1.3 for循环原理
for in list：把list生成可迭代对象，然后使用next方法取出一个个值，直到报错捕捉异常然后中断退出，所以for循环可以不基于索引值
0.2 三元表达式
成立时干嘛 if 条件 else 不成立干嘛
0.3 列表推导式
[ i for i in range(10)]
0.4 字典生成器
{ i: i for i in range(10)}
0.5 生成器
自定义的迭代器，函数内使用yield关键字
yield： 接受函数返回值，但是会继续运行下面的代码，使用yield关键字调用的函数变成生成器
return： 接受函数返回值，但会终止函数的运行，使用return关键字调用的函数就是一个普通的函数
0.5.1 生成器表达式
{i for i in range(10)}
生成器表达式生成的东西相当于老母鸡，需要的时候next拿出来
列表推导式就是一筐鸡蛋
0.6 递归
本质上就是函数调用本身，必须得有终止条件
0.7 二分法
lis = [i for i in range(10000)]
def deco(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper
@deco
def find_num(num):
for i in lis:
if i ==num:
print('找到了')
break
else:
print('没有被找到')
find_num(45678)
1 匿名函数
1.1 有名函数
有名字的函数。名字（）调用
def mingzi():
pass
mingzi()
1.2 匿名函数
没有名字的函数
lambda关键字定义，语法：
# lambda x,y(参数):x+y(代码)
f = lambda x,y:x+y #(不可这样)
匿名函数也能调用，但是调用需要注意只能使用一次，匿名函数一般不单独使用，而是与max(),min(),map(),sorted(),filter()这些内置函数一起使用
max() 求最大值
min() 求最小值
sorted() 排序，默认从小到大，需要接受
map() 映射：
map(lambda name:f'{name}dsb',name_list)
filter() 过滤
lis = ['sad dsb', 'dsadas dsb','sadsad']
res = filter(lambda x:x.endswith('dsb'),lis)
print(list(res)) # 输出：['sad dsb', 'dsadas dsb']
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000
}
salary_max = max(salary_dict,key = lambda name:salary_dict(name))
print(salary_max)
2 内置函数
2.1 掌握
# 1.bytes()
print('中文'.encode('utf-8'))
print(bytes('中文'.encode('utf-8')))
# 2.chr()/ord() ascill码对应关系
print(chr(98)) #输出b
print(ord('a')) #输出97
# 3.divmod(x,y) 整除 输出 x//y x%y
print(divmod(10,3)) #(3, 1)
# 4.enumerate() 获取索引和值
lis = ['a','b','c']
for i in enumerate(lis):
print(i) #输出(0, 'a')(1, 'b')(2, 'c')
for index,value in enumerate(lis):
print(index,value) #输出 0 a ；1 b ；2 c
# 5.eval() 去掉字符串的引号，然后他是什么数据类型就是什么数据类型
lis = ' ["a","b","c"]'
print(lis)
print(type(lis))
print(eval(lis))
print(type(eval(lis)))
# 6.hash() 可哈希不可变，不可哈希可变
print(hash(1))
# hash([1,2,3]) #list为可变，故不可哈希，会报错
2.2 了解
# 1.abs() 求绝对值
print(abs(-10)) # 10
# 2.all() 可迭代对象内元素全为真，则返回真，括号里只能有一个对象 类似于 and
print(all([1,2,3,4])) #True
print(all([0,1,4,7])) #Flase
# 3.any() 可迭代对象内元素有一个为真，则返回真，括号里只能有一个对象 类似于 or
print(any([0,0,0,0])) #Flase
print(any([0,0,1,0])) #True
# 4.bin/oct/hex 二进制，八进制，十六进制
print(bin(10)) # 0b1010
print(oct(10)) # 0o12
print(hex(10)) # 0xa
# 5.dir 列举出math的所有功能
import math
print(dir(math))
# 6.frozenset() 不可更改的集合
s = frozenset({1, 2, 3})
print(s) #frozenset({1, 2, 3})
# 7. globals()/nonlocal() 查看全局名字；查看局部名字。
# 8.pow(x,y,z) (x**y)%z
print(pow(3, 2, 3)) # (3**2)%3
# 9.round() 四舍五入
print(round(3.5)) #4
# 10.sum() 求和
print(sum(range(100))) #4950
# 11.__import__() 通过字符串导入模块。
m = __import__('time')
print(m.time())
3 面向过程编程
原材料（一堆塑料） \(\rightarrow\) 融化塑料 \(\rightarrow\) 通过模具做出一个个瓶子 \(\rightarrow\) 包装检测瓶子 \(\rightarrow\) 卖瓶子
面向过程编程：按照一定的顺序，顺序中的每一步都可以看成函数，这个函数的输入是上一个函数的输出
- 优点：
- 逻辑清晰，简单明了
- 每个函数可以独立的写出来
- 缺点：
- 相互之间会有一定的联系，上一步中断了，下一步也中断了
- 有一个功能改变了，其他的功能也要改变
- 可扩展性差
def enter_username_pwd():
username = input("请输入你的名字>>>").strip()
pwd = input("请输入你的密码>>>").strip()
return username, pwd
def register():
username, pwd = enter_username_pwd()
with open('test.txt', 'a',encoding = 'utf8') as fa:
fa.write(f"{username}:{pwd}\n")
def login():
username, pwd = enter_username_pwd()
with open('test.txt', 'r',encoding = 'utf8') as fr:
for user in fr:
user_list = user.strip().split(':')
username_file = user_list[0]
pwd_file = user_list[1]
if username == username_file and pwd == pwd_file:
print('登陆成功！')
break
else:
print('登录失败')
fun_dict = {
0:register,
1:login,
}
print_message = '''
0:register
1:login
q:quit
'''
print(print_message)
while True:
choice = input('请输入你需要的功能').strip()
if choice == 'q':
break
fun_dict[int(choice)]()
浙公网安备 33010602011771号