深度解析Python函数的使用与实现

最新推荐文章于 2024-04-02 15:54:20 发布

肖申克的陪伴

最新推荐文章于 2024-04-02 15:54:20 发布

阅读量983

点赞数

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_42076902/article/details/129829602

版权

python 专栏收录该内容

36 篇文章 8 订阅

订阅专栏

在Python中，函数是一段可以重复使用的代码块，用于执行特定的任务。函数可以接受参数，并可以返回值。函数通常用于模块化程序代码，使其更易于维护和重用。

1.函数的作用

来看一个典型的应用场景，用户到ATM机取钱：

在这里插入图片描述

1.输入密码后显示"选择功能"界面
2.查询余额后显示"选择功能"界面
3.取3000钱后显示"选择功能"界面
问题：显示“选择功能”界面需要重复输出给用户，要怎么实现呢？答：使用函数

2.什么是函数

函数是一个被命名的、独立的、完成特定功能的代码段，其可能给调用它的程序一个返回值。

函数的定义通常包括以下部分：

函数名称：遵循标识符的命名规则。
参数列表：包含函数的输入参数，可以是位置参数、默认参数、可变参数、关键字参数等。
函数体：包含了函数的执行代码，完成特定的任务。
返回值：用于向调用方返回结果，可以是任何数据类型，也可以不返回。

函数的定义通常使用关键字 def 开始，然后是函数名称、参数列表和冒号。函数体通常使用缩进来标识。

3.函数的意义

代码重用：将代码逻辑封装到函数中，可以在多个地方调用函数，实现代码的重用，避免代码冗余和重复编写。
模块化程序设计：函数的定义使得程序的各个部分更加独立，方便程序的模块化设计，提高代码的可维护性和可读性。
提高程序的可扩展性：程序中定义的函数可以随时扩展和修改，不影响程序的其他部分，提高程序的可扩展性和灵活性。
提高程序的可测试性：定义好函数之后，可以对函数进行单元测试，保证函数的正确性和稳定性，从而提高程序的可测试性和可靠性。

4.简单的函数示例

1.无参函数

无参函数不需要接受任何参数，直接执行函数体中的代码。例如：

# 定义一个简单的函数，打印一条消息
def say_hello():
    print("Hello, world!")

# 调用函数
say_hello()   # 输出：Hello, world!

2.有参函数

有参函数接受一个或多个参数，在函数内部进行处理并返回结果。例如：

# 定义一个带参数的函数，计算两个数的和
def add_numbers(a, b):
    result = a + b
    return result

# 调用函数
x = 2
y = 3
z = add_numbers(x, y)   # z的值为5
print(z)

3.默认参数函数

默认参数函数在定义时可以指定参数的默认值，如果调用时没有传入该参数，则使用默认值。例如：

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice")  # 输出 "Hello, Alice!"
greet("Bob", "Hi")  # 输出 "Hi, Bob!"

4.可变参数函数

可变参数函数可以接受任意个数的参数，并将它们存储为一个元组或列表。例如：

def calculate(*args):
    total = 0
    for num in args:
        total += num
    return total

result = calculate(1, 2, 3, 4)  # 返回结果为 10

5.关键字参数函数

关键字参数函数允许传递任意数量的关键字参数，并将它们存储为一个字典。例如：

def greet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

greet(name="Alice", age=25, location="New York")
# 输出：
# name: Alice
# age: 25
# location: New York

6.lambda函数

lambda函数是一种匿名函数，通常用于一次性的、简单的操作。例如：

square = lambda x: x**2
result = square(3)  # 返回结果为 9

5.函数参数进阶

函数参数进阶是指在函数定义和调用中，使用更加灵活的参数传递方式，以满足不同的需求。以下是一些常见的函数参数进阶方式：

1.位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20, '男')

注意：递和定义参数的顺序及个数必须一致。

2.关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

3.缺省参数（默认值）

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '女')

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

4.不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

不定长参数分为两种：*args 和 **kwargs。

*args 是用来处理不定量的位置参数（positional arguments），它会将所有传进来的位置参数放入一个元组中，然后作为参数传递给函数。例如：

def my_function(*args):
    for arg in args:
        print(arg)

在调用该函数时，可以传递任意数量的位置参数：

my_function(1, 2, 3)       # 输出 1\n 2\n 3\n
my_function('a', 'b')      # 输出 a\n b\n
my_function()              # 没有输出

**kwargs 则是用来处理不定量的关键字参数（keyword arguments），它会将所有传进来的关键字参数放入一个字典中，然后作为参数传递给函数。例如：

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(key + ': ' + str(value))

在调用该函数时，可以传递任意数量的关键字参数：

my_function(name='Alice', age=30)   # 输出 name: Alice\nage: 30\n
my_function(city='New York')        # 输出 city: New York\n
my_function()                       # 没有输出

此外，还可以将*args和**kwargs组合在一起，以接受任意数量的参数：

def my_function(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(key + ': ' + str(value))

在调用该函数时，可以传递任意数量的位置参数和关键字参数：

my_function(1, 2, name='Alice', age=30)   # 输出 1\n2\nname: Alice\nage: 30\n
my_function(city='New York')              # 输出 city: New York\n
my_function()                             # 没有输出

需要注意的是，在定义函数时，*args 必须在 **kwargs 的前面，否则会产生语法错误。

6.lambda 表达式函数

Lambda是Python中的一种匿名函数，它可以在需要函数对象的任何地方使用。Lambda函数通常用于编写简短的代码块，并且由于它们是匿名的，所以非常适合作为函数参数或返回值使用。

1.lambda的应用场景

如果一个函数有一个返回值，并且只有一句代码，可以使用 lambda简化。

2.lambda语法

如果一个函数有一个返回值，并且只有一句代码，可以使用 lambda简化。

lambda 参数列表 ： 表达式

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。
lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

3.lambda快速入门

如果一个函数有一个返回值，并且只有一句代码，可以使用 lambda简化。

# 定义lambda函数并赋值给变量x
x = lambda a, b : a + b

# 调用lambda函数并输出结果
print(x(5, 10))

#输出：15

4.lambda参数形式

有一个参数：lambda x: x + 1，其中x是参数名。
有多个参数：lambda x, y: x + y，使用逗号分隔多个参数。
参数列表可以包含默认值：lambda x=1, y=2: x + y，这样调用时如果没有提供参数，则会使用默认值。
可以使用可变参数（*args）：lambda *args: sum(args)，这样可以接收任意数量的参数，并将它们求和。

可以使用关键字参数（**kwargs）：lambda **kwargs: kwargs['a'] + kwargs['b']，这样可以接收任意数量的关键字参数，并将它们相加。

下面是一些例子来演示这些不同的参数形式：

# 有一个参数
f = lambda x: x + 1
print(f(1)) # 输出 2

# 有多个参数
g = lambda x, y: x + y
print(g(1, 2)) # 输出 3

# 带默认值的参数
h = lambda x=1, y=2: x + y
print(h()) # 输出 3

# 可变参数
i = lambda *args: sum(args)
print(i(1, 2, 3)) # 输出 6

# 关键字参数
j = lambda **kwargs: kwargs['a'] + kwargs['b']
print(j(a=1, b=2)) # 输出 3

5.lambda应用

列表数据排序

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'Jack', 'age': 22}
]

# 按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)

# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)

# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

7.高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

1.高阶函数快速入门

需求：任意两个数字，按照指定要求整理数字后再进行求和计算。

方法一：

def add_num(a, b):
    return abs(a) + abs(b)

result = add_num(-1, 2)
print(result)  # 3

方法二：

def sum_num(a, b, f):
    return f(a) + f(b)

result = sum_num(-1, 2, abs)
print(result)  # 3

注意：两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

2.常见的高阶函数

在Python中，高阶函数指的是可以接受其他函数作为参数或者返回函数作为结果的函数。高阶函数是函数式编程中的重要概念，它可以让我们编写更加简洁和灵活的代码。以下是一些常见的高阶函数：

1.map

map() 函数可以将一个函数应用到一个可迭代对象的每个元素上，并返回一个新的可迭代对象，其中包含每个元素应用函数后的结果。

例如：

def square(x):
    return x * x

numbers = [1, 2, 3, 4]
squares = map(square, numbers)  # 返回结果为 [1, 4, 9, 16]

map() 函数也可以使用匿名函数来简化代码：

numbers = [1, 2, 3, 4]
squares = map(lambda x: x * x, numbers)  # 返回结果为 [1, 4, 9, 16]

2.filter

filter() 函数可以根据指定的条件过滤可迭代对象中的元素，并返回一个新的可迭代对象，其中包含满足条件的元素。例如：

def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4]
evens = filter(is_even, numbers)  # 返回结果为 [2, 4]

filter() 函数也可以使用匿名函数来简化代码：

numbers = [1, 2, 3, 4]
evens = filter(lambda x: x % 2 == 0, numbers)  # 返回结果为 [2, 4]

3.reduce

reduce() 函数可以将一个函数应用到可迭代对象的每个元素上，并将结果累加起来。例如：

from functools import reduce

def add(x, y):
    return x + y

numbers = [1, 2, 3, 4]
total = reduce(add, numbers)  # 返回结果为 10

reduce() 函数还可以使用匿名函数来简化代码：

numbers = [1, 2, 3, 4]
total = reduce(lambda x, y: x + y, numbers)  # 返回结果为 10

总之，函数是Python中非常重要的语言特性，使用函数能够使我们的程序更加模块化、易于理解和维护。在编写程序时，应该充分利用函数这个工具来组织代码，提高代码的复用性和可读性。

8.额外：Python拆包

Python拆包是一种常见的技巧，它可以将元组、列表或字典中的值解构到单独的变量中。这使得代码更加简洁和易于阅读。以下是一些Python拆包的示例：

1.拆包元组

t = (1, 2, 3)
a, b, c = t
print(a, b, c) # 输出：1 2 3

2.拆包列表

l = [4, 5, 6]
x, y, z = l
print(x, y, z) # 输出：4 5 6

3.拆包字典

d = {'name': 'John', 'age': 30}
name, age = d.values()
print(name, age) # 输出：John 30

#也可以
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

# 对字典进行拆包，取出来的是字典的key
print(a)  # name
print(b)  # age

print(dict1[a])  # TOM
print(dict1[b])  # 18

另外，我们还可以使用星号运算符 * 来处理不确定数量的元素，例如：

t = (1, 2, 3, 4, 5)
a, b, *c = t
print(a, b, c) # 输出：1 2 [3, 4, 5]

在上面的例子中，*c 表示将剩余的元素都放入列表 c 中。

肖申克的陪伴

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
深度解析Python函数的使用与实现

函数是一个被命名的、独立的、完成特定功能的代码段，其可能给调用它的程序一个返回值。函数名称：遵循标识符的命名规则。参数列表：包含函数的输入参数，可以是位置参数、默认参数、可变参数、关键字参数等。函数体：包含了函数的执行代码，完成特定的任务。返回值：用于向调用方返回结果，可以是任何数据类型，也可以不返回。函数的定义通常使用关键字def开始，然后是函数名称、参数列表和冒号。函数体通常使用缩进来标识。
复制链接

扫一扫