一、python3函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。可以自己创建函数，这被叫做用户自定义函数。
1、定义函数规则
函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
2、语法
python定义函数使用def关键字，格式如下：
def 函数名(参数列表):
函数体
>>> def hello(): #定义简单函数
... print('hello world')
...>>> hello() #执行函数
hello world>>> def yourname(name): #传参函数
... print('your are name is:',name)
...>>> yourname('qi') #执行传参函数
your are name is: qi>>> def multiplication(x,y): #传参运算函数
... return x*y
...>>> multiplication(8,9)723、函数调用
定义一个函数：给函数一个名称，并指定了函数里包含的参数和代码块结构。这个函数的基本结构完成以后。
可以通过另一个函数调用执行，也可以直接从python命令提示符执行
>>> deftimes(date):
...'打印当前时间'...print(date);
...return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
...>>> importtime>>> times('当前时间是')
当前时间是'2017-09-30 23:23:27'
4、参数传递
在 python 中，类型属于对象，变量是没有类型。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值a=5后再赋值a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值la=[1,2,3,4]后再赋值la[2]=5则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。不可变实例：
>>> def changeint(x): #定义函数传参赋值
... x = 100...>>> i1 = 200
>>> changeint(i1) #当将定义的变量赋值给函数调用后，原变量还是不变，只是把i1变量的值复制给了x，它们同时指向这个对象。
>>> print(i1)200传可变对象实例：
可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。
>>> def changelist(l1,v): #定义列表插入函数
... l1.insert(2,v)
...returnl1
...>>> list1 = [1,2,3,4] #列表
>>> changelist(list1,'python') #应用外面的列表，即会影响外面列表的内容
[1, 2, 'python', 3, 4]>>> print(list1) #列表内容被改变
[1, 2, 'python', 3, 4]5、参数类型
必须参数：在一个函数指定需要参数时，在执行函数是必须指定参数，否则会报错
关键字参数：使用关键字传递参数时，参数顺序可以随意，解释器会根据参数名来匹配参数传递
默认参数：调用函数时，如果没有传递参数，则会使用默认参数。
不定长参数：如传递列表，元祖，字典时，参数的个数不定长，可以使用（*）代表不定长，
>>> def foo(user): #必须参数
... print(user,'去旅游')
...>>> foo('张三')张三 去旅游>>> foor() #如不传递参数执行函数会报错
Traceback (most recent call last):
File"", line 1, in NameError: name'foor' is notdefined>>> deffoo(user,action):
...print(action,'去了',user) #通过关键字传递参数给函数实体调用，不用不按顺序
...>>> foo('李四','上班')上班 去了 李四>>> def foo(user,action='北京'): #定义默认参数是必须在最后定义
... print(user,'来自',action)
...>>> foo('zhangsan','shanghai') #如指定则输出指定值
zhangsan 来自 shanghai>>> foo('shangsan') #如指定一个参数则输出默认值
shangsan 来自 北京>>> def foo(user,where='北京',action='旅游'): #定义默认参数
... print(user,'去',where,action)
...>>> foo('zhangsan','shanghai','gongzuo') #指定参数输出
zhangsan 去 shanghai gongzuo>>> foo('lisi') #如只指定一个参数则使用默认参数
lisi 去 北京 旅游>>> foo('lisi',action='工作') #在有多个默认参数时，需指定参数名传参
lisi 去 北京 工作>>> foo('lisi',where='上海',action='学习')
lisi 去 上海 学习>>> def show(*args): #不定长传参
... for i inargs:
...print(i)
...>>> show('zhangsan','lisi','wangwu')
zhangsan
lisi
wangwu>>> l1 = [1,2,3,4]>>>show(l1)
[1, 2, 3, 4]>>> show(*l1) #在列表传参是必须使用*来不定长传参
1
2
3
4
>>> def show(**kargs): #两参数不定长传参，也就是字典传参
... for i inkargs.items():
...print(i)
...>>> show(name='zhangsan',age=9999)
('age', 9999)
('name', 'zhangsan')>>> dict = {'k1':123,'k2':456,'k3':678}>>> show(dict) #在传参字典时会将字典当一个参数传入会报错
Traceback (most recent call last):
File"", line 1, in TypeError: show() takes 0 positional arguments but1was given>>> show(**dict) #必须使用（**）将参数分隔传参
('k1', 123)
('k2', 456)
('k3', 678)6、return语句
return [表达式]语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
>>> deffoo():
...1+1...return...>>> print(foo()) #默认返回None
None>>> deffoo():
...1+1...return 0 #指定返回值
...>>> print(foo())
0>>> deffoo():
...return 1+1...>>> print(foo())2
>>> deffoo():
...print(1+1)
...return 1+2...>>> print(foo())2
37、变量作用域
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
>>> m = 'girl' #全局作用域变量
>>> deffunc():
... m= 'boy' #局部作用域变量
... returnm
...>>> func() #优先使用局部作用域变量
'boy'
>>> print(m) #但不改变全局作用域的变量
girl>>> deffoo():
... num= x + 100 #变量x没有定义会报错
... returnnum
...>>>foo()
Traceback (most recent call last):
File"", line 1, in File"", line 2, infoo
NameError: name'x' is notdefined>>> x = 11 #定义一个全局变量
>>> foo() #则函数会调用全局变量
111
>>> num = 100
>>> deffunc():
... num= 200... x= num + 100...returnx
...>>>func()300
>>> n = 10 #全局
>>> deffoo():
...global n #使用global定义局部变量为全局变量，并会覆盖前面的变量值
... n = 100...returnn
...>>>foo()100
>>> print(n) #全局变量值会改变
100
>>> def foo(): #定义一个嵌套函数
... num = 5...def bar(): #嵌套使用闭包作用域变量
... print(num)
... bar()
...print(num)
...>>>foo()5
5
>>> deffoo():
... num1= 20...defbar():
... z= 30...print(num1)
... bar()
...print(z)
...>>>foo()20Traceback (most recent call last):#而当嵌套内闭包作用域在未定义时引用就会报错
File "", line 1, in File"", line 7, infoo
NameError: name'z' is notdefined>>> deffoo():
... m= 111...defbar():
... n= 222...print(m+n) #在bar()函数中的m就是一个既不属于全局域又不属于局部域的闭包变量，它存活在一个函数的名称空间和作用域，即嵌套作用域
... bar()
...print(m)
...>>>foo()333
111
deffoo():
num2= 400
defbar():print(num2)
num2= 333
print(num2)
bar()
foo()
Traceback (most recent call last):#错误原因为num2为不可变类型，此处不能重新定义
File "", line 1, in File"", line 7, infoo
File"", line 4, inbar
UnboundLocalError: local variable'num2'referenced before assignmentdeffoo():
num2= [400]defbar():print(num2[0])
num2[0]= 333 #如果定义为列表则不会报错了
print(num2[0])
bar()
foo()400
333二、匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
1、语法
lambda函数的语法只包含一个语句
lambda [arg1 [,arg2....argn]]:expression
>>> funct1 = lambda x,y:x+y #生成一个匿名函数
>>> print(funct1(10,43))53
>>> funct2 = lambda x:x**3
>>> print(funct2(2))8
>>> funct3 = lambda x,y=3,z=4:x+y+z #参数可以设置默认值
>>> print(funct3(3))10
>>> print(funct3(3,4,5))12
>>> print(funct3(3,y=9)) #注意多参数传值时需指定参数名
16
>>> print(funct3(3,z=8,y=9))20
>>> list(map(lambda x:x**3,[1,2,3,4,5])) #使map生成序列
[1, 8, 27, 64, 125]>>> list(map(lambda x,y:x+y,[11,22,33,44],[1,2,3,4])) #多个参数传值，如不匹配则以最少为准
[12, 24, 36, 48]>>> list(map((lambda x:x+5),range(10))) #使用迭代器
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]>>> l1 = [(lambda x:x+5),(lambda x:x**2),(lambda x:x/2)] #生成可变列表
>>> print(l1[0](5),l1[1](3),l1[2](10))10 9 5.0
>>> dict1 = {'k1':(lambda x:x**2),'k2':(lambda x:x**3),'k3':(lambda x:x**4)}>>> print(dict1['k1'](2),dict1['k2'](2),dict1['k3'](2)) #生成可变字典
4 8 16
