在没有学习函数之前我们的程序是面向过程的，不停的判断，不停的循环，同样的代码重复出现在我们的代码里。函数可以更好的提高我们的 代码质量，避免同样的代码重复出现，而只需要在用的时候调用函数即可执行。此为函数式编程。
函数的定义与执行：
定义函数：def 函数名():
执行函数：函数名()
def func(): #定义函数
print('你好') #函数体
func() #执行函数 #输出结果：
你好
如下需求：
让用户输入年龄，如果小于18岁，打印你好，并打印你是未成年人，否则打印你好，并打印你是未成年人。
无函数实现：
age = input('请输入你的年龄：')
age = int(age)
if age < 18:
print('你好')
print('你是未成年人')
else:
print('你好')
print('你是成年人')
有函数实现：
def age1():
print('你好')
print('你是未成年人')
def age2():
print('你好')
print('你是成年人') age = input('请输入你的年龄：')
age = int(age)
if age < 18:
age1()
else:
age2()
函数的返回值 return
函数在retrun后将终止，后面的内容不执行
def func():
return True
print('a') #这里的内容在retru之后，所以兵不执行
print(func()) #输出结果：
True
函数的参数
普通参数：
上例无参数函数：
def age1():
print('你好')
print('你是未成年人')
def age2():
print('你好')
print('你是成年人') age = input('请输入你的年龄：')
age = int(age)
if age < :
age1()
else:
age2()
上例有参数函数：
一个参数
def age(args):
print('你好')
print('你是%s' %args) age = input('请输入你的年龄：')
age = int(age)
if age < :
age('未成年人')
else:
age(‘成年人')
两个参数：
def func(args1,args2):
print(args1)
print(args2)
func(,) #执行此函数是两个参数按照位置对应，第一个是args1，第二个sargs2 #输出结果：
1
2
默认参数：
默认参数只能放在参数的最后面
def func(args1,args2=):#args2默认为1111，即如果执行函数时不指定args2则args2的参数值为1111
print(args1)
print(args2)
func() #执行函数时没有指定args2 #输出结果： func(,) #执行函数的时候指定了args2
#输出结果：
指定参数：
如果一个函数有多个函数，在执行函数的时候是按照参数顺序分别赋予args1，args2，args3等，指定参数跟参数位置无关。
示例：
def func(args1,args2,args3):
print(args1)
print(args2)
print(args3) func(args3=,args1=,args2=) #输出结果：
动态参数：
类似*args **kwargs，前者会把参数转换为元祖，后者会把函数转换为字典
#传没有事先定义的参数
def s2(*ar,**ar2):
print(ar,type(ar))
print(ar2,type(ar2))
s2(a=) #如果想传字典进去必须用长的方式
s2(,,,) # 这样的参数将被全部转换成数组 #输出结果：
() <class 'tuple'> #传进来的a=，被转换成字典，因此*ar参数不存在，故为空元祖
{'a': } <class 'dict'> #**ar2的参数返回结果
(, , , ) <class 'tuple'> #*ar的返回结果
{} <class 'dict'> #传一个已经定义好的变量的参数
def s2(*ar,**ar2):
print(ar,type(ar))
print(ar2,type(ar2))
l1 = [1,2,3,45,]
d1 = {'1':'a','2':'b'}
#我们的初衷是想把l1和d1分别赋值给*ar和**ar2
s2(l1,d1) #输出结果：
([1, 2, 3, 45], {'1': 'a', '2': 'b'}) <class 'tuple'> #但是结果并不是我们预想的那样，函数把所有的参数转换成一个元祖了。
{} <class 'dict'>
因此我们应该这样执行函数
s2(*l1,**d1)
#输出结果：
(1, 2, 3, 45) <class 'tuple'>
{'1': 'a', '2': 'b'} <class 'dict'>
动态参数在字符串格式化方法中的应用体现：
strs = '{0} is {1}'
lists = ['a','b']
result = strs.format(*lists)
print(result)
#输出结果：
a is b
lambda 表达式
my = lambda a:a+
print(my()) #输出结果：
常用内置函数
map函数
便利整个序列内的元素，并对每个元素进行操作，然后输出。
li = [1,2,3,23,42,12,3,56,34,2,3,2,23,23,2,3,4,44,44,4,343,0,]
a = list(map(lambda args:args+100,li))
print(a)
#输出结果：
[101, 102, 103, 123, 142, 112, 103, 156, 134, 102, 103, 102, 123, 123, 102, 103, 104, 144, 144, 104, 443, 100]
filter函数：
对序列内的每个元素过滤，只有返回为True的才会输出，两个参数，args1为函数，args2为序列，args1可以为None，则过滤空值的预算
#参数为None，只输出非空元素
li = [1,2,3,23,42,12,3,56,34,2,3,2,23,23,2,3,4,44,44,4,343,0,'']
a = list(filter(None,li))
print(a) #输出结果：
[1, 2, 3, 23, 42, 12, 3, 56, 34, 2, 3, 2, 23, 23, 2, 3, 4, 44, 44, 4, 343] #参数为lambda函数，输出条件为True的元素
li = [1,2,3,23,42,12,3,56,34,2,3,2,23,23,2,3,4,44,44,4,343,0,]
a = list(filter(lambda a:a>20,li))
print(a) #输出结果：
[23, 42, 56, 34, 23, 23, 44, 44, 343] #以自定义函数作为参数
li = [1,2,3,23,42,12,3,56,34,2,3,2,23,23,2,3,4,44,44,4,343,0,]
def func(args):
return args >20 and args <200
a = list(filter(func,li))
print(a) #输出结果：
[23, 42, 56, 34, 23, 23, 44, 44]
reduce函数
对于序列内所有元素进行累计操作
注意：
在Python 3里，reduce()函数已经被从全局名字空间里移除了，它现在被放置在fucntools模块里
用的话要 先引入
from functools import reduce
import functools
li = [1,2,3,23,42,12,3,56,34,2,3,2,23,23,2,3,4,44,44,4,343,0,]
a = functools.reduce(lambda args1,args2:args1+args2,li)
print(a) #输出结果：
673