函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
说白了，函数就是为了实现某一功能的代码段，只要写好以后，就可以重复利用。 你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号起始，并且缩进。return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。先来看下面一个简单的例子:
def my_func(message): print('Got a message: {}'.format(message)) # 调用函数 my_func() my_func('Hello World') # 输出 Got a message: Hello World其中：
def 是函数的声明； my_func 是函数的名称； 括号里面的 message 则是函数的参数； 而 print 那行则是函数的主体部分，可以执行相应的语句； 在函数最后，你可以返回调用结果（return 或 yield），也可以不返回。总结来说：
def name(param1, param2, ..., paramN): statements return/yield value # optional和其他需要编译的语言（比如 C 语言）不一样的是，def 是可执行语句，这意味着函数直到被调用前，都是不存在的。当程序调用函数时，def 语句才会创建一个新的函数对象，并赋予其名字。
再来看一个例子：
def my_sum(a, b): return a + b result = my_sum(3, 5) print(result) # 输出 8定义了 my_sum() 这个函数，它有两个参数 a 和 b，作用是相加；随后，调用 my_sum() 函数，分别把 3 和 5 赋于 a 和 b；最后，返回其相加的值，赋于变量 result，并输出得到 8。
需要注意，主程序调用函数时，必须保证这个函数此前已经定义过，不然就会报错，比如：
my_func('hello world') def my_func(message): print('Got a message: {}'.format(message)) # 输出 NameError: name 'my_func' is not defined但是，如果我们在函数内部调用其他函数，函数间哪个声明在前、哪个在后就无所谓，因为 def 是可执行语句，函数在调用之前都不存在，我们只需保证调用时，所需的函数都已经声明定义：
def my_func(message): my_sub_func(message) # 调用 my_sub_func() 在其声明之前不影响程序执行 def my_sub_func(message): print('Got a message: {}'.format(message)) my_func('hello world') # 输出 Got a message: hello world另外，Python 函数的参数可以设定默认值，比如下面这样的写法：
def func(param = 0): ...在调用函数 func() 时，如果参数 param 没有传入，则参数默认为 0；而如果传入了参数 param，其就会覆盖默认值。
Python 和其他语言相比的一大特点是，Python 是 dynamically typed 的，可以接受任何数据类型（整型，浮点，字符串等等）。对函数参数来说，这一点同样适用。
比如还是刚刚的 my_sum 函数，我们也可以把列表作为参数来传递，表示将两个列表相连接：
print(my_sum([1, 2], [3, 4])) # 输出 [1, 2, 3, 4]同样，也可以把字符串作为参数传递，表示字符串的合并拼接：
print(my_sum('hello ', 'world')) # 输出 hello world当然，如果两个参数的数据类型不同，比如一个是列表、一个是字符串，两者无法相加，那就会报错：
print(my_sum([1, 2], 'hello')) TypeError: can only concatenate list (not "str") to listPython 不用考虑输入的数据类型，而是将其交给具体的代码去判断执行，同样的一个函数（比如这边的相加函数 my_sum()），可以同时应用在整型、列表、字符串等等的操作中。
在编程语言中，我们把这种行为称为多态。这也是 Python 和其他语言，比如 Java、C 等很大的一个不同点。当然，Python 这种方便的特性，在实际使用中也会带来诸多问题。因此，必要时请你在开头加上数据的类型检查。
Python中多态的作用：
让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。
拓展： Java中多态性的表现： 多态性，可以理解为一个事物的多种形态。同样python中也支持多态，但是是有限的的支持多态性，主要是因为python中变量的使用不用声明，所以不存在父类引用指向子类对象的多态体现，同时python不支持重载。在python中 多态的使用不如Java中那么明显，所以python中刻意谈到多态的意义不是特别大。
Java中多态的体现： ① 方法的重载(overload)和重写(overwrite)。 ② 对象的多态性（将子类的对象赋给父类的引用）——可以直接应用在抽象类和接口上 广义上：①方法的重载、重写 ②子类对象的多态性 狭义上：子类对象的多态性（在Java中,子类的对象可以替代父类的对象使用）可更改(mutable)与不可更改(immutable)对象：
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
Python 函数的另一大特性，是 Python 支持函数的嵌套。所谓的函数嵌套，就是指函数里面又有函数，比如：
def f1(): print('hello') def f2(): print('world') f2() f1() # 输出 hello world这里函数 f1() 的内部，又定义了函数 f2()。在调用函数 f1() 时，会先打印字符串’hello’，然后 f1() 内部再调用 f2()，打印字符串’world’。
其实，函数的嵌套，主要有下面两个方面的作用。
第一，函数的嵌套能够保证内部函数的隐私。内部函数只能被外部函数所调用和访问，不会暴露在全局作用域，因此，如果你的函数内部有一些隐私数据（比如数据库的用户、密码等），不想暴露在外，那你就可以使用函数的的嵌套，将其封装在内部函数中，只通过外部函数来访问。比如： def connect_DB(): def get_DB_configuration(): ... return host, username, password conn = connector.connect(get_DB_configuration()) return conn这里的函数 get_DB_configuration，便是内部函数，它无法在 connect_DB() 函数以外被单独调用。也就是说，下面这样的外部直接调用是错误的：
get_DB_configuration() # 输出 NameError: name 'get_DB_configuration' is not defined我们只能通过调用外部函数 connect_DB() 来访问它，这样一来，程序的安全性便有了很大的提高。
第二，合理的使用函数嵌套，能够提高程序的运行效率。我们来看下面这个例子： def factorial(input): # validation check if not isinstance(input, int): raise Exception('input must be an integer.') if input < 0: raise Exception('input must be greater or equal to 0' ) ... def inner_factorial(input): if input <= 1: return 1 return input * inner_factorial(input-1) return inner_factorial(input) print(factorial(5))这里，我们使用递归的方式计算一个数的阶乘。因为在计算之前，需要检查输入是否合法，所以我写成了函数嵌套的形式，这样一来，输入是否合法就只用检查一次。而如果我们不使用函数嵌套，那么每调用一次递归便会检查一次，这是没有必要的，也会降低程序的运行效率。
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量局部变量Python 函数中变量的作用域和其他语言类似。如果变量是在函数内部定义的，就称为局部变量，只在函数内部有效。一旦函数执行完毕，局部变量就会被回收，无法访问，比如下面的例子：
def read_text_from_file(file_path): with open(file_path) as file: ...我们在函数内部定义了 file 这个变量，这个变量只在 read_text_from_file 这个函数里有效，在函数外部则无法访问。
相对应的，全局变量则是定义在整个文件层次上的，比如下面这段代码：
MIN_VALUE = 1 MAX_VALUE = 10 def validation_check(value): if value < MIN_VALUE or value > MAX_VALUE: raise Exception('validation check fails')这里的 MIN_VALUE 和 MAX_VALUE 就是全局变量，可以在文件内的任何地方被访问，当然在函数内部也是可以的。不过，我们不能在函数内部随意改变全局变量的值。比如，下面的写法就是错误的：
MIN_VALUE = 1 MAX_VALUE = 10 def validation_check(value): ... MIN_VALUE += 1 ... validation_check(5)如果运行这段代码，程序便会报错：
UnboundLocalError: local variable 'MIN_VALUE' referenced before assignment这是因为，Python 的解释器会默认函数内部的变量为局部变量，但是又发现局部变量 MIN_VALUE 并没有声明，因此就无法执行相关操作。所以，如果我们一定要在函数内部改变全局变量的值，就必须加上 global 这个声明：
MIN_VALUE = 1 MAX_VALUE = 10 def validation_check(value): global MIN_VALUE ... MIN_VALUE += 1 ... validation_check(5)这里的 global 关键字，并不表示重新创建了一个全局变量 MIN_VALUE，而是告诉 Python 解释器，函数内部的变量 MIN_VALUE，就是之前定义的全局变量，并不是新的全局变量，也不是局部变量。这样，程序就可以在函数内部访问全局变量，并修改它的值了。
另外，如果遇到函数内部局部变量和全局变量同名的情况，那么在函数内部，局部变量会覆盖全局变量，比如下面这种：
MIN_VALUE = 1 MAX_VALUE = 10 def validation_check(value): MIN_VALUE = 3 ...在函数 validation_check() 内部，我们定义了和全局变量同名的局部变量 MIN_VALUE，那么，MIN_VALUE 在函数内部的值，就应该是 3 而不是 1 了。
类似的，对于嵌套函数来说，内部函数可以访问外部函数定义的变量，但是无法修改，若要修改，必须加上 nonlocal 这个关键字：
def outer(): x = "local" def inner(): nonlocal x # nonlocal 关键字表示这里的 x 就是外部函数 outer 定义的变量 x x = 'nonlocal' print("inner:", x) inner() print("outer:", x) outer() # 输出 inner: nonlocal outer: nonlocal如果不加上 nonlocal 这个关键字，而内部函数的变量又和外部函数变量同名，那么同样的，内部函数变量会覆盖外部函数的变量。
def outer(): x = "local" def inner(): x = 'nonlocal' # 这里的 x 是 inner 这个函数的局部变量 print("inner:", x) inner() print("outer:", x) outer() # 输出 inner: nonlocal outer: local问题：可能会有人问，全局变量不可以在函数内部修改，但是对于 list 全局变量，却可以使用 append、extend 之类修改，这是为什么呢?
首先，当全局变量指向的对象不可变时，比如是整型、字符串等等，如果你尝试在函数内部改变它的值，却不加关键字 global，就会抛出异常：
x = 1 def func(): x += 1 func() x ## 输出 UnboundLocalError: local variable 'x' referenced before assignment这是因为，程序默认函数内部的 x 是局部变量，而你没有为其赋值就直接引用，显然是不可行。
不过，如果全局变量指向的对象是可变的，比如是列表、字典等等，你就可以在函数内部修改它了：
x = [1] def func(): x.append(2) func() x ## 输出 [1, 2]当然，需要注意的是，这里的x.append(2)，并没有改变变量 x，x 依然指向原来的列表。事实上，这句话的意思是，访问 x 指向的列表，并在这个列表的末尾增加 2。
闭包其实和刚刚讲的嵌套函数类似，不同的是，这里外部函数返回的是一个函数，而不是一个具体的值。返回的函数通常赋于一个变量，这个变量可以在后面被继续执行调用。
举个例子你就更容易理解了。比如，我们想计算一个数的 n 次幂，用闭包可以写成下面的代码：
def nth_power(exponent): def exponent_of(base): return base ** exponent return exponent_of # 返回值是 exponent_of 函数 square = nth_power(2) # 计算一个数的平方,返回了exponent为2的exponent_of 函数 cube = nth_power(3) # 计算一个数的立方 square # 输出 <function __main__.nth_power.<locals>.exponent(base)> cube # 输出 <function __main__.nth_power.<locals>.exponent(base)> print(square(2)) # 计算 2 的平方 print(cube(2)) # 计算 2 的立方 # 输出 4 # 2^2 8 # 2^3这里外部函数 nth_power() 返回值，是函数 exponent_of()，而不是一个具体的数值。需要注意的是，在执行完square = nth_power(2)和cube = nth_power(3)后，外部函数 nth_power() 的参数 exponent，仍然会被内部函数 exponent_of() 记住。这样，之后我们调用 square(2) 或者 cube(2) 时，程序就能顺利地输出结果，而不会报错说参数 exponent 没有定义了。
上面的程序，我也可以写成下面的形式啊
def nth_power_rewrite(base, exponent): return base ** exponent其实可以，不过，要知道，使用闭包的一个原因，是让程序变得更简洁易读。设想一下，比如你需要计算很多个数的平方，那么你觉得写成下面哪一种形式更好呢？
# 不适用闭包 res1 = nth_power_rewrite(base1, 2) res2 = nth_power_rewrite(base2, 2) res3 = nth_power_rewrite(base3, 2) ... # 使用闭包 square = nth_power(2) res1 = square(base1) res2 = square(base2) res3 = square(base3) ...和上面讲到的嵌套函数优点类似，函数开头需要做一些额外工作，而你又需要多次调用这个函数时，将那些额外工作的代码放在外部函数，就可以减少多次调用导致的不必要的开销，提高程序的运行效率。
另外，闭包常常和装饰器（decorator）一起使用。
再来看一下闭包：
闭包，顾名思义，就是一个封闭的包裹，里面包裹着自由变量，就像在类里面定义的属性值一样，自由变量的可见范围随同包裹，哪里可以访问到这个包裹，哪里就可以访问到这个自由变量。
闭包避免了使用全局变量，此外，闭包允许将函数与其所操作的某些数据（环境）关连起来。这一点与面向对象编程是非常类似的，在面对象编程中，对象允许我们将某些数据（对象的属性）与一个或者多个方法相关联。
一般来说，当对象中只有一个方法时，这时使用闭包是更好的选择。来看一个例子：
def adder(x): def wrapper(y): return x + y return wrapper adder5 = adder(5) #返回了x=5的wrapper函数 print(adder5(10)) 15 print(adder5(7)) 12所有函数都有一个 __closure__属性，如果这个函数是一个闭包的话，那么它返回的是一个由 cell 对象 组成的元组对象。cell 对象的cell_contents 属性就是闭包中的自由变量。
adder5.__closure__[0].cell_contents 5这解释了为什么局部变量脱离函数之后，还可以在函数之外被访问的原因的，因为它存储在了闭包的 cell_contents中了。
在使用函数时需要注意的几点：
Python 中函数的参数可以接受任意的数据类型，使用起来需要注意，必要时请在函数开头加入数据类型的检查；和其他语言不同，Python 中函数的参数可以设定默认值；嵌套函数的使用，能保证数据的隐私性，提高程序运行效率；合理地使用闭包，则可以简化程序的复杂度，提高可读性。参考： 《Python核心技术与实践》 《Python 函数 | 菜鸟教程》 《一步一步教你认识Python闭包》
