“人造太阳”计划

Python学习day13-函数进阶（1） 闭包函数 闭包函数，从名字理解，闭即是关闭，也就是说把一个函数整个包起来。正规点说就是指函数内部的函数对外部作用域而非全局作用域的引用。 为函数传参的方式有常用有以下两种： 用参数的形式 xxxxxxxxxx 5 1 def func(x): 2 print(x) 3 4 func(1) 5 ​ 包给函数 xxxxxxxxxx 11 1 def outter(x): 2 x = 1 3 4 def inner(): 5 print(x) 6 return inner 7 f = outter(1)# outter的返回值为inner所以会执行到print(x) 8 ​ 9 f() 10 f() 11 ​ 闭包函数的应用 闭包的意义在哪呢，其返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得该函数无论在何处调用的时候，都会优先调用外层包裹的作用域。 其主要应用领域就在于延迟计算和爬虫领域，可以简化代码量，也会使代码更加的稳定。 装饰器 装饰器是一个逻辑上比较复杂的概念，所幸我们并不必追究太深，只需知道其使用方法和大概原理即可。 所以什么是装饰器呢，个人理解装饰器就是包裹在函数外面的另外一个函数，而且装饰器的起到对原函数增加功能的作用，且不影响原函数的调用和存在。 需要注意的是，装饰器本身其实是任意可调用的对象

一、闭包函数 简单来说闭包函数是传参的另外一种方式，将参数+函数包在一起返回出去。 1.两种为函数传参的方式 # 1.使用参数的形式 def func(x): print(x) func(1) func(1) # 2.包给函数 def outter(x): def inner(): print(x) return inner f = outter(1) f() f() 2.闭包函数的应用 闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。 应用领域：延迟计算（原来我们是传参，现在我们是包起来）、爬虫领域。 import requests def outter(url): def inner(): response = requests.get(url) print(f"done: {url}") return inner baidu = outter('www.baidu.com') python = outter('https://www.python.org') baidu() baidu() python() python() 二、装饰器 装饰器本质就是一个函数a，装饰的对象也是一个函数b，用一个函数a去装饰一个函数b 装饰器的实现必须遵循两大原则： 不修改被装饰对象的源代码

8.12 迭代器 定义 迭代器： 迭代的工具。迭代是更新换代，如你爷爷生了你爹，你爹生了你，迭代也可以说成是重复，并且但每一次的重复都是基于上一次的结果来的。 可迭代对象 python中，一切皆对象： x = 1 name = 'nick' lis = [1, 2] tup = (1, 2) dic = {'name': 'nick'} s1 = {'a', 'b'} f = open('49w.txt', 'w', encoding='utf-8) def func(): pass 对于这一切的对象中，但凡有 __iter__ 方法的对象，都是可迭代对象。 # 以下都是可迭代的对象 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__ 可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象。 特点： 内置有 __iter__ 方法的都叫可迭代的对象。 迭代器对象 只有字符串和列表都是依赖索引取值的，而其他的可迭代对象都是无法依赖索引取值的

迭代 for循环遍历的原理 for循环遍历的原理就是迭代，in后面必须是可迭代对象 1.可迭代对象 有 __iter__ 方法的对象，都是可迭代对象，有以下6种 可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象 "zx".__iter__() ["zx"].__iter__() {"zx":"wl"}.__iter__() ("zx",).__iter__() {"z","x"}.__iter__() with open("prize.txt","r") as file: file.__iter__() 2.迭代器对象 可迭代的对象执行 __iter__ 方法得到的返回值。并且可迭代对象会有一个 __next__ 方法 list=[1,2,3,4,5,6] zx=list.__iter__() while True: try: print(zx.__next__()) except: breakc 来源： https://www.cnblogs.com/zx125/p/11340680.html

#迭代器 迭代的工具,迭代是更新换代,也可以说成重复,可以基于上一次的结果推出下一次的结果 可迭代对象 python中一切皆对象,对这一切的对象中 但凡有 __iter__ 方法的对象，都是可迭代对象。 x = 1 # 不可迭代对象 s = 'nick' # 可迭代对象 s.__iter__() lt = [1, 2, 3] # 可迭代对象 dic = {'a': 1, 'b': 2} # 可迭代对象 tup = (1,) # 元组只有一个元素必须得加逗号# 可迭代对象 set = {1, 2, 3} # 可迭代对象 f = open('time.py') # 可迭代对象 def func(): # 不可迭代对象 pass Python内置str、list、tuple、dict、set、file都是可迭代对象.然后出了数字类型和函数之外都是可迭代对象 迭代器对象 具有 __iter__ 以及 __next__ 方法的叫做迭代器对象 s = 'nick' # 可迭代对象,不属于迭代器对象 s.__iter__() lt = [1, 2, 3] # 可迭代对象,不属于迭代器对象 dic = {'a': 1, 'b': 2} # 可迭代对象,不属于迭代器对象 tup = (1,) # 元组只有一个元素必须得加逗号# 可迭代对象,不属于迭代器对象 se = {1, 2, 3} #

闭包函数 闭包 闭包：闭是封闭（函数内部函数），包是包含（该内部函数对外部作用域而非全局作用域的变量的引用）。闭包指的是：函数内部函数对外部作用域而非全局作用域的引用。 额。。。这里提示一下闭包！=自闭 为函数传参的两种方式 使用参数的方式 def func(x): print(x) func(1) func(1) func(1) 1 1 1 包给函数 def outter(x): x = 1 def inner(): print(x) return inner f = outter(1) f() f() f() # 查看闭包的元素 print(F"f.__closure__[0].cell_contents: {f.__closure__[0].cell_contents}") 1 1 1 f.__closure__[0].cell_contents: 1 装饰器 什么是装饰器 器指的是工具，而程序中的函数就是具备某一功能的工具，所以装饰器指的是为被装饰器对象添加额外功能。因此定义装饰器就是定义一个函数，只不过该函数的功能是用来为其他函数添加额外的功能。 需要注意的是： 装饰器本身其实是可以任意可调用的对象 被装饰的对象也可以是任意可调用的对象 为什么要用装饰器 如果我们已经上线了一个项目，我们需要修改某一个方法，但是我们不想修改方法的使用方法，这个时候可以使用装饰器

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。 举个例子，我们来计算阶乘 n! = 1 x 2 x 3 x ... x n ，用函数 fact(n) 表示，可以看出： fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n 所以， fact(n) 可以表示为 n x fact(n-1) ，只有n=1时需要特殊处理。 于是， fact(n) 用递归的方式写出来就是： def fact(n): if n==1: return 1 return n * fact(n - 1) 上面就是一个递归函数。可以试试： >>> fact(1) 1 >>> fact(5) 120 >>> fact(100) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L 如果我们计算 fact(5) ，可以根据函数定义看到计算过程如下： ===> fact(5) ===> 5 * fact(4) ===> 5 * (4 *

1、为什么使用traits？ 　　考虑下面的需求，实现一个方法Advance(iter，n)，接收一个迭代器iter和移动距离n，将iter向前移动n个距离。 　　分析，因为存在不同类型的迭代器，做同一件事情，大家的能力不一样，做法当然不一样。有的迭代器可以一下子移到目标，有的迭代器只能一步一步移动，进行n次。因此，在方法内，必须要判断迭代器的类型，然后进行相应的操作。这种方法当然不好，运行期判断类型，需要核对继承层次中的每个类，效率差。有没有更好的办法呢？ 2、解决办法： 　　a、每个迭代器暴露一个接口，暴露自己类型的别名（使用typedef MyType Category），每个迭代器都使用相同的别名。再使用一个traits类模版，对迭代器封装，对外暴露迭代器类型的别名，也就是内部迭代器的类型别名（使用 typedef iter::Category Category）。 　　b、建立多个重载方法，根据迭代器类型的真名，进行重载。 　　c、在Advance方法内，对iter封装，根据类型别名，调用重载的方法。 3、分析编译器编译过程，看到Advance方法，对迭代器封装后，暴露的Category就是iter 的Category，也就是迭代器的类型别名，在编译时期，就可以知道迭代器的类型真名，因此，在编译期就可以确定下来调用哪个重载方法。 4、其实这种场景，如果是自己的代码

#函数 --2天 #函数的定义和调用 #def 函数名(形参) #函数体 #return返回值 #调用 函数名(实参) #站在形参的角度上:位置参数,*args,默认参数(陷阱),**kwargs #站在实参的角度上:按位置传,按照关键字传 #返回值:没有返回值 返回一个值 返回多个值 #接收返回值:没有返回值不接收,返回一个值作一个变量接收,返回多个值用一个变量或者对应数目变量接收#闭包函数 --在内部函数引用外部函数的变量#装饰器函数 --装饰器一定是闭包函数 #装饰器的作用 --在不改变原来函数的调用方式的情况下,在这个函数前后添加新的功能 #完美的符合了一个开发原则:开放封闭原则 #对扩展是开发的 #对修改是封闭的 #基础的装饰器 # from functools import wraps # def wrapper(func): # @wraps(func) # def inner(*args,**kwargs): # '''在函数被调用之前添加的代码''' # ret=func(*args,**kwargs) #func是被装饰的函数,在这里被调用 # return ret # return inner # 使用---@wrapper # def func(): #inner # pass #func name # 带参数的装饰器 def outer(形参): def

__getitem__ 单独实现这个魔法函数，可以让这个类成为一个可迭代的对象，并且可以通过使用下标获取类中元素值下标的元素 class Library(object): def __init__(self): self.books = [1, 2, 3] self.index = -1 def __getitem__(self, i): return self.books[i] # def __iter__(self): # return self # # # def __next__(self): # self.index += 1 # if self.index > len(self.books)-1: # raise StopIteration() # return self.books[self.index] l = Library() print(l[1]) for i in l: print(i) __iter__ 这个是返回一个可迭代的对象，如果一个类实现了这个魔法函数，那么这个类就是可迭代对象，并且实现了__next__这个魔法函数的话，可以通过for循环遍历；__next__如果单独实现了这一个魔法函数，只能通过next()调用 class Library(object): def __init__(self): self.books = [1, 2, 3]