python之路(六)-函数相关

在没有学习函数之前我们的程序是面向过程的，不停的判断，不停的循环，同样的代码重复出现在我们的代码里。函数可以更好的提高我们的 代码质量，避免同样的代码重复出现，而只需要在用的时候调用函数即可执行。此为函数式编程。

函数的定义与执行：

定义函数：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 < 18:
    age1()
else:
    age2()

 上例有参数函数：

一个参数

def age(args):
    print('你好')
    print('你是%s' %args)

age = input('请输入你的年龄：')
age = int(age)
if age < 18:
    age('未成年人')
else:
    age(‘成年人')

两个参数：

def func(args1,args2):
    print(args1)
    print(args2)
func(1,2) #执行此函数是两个参数按照位置对应，第一个是args1，第二个sargs2

#输出结果：

1
2

默认参数：

默认参数只能放在参数的最后面

def func(args1,args2=1111):#args2默认为1111，即如果执行函数时不指定args2则args2的参数值为1111
    print(args1)
    print(args2)
func(1) #执行函数时没有指定args2


#输出结果：
1111


func(100,200) #执行函数的时候指定了args2
#输出结果：
100
100

指定参数：

如果一个函数有多个函数，在执行函数的时候是按照参数顺序分别赋予args1，args2，args3等，指定参数跟参数位置无关。

示例：

def func(args1,args2,args3):
    print(args1)
    print(args2)
    print(args3)

func(args3=300,args1=100,args2=200)

#输出结果：
100
200
300

动态参数：

类似*args **kwargs，前者会把参数转换为元祖，后者会把函数转换为字典

#传没有事先定义的参数
def s2(*ar,**ar2):
    print(ar,type(ar))
    print(ar2,type(ar2))
s2(a=1) #如果想传字典进去必须用长的方式
s2(1,2,3,4) # 这样的参数将被全部转换成数组

#输出结果：
() <class 'tuple'>   #传进来的a=2，被转换成字典，因此*ar参数不存在，故为空元祖
{'a': 1} <class 'dict'> #**ar2的参数返回结果
(1, 2, 3, 4) <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+100
print(my(100))

#输出结果：
200

常用内置函数

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