1、特性
减少重复代码
使程序变的可扩展
使程序变得易维护
2、参数
形参变量
只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参
可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
默认参数
# 如果country不指定值，这默认是“CN”
def register(name,age,course,country="CN"):
pass
register('tom',18,'英语')
register('jerry',28,'数学','UK')
位置参数
# 位置参数即常见的参数，必须按照参数顺序传值
def register(name,age,course,country):
pass
register('tom',18,'英语','CN')关键字参数
# 关键字参数即传入参数时，指定给那个参数传值
def register(name,age,course,country):
pass
register('tom',age=18,course='英语','CN')非固定参数
# 用一个参数收集器来收集非固定参数，用*args收集到的是一个元祖，**kwargs收集到的是一个字典
def register(name,age,course,country):
pass
def register_1(name,*args):
print(args)
def register_2(name,**kwargs):
print(kwargs)
register('tom',18,'英语','CN')
register_1('tom',18,'英语','CN') # (18, '英语', 'CN')
register_2('tom',age = 18,course='英语',country='CN') # {'age': 18, 'course': '英语', 'country': 'CN'}注意：
键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后
非固定参数必须放在位置参数之后
3、返回值
函数在执行过程中只要遇到return语句，就会停止执行并返回结果，因此也可以理解为 return 语句代表着函数的结束
如果未在函数中指定return,那这个函数的返回值为None
4、作用域
作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。
在函数中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的函数。
当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用；在其它地方全局变量起作用。
在函数里修改全局变量（使用global关键字）
# global name的作用就是要在函数里声明全局变量name
name = "tom"
def updateStu():
global name
name = "jerry"
print("after change", name)
updateStu() # after change jerry
print("全局name:", name) # 全局name: jerry5、嵌套函数
name = "tom"
def change_name():
name = "jerry"
def change_name2():
name = "cat"
print("第3层打印", name)
change_name2() # 调用内层函数
print("第2层打印", name)
change_name()
print("最外层打印", name)6、匿名函数
匿名函数就是不需要显式的指定函数名
#这段代码
def calc(x,y):
return x**y
print(calc(2,5))
#换成匿名函数
calc = lambda x,y:x**y
print(calc(2,5))匿名函数主要是和其它函数搭配使用
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
print(i)7、递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归的特性：
- 必须有一个明确的结束条件
- 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
def calc(n):
print(n)
if int(n/2) ==0:
return n
return calc(int(n/2))
calc(10)8、高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数,只需满足以下任意一个条件，即是高阶函数
1、接受一个或多个函数作为输入
2、return 返回另外一个函数
def add(x,y,f):
return f(x) + f(y)
res = add(3,-6,abs)
print(res)9、名称空间
又名name space, 顾名思义就是存放名字的地方，存什么名字呢？举例说明，若变量x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方
名称空间共3种，分别如下
- locals: 是函数内的名称空间，包括局部变量和形参
- globals: 全局变量，函数定义所在模块的名字空间
- builtins: 内置模块的名字空间
不同变量的作用域不同就是由这个变量所在的命名空间决定的。
作用域即范围
- 全局范围：全局存活，全局有效
- 局部范围：临时存活，局部有效
查看作用域方法 globals(),locals()
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
- locals 是函数内的名字空间，包括局部变量和形参
- enclosing 外部嵌套函数的名字空间
- globals 全局变量，函数定义所在模块的名字空间
- builtins 内置模块的名字空间
10、闭包
关于闭包，即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包。也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行时，它仍然必需访问其外部函数的局部变量、参数以及其他内部函数。这些局部变量、参数和函数声明（最初时）的值是外部函数返回时的值，但也会受到内部函数的影响。
def outer():
name = 'alex'
def inner():
print("在inner里打印外层函数的变量",name)
return inner
f = outer()
f()闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
11、装饰器
当需要在原有的函数执行前后增加一些额外的操作时，可以是使用装饰器来实现。比如有个一个购物的网站，在添加购物车的时候，需要检测用户是否登录，如果用户登录则添加购物车，未登录，则跳转到登录页面。正如字面意思所表述的一样，对添加购物车的方法进行下装饰，使其具有可以判读用户是否登录的功能。
# _*_coding:utf-8 _*_
is_login = False
def add_cart(*args):
print(args)
print('add a apple to my cart')
def login():
is_login = True
print("login success")
def login_wrapper(fun):
def inner(*args):
if not is_login:
login()
fun(args)
else:
fun(args)
return inner
add_cart = login_wrapper(add_cart)
add_cart('apple','banana','peach')12、生成式
列表生成式
>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> [i for i in range(100) if not (i%2) and (i%3)]
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]字典生成式
>>> {i:i%2 == 0 for i in range(10)}
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}13、生成器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630> 创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：next(g)
generator保存的是算法，每次调用next(g)就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。
定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次被next()调用时从上次返回的yield语句处继续执行。
def fib(max):
n,a,b = 0,0,1
while n < max:
#print(b)
yield b
a,b = b,a+b
n += 1
return 'done'
-----------------------------
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>14、迭代器
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象：
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数。
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
小结：
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python3的for循环本质上就是通过不断调用next()函数实现的，例如：
for x in [1, 2, 3, 4, 5]:
pass完全等价于
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
1916
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
