PYTHON 函数

1.1 函数

函数是可以反复执行的代码块，具有函数名，参数，返回值。

1.2 定义函数

函数必须先定义后执行。

def 函数名(参数列表):
    函数体
    return 返回值

没的返回数据时，返回None

def circle_area(radius: float) -> float:
    return 3.14 * radius * radius

radius = 15
area = circle_area(radius)
print("半径是{}圆的面积是：{}.".format(radius, area))

1.3 函数的参数

传递参数有多种形式

1.3.1 使用关键字参数

在调用时写上参数的名称。

• 调用时可以不按定义顺序，指定名称就可以。
• 如果一个参数用关键字参数，后面的参数都需要用关键字参数

def rect_area(width: float, height: float) -> float:
    return width * height


print(rect_area(width=100,height=30))

1.3.2 参数默认值

在定义函数时为参数指定一个默认值，调用时不传递数据则按默认值计算。

def rect_area(width: float, height: float = 30.0) -> float:
    return width * height


print(rect_area(width=100, height=30))
# 结果同上，height按默认值30计算
print(rect_area(width=100))

1.3.3 可变参数

一个函数可以接收不确定数量的参数。

1.3.3.1 *可变参数

可以传递任意数量的参数（位置参数）

# *args会被包装成一个元组
def calc_sum(*args) -> float:
    print(type(args))  # tuple
    _sum = 0
    for value in args:  # 遍历元组获取里面的值
        _sum += value
    return _sum

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

# 如果传递的是一个元组对象，必须解包： *元组对象
print(calc_sum(*(3,4,5)))

对于可变参数后面有普通参数的的调用：

def calc_sum(*args, multiple:int) -> float:
    print(type(args))
    _sum = 0
    for value in args:
        _sum += value
    return _sum * multiple

# 在调用时必须按关键字参数指定其名称
print(calc_sum(1,2,3,4,5, multiple=10))

1.3.3.1 **可变参数

这些参数会被包装成一个字典(关键字参数)

def put_student(**info) -> None:
    print(type(info))  # dict
    for key, value in info.items():
        print("{} -> {}".format(key, value))


put_student(name="张三", sex="男", age=10)

# 如果传递的是字典对象，必须解包： **字典对象
put_student(**{'name': '李四', 'sex': '男', 'age': 10})

1.3.4 强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

1.4 函数返回值

返回值有三种形式：

• 无返回值
• 返回单一值： return 5
• 返回多个值：return 5,6

1.4.1 无返回值

无返回值实际上返回一个None，表示没有。

Python中的None 是什么？

• python中的None是一个特殊的常量

• 它既不是0，也不是False，也不是空字符串。它只是一个空值的对象，也就是一个空的对象

• None可作为一个对象，该对象的类型为：NoneTye

• None 表示的含义，更多的是一种不存在，是真正的空，而不是空列表（[]）的空，也不是空的字符串

def test():
    return
    return None  # 这两个返回意义一样。

1.4.2 返回单一值

def test():
    return 3

1.4.3 返回多个值

多个值之间用逗号分隔，会被打包成元组。

import random

def random_value():
    a = random.randint(0, 100)
    b = random.randint(0, 100)
    return a, b

v = random_value()
print(v, type(v))  # 输出两个值的元组

1.5 递归函数

就是自己调用自己

• 要有一个出口，防止死循环。(结束条件)

def r_sum(n: int) -> int:
    if n == 1:
        return 1  #出口
    else:
        return n + r_sum(n - 1)

print(r_sum(100))

1.6 匿名函数

就是一个没有名称的函数，所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

匿名函数有许多参数，但只能有一个程序码表达式，然后将结果返回。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

匿名函数一般与高阶函数一同使用。

1.6.1 定义匿名函数

lambda:参数1，参数2，... : 一个表达式

f_add = lambda x, y: x + y  # 匿名函数赋值给一个变量，这个变量就是一个函数对象

print(type(f_add))  # <class 'function'>
print(f_add(3,4))

1.7 嵌套函数

默认定义的函数都是全局的，在一个函数内定义函数称为“嵌套函数”

def calc_fun(op):
    # 定义两个嵌套函数
    def add(a, b):
        return a + b

    def sub(a, b):
        return a - b

    # 返回函数对象
    if op == '+':
        return add
    else:
        return sub

f1 = calc_fun('+')
f2 = calc_fun('-')

print(f1(3,3,))  # 6
print(f2(3,3,))  # 0

1.8 高阶函数

1.8.1 filter()过滤函数

filter(function, iterable)

iterable是可迭代对象，函数执行时iterable会被遍历，它的元素逐一传入function函数，function函数返回布尔值，如果为True留下。

返回filter可迭代对象

users = ['Tony', 'Tom', 'Den', 'Alex']
a = filter(lambda x: x.startswith('T'), users)
print(list(a))  # ['Tony', 'Tom']
print(users)  # ['Tony', 'Tom', 'Den', 'Alex']

1.8.2 map()映射函数

map(function,iterable)

iterable是可迭代对象，函数执行时iterable会被遍历，它的元素逐一传入function函数，function函数对传递的元素进行变换， 返回map可迭代对象。

users = ['Tony', 'Tom', 'Den', 'Alex']
a = map(lambda x: x.lower(), users)
print(list(a))  # ['tony', 'tom', 'den', 'alex']