<h3>1. python函数：</h3>

1. 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2. 函数能提高应用的模块性，和代码的重复利用率。
3. python 提供了许多内置函数

<h4>2. 部分内置函数：</h4>
<h5>2.1 常用的内置函数</h5>
len()、max()、min()、sorted()、range()、sum()
sorted(参数) 将可迭代的数据从小到大按list形式返回
sum(元组/列表)之和


<h5>2.2 进制转换函数：</h5>
● bin() 转换为二进制的函数
● oct() 转换为八进制的函数
● hex() 转换为十六进制的函数
● ord() 将字符转换成对应的ASCII码值
● chr() 将ASCII码值转换成对应的字符

<pre>

a ='asdfhjkhkfA'
len(a)
11
min(a)
'A'
max(a)
's'
range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
help(sorted)
Help on built-in function sorted in module builtin:
sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
sorted(a)
['A', 'a', 'd', 'f', 'f', 'h', 'h', 'j', 'k', 'k', 's']
a
'asdfhjkhkfA'
TypeError: sum expected at most 2 arguments, got 5
sum ((2,3,56,4,4))
69
sum([2,5,3,6])
16
help(sum)
Help on built-in function sum in module builtin:
sum(...)
sum(sequence[, start]) -> value
Return the sum of a sequence of numbers (NOT strings) plus the value
of parameter 'start' (which defaults to 0). When the sequence is
empty, return start.
a = 18
bin(a)
'0b10010'
oct(a)
'022'
hex(a)
'0x12'
ord('a')
97
chr(97)
'a'
</pre>

<h5>2.3 python idle里面查看帮助文档：</h5>

help.png

<h4>3. 自定义函数</h4>
<h5>3.1 函数的基本语法：</h5>
<pre>
def 函数名(参数):
代码块
return [表达式]
</pre>

1. 函数名用来描述这个函数作用的名称，写文档对函数所实现功能的简单描述
2. return 后面的表达式是函数的返回值
3. return 后面不接表达式时返回的是None
   <h5>3.2 函数的调用：函数名（参数）</h5>
   <h5>3.3 函数的参数：</h5>
4. 必备参数(函数定义时)：传入的参数与函数定义时的个数相等且按顺序传入
5. 位置参数(函数调用时)
6. 关键字参数(函数调用)：在函数调用时可以改变传入参数的顺序
7. 默认参数，给参数一个初始值(函数定义时)：在定义函数时将参数赋一个初始值，调用时参数可缺省，也称为可缺省参数
   不传参数，按默认值走;
   传参数，按参数个数及函数参数顺序按传的参数调用.
8. 不定长参数（* 参数名：元组，**参数名：字典）
   */** 返回了一个元组/字典，把参数组合成了一个元组/字典
   ● 定义时候 加 */** 参数 变成元组/字典
   ● 调用时候 加 */** 元组/字典 变成传参

<h5>3.3.1 必备参数：传入的参数个数、顺序必须和函数定义时一样</h5>
<pre>

def function(a,b,c):
return a,b,c
function(1,2,3)
(1, 2, 3)
function('a','b','c')
('a', 'b', 'c')
function(1,2)

Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
function(1,2)
TypeError: function() takes exactly 3 arguments (2 given)
</pre>

<h5>3.3.2 关键字参数：在函数调用时可以改变传入参数的顺序<h5>
<pre>

def function1(a,b,c):
return a,b,c

function1(b='x',c='y',a='z')
('z', 'x', 'y')
function1(1,2,3)
(1, 2, 3)
function1(c=3,b=2,a=1)
(1, 2, 3)
ord('a')
97
>>> chr(97)
'a'
</pre>

<h5>2.3 python idle里面查看帮助文档：</h5>

help.png

<h4>3. 自定义函数</h4>
<h5>3.1 函数的基本语法：</h5>
<pre>
def 函数名(参数):
代码块
return [表达式]
</pre>

1. 函数名用来描述这个函数作用的名称，写文档对函数所实现功能的简单描述
2. return 后面的表达式是函数的返回值
3. return 后面不接表达式时返回的是None
<h5>3.2 函数的调用：函数名（参数）</h5>
<h5>3.3 函数的参数：</h5>
1. 必备参数(函数定义时)：传入的参数与函数定义时的个数相等且按顺序传入
2. 位置参数(函数调用时)
3. 关键字参数(函数调用)：在函数调用时可以改变传入参数的顺序
4. 默认参数，给参数一个初始值(函数定义时)：在定义函数时将参数赋一个初始值，调用时参数可缺省，也称为可缺省参数
不传参数，按默认值走;
传参数，按参数个数及函数参数顺序按传的参数调用.
5. 不定长参数（* 参数名：元组，**参数名：字典）
*/** 返回了一个元组/字典，把参数组合成了一个元组/字典
● 定义时候 加 */** 参数 变成元组/字典
● 调用时候 加 */** 元组/字典 变成传参

<h5>3.3.1 必备参数：传入的参数个数、顺序必须和函数定义时一样</h5>
<pre>
>>> def function(a,b,c):
return a,b,c
>>> function(1,2,3)
(1, 2, 3)
>>> function('a','b','c')
('a', 'b', 'c')
>>> function(1,2)

Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
function(1,2)
TypeError: function() takes exactly 3 arguments (2 given)
</pre>

<h5>3.3.2 关键字参数：在函数调用时可以改变传入参数的顺序<h5>
<pre>
>>> def function1(a,b,c):
return a,b,c

>>> function1(b='x',c='y',a='z')
('z', 'x', 'y')
>>> function1(1,2,3)
(1, 2, 3)
>>> function1(c=3,b=2,a=1)
(1, 2, 3)
</pre>

<h5>3.3.3 默认参数：在定义函数是讲参数赋一个初始值，调用时参数可缺省，也称为可缺省参数</h5>
<pre>

def function2(a=1,b=2,c=3):
return a+b+c

function2()
6
function2(9)
14
function2(9,8)
20
function2(9,8,7)
24
function2(b=8)
12
function2(c=9,b=8)
</pre>

<h5>3.3.4 不定长参数：</h5>
<h6>3.3.4.1 *参数名：元组</h6>
<pre>

def function3(*arg):
s=0
for i in arg:
s+=i

return s

function3(1,2,3,4)
10
a = (1,2,3,4)
function3(*a)
10
</pre>

<h6>3.3.4.2 **参数名：字典</h6>
<pre>

def function4(arg):
for i in arg.items():
print i
function4(name='jane',age=20,sex='female')
('age', 20)
('name', 'jane')
('sex', 'female')
b = dict(a=1,b=2,c=3)
function4(b)
('a', 1)
('c', 3)
('b', 2)
c = {'a':1,'b':2,'c':3}
function4(c)
('a', 1)
('c', 3)
3.3.1 必备参数：传入的参数个数、顺序必须和函数定义时一样</h5>
<pre>
>>> def function(a,b,c):
return a,b,c
>>> function(1,2,3)
(1, 2, 3)
>>> function('a','b','c')
('a', 'b', 'c')
>>> function(1,2)

Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
function(1,2)
TypeError: function() takes exactly 3 arguments (2 given)
</pre>

<h5>3.3.2 关键字参数：在函数调用时可以改变传入参数的顺序<h5>
<pre>
>>> def function1(a,b,c):
return a,b,c

>>> function1(b='x',c='y',a='z')
('z', 'x', 'y')
>>> function1(1,2,3)
(1, 2, 3)
>>> function1(c=3,b=2,a=1)
(1, 2, 3)
</pre>

<h5>3.3.3 默认参数：在定义函数是讲参数赋一个初始值，调用时参数可缺省，也称为可缺省参数</h5>
<pre>
>>> def function2(a=1,b=2,c=3):
return a+b+c

>>> function2()
6
>>> function2(9)
14
>>> function2(9,8)
20
>>> function2(9,8,7)
24
>>> function2(b=8)
12
>>> function2(c=9,b=8)
</pre>

<h5>3.3.4 不定长参数：</h5>
<h6>3.3.4.1 参数名：元组</h6>
<pre>
>>> def function3(arg):
s=0
for i in arg:
s+=i
return s
>>> function3(1,2,3,4)
10
>>> a = (1,2,3,4)
>>> function3(a)
10
</pre>

<h6>3.3.4.2 参数名：字典</h6>
<pre>
>>> def function4(arg):
for i in arg.items():
print i
>>> function4(name='jane',age=20,sex='female')
('age', 20)
('name', 'jane')
('sex', 'female')
>>> b = dict(a=1,b=2,c=3)
>>> function4(b)
('a', 1)
('c', 3)
('b', 2)
>>> c = {'a':1,'b':2,'c':3}
>>> function4(c)
('a', 1)
('c', 3)
('b', 2)
def function5(arg):
for i in arg.keys():
print i,
function5(*c)
a c b
</pre>

<h5>3.4 全局变量和局部变量：</h5>

全局变量：定义在函数外的拥有全局作用域的变量，可以在整个程序范围内访问，全局变量可以在函数内被访问但不可以在函数内被修改
局部变量：定义在函数内部的拥有一个局部作用于的变量，只能在其被申明的函数内部访问

<h6>3.4.1 作用域：局部变量，全局变量</h6>

1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>

x = 2
def funct1():
x =3
function1(b='x',c='y',a='z')
('z', 'x', 'y')
>>> function1(1,2,3)
(1, 2, 3)
>>> function1(c=3,b=2,a=1)
(1, 2, 3)
</pre>

<h5>3.3.3 默认参数：在定义函数是讲参数赋一个初始值，调用时参数可缺省，也称为可缺省参数</h5>
<pre>
>>> def function2(a=1,b=2,c=3):
return a+b+c

>>> function2()
6
>>> function2(9)
14
>>> function2(9,8)
20
>>> function2(9,8,7)
24
>>> function2(b=8)
12
>>> function2(c=9,b=8)
</pre>

<h5>3.3.4 不定长参数：</h5>
<h6>3.3.4.1 参数名：元组</h6>
<pre>
>>> def function3(arg):
s=0
for i in arg:
s+=i
return s
>>> function3(1,2,3,4)
10
>>> a = (1,2,3,4)
>>> function3(a)
10
</pre>

<h6>3.3.4.2 参数名：字典</h6>
<pre>
>>> def function4(arg):
for i in arg.items():
print i
>>> function4(name='jane',age=20,sex='female')
('age', 20)
('name', 'jane')
('sex', 'female')
>>> b = dict(a=1,b=2,c=3)
>>> function4(b)
('a', 1)
('c', 3)
('b', 2)
>>> c = {'a':1,'b':2,'c':3}
>>> function4(c)
('a', 1)
('c', 3)
('b', 2)
>>> def function5(arg):
for i in arg.keys():
print i,
>>> function5(*c)
a c b
</pre>

<h5>3.4 全局变量和局部变量：</h5>

全局变量：定义在函数外的拥有全局作用域的变量，可以在整个程序范围内访问，全局变量可以在函数内被访问但不可以在函数内被修改
局部变量：定义在函数内部的拥有一个局部作用于的变量，只能在其被申明的函数内部访问

<h6>3.4.1 作用域：局部变量，全局变量</h6>
1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>
>>> x = 2
>>> def funct1():
x =3
x = x+1
return x
funct1()
4
x
2
def funct2():
x = x+1
return x

funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>

x = 2
def funct3():
global x
x += 5
return x
x
2
funct3()
7
x

function3(1,2,3,4)
10
>>> a = (1,2,3,4)
>>> function3(a)
10
</pre>

<h6>3.3.4.2 参数名：字典</h6>
<pre>
>>> def function4(arg):
for i in arg.items():
print i
>>> function4(name='jane',age=20,sex='female')
('age', 20)
('name', 'jane')
('sex', 'female')
>>> b = dict(a=1,b=2,c=3)
>>> function4(b)
('a', 1)
('c', 3)
('b', 2)
>>> c = {'a':1,'b':2,'c':3}
>>> function4(c)
('a', 1)
('c', 3)
('b', 2)
>>> def function5(arg):
for i in arg.keys():
print i,
>>> function5(c)
a c b
</pre>

<h5>3.4 全局变量和局部变量：</h5>

全局变量：定义在函数外的拥有全局作用域的变量，可以在整个程序范围内访问，全局变量可以在函数内被访问但不可以在函数内被修改
局部变量：定义在函数内部的拥有一个局部作用于的变量，只能在其被申明的函数内部访问

<h6>3.4.1 作用域：局部变量，全局变量</h6>
1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>
>>> x = 2
>>> def funct1():
x =3
x = x+1
return x
>>> funct1()
4
>>> x
2
>>> def funct2():
x = x+1
return x

>>> funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>
>>> x = 2
>>> def funct3():
global x
x += 5
return x
>>> x
2
>>> funct3()
7
>>> x
7
function3(1,2,3,4)
10
>>> a = (1,2,3,4)
>>> function3(a)
10
</pre>

<h6>3.3.4.2 参数名：字典</h6>
<pre>
>>> def function4(arg):
for i in arg.items():
print i
>>> function4(name='jane',age=20,sex='female')
('age', 20)
('name', 'jane')
('sex', 'female')
>>> b = dict(a=1,b=2,c=3)
>>> function4(b)
('a', 1)
('c', 3)
('b', 2)
>>> c = {'a':1,'b':2,'c':3}
>>> function4(c)
('a', 1)
('c', 3)
('b', 2)
>>> def function5(arg):
for i in arg.keys():
print i,
>>> function5(c)
a c b
</pre>

<h5>3.4 全局变量和局部变量：</h5>

全局变量：定义在函数外的拥有全局作用域的变量，可以在整个程序范围内访问，全局变量可以在函数内被访问但不可以在函数内被修改
局部变量：定义在函数内部的拥有一个局部作用于的变量，只能在其被申明的函数内部访问

<h6>3.4.1 作用域：局部变量，全局变量</h6>
1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>
>>> x = 2
>>> def funct1():
x =3
x = x+1
return x
>>> funct1()
4
>>> x
2
>>> def funct2():
x = x+1
return x

>>> funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>
>>> x = 2
>>> def funct3():
global x
x += 5
return x
>>> x
2
>>> funct3()
7
>>> x
7
</pre>

<h5>3.5 内嵌函数和闭包：</h5>
<h6>3.5.1 如下中func2是func1的内嵌函数，func2函数的作用域是func1的整个内部空间，如果直接在外部调用func2则会报错</h6>
<pre>

def func1():
print 'func1被调用了...'
def func2():

function4(name='jane',age=20,sex='female')
('age', 20)
('name', 'jane')
('sex', 'female')
>>> b = dict(a=1,b=2,c=3)
>>> function4(b)
('a', 1)
('c', 3)
('b', 2)
>>> c = {'a':1,'b':2,'c':3}
>>> function4(c)
('a', 1)
('c', 3)
('b', 2)
>>> def function5(arg):
for i in arg.keys():
print i,
>>> function5(c)
a c b
</pre>

<h5>3.4 全局变量和局部变量：</h5>

全局变量：定义在函数外的拥有全局作用域的变量，可以在整个程序范围内访问，全局变量可以在函数内被访问但不可以在函数内被修改
局部变量：定义在函数内部的拥有一个局部作用于的变量，只能在其被申明的函数内部访问

<h6>3.4.1 作用域：局部变量，全局变量</h6>
1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>
>>> x = 2
>>> def funct1():
x =3
x = x+1
return x
>>> funct1()
4
>>> x
2
>>> def funct2():
x = x+1
return x

>>> funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>
>>> x = 2
>>> def funct3():
global x
x += 5
return x
>>> x
2
>>> funct3()
7
>>> x
7
</pre>

<h5>3.5 内嵌函数和闭包：</h5>
<h6>3.5.1 如下中func2是func1的内嵌函数，func2函数的作用域是func1的整个内部空间，如果直接在外部调用func2则会报错</h6>
<pre>
>>> def func1():
print 'func1被调用了...'
def func2():
print 'func2被调用...'
func2()
func1()
func1被调用了...
func2被调用...
func2()
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
c = {'a':1,'b':2,'c':3}
>>> function4(c)
('a', 1)
('c', 3)
('b', 2)
>>> def function5(arg):
for i in arg.keys():
print i,
>>> function5(**c)
a c b
</pre>

<h5>3.4 全局变量和局部变量：</h5>

全局变量：定义在函数外的拥有全局作用域的变量，可以在整个程序范围内访问，全局变量可以在函数内被访问但不可以在函数内被修改
局部变量：定义在函数内部的拥有一个局部作用于的变量，只能在其被申明的函数内部访问

<h6>3.4.1 作用域：局部变量，全局变量</h6>
1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>
>>> x = 2
>>> def funct1():
x =3
x = x+1
return x
>>> funct1()
4
>>> x
2
>>> def funct2():
x = x+1
return x

>>> funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>
>>> x = 2
>>> def funct3():
global x
x += 5
return x
>>> x
2
>>> funct3()
7
>>> x
7
</pre>

<h5>3.5 内嵌函数和闭包：</h5>
<h6>3.5.1 如下中func2是func1的内嵌函数，func2函数的作用域是func1的整个内部空间，如果直接在外部调用func2则会报错</h6>
<pre>
>>> def func1():
print 'func1被调用了...'
def func2():
print 'func2被调用...'
func2()
>>> func1()
func1被调用了...
func2被调用...
>>> func2()
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
func2()
NameError: name 'func2' is not defined
</pre>

<h6>3.5.2 如下中fun2是fun1的内嵌函数，这里在fun1中直接返回fun2这个函数，这样可以直接在外部传入参数到内部的函数中并返回结果</h6>
<pre>

def fun1(x):
def fun2(y):
return x*y
return fun2

fun1(3)
<function fun2 at 0x038A1B70>
fun1(2)(5)
10
x1 = fun1(4)
x1(6)
24
3.4.1 作用域：局部变量，全局变量</h6>
1. 里面可以访问外面的，外面不能访问里面的
2. 如果里面有用里面，没有用外面
3. 里面可以访问外面的变量，但是不能修改外面的变量
4. 如果里面想要改变外面的变量，申明为 global，可以将外面变量进行修改

<pre>
>>> x = 2
>>> def funct1():
x =3
x = x+1
return x
>>> funct1()
4
>>> x
2
>>> def funct2():
x = x+1
return x

>>> funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>
>>> x = 2
>>> def funct3():
global x
x += 5
return x
>>> x
2
>>> funct3()
7
>>> x
7
</pre>

<h5>3.5 内嵌函数和闭包：</h5>
<h6>3.5.1 如下中func2是func1的内嵌函数，func2函数的作用域是func1的整个内部空间，如果直接在外部调用func2则会报错</h6>
<pre>
>>> def func1():
print 'func1被调用了...'
def func2():
print 'func2被调用...'
func2()
>>> func1()
func1被调用了...
func2被调用...
>>> func2()
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
func2()
NameError: name 'func2' is not defined
</pre>

<h6>3.5.2 如下中fun2是fun1的内嵌函数，这里在fun1中直接返回fun2这个函数，这样可以直接在外部传入参数到内部的函数中并返回结果</h6>
<pre>
>>> def fun1(x):
def fun2(y):
return x*y
return fun2

>>> fun1(3)
<function fun2 at 0x038A1B70>
>>> fun1(2)(5)
10
>>> x1 = fun1(4)
>>> x1(6)
24
</pre>

<h6>3.5.3 如下中fun2是fun1的内嵌函数，当我们在fun2中试图修改x的值的时候，再调用fun1就会报错，这里也是作用域的问题</h6>
<pre>

def fun1():
x=5
def fun2():
x=x
return x
def funct1():
x =3
x = x+1
return x
>>> funct1()
4
>>> x
2
>>> def funct2():
x = x+1
return x

>>> funct2()

Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
funct2()
File "<pyshell#58>", line 2, in funct2
x = x+1
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h6>3.4.2 global 关键字：global语句用来声明x是全局变量，当我们在函数内给x赋值时，它的改变映射到我们在主块中使用的x的值</h6>
<pre>
>>> x = 2
>>> def funct3():
global x
x += 5
return x
>>> x
2
>>> funct3()
7
>>> x
7
</pre>

<h5>3.5 内嵌函数和闭包：</h5>
<h6>3.5.1 如下中func2是func1的内嵌函数，func2函数的作用域是func1的整个内部空间，如果直接在外部调用func2则会报错</h6>
<pre>
>>> def func1():
print 'func1被调用了...'
def func2():
print 'func2被调用...'
func2()
>>> func1()
func1被调用了...
func2被调用...
>>> func2()
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
func2()
NameError: name 'func2' is not defined
</pre>

<h6>3.5.2 如下中fun2是fun1的内嵌函数，这里在fun1中直接返回fun2这个函数，这样可以直接在外部传入参数到内部的函数中并返回结果</h6>
<pre>
>>> def fun1(x):
def fun2(y):
return xy
return fun2

>>> fun1(3)
<function fun2 at 0x038A1B70>
>>> fun1(2)(5)
10
>>> x1 = fun1(4)
>>> x1(6)
24
</pre>

<h6>3.5.3 如下中fun2是fun1的内嵌函数，当我们在fun2中试图修改x的值的时候，再调用fun1就会报错，这里也是作用域的问题</h6>
<pre>
>>> def fun1():
x=5
def fun2():
x*=x
return x
return fun2

fun1()
<function fun2 at 0x038A1BF0>
fun1()()

Traceback (most recent call last):
File "<pyshell#102>", line 1, in <module>
fun1()()
File "<pyshell#100>", line 4, in fun2
x*=x
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h5>3.6 lambda表达式：</h5>

1. 关键字lambda用来创建简单的匿名函数，它既不能包含控制结构也没有return语句，返回的值就仅仅是表达式计算后得到的值。
2. 使用lambda可以省下函数定义的过程，可以使得代码更加精简，对于有些只需要使用一两次的函数，使用lambda也就不需要考虑函数命名的问题
   <h6>3.6.1 lambda表达式： lambda 参数 : 返回值</h6>

<pre>

def fun1(x):
return x+1
fun1(5)
6
lambda x:x+1
3.5.1 如下中func2是func1的内嵌函数，func2函数的作用域是func1的整个内部空间，如果直接在外部调用func2则会报错</h6>
<pre>
>>> def func1():
print 'func1被调用了...'
def func2():
print 'func2被调用...'
func2()
>>> func1()
func1被调用了...
func2被调用...
>>> func2()
Traceback (most recent call last):
File "<pyshell#84>", line 1, in <module>
func2()
NameError: name 'func2' is not defined
</pre>

<h6>3.5.2 如下中fun2是fun1的内嵌函数，这里在fun1中直接返回fun2这个函数，这样可以直接在外部传入参数到内部的函数中并返回结果</h6>
<pre>
>>> def fun1(x):
def fun2(y):
return xy
return fun2

>>> fun1(3)
<function fun2 at 0x038A1B70>
>>> fun1(2)(5)
10
>>> x1 = fun1(4)
>>> x1(6)
24
</pre>

<h6>3.5.3 如下中fun2是fun1的内嵌函数，当我们在fun2中试图修改x的值的时候，再调用fun1就会报错，这里也是作用域的问题</h6>
<pre>
>>> def fun1():
x=5
def fun2():
x=x
return x
return fun2

>>> fun1()
<function fun2 at 0x038A1BF0>
>>> fun1()()

Traceback (most recent call last):
File "<pyshell#102>", line 1, in <module>
fun1()()
File "<pyshell#100>", line 4, in fun2
x*=x
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h5>3.6 lambda表达式：</h5>
1. 关键字lambda用来创建简单的匿名函数，它既不能包含控制结构也没有return语句，返回的值就仅仅是表达式计算后得到的值。
2. 使用lambda可以省下函数定义的过程，可以使得代码更加精简，对于有些只需要使用一两次的函数，使用lambda也就不需要考虑函数命名的问题
<h6>3.6.1 lambda表达式： lambda 参数 : 返回值</h6>

<pre>
>>> def fun1(x):
return x+1
>>> fun1(5)
6
>>> lambda x:x+1
<function <lambda> at 0x038A1BF0>
f1 = lambda x:x+1
f1(7)
8

def fun2(x,y=5):
return x+y
fun2(8,9)
17
f2 = lambda x,y=5:x+y
f2(5,6)
11
</pre>

<h6>3.6.2 lambda与内置函数filter,map</h6>
filter()函数相当于过滤器
第一个参数可以是一个函数或者是None，第二个参数为序列

<pre>

filter(None,[1,2,3,False,True])
[1, 2, 3, True]
filter(lambda x:x%3==0,range(10))
[0, 3, 6, 9]


<h6>3.5.2 如下中fun2是fun1的内嵌函数，这里在fun1中直接返回fun2这个函数，这样可以直接在外部传入参数到内部的函数中并返回结果</h6>
<pre>
>>> def fun1(x):
def fun2(y):
return xy
return fun2

>>> fun1(3)
<function fun2 at 0x038A1B70>
>>> fun1(2)(5)
10
>>> x1 = fun1(4)
>>> x1(6)
24
</pre>

<h6>3.5.3 如下中fun2是fun1的内嵌函数，当我们在fun2中试图修改x的值的时候，再调用fun1就会报错，这里也是作用域的问题</h6>
<pre>
>>> def fun1():
x=5
def fun2():
x=x
return x
return fun2

>>> fun1()
<function fun2 at 0x038A1BF0>
>>> fun1()()

Traceback (most recent call last):
File "<pyshell#102>", line 1, in <module>
fun1()()
File "<pyshell#100>", line 4, in fun2
x*=x
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h5>3.6 lambda表达式：</h5>
1. 关键字lambda用来创建简单的匿名函数，它既不能包含控制结构也没有return语句，返回的值就仅仅是表达式计算后得到的值。
2. 使用lambda可以省下函数定义的过程，可以使得代码更加精简，对于有些只需要使用一两次的函数，使用lambda也就不需要考虑函数命名的问题
<h6>3.6.1 lambda表达式： lambda 参数 : 返回值</h6>

<pre>
>>> def fun1(x):
return x+1
>>> fun1(5)
6
>>> lambda x:x+1
<function <lambda> at 0x038A1BF0>
>>> f1 = lambda x:x+1
>>> f1(7)
8

>>> def fun2(x,y=5):
return x+y
>>> fun2(8,9)
17
>>> f2 = lambda x,y=5:x+y
>>> f2(5,6)
11
</pre>

<h6>3.6.2 lambda与内置函数filter,map</h6>
filter()函数相当于过滤器
第一个参数可以是一个函数或者是None，第二个参数为序列

<pre>
>>> filter(None,[1,2,3,False,True])
[1, 2, 3, True]
>>> filter(lambda x:x%3==0,range(10))
[0, 3, 6, 9]
</pre>

<h6>3.6.3 map()函数相当于一次性完成多次的调用</h6>
第一个参数是函数，后面的参数为序列
<pre>

map(lambda x:x**2,range(10))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
</pre>

<h5>3.7 递归：如果一个函数在内部调用自己本身，这个函数就是递归函数</h5>
阶乘 1和0 的阶乘是 1
1! = 1
2! = 12 = 1! * 2
3! = 123 = 2! * 3
4! = 1234 = 3! * 4
n! = 123......(n-1)n = (n-1)! * n
递归来写阶乘和正整数求和：
<pre>

def factorial(n):
if n == 1 or n == 0:
return 1
else:
return factorial(n-1)*n
factorial(5)
120

def sums(n):
if n == 1:
return 1
else:
return sums(n-1)+n
sums(5)
15

fun1()()
File "<pyshell#100>", line 4, in fun2
x=x
UnboundLocalError: local variable 'x' referenced before assignment
</pre>

<h5>3.6 lambda表达式：</h5>
1. 关键字lambda用来创建简单的匿名函数，它既不能包含控制结构也没有return语句，返回的值就仅仅是表达式计算后得到的值。
2. 使用lambda可以省下函数定义的过程，可以使得代码更加精简，对于有些只需要使用一两次的函数，使用lambda也就不需要考虑函数命名的问题
<h6>3.6.1 lambda表达式： lambda 参数 : 返回值</h6>

<pre>
>>> def fun1(x):
return x+1
>>> fun1(5)
6
>>> lambda x:x+1
<function <lambda> at 0x038A1BF0>
>>> f1 = lambda x:x+1
>>> f1(7)
8

>>> def fun2(x,y=5):
return x+y
>>> fun2(8,9)
17
>>> f2 = lambda x,y=5:x+y
>>> f2(5,6)
11
</pre>

<h6>3.6.2 lambda与内置函数filter,map</h6>
filter()函数相当于过滤器
第一个参数可以是一个函数或者是None，第二个参数为序列

<pre>
>>> filter(None,[1,2,3,False,True])
[1, 2, 3, True]
>>> filter(lambda x:x%3==0,range(10))
[0, 3, 6, 9]
</pre>

<h6>3.6.3 map()函数相当于一次性完成多次的调用</h6>
第一个参数是函数，后面的参数为序列
<pre>
>>> map(lambda x:x2,range(10))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
</pre>

<h5>3.7 递归：如果一个函数在内部调用自己本身，这个函数就是递归函数</h5>
阶乘 1和0 的阶乘是 1
1! = 1
2! = 12 = 1! * 2
3! = 123 = 2! * 3
4! = 1234 = 3! * 4
n! = 123......(n-1)n = (n-1)! * n
递归来写阶乘和正整数求和：
<pre>
>>> def factorial(n):
if n == 1 or n == 0:
return 1
else:
return factorial(n-1)n
>>> factorial(5)
120

>>> def sums(n):
if n == 1:
return 1
else:
return sums(n-1)+n
>>> sums(5)
15
</pre>

<h5>3.8 回调函数：</h5>
一般写程序是你调用系统的API，如果把关系反过来，你写一个函数，让系统调用你的函数，那就是回调了，那个被系统调用的函数就是回调函数
<pre>

def my_callback(input):
print 'function my_callback was called with %s input' % (input,)

def caller(input,func):
func(input)

caller(3,my_callback)
function my_callback was called with 3 input

for i in range(5):
caller(i,my_callback)
function my_callback was called with 0 input
function my_callback was called with 1 input
function my_callback was called with 2 input
function my_callback was called with 3 input
function my_callback was called with 4 input
</pre>

<h4>4 扩展练习</h4>
<h6>4.1 根据range()函数，创建一个队浮点数float进行操作的frange()函数：</h6>
<pre>

def frange(start,stop,inc):
result = []
while start < stop:
result.append(start)
start += inc
return result
frange(0,5,0.5)
[0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
</pre>

<h6>4.2 创建一个与range()相同参数逻辑的frange()函数</h6>
<pre>

def frange(start,stop,inc):
result = []
while start < stop:
result.append(start)
start += inc
return result
frange(0,5,0.5)
[0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
</pre>

<pre>

-- coding:utf-8 --

def frange(arg0,arg1=None,arg2=None):
'''
frange(start,stop,inc) #三个参数
frange(start,stop) #两个参数
frange(stop) #一个参数
'''
start = 0.0
inc =1.0
if arg2 is not None: #当调用输入了三个参数
start = float(arg0)
stop = arg1
inc = arg2
elif arg1 is not None: #当调用输入了两个参数
start = float(arg0)
stop = arg1
else: #当调用输入了一个参数
stop = arg0
result = []
while start < (stop-(inc/2)):
result.append(start)
start += inc
return result

frange(2)
[0.0, 1.0]
frange(2,5)
[2.0, 3.0, 4.0]
frange(1,10,2)
[1.0, 3.0, 5.0, 7.0]
</pre>

<h6>4.3 参数综合练习：</h6>
<pre>

def func1(a,b,c=1,d,*e):
print a,b,c
print d
print e
func1(1,2)
1 2 1
()
{}
func1(1,2,3)
1 2 3
()
{}
func1(1,2,3,4)
1 2 3
(4,)
{}
func1(1,2,3,4,5,6,7)
1 2 3
(4, 5, 6, 7)
{}

func1(1,2,3,4,5,6,x=1,y=2,z=3)
1 2 3
(4, 5, 6)
{'y': 2, 'x': 1, 'z': 3}
</pre>

<h6>4.4 return 和 print 的区别：</h6>
print 调用就会 打印输出
return 会返回值 没有return 返回None
<pre>

def func(a,b):
print a+b
def func7(a,b):
return a+b
func(1,2)
3
func7(1,2)
3
func(1,2)+10
3

Traceback (most recent call last):
File "<pyshell#68>", line 1, in <module>
func(1,2)+10
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

type(func(1,2))
3
<type 'NoneType'>
x = func(1,2)
3
x
type(func7(1,2))
<type 'int'>
func7(1,2) + 10
13
</pre>

<h6>4.5 装饰器：</h6>
<pre>

-- coding:utf-8 --

def fun(a): #正常的fun函数，返回乘方
return a*a

def ff1(x): # x 参数类型是函数
def ff2(a):
return x(a)+1 #f1的参数x函数调用ff2的参数a，在此基础上加1
return ff2 #ff1函数返回ff2函数, ff2返回ff1函数的参数的函数加1

@ff1 #相当于 fun1=ff1(fun1)(b) ff1装饰了fun1
def fun1(b):
return b*b

ff1(fun)(3) 相当于 调用fun1(3)

ff1(fun)(2) 相当于 调用fun1(2)

ff1(fun)(3)
10
fun1(3)
10

ff1(fun)(2)
5
fun1(2)
frange(2,5)
[2.0, 3.0, 4.0]
>>> frange(1,10,2)
[1.0, 3.0, 5.0, 7.0]
</pre>

<h6>4.3 参数综合练习：</h6>
<pre>
>>> def func1(a,b,c=1,d,e):
print a,b,c
print d
print e
>>> func1(1,2)
1 2 1
()
{}
>>> func1(1,2,3)
1 2 3
()
{}
>>> func1(1,2,3,4)
1 2 3
(4,)
{}
>>> func1(1,2,3,4,5,6,7)
1 2 3
(4, 5, 6, 7)
{}

>>> func1(1,2,3,4,5,6,x=1,y=2,z=3)
1 2 3
(4, 5, 6)
{'y': 2, 'x': 1, 'z': 3}
</pre>

<h6>4.4 return 和 print 的区别：</h6>
print 调用就会 打印输出
return 会返回值 没有return 返回None
<pre>
>>> def func(a,b):
print a+b
>>> def func7(a,b):
return a+b
>>> func(1,2)
3
>>> func7(1,2)
3
>>> func(1,2)+10
3

Traceback (most recent call last):
File "<pyshell#68>", line 1, in <module>
func(1,2)+10
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
>>> type(func(1,2))
3
<type 'NoneType'>
>>> x = func(1,2)
3
>>> x
>>> type(func7(1,2))
<type 'int'>
>>> func7(1,2) + 10
13
</pre>

<h6>4.5 装饰器：</h6>
<pre>
# -- coding:utf-8 --

def fun(a): #正常的fun函数，返回乘方
return aa

def ff1(x): # x 参数类型是函数
def ff2(a):
return x(a)+1 #f1的参数x函数调用ff2的参数a，在此基础上加1
return ff2 #ff1函数返回ff2函数, ff2返回ff1函数的参数的函数加1

@ff1 #相当于 fun1=ff1(fun1)(b) ff1装饰了fun1
def fun1(b):
return b*b

# ff1(fun)(3) 相当于 调用fun1(3)
# ff1(fun)(2) 相当于 调用fun1(2)

>>> ff1(fun)(3)
10
>>> fun1(3)
10

>>> ff1(fun)(2)
5
>>> fun1(2)
5
</pre>