python 函数Function

函数Function

数学定义

• y = f(x),y是x的函数，x是自变量。

Python函数

• 由若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元。

• 完成一定功能

函数的作用

• 结构化编程对代码的最基本封装，一般按照功能组织一段代码

• 封装的目的为了复用，减少冗余代码

• 代码更加简洁美观、可读易懂

函数的分类

• 内建函数，如max()、min()、sum()等

• 库函数，如math.ceil()

• 自定义函数，使用def关键字定义

函数定义

def 函数名（参数列表）：
    函数体（代码块）
    [return 函数值]

• 函数名就是标识符，命名要求一样

• 语句块必须缩进，约定4个空格

• Python的函数若没有return语句，会隐式返回一个None值

• 定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参。

def add(x,y): #函数定义，创建一个标识符 add 指向 函数对象
    return x+y   
add(3,4)#函数的调用，函数名后使用小括号，小括号中填入实实在在的参数，简称实参

def add(x,y):
    pass   #返回None

函数的调用

• 函数的定义，只声明了一个函数，它不能被执行，需要调用才能执行。

• 调用：函数名+（实参）

• 调用时写的参数是实际参数，简称实参。

• 函数是可调用的对象。查看是否可调用callable()。

函数的参数

函数在定义是要约定好形式参数，调用时也提供足够的实际参数，一般来说，形参和实参个数要一致。

传参方式

• 位置传参（一一对应）

add(4,5)

• 关键字传参

add(x=4,y=5)  
add(y=5,x=4)

要求位置参数必须在关键字传参之前传入，位置参数是按位置对应的。

参数缺省值

缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用：

• 参数的默认值可以在未传入足够的实参的时候，对没有给定实参的参数赋值为默认值

• 参数非常多的时候，并不需要用户每次都输入所有的参数，简化参数调用

def add(x=4,y=5):
    return x+y
    
add(),add(10),add(10,y=6),add(11,10)

能否这样定义def add(x, y=5) 或 def add(x=4, y)?

def add(x=4, y)

SyntaxError: non-default argument follows default argument
#位置参数必须在关键字参数之前传入

可变参数

• 可变位置参数

  • 在形参前使用*表示该形参是可变位置参数，可以接受多个实参

  • 它将收集来的实参封装成元组

可变位置参数不能用关键字传参

def fn(x,*args):
   print(x)
   print(args)
fn(3,args=4)  #error

• 可变关键字参数
  • 在形参前使用**表示该形参是可变关键字参数，可以接受多个实参
  • 它将收集来的实参的名称和值组织成dict

def showconfig(**kwargs)
    print(type(kwargs))
    print(kwargs)
showconfig(a=1,b=2)

def fn1(x,**kwargs):
    print(x)
    print(kwargs)
fn1(5,kwargs=7)  #这里是将kwargs作为一个key

混合使用

参数顺序：普通参数、可变位置参数、可变关键字参数

def showconfig(username,password,**kwargs):
    pass
def showconfig(username,*args,**kwargs):
    pass

总结：

• 有可变位置参数和可变关键字参数

• 可变位置参数在形参前使用*

• 可变关键字参数在形参定义前使用**

• 可变位置参数和可变关键字参数都可以收集若干个实参，分别返回tuple、dict。

• 混合使用参数的时候，顺序为参数顺序：普通参数、可变位置参数、可变关键字参数。

def fn(x,y,*args,**kwargs):
   print(x,y,args,kwargs)
fn(3,5)
fn(3,4,5,a=3,b=5)

keyword-only参数

def fn(*args,x,y,**kwargs):
    print(x,y,args,kwargs)
fn(3, 5)#Error
fn(3, 4, 5, a=3, b=5)#Error
fn(3, 5, y=6, x=7, a=1, b='abc')

在Python3之后，新增了keyword-only参数。

keyword-only参数：在形参定义时，在一个*之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通参数了，称为keyword-only参数。采用关键字传参。

*后所有的普通参数都变成了keyword-only参数。

def fn(*, x, y):
    print(x, y)
fn(x=6, y=7)

def fn4(**kwargs,x):
    print(x)
    print(kwargs)  
    
fn4(x=1, y=2, z=3)#Error   语法错误，可变关键字参数将关键字传参全部收集

参数规则

参数列表参数一般顺序是：普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺省值）、可变关键字参数。

注意：

• 代码应该易读易懂，而不是为难别人

• 请按照书写习惯定义函数参数

def fn(x,y,z,*args,m=4,n,**kwargs):
    print(x,y,z,m,n)
    print(args)
    print(kwargs)

• 定义最常用参数为普通参数，可不提供缺省值，必须由用户提供。注意这些参数的顺序，最常用的先定义。

• 将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参。

• 如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则使用可变关键字参数收集。

参数解构

必须在传实参的时候使用

def add(x, y):
    print(x,y)
    return x+y
add(*[4,5]),add(*(4,5)),add(*{4,5}),add(*rnage(4,6))

def add(x, y, *args):
    print(x,y)
    return x+y
add(3, 4, 5)
add(*{'a':3,'b':4})  #-->add(*{'a':3,'b':4}.keys())
add(**{'x': 1}, 'y': 4))   #-->解构成x=1,y=4,只有dict可以使用，但是字典的key必须和函数的形参一致

• 在给参数提供实参的时候，可以在可迭代对象前使用*或**来进行结构的解构，提取出其中所有元素作为函数参数

• 使用*解构成位置传参

• 使用**解构成关键字传参

• 提取出来的元素数目和参数要匹配

函数返回值语句

• python函数使用return语句返回值

• 所有函数都有返回值，如果没有return语句，隐式调用return None

• return语句并不一定是函数语句的最后一条语句

• 一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用return None

• 如果有必要，可以显示调用 return None，可简写return

• 如果函数执行了return语句，函数就会返回，当前语句之后的其他语句就不会被执行了

• 函数不能同时返回多个值，看似返回多个值，实则隐式的被封装成一个元组

函数作用域（三星重点）

作用域

一个标识符（变量）的可见范围。

每个函数都会开辟一个作用域，函数内部的变量不能超出函数的范围。

作用域分类

• 全局作用域
  • 在整个程序运行环境中都可见
  • 全局作用域中的变量称为全局变量
• 局部作用域
  • 在函数、类等内部可见
  • 局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域

基本原则：

       一般来讲外部作用域变量在函数内部可见，可以使用，
反过来，函数内部的局部变量，不能在函数外部看到。

函数嵌套

def outer():
    x = 100   #局部变量，local变量，临时变量
    def inner():
        x = 200   #赋值即定义
        print('inner',x)
    inner()
    print('outer',x)
    
outer()

从执行结果来看：

• 外层变量在内部可见

• 内层作用域inner中，如果定义了x = 200，相当于在当前函数inner作用域中重新定义了一个新的变量x，但是，这个x并不能覆盖掉外部作用域outer中的变量x.只不过对于inner函数来说，其只能可见自己作用域中定义的变量x。

• 其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已。

一个赋值语句的问题

x = 100   
def inner():
    #x += 100   #error
    x = x + 100   #赋值即定义
    print('inner',x)
inner()

原因分析：
x += 100 相当于 x = x + 100（赋值即定义）在inner作用域中，定义局域变量x，但是x并未被赋值 ,可以理解为 None = None + 100

x = 100

def fn():
    print(x)   #error
    x = 200   #赋值即定义
    
print(x)
fn()
print(x)

原因分析：
在fn作用域中，定义局域变量x，执行print语句时，x并未被赋值。

global语句

• 使用global关键字变量，将foo内的x声明为使用外部的全局作用域中定义的x

• 全局作用域中必须有x的定义

def fn():
    global x
    x = 200
    print(1, x)
fn()
print(2,x)

使用global关键字定义的变量，是全局变量，不再是局域变量

总结

x += 1 这种是特殊形式产生的错误原因？
先引用后赋值，而python动态语言是赋值才算定义，才能被引用。解决办法，在这条语句钱增加x=0 之类的赋值语句会重新定义局部变量x，但是，一旦这个作用域中使用global声明x为全局变量。

global使用原则

• 外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，尽量与外界隔离。
• 如果函数需要使用外部全局变量,请尽量使用函数的形参定义，并在调用传实参解决
• 一句话，不用global。学习它就是为了深入理解变量作用域
• 形参就是函数的标识符，就是变量，就是本地变量

def fn(y=[]):
    y.append(1)
    return y
    
fn()
fn()
print(fn())  结果是什么？

结果是[1,1,1],fn函数中y.append(1)语句，y是引用了[]的地址。

y = []

def fn(x):
    x.append(1)
    return x
    
fn(y)
fn(y)
print(y)

c = 100

def inc(a):
    return a + 1
    
c = inc(c)
c = inc(c)
print(c)

闭包（三星重点）

自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量。

闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。

def counter():
    c = [0]
    def inc():
        c[0] += 1
        return c[0]
    return inc  #返回inc函数对象,注意这个函数对象并不释放，因为m记着，引用计数不为0
    
m = counter()
m()

nonlocal 不在本地作用域中定义，在上级作用域中定义，但不在global作用域中定义

def counter():
    c = 0
    def inc():
        nonlocal c
        c += 1
        return c
    return inc  #返回inc函数对象
    
m = counter()
m()
m()
print(m())

默认值的作用域

def foo(x=1):
    x += 1
    print(x)
    
foo()
foo()


def bar(x=[]):    #引用类型，x引用[]的地址
    x.append[1]
    print(x)
    
bar()
bar()

为什么第二次打印是[1,1]?

• 因为函数也是对象，每个函数定义被执行后，就生成了一个函数对象和函数名这个标识符关联
• python把函数的默认值放在了函数的属性中，这个属性就伴随这个函数对象的整个生命周期
  函数名.defaults 查看函数属性

l3 = []
l3 += 5    #相当于l3.extend(5)  就地修改    列表可修改


c = 'abc'
c += 'd'  -->   c = c + 'd'  #字符串不可变，生成新的地址

变量名解析原则LEGB(三星重点)

外层的内层能看见，内层的外层看不见

• Local,本地作用域、局部作用域的local命名空间。函数调用时创建，调用结束消亡

• Enclosing，Python2.2时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数命名空间

• Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡

• Build-in,内置模块的命名空间，解释器启动时创建，解释器退出时消亡

所有一个名词的查找顺序就是LEGB

函数的销毁

• 定义一个函数就是生成一个函数对象，函数名指向的就是函数对象

• 可以使用del语句删除函数，使其引用计数减1

• 可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减1

• Python程序结束时，所有对象销毁

• 函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0

思考习题

• 举出三种Python函数中保存 状态信息的方法？
  • 尽管函数返回的时候本地变量的值已经不在了，我们可以使用全局变量、嵌套函数def内嵌套函数作用域引用，或者使用函数默认参数值让一个函数保持状态信息。