1 *2 * 3 * ... * 10，写起来十分不方便，我们为了简便可以写成10！ 这就是抽象，借助抽象我们不用关心底层的具体计算过程，而直接在更高的层次上思考问题。函数就是最基本的一种代码抽象的方式。python内置了很多有用的函数，也可以灵活地自己定义函数。
1.定义
def 函数名(参数1，参数2，....):
函数体
return 返回值
函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。函数可以返回多个值，返回值为单个元组。最好写函数说明
2.调用
要调用一个函数，需要知道函数的名称和参数；调用函数式我们传入的参数数量或者类型不正确会抛出 TypeError 错误
3.参数
参数类型：必需参数、关键字参数、默认参数、不定长参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def printinfo( name, age ):
print ("名字: ", name)
print ("年龄: ", age)
return
printinfo( age=50, name="runoob" )
定义函数时我们可以给参数传递默认值，当调用函数时没有传递该参数值时使用默认参数值。带默认值的参数称为默认参数，而无默认值的参数为必需参数，调用函数时必需参数必填，默认参数选填。默认参数只能定义在必需参数的后面
def per_info(name, sex='男', age=30):
print(name, sex, age)
tuple = ('Peter', '男', 22)
per_info(*tuple)
要将列表或元组中值当参数传入函数，我们可在前面加上*，注意参数的顺序和个数
不定长参数：函数能处理比当初声明时更多的参数，加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。（如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。）
def printinfo( arg1, *vartuple ):
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
printinfo( 10 )
printinfo( 70, 60, 50 )
加了两个星号 ** 的参数会以字典的形式导入。
def printinfo(arg1, **vardict):
print("输出: ")
print(arg1)
print(vardict)
printinfo(1,a=2,b=3)
补充：
可更改(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 函数的参数传递：
不可变类型： 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型： 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，传参数即为传不可变对象和传可变对象。
4.变量作用域
Python的作用域：Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域
变量的查找以 L –> E –> G –>B 的规则查找，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。即可以在if外面访问if中定义的变量，不可以在函数外访问函数中定义的变量
全局变量和局部变量：在函数内部的变量拥有一个局部作用域，在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
global 和 nonlocal关键字
num = 123
def fun1():
global num # 使用 global 关键字声明，使num成为全局变量值可在函数内修改
print(num) # 输出123
num = 456 # 修改全局变量值
fun1()
print(num) # 输出 456,全局变量值被修改
def out():
num = 10 # out函数的内部变量
def inner():
nonlocal num # nonlocal关键字声明，修改嵌套作用域（外层非全局作用域）中的变量
print(num) # 输出10
num = 100 # 修改out内部变量
inner()
print(num) # 输出100
out()
5.匿名函数 lambda
lambda [参数1[,参数2,.....参数n]]:表达式
函数体只能有一个表达式，而不是一个代码块，返回结果为表达式的值
g = lambda x:x*x+1
print(g(3)) # 结果为10
lambda 匿名函数的 if...else..
lambda [arg1 [,arg2,.....argn]]:expression1 if condition else expression2 释义：如果condition 为True，条件表达式的结果为expression1，否则为expression2
funmax = lambda x, y: x if x > y else y # 求两个数最大值 print(funmax(5,2))
func = lambda n: 1 if n == 0 else n * func(n - 1)# 递归求n！ print(func(5))
filter(function,sequence)过滤筛选类，他能过滤筛选序列中的数据，返回可迭代对象。
list1 = [1, 18, 9, 7, 17, 12, 6]
f = filter(lambda x: x % 2 == 0, list1) # 筛选list1中能被2整除的数据，返回值可迭代对象
print(list(f)) # 转换为list 打印出结果，输出[18, 12, 6]
map(function,sequence)将function调用映射到每个序列的对应元素上，返回可迭代对象。
m = map(lambda x: x * 2 + 10, list1) # 对list中的每个值进行操作，返回可迭代对象
print(list(m)) #输出[12, 46, 28, 24, 44, 34, 22]
reduce(function,sequence,[initial])累积函数，function有两个参数，如无initial值，取sequence第一个元素与第二个为function参数，有则initial值作为第一个参数，sequence的第一个参数作为第二个参数。function返回值作为下次调用的第一个参数，取sequence中没选取的后一个参数作为函数第二个参数，依次类推将结果积累返回。
from functools import reduce
r = reduce(lambda x, y: x + y, list1) # 对list中元素进行累积((((((1+18)+9)+7)+17)+12)+6)
print(r) #输出70
r = reduce(lambda x, y: x + y, list1, 1) # 对list中元素进行累积,初始值为1,相当于 1+((((((1+18)+9)+7)+17)+12)+6)
print(r) #输出71
6.可变参数(*args, **kwargs)
*args 序列可变参数
def 函数名([参数,] *args):
函数体
return [返回值]
*args会存放所有未命名的不带键的参数，将这些参数转换为一个元组存储在args中。*args传入参数可以是元组、列表，也可以指不带关键字的任意多个参数。
def variablefun(name, *args):
print(name, end=':')
for arg in args:
print(arg, end=',')
print('')
variablefun('Bobo') # 可变参数可以不传入值
variablefun('woodman', 80, 90, 'man') # 可变参数可以传入任意值
tuple1 = ('女', 20) # 元组或列表前无*可变参数将元组当成一个变量
variablefun('Helen', tuple1) # 传入的是整个元组，函数会认为是一个元组参数 ('女', 20)
variablefun('Baby', *tuple1) # 加了星号，程序会将元组数据拆开，按照顺序传入数据，*tuple1 传入的是两个参数‘女’ 20
**kwargs 键对值可变型参数
def 函数名([参数,] **kwargs ):
函数体
return [返回值]
**kwargs 会存放所有未命名的带有键对值的变量参数，将这些参数转换为一个字典存储在kwargs 中。键对值可变参数中的kwargs 传入参数可以是字典，也可以是任意带关键字的参数
def fun(name, **kwargs):
print('name:', name)
for key, value in kwargs.items():
print(key, ':', value)
print('----------')
fun('woodman') # 可变参数可以不传入值
fun('Bob', sex='男') # 不在参数列表中的参数必须指定键值对
tuple1 = {'sex': '男', 'class': 2016012}
fun('Alan', **tuple1) # 可以传入字典
tuple2 = {'name': 'Heln', 'sex': '女', 'score': 89}
fun(**tuple2) #将参数name也放入了字典tuple2中，通过**tuple2传入函数