函数的概述

  • 什么是函数？
    • 函数就是封装了一段准备好代码，在需要的时候可以被重复使用；
  • 注意的地方：
    • 函数的声明：使用关键字def来声明一个函数；
    • 函数的命名：建议使用小写单词组成，单词之间用_下划线链接，不能重名, 如果重名了, 后一个函数会覆盖前一个函数；

      无参函数

  1. def tell_story():                          # 无参
  2.     print('从前有座山')
  3.     print('山上有座庙')
  4.     print('......')
  6. age = int(input('请输入小孩子的年龄：'))
  8. if 0 < age < 5:
  9.     if 0 < age < 3:
  10.         print('孩子太小了，听不懂故事！')  
  11.     else:
  12.         tell_story()                       # 这里直接调用函数
  13. elif age <= 0:
  14.     print('请输入正确的年龄')
  15. else:
  16.     print('孩子长大了')
  1. def test1():
  2.     print('123') 
  4. test1()                  # 没有定义任何参数，直接调用test1()函数，执行print()，有print，则屏幕显示‘123’  
  5. print('------')
  6. print(test1())           # 使用外部print()打印test1()函数，首先是执行函数体的print()，由于test1()函数中没有指定返回值，所以外部print()将None打印到屏幕

有参函数 (函数中带上参数变量)

常见的报错情况有：

  • 设定函数的, 参数没有指定默认值时，调用函数没有填入该参数，则报错！
  • 调用函数时, 没有按照定义函数的参数位置和顺序一 一对应填入，则报错！
  • 位置参数需要放在关键字参数的后面，报错！
  • 输入实参与形参数据类型不一致，报错！

    位置参数 (不带默认值)

    1，位置参数：调用函数时根据函数定义的参数位置来传递参数；
    2，定义函数时，指定的参数叫做“形参”，主要用来占位的；函数只有被调用，才会被执行，调用时传入的参数称之为：实参；
    3，调用函数时, 传递的实参和函数定义中的形参位置及顺序必须一致，顺序出错就会抛出异常提示：SyntaxError: non-default argument follows default argument； ```python def buy_water(money,name): print(‘{}每瓶售价{}元’.format(name,money))

buy_water(10,’康师傅矿泉水’) # 函数调用时，实参的位置和顺序必须一 一对应传递；

  2. ```python
  3. def get_birthday(id):            # 定义函数名称并设定参数
  4.     birthday = id[6:14]          # 函数运算过程
  5.     print(birthday)              # 函数运算过程
  7. get_birthday('110123199001012121')       # 调用函数
  8. get_birthday('120122199508081321')       # 调用函数

关键字参数 (带默认值)

1，关键字参数：通过“建 = 值”的形式定义参数；
2，定义形参，传递实参，对位置和顺序没有要求，都可以任意顺序写入；
3，如果形参指定了默认值，调用时传入，则使用传入的值，如果不传入，则使用默认值；
4，如果形参没有指定默认值，则按位置参数传递实参，否则程序会抛出异常;
5，调用函数时，位置参数必须放在关键字参数的前面；

  1. # 定义函数时，希望某些参数可以省略，例如: 通过身份证号码，获取出生日期或者年龄，则可以通过设定一个参数来控制函数如何返回结果, 比如下方代码中的get_age,使用True和False进行判断后输出.
  2. def get_birthday(id,age = False):                  # 设定参数, age为关键字参数, 默认值为False
  3.     if age == True:                                # 对关键字参数进行判断
  4.         return 2020-int(id[6:10])                  # 返回计算公式的计算结果
  5.     else:
  6.         year = id[6:10]                            # 函数运算过程
  7.         month = id[10:12]                          # 函数运算过程
  8.         day = id[12:14]                            # 函数运算过程
  9.         return year, month, day                    # 返回多个变量值
  11. # 传入，则使用传入的值
  12. result = get_birthday('42058119870601101X',True)     # 调用函数，输入2个参数,输入True,满足条件,则执行if语句下的代码
  13. print(result)                                     
  15. # 不传入，则使用默认值
  16. result = get_birthday('42058119870601101X')          # 调用函数，省略第2个参数，注意：如果第2个参数原本没有赋默认值，省略的话，则会报错！
  17. print(result)
  1. # 调用函数时，传入参数，则使用传入的值，不传入参数，则使用默认值
  2. def sleep(name,time=8):
  3.     print('{}睡了{}小时'.format(name,time))
  5. sleep('小明',12)
  1. def sleep(name,time=8,age=20 ):
  2.     print('{}今年{}岁，今天中午睡了{}小时'.format(name,age,time))
  4. sleep('小明',12)           # 函数调用时，传入参数，则使用传入的值，不传入参数，则使用默认值
  5. sleep('小明',age=12)       # 如果想把12赋值给age, 则需要结合关键字的key来使用
  1. def tt(a,b=2,c=3):
  2.     print('a=',a,'b=',b,'c=',c)
  4. tt('x','y')
  5. tt(1)
  6. tt('x',c='y',b='z')

传入错误类型的参数

定义函数，往往对输入的参数有类型的要求，当输入了错误的类型，也会有异常发生；

  1. # 例如，我们定义一个减法运算的函数，参数为两个整数
  2. def subtraction1(num1,num2):        
  3.     result=num1-num2                
  4.     return result                   
  6. print(subtraction1(3,2)) 
  8. # 上方代码中，调用函数时输入了两个整数，运行正常，接下来，如果输入错误的参数，比如两个字符：print(subtraction('3','2'))
  9. # 程序抛出异常，TypeError：unsupported operand type(s) for -: ‘str’ and ‘str’，提示内容为类型错误，不支持的操作数类型：'str’和'str’
  10. # 所以我们可以自定义这个异常的提示，我们知道，整数与小数可以支持减法，那么在函数中就可以通过判断传入的参数类型是否是这两种类型，如果不是，就给出异常提示：
  12. def subtraction2(num1,num2):                 
  13.     if not isinstance(num1,(int,float)) or not isinstance(num2,(int,float)):        # 判断参数是否为指定类型
  14.         raise TypeError('参数类型错误，参数必须为整数或者小数')                           # 设定自定义异常内容
  15.     result = num1 - num2                                                          
  16.     return result                                                                 
  18. # print(subtraction2('3',2))                                                          # 调用函数,程序抛出异常
  20. # 上方代码中，使用内置函数isinstance( )对输入的参数值进行类型的比较，当任何一个参数不是int（整数）或者float（小数）类型时，都将抛出异常
  21. # 关键字raise用于引发异常，TypeError( )为异常的类型，括号中可以输入自定义的异常提示；

位置参数包装传递【元组型不定长参数】

不定长参数也叫可变参数：用于在不确定调用的时候会传递多少个参数的情况下（不传参也可以），这些参数被包装进一个元组中，被包装的参数可以是位置参数，也可以是关键字参数；

  1. # 包装位置参数传递
  2. def user(*args):              # 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并成一个元组，args是元组类型，这就是包裹位置传递
  3.     print(args)
  5. user()                       # ()
  6. user('zhangsan')             # ('zhangsan',)
  7. user('zhangsan',18)          # ('zhangsan', 18)
  8. user('zhangsan',18,'man')    # ('zhangsan', 18, 'man')
  9. print('=============================\n')
  11. def arithmetic_mean(*args):       # 加了星号 * 的args参数就会以元组(tuple)的形式导入    
  12.     sum = 0
  13.     for x in args:
  14.         sum += x
  15.     return sum                    # 输入结果是一个元组，然后求元组中所有数值相加之和
  17. print(arithmetic_mean())
  18. print(arithmetic_mean(45))
  19. print(arithmetic_mean(45,32))
  20. print(arithmetic_mean(45,32,89,78))
  21. print(arithmetic_mean(8989.8,78787.78,3453,78778.73))
  22. print('=============================\n')
  24. def print_number(a,b,*args):                  
  25.     print(a,b)
  26.     print(args)       
  27.     print(type(args))
  28.     c = a + b
  29.     for i in args:
  30.         c += i                      
  31.     return c
  33. x = print_number(1,2,10)
  34. print(x)  
  35. print('=============================\n')
  37. def func(a,b,*,c):                  # 声明函数时，参数中星号 * 可以单独出现, 如果单独出现星号, * 后的参数必须用关键字传入
  38.     return a + b + c
  40. y = func(1,2,c=3)
  41. print(y)                            # * 后的参数必须用关键字传入

关键字包装参数传递【字典型不定长参数】

传入的是多个关键字参数，在调用函数时, 使用**dic这种方式，实际上是将字典的键值对（key:values）拆包成了 (key=values) 关键字参数形式进行传递

  1. def user(**kwargs):              # 无论是包裹位置参数传递还是包裹关键字参数传递，都是一个组包的过程
  2.     print(kwargs)
  4. print('==========包装关键字参数传递============')
  5. user(name = 'zhangsan')           
  6. user(name = 'zhangsan',age = 18)        
  7. user(name = 'zhangsan',age = 18,gender = 'man')  
  10. dic1 = {'A':111,'B':222,'C':333}
  12. def test1(a,b,**kwargs):                 # **kwargs表示关键字参数（就是在调用的时候必须传入带赋值的实参），随便传入多少个都可以，实际上kwargs以字典的形式导入  ---装包的过程
  13.     print(a)
  14.     print(b)
  15.     print(kwargs)
  16.     print(type(kwargs))
  18. print('\n==========按照关键字参数传递============')
  19. test1(100,200,name='张三',age='22')       # 调用时，必须传递关键字参数，按照key=value的形式传递
  21. print('\n==========将字典作为实参传入============')
  22. test1(100,200,**dic1)                     # 将字典作为实参传入时，使用**dic这种方式 (实际上就是将字典的键值对（key:values）拆包成(key=values)  ----拆包的过程

参数传递顺序

如果一个函数中，有必备参数，默认参数，不定长参数，关键字不定长参数，需要注意这几个参数的先后顺序；

  1. def total(name,age=10,*args,**kwargs):
  2.     print(name,age,args,kwargs)
  4. total('小红')                                                 # 小红 10 () {}
  5. total('小明', 22, 1,2,3,4,5,phone=110,sex='男')               # 小明 22 (1, 2, 3, 4, 5) {'phone': 110, 'sex': '男'}

拆包与装包

  1. print('==========拆包：元组============')
  2. def test1():
  3.     return 100,200
  5. x,y = test1()
  6. print(x)
  7. print(y)
  9. print('\n==========拆包：字典============')
  10. dic1 = {'name':'tom','age':18}
  11. a,b = dic1                      # 对字典进行拆包，取出来的是字典的key，后续可以通过可以找到对应的values
  13. print(a,dic1[a])
  14. print(b,dic1[b])
  1. def test1(a,b=20,*args,**kwargs):
  2.     print(a,b,args,kwargs)
  4. list1 = [3,4,5,6]
  6. dic1 = {'A':100,'B':200,'C':300}
  8. print('\n【如果列表没有被拆包传递】，则整个列表会作为元组中的一个元素输出：')  
  9. test1(10,30,list1,x=88,y=99)                                    # 10 30 ([3, 4, 5, 6],) {'x': 88, 'y': 99}
  11. print('\n【如果列表拆包后传递】，则列表就会转换成元组后输出：')                        
  12. test1(10,30,x=88,y=99,*list1)                                   # 10 30 (3, 4, 5, 6) {'x': 88, 'y': 99}
  14. print('\n【如果字典没有拆包传递】, 则整个字典会作为元组中的一个元素输出：')   
  15. test1(10,30,dic1,x=88,y=99)                                     # 10 30 ({'A': 100, 'B': 200, 'C': 300},) {'x': 88, 'y': 99}
  17. print('\n【如果字典拆包后传递】，则会将字典的键值对（key:values）拆包成(key=values) 的形式后传递给函数：') 
  18. test1(10,30,x=88,y=99,**dic1)                                   # 10 30 () {'x': 88, 'y': 99, 'A': 100, 'B': 200, 'C': 300}
  1. # 传入的是一个列表, --> 对列表拆包 --> 在函数中装包成一个元组
  2. list1 = ['c++','java','mysql','html']
  4. def func1(name,*args):                       # 传递进来的列表元素装包成了一个元组, *args = ('c++','java','mysql','html')
  5.     if len(args) > 0:
  6.         for i in args:
  7.             print('{}学过了{}'.format(name,i))
  8.     else:
  9.         print('没有学过任何编程')
  11. func1('小明',*list1)                           # 将列表拆包后传递给函数

可变与不可变数据类型

  • 不可变：变量引用的数据类型，在更改数值的时候，不存在不开辟新内存 的行为，此数据类型为不可变数据类型。【字符串，整型，浮点型，元组，不可变集合】
  • 可变：变量引用的数据类型，在更改数值的时候，存在不开辟新内存 的行为，此数据类型为可变数据类型。【列表，字典，可变集合】 ```python print(‘不可变数据类型测试结果如下：’) s1 = ‘abc’ s2 = s1 # 此时，s1和s2指向的同一块内存地址

print(s2) # abc print(id(s1)) # 140001141830448 print(id(s2)) # 140001141830448

s1 = ‘def’
print(id(s1)) # 140001140882032【不可变数据类型 重点】 print(id(s2)) # 140001141830448 print(s2) # 打印出来还是‘abc’,字符串是不可变数据类型，如果要改变，则需要重新分配内存空间进行修改存储，所以，s1会发生了变化，而s2保持不变

print(‘\n可变数据类型测试结果如下：’) list1 = [1,3,4,5,7,9] list2 = list1 # 此时，list2和list1指向的同一块内存地址

print(list2) # [1, 3, 4, 5, 7, 9] print(id(list1)) # 140000683211904 print(id(list2)) # 140000683211904

list1.remove(5) # 当list1中发生了变化，list2也会随之改变 print(id(list1)) # 140000683211904 print(id(list2)) # 140000683211904 print(list2) # 打印出来没有5

  2. ```python
  3. # 交换两个变量的值
  4. a = 13
  5. b = 20
  7. # 方法一：使用第三个变量实现
  8. # c = b
  9. # b = a
  10. # a = c
  12. # 方法二：使用运算符来实现，只能是数字
  13. # a = a + b
  14. # b = a - b
  15. # a = a - b
  17. # 方法三：python独有的方法
  18. a,b = b,a
  19. print(a,b)

return 语句

return 的特点

  1. def test1():        # 特点1：函数结束时没有使用 return 语句，调用函数时返回None
  2.     s = 1 + 2
  4. def test2():        # 特点2：return 语句不带任何参数，调用函数时返回None
  5.     s = 1 + 2
  6.     return
  7. x = test2()         # 特点3：函数有返回值，那么调用函数时，需要使用一个变量来接收它
  9. def test3():
  10.     return 1        # 特点3：结束当前函数，该语句之后的语句将不再被执行，return 1 执行完后，退出当前函数，return 2不会被执行
  11.     return 2
  1. def test4(a):
  2.     print('uuuuuuu')
  3.     if a == 10:
  4.         return            # 条件满足，执行到return语句时，函数终止，后边的语句不再执行，注意，这里的return后面没有任何代码！
  5.     print('kkkkkk')
  7. test4(10)
  1. # 执行到return语句时，会退出函数，return之后的语句不再执行，但将return放在try语句块中，就会执行;
  2. def test1():
  3.     print('98')
  4.     return 'ok'         # 执行到该return语句时，函数终止，后边的语句不再执行
  5.     print('100')
  6. def test2():
  7.     try:
  8.         print('98')
  9.         return 'ok'     # 函数得到了一个返回值
  10.     finally:            # finally语句块中的语句依然会执行
  11.         print('100')
  13. print(test1())
  14. print('----------')
  15. print(test2())
  1. # 1，定义函数，求（n，m）之间的所有整数之和
  2. def add(n,m):
  3.     x = 0
  4.     for i in range(n,m):
  5.         x += i
  6.     return x
  8. result = add(1,5)   # 1+2+3+4=10
  9. print(result)
  1. # 2, 定义函数，求一个数n的阶乘   比如：n=5 ===> 1x2x3x4x5=120
  2. def fac(n):
  3.     x = 1                      # 这里的容器变量初始化不能等于0，如果为0，0乘任何数都为0了
  4.     for i in range(1,n+1):
  5.         x = x * i
  6.     return x
  8. result = fac(5)
  9. print(result)
  1. # 3, 计算m阶乘的和   比如：m=5 ===>  1!+2!+3!+4!+5!
  2. def fac_sum(m):
  3.     x = 0
  4.     for i in range(1, m + 1):
  5.         x += fac(i)
  6.     return x
  8. result1 = fac_sum(5)
  9. print(result1)

return的返回值作为参数传递

  1. def test1():
  2.     return 100
  4. def test2(a):
  5.     return a + test1()
  7. x = test1()     # 保存函数test1的值
  9. y = test2(x)    # 将函数返回值所在的变量作为参数传递给test2使用
  11. print(y)

return返回一个值

  1. def test1(a,b):
  2.     s = a + b
  3.     return s         
  5. x = test1(100,200)            # 既然使用return，就应该使用一个变量来接收这个返回值
  6. print(x)                      # 这个返回值可以使用print()打印出来

return返回多个值

当函数返回多个结果时：可以以列表，元组，字典的形式返回；

  1. # 通过if条件判断后，可以使用多个return语句来返回满足条件的值
  2. def test1(a:int,b:int,c=0,d=False):
  3.     s1 = a - b
  4.     s2 = b - a
  5.     s3 = a + b + c
  7.     if d:   
  8.         return {'A':s1,'B':s2,'C':s3}   # 以字典的形式返回多个值    
  10.     elif a > b:                         # 默认以元组的形式返回多个值
  11.         return a,b,s1   
  13.     elif a < b: 
  14.         return [a,b,s2]                 # 以列表的形式返回多个值  
  16.     else:
  17.         return a,b,c
  20. result1 = test1(2,1)                     # 关键字没有传入,则是用默认值，如果使用一个变量接收，则多个结果以元组的形式返回  
  21. print('当a>b（返回元组型数据:）--->',result1)
  23. result2 = test1(1,2)                           
  24. print('当a<b（返回列表型数据:）--->',result2)
  26. result3 = test1(2,5,d = True)        
  27. print('当d=True（返回字典型数据:）--->',result3)
  29. x,y,z = test1(1,1,1)                     # 如果使用多个变量接收，则一对一接收每个返回的结果
  30. print('当a=b（多变量接收返回）--->',x,y,z)
  1. def get_birthday(id):            
  2.     year = id[6:10]            
  3.     month = id[10:12]         
  4.     day = id[12:14]           
  5.     return year, month, day                  
  7. birthday = get_birthday('110123199001012121')   
  8. print(birthday)                               
  10. y,m,d = get_birthday('110123199001012121')    
  11. print('您的出生日期是%s年%s月%s日. '%(y,m,d))

return返回一个函数【闭包】

  1. def test1(*args):
  2.     def sum():
  3.         x = 0
  4.         for i in args:
  5.             x = x + i
  6.         return x 
  7.     return sum               # 返回一个函数名
  10. test1(1, 2, 3, 4, 5)         # 调用test1(), 此时该函数并没有执行，而是返回一个指向求和的函数名sum的内存地址，此时，test1 = test1.sum
  12. y = test1(1, 2, 3, 4, 5, 6, 7, 8, 9)
  14. print(type(y))
  15. y()                          # 调用y()函数，实际上就是调用sum()进行求和，这就是闭包.
  1. def count():
  2.     fs = []
  3.     for i in range(1, 4):
  4.         def f():
  5.             return i * i
  6.         fs.append(f)
  7.     return fs              # 返回一个列表
  9. f1, f2, f3 = count()
  10. print(f1())
  11. print(f2())
  12. print(f3())

执行过程：

  • 当i=1, 执行for循环， 结果返回函数f的函数地址，存在列表fs中的第一个位置上;
  • 当i=2, 由于fs列表中第一个元素所指的函数中的i是count函数的局部变量，i也指向了2; 然后执行for循环， 结果返回函数f的函数地址，存在列表fs中的第二个位置上;

  • 当i=3, 同理，在fs列表第一个和第二个元素所指的函数中的i变量指向了3；然后执行for循环，结果返回函数f的函数地址，存在列表fs中的第三个位置上，所以在调用f1()的时候,函数中的i是指向3的

    1. f1():
    2.   return 3*3

  • 同理f2( ), f3( )结果都为9;

  • 闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量,即包在里面的函数(本例为f())，不要引用外部函数(本例为count())的任何循环变量.，如果一定要引入循环变量，方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变： ```python def count(): fs=[ ] for i in range(1,4):
    1.   def f(j):
    2.       def g():
    3.           return j*j
    4.       return g
    5.   fs.append(f(i))
    return fs

f1,f2,f3=count() print(f1()) print(f2()) print(f3())

  2. <a name="fb6128e2"></a>
  3. ## 全局变量和局部变量
  5. ---
  7. - **关键字: global  nonlocal**
  8.    - 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
  9. -  **变量作用域（LEGB）：局部 -> 外层 -> 全局 -> 内置**
  10.    - L：local 本地，局部变量，内部函数变量
  11.    - E：encloseing  外层函数变量
  12.    - G：global 全局变量
  13.    - B：built-in 内置变量
  14. -  通过以下实例，你可以清楚了解Python函数变量的作用域： 
  15. ```python
  16. # a,b,c为全局变量，在整个py文件中都可以访问
  17. a = 100                                
  18. b = '你好'
  19. c = [1,2,3,4]                              # 列表属于可变类型
  21. def test():   
  22.     x = 123                                # 在函数内部定义的变量叫作局部变量，只能在函数内使用                            
  23.     print('内部变量x=',x) 
  25.     y = ['A','B','C']                    
  26.     print('内部变量y=',y)             
  28.     a = 111                                # 如果局部变量和全局变量同名，则函数内部的变量为全新定义的一个变量，这里不会修改全局变量的值                                              
  29.     print('内部变量a=',a)  
  31.     global b                               # 在函数内修改全局不可变类型的数据，使用global关键字,修改之后，全局变量也会随之改变                           
  32.     b = '再见'                           
  34.     c.append(88)                           # 在函数内可以修改全局中的可变数据类型数据（如：列表），不需要使用global关键字                             
  35.     print('修改c之后的结果为：',c) 
  37.     def test1():       
  38.         nonlocal x                         # 在内部函数中可以修改外部函数中不可变类型的数据，使用nonlocal关键字,如果没有就继续往上直到找到为止
  39.         x += 4
  40.         print('修改内部函数中x之后的结果为：',x) 
  42.         y.append('DD')                     # 在内部函数中可以修改外部函数中可变类型的数据，不需要使用关键字
  43.         print('修改y之后的结果为：',y)      
  45.     test1()                                # 注意，有函数嵌套的情况下，内层函数必须调用一下才行
  47. # 调用函数 
  48. print('全局变量a=',a)
  49. print('全局变量b=',b)                       # 这里可以看见，在函数内对全局变量的修改已生效。’你好‘===》’再见‘
  50. test()
  51. print('调用函数之后全局变量b=',b)
  53. # print('locals = {},globasl = {}'.format(locals(),globals()))  # 内置函数 globals() 和 locals() 可以查看全局变量和局部变量，以字典的形式输出

函数嵌套

  • 函数的嵌套调用是在函数调用中再调用其它函数.
  • 函数嵌套允许在一个函数中调用另外一个函数，比如有三个函数： ```python NAME = ‘nichoulas’ # 1 -> 首先执行NAME = ‘nicholas’语句

def jack(): # 2 -> 加载def jack():函数到内存进行编译，但不执行
name =’jack’ # 3.1 -> 执行name = “jack”语句 print(‘a,—->’,name) # 3.2 -> 执行print(name)语句，这里由于没有global关键字，优先读取局部变量name = “jack”，所以这里输出jack

  1. def pony():                    # 3.3          -> 加载def pony():函数到内存进行编译，但不执行
  2.     name = 'pony'              # 3.3.1        -> 执行name = "pony"语句，这里是一个局部变量
  3.     print('b,--->',name)       # 3.3.2        -> 执行print语句，这里由于没有global、nonlocal关键字，优先读取局部变量name = "pony"，所以这里输出pony
  5.     def charles():             # 3.3.3        -> 加载charles():函数到内存进行编译，但不执行
  6.         name = 'charles'       # 3.3.3.1      -> 执行name = 'charles'语句，这里是个局部变量
  7.         print('c,--->',name)   # 3.3.3.2      -> 执行print(name)语句，优先读取局部变量name = "charles"，所以这里输出charles
  9.     print('d,--->',name)       # 3.3.4        -> 执行print语句，这里由于没有global、nonlocal关键字，优先读取同一层级的局部变量name="pony"，所以这里输出pony
  11.     charles()                  # 3.3.5        -> 调用charles():函数，开始执行
  13. pony()                         # 3.4          -> 调用pony():函数，开始执行
  14. print('e,--->',name)           # 3.5          -> 执行执行print(name)语句，优先使用同层级的局部变量name = "jack",所以这里输出jack

jack() # 3 -> 调用jack()函数，开始执行

执行顺序：1——2——3——3.1——3.2——3.3——3.4——3.3.1——3.3.2——3.3.3——3.3.4——3.3.5—3.3.3.1—3.3.3.2——3.5

  2. ```python
  3. def outer():
  4.     def inner():
  5.         print('inner')
  6.     print('outer')
  7.     inner()             # 函数有可见范围，这就是作用域的概念。内部函数不能被外部直接使用
  9. outer()
  1. # 函数嵌套综合实验
  3. # 用户登录
  4. # 输入用户名
  5. # 输入密码
  6. # 输入验证码
  8. import random
  10. # 定义生成验证码的函数
  11. def generate_checkcode(n):
  12.     s = '0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
  13.     code = ''                     # 用一个空字符串来接收产生的随机字符
  14.     for i in range(n):            # 自定义循环次数                 
  15.         ran = random.randint(0,len(s)-1)    # 每次在字符串s中生成一个随机字符,赋值给ran.
  16.         code += s[ran]            # 每次将这个字符累加
  17.     return code
  19. # 定义登录函数
  20. def login():
  21.     username = input('输入用户名:')
  22.     password = input('输入密码:')
  23.     code = generate_checkcode(4)              # 调用前面的函数得到一个验证码
  24.     print('产生的验证码是:',code)
  25.     code1 = input('输入验证码:')
  27.     # 验证
  28.     if code.lower() == code1.lower():         # 全是小写状态下,如果产生的随机验证码与输入的验证码相同,则验证码输入正确
  29.         if username == 'xellgat' and password == '123456':  # 验证码输入正确的情况下, 且用户名和密码也输入正确
  30.             print('用户登录成功')
  31.         else:
  32.             print('用户名和密码输入有误')
  33.     else:
  34.         print('验证码输入不正确')
  36. # 函数调用
  37. login()

函数递归

  • 函数的递归调用是在函数调用中再调用该函数自身; 递归函数每次运行需要等待, 占用内存。
  • 递归函数一般有一个入口, 比如:函数传递的参数.
  • 递归函数一般也有一个出口, 用于终止递归的循环, 一般使用条件判断来控制;
    1. def food(x):        # x就是入口,就是传递的值
    2.   if x==1:        # 1就是出口,就是用于终止递归循环的值,这里当x == 1 的时候, 终止递归函数的循环  
    3.       return 1
    4.   else:
    5.       return x + food(x-1)   # 1, 4+Foo(4-1) => 2, 4+3+Foo(3-1)  => 3, 4+3+2+Foo(1)  => 4, 4+3+2+1+Foo(0)
    6. food(4)      # 4+3+2+1
  1. # 分析：先计算n=10，不符合if语句，往下继续计算的5，同理可得到2和1，计算到1时，符合if语句。所以返回1，再将1反馈到2，...最终得到结果就是1.
  3. def calc(n):    # n 的值为入口
  4.     print('每次递归n的值为:',n)
  5.     if int(n/2) == 0:   # 满足条件后的出口        
  6.         return n
  7.     return calc(int(n/2))
  9. x = calc(10)
  10. print('x的值为:',x)
  1. # 死循环
  2. def tell_story():
  3.     print('从前有座山')
  4.     print('山上有座庙')
  5.     print('......')
  6.     tell_story()
  7. tell_story()
  1. # 解决死循环 通过一个[条件]来停止递归
  2. count = 0
  4. def tell_story():
  5.     global count
  6.     count += 1
  7.     print('从前有座山')
  8.     print('山上有座庙')
  9.     print('......')
  10.     if count < 5:
  11.         tell_story()    # 满足条件才递归
  12. tell_story()
  1. # 求1-n的和
  2. # 思路: 1+2+3+4+5+6  
  3. # = sum(5)+6      # 当sum(5),又会中sum(n-1) + n 这条语句, 所以一直会加下去
  4. # = sum(4)+5+6 
  5. # = sum(3)+4+5+6 
  6. # = sum(2)+3+4+5+6 
  7. # = sum(1)+2+3+4+5+6 
  8. # = sum(0)+2+3+4+5+6   ==> 中了if条件,n = 0 ,直接返回 0 , 就是1+2+3+4+5+6
  9. count = 1
  11. def sum(n):   
  12.     if n == 0:
  13.         return 0  
  14.     return sum(n-1) + n   #例如:计算到6的和, 就是sum(6-1)+6
  16. sum(6)
  1. # 求n (正数)的阶乘  - n! = n * (n-1)!         ===> [ 1! = 1 * 0! , 0的阶乘是1]
  2. def fac(n):
  3.     if n == 0:            # 找到终止递归函数的出口条件,并返回一个值
  4.         return 1       
  5.     return n * fac(n - 1)
  7. factorial(5)               # 5*fac(5-1) ===> 5*4*fac(4-1) ===> 5*4*3*2*1*1=120

闭包（返回的是一个函数）

满足闭包的条件：

  • 外部函数中必须定义了内部函数
  • 外部函数必须有返回值，注意返回值是：内部函数名

  • 内部函数中必须引用了外部函数的变量或者参数，该变量称之为内部函数的自由变量

    我对闭包的理解

  • 当函数存在嵌套，并且子函数引用了父函数中的变量，可以访问这些变量的作用域就形成闭包，如果子函数没有访问父函数中的变量，就不存在闭包；

  • 打个比方: 一个大盒子，内部有一个小盒子，小盒子里用到一些东西是来自这个大盒子，那么这些来自大盒子的东西，就是闭包；

闭包的架构（个人理解：类似面向对象的结构）：

  • 定义外层函数 —-》类似定义类
  • 外层函数变量 —》类似类属性
  • 定义内层函数 —-》类似定义实例方法
  • 调用自由变量 —-》类似调用类属性 ```python def func(a,b): # 类似定义类 c = 10 # 类似类属性 def inner_func(): # 类似定义实例方法
    1.   s = a + b + c                # 类似调用类属性
    2.   print('相加之后的和为:',s)
    return inner_func

x = func(50,60) # 此时，x = inner_func =====> 类似通过类创建实例对象 x() # 相加之后的和为：120 =====> 调用实例方法

  2. <a name="fda5309d"></a>
  3. ### 应用1：多次实参传递不受影响
  4. 调用闭包函数时，将实参传递给闭包所返回的值，不会受到下一次使用其它实参传递给闭包的影响<br />闭包函数中，引用的自由变量只和具体的闭包函数有关联，且闭包函数创建的每个实例所引用的自由变量都互不干扰
  5. ```python
  6. def func(a,b):
  7.     c = 10
  9.     def inner_func():
  10.         s = a + b + c                # 在python中我们称上面的这个c为闭包函数inner_func的一个自由变量
  11.         print('和是:',s)
  12.     return inner_func                # (注意点) 这里返回的是内部函数名变量，务必记住不能带()，因为带了()就是被调用的意思
  14. # 实例1
  15. x = func(5,6)                        # 实例1，此时，# x = func(5,6) = inner_func 
  16. print(x)                             # 只要创建了一个内部函数，它就占用了一块内存地址
  17. x()                                  # 第一次使用x调用函数返回的值为：21             
  20. # 实例2
  21. y = func(50,60)                       # 实例2，既然有返回值，那么函数被调用时就必须使用一个变量来接收它的返回值；             
  22. y() 
  24. # 再次打印实例1
  25. print(x)                   
  26. x()                                  # 第二次使用x调用函数返回的值为：21，不变，说明期间没有受到使用y调用函数传值的影响

应用2：可以同级调用

  1. def func():
  2.     a = 100
  3.     def inner_func1():
  4.         b = 90
  5.         s = a + b
  6.         print(s)
  8.     def inner_func2():
  9.         inner_func1()              # 可以调用同级的函数
  10.         print('--->',a)            # 可以使用同级的变量
  11.         return 'hello'
  13.     return inner_func2    
  16. x = func()                         # x = inner_func2()
  17. print(x())

应用3：接收多个值

面这个例子中我们至少可以对闭包中引用的自由变量有如下的认识：

  • 闭包函数中，引用的自由变量只和具体的闭包函数有关联，且闭包函数产生的每个实例所引用的自由变量都互不干扰；
  • 一个闭包实例对其自由变量的修改会被传递到下一次该闭包实例的调用；【上述代码第22行处】 ```python def outer_func(): a = [] # 接收多个值 def inner_func(name):
    1.   a.append(len(a)+1)        
    2.   print('%s = %s'%(name,a))
    return inner_func

实例1

x = outer_func()
print(x)
x(‘list1’) # list1 = [1] x(‘list1’) # list1 = [1, 2] x(‘list1’) # list1 = [1, 2, 3]

print(‘==========================’)

实例2

y = outer_func() y(‘list2’) # list2 = [1] x(‘list2’) # list2 = [1, 2, 3, 4] 注意点：一个闭包实例对其自由变量的修改会被传递到下一次该闭包实例的调用 y(‘list2’) # list2 = [1, 2]

  2. <a name="d06f21c5"></a>
  3. ### 应用4：使用nonlocal关键字
  4. 闭包中，如果要修改引用的外层变量，需要使用nonlocal 变量，否则当做是闭包内新定义的变量
  5. ```python
  6. def test1():
  7.     num = 10
  9.     def test2():
  10.         nonlocal num        # 如果在内部函数中要修改外部函数的变量，需要使用nonlocal关键字
  11.         num = 666     
  12.         print(num)
  14.     print(num)                # num = 10
  15.     test2()                    # num = 666
  16.     print(num)                # num = 666
  17.     return test2
  19. result = test1()
  20. result()

应用5：闭包变量所对应的值

在闭包内，如果引用了一个后期会发生变化的变量时，一定要注意：函数，必须是在被调用时, 才会去确定变量所对应的值；

  1. def test1():
  2.     a = 1
  4.     def test2():
  5.         print(a)
  7.     a = 2               # 此时a = 2
  9.     return test2
  11. result = test1()        # result = test1() = test2
  12. result()                 # 结果为2，因为只函数被调用时，才会去确定函数体内变量标识符所对应的值，而函数体后面已经将a重新赋值为2，所有最后函数调用后得到的值也为2

应用6：错误的闭包

  1. def test():
  2.     funcs = []
  3.     for i in range(3):            # i = 0, i = 1, i = 2 
  5.         def inner():            # 定义一个闭包
  6.             print(i*i)
  7.         funcs.append(inner)
  9.     return funcs
  11. x = test()                        # 创建实例 
  12. x[0]()                            # 4
  13. x[1]()                            # 4
  14. x[2]()                            # 4

程序的结果并不是我们想象的0，1，4；实际结果全部都是4，这段代码是典型的错误使用闭包的例子；
该例子中比较特殊的地方就是：返回的所有闭包函数均引用了父函数中定义的同一个自由变量；而test( )返回的并不是一个闭包函数，而是一个包含了三个闭包函数的一个列表；
这里有个问题是：为什么for循环中的变量变化会影响到所有的闭包函数呢【取的是for循环最后那个值2】？
可是，我们上面说过：同一闭包的不同实例中引用的自由变量互相之间是没有影响的，那么问题到底出在哪里呢？

  • 其实问题的关键就在于在返回闭包列表funcs之前，for循环中的变量值i已经发生变化了，而且这个改变会影响到所有引用它的内部函数；
  • 因为在test( )函数返回前，其内部函数并不是闭包函数，只是一个内部定义的函数而已，函数必须调用，才能确定内部函数中变量所对应的值；
  • 当然这个内部函数引用的父函数中的变量也不是自由变量，而只是当前局部中的一个本地变量而已；

如何才能打印出0，1，4呢？

应用7：修正错误的闭包

  1. def test():
  2.     funcs = []
  3.     for i in range(3):            # i = 0, i = 1, i = 2 
  5.         def outer(num):            # 定义一个闭包的外层函数，接收一个参数，该参数是for循环中的i值
  6.             def inner():        
  7.                 print(num*num)
  8.             return inner        # 这是一个普通的闭包返回
  10.         funcs.append(outer(i))    # 在for循环体内，【调用】闭包函数，那么每次循环都可以获取到精准的i值，然后将返回的函数添加进列表中      
  11.     return funcs
  13. x = test()                        # 创建实例 
  14. x[0]()                            # 0
  15. x[1]()                            # 1
  16. x[2]()                            # 4

原始函数

  1. def str1(): 
  2.     print("hello workd") 
  3. str1()

侵入原始函数进行修改

  1. import time
  3. def str1():
  4.     star = time.time()           # 侵入修改
  5.     print("hello workd")         # 这个是原函数代码块
  6.     end = time.time()               # 侵入修改
  7.     print('程序运行时间为：',(end-star)*1000)
  9. if __name__ == '__main__':
  10.     str1()

优点：

  • 要想拓展原始函数代码的功能，最直接的办法就是侵入代码里面修改，例如：在原本的代码上添加时间戳（辅助功能），用于记录这个函数执行的总时间；
  • 好处：逻辑函数和功能函数融合在一起了;

缺点：

  • 不方便修改，因为是在原始函数体内进行修改，一旦代码量过多，修改起来很容易引起bug；
  • 如果有一天你的boss和你说：“这段代码是公司的核心代码，不能直接去修改改，那该怎么办呢?

  • 于是可以尝试将侵入到原始函数中的代码单独写成一个函数，然后将原始函数作为参数传递给该函数；

    单独写一个函数来增强原函数

  • 将功能函数 (添加时间戳) 分离出来，单独写一个功能函数timer( )，然后将原始函数作为参数传递给功能函数timer(func)； ```python import time

原始函数

def str1(): # 把该函数名当作成一个变量，str1是一个变量，指向的是一块内存地址，str1()则表示调用函数，执行函数内部的操作 print(‘hello world’) time.sleep(2)

单独写一个功能函数

def timer(func): # 传递一个参数，该参数是一个函数变量
star = time.time()
func() # 中间插入接下来需要计算哪个函数执行的时间 end = time.time() print(‘程序运行时间为：’,(end-star)*1000)

if name == ‘main‘:
timer(str1) # 使用功能函数调用原始函数 

  1. **优点：**
  3. - 避免直接侵入原函数中进行修改导致bug的产生；
  5. **缺点:**
  7. - 需要通过功能函数来调用原始函数名，使用起来不方便；
  8. - 这里的原函数指的是str1( )，而最后却是使用timer( )函数进行调用来拓展函数func的功能；
  10. 我们的目标：能不能再调用原始函数的同时自动完成时间的统计；
  11. <a name="zHGZx"></a>
  12. ## 通过闭包来增强原函数
  13. 没有使用闭包：
  14. ```python
  15. import time
  17. # 原始函数
  18. def str1():           
  19.     print('hello world')
  20.     time.sleep(2)
  22. def timer(func):                            # 函数名作为参数传递        
  23.     star = time.time()   
  24.     func()                                     # 函数名 + () = 调用
  25.     end = time.time()
  26.     print('程序运行时间为：',(end-star)*1000) 
  28. if __name__ == '__main__':               
  29.     str1 = timer(str1)                        # 其实这里已经将结果显示出来了，但是我们希望最后还是通过原始函数str1()来显示结果，所以这里应该返回一个函数名才行

上面的调试中，我们希望timer(str1)能够返回的是一个函数名，然后重新赋值给原始函数名，这样最后就可以通过str1( )的方式进行调用了，所以需要使用闭包模式！
使用闭包：

  1. import time
  3. # 原始函数
  4. def str1():           
  5.     print('hello world')
  6.     time.sleep(2)
  8. # 闭包
  9. def timer(func):                                # 闭包：用于增强函数func，闭包本质上也是一个函数，闭包函数的传入参数和返回值都是函数
  10.     def inner():
  11.         star = time.time()   
  12.         func()                     
  13.         end = time.time()
  14.         print('程序运行时间为：',(end-star)*1000) 
  15.     return inner                                # 返回内层函数名，因为我们上面的调试中要求返回一个函数名，然后重新赋值给原始函数名
  17. if __name__ == '__main__':               
  18.     str1 = timer(str1)                            # 所以timer(str1)返回的是函数名，赋值给原始函数名，从而使用闭包对原函数进行了增强
  19.     str1()                                        # 通过原始函数名进行调用

使用闭包的缺点：

  • 这里定义了一个timer( )函数，它的参数是一个函数，然后给这个函数嵌入了计时功能，然后你可以拍着胸脯对老板说，看吧，不用动你原来的代码，我照样拓展了它的函数功能；
  • 然后老板对你说: “我们公司核心代码区域有一千万个func( )函数，按你的方案，想要拓展这一千万个函数功能，就是要执行一千万次timer()函数，这可不行呀，我心疼我的机器”；
  • 好了，你终于受够你老板了，准备辞职了，然后你无意间听到了装饰器这个神器，突然发现能满足你的要求了。

装饰器用于解决上面每次调用原始函数时，都需要使用闭包来增强原函数才行，所以让python自动增强原函数，则使用装饰器；

使用装饰器

优点：

  • 既不需要侵入，也不需要调用其他函数来重复执行；
  • 这里的timer()函数就是最原始的装饰器，它的参数是一个函数，然后返回值是一个函数名；
  • 作为参数的这个函数str1( )是在返回函数inner( )的内部执行的；
  • 在函数str1( )前面加上@timer，str1( )函数就相当于被注入了计时功能，现在只要调用str1( )，那么它就已经变身拥有“更多新的功能”的函数了；
  • 所以这里的装饰器就像一个注入符号：有了它，拓展原来函数的功能，既不需要侵入函数内更改代码，也不需要重复执行原函数。 ```python import time

def timer(func): # 装饰函数
def inner(): # 闭包函数(不带参数) star = time.time()
func()
end = time.time() print(‘程序运行时间为：’,(end-star)*1000) return inner

@timer # 原始函数上使用装饰函数,它相当于str1 = timer(str1) def str1():
print(‘hello world’) time.sleep(2)

if name == ‘main‘: str1()
print(“str1.name is”,str1.name) # str1的name是inner

  1. <a name="jF82X"></a>
  2. ## 带有参数的装饰器
  3. ```python
  4. import time
  6. def timer(func):                           # 装饰函数
  7.     def inner(a,b):                       # 闭包函数(带指定参数)
  8.         star = time.time()  
  9.         func(a,b)  
  10.         end = time.time()
  11.         print('程序运行时间为：',(end-star)*1000)
  12.     return inner
  14. @timer
  15. def func1(a,b):
  16.     print("hello，here is a func1 for add :")
  17.     time.sleep(1)
  18.     print("result is %d" %(a+b))
  20. if __name__ == '__main__':
  21.     f = func1
  22.     f(3,4)
  23.     #func()

然后你满足了Boss的要求后，Boss又说：“我让你拓展的函数好多都是有参数的呀，有的参数还是个数不确定的那种，你的装饰器搞的定不？”然后你嘿嘿一笑，深藏功与名！

带有不定参数的装饰器

  1. import time
  3. def deco(func):
  4.     def wrapper(*args, **kwargs):            # 闭包函数(带无指定参数)
  5.         startTime = time.time()
  6.         func(*args, **kwargs)
  7.         endTime = time.time()
  8.         msecs = (endTime - startTime)*1000
  9.         print("time is %d ms" %msecs)
  10.     return wrapper
  13. @deco
  14. def func(a,b):
  15.     print("hello，here is a func for add :")
  16.     time.sleep(1)
  17.     print("result is %d" %(a+b))
  19. @deco
  20. def func2(a,b,c):
  21.     print("hello，here is a func for add :")
  22.     time.sleep(1)
  23.     print("result is %d" %(a+b+c))
  26. if __name__ == '__main__':
  27.     f = func
  28.     func2(3,4,5)
  29.     f(3,4)

最后，老板说：“可以的，小祁，我这里一个函数需要加入很多功能，一个装饰器怕是搞不定，装饰器能支持多个嘛”，最后你就把这段代码丢给了他

带返回值的装饰器

  1. def zhuangshiqi(func):
  2.     def inner(*args,**kwargs):
  3.         print('='*30)
  4.         res = func(*args,*kwargs)       # 被装饰的函数如果有返回值，那么在装饰器中对应的函数代码也应该保持一致，进行返回
  5.         return res
  6.     return inner
  8. @zhuangshiqi
  9. def test1(x,y,z):
  10.     s = x + y + z
  11.     return s                            # 带返回值
  13. @zhuangshiqi
  14. def test2(x):
  15.     print(x)                            # 没有返回值，那么返回的就是none
  18. result = test1(1,2,10)                   # 有返回值，使用变量接收
  19. print(result)
  20. test2(100)

多个装饰器

  1. import time
  3. def deco01(func):
  4.     def wrapper(*args, **kwargs):
  5.         print("this is deco01")
  6.         startTime = time.time()
  7.         func(*args, **kwargs)
  8.         endTime = time.time()
  9.         msecs = (endTime - startTime)*1000
  10.         print("time is %d ms" %msecs)
  11.         print("deco01 end here")
  12.     return wrapper
  14. def deco02(func):
  15.     def wrapper(*args, **kwargs):
  16.         print("this is deco02")
  17.         func(*args, **kwargs)
  19.         print("deco02 end here")
  20.     return wrapper
  22. @deco01
  23. @deco02
  24. def func(a,b):
  25.     print("hello，here is a func for add :")
  26.     time.sleep(1)
  27.     print("result is %d" %(a+b))
  31. if __name__ == '__main__':
  32.     f = func
  33.     f(3,4)
  34.     #func()
  36. '''
  37. this is deco01
  38. this is deco02
  39. hello，here is a func for add :
  40. result is 7
  41. deco02 end here
  42. time is 1003 ms
  43. deco01 end here
  44. '''

多个装饰器执行的顺序就是从最后一个装饰器开始，执行到第一个装饰器，再执行函数本身，盗用网上一个例子：

  1. def dec1(func):  
  2.     print("1111")  
  3.     def one():  
  4.         print("2222")  
  5.         func()  
  6.         print("3333")  
  7.     return one  
  9. def dec2(func):  
  10.     print("aaaa")  
  11.     def two():  
  12.         print("bbbb")  
  13.         func()  
  14.         print("cccc")  
  15.     return two  
  17. @dec1  
  18. @dec2  
  19. def test():  
  20.     print("test test")  
  22. test()

装饰器的外函数和内函数之间的语句是没有装饰到目标函数上的，而是在装载装饰器时的附加操作；17~20行是装载装饰器的过程，相当于执行了 test=dect1(dect2(test))，此时先执行 dect2(test)，结果是输出 aaaa、将func指向函数test、并返回函数two，然后执行dect1(two)，结果是输出1111、将func指向函数two、并返回函数one，然后进行赋值；用函数替代了函数名test， 22行则是实际调用被装载的函数，这时实际上执行的是函数one，运行到func()时执行函数two，再运行到func()时执行未修饰的函数test

其他资料

  1. # 定义装饰器函数
  2. def decorate(func):                 # 定义一个名为decorate(装饰器)的函数,带的参数也为一个函数
  3.     a = 100
  4.     print('装饰器外层函数打印输出')
  6.     def inner_func():
  7.         func()                      # 调用一下外层函数中的参数(就是自定义的函数,它是作为参数传递给了外层函数)
  8.         b = 200
  9.         print('装饰器:',a+b)         # 使用一下外层函数中的变量(闭包的特点)
  11.     print('装饰器内层函数加载完成')  
  12.     return inner_func               # 在外层函数下返回内层函数名(闭包的特点)
  15. # 调用装饰器, 实际上就是将自定义的函数送给装饰器函数进行加工,然后再返回给自定义的函数使用;
  16. # 1,@decorate用在哪个函数上面,则这个函数就会被当成参数传递给装饰器函数
  17. # 2,一旦使用@decorate, 就会直接执行decorate函数
  18. @decorate                  # 如果不使用装饰器,那么下面的函数只能输出函数内部的计算结果,如果使用了装饰器,那么可以将装饰器内容附加到该函数中
  19. def tt_test1():            # 自定义函数1
  20.     print('这是我的自定义函数1')
  22. def tt_test2():            # 自定义函数2
  23.     print('这是我的自定义函数2')
  25. # 再不调用自定义函数时,就会直接执行装饰器函数,而装饰器内有返回的值, 它是被tt_test接收的: tt_test = inner_func
  26. print(tt_test)        # decorate.<locals>.inner_func
  28. # 最后调用自定义函数,查看结果
  29. tt_test1() 
  30. tt_test2()           # 自定义函数2没有使用装饰器的情况下
  1. import time
  3. def decorate(func):
  4.     def wrapper():
  5.         print('正在校验中...')
  6.         time.sleep(2)
  7.         print('校验完毕')
  8.         func()            # 调用一下原函数(即装饰器的参数,即自定义的函数)
  9.     return wrapper
  11. @decorate
  12. def test1():
  13.     print('---one---')
  15. @decorate
  16. def test2():
  17.     print('---two---')
  19. test1()
  20. test2()
  1. # 带参数(定义一个万能的装饰器)
  2. import time
  4. def decorate(func):
  6.     def wrapper(*args,**kwargs):         # 装包成一个元组
  7.         print('\n正在校验中...')
  8.         time.sleep(2)
  9.         print('校验完毕')
  10.         # 调用一下原函数(即装饰器的参数,即自定义的函数), 原函数是带参数的,所以这里也要将wrapper的参数传递给原函数.
  11.         func(*args,**kwargs)            # 拆包, 因为args是一个元组,这里带*args就是将整一个元组拆开,这样就可以将元素分别赋值到test2中的两个参数中      
  12.     return wrapper
  14. # 传递一个空参数
  15. @decorate
  16. def test():
  17.     print('第一次输出:test')
  19. test()
  21. # 传递一个参数
  22. @decorate
  23. def test1(n):                    # test1 =  wrapper    
  24.     print('第二次输出:',n)
  26. test1(8)                        
  28. # 传递两个参数
  29. @decorate
  30. def test2(name,age):              # test2 =  wrapper
  31.     print('第三次输出:',name,age)
  33. test2('张三',20)
  35. # 传递一个列表参数
  36. @decorate
  37. def test3(students,clazz = '1905'):              # test3 =  wrapper  
  38.     print('第四次输出:\n{}班级的学生如下:'.format(clazz))
  39.     for i in students:
  40.         print(i)
  42. students = ['lily','tom','lucy']
  44. test3(students,clazz='1900')
  1. # 多层装饰器(以装修为例)
  2. def zhuangxiu_1(func):               # 第一个装修公司
  3.     print('----->1,start')
  5.     def wrapper(*args,**kwargs):
  6.         func()
  7.         print('刷漆')
  8.     print('----->1,end')
  9.     return wrapper
  11. def zhuangxiu_2(func):                # 第二个装修公司
  12.     print('----->2,start')
  13.     def wrapper(*args,**kwargs):
  14.         func()
  15.         print('铺地板')
  16.     print('----->2,end')
  17.     return wrapper
  19. #同时使用两个装修公司装修
  20. @zhuangxiu_1
  21. @zhuangxiu_2                 # 离自定义函数最近的装饰器,先干活,干完活之后再整体送给上一个装饰器
  22. def house():
  23.     print('这是我的毛坯房')
  25. # 调用
  26. house()
  1. # 带参数的装饰器(只要装饰器带参数,那么定义装饰器的时候就是三层函数)
  2. def outer(x):       # 第一层:负责接收装饰器的参数
  4.     def inner_func(func):      # 第二层:负责接收自定义函数
  6.         def wrapper(*args,**kwargs):  # 第三层:负责接收自定义函数中的参数
  7.             func(*args)
  8.             print('当前正在铺第{}块地砖'.format(x))
  10.         return wrapper     # 返回的是第三层
  12.     return inner_func      # 返回的是第二层
  14. @outer(10)
  15. def house(time):
  16.     print('{}年拿到房子的钥匙'.format(time))
  17. house('2019-10-1')
  19. @outer(x=100)
  20. def street():
  21.     print('新的街道名为:东风路')
  22. street()
  1. # 模拟付款流程
  2. import time
  4. islogin = False  # 指定登录状态,默认是没有登录的
  6. # 定义一个登录函数
  7. def login():
  8.     username = input('请输入用户名:')
  9.     password = input('请输入密码:')
  10.     if username == 'admin' and password == '123456':
  11.         return True
  12.     else:
  13.         return False
  16. #定义一个装饰器,用于验证付款验证(就是用户在付款前做一下登录验证)
  17. def login_required(func):           
  18.     def wrapper(*args,**kwargs):
  19.         global islogin
  20.         print('-----正在进行付款操作-----')
  21.         # 验证用户是否登录
  22.         if islogin:                 # 如何登录为True,表示登录成功,就执行自定义函数
  23.             func(*args,**kwargs)
  24.         else:                       # 如果没有登录成功,则跳转到登录页面,进行身份验证
  25.             print('用户没有登录,不能付款')
  26.             islogin = login()        # 调用登录函数,由于有返回值,需要使用变量来接收(这个变量可以指定为全局的islogin)
  27.             print('result:',islogin)         
  29.     return wrapper
  31. @login_required
  32. # 自定义付款过程的函数
  33. def pay(money):
  34.     print('正在付款,付款金额是{}元'.format(money))
  35.     print('付款中,请稍后...')
  36.     time.sleep(2)
  37.     print('付款完成!')
  39. #调用
  40. pay(100)
  41. pay(200)

匿名函数

  • 使用 lambda 来创建匿名函数, 所谓匿名，就是不使用def语句的形式定义函数。
    • lambda 只是一个表达式，函数体比 def 简单很多。
    • lambda 的主体是一个表达式，而不是一个代码块, 仅仅能在lambda表达式中封装有限的逻辑进去。
    • lambda 函数拥有自己的命名空间，它不能访问自己参数列表之外或全局命名空间里的参数。
  • 格式：lambda 参数1, 参数2… : 返回的结果 ```python result = lambda a,b:a+b # sum相当于函数名, a,b相当于参数, a+b相当于return返回的结果 print(result) # 输出结果是一个内存地址，表明sum就是一个函数变量名 print(result(10,20)) # 调用sum函数

1,无参数传递

fn1 = lambda:100 print(fn1())

2.传递一个参数

fn2 = lambda a: a # 为了验证传递的参数是否成功，所有将直接将参数返回 print(fn2(‘hello world’))

3.默认参数传递

fn3 = lambda a,b,c=100: a+b+c print(fn3(10,20)) # 130 print(fn3(10,20,30)) # 60

4.传递可变参数(位置参数，返回的是一个元祖)

fn4 = lambda *args: args print(fn4(10)) #(10,) print(fn4(10,20)) #(10,20) print(fn4(10,20,30,40)) #(10,20,30,40)

4.传递可变参数(关键字参数，返回的是一个字典)

fn5 = lambda **kwargs: kwargs print(fn5(name=’python’)) #{‘name’:’python’} print(fn5(name=’python’,age=20)) #{‘name’:’python’,’age’:20}

  2. ```python
  3. # 匿名函数作为参数
  4. def test(x,y,func):
  5.     print(x,y)
  6.     print(func)
  8.     s = func(x,y)      # func函数的定义
  9.     print(s)
  10.     print(func(x,y))
  12. # 调用test
  13. test(1,2,lambda a,b:a+b)
  1. import os
  3. host = 'gza-access8'
  5. oid = {'interName':'1.3.6.1.2.1.2.2.1.2'}
  7. get_oid = lambda snmpoid:os.popen('snmpwalk -c public -v 2c %s %s'%(host,snmpoid)).readlines()   
  8. print(get_oid)        # 结果显示get_oid就是一个函数
  9. get_oid(oid['interName'])
  11. get_cvoid = lambda snmpoid,values:os.popen('snmpwalk -c public -v 2c %s %s.%s'%(host,snmpoid,values)).readlines()
  12. print(get_cvoid)        # 结果显示get_oid就是一个函数
  13. # get_cvoid(oid['interName'])
  15. get_joid = lambda logicname,snmpoid:os.popen('snmpwalk -c %s/default@public -v 2c %s %s'%(logicname,host,snmpoid)).readlines()
  16. print(get_joid)        # 结果显示get_oid就是一个函数
  17. # get_joid(oid['interName'])
  19. get_jvoid = lambda logicname,snmpoid,values:os.popen('snmpwalk -c %s/default@public -v 2c %s %s.%s'%(logicname,host,snmpoid,values)).readlines()
  20. print(get_jvoid) 
  21. # get_jvoid()
# 匿名函数与内置函数的结合使用  --- max() 

# 取出列表list1中，字典元素中"a"是最大值的那个列表元素。
list1 = [{'a':10,'b':20},{'a':30,'b':20},{'a':15,'b':20}]

# max这个内在函数存在一个key参数，它用于接收一个函数，使用lambda，i为每次从list1中取出的一个字典元素，将每个字典中键为“a”的值返回给key，最后在key中比较
m = max(list1,key = lambda i:i['a'])
print(m)                              # {'a': 30, 'b': 20}

# 匿名函数与内置函数的结合使用  --- map()  
# map(func,*iterables)  对列表中的元素一一进行操作的时候，使用map()函数
print('-----map()函数简单使用-----')
list1 = [1,2,3,4,5,6,7,8]
x = map(lambda i:i + 2,list1)
print(x)
print(list(x))

print('\n-----带if判断的lambda表达式-----')
func = lambda j:j if j % 2 == 0 else j + 10
print(func)
y = func(3)
print(y)

print('\n-----套上map()函数-----')
result = map(func,list1)
print(result)
print(list(result))

# 匿名函数与内置函数的结合使用
# reduce() 对可迭代的数组中元素进行加减乘除运算的函数  ---> reduce（function,sequence, initial=None）
from functools import reduce

tuple1 = (1,2,3,4,5,6,7,8,9)

x = reduce(lambda i,j:i+j,tuple1)
print(x)                 # 45

# 说明：
# 1,2:1+2  --> 返回3
# lambda 3,3:3+3 --> 返回6
# lambda 6,4:6+4 --> 返回10
# lambda 10,5:10+5 --> 返回15
# lambda 15,6:15+6 --> 返回21
# lambda 21,7:21+7 --> 返回28
# lambda 28,8:28+8 --> 返回36
# lambda 36,9:36+9 --> 返回45

print('\n-----如果可迭数组中只有一个元素的情况下：-----')
tuple2 = (3,)
print(reduce(lambda i,j:i+j,tuple2))
print(reduce(lambda i,j:i+j,tuple2,1000))      # 后面的1000表示的是initial = 1000，就是初始化值.

# 匿名函数与内置函数的结合使用  --- filter()
# 用于过滤
list1 = [11,8,7,15,20,5]

# 取出list1中大于10的元素
list(filter(lambda i:i > 10,list1))

# 匿名函数与内置函数的结合使用  --- sorted()


dict1 = [{'name':'A','age':20},
         {'name':'C','age':19},
         {'name':'B','age':18},
         {'name':'E','age':21},
         {'name':'D','age':23},
         {'name':'F','age':22}]
# 找出字典中，age大于20的元素
print(list(filter(lambda i:i['age'] > 20,dict1)))

# 对age进行从大到小排序
list(sorted(dict1,key = lambda j:j['age']))