标签：数据 匿名 content 生效 timer lob 表达 sdfs oba
1、什么是函数：函数就是封装一个功能。（程序中如果没有函数的引用，会产生重复代码多，可读性差的特点。）
2、函数的定义：def 关键词开头，空格之后接函数名称和圆括号()
l1 = [1,2,3,4] def my_len(): # def 关键字 定义一个函数 # my_len 函数名书写规则与变量一样 # def与函数名中间一个空格 # 函数名（）：加上冒号 # 函数体 count = 0 for j in l1: count += 1 print(count) my_len()
l1 = [1,2,3,4] def my_len(): count = 0 for j in l1: count += 1 return count print(my_len()) # 函数的返回值： # 写函数，不要在函数中写print（） # return # 1、在函数中，遇到return结束函数。 # 2、将返回值给函数的调用者。 # 无 return = return None # return 1个值 该值是什么，就直接返回给函数的调用者，函数名（） # return 多个值，将多个值放到一个元组中，返回给函数的调用者。
函数分为形参和实参：
形参：形式参数，不代表实际的变量。
实参：实际参数，带入形参中的变量。
形参传参：1、位置传参。按顺序，一一对应。
2、默认参数。传参则覆盖，不传则默认，默认参数永远在位置参数的后面。
形参传参：1、位置传参。按顺序，一一对应。
2、关键字传参，不按顺序，一一对应。
3、混合传参，关键字参数永远在位置参数的后面。
形参传递顺序：位置参数，*args，默认参数，**kwargs
def test(a, *args, **kwargs): print(a) # 1 print(args) # (2, 3) print(kwargs) # {‘e‘: 5, ‘d‘: ‘4‘} test(1, 2, 3, d=‘4‘, e=5) # 1还是参数a的值，args表示剩余的值，kwargs在args之后表示成对键值对。
# * 魔法运用 def func(*args): print(args) l1 = [1,2,30] l2 = [1,2,33,21,45,66] tu = (1,2,3) func(1,2,30,1,2,33,21,45,66) # (1, 2, 30, 1, 2, 33, 21, 45, 66) func(*‘qweqrfdsaf‘) # (‘q‘, ‘w‘, ‘e‘, ‘q‘, ‘r‘, ‘f‘, ‘d‘, ‘s‘, ‘a‘, ‘f‘) func(*{‘name‘:‘alex‘,"age":12}) # (‘name‘, ‘age‘) func(*l1,*l2) # (1, 2, 30, 1, 2, 33, 21, 45, 66) def func(*args): print(args) func(1,2,3,10,20,80) # (1, 2, 3, 10, 20, 80) def func(**kwargs): print(kwargs) dic1 = {‘name1‘:‘alex‘,‘age1‘:46} dic2 = {‘name‘:‘老男孩‘,‘age‘:56} func(**dic1,**dic2) # {‘age1‘: 46, ‘name1‘: ‘alex‘, ‘name‘: ‘老男孩‘, ‘age‘: 56} # 在函数的调用执行时， # *可迭代对象，代表打散(list,tuple,str,dict(键))将元素一一添加到args。 # **字典，代表打散，将所有键值对放到一个kwargs字典里。 # 在函数定义时， *args，**kwargs代表的是聚合。 def func(*args,**kwargs): print(args) print(kwargs) dic1 = {‘name1‘:‘alex‘,‘age1‘:46} dic2 = {‘name‘:‘老男孩‘,‘age‘:56} func(*[1,2,3,4],*‘asdfsad‘,**dic1,**dic2) # (1, 2, 3, 4, ‘a‘, ‘s‘, ‘d‘, ‘f‘, ‘s‘, ‘a‘, ‘d‘) # {‘name‘: ‘老男孩‘, ‘name1‘: ‘alex‘, ‘age‘: 56, ‘age1‘: 46}
def func1(): """ 此函数是完成登陆的功能，参数分别是...作用。 :return: 返回值是登陆成功与否（True，False） """ print(666) return True func1() # 666 print(func1.__name__) # func1 print(func1.__doc__) # 显示注释内容
命名空间的本质：存放名字与值的绑定关系
命名空间一共分为三种：
全局命名空间：代码在运行伊始，创建的存储“变量名与值的关系”的空间
局部命名空间：在函数的运行中开辟的临时的空间
内置命名空间：存放了python解释器
三种命名空间之间的加载与取值顺序：
加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
取值：在局部调用：局部命名空间->全局命名空间->内置命名空间
在全局调用：全局命名空间->内置命名空间
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
全局作用域（globals）：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域（locals）：局部名称空间，只能在局部范围内生效
global关键字
#global # 1,在局部空间内，声明一个全局变量 def func1(): global name name = ‘老男孩‘ print(name) # 老男孩 func1() print(name) # 老男孩 # 2,在局部空间内改变一个全局变量 a = 4 def func1(): global a # 5 a = 5 func1() print(a)
nolocal关键字
#nonlocal # 1,不能修改全局变量。 #在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改， # 并且引用的哪层，从那层及以下此变量全部发生改变。 a = 4 def func1(): b = 6 def func2(): b = 666 print(b) # 666 func2() print(b) # 6 func1() b = 4 def func1(): b = 6 def func2(): nonlocal b b = 666 print(b) # 666 func2() print(b) # 666 print(b) # 4 func1()
# 函数名是函数的名字，本质：变量，特殊的变量。 # 1,单独打印函数名 <function func1 at 0x0000000000872378> def func1(): print(666) print(func1) # <function func1 at 0x0000000000872378> a = 6 print(a) # 6 # 2、函数名的赋值 def func2(): print(666) f = func2 f() # 666 # 3、函数名可以作为容器类数据的元素 def f1(): print(1211) def f2(): print(1222) def f3(): print(1233) def f4(): print(1233) l1 = [f1, f2, f3, f4] for i in l1: i() # 4、函数名可以作为参数 a = 1 def f1(x): print(x) # 1 f1(a) def f1(): print(666) def f2(x): # x = f1 x() # f1() f2(f1) # 5、函数名可以作为函数的返回值 def wraaper(): def inner(): print(666) return inner ret = wraaper() # inner ret() # inner()
闭包：就是内层函数对外层函数（非全局）变量的引用。
闭包：当函数开始执行时，如果遇到闭包，他又一个机制，他会永远开辟一个内存空间，将闭包中的额变量等值放入其中，不会随着函数的执行完毕而消失。
判断是不是闭包：内层函数名.__closure__ 结果是:cell...就是闭包
name = ‘老男孩‘ def wraaper2(n): # n = ‘老男孩‘ def inner(): print(n) # 老男孩 inner() print(inner.__closure__) # (<cell at 0x000001E3F9123B28: str object at 0x000001E3F9010F30>,) wraaper2(name)
开放封闭原则：
1、对扩展是开放的
2、对修改是封闭的
装饰器主要功能和装饰器固定结构：在不改变函数调用方式的基础上在函数的前、后添加功能。
装饰器固定格式
def timer(func): def inner(*args,**kwargs): ‘‘‘执行函数之前要做的‘‘‘ re = func(*args,**kwargs) ‘‘‘执行函数之后要做的‘‘‘ return re return inner
带参数的装饰器
def outer(flag): def timer(func): def inner(*args,**kwargs): if flag: print(‘‘‘执行函数之前要做的‘‘‘) re = func(*args,**kwargs) if flag: print(‘‘‘执行函数之后要做的‘‘‘) return re return inner return timer @outer(False) def func(): print(111) func()
多个装饰器装饰同一个函数
def wrapper1(func): def inner(): print(‘wrapper1 ,before func‘) # 第二步 func() print(‘wrapper1 ,after func‘) # 第四步 return inner def wrapper2(func): def inner(): print(‘wrapper2 ,before func‘) # 第一步 func() print(‘wrapper2 ,after func‘) # 第五步 return inner @wrapper2 @wrapper1 def f(): print(‘in f‘) # 第三步 f()
可迭代协议：可以被迭代要满足的要求，可以将某个数据集内的数据“一个挨着一个的取出来”，就叫做迭代，内部实现了__iter__方法
迭代协议：必须拥有__iter__方法和__next__方法
迭代器的好处：
1、节省内存空间。
2、满足惰性机制。
3、不能反复取值，不可逆。
可迭代计算过程：
1、将可迭代对象转化成迭代器
2、内部使用__next__方法取值
3、运用了异常处理去处理报错。
l2 = [1, 2, 3, 4, 5, 6, 7, 8] l2_obj = l2.__iter__() while True: try: i = l2_obj.__next__() print(i) except Exception: break
生成器：生成器本质上是迭代器。
初始生成器：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
生成器函数定义：
1、一个包含yield关键字的函数就是一个生成器函数
2、next 和send 功能一样，都是执行一次，send获取下一个值可以给上一个yield赋值。
使用send的注意事项：第一次使用生成器的时候，使用next获取下一个值，最后一个yield不能接受外部的值
def generator(): print(123) # 123 content = yield 1 print(content) # hello print(456) #456 yield 2 g = generator() g.__next__() g.send(‘hello‘)
1、列表推导式：用列表推导式能够构建的任何列表，用别的都可以构建，一目了然，占内存。
l2 = [i*i for i in range(1,11)] print(l2) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2、生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表，不易看出，节省内存。
l_obj = (‘python%s期‘ % i for i in range(1,12)) print(l_obj) # <generator object <genexpr> at 0x000001AAF0AEBDB0> print(l_obj.__next__()) # python1期 print(l_obj.__next__()) # python2期 print(l_obj.__next__()) # python3期
总结：
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可 以直接这样计算一系列值的和：
标签：数据 匿名 content 生效 timer lob 表达 sdfs oba
原文地址：https://www.cnblogs.com/qiujie/p/8977972.html
