Python函数（九）

Python 函数

在一个完整的项目中，某些功能会反复地使用。将功能封装成函数 ，当要使用某功能时，直接调用函数即可。

一、基础函数

函数的本质：函数就是对功能的封装

函数的优点

1. 简化代码结构，减少了用户写代码的工作量以及重复性

2. 如果想修改某些功能或者调试某个bug，只需要修改对应的函数即可

定义函数

def 函数名(参数列表):                   #参数列表(参数1， 参数2， 参数3，....., 参数n)
    语句
    return 表达式

'''
解释：
def：函数代码块以def关键字开始
函数名：遵循标识符规则
()：是参数列表的开始~结束
参数列表：任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函数调用者那里获取的信息
冒号：函数内容(封装的功能)以冒号开始，并且缩进
语句：函数封装的功能
return：一般用于结束函数的，并返回信息给函数的调用者
表达式：即为要返回给函数调用者的信息，
注意：最后的return表达式，可以不写，那return默认返回的就是None
'''

函数的调用

'''
格式：函数名(参数列表)
函数名：是在使用这个函数功能时的参数
参数列表：函数的调用者给函数传递的信息，可以没有参数，但是小括号不能省略！
函数调用的本质：实参给形参赋值的过程
'''

# 定义一个无参数无返回值的函数
def a_Mprint():
    print("lemon is very cool")
    print("lemon is very handsome")

a_Mprint()    #这就可以理解函数的调用者

函数的参数

# 定义一个有参数、返回值的函数
def get_print(name, age): # 形参(形式参数)：定义函数时小括号中的参数，本质是变量
    return name, age      # 将age变量的值返回给函数调用者那里
r = get_print("at", 18)   # 实参(实际参数)：调用函数时给函数传递的数据，本质是值，并且将return返回的值赋值到r变量里
print(r, type(r))         # ('at', 18) <class 'tuple'>

函数的返回值

# 编写函数，实现功能，给函数两个数，返回这两个数的和
def get_num(num1, num2):
    return num1 + num2         # 将结果返回给函数的调用者,执行完return语句后该函数就会结束，return后面的代码不执行
    print("lemon is very cool")

res = get_num(2, 3)
print(res)

传递参数

# 1、值传递：传递不可变的类型，比如{number、string、tuple}是不可变的，意思就是只改变函数内部，不会改变函数外部
例如：
def func1(num):
    num = num + 10
    print(id(num), num)      # 140709658482624  30

temp = 20
func1(temp)
print(id(temp), temp)        # 140709658482304  20


# 2、引用传递：传递可变的类型，比如{list、dict、set}是可变的，意思就是不管是函数内部还是外部全都一并改变
例如：
def func2(list1):
    list1[0] = 100
    print(id(list1), list1)         # 2010828005960  [100, 2, 3, 4, 5]

list2 = [1, 2, 3, 4, 5]
func2(list2)
print(id(list2), list2)             # 2010828005960  [100, 2, 3, 4, 5]

关键字参数

# 概念：允许函数调用时参数的顺序与定义不一致
# 例如：
def get_print(name, age):
    print(name, age)                   # lemon 18

get_print(age = 18, name = "lemon")    #使用关键字参数

默认参数

# 概念：调用函数是，如果没有传递参数，则使用默认参数
def a_Mprint(name = "lemon", age = 18):
    print(name, age)          # lemon 18

a_Mprint()     # 如果实参里有数据则优先使用实参参数，如若不然，使用默认参数

# 或者
# 注意：以后如果要使用默认参数，必须将默认参数放到最后面，否则会报错
def a_Mprint(name, age = 18):
    print(name, age)          # lemon 18

a_Mprint("lemon")

不定长参数–>也叫多值参数

# 概念：能处理比定义时更多的参数
# 加了星号(*)的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，他就是一个空元组
def u_good(name, *args):
    print(name)                # lemon
    print(args, type(args))    # ('good', 'gool', 'handsome') <class 'tuple'>
    for i in args:
        print(i)
        # 返回值：
        # good
        # gool
        # handsome

u_good("lemon", "good", "gool", "handsome")



# **代表着键值对的参数字典，和*所代表的意义类似
def u_nice(name, **kwargs):
    print(name)
    print(kwargs, type(kwargs))         # {'age': 18, 'height': 1.75, 'weight': '112'} <class 'dict'>
    return kwargs

res = u_nice("lemon", age=18, height=1.75, weight="112")     # **必须是关键字参数
print(res["age"])                         # 18



# 用函数不定长参数方法统计1~5的总核   1+2+3+4+5 = 15
def i_jbk(*fet):          # (1, 2, 3, 4, 5) <class 'tuple'>
    sum = 0
    for i in fet:
        sum += i
    return sum

a_Num = i_jbk(1,2,3,4,5)
print(a_Num)              # 15

匿名函数

# 概念：不使用def关键字这样的语句定义函数，使用lambda来创建匿名函数
# 特点：
# 1、lambda只是一个表达式，函数体比def简单
# 2、lambda的主体是一个表达式，而不是代码块，仅仅只能在lambad表达式中封装简单的逻辑
# 3、lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数
# 4、虽然lambda是一个表达式且看起来只能写一行，与C和C++内联函数不同

# 格式：lambda 参数1， 参数2，......, 参数n: expression(表达式)
#例如：
u_sum = lambda num1, num2: num1 * num2
net = u_sum(2, 5)
print(net)          # 10

二、装饰器及偏函数

1、装饰器

概念：是一个闭包，比一个函数当作参数返回一个替代般的函数，本质上就是一个返回函数的函数

作用：装饰器就是给函数增加一些功能的

闭包案例

def test1(a, b):
    def test2(x):
        print(a * b + x)

    return test2

line1 = test1(2, 3)
line2 = test1(2, 5)
line1(4)
line2(10)

简单的装饰器

def func1():
    print("lemon is very handsome")

def outer(func):
    def inner():
        print("**********************")
        func()
    return inner

# f 是函数func1的升级版本
f = outer(func1)

# f()就是引用了inner函数
f()

复杂一点的装饰器

def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner

#使用@符号将装饰器应用到函数
#从python2.4就开始支持使用@符号
@outer    #相当于say = outer(say)
def say(age):
    print("lemon is %d years old" % (age))

# say = outer(say)
say(-10)

通用装饰器（常用）

# 上面的两个装饰器都是有缺陷的及不通用的！
def outer(func):
    def inner(*args, **kwargs):
        #添加修改的功能
        print("&&&&&&&&&&&&&&&")
        func(*args, **kwargs)
    return inner

@outer
def say(name, age):     #函数的参数理论上是无限制的，但实际上最好不要超过6~7个
    print("my name is %s, I am %d years old" % (name, age))

say("lemon", 18)

2、偏函数

把一个参数固定住，形成一个新的函数

import functools
ints1 = functools.partial(int, base = 2)     # base按照二进制运算
print(ints1("1010"))          # 10



#偏函数
def ints2(str, base = 10):    # base按照十进制运算
    return int(str, base)

res = ints2("1010")
print(res)                    # 1010

三、高阶函数

1、filter

功能: 用于过滤序列的，意思就是把传入的函数依次作用于序列的每个元素，根据返回的是True还是False来决定是否保留该元素

filter()

原型: filter(fn, lsd)

参数fn: 是函数

参数lsd: 是序列或列表

list1 = [1, 2, 3, 4, 5, 6, 7]
# 筛选条件
def lem(num):
    #偶数保留
    if num % 2 == 0:
        return True
    # 基数剔除
    return False

t = filter(lem, list1)
print(list(t))

2、map 与 reduce

Google 文章 map reduce，python内置了map()和reduce()函数。

map()

功能: 将传入的函数依次作用在序列中的每一个元素，并把结果作为新的Iterator返回

原型: map(fn, lsd)

参数fn: 是函数

参数lsd: 是序列或列表

# 将所有单个字符转成对应的字面量整数；["1", "2", "3", "4"]   -->   [1, 2, 3, 4]
def chr2int(chr):
    return {"0":0, "1":1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9}[chr]

list1 = ["2", "1", "6", "5"]
res = map(chr2int, list1)             # 相当于： [chr2int("2"), chr2int("1"), chr2int("6"), chr2int("5")]
print(res)
print(list(res))


# 将整数元素的序列，转为字符串类型；[1, 2, 3, 4]   -->   ["1", "2", "3", "4"]
n = map(str, [1, 2, 3, 4])
print(list(n))

reduce()

功能: 一个函数作用在序列上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素累计运算，知道序列为空为止。

• 比如：reduce(f, [a, b, c, d ])
• 相当于： a+b=ab ab+c=abc abc+d=abcd

原型: reduce(fn, lsd)

参数fn: 是函数

参数lsd: 是序列或列表

# 求一个序列的和
from functools import reduce
list2 = [1, 2, 3, 4, 5]
# 1 + 2
# 1 + 2 + 3
# 1 + 2 + 3 + 4
# 1 + 2 + 3 + 4 + 5 = 15
def mySum(x, y):
    return x + y

r = reduce(mySum, list2)
print(f"r = {r}")

map-reduce联合使用，将字符串转成对应字面量数字；不用int()

def str2int(str):
    def fc(x, y):
        return x * 10 + y
    def fs(chr):
        return {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9}[chr]
    return reduce(fc, map(fs, list(str)))

a = str2int("1230")
print(a, type(a))