函数

一、函数

函数

​ 数学定义

​ y=f(x) ，y是x的函数，x是自变量。y=f(x0, x1, …, xn)

​ Python函数

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

​ 完成一定的功能

​ 函数的作用

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

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

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

​ 函数的分类

​ 内建函数，如max()、reversed()等

​ 库函数，如math.ceil()等
​ 自定义函数，使用def关键字定义

函数定义

def 函数名(参数列表):
	函数体（代码块）     
	[return 返回值]

​ 函数名就是标识符，命名要求一样
​ 语句块必须缩进，约定4个空格
​ Python的函数若没有return语句，会隐式返回一个None值
​ 定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

函数调用

​ 函数定义，只是声明了一个函数，它不能被执行，需要调用执行
​ 调用的方式，就是函数名后加上小括号，如有必要在括号内填写上参数

​ 调用时写的参数是实际参数，是实实在在传入的值，简称实参

def add(x, y): # 函数定义
	result = x + y # 函数体     
	return result  # 返回值
	out = add(4,5) # 函数调用，可能有返回值，使用变量接收这个返回值
	print(out) # print函数加上括号也是调用

上方代码解释：

​ 定义一个函数add，及函数名是add，能接受2个参数
​ 该函数计算的结果，通过返回值返回，需要return语句
​ 调用时，通过函数名add后加2个参数，返回值可使用变量接收。
​ 函数名也是标识符，返回值也是值
​ 定义需要在调用前，也就是说调用时，已经被定义过了，否则抛NameError异常

​ 函数是可调用的对象，callable()

函数参数

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

传参方式

1、位置传参
定义时def f(x, y, z)， 调用使用 f(1, 3, 5)，按照参数定义顺序传入实参

2、关键字传参

定义时def f(x, y, z)，调用使用 f(x=1, y=3, z=5)，使用形参的名字来传入实参的方式，如果使用了形参名字，那么传参顺序就可和定义顺序不同
要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的

def f(x, y, z):
	pass
	
f(z=None,y=10,x=[1])
f((1,),z=6,y=4.1)
f(y=5, z=6, 2) # 错误传参

参数缺省值

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

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

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

def add(x=4, y=5):     
	return x+y
add() # 9
add(x=5) # 10
add(y=7) # 11
add(6, 10) # 16
add(6, y=7) # 13
add(x=5, y=6) # 11
add(y=5, x=6) # 11
add(x=5, 6) # SyntaxError
add(y=8, 4) # SyntaxError
add(11, x=20) # TypeError

# 定义一个函数login，参数名称为host、port、username、password
def login(host='127.0.0.1', port=8080, username='wayne', password='magedu'):
	print('{}:{}@{}/{}'.format(host, port, username, password))
login() # 127.0.0.1:8080@wayne/magedu
login('127.0.0.1', 80, 'tom', 'tom') # 127.0.0.1:80@tom/tom
login('127.0.0.1', username='root') # 127.0.0.1:8080@root/magedu
login('localhost', port=80, password='com' )  # localhost:80@wayne/com
login(port=80, password='magedu', host='www')  # www:80@wayne/magedu

可变参数

需求：写一个函数，可以对多个数累加求和

def sum(iterable):
	sum = 0
    for x in iterable:
		sum += x     
	return sum
	print(sum([1,3,5])) 
	print(sum(range(4)))
	#  9 6

上例，传入可迭代对象，并累加每一个元素。

也可以使用可变参数完成上面的函数。

def sum(*nums):
	sum = 0
    for x in nums:
    	sum += x     
    return sum
print(sum(1, 3, 5)) 
print(sum(1, 2, 3))

1、可变位置参数

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

​ 它将收集来的实参组织到一个tuple中

2、可变关键字参数

​ 在形参前使用 ** 表示该形参是可变关键字参数，可以接受多个关键字参数

​ 它将收集来的实参的名称和值，组织到一个dict中

def showconfig(**kwargs):
	for k,v in kwargs.items():
		print('{}={}'.format(k,v), end=', ')

showconfig(host='127.0.0.1', port=8080, username='wayne', password='magedu')
# host=127.0.0.1, port=8080, username=wayne, password=magedu, 

混合使用

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

总结：

​ 有可变位置参数和可变关键字参数
​ 可变位置参数在形参前使用一个星号*
​ 可变关键字参数在形参前使用两个星号**
​ 可变位置参数和可变关键字参数都可以收集若干个实参，可变位置参数收集形成一个tuple，可变关键字参数 收集形成一个dict
​ 混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参数列表的后面，可变位置参数需要 在可变关键字参数之前

使用举例

def fn(x, y, *args, **kwargs):
	print(x, y, args, kwargs, sep='\n', end='\n\n')
fn(3, 5, 7, 9, 10, a=1, b='abc') fn(3, 5)
fn(3, 5, 7)
fn(3, 5, a=1, b='abc')
fn(x=1, y=2, z=3)
fn(x=3, y=8, 7, 9, a=1, b='abc') # 错在位置传参必须在关键字传参之前 
fn(7, 9, y=5, x=3, a=1, b='abc') # 错在7和9已经按照位置传参了，x=3、y=5有重复传参了

keyword-only参数

def fn(*args, x, y, **kwargs):
	print(x, y, args, kwargs, sep='\n', end='\n\n')
fn(3, 5) # TypeError  
fn(3, 5, 7) # TypeError
fn(3, 5, a=1, b='abc') #TypeError
fn(3, 5, y=6, x=7, a=1, b='abc') 
# 7 6 (3, 5) {'a': 1, 'b': 'abc'}

在Python3之后，新增了keyword-only参数。
keyword-only参数：在形参定义时，在一个*星号之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通的参数了，称为keyword-only参数。

def fn(*args, x):
	print(x, args, sep='\n', end='\n\n')
	
fn(3, 5) #TypeError
fn(3, 5, 7) #TypeError
fn(3, 5, x=7) # 7 (3, 5)

keyword-only参数，言下之意就是这个参数必须采用关键字传参。
可以认为，上例中，args可变位置参数已经截获了所有位置参数，其后的变量x不可能通过位置传参传入了。

keyword-only参数另一种形式

星号后所有的普通参数都成了keyword-only参数。

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

参数的混合使用

# 可变位置参数、keyword-only参数、缺省值
def fn(*args, x=5):
    print(x)
    print(args)
fn() # 等价于fn(x=5)  5 ()
fn(5) # 5 (5,)
fn(x=6) # 6 () 
fn(1,2,3,x=10) # 10 (1, 2, 3)

# 普通参数、可变位置参数、keyword-only参数、缺省值
def fn(y, *args, x=5):
	print('x={}, y={}'.format(x, y))
 	print(args)
fn() #  TypeError    
fn(5) # x=5, y=5 ()
fn(5, 6) # x=5, y=5 (6,)
fn(x=6)  # TypeError 
fn(1, 2, 3, x=10) # x=10, y=1 (2, 3)
fn(y=17, 2, 3, x=10)  # fn(1, 2, y=3, x=10)  # SyntaxError

# 普通参数、缺省值、可变关键字参数
def fn(x=5, **kwargs):
    print('x={}'.format(x))
    print(kwargs)
fn() # x=5 {}
fn(5)  # x=5 {}
fn(x=6)  # x=6 {}
fn(y=3, x=10)  # x=10 {'y': 3}
fn(3, y=10) # x=3 {'y': 10}
fn(y=3, z=20) # x=5 {'y': 3, 'z': 20}

参数规则

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

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

def connect(host='localhost', port='3306', user='admin', password='admin', **kwargs):
	print(host, port)     
	print(user, password)     
	print(kwargs)
connect(db='cmdb')
connect(host='192.168.1.123', db='cmdb')
connect(host='192.168.1.123', db='cmdb', password='mysql')
# localhost 3306
# admin admin
# {'db': 'cmdb'}
# 192.168.1.123 3306
# admin admin
# {'db': 'cmdb'}
# 192.168.1.123 3306
# admin mysql
# {'db': 'cmdb'}

定义最常用参数为普通参数，可不提供缺省值，必须由用户提供。注意这些参数的顺序，最常用的先定义将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参
如果函数有很多参数，无法逐一定义，可使用可变参数。如果需要知道这些参数的意义，则使用可变关键字参数收集

参数解构：

def add(x, y):
	print(x, y)     
	return x + y
	
add(4, 5) # 4 5 9
add((4, 5)) # TypeError 没有找到Y
t = 4, 5  # 只是对Y的赋值，和函数没啥关系
add(t[0], t[1]) 
add(*t)
add(*(4, 5)) 
add(*[4, 5]) 
add(*{4, 5}) 
add(*range(4, 6))
add(*{'a':10, 'b':11}) # 可以吗？
add(**{'a':10, 'b':11}) # 可以吗？
add(**{'x':100, 'y':110}) # 可以吗？

在给函数提供实参的时候，可以在可迭代对象前使用 * 或者 ** 来进行结构的解构，提取出其中所有元素作为函数的实参
使用 * 解构成位置传参
使用 ** 解构成关键字传参
提取出来的元素数目要和参数的要求匹配

def add(*iterable):
	result = 0
    for x in iterable:
		result += x     
	return result
add(1, 2, 3) # 6
add(*[1, 3, 5]) # 9
add(*range(5)) # 10

二、函数返回值

​ Python函数使用return语句返回“返回值”
​ 所有函数都有返回值，如果没有return语句，隐式调用return None
​ return 语句并不一定是函数的语句块的最后一条语句
​ 一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用 return None
​ 如果有必要，可以显示调用return None，可以简写为return

​ 如果函数执行了return语句，函数就会返回，当前被执行的return语句之后的其它语句就不会被执行了返回值 的作用：结束函数调用、返回“返回值”

​ 函数不能同时返回多个值，看似返回多个值，实际是被python 封装成一个元组

函数作用域***

作用域

​ 一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域

def foo():
	x = 100
print(x)
 # NameError: name 'y' is not defined

函数是一个封装，它会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部x变量不可见。
注意：每一个函数都会开辟一个作用域

作用域分类

全局作用域
在整个程序运行环境中都可见
全局作用域中的变量称为全局变量

局部作用域

​ 在函数、类等内部可见
​ 局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域

​ 也称为本地作用域local

外部变量可以穿透函数内部，函数内部变量对外不可见。

函数嵌套

在一个函数中定义了另外一个函数

def outer():
	def inner():
		print("inner")     
	print("outer")
	inner() 
outer() 
inner()  # 报错 NameError 

内部函数inner不能在外部直接使用，会抛NameError异常，因为它在函数外部不可见。其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已。

嵌套结构的作用域

对比下面嵌套结构，代码执行的效果

def outer1(): 
	o = 65
	def inner():
		print("inner {}".format(o)) 
		print(chr(o))
	inner()
	print("outer {}".format(o))
outer1() 
# inner 65
# A
# veouter 65

def outer2(): 
	o = 65
	def inner():
		o = 97
		print("inner {}".format(o)) 
		print(chr(o))
	inner()
    print("outer {}".format(o))
outer2() 
# inner 97
# a
# outer 65

外层变量在内部作用域可见

global语句

x = 5
def foo():
	global x # 全局变量     
	x += 1
    print(x)
foo()
# 6

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

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

使用了global，foo中的x不再是局部变量了，它是全局变量。

global使用原则

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

闭包***

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

闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉就是JavaScript

def counter():
    c = [0]
    def inc():
        c[0] += 1 # 不会报错，c已经在counter函数中定义过了。而且inc中的使用方式是为c的元素修改值，而不是重新定
        return c[0]
    return inc
foo = counter() 
print(foo(), foo())  # 1 2
c = 100  # c和counter中的c不一样，而inc引用的是自由变量正是counter中的变量c
print(foo()) # 3

上下比较有什么不同，下面不许用global 才行，(尽量别用global)这也就不是闭包了。

def counter():
    count = 0
    def inc():
        global count
        count += 1 
        return count     
    return inc
foo = counter() 
print(foo(), foo())

nonlocal语句

定义：将变量标记为不在本地作用域定义，而是在上级的某一级局部作用域中定义，但不能是全局作用域中定义。

def counter():
        count = 0     
        def inc():
            nonlocal count # 声明变量count不是本地变量
            count += 1
            return count
        return inc
foo = counter() 
print(foo(), foo()) # 1 2

count 是外层函数的局部变量，被内部函数引用。

内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义。

代码中内层函数引用外部局部作用域中的自由变量，形成闭包。

使用nonlocal的上级作用域不能是全局作用域

默认值的作用域

函数也是对象，每个函数定义被执行后，就生成了一个函数对象，和函数名这个标识符关联

函数是对象，有属性。python把函数的默认值放在了函数对象的属性中，这个属性就伴随着这个函数对象的整个生命周期

def foo(xyz=[]):
	xyz.append(1)     
	print(xyz)
foo() # [1]
foo() # [1,1]
print(xyz) # NameError ，当前作用域没有xyz变量

查看foo.__defaults__属性，它是个元组

def foo(xyz=[], m=123, n='abc'):
	xyz.append(1)     	
	print(xyz
print(id(foo), foo.__defaults__) 
foo()
print(id(foo), foo.__defaults__) 
foo()
print(id(foo), foo.__defaults__)

函数地址并没有变，就是说foo这个函数对象的没有变过，调用它，它的属性__defaults__中使用元组保存默认值 xyz默认值是引用类型，引用类型的元素变动，并不是元组的变化

变量名解析原则LEGB

Local，本地作用域、局部作用域的local命名空间。函数调用时创建，调用结束消亡
Enclosing，Python2.2时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡
Build-in，内置模块的命名空间，生命周期从python解释器启动时创建到解释器退出时消亡。例如 print(open)，print和open都是内置的变量

简单概括来说 向内穿透，内部对外不可见

函数的销毁

定义一个函数就是生成一个函数对象，函数名指向的就是函数对象。可以使用del语句删除函数，使其引用计数减1。
可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减1。 Python程序结束时，所有对象销毁。
函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0。