系列文章目录

个人简介：机电专业在读研究生，CSDN内容合伙人，博主个人首页
Python面试专栏：《Python面试》此专栏面向准备面试的2024届毕业生。欢迎阅读，一起进步！🌟🌟🌟
码字不易，如果觉得文章不错或能帮助到你学习，可以点赞👍收藏📁评论📒+关注哦！😊😊😊

文章目录

系列文章目录
Python 面试的进阶问题
- 19. 在 Python 中如何管理内存?
- 20. 什么是 Python 命名空间？为什么使用它们？
- 21. Python 中的范围解析是什么？
- 22. 什么是 Python 中的装饰器？
- 23. 什么是字典和列表推导式？
- 24. 什么是 Python 中的 lambda？为什么使用它？
- 25. 如何在 Python 中复制对象？
- 26. 在 Python 中，xrange 和 range 有什么区别？
- 27.什么是序列化和反序列化？
- 28. 什么是 Python 中的生成器？
- 29. 什么是 Python 中的 PYTHONPATH？
- 30. `help()` 和 `dir()` 函数有什么用？
- 31. .py 和 .pyc 文件有什么区别？
- 32. Python 是如何解释代码的？
- 33. 在 Python 中，参数是如何通过值或引用传递的？
- 34. 什么是 Python 中的迭代器？
- 35. 如何在 Python 中删除文件？
- 36. 什么是 Python 中的 `split()` 和 `join()` 函数？
- 37. 什么是 `*args` 和 `**kwargs`？
- 38. 什么是负索引，为什么使用负索引？
Python 面试的高阶问题：[待更新](https://blog.csdn.net/a2360051431)

本文是Python面试专栏的第一篇。在本专栏中，我将总结华为、阿里巴巴、字节跳动等互联网公司 Python 面试中最常见的 100+ 问题。每道题都提供参考答案，希望能够帮助你在求职面试中脱颖而出，找到一份高薪工作。这些面试题涉及 Python 基础知识、Python 编程、数据分析以及 Python 函数库等多个方面。

Python 面试的进阶问题

19. 在 Python 中如何管理内存?

Python 中的内存管理由 Python 内存管理器处理。由管理器分配的内存以专用于 Python 的私有堆空间的形式存在。所有 Python 对象都存储在这个堆中，并且是私有的，程序员无法访问它。
此外，Python有一个内置的垃圾收集站来回收私有堆空间中未使用的内存。

在这里插入图片描述

20. 什么是 Python 命名空间？为什么使用它们？

Python 命名空间是一个抽象概念，它表示 Python 解释器用来查找变量名称（或标识符）的方式。Python 中的每个标识符都必须位于某个命名空间中。

Python 中有三种命名空间：

内置命名空间（Built-in namespace）：包含了 Python 的内置函数和异常等。
全局命名空间（Global namespace）：在程序的全局范围定义的变量和函数等，存在于整个程序运行过程中。
局部命名空间（Local namespace）：在函数或类的方法中定义的变量和参数等，只在函数或方法执行期间存在。

使用命名空间可以避免变量名冲突，并且可以使代码更易于理解和维护。例如，在一个函数中定义的变量不会与程序的其他部分发生冲突，因为它们位于局部命名空间中，只在函数执行期间存在。

另外，Python 还提供了一些特殊的语法和关键字来修改命名空间，比如 global 和 nonlocal 关键字用于访问全局命名空间和上一级的局部命名空间，import 语句可以将模块中的命名空间合并到当前命名空间中。

总之，Python 命名空间是一种非常重要的概念，它帮助开发者避免变量名冲突，并使代码更易于维护和理解。

在这里插入图片描述

21. Python 中的范围解析是什么？

Python 中的范围解析（Scope Resolution）是指解释器如何确定在程序中使用的标识符所表示的变量或函数等的作用域（Scope）。

如上所述，在 Python 中，每个变量和函数都有一个作用域，它是该变量或函数可见的代码区域。Python 的作用域为内置作用域、全局作用域和局部作用域。

在 Python 中，解释器会按照以下顺序查找标识符的作用域：

首先，在当前作用域中查找标识符。
如果在当前作用域中没有找到标识符，则在上一级作用域中查找，直到找到为止。
如果在任何作用域中都没有找到标识符，则抛出 NameError 异常。

另外，如果要在函数中修改全局变量的值，需要使用 global 关键字来声明这个变量是全局变量而不是局部变量。

考虑下面的代码，对象 temp 已全局初始化为 10，然后在函数调用时初始化为 20。但是，函数调用不会全局更改 temp 的值。在这里，我们可以观察到 Python 在全局变量和局部变量之间划清了界限，将它们的命名空间视为单独的身份。

temp = 10		# global-scope variable
def func():
	temp = 20		# local-scope variable
	print(temp)
print(temp)		# output => 10
func()		# output => 20
print(temp)		# output => 10

可以使用函数内的 global 关键字重写此行为，如以下示例所示：

temp = 10		# global-scope variable
def func():
    global temp
    temp = 20		# local-scope variable
    print(temp)
print(temp)		# output => 10
func()		# output => 20
print(temp)		# output => 10

22. 什么是 Python 中的装饰器？

在 Python 中，装饰器（Decorator）是一种用于修改或扩展函数或类的行为的函数。装饰器可以接受一个函数或类作为参数，并返回一个新的经过修改后的函数或类。

通常情况下，装饰器会在不修改原始函数或类定义的情况下，为它们添加一些额外的功能或特性。例如，可以使用装饰器来实现以下功能：

记录函数调用次数或执行时间等统计信息
检查函数参数类型和返回值是否符合预期
缓存函数的结果以优化性能
实现权限验证或日志记录等功能

以下是一个使用装饰器实现权限验证的示例代码：

def login_required(func):
    def wrapper(*args, **kwargs):
        # 模拟登录验证逻辑，这里简单地检查了一个参数是否为 True
        if kwargs.get('logged_in'):
            return func(*args, **kwargs)
        else:
            raise Exception("Login required!")
    return wrapper

@login_required
def foo(bar=None, **kwargs):
    print("Hello, world!")
    
foo(logged_in=True) # output => Hello, world!
foo(logged_in=False) # output => Exception: Login required!

在这个示例中，我们定义了一个名为 login_required 的装饰器函数，它接受一个函数作为参数，并返回一个新的函数来代替原始函数。新的函数 wrapper 实现了登录验证逻辑，在调用原始函数之前先检查了一个名为 logged_in 的关键字参数是否为 True。如果验证通过，则调用原始函数；否则，抛出一个异常。

在定义函数 foo 时，我们使用了 @login_required 语法来将其传递给装饰器函数 login_required 进行修改。这样，在调用函数 foo 时，就会自动应用登录验证逻辑，确保只有已登录用户才能执行该函数。

总之，装饰器是 Python 中非常强大的工具，它可以让开发者在不修改原始函数或类定义的情况下，轻松地扩展和修改它们的行为。

23. 什么是字典和列表推导式？

字典和列表推导式是 Python 中用于快速生成新列表或字典的语法。

列表推导式（List Comprehension）的基本语法为：

[expression for item in iterable if condition]

其中，expression 是一个表达式，表示在循环中对每个元素执行的操作；item 是可迭代对象中的每个元素；iterable 是一个可迭代对象，例如列表、元组或集合等；condition 是一个可选的条件，表示仅当满足条件时才将 expression 的结果添加到列表中。

以下是一个使用列表推导式生成 1 到 10 的平方数的示例代码：

squares = [x ** 2 for x in range(1, 11)]
print(squares) # output => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

字典推导式（Dictionary Comprehension）它生成的是一个新的字典。它的基本语法为：

{key_expression: value_expression for expression in iterable if condition}

其中，key_expression 和 value_expression 分别表示字典中的键和值，expression 和 iterable 的含义与列表推导式相同，condition 表示仅当满足条件时才将结果添加到字典中。

以下是一个使用字典推导式生成一个由数字和它们的平方组成的字典的示例代码：

squares_dict = {x: x ** 2 for x in range(1, 11)}
print(squares_dict) # output => {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

24. 什么是 Python 中的 lambda？为什么使用它？

在 Python 中，Lambda 表达式（也称为匿名函数）是一种灵活和简洁的函数定义方式，它可以用于创建一个小型的、一次性的函数,而不必创建一个完整的函数定义。Lambda 表达式可以接受任意多个参数，但只能返回一个表达式的值。Lambda 表达式通常用于传递给那些需要函数作为参数的函数，例如 sorted、map 和 filter 等函数。

可以通过以下两种方式之一使用 Lambda 函数：

将 Lambda 函数分配给变量：

mul = lambda a, b : a * b
print(mul(2, 5))    # output => 10

将 Lambda 函数包装在另一个函数中：

def myWrapper(n):
   return lambda a : a * n
mulFive = myWrapper(5)
print(mulFive(2))    # output => 10

25. 如何在 Python 中复制对象？

在 Python 中，复制（或克隆）对象可以使用多种方式，具体取决于你想复制的对象类型和目的。

以下是一些常见的对象复制方式：

浅拷贝（Shallow Copy）
浅拷贝是指创建一个新的对象并将原始对象中的所有元素逐个复制到新对象中。对于可变对象，例如列表和字典，新对象只是原始对象的一个副本，但其中的子对象仍然是引用相同的内存地址。浅拷贝可以通过切片、copy.copy() 函数或 dict.copy() 方法来实现。
深拷贝（Deep Copy）
深拷贝是指创建一个全新的、独立的对象，并将原始对象中的所有元素递归地复制到新对象中。这意味着每个子对象都有自己的内存地址，而不是共享原始对象的地址。深拷贝可以通过 copy.deepcopy() 函数来实现。

下面是一些示例代码：

import copy

# 列表浅拷贝
original_list = [[1, 2], [3, 4]]
new_list = original_list[:]  # 或者 new_list = list(original_list)
new_list[0][0] = 5
print(original_list) # output => [[5, 2], [3, 4]]

# 字典浅拷贝
original_dict = {'a': [1, 2], 'b': [3, 4]}
new_dict = original_dict.copy()  # 或者 new_dict = dict(original_dict)
new_dict['a'][0] = 5
print(original_dict) # output => {'a': [5, 2], 'b': [3, 4]}

# 对象深拷贝
class MyClass:
    def __init__(self, value):
        self.value = value

original_obj = [MyClass(1), MyClass(2)]
new_obj = copy.deepcopy(original_obj)
new_obj[0].value = 5
print(original_obj[0].value) # output => 1

需要注意的是，在进行深拷贝时，由于需要递归地复制所有子对象，因此可能会比较耗时。

26. 在 Python 中，xrange 和 range 有什么区别？

在 Python 中，range 和 xrange 是用于生成整数序列的两个内置函数。

主要区别如下：

返回类型：range 返回一个列表对象，而 xrange 返回一个可迭代的 xrange 对象。这意味着 range 在调用时会一次性生成并返回整个列表，而 xrange 则是按需生成每个元素。
内存占用：由于 range 返回整个列表，所以它会占用更多的内存空间。相比之下，xrange 只在需要时生成单个元素，因此在处理大型数据集时，xrange 可以减少内存使用量。
迭代速度：由于 xrange 每次只生成一个元素，所以在迭代时比 range 更高效。对于循环中需要迭代大量整数的情况，xrange 通常比 range 更快。

需要注意的是，从 Python 3 开始，xrange 函数已被移除，在 Python 3 及更高版本中，只有 range 函数可用，range 函数改为具有 xrange 的功能，即返回一个可迭代的对象，而不是立即生成整个列表。

27.什么是序列化和反序列化？

在 Python 中，序列化（Pickling）和反序列化（Unpickling）是用于将对象转换为字节流以便存储或传输，并从字节流中还原对象的过程。

Pickling：Pickling 是将 Python 对象转换为可存储或传输的字节流的过程。通过使用 pickle 模块，可以将对象序列化为字节流，并保存到文件或传输给其他进程。这对于持久化数据、缓存对象或在分布式系统中进行进程间通信都非常有用。pickle 模块可以处理几乎所有的 Python 对象，包括自定义类实例。
Unpickling：Unpickling 是将字节流还原为原始对象的过程。通过使用 pickle 模块，可以从保存的文件或接收的字节流中提取出序列化的对象，并重新构建成原来的对象。这使得我们能够轻松地恢复先前序列化的对象，并继续使用它们。

需要注意的是，pickle 模块只能在 Python 之间共享并解析。如果需要与其他编程语言交互，则可能需要使用不同的序列化方案，如 JSON 或 MessagePack。

以下是一个简单示例，展示了如何使用 pickle 模块进行 Pickling 和 Unpickling：

import pickle

# 定义一个对象
data = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# Pickling，将对象转换为字节流
pickled_data = pickle.dumps(data)

# 将字节流保存到文件中
with open('data.pickle', 'wb') as file:
    file.write(pickled_data)

# Unpickling，将字节流还原为对象
with open('data.pickle', 'rb') as file:
    unpickled_data = pickle.load(file)

print(unpickled_data)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

通过 Pickling 和 Unpickling，我们可以在 Python 中方便地将对象序列化和反序列化，以实现数据持久化或进程间通信。

在这里插入图片描述

28. 什么是 Python 中的生成器？

在Python中，生成器（Generator）是一种特殊的迭代器。它以一种惰性的方式生成（yield）序列化的值，而不是一次性生成并保存整个序列。

生成器的创建通常使用函数和 yield 关键字来实现。当函数中包含 yield 语句时，该函数就成为一个生成器函数。每次调用生成器函数时，它会返回一个生成器对象，而不是执行函数体内的代码。

与普通函数不同的是，生成器函数可以通过 yield 语句多次产生值。每次遇到 yield 语句时，生成器会暂停执行，并将产生的值返回给调用者。下次调用生成器时，它会从上次暂停的位置恢复执行，并继续进行下一次的迭代。

这种按需生成值的方式使得生成器非常适合处理大量数据或无限序列，因为它们可以在需要时逐个生成值，而不会占用过多的内存。

以下是一个简单的示例，展示了如何创建和使用生成器：

def number_generator(n):
    for i in range(n):
        yield i

# 创建生成器对象
generator = number_generator(5)

# 使用生成器迭代产生值
for value in generator:
    print(value)

# 输出：
# 0
# 1
# 2
# 3
# 4

在上述示例中，number_generator 是一个生成器函数，它通过使用 yield 语句产生序列化的值。通过调用生成器函数并将结果赋值给变量 generator，我们创建了一个生成器对象。然后，我们可以通过迭代生成器对象来逐个获取生成器产生的值。

生成器提供了一种方便且高效的方式来处理大型数据集或需要延迟计算的序列。通过使用生成器，我们可以以更节省内存的方式进行迭代和处理数据。

29. 什么是 Python 中的 PYTHONPATH？

PYTHONPATH 是一个环境变量，用于告诉 Python 解释器在哪里查找模块文件。

当导入模块时，Python 解释器会按照一定的规则搜索模块所在的位置。其中之一就是通过 PYTHONPATH 环境变量来指定搜索路径。PYTHONPATH 是一个包含目录路径的字符串，

当我们导入模块时，Python 解释器会按照以下顺序搜索模块的位置：

内置模块：首先搜索内置的模块，例如 math、sys 等。
当前工作目录：如果模块与当前脚本文件（或交互式会话）在同一目录下，那么 Python 会优先从当前工作目录进行搜索。
PYTHONPATH 路径：Python 会按照 PYTHONPATH 环境变量中声明的路径顺序逐个搜索。
标准库路径：如果模块仍然未找到，则 Python 会搜索标准库的安装路径。
错误：如果在以上步骤都找不到模块，则会抛出 ModuleNotFoundError 异常。

可以通过以下方式查看当前系统中设置的 PYTHONPATH 值：

在终端或命令提示符中执行 echo %PYTHONPATH%（Windows）
在终端中执行 echo $PYTHONPATH（Linux和Mac）

使用 PYTHONPATH 来指定额外的模块搜索路径，以便 Python 解释器能够找到所需的模块文件。这在组织大型项目、自定义模块库或调试代码时非常有用。

30. `help()` 和 `dir()` 函数有什么用？

Python 中的 help() 函数用于显示模块、类、函数、关键字等的文档。如果未向 help() 函数传递任何参数，则会在控制台上启动交互式帮助程序。

dir() 函数尝试返回调用它的对象的属性和方法的有效列表。它对不同对象的行为不同，因为它旨在生成最相关的数据，而不是完整的信息。

对于模块/库对象，它返回该模块中包含的所有属性的列表。
对于类对象，它返回所有有效属性和基属性的列表。
如果未传递任何参数，它将返回当前范围内的属性列表。

31. .py 和 .pyc 文件有什么区别？

.py 文件：.py 文件是 Python 源代码文件的扩展名。这是我们编写 Python 程序的文件类型。Python 解释器可以直接运行 .py 文件，并执行其中的代码。当我们修改 .py 文件时，需要重新运行整个文件。
.pyc 文件：.pyc 文件是 Python 字节编译文件的扩展名。当 Python 解释器运行一个 .py 文件时，它会将该文件转换为字节码（即 .pyc 文件），以提高程序的执行效率。.pyc 文件包含已经编译的字节码，这意味着 Python 解释器不需要重新编译源代码，而是直接加载并执行 .pyc 文件。.pyc 文件是平台特定的，因此它们在不同的操作系统上可能不可互用。

Python 解释器在运行 .py 文件时，会自动检查是否存在对应的 .pyc 文件，并根据需要自动生成或更新 .pyc 文件。

32. Python 是如何解释代码的？

Python 是一种解释型语言，它的执行过程可以简单分为两个步骤：解析（Parsing）和解释（Interpreting）。

解析（Parsing）：

在解析阶段，Python 解释器会对源代码进行语法解析。它会逐行读取源代码，并将其转换成一种称为"抽象语法树"（Abstract Syntax Tree，AST）的数据结构。抽象语法树表示了代码的结构和语义，使得解释器能够理解源代码的含义和逻辑关系。
解释（Interpreting）：

在解释阶段，Python 解释器会按照抽象语法树的结构和定义的语义规则来执行源代码。它会逐条解释执行代码，并计算表达式、处理语句、调用函数等操作。解释器会逐行执行代码，将代码转化为机器可执行的指令序列，并在运行时动态地执行这些指令。

Python 解释器有多个实现，其中最常用的是 CPython，它是官方的 Python 解释器。CPython 使用一种称为"解释执行"的方式来运行 Python 代码。也就是说，它将源代码逐行解析并立即执行，而不需要事先将整个程序编译成二进制文件。

相比之下，编译型语言（如 C++、Java）在程序运行前需要将源代码编译成机器语言的可执行文件，然后直接在计算机上运行这个二进制文件。而解释型语言（如 Python）则是逐行解释和执行源代码，将其转换为机器可执行的指令序列，并在运行时动态地执行这些指令。

33. 在 Python 中，参数是如何通过值或引用传递的？

在 Python 中，参数的传递方式有：

按值传递：传递实际对象的副本。更改对象副本的值不会更改原始对象的值。
按引用传递：传递对实际对象的引用。更改新对象的值将更改原始对象的值。

如果参数是可变对象（例如列表、字典等），那么在函数内部对该参数进行的修改会影响到原始对象，因为它们引用的是同一个对象。这种情况下，参数的传递类似于通过引用传递。例如：

def change_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
change_list(my_list)
print(my_list)  # 输出 [1, 2, 3, 4]

在上面的例子中，我们定义了一个函数 change_list，它接受一个列表作为参数，并在列表末尾添加了一个元素。当我们调用 change_lis t函数并传入 my_list 时，函数内部对列表的修改会直接影响到原始的 my_list，因为它们引用的是同一个列表对象。

然而，如果参数是不可变对象（例如数字、字符串等），那么在函数内部对该参数进行的修改不会影响到原始对象，因为不可变对象是无法被修改的。这种情况下，参数的传递类似于通过值传递。例如：

def increment(num):
    num += 1

my_num = 10
increment(my_num)
print(my_num)  # 输出 10

在上面的例子中，我们定义了一个函数 increment，它接受一个数字作为参数，并将该数字加 1。当我们调用 increment 函数并传入 my_num 时，函数内部对数字的修改不会影响到原始的 my_num，因为数字是不可变对象。

总结起来，Python 中的参数传递方式可以简单理解为：对于可变对象，是通过引用传递；对于不可变对象，是通过值传递。

34. 什么是 Python 中的迭代器？

在 Python 中，迭代器（Iterator）是一个用于遍历可迭代对象的对象。可迭代对象（Iterable）包括但不限于列表、元组、字典、集合和字符串等。

通过使用迭代器，我们可以逐个访问可迭代对象中的元素，而无需提前获取整个可迭代对象的内容。这对于处理大型数据集或者懒加载数据非常有用，因为它可以节省内存空间，并且能够提高程序的效率。

在 Python 中，迭代器对象必须实现两个方法：

__iter__()：返回迭代器对象本身。
__next__()：返回可迭代对象中的下一个元素，如果没有更多的元素，则抛出 StopIteration 异常。

以下是一个使用迭代器遍历列表的示例：

my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)  # 创建迭代器对象

print(next(my_iter))  # 输出 1
print(next(my_iter))  # 输出 2
print(next(my_iter))  # 输出 3

在上面的示例中，我们首先使用 iter() 函数创建了一个迭代器对象 my_iter，该迭代器对象可以逐个访问列表 my_list 中的元素。然后，我们使用 next() 函数来获取迭代器中的下一个元素，并依次输出。

需要注意的是，当迭代器遍历完可迭代对象中的所有元素后，再调用 next() 函数将会触发 StopIteration 异常。因此，在使用迭代器时，通常使用循环来迭代整个可迭代对象，而不是手动调用 next() 函数。

下面是一个使用迭代器遍历字符串的示例：

my_string = "Hello"
my_iter = iter(my_string)  # 创建迭代器对象

for char in my_iter:
    print(char)  # 逐个输出字符串中的字符

35. 如何在 Python 中删除文件？

使用命令 os.remove() 或者 os.unlink()，示例代码如下：

import os

file_path = "/path/to/file.txt"

if os.path.exists(file_path):
    os.remove(file_path)
    print("文件删除成功")
else:
    print("文件不存在")

import os

file_path = "/path/to/file.txt"

if os.path.exists(file_path):
    os.unlink(file_path)
    print("文件删除成功")
else:
    print("文件不存在")

无论是使用 os.remove() 还是 os.unlink()，都需要确保当前用户对要删除的文件具有足够的权限，并且文件没有被其他程序占用。否则，在执行删除操作时可能会抛出 PermissionError 或 FileNotFoundError 异常。

36. 什么是 Python 中的 `split()` 和 `join()` 函数？

split() 函数用于将一个字符串分割成子字符串，并返回一个包含分割后子字符串的列表
join() 函数则用于将一个可迭代对象中的字符串元素连接起来，返回一个新的字符串。

这两个函数在处理字符串时非常有用。

text = "apple,banana,orange"
fruits = text.split(",")  # 使用逗号作为分隔符分割字符串
print(fruits)  # 输出 ['apple', 'banana', 'orange']
fruits = ['apple', 'banana', 'orange']
text = ",".join(fruits)  # 使用逗号连接字符串元素
print(text)  # 输出 'apple,banana,orange'

37. 什么是 `*args` 和 `**kwargs`？

在Python中，*args 和 **kwargs 是用于函数定义时的特殊参数形式。

*args：
- *args 表示一个非关键字可变长度参数（Variable Length Arguments），可以接收任意数量的位置参数。
- 在函数定义时，使用 *args 可以将传入函数的多个位置参数打包成一个元组（tuple）。
- 例如：
```
def my_function(*args):
	for arg in args:
    	print(arg)
my_function('apple', 'banana', 'orange')
''' 
输出结果：
apple
banana
orange
'''
```
- 在调用函数时，可以传递任意数量的位置参数，它们会被打包成一个元组，并在函数内部作为 args 参数的值。
**kwargs：
- **kwargs 表示一个关键字可变长度参数（Keyword Variable Length Arguments），可以接收任意数量的关键字参数。
- 在函数定义时，使用 **kwargs 可以将传入函数的多个关键字参数打包成一个字典（dictionary）。
- 例如：
```
def my_function(**kwargs):
    for key, value in kwargs.items():
	    print(key, value)
my_function(name='John', age=25, city='New York')
'''
输出结果：
name John
age 25
city New York
'''
```
- 在调用函数时，可以传递任意数量的关键字参数，它们会被打包成一个字典，并在函数内部作为 kwargs 参数的值。

需要注意的是，args 和 kwargs 只是常用的约定俗成的命名，并不是固定的关键字。可以选择其他的名称，但通常保持一致性以增加可读性。

同时使用 *args 和 **kwargs 时，args 会接收位置参数，kwargs 会接收关键字参数。例如：

def my_function(*args, **kwargs):
	print(args)   # 输出一个元组
	print(kwargs)  # 输出一个字典
my_function('apple', 'banana', name='John', age=25)
'''
输出结果：
('apple', 'banana')
{'name': 'John', 'age': 25}
'''