【python进阶1】函数，形参，匿名函数，递归，闭包，回调

python官方文档——函数的定义

函数定义

• python使用关键字def定义函数
  • 函数可以封装代码，实现代码的复用

def fn():
    print('hello word')
fn() # 输出 hello word

• 函数调用
  • 函数使用函数名和括号调用，括号内传入参数
• return语句
  • 在函数内，return语句作为函数的返回值，默认返回None
  • return语句后的代码不执行
  • 如果返回多个值，则以元组的类型返回

函数参数

• 位置参数
  • 函数调用时按照参数的位置传入

def fn(x,y):
    print(x,y)
fn(1,2) # 1>>x,2>>y

• 关键字参数
  • 函数调用时使用变量的名称传递参数

位置参数要在关键字参数之前，关键字参数后必须使用关键字参数

def fn(a,b,c):
    print(a,b,c)
fn(1,c=2,b=3)

• 函数参数的定义方法

  • 默认参数
    • def(形参=default) 调用时没有传入则使用默认值
  • 元组形参
    • def(*args) args 以元组的类型接受传入的参数

  def fn(*args):
      print(type(args))
      for el in args:
          print(el,end=' ')
  fn(1,2,3,4) # <class 'tuple'>   1 2 3 4 
  

  • 字典形参
    • def(**kwargs) 以字典类型接收
    • 以关键字参数传入，关键字作为键，值作为字典的值

  def fn(**kwargs):
      print(type(kwargs))
      for k,v in kwargs.items():
          print(k,v)   
  fn(name='zhang',age=111)
  # <class 'dict'> name zhang age 111
  

  • 强制关键字参数传入
    • def(*,a,b) a,b传入必须以关键字的形式传入
  • 强制位置参数
    • def(a,b,//,c,d) a,b必须以位置参数传入，不能以关键字参数传入

  def fn(a,b,/,c,d):
      print(a,b,c,d)
  def fn(a,b,*,c,d):
      print(a,b,c,d)
  

  可变不可变

  可变类型在函数内部是引用传递，不可变类型在函数内部是值传递（新的地址存储）

  • 可变类型
    • 字符串 元组 数字
  • 不可变类型
    • 列表，字典

  a = 4
  li = [1,2]
  def fn(a):
      print(id(a))  #140716343114296
      print(a)  # 5
      li[0]='a'
      li.append(111)
  fn(a)
  print(id(a)) # 140716343114264
  print(a,li)  # 4 ['a', 2, 111]
  

  匿名函数

  python中有一种特殊的一行函数，使用关键字lambda

  lambda 形参：表达式

  把表达式的返回值作为函数的返回值

  不支持赋值语句

  f = lambda x:x**2
  print(f(3)) # 9
  

变量作用域

能使用函数变量的地方就是变量的作用域

• 局部变量
  • 定义函数内部的变量，只能函数的内部使用
• 全局变量
  • 定义在函数外部，模块内部，所用模块内部的函数都可以访问

def fun(n,o=None):
    print(n,o)
    def fn(m):
        return fun(m,n)
    return fn
a=fun(0)
a(1)
a(2)
a(3)
b=fun(0)(1)(2)(3)
c=fun(0)(1)
c(2)
c(30)
'''
0 None
1 0
2 0
3 0
0 None
1 0
2 1
3 2
0 None
1 0
2 1
30 1
'''

局部作用域，修改全局变量

• global
  • 申明变量是全局变量
• nonlocal
  • 申明变量是外层的变量

b = 200
def fa():
    global b
    b = 222
fa()
print(b) # 222

def f1():
    a = 'a'
    def f2():
        nonlocal a
        a = 'aaa'
    f2() 
    print(a)     # aaa
f1()

LEGB顺序

python中，LEGB代表四种作用域的查找方式

• Local
  • 本地作用域，当前函数的内部变量
• Enclosing
  • 嵌套函数中的外层函数的作用域
• Global
  • 全局作用域，模块中定义的变量，文件中最外层的变量
• Built-in
  • 内建作用域，python内置的变量，函数

函数的内存分配

函数中的代码存储到代码区，不执行

当函数被调用时执行函数，开辟内存空间

调用结束，空间被释放

函数自调用 递归

函数调用自身，可以被while循环结构替代

def f(n): # 求n的阶乘
    if n ==1:
        return 1  # 如果等于1，就返回1 
    else:
        return f(n-1)*n # 如果不等于1，就取出n*下一个函数的结果
print(f(4)) # 24
def m(n):
    s = 1
    if n == 1:
        return s
    else:
        while n != 1:
            s *= n
            n -= 1
        return s          
print(m(4)) # 24

闭包函数

返回函数作为函数的结果，可以使用函数内部的变量

def f():
    def hi():
        print('hi!!! ')
    return hi  # 返回函数名，可以在外部调用该内部调用的函数
f()() # hi!!!
def f2(x,y):
    a = x+y
    b = x-y
    def fff():
        return a*b   
    return fff
print(f2(1,2)) # <function f2.<locals>.fff at 0x000001ABD4CC0CA0>
print(f2(1,2)()) # -3

回调函数

函数接收函数名作为参数

def cb(x):
    return str(x)

def f(n,function):
    n = bin(n)
    return function(n)

print(f(10,cb))  # 0b1010