疯狂Python讲义之函数笔记11

最新推荐文章于 2024-04-11 09:40:22 发布

专业游手好闲

最新推荐文章于 2024-04-11 09:40:22 发布

阅读量371

点赞数

CC 4.0 BY-SA版权

分类专栏： Python

本文链接：https://blog.youkuaiyun.com/XieWinter/article/details/96301506

Python 专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了Python函数的使用，包括定义、参数、返回值、递归、局部函数、函数作为参数和返回值等。重点讨论了关键字参数、默认值、可变参数、逆向参数收集以及函数的参数传递机制。还提到了局部作用域、全局作用域以及如何使用nonlocal关键字。此外，文章涵盖了lambda表达式及其在简化代码和提高性能上的作用。

函数是执行特定任务的一段代码，程序通过将一段代码定义成函数，并为该函数指定一个函数名，这样即可在需要的时候多次调用这段代码。因此，函数是代码复用的重要手段。

1. 函数入门

1.1 定义函数和调用函数

在使用函数之前必须先定义函数，定义函数的语法格式如下：

def 函数名（形参列表）:
    // 由零条到多条可执行语句组成的函数
    [return ［返回值]]

Python 声明函数必须使用def 关键字，对函数语法格式的详细说明如下。

函数名：从语法角度来看，函数名只要是一个合法的标识符即可；从程序的可读性角度来看，函数名应该由一个或多个有意义的单词连缀而成，每个单词的字母全部小写，单词与单词之间使用下画线分隔。
形参列表：用于定义该函数可以接收的参数。形参列表由多个形参名组成，多个形参名之间以英文逗号（，）隔开。一旦在定义函数时指定了形参列表，调用该函数时就必须传入到应的参数值一一谁调用函数，谁负责为形参赋值。

在函数体中多条可执行语句之间有严格的执行顺序，排在函数体前面的语句总是先执行，排在函数体后面的语句总是后执行。

## 定义一个函数，声明2个形参
#def my_max(x, y) : 
#	# 定义一个变量z，该变量等于x、y中较大的值
#	z = x if x > y else y
#	# 返回变量z的值
#	return z
def my_max(x, y) : 
	# 返回一个表达式
	return x if x > y else y

# 定义一个函数，声明一个形参
def say_hi(name) :
	print("===正在执行say_hi()函数===")
	return name + "，您好！"
a = 6
b = 9
# 调用my_max()函数，将函数返回值赋值给result变量
result = my_max(a , b) # ①
print("result:", result)
# 调用say_hi()函数，直接输出函数的返回值
print(say_hi("孙悟空")) # ②

1.2 为函数提供文档

为函数编写说明文档－一只要把一段字符串放在函数声明之后、函数体之前，这段字符串将被作为函数的部分，这个文档就是函数的说明文档。

程序既可通过help（）函数查看函数的说明文档，也可通过函数的__doc__属性访问函数的说明文挡。

def my_max(x, y) : 
    '''
    获取两个数值之间较大数的函数。

    my_max(x, y)
        返回x、y两个参数之间较大的那个
    '''
    # 定义一个变量z，该变量等于x、y中较大的值
    z = x if x > y else y
    # 返回变量z的值
    return z
# 使用help()函数查看my_max的帮助文档
help(my_max)
print(my_max.__doc__)

1.3 多个返回值

如果程序需要有多个返回值，则既可将多个值包装成列表之后返回，也可直接返回多个值。如果Python 函数直接返回多个值， Python 会自动将多个返回值封装成元组。

# coding: utf-8
def fun_mul_ret():
    return 1, 2, 3


a_tuple = fun_mul_ret()       # 元组封包
print(a_tuple)

a, b, c = fun_mul_ret()       # 元组解包
print(a, b, c)

*a_list, c = fun_mul_ret()    # 列表和单个
print(a_list)
print(c)

1.4 递归函数

在一个函数体内调用它自身，被称为函数递归。函数递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

当一个函数不断地调用它自身肘，必须在某个时刻函数的返回值是确定的，即不再调用它自身：否则，这种递归就变成了无穷递归，类似于死循环。因此，在定义递归函数时有一条最重要的规定： 递归一定要向己知方向进行。

def fn(n) :
	if n == 0 :
		return 1
	elif n == 1 :
		return 4
	else :
		# 函数中调用它自身，就是函数递归
		return 2 * fn(n - 1) + fn(n - 2)
# 输出fn(10)的结果
print("fn(10)的结果是:", fn(10))

2. 函数参数

2.1 关键字（ keyword ）参数

Python 允许在调用函数时通过名字来传入参数值。因此，Python 函数的参数名应该具有更好的语义一一程序可以立刻明确传入函数的每个参数的含义。

按照形参位置传入的参数被称为位置参数。如果使用位置参数的方式来传入参数值，则必须严格按照走义函数时指定的顺序来传入参数值。

如果根据参数名来传入参数值，则无须遵守定义形参的顺序，这种方式被称为关键字（ keyword)参数。

调用函数时，混合使用关键字参数和位置参数，则关键字参数必须位于位置参数之后。换句话说，在关键字参数之后的只能是关键字参数。否则，提示语法错误！

# 定义一个函数
def girth(width , height): 
	print("width: ", width)
	print("height: ", height)
	return 2 * (width + height)
# 传统调用函数的方式，根据位置传入参数
print(girth(3.5, 4.8))
# 根据关键字参数来传入参数
print(girth(width = 3.5, height = 4.8))
# 使用关键字参数时可交换位置
print(girth(height = 4.8, width = 3.5))
# 部分使用关键字参数，部分使用位置参数
print(girth(3.5, height = 4.8))

# 位置参数必须放在关键字参数之前，下面代码错误
print(girth(width = 3.5, 4.8))

2.2 参数默认值

在某些情况下，程序需要在定义函数时为一个或多个形参指定默认值一一这样在调用函数时就可以省略为该形参传入参数值，而是直接使用该形参的默认值。

# 为形参指定默认值的语法格式如下：
形参名＝默认值

# 为两个参数指定默认值
def say_hi(name = "孙悟空", message = "欢迎来到疯狂软件"):
	print(name, ", 您好")
	print("消息是：", message)
# 全部使用默认参数
say_hi()
# 只有message参数使用默认值
say_hi("白骨精")
# 两个参数都不使用默认值
say_hi("白骨精", "欢迎学习Python")
# 只有name参数使用默认值
say_hi(message = "欢迎学习Python")

say_hi("欢迎学习Python")

#say_hi(name="白骨精", "欢迎学习Python")

#say_hi("欢迎学习Python" , name="白骨精")

say_hi("白骨精", message="欢迎学习Python")
say_hi(name="白骨精", message="欢迎学习Python")

2.3 参数收集（个数可变的参数）

Python 允许在形参前面添加一个星号（ * ) ，这样就意味着该参数可接收多个参数值，多个参数值被当成元组传入。

Python 允许个数可变的形参可以处于形参列表的任意位置，但Python 要求一个函数最多只能带一个支持“普通”参数收集的形参。

# coding: utf-8
# 定义了支持参数收集的函数
def test(a, *books) :
    print(books)
    print(type(books))          # <class 'tuple'>
    # books被当成元组处理
    for b in books :
        print(b)
    # 输出整数变量a的值
    print(a)
# 调用test()函数
test(5 , "疯狂iOS讲义" , "疯狂Android讲义")

Python 还可以收集关键宇参数，此时Python 会将这种关键宇参数收集成字典。为了让Python能收集关键字参数，需要在参数前面添加两个星号。在这种情况下，一个函数可同时包含一个支持“普通”参数收集的参数和一个支持关键字参数收集的数。

# coding: utf-8
# 定义了支持参数收集的函数
def test(x, y, z=3, *books, **scores) :
    print(x, y, z)
    print(books)
    print(type(books))          # tuple
    print(scores)
    print(type(scores))         # dict 
test(1, 2, 3, "疯狂iOS讲义" , "疯狂Android讲义", 语文=89, 数学=94)
test(1, 2, "疯狂iOS讲义" , "疯狂Android讲义", 语文=89, 数学=94)
test(1, 2, 语文=89, 数学=94)

2.4 逆向参数收集

所谓逆向参数收集，指的是在程序己有列表、元组、字典等对象的前提下，把它们的元素“ 拆开”后传给函数的参数。

逆向参数收集需要在传入的列表、元组参数之前添加一个星号，在字典参数之前添加两个星号。

字典也支持逆向收集，字典将会以关键宇参数的形式传入。

# coding: utf-8
def test(name, message):
    print("用户是: ", name)
    print("欢迎消息: ", message)


my_list = ['孙悟空', '欢迎来疯狂软件']
test(*my_list)


def foo(name, *nums):
    print("name参数: ", name)
    print("nums参数: ", nums)


my_tuple = (1, 2, 3)
# 使用逆向收集，将my_tuple元组的元素传给nums参数
foo('fkit', *my_tuple)

# 使用逆向收集，将my_tuple元组的第一个元素传给name参数，剩下参数传给nums参数
foo(*my_tuple)

# 不使用逆向收集，my_tuple元组整体传给name参数
foo(my_tuple)


def bar(book, price, desc):
    print(book, " 这本书的价格是: ", price)
    print('描述信息', desc)


my_dict = {'price': 89, 'book': '疯狂Python讲义', 'desc': '这是一本系统全面的Python学习图书'}
# 按逆向收集的方式将my_dict的多个key-value传给bar()函数
bar(**my_dict)

2.5 函数的参数传递机制

Python中函数的参数传递机制都是“值传递”。所谓值传递，就是将实际参数值的副本（复制品〉传入函数，而参数本身不会受到任何影响。

def swap(a , b) :
    # 下面代码实现a、b变量的值交换
    a, b = b, a                    # 需要注意，在此先计算出右边表达式的值之后再赋值
    print("swap函数里，a的值是", \
        a, "；b的值是", b)
a = 6
b = 9
swap(a , b)
print("交换结束后，变量a的值是", \
    a , "；变量b的值是", b)

不管什么类型的参数，在Python 函数中对参数直接使用“＝” 符号赋值是没用的，直接使用“＝”符号赋值并不能改变参数。
如果需要让函数修改某些数据，则可以通过把这些数据包装成列表、字典等可变对象，然后把列表、字典等可变对象作为参数传入函数，在函数中通过列表、字典的方法修改它们，这样才能改变这些数据。

def swap(dw):
    # 下面代码实现dw的a、b两个元素的值交换
    dw['a'], dw['b'] = dw['b'], dw['a']
    print("swap函数里，a元素的值是",\
        dw['a'], "；b元素的值是", dw['b'])
    # 把dw直接赋值为None，让它不再指向任何对象
    dw = None
dw = {'a': 6, 'b': 9}
swap(dw)
print("交换结束后，a元素的值是",\
    dw['a'], "；b元素的值是", dw['b'])

2.6 变量作用域

变量的作用范围被称为它的作用域。根据定义变量的位置，变量分为两种。

局部变量。在函数中定义的变量，包括参数，都被称为局部变量。
全局变量。在函数外面、全局范围内定义的变量，被称为全局变量。

不管是在函数的局部范围内还是在全局范围内，都可能存在多个变量，每个变量“持有”该变量的值。从这个角度来看，不管是局部范围还是全局范围，这些变革和它们的值就像一个“看不见”的字典，其中变量名就是字典的key ，变量值就是字典的value。

实际上， Python 提供了如下三个工具函数来获取指定范围内的“变量字典”。

def test ():
    age = 20
    # 直接访问age局部变量
    print(age) # 输出20
    # 访问函数局部范围的“变量数组”
    print(locals()) # {'age': 20}
    # 通过函数局部范围的“变量数组”访问age变量
    print(locals()['age']) # 20
    # 通过locals函数局部范围的“变量数组”改变age变量的值
    locals()['age'] = 12
    # 再次访问age变量的值
    print('xxx', age) # 依然输出20
    # 通过globals函数修改x全局变量
    globals()['x'] = 19
x = 5
y = 20
print(globals()) # {..., 'x': 5, 'y': 20}
# 在全局访问内使用locals函数，访问的是全局变量的“变量数组”
print(locals()) # {..., 'x': 5, 'y': 20}
# 直接访问x全局变量
print(x) # 5
# 通过全局变量的“变量数组”访问x全局变量
print(globals()['x']) # 5
# 通过全局变量的“变量数组”对x全局变量赋值
globals()['x'] = 39
print(x) # 输出39
# 在全局范围内使用locals函数对x全局变量赋值
locals()['x'] = 99
print(x) # 输出99

访问被遮蔽的全局变量：可通过globals （）函数来实现

name = 'Charlie'
def test ():
    # 直接访问name全局变量
    print(globals()['name'])  # Charlie
    name = '孙悟空'
test()
print(name)  # Charlie

在函数中声明全局变量：global 吾句来声明全局变量

name = 'Charlie'
def test ():
    # 声明name是全局变量，后面的赋值语句不会重新定义局部变量
    global name
    # 直接访问name全局变量
    print(name)  # Charlie
    name = '孙悟空'
test()
print(name)  # 孙悟空

3. 局部函数

Python 还支持在函数体内定义函数，这种被放在函数体内定义的函数称为局部函数。

在默认情况下，局部函数对外部是隐藏的，局部函数只能在其封闭（ enclosing ）函数内有效，其封闭函数也可以返回局部函数，以便程序在其他作用域中使用局部函数。

# 定义函数，该函数会包含局部函数
vdef get_math_func(type, nn) :
    # 定义一个计算平方的局部函数
    def square(n) :  # ①
        return n * n
    # 定义一个计算立方的局部函数
    def cube(n) :  # ②
        return n * n * n
    # 定义一个计算阶乘的局部函数
    def factorial(n) :   # ③
        result = 1
        for index in range(2, n + 1) :
            result *= index
        return result
    # 调用局部函数
    if type == "square" :
        return square(nn)
    elif type == "cube":
        return cube(nn)
    else:
        return factorial(nn)
print(get_math_func("square", 3)) # 输出9
print(get_math_func("cube", 3)) # 输出27
print(get_math_func("", 3)) # 输出6

局部函数内的变量也会遮蔽它所在函数内的局部变量

Python 提供了nonlocal 关键字，通过nonlocal 语句即可声明访问赋值语句只是访问该函数所在函数内的局部变量。

def foo ():
    # 局部变量name
    name = 'Charlie'
    def bar ():
        nonlocal name
        # 访问bar函数所在的foo函数的name局部变量
        print(name) # Charlie
        name = '孙悟空'
    bar()
foo()

4. 函数的高级内容

函数本身也是一个对象，函数既可用于赋值，也可用作其他函数的参数，还可作为其他函数的返回值

4.1 使用函数变量

Python 的函数也是一种值：所有函数都是function 对象，这意味着可以把函数本身赋值给变量，就像把整数、浮点数、列表、元组赋值给变量一样。

当把函数赋值给变量之后，接下来程序也可通过该变量来调用函数。

# 定义一个计算乘方的函数
def pow(base, exponent) :
	result = 1
	for i in range(1, exponent + 1) :
		result *= base
	return result
# 将pow函数赋值给my_fun，则my_fun可当成pow使用
my_fun = pow
print(my_fun(3 , 4)) # 输出81
# 定义一个计算面积的函数
def area(width, height) :
	return width * height
# 将area函数赋值给my_fun，则my_fun可当成area使用
my_fun = area
print(my_fun(3, 4)) # 输出12

4.2 使用函数作为函数形参

Python 支持像使用其他参数一样使用函数参数

# 定义函数类型的形参，其中fn是一个函数
def map(data, fn) :    
    result = []
    # 遍历data列表中每个元素，并用fn函数对每个元素进行计算
    # 然后将计算结果作为新数组的元素
    for e in data :
        result.append(fn(e))
    return result
# 定义一个计算平方的函数
def square(n) :
    return n * n
# 定义一个计算立方的函数
def cube(n) :
    return n * n * n
# 定义一个计算阶乘的函数
def factorial(n) :
    result = 1
    for index in range(2, n + 1) :
        result *= index
    return result
data = [3 , 4 , 9 , 5, 8]
print("原数据: ", data)
# 下面程序代码3次调用map()函数，每次调用时传入不同的函数
print("计算数组元素的平方")
print(map(data , square))
print("计算数组元素的立方")
print(map(data , cube))
print("计算数组元素的阶乘")
print(map(data , factorial))
# 获取map的类型
print(type(map))

4.3 使用函数作为返回值

Python 还支持使用函数作为其他函数的返回值

def get_math_func(type) :
    # 定义一个计算平方的局部函数
    def square(n) :  # ①
        return n * n
    # 定义一个计算立方的局部函数
    def cube(n) :  # ②
        return n * n * n
    # 定义一个计算阶乘的局部函数
    def factorial(n) :   # ③
        result = 1
        for index in range(2 , n + 1): 
            result *= index
        return result
    # 返回局部函数
    if type == "square" :
        return square
    if type == "cube" :
        return cube
    else:
        return factorial
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube") # 得到cube函数
print(math_func(5)) # 输出125
math_func = get_math_func("square") # 得到square函数
print(math_func(5)) # 输出25
math_func = get_math_func("other") # 得到factorial函数
print(math_func(5)) # 输出120

5. 局部函数与lambda 表达式

使用lambda 表达式代替局部函数

llambda 表达式的本质就是匿名的、单行函数体的函数。lambda 表达式只能创建简单的函数对象

lambda 表达式的语法格式如下：

lambda [parameter_list ］ ： 表达式

lambda 表达式的几个要点。

lambda 表达式必须使用lambda 关键字定义。
lambda 关键字之后、冒号左边的是参数列表，可以没有参数，也可以有多个参数。如果有多个参数，则需要用逗号隔开，冒号右边是该lambda 表达式的返回值。

两个用途。

对于单行函数，使用lambda 表达式可以省去定义函数的过程，让代码更加简洁。

对于不需要多次复用的函数，使用lambda 表达式可以在用完之后立即释放，提高了性能。

def get_math_func(type) :
    result=1
    # 该函数返回的是Lambda表达式
    if type == 'square':
        return lambda n: n * n  # ①
    elif type == 'cube':
        return lambda n: n * n * n  # ②
    else:
        return lambda n: (1 + n) * n / 2 # ③
# 调用get_math_func()，程序返回一个嵌套函数
math_func = get_math_func("cube")
print(math_func(5)) # 输出125
math_func = get_math_func("square")
print(math_func(5)) # 输出25
math_func = get_math_func("other")
print(math_func(5)) # 输出15.0

a = lambda x, y: x + y
def add(x, y): return x+ y

# 传入计算平方的lambda表达式作为参数
x = map(lambda x: x*x , range(8))        # map() 会根据提供的函数对指定序列做映射
print([e for e in x]) # [0, 1, 4, 9, 16, 25, 36, 49]
# 传入计算平方的lambda表达式作为参数
y = map(lambda x: x*x if x % 2 == 0 else 0, range(8))
print([e for e in y]) # [0, 0, 4, 0, 16, 0, 36, 0]