闭包：闭是封闭（函数内部函数），包是包含（该内部函数对外部作用域而非全局作用域的变量的引用）。闭包指的是：函数内部函数对外部作用域而非全局作用域的引用。
def outter(x): x = 1 def inner(): print(x) return inner f = outter(2) f() # 1 f() # 1 f() # 1 # 查看闭包的元素 print(f.__closure__[0].cell_contents) # 1
闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。
延迟计算（原来我们是传参，现在我们是包起来）、爬虫领域。
import requests def outter(url): def get(): response = requests.get(url) print(f"done: {url}") return get baidu = outter(‘https://www.baidu.com‘) python = outter(‘https://www.python.org‘) baidu() baidu() python() python()
装饰器指的是为被装饰器对象添加额外功能。因此定义装饰器就是定义一个函数，只不过该函数的功能是用来为其他函数添加额外的功能。装饰器的实现必须遵循两大原则：
装饰器其实就是在遵循以上两个原则的前提下为被装饰对象添加新功能。
不改变函数体代码，并且不改变函数调用方式，它本质就是一个函数。
def f1(x): def f2(): print(x) # 10 return f2 f2 = f1() f2() # f2()
def deco(func): def wrapper(*args,**kwargs): res = func(*args,**kwargs) return res return wrapper
import time def index(): print(‘welcome to index‘) time.sleep(1) def time_count(func): # func = 最原始的index def wrapper(): start = time.time() func() end = time.time() print(f"{func} time is {start - end}") # <function index at 0x102977730> time is -1.0038220882415771 return wrapper index = time_count(index) # index为被装饰函数index的内存地址，即index = wrapper index() # wrapper()
如果原始的被装饰函数index()有返回值的时候，wrapper()函数的返回值应该和index()的返回值相同，也就是说，我们需要同步原始的index()和wrapper()方法的返回值。
import time def index(): print(‘welcome to index‘) time.sleep(1) return 123 def time_count(func): # func = 最原始的index def wrapper(): start = time.time() res1 = func() end = time.time() print(f"{func} time is {start - end}") # <function index at 0x102977620> time is -1.0050289630889893 return res1 return wrapper index = time_count(index) res = index() print(f"res: {res}") # res: 123
如果原始的被装饰函数index()方法需要传参，那么我们之前的装饰器是无法实现该功能的，由于有wrapper()=index()，所以给wrapper()方法传参即可。
import time def index(): print(‘welcome to index‘) time.sleep(1) return 123 def home(name): print(f"welcome {name} to home page") time.sleep(1) return name def time_count(func): def wrapper(*args, **kwargs): start = time.time() res = func(*args, **kwargs) end = time.time() print(f"{func} time is {start-end}") # <function home at 0x102977378> time is -1.0039079189300537 return res
return wrapper home = time_count(home) res = home(‘egon‘) print(f"res: {res}") #res: egon
在被装饰函数正上方，并且是单独一行写上@装饰器名
import time def time_count(func): # func = 最原始的index def wrapper(*args, **kwargs): start = time.time() res = func(*args, **kwargs) end = time.time() print(f"{func} time is {start-end}") #<function home at 0x102977620> time is -1.0005171298980713 return res
return wrapper @time_count # home = time_count(home) def home(name): print(f"welcome {name} to home page") #welcome egon to home page time.sleep(1) return name @time_count # index = time_count(index) def index(): print(‘welcome to index‘) time.sleep(1) return 123 res = home(‘egon‘) print(f"res: {res}") #res: egon
import time current_user = {‘username‘: None} def login(func): # func = 最原始的index def wrapper(*args, **kwargs): if current_user[‘username‘]: res1 = func(*args, **kwargs) return res1 user = input(‘username: ‘).strip() pwd = input(‘password: ‘).strip() if user == ‘nick‘ and pwd == ‘123‘: print(‘login successful‘) current_user[‘username‘] = user res1 = func(*args, **kwargs) return res1 else: print(‘user or password error‘) return wrapper @login def home(name): print(f"welcome {name} to home page") time.sleep(1) @login def index(): print(‘welcome to index‘) time.sleep(1) res = index()
username: nick
password: 123
login successful
welcome to index
def f1(y): def f2(): x = 1 def f3(): print(f"x: {x}") # x: 1 print(f"y: {y}") # x: 1 return f3 return f2 f2 = f1(2) f3 = f2() f3()
import time current_user = {‘username‘: None} def auth(engine=‘file‘): def login(func): def wrapper(*args, **kwargs): if current_user[‘username‘]: res = func(*args, **kwargs) return res user = input(‘username: ‘).strip() pwd = input(‘password: ‘).strip() if engine == ‘file‘: print(‘base of file‘) if user == ‘nick‘ and pwd == ‘123‘: print(‘login successful‘) current_user[‘username‘] = user res = func(*args, **kwargs) return res else: print(‘user or password error‘) elif engine == ‘mysql‘: print(‘base of mysql, please base of file‘) return wrapper return login @auth(engine=‘mysql‘) def home(name): print(f"welcome {name} to home page") time.sleep(1) @auth(engine=‘file‘) def index(): print(‘welcome to index‘) time.sleep(1) res = index()
username: nick
password: 123
base of file
login successful
welcome to index
Python内置str、list、tuple、dict、set、file都是可迭代对象。
内置有__iter__方法的都叫可迭代的对象。
x = 1.__iter__ # SyntaxError: invalid syntax # 以下都是可迭代的对象 name = ‘nick‘.__iter__ lis = [1, 2].__iter__ tup = (1, 2).__iter__ dic = {‘name‘: ‘nick‘}.__iter__ s1 = {‘a‘, ‘b‘}.__iter__ f = open(‘49w.txt‘, ‘w‘, encoding=‘utf-8‘) f.__iter__ f.close()
执行可迭代对象的__iter__方法，拿到的返回值就是迭代器对象。只有字符串和列表都是依赖索引取值的，而其他的可迭代对象都是无法依赖索引取值的，只能使用迭代器对象。
__next__方法，执行该方法会拿到迭代器对象中的一个值
__iter__方法，执行该方法会拿到迭代器本身
s = ‘hello‘ iter_s = s.__iter__() while True: try: print(iter_s.__next__()) except StopIteration: break
for循环称为迭代器循环，in后必须是可迭代的对象。
lis = [1, 2, 3] for i in lis: print(i) print(range(10)) # range(0, 10) for i in range(10): print(i)
语法：条件成立时的返回值 if 条件 else 条件不成立时的返回值
x = 10 y = 20 print(x if x > y else y) # 20
语法：
[expression for item1 in iterable1 if condition1 for item2 in iterable2 if condition2 ... for itemN in iterableN if conditionN ]
举例：
print([i for i in range(10)]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print([i ** 2 for i in range(10)]) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] name_list = [‘nick‘, ‘sean‘, ‘jason‘, ‘tank‘] for n in [name if name == ‘nick‘ else name + ‘_a‘ for name in name_list] : print(n) # ‘nick‘, ‘sean_a‘, ‘jason_a‘, ‘tank_a‘
print( {i: i**2 for i in range(10)} ){0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}keys = [‘name‘, ‘age‘, ‘gender‘] values = [‘nick‘, 19, ‘male‘] res = zip(keys, values) print(res) # <zip object at 0x0000000002233540> info_dict = {k: v for k, v in res} print(info_dict) # {‘name‘: ‘nick‘, ‘age‘: 19, ‘gender‘: ‘male‘}
通过解压缩函数生成一个字典返回：
info_dict = {‘name‘: ‘nick‘, ‘age‘: 19, ‘gender‘: ‘male‘}
print(info_dict.keys()) # dict_keys([‘name‘, ‘age‘, ‘gender‘])
print(info_dict.values()) # dict_values([‘nick‘, 19, ‘male‘])
res = zip(info_dict.keys(), info_dict.values())
print(res) # <zip object at 0x00000000026939C0>
info_dict = {k: v for k, v in res}
print(info_dict) # {‘name‘: ‘nick‘, ‘age‘: 19, ‘gender‘: ‘male‘}生成器的本质就是迭代器
def func(): print(1) yield # 在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。 print(2) g = func() print(g) # <generator object func at 0x00000000026617B0>
yield和return:
def my_range(start, stop, step=1): while start < stop: yield start start += 1 g = my_range(0, 3) print(f"list(g): {list(g)}")
复杂版本：
def range(*args, **kwargs): if not kwargs: if len(args) == 1: count = 0 while count < args[0]: yield count count += 1 if len(args) == 2: start, stop = args while start < stop: yield start start += 1 if len(args) == 3: start, stop, step = args while start < stop: yield start start += step else: step = 1 if len(args) == 1: start = args[0] if len(args) == 2: start, stop = args for k, v in kwargs.items(): if k not in [‘start‘, ‘step‘, ‘stop‘]: raise (‘参数名错误‘) if k == ‘start‘: start = v elif k == ‘stop‘: stop = v elif k == ‘step‘: step = v while start < stop: yield start start += step for i in range(3): print(i) # 0,1,2 for i in range(99, 101): print(i) # 99,100 for i in range(1, 10, 3): print(i) # 1,4,7 for i in range(1, step=2, stop=5): print(i) # 1,3 for i in range(1, 10, step=2): print(i) # 1,3,5,7,9
把列表推导式的[]换成()就是生成器表达式 。
优点：省内存，一次只产生一个值在内存中
t = (i for i in range(10)) print(t) # <generator object <genexpr> at 0x00000000026907B0> print(next(t)) # 0 print(next(t)) # 1
举例：
with open(‘32.txt‘, ‘r‘, encoding=‘utf8‘) as f: nums = [len(line) for line in f] # 列表推导式相当于直接给你一筐蛋 print(max(nums)) # 2 with open(‘32.txt‘, ‘r‘, encoding=‘utf8‘) as f: nums = (len(line) for line in f) # 生成器表达式相当于给你一只老母鸡。 print(max(nums)) # ValueError: I/O operation on closed file.
递归的精髓在于通过不断地重复逼近一个最终的结果。
age(1)=26,age(n)=age(n-1)+2 ，求age(5)的值：
‘‘‘ ... age(5) = age(4) + 2 age(4) = age(3) + 2 age(3) = age(2) + 2 age(2) = age(1) + 2 age(1) = 26 age(n) = age(n-1) +2 age(1) = 26 # n=1 ‘‘‘ def age(n): if n == 1: return 26 res = age(n-1) + 2 return res print(f"age(5): {age(5)}")
递归的本质就是干重复的活。
lis = [1, [2, [3, [4, [5, [6, ]]]]]] def tell(lis): for i in lis: if type(i) is list: tell(i) else: print(i) tell(lis)
二分法的思想实现查找数字。
from random import randint nums = [randint(1, 100) for i in range(100)] nums = sorted(nums) def search(search_num, nums): print(nums) mid_index = len(nums) // 2 if not nums: print(‘not exists‘) return if search_num > nums[mid_index]: # in the right nums = nums[mid_index + 1:] search(search_num, nums) elif search_num < nums[mid_index]: # in the left nums = nums[:mid_index] search(search_num, nums) else: print(‘find it‘) search(7, nums)
原文：https://www.cnblogs.com/springsnow/p/11941822.html