00 如何学习python
如何学好英语？
母系英语。
听 说 读 写 练
input output
听 说
读 写（练）
听，读 说 纠正
01 昨日内容回顾
生成器：本质就是迭代器，自己用python代码构建的迭代器。
1，生成器函数。(yield)
2，生成器表达式。（i for i in range(100)）
生成器对象：gentor
next(gentor)
send(gentor)
for 循环
yield 与 return 区别？
send：
给上一个yield发送一个值
send 对应yield取值。
next：
对应一个yield 取值。
yield from 将一个可迭代对象变成一个迭代器返回。
列表推导式：
循环模式：[变量（加工后的变量） for 变量 in iterable]
三元模式：['*' if a > b else 变量 for 变量 in iterable]
筛选模式：[变量（加工后的变量） for 变量 in iterable if 条件]
优点：
一行代码搞定，简单，高逼格。
缺点：有毒。不能采用debug模式查错。
生成器表达式：与上面相同，将[] 换成（）
字典推导式，集合推导式（了解）。
02 作业讲解（下午）
03 内置函数
04 装饰器
05 递归函数（了解）
06 购物车（下午）
# 03 装饰器
import time
# # 第一版完成
# def func():
# print('非常复杂.....')
# time.sleep(0.2)
# def func1():
# print('非常复杂.....')
# time.sleep(0.2)
# def func2():
# print('非常复杂.....')
# time.sleep(0.2)
# def timmer(f):
# start_time = time.time()
# f()
# end_time = time.time()
# print('执行效率%s' %(end_time-start_time))
# func()
# timmer(func)
# timmer(func1)
# timmer(func2)
# 上一个版本：假如500个函数都在实际的项目中，项目中可能出现了5000次调用，春哥想要不影响项目正常运转的情况下， 测试他们的
#执行效率：意味着将项目中5000次这样的调用方式func() 变成timmer(func)
# 第二版本：尽量不要改变原函数的调用方式，并且能对原函数进行时间效率测试。
# def func():
# print('非常复杂.....')
# time.sleep(0.2)
# def timmer(f):
# start_time = time.time()
# f()
# end_time = time.time()
# print('执行效率%s'%(end_time-start_time))
# f1 = func
# func = timmer
# func(f1)
# 上一个版本虽然你做了伪装，执行原函数的调用方式看似不变，并且测试了执行效率，
# 但是执行原函数的调用方式还是变了，原来是没有参数，现在多加了一个参数，而且还加了两行代码
# 装饰器的雏形： 没有改变原函数以及原函数的调用方式，并且测试了执行效率
# def func():
# print('非常复杂.....')
# time.sleep(0.2)
# def func1():
# print('超级简单.....')
# time.sleep(0.2)
# def timmer(f): #func函数
# def inner():
# start_time = time.time()
# f() #原函数func
# end_time = time.time()
# print('执行效率%s'%(end_time-start_time))
# return inner
# func = timmer(func)
# func() # inner()
# func1 = timmer(func1)
# func1()
# 上一个版本每次执行原函数都要加一句func1 = timmer(func1)，还是比较麻烦，但是解释器为咱们提供了一个语法糖@的概念。
# def timmer(f): # func函数
# def inner():
# start_time = time.time()
# f() # 原函数func()
# end_time = time.time()
# print('二师兄的执行效率%s' %(end_time-start_time))
# return inner
#
# @timmer # func = timmer(func) # inner
# def func():
# print('非常复杂.....')
# time.sleep(0.2)
# func()
# @timmer # func1 = timmer(func1)
# def func1():
# print('fsdafsa...')
# time.sleep(0.3)
# #
# # func1() # inner()
# 上一个版本有问题：被装饰的函数是需要有参数的，上一个版本不满足
# def timmer(f):
# def inner(*args,**kwargs): # 函数的定义：* 代表聚合。
# # args = ('二师兄', '三包春药')
# start_time = time.time()
# f(*args, **kwargs) # 函数的执行：* 代表打散。 f('二师兄', '三包春药')
# end_time = time.time()
# print('二师兄的执行效率%s' %(end_time-start_time))
# return inner
# @timmer
# def func(x):
# print('这是一个人名:%s' %x)
# time.sleep(0.2)
# @timmer
# def func1(x,y):
# print('这是两个人名:%s %s' %(x,y))
# time.sleep(0.2)
# @timmer
# def func2(x,y,z='alex'):
# print('这是两个人名:%s %s' %(x,y))
# print('这是两个男神的名字:%s '%z)
# time.sleep(0.2)
# # func('三包春药') # inner('三包春药')
# func1('二师兄', '三包春药') # inner('二师兄', '三包春药')
# func2('二师兄', '三包春药','太白')
# 上一个版本不能实现被装饰函数含有返回值的功能。
# 标准版装饰器
# def timmer(f):
# def inner(*args,**kwargs):
# start_time = time.time()
# ret = f(*args, **kwargs)
# end_time = time.time()
# print('二师兄的执行效率%s' %(end_time-start_time))
# return ret
# return inner
# @timmer # func = timmer(func)
# def func(x):
# print('这是一个人名:%s' %x)
# time.sleep(0.2)
# return 666
# func(1)
# #
# r = func('三包春药') # inner('三包春药')
# print(r)
# 标准版装饰器
# def wrapper(f):
# def inner(*args,**kwargs):
# '''执行被装饰函数之前的操作'''
# ret = f(*args,**kwargs)
# '''执行被装饰函数之后的操作'''
# return ret
# return inner
# 装饰器：装饰器的本质是闭包，而且装饰器其实就是个函数而已。
# 装饰器：在不改变原函数调用方式上，给原函数增加了一些额外的功能。登录验证，写日志，执行效率等等。
# 开放封闭原则：
# 对拓展开放的：
# 我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。
# 所以我们必须允许代码扩展、添加新功能。
#对修改是封闭的：
# 就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，
# 如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。
# 装饰器就是开放封闭原则完美的体现。
# flag = False
# def login(f):
# def inner(*args,**kwargs):
# global flag
# if flag:
# ret = f(*args, **kwargs)
# return ret
# else:
# username = input('用户名').strip()
# password = input('密码').strip()
# if username == 'alex' and password == '123':
# flag = True
# print('登录成功！')
# ret = f(*args, **kwargs)
# return ret
# return inner
#
# @login
# def func1():
# print(111)
# @login
# def func2():
# print(222)
# @login
# def func3():
# print(333)
# func1()
# func2()
# func3()
# 04 内置函数
# 内置函数：python给咱们提供了一些他认为你会经常用到的函数。68种。
'''
print() input() len() list() str() max()min() type()
id() dict() next() range() int() dir() set() isinstance()
bool() open() globals() locals() hash() iter() enumrate()tuple()
'''
# 作用域相关
# *** locals ：函数会以字典的类型返回当前位置的全部局部变量。
# *** globals：函数以字典的类型返回全部全局变量。
# 1.2其他相关
# 1.2.1 字符串类型代码的执行 eval，exec，complie 慎用 **
# eval 执行字符串类型的代码，并返回最终结果。
# s1 = '1 + 2 +3'
# n = 55
# s3 = "{'name': 'alex'}"
# num = input('>>>')
# # print(s1)
# print(eval(s1))
# print(eval('n + 16'))
# ret = eval(s3)
# print(ret,type(ret))
# s4 = '''
# for i in range(1,5):
# print(i)
# '''
# print(s4)
# exec 执行字符串类型的代码流
# exec(s4)
# 1.2.2 输入输出相关 input，print ***
# # input:函数接受一个标准输入数据，返回为 string 类型。
# # print:打印输出。
# print(1,2,3,sep='|') # 设置打印的分隔符
# print(1,2,3,end=' ') # 设置结束时的格式
# f = open('log','w',encoding='utf-8')
# print('写入文件',file=f)
#
# 1.2.3内存相关 hash id ***
# hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
# id:用于获取对象的内存地址。
# print(hash('fsdfdsa'))
# print(hash('alex'))
# print(hash('太白金星'))
# print(hash(100))
# print(hash(10000))
# 1.2.3文件操作相关
#
# open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。 ***
# 1.2.4模块相关__import__ *
# __import__：函数用于动态加载类和函数 。
# 1.2.5帮助
# help：函数用于查看函数或模块用途的详细说明。 ***
# print(help(str))
# 1.2.6调用相关
# callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；
# 但如果返回False，调用对象ojbect绝对不会成功。 ***
# def func():
# pass
# func1 = 77
# print(callable(func))
# print(callable(func1))
# 1.2.7查看内置属性 **
# dir：函数不带参数时，返回当前范围内的变量、
# 方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
# 如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，
# 该方法将最大限度地收集参数信息。
# 1.3 迭代器生成器相关
# range：函数可创建一个整数对象，一般用在 for 循环中。 ***
# next：内部实际使用了__next__方法，返回迭代器的下一个项目。 **
# iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。**
# 1.4.1数字相关（14）
# 数据类型（4）：
#
# bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。 **
#
# int：函数用于将一个字符串或数字转换为整型。 **
# print(int('123'))
# print(int(3.14)) # 取整 3
# print(int(3.94)) # 取整 3
# 二进制转化成十进制
# print(int('0100',base=2)) # 4
# float：函数用于将整数和字符串转换成浮点数。 **
# print(float('3.14'))
# print(float(10)) # 10.0
# complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。*
# 如果第一个参数为字符串，则不需要指定第二个参数。。
# 3 + 4j
# 进制转换（3）： **
# bin：将十进制转换成二进制并返回。
# oct：将十进制转化成八进制字符串并返回。
# hex：将十进制转化成十六进制字符串并返回。
# 数学运算（7）：
#
# abs：函数返回数字的绝对值。 **
# print(abs(-5))
# divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。 ***
# print(divmod(100,9))
# round：保留浮点数的小数位数，默认保留整数。 **
# print(round(3.14))
# print(round(3.1415926, 3))
# pow：求x**y次幂。（三个参数为x**y的结果对z取余） **
# print(pow(3,4))
# print(pow(3,4,6))
# sum：对可迭代对象进行求和计算（可设置初始值）。 ***
# l1 = [i for i in range(20)]
# print(sum(l1))
# print(sum(l1,10))
# min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。 ***
# l1 = [3, 2, 7, 9, 10]
# print(min(l1))
# l1 = [3, 2, 7, 9, -10, -1]
# print(min(l1,key=abs))
# dic = {'a': 3 ,'b': 2,'c': 1}
# def func(x):
# # x = a 第一次
# # x = b 第二次
# # x = c 第二次
# return dic[x]
# dic['a'] 3
# dic['b'] 2
# dic['c'] 1
# print(min(dic)) # 默认比较字典的key 将最小的key返回
# print(min(dic,key=func)) # 将dic中的每个键传入函数中，以函数的返回值比较最小。
# print(dic[min(dic,key=func)]) # 将dic中的每个键传入函数中，以函数的返回值比较最小。
# print(min(dic,key=lambda x: dic[x])) # 将dic中的每个键传入函数中，以函数的返回值比较最小。
# print(dic[min(dic,key=func)])
# l1 = [('a', 3), ('b', 2), ('c', 1)]
# # print(min(l1))
# print(min(l1,key=lambda x: x[1]))
# max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。 ***
# l1 = [('c', 3), ('b', 2), ('a', 1)] # 按照数字返回最大的元组
# dic = {'c': 3, 'b': 2, 'a': 1} # 按照value 返回最大的值
# list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。 **
# print(list({1,5,6,8}))
# print(list({'a': 1, 'b': 2}))
# tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。 **
# reversed：将一个序列翻转，并返回此翻转序列的迭代器。
# l1 = [3, 6, 1, 9]
# l1.reverse()
# print(l1)
# l1 = [3, 6, 1, 9]
# s1 = '太白金星'
# # iter1 = reversed(l1)
# iter2 = reversed(s1)
# # print(iter1)
# for i in iter2:
# print(i)
# slice *
# li = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
# l1 = ['d', 'e', 'f', 'g']
# sli_obj = slice(3)
# print(li[sli_obj])
# print(l1[sli_obj])
# format:与具体数据相关，用于计算各种小数，精算等。 *
# print(format('test', '<20'))
# print(format('test', '>20'))
# print(format('test', '^20'))
# str ***
# bytes ***
# s1 = 'alex'
# 编解码的第一种方式：
# b1 = s1.encode('utf-8')
# s2 = b1.decode('utf-8')
# print(b1,s2)
# # 编解码的第二种方式：
# s1 = 'alex'
# b1 = bytes(s1,encoding='utf-8') # 编码 unicode ---> utf-8
# s3 = str(b1,encoding='utf-8') # 解码：utf-8 ----> unicode
# print(b1)
# print(s3)
# bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。 *
# memoryview *
# ord 输入字符找该字符编码的位置 unicode *
# print(ord('a'))
# print(ord('中'))
# chr 输入位置数字找出其对应的字符 *
# print(chr(97))
# print(chr(20013))
# 是ascii码中的返回该值，不是就返回/u... *
# print(ascii('a'))
# print(ascii('中'))
# repr:返回一个对象的string形式（原形毕露）。
# s1 = '太白'
# print(s1)
# print(repr(s1))
# msg = '我叫%s' %('太白')
# msg = '我叫%r' %('太白')
# print(msg)
# dict：创建一个字典。 **
#
# set：创建一个集合。 **
#
# frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 **
#
# 相关内置函数（8）
#
# len:返回一个对象中元素的个数。 ***
# all：可迭代对象中，全都是True才是True **
# any：可迭代对象中，有一个True 就是True **
# l1 = [1, 2, 'alex', [1,2,3]]
# l2 = [1, '', [], {}]
# print(all(l1))
# print(any(l1))
# min max 可以加key
# sorted：对所有可迭代的对象进行排序操作。 ***
# l1 = [1, 6, 5, 3, 10]
# l2 = sorted(l1)
# print(l2)
# l1 = [('b明亮', 25),('a二师兄', 21),('c相爷', 73), ('d三包春药', 30),]
# l2 = sorted(l1,key=lambda x: x[1])
# l2 = sorted(l1,key=lambda x: x[1],reverse=True)
# # print(l2)
# zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，
# 然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
# 拉链方法 ***
# l1 = [1, 2, 3]
# l2 = ['a', 'b', 'c', 5]
# l3 = ('*', '**', '***')
# iter1 = zip(l1, l2, l3)
# # print(iter1)
# for i in iter1:
# print(i)
# filter：返回一个迭代器 ***
# 过滤 类似于列表推导式的筛选模式。
# l1 = [2, 4, 5, 6, 7, 8, 10]
# iter2 = filter(lambda x: x % 2 == 0, l1)
# for i in iter2:
# print(i)
# # map:返回一个迭代器, 循环 类似于列表推导式的循环模式。
# l1 = [1, 2, 3, 4, 5]
# # print([i**2 for i in l1])
# iter3 = map(lambda x: x**2, l1)
# print(list(iter3))
# reduce lambda
from functools import reduce
# l1 = [1, 2, 3, 4, 5]
# l1 = ['alex', 'wusir', 'taibai']
# i = reduce(lambda x,y: x + y, l1)
# 3
# 6
# 10
# 15
# i = reduce(lambda x,y: x + y, l1)
# print(i)