函数是python为了代码最大程度地重用和最小化代码冗余而提供的基本程序结构
函数是一种设计工具，它能让程序员将复杂的系统分解为可管理的部件； 函数用于将相关功能打包并参数化
在python中可以创建如下4种函数：
1)、全局函数：字义在模块中。直接定义在模块中的函数
2)、局部函数：嵌套于其它函数中。在函数中再定义的函数。
3)、lambda函数：表达式。匿名函数(它仅是一个表达式)，它可以出现在任何位置，很高的录活性。
4)、方法：与特定数据类型关联的函数，并且只能与数据类型相关一起使用。定义在类中的函数。
python也提供了很多内置函数
函数与过程的区别：
函数都有return返回值。返回一个对象
创建函数
def functionName(parameters):
suite
相关概念：
def 是一个可执行语句；因此可以出现在任何能够使用语句的地方，甚至可以嵌套于其它语句，例if或while中。def创建了一个对象并将其赋值给一个变量名(即函数名)
return用于返回结果对象，其为可选项；无return语句的函数自动返回一个None对象；返回多个值时，彼此间使用逗号分隔，且组合为元组形式返回一个对象
def语句运行之后，可以在程序中通过函数后附加括号进行调用 。
例1：
|
1
2
3
4
5
6
7
|
def
printName():
print
"hello"
printName()
def
testFun():
pass
testFun()
|
例2：(注意函数的返回值)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
def
login(username):
if
username
=
=
"Thompson"
:
print
"登录成功"
else
:
print
"登录失败"
if
__name__
=
=
"__main__"
:
uname
=
raw_input
(
"Please enter your name:"
)
login(uname)
例
3
：(注意函数的返回值)
def
login(username):
if
username
=
=
"Thompson"
:
return
"登录成功"
else
:
return
"登录失败"
def
detail(username):
print
username,
"detail information"
if
__name__
=
=
"__main__"
:
uname
=
raw_input
(
"Please enter your name:"
)
result
=
login(uname)
if
result
=
=
"登录成功"
:
detail(uname)
else
:
print
result
|
例4：函数可以定义多个形参，可以为形参设置默认值，但设置默认值的形参必须放置在参数列表的最后一个
|
1
2
3
4
5
6
7
8
9
10
|
def
func1(username,action
=
"听课"
):
print
username,
":"
,action
func1(
"tom"
)
func1(
"eric"
,
"吃饭"
)
例
5
：
def
func1(username,where
=
"北京"
,action
=
"听课"
):
print
username,
":去"
,where,action
func1(
"tom"
)
func1(
"jack"
,
"上海"
)
func1(
"eric"
,action
=
"吃饭"
)
|
函数的作用域：(变量查找的名称空间)
变量名在程序中赋值的位置决定了其能够被访问到的范围。函数定义了本地作用域，即函数内定义的变量，只能生效于本函数内部。模块定义了全局作用域。即在本python脚本中定义的变量，生效于本脚本的任意位置。
变量名引用分三个作用域：首先本地、然后函数内、接着是全局，最后是内置。
说明：在函数1中嵌套的函数2，在函数2中定义的变量称为“本地”；在函数1中定义的变量称为函数外层的；
Python创建、改变或查找变量名都是在名称空间中进行；在代码中变量名被赋值的位置决定了其能被访问到的范围。
函数定义了本地作用域，而模块定义了全局作用域；每个模块都是一个全局作用域，因此全局作用域的范围仅限于单个程序文件；每次对函数的调用都会创建一个新的本地作用域，赋值的变量除非声明为全局变量，否则均为本地变量。
所有的变量名都可以归纳为本地、全局或内置(由__builtin__模块提供)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
def f1():
y = 3
print y
f1()
print y 抛出异常
#!/usr/bin/python27
x = 32
def f1():
x = 43
print x
f1()
print x
chmod
+x test1.py
.
/test1
.py
x = 32
def f1():
y = 43
print x,y
f1()
print x,y
global x 将x定义为全局变量(在本地范围内定义全局变量时使用)
x = 43
print x
|
LEGB 原则: local → enclosing → global → builtin
例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
x = 5
z =
"global"
def f1():
x =
"from f1"
y = 3
print x,z
def f2():
x =
"from f2"
print x,y,z
f2()
f1()
输出结果为：
from f1 global
from f2 3 global
def f1():
x =3
def f2():
y =
"hello"
print x,y
return
f2
a1 = f1()
type
(a1)
a1()
|
函数的参数：
def funcName(arg1,arg2....):
例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
def
f1(x):
print
x
f1(
4
)
f1(
'abcd'
)
def
f2(x,y):
print
x
+
y
f2(
3
,
4
)
f2(
"hello"
,
"world"
)
m
=
3
;n
=
4
def
f3(x,y):
x
-
=
1
print
x,y
f3(m,n)
print
m,n 注意：比较结果值。m、n为数值，是不可变类型，所以m、n的数据不变。
l1
=
[
1
,
2
,
3
]
def
f4(x)
x.pop()
print
x
f4(l1) 将l1对象传递给函数f5
print
l1 比较两次的结果相同，因为列表为可变类型
l1
=
[
1
,
2
,
3
]
def
f5(x):
x.pop()
print
x
f5(l1[:]) 将l1做切片之后的所有值传递给函数f5
|
函数参数的匹配模型：
默认情况下，参数通过其位置进行传递，从左至右，这意味着必须精确地传递和函数头部参数一样多的参数。但也可以通过关键字参数、默认参数或参数容器等改变这种机制：
位置：从左至右
关键字参数：使用"name=value"的语法通过参数名进行匹配(如果关键字参数与位置参数混合时，位置参数必须放在参数列表的左边，所有位置参数写完后，才可以放置关键字参数)
默认参数：定义函数时使用"name=value"的语法直接给变量一个值，从而传入的值可以少于参数个数。(混用有默认和无默认值的参数时，无默认值的参数需放前面)
可变参数：定义函数时使用*开头的参数，可用于收集任意多基于位置的参数；定义函数时使用**，收集关键字参数。
可变参数解包：调用函数时，使用*开头的参数，可用于将参数集合打散，从而传递任意多基于位置或关键字的参数。
例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
def
f10(
*
x):
print
x
f10(m)
f10(m,n)
f10(m,n,z)
def
f11(
*
*
x):
print
x
f11(x
=
1
,y
=
2
,z
=
9
)
#收集关键字参数，并以字典的形式返回。
def
f12(x,
*
y):
#可变参数必须写在后面，不可变参数必须写在左侧(前面)
print
x,y
f12(m,n,o)
#函数调用时，将m的值传递给x，将n与o的值传递给y，y会以元组的形式返回结果
def
f15(
*
x,
*
*
y):
print
x
print
y
f15(m,n,o,i
=
3
,j
=
6
)
#位置参数被"*x"收集，而关键字参数被"**y"收集
l1
=
[
'sun'
,
'mon'
,
'tus'
]
x,y,z
=
l1
print
x,y,z
#将列表分解赋值
def
f17(x,y,z):
print
x,y,z
f17(
*
l1)
#将l1的值分解，并分别传递给变量x、y、z。要求被分解对象的元素个数 要与 函数定义的形参个数相同。
#调用函数时使用*是为了分解参数对象，定义时使用*是为了整合。
def
f18(x,
*
y):
print
x
print
y
f18(m,
*
l1)
#将m的值传递给x，将 l1对象中的元素分解后，传递给y
d1
=
{
'key1'
:
'v1'
,
'key2'
:
'v2'
,
'key3'
:
77
}
def
f19(x,
*
y,
*
*
z):
print
x
print
y
print
z
f19(m,
*
l3,
*
*
d1)
#将m的值传递给x，将l3对象中的元素分解后以元组的形式传递给y，将d1字典对象中的键值对儿分解，并以字典的形式传递给z
#顺序必须是：先位置参数、再任意位置参数、最后任意关键字参数
f19(m,n,o,
*
*
d1)
#将m传递给x，将n与o传递给y，将字典d1对象分解后传递给z
f19(m,n,z,key1
=
'v1'
,key2
=
'v2'
)
#将m传递给x，将n与o传递给y，将关键参数key1='v1',key2='v2'传递给z
|
python闭包：lexical closure
在函数嵌套环境中，如果外层函数直接返回内层函数(即把内层函数做为一个对象当做返回值)，而且内层函数调用了外层函数的变量，那么内层函数会自动记忆外层函数的变量值。 它称为函数的闭合，也称为工厂函数。
例：
def f1(x):
def f2(y):
return y ** x
return f2 函数有嵌套，外层函数会将整个内层函数做为一个函数对象返回，而且内层函数还调用了外层函数定义的变量，此时内层函数会记忆外层函数的相关变量值，这种函数称为闭合函数。
f3=f1(3) 执行f1(3)，将3传递给x，然后外层函数将“内层函数整体”作为一个对象的方式返回并赋值给f3变量。此时的f3 就是内层函数对象，此时的内层函数对象已记忆了x的值为3。
type(f3) 查看f3的类型为函数对象
f3(2) 调用f3这个函数对象，并将2传递给y变量，则最终结果返回 2 ** 3 (即2的3次方)
f3(3) 本次调用就是计算 3 ** 3
f3(4) 本次调用就是计算 4 ** 3
以上的函数也称为工厂函数或闭合函数或函数的闭合特性。
例： f3 = f1(4)
f3(3) 本次就是计算的 3 ** 4 (即3的4次方)
内层函数才是一个真正的函数，而外层函数仅仅是内层函数运行的环境而已。外层函数主要是为内层函数提供运行环境。
def startPos(m,n):
def newPos(x,y):
print "The old position is (%d,%d),and the new position is (%d,%d)." % (m,n,m+x,n+y)
return newPos
action = startPos(10,10)
action(1,2)
action(-1,3)
匿名函数lambda：
lambda仅仅是个表达式，但它有函数的特性；def是个语句。
lambda运算符 lambda args: expression
args: 以逗号分隔的参数列表
expression : 用到args中各参数的表达式
lambda语句定义的代码必须是合法的表达式，不能出现多条件语句(可使用if的三元表达式)和其它非表达式语句，如for和while等。
lambda的首要用途是指定短小的回调函数
lambda将返回一个函数而不是将函数赋值给某变量名。
注意：lambda是一个表达式而非语句；lambda是一个单个表达式，而不是一个代码块
例：
f20 = lambda x,y: x+y lambda本身没有名称，在调用时才为它赋一个变量名(函数名)。
f20(3,4) 它返回3+4的结果；它的效果等同于以下函数：
def f20(x,y):
return x+y
f20(3,4)
f=lambda x,y,z: x+y+z
f(4,5,6)
f2=(lambda x,y,z=10: x+y+z)
f2(4,5)
def 语句创建的函数将赋值给某变量名，而lambda表达式则直接返回函数。lambda可以实现简单函数速写的功能。
l3 = [ (lambda x: x*2), (lambda y: y*3) ]
for i in l3:
print i(4) i的值为lambda函数，i(4)表示将4传递到函数中，最终返回函数的值
装饰器
也称为函数装饰器，它自身是个函数，作用是能够其它函数的功能增强。
函数代码重用，函数功能在不同场景中重用。
1)、装饰器本身是一个函数，用于装饰其它函数
2)、增强被装饰函数的功能：
装饰器需要接收一个函数对象做为参数，然后对其函数做包装（即增强该函数的功能）。
装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能 测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器 的作用就是为已经存在的对象添加额外的功能。
例1：使用装饰函数在函数执行前和执行后分别附加额外功能
|
1
2
3
4
5
6
7
8
|
def
myfunc():
print
"myfunc called"
def
deco(func):
print
"before myfunc() called"
func()
print
"after myfunc() called"
return
func
deco(myfunc)
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
In [5]: def f1():
...: print
"hello uplooking"
...: print
"welcome to python"
...:
In [6]: def f2(func):
...: print
"before ........"
...: func()
...: print
"after........"
...:
In [7]: f2(f1)
before ........
hello uplooking
welcome to python
after........
|
例2：使用语法糖@来装饰函数
|
1
2
3
4
5
6
7
8
|
def
deco(func):
print
"before myfunc() called"
func()
print
"after myfunc() called"
return
func
@deco
def
myfunc():
print
"myfunc called"
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
In [11]: def f3(func):
print
"before .............."
func()
print
"after ..............."
....:
In [12]: @f3
def f4():
print
"xxxxxxxxxxxx"
print
"yyyyyyyyyyyyy"
....:
before ..............
xxxxxxxxxxxx
yyyyyyyyyyyyy
after ...............
或：
def myfunc(x):
return
x
def deco(func):
def _deco(x):
return
func(x)*x
# 不需要返回func，实际上应返回原函数的返回值
return
_deco
myfunc=deco(myfunc)
#前一个myfunc仅是自定义的变量名，后一个myfunc是上面的函数名；等号右侧的表达式返回一个函数
print myfunc(2)
#执行返回的新函数(也就是说将上面定义的myfunc函数代入deco的_deco本地函数，然后执行)
In [21]: def f1(number):
return
number+10
....:
In [22]: def deco(func):
def _deco(x):
return
func(x)*x
return
_deco
....:
In [23]: f2=deco(f1)
In [24]: f2(5)
Out[24]: 75
|
例3：使用内嵌包装函数来确保每次新函数都被调用
内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象
|
1
2
3
4
5
6
7
8
9
10
|
def
deco(func):
def
_deco():
print
"before myfunc() called"
func()
print
"after myfunc() called"
return
_deco
@deco
def
myfunc():
#将myfunc()函数作为参数的形式传递给deco函数的func参数
print
"myfunc called"
myfunc()
|
例4：对带参数的函数进行装饰
内嵌包装函数的形参和返回值与原函数相同，装饰函数返回内嵌包装函数对象
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def
deco(func):
def
_deco(a,b):
print
"before myfunc() called"
ret
=
func(a,b)
print
"after myfunc() called"
return
ret
return
_deco
@deco
def
myfunc(a,b):
print
"myfunc(%s,%s) called"
%
(a,b)
return
a
+
b
myfunc(
1
,
2
)
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
In [27]: def deco(func):
def _deco(x,y):
print
".....function before......."
result=func(x,y)
print
".....function after ......"
return
result
return
_deco
....:
In [28]: @deco
....: def f1(i,j):
....: print
"%d * %d = %d"
% (i,j,i*j)
....:
return
i*j
....:
In [31]: f1(4,6)
.....
function
before.......
4 * 6 = 24
.....
function
after ......
Out[31]: 24
|
例5：对参数数量不确定的函数进行装饰
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
def
deco(func):
def
_deco(
*
args,
*
*
kwargs):
print
"before %s called."
%
func.__name__
ret
=
func(
*
args,
*
*
kwargs)
print
"after %s called. result: %s"
%
(func.__name__, ret)
return
ret
return
_deco
@deco
def
myfunc(a, b):
print
"myfunc(%s,%s) called."
%
(a, b)
return
a
+
b
@deco
def
myfunc2(a, b, c):
print
"myfunc2(%s,%s,%s) called."
%
(a, b, c)
return
a
+
b
+
c
myfunc(
1
,
2
)
myfunc(
3
,
4
)
myfunc2(
1
,
2
,
3
)
myfunc2(
3
,
4
,
5
)
|
例6：在例5的基础上，让装饰器带参数，和上一示例相比在外层多了一层包装。装饰函数名实际上应更有意义些
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
def
deco(arg):
def
_deco(func):
def
__deco():
print
"before %s called [%s]."
%
(func.__name__, arg)
func()
print
"after %s called [%s]."
%
(func.__name__, arg)
return
__deco
return
_deco
@deco
(
"mymodule"
)
def
myfunc():
print
(
" myfunc() called."
)
@deco
(
"module2"
)
def
myfunc2():
print
(
" myfunc2() called."
)
myfunc()
myfunc2()
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
In [48]: def deco(arg):
....: def _deco(func):
....: def __deco(*args):
....: print
"======function before======"
....: func(*args)
....: print
"function after: %s , %s "
% (func.__name__,arg)
....:
return
__deco
....:
return
_deco
....:
In [49]: @deco(
"module1"
)
....: def f1(var):
....: print
"enter arguments:%s"
%var
....:
In [50]: @deco(
"module2"
)
....: def f2(x,y):
....: print
"%d * %d = %d"
% (x,y,x*y)
....:
In [55]: f1(
"test"
)
======
function
before======
enter arguments:
test
function
after: f1 , module1
In [56]: f2(4,6)
======
function
before======
4 * 6 = 24
function
after: f2 , module2
In [57]:
|
例7：让装饰器带 类 参数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
class
locker:
def
__init__(
self
):
print
(
"locker.__init__() should be not called."
)
@
staticmethod
def
acquire():
print
(
"locker.acquire() called.（这是静态方法）"
)
@
staticmethod
def
release():
print
(
" locker.release() called.（不需要对象实例）"
)
def
deco(
cls
):
'''cls 必须实现acquire和release静态方法'''
def
_deco(func):
def
__deco():
print
(
"before %s called [%s]."
%
(func.__name__,
cls
))
cls
.acquire()
try
:
return
func()
finally
:
cls
.release()
return
__deco
return
_deco
@deco
(locker)
def
myfunc():
print
(
" myfunc() called."
)
myfunc()
myfunc()
|
递归
递归需要边界条件，递归前进段和递归返回段：
|
1
2
3
|
def fact(n):
if
n<=1:
return
1
else
:
return
n*fact(n-1)
|
fact(3) 就相当于 3 * fact(3-1) = 3 * 2 * face(1) = 3 * 2 * 1
fact(6)
fact(10)
Python函数式编程：
函数式编程：也称为泛函编程，是一种编程范型。它将电脑运算视为数据上的函数计算，并且避免状态以及可变数据。函数式编程语言最重要的基础是lambda演算，而且lambda演算的函数可以接受函数当作输入、输出。
python支持有限的函数式编程功能:
filter(func,seq) 调用一个布尔函数func来迭代遍历每上seq中的元素；返回一个使func返回值为true的元素的序列。
map(func,seq1[,seq2...]) 将函数func作用于给定序列(seq1)的每个元素，并用一个列表来提供返回值；如果func为None，func表现为一个身份函数，返回一个含有每个序列中元素集合的n个元组的列表。
reduce(func,seq[,init]) 将二元函数作用于seq序列的元素，每次携带一对(先前的结果以及下一个序列元素)，连续地将现有的结果和下一个值作用在获得的随后的结果上，最终将序列减少到一个单一的返回值；如果指定初始值init，第一个比较会是init和序列中的第一个元素，而不是序列的前两个元素。
filter过滤器
例：
|
1
2
3
4
5
6
7
|
def f1(x):
if
x > 20:
return
True
else
:
return
False
l1=[1,5,10,30,80,100]
filter(f1,l1) 返回一个符合条件的列表
|
filter()为已知序列的每个元素调用给定的布尔函数
调用中，返回值为非零值的元素将被添加至一个列表中
作业：/etc/passwd文件中，返回 /bin/bash字串的用户名
map()映射器
map() 将函数调用"映射"到每个序列的对应元素上，并返回一个含有所有返回值的列表
map()将使用func函数对不同序列的同一个元素作运算处理，并将每个元素的处理结果整合成一个元组，最后将所有元组再返回成一个元组列表
例：
|
1
2
3
4
5
6
7
8
9
10
11
|
l1=[0,1,2,3,4,5,6]
l2=[
'Sun'
,
'M'
,
'Tu'
,
'W'
,
'T'
,
'F'
,
'S'
]
map(None,l1,l2) 由于func为None，所以将返回[(0,
'Sun'
),(1,
'M'
),(2,
'Tu'
),(3,
'W'
),(4,
'T'
),(5,
'S'
),(6,
'S'
)] 的一个元组列表
def f3(x):
return
x*2
map(f3,l1)
map(f3,l2)
def f4(x,y):
return
x*2,y*2
map(f4,l1,l2)
|
reduce() 只接收两个参数，返回一个值
|
1
2
3
4
5
6
7
8
9
10
|
def f5(x,y):
return
x+yreduce(f5,l1) 即将l1列表中的每个元素相加，返回结果reduce(f5,l1,10) 将初始值加上l1 列表中的每个元素，返回最终结果。
>>> list1=range(10)
>>> print list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> filter(lambda x:x%2==0,list1)
[0, 2, 4, 6, 8]
>>> map(lambda x:x**2,list1)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> list2=map(lambda x:x**2,list1)
>>> reduce(lambda x,y:x+y, list2)
|
zip函数
|
1
2
3
4
5
|
list1=[1,2,3,4]
list2=[
'a'
,
'b'
,
'c'
,
'd'
]
list3=[11,22,33,44]
print zip(list1,list2,list3)
输出结果为：[(1,
'a'
, 11), (2,
'b'
, 22), (3,
'c'
, 33), (4,
'd'
, 44)]
|
随机函数：
import random
print random.random()
#生成0至1之间的小数
print random.randint(1,5)
#生成1至5的整数
print random.randrange(1,5)
#生成1至4的整数
例：生成六位随机数
code=[]
for i in range(6):
if i==random.randint(1,5):
code.append(str(i))
else:
code.append(chr(random.randint(65,90)))
print "".join(code)
内置md5函数：
import hashlib
hash=hashlib.md5()
hash.update("admin")
print hash.hexdigest()
print hash.digest()
常用内置函数：
print 3*4
print eval("3*4")
#算术运算字符串表达式
print divmod(9,4)
#返回表达式的商及余数
print pow(2, 10)
#返回2的10次方
print chr(65)
#返回Ascii码65对应的字符
print ord("a")
#返回字符"a"对应的Ascii码
list2=["aa","bb","cc"]
for item in enumerate(list2):
print item
#遍历出列表中每个元素的值与对应下标
id type import reload help dir var
dir()和vars()的区别就是dir()只打印属性（属性,属性......）而vars()则打印属性与属性的值（属性：属性值......）
自定义字符串的格式化输出:
str1='I am {0},the working of the {1}'
print str1.format("tom","computer")
输出结果为：I am tom,the working of the computer
执行函数时也可以使用apply(function_name())的方式
总结：
在python语言中，定义(声明)函数时，使用def语句。
def function_name(arg1,....):
func_suite
当程序遇到def时就会生成一个函数对象，并且这个函数对象被命名为func_name(该名称从某种角度上也可以理解成一个变量名，只是该变量名是为了引用一个函数对象而建立的)，并生成函数体。此函数对象靠函数名来引用。函数体内部的语句只有在函数被调用时才会被执行，而函数结束时( 函数返回后)，其内部生成的数据都会被销毁。
列表解析与生成器：
for i in ( j**2 for j in range(1,11)):
print i
生成器不能相列表解析一样将某个元素弹出或添加新元素或切片等。因为生成器并不是列表，它只是模拟了列表的一些行为。所以列表的很多功能在生成器中是无法实现的。
可以使用list将生成器转换成列表
list((i**2 for i in range(1,11)))
生成器本身是延迟计算。可以使用自定义函数实现生成器的功能，如下：
def genNum(x):
y = 0
while y <= x:
yield y yield将返回一个生成器对象。而且每次函数执行都会记录前一次的结果。
y +=1
g1=genNum(10)
type(g1)
g1.next()
g1.next()
def genNum2(n):
m = 1
while m <= n:
yield m**2
m +=1
g2 = genNum2(20)
for i in g2:
print i
函数中使用yield，会返回一个生成器对象。
协程：yield写在表达式右侧，实现协程目的
函数的设计规范：
耦合性：
(1)尽可能通过参数授受输入，适就更多场景。以及通过return产生输出，以保证函数的独立性。
(2)尽量减少使用全局变量进行函数间通信。
(3)不要在函数中修改可变类型的参数。
(4) 避免直接改变定义在另外一个模块中的变量。
聚合性：
(1)每个函数都应该有一个单一的、统一的目标。
(2)每个函数的功能都应该相对简单。
输入：参数、全局变量、文件/流
输出：return语句、可变参数、全局变量、文件/流
