python 函数的应用

1. 自定义函数的语法

函数能对程序执行的过程进行封装和重用。

def func_name(parameters):
    expression    
    return(res)

def为创建自定义函数的关键字，即告诉Python，我要准备构造函数了；
- func_name:是用户为自己的函数起的一个名称，最好能够做到见名如见意；
- parameters:为该函数需要使用到的形参，当然你也可以不使用参数；
- expression:就是你的函数实体了，即需要这个实体做什么；
- return也是:个关键字，目的是将最终的结果进行输出；

def my_fun(p):
    print(p)
    return 0

my_fun("第一个函数")  # 函数的调用

第一个函数
0

2. 自定义函数的参数

在Python中，有关自定义函数的参数一共有4种定义，他们分别是：

• 必选参数
• 默认参数
• 可变参数
• 关键字参数

2.1 必选参数

必选参数，顾名思义就是当你在调用一个自定义函数时，必选给函数中的一些参数赋值，否则程序将会报错，并提醒用户“缺少一些必选的位置参数”。

def absent_fun(a):
    print(f"{a}为必选参数，调用时不能忘。")
    
absent_fun("参数a")

参数a为必选参数，调用时不能忘。

# 若在调用时不传参数则会：
absent_fun()

---------------------------------------------------------------------------
TypeError  Traceback (most recent call last)
<ipython-input-16-1988d8bd29f0> in <module>()
      1 #若在调用时不传参数则会：
----> 2 absent_fun()
TypeError: absent_fun() missing 1 required positional argument: 'a'

2.2 默认参数

# 签到打卡
def deafult_fun(name, string = '已签到'):
    print(name + string)
    
names = ['小明','小李', '小张']
for name in names:
    deafult_fun(name)

小明已签到
小李已签到
小张已签到

  其中name为必须参数，因为在函数定义时并没有给他一个初始值，而string参数就是一个默认参数，并假定初始值为'已签到'。若要改变功能则，修改string即可

# 发工资
def deafult_fun(name, string = '，工资已发'):
    print(name + string)
    
names = ['小明','小李', '小张']
for name in names:
    deafult_fun(name)

小明，工资已发
小李，工资已发
小张，工资已发

2.3 可变参数

如果我不确定该给这个函数传入多少个参数的时候，则需要使用可变参数。用一颗星 *
放在参数的前面，就代表了该参数为可变参数。

def add(*args):
    s = sum(args)
    return s 

add(1,2)

3

add(1,2,3)

6

add(1,2,3,4)

10

2.4 关键字参数

  关键字参数：能够实现某个实参指定给某个形参，和给自定义函数设置多少个形参的功能。

# 信息统计 -- 参考微信公众号：数据分析1480
import re

def info(tel, birthday, **args):
    user = {}
    user['tel'] = str(tel)    
    if args.get('id') == None:
        user['birthday']=''.join(re.findall('d+',str(birthday)))           
    else:
        user['birthday']=str(args.get('id'))[6:14]
    user['name'] = args.setdefault('name',None)
    user['gender'] = args.setdefault('gender',0)
    user['income'] = args.setdefault('income',5000)
    user['edu'] = args.setdefault('edu','大专')
    print(user)

info('13272573264','19971022')

{'tel': '13272573264', 'birthday': '19971022', 'name': None, 'gender': 0, 'income': 5000, 'edu': '大专'}

info('13272573264','19971022',name = 'nick',gender = 1,income = '15000')

{'tel': '13272573264', 'birthday': '19971022', 'name': 'nick', 'gender': 1, 'income': '15000', 'edu': '大专'}

  这段代码的含义是，用户注册时必需填写手机号和出生日期，如果除此还填写了身份证号，则以身份证号里面的出生日期为准；如果用户没有填写姓名，则为空（None表示），否则以填写的内容为准；如果用户没有填写性别，则默认为女性（0表示），否则以填写的为准；如果用户没有填写收入状况，则默认为5000，否则以填写的为准；如果用户没有填写学历，则默认为大专，否则以填写内容为准....以此类推，可以填写其他更多的信息，而且还可以将实参与形参一一配对。

def count_income( name, slary, **cutpay):
    income =  slary - sum(cutpay.values())
    print("%s的月收入为：%.2f" %(name,income))

count_income('小张', 1383.5 , 公积金 = 134.78 , 养老保险 = 26.96 , 失业保险 = 13.48, 医疗保险 = 26.96, 工会会费 = 4.16,  所得税 = 33.12)

小张的月收入为：1144.04

另外的计算方式：

count_income('小李', 3176, 迟到= 480 ,请假 = 1028 , 顶撞上司= 1000,旷工=500)

小李的月收入为：168.00

3. 几个特殊到的函数

3.1. 返回函数

函数可以有返回值，除了返回值外，函数中也可以返回函数。

# 函数返回值
def calc_sum(*args):
    su = 0 
    for n in args:
        su += n
    return su

print(calc_sum(1,2,3,4))

10

# 函数返回函数
def ret_sum(*args):
    def calc_sum():
        su = 0 
        for n in args:
            su += n
        return su
    return calc_sum

clc_sum = ret_sum(1,2,3,4)
clc_sum()

10

f1 = ret_sum(1,2,3,4)
f2 = ret_sum(1,2,3,4)
print( f1 == f2)

False

3.2. 递归函数

    如果一个函数在内部调用自身，这个函数就称作递归函数。递归函数的简单定义如下:

  def recurision():
    retrun recurision

# 简单的例子： 求5的阶乘

def fun(n):
    s = 1
    if n != 1:
        s = n * fun(n-1)
    return s 

fun(5)

120

def fun(n):
    if n == 1:
        return 1
    return n * fun(n-1)

fun(5)

120

计算过程如下：

fun(5)
5 * fun(4)
5 * (4 * fun(3))
5 * (4 * (3 * fun(2)))
5 * (4 * (3 * (2 * fun(1)))
5 * (4 * (3 * (2 * 1)))
5 * (4 * (3 * 2))
5 * (4 * 6)
5 * 24
120

3.3. filter()函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。以下是 filter() 方法的语法:
filter(function, iterable)

• function -- 判断函数。
• iterable -- 可迭代对象。

# 过滤出列表中的所有奇数：
def is_odd(n):
    return n % 2 == 1
 
templist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) 
# python 3 返回的是迭代器对象，需要list转化一下：
newlist = list(templist)
print(newlist)

[1, 3, 5, 7, 9]

item for item in filter是Python 3中filter函数的取值方式，因为从Python
3起，filter函数返回的对象从列表改为迭代器（filter object）。filter object支持迭代操作，比如for循环：

# 过滤出1~100中平方根是整数的数：
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
newlist= []
for item in  filter(is_sqr, range(1, 101)):
    newlist.append(item)
print(newlist )

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

3.4. 匿名函数

匿名函数就是不再使用def语句这样的标准形式定义一个函数。 Python使用lambda创建匿名函数。 lambda函数的语法只包含一个语句，语句如下：lambda [arg1 [,arg2,.....argn]]:expression

def fun(x,y):
    return x + y
fun(1,2)

3

fun = lambda x,y : x+ y  
fun(1,2)

3

# 过滤出列表中的所有奇数：
newlist = []
for item in  filter(lambda n : n % 2 ==1,[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
    newlist.append(item)
print(newlist)

[1, 3, 5, 7, 9]

# 过滤出1~100中平方根是整数的数：
import math
newlist = []
for item in  filter(lambda x: math.sqrt(x) % 1 ==0 ,  range(1, 101)):
     newlist.append(item)
print(newlist )

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

3.5. 偏函数

偏函数是将所要承载的函数作为partial()函数的第一个参数，原函数的各个参数依次作为partial()函数的后续参数，除非使用关键字参数。

from functools import partial

def add(m,n):
    return m + n
def sub(m,n):
    return m - n 
def mult(m,n):
    return m * n
def div(m,n):
    if n != 0:
        return m /n
    else:
        print("除数不能为0")
        
partial_fun = partial(add,6,2)
# partial_fun = partial(sub,6,2)
# partial_fun = partial(mult,6,2)
# partial_fun = partial(div,6,2)
partial_fun()

8