2024年最全华为、阿里巴巴、字节跳动 100+ Python 面试问题总结（二）(2)

最新推荐文章于 2024-09-27 10:11:28 发布

2401_84561736

最新推荐文章于 2024-09-27 10:11:28 发布

阅读量1k

点赞数 27

分类专栏：程序员文章标签：华为 python 面试

本文链接：https://blog.csdn.net/2401_84561736/article/details/138383377

版权

程序员专栏收录该内容

192 篇文章 0 订阅

订阅专栏

+ [23. 什么是字典和列表推导式？](#23__110)
+ [24. 什么是 Python 中的 lambda？为什么使用它？](#24__Python__lambda_140)
+ [25. 如何在 Python 中复制对象？](#25__Python__158)
+ [26. 在 Python 中，xrange 和 range 有什么区别？](#26__Python_xrange__range__196)
+ [27.什么是序列化和反序列化？](#27_210)
+ [28. 什么是 Python 中的生成器？](#28__Python__243)
+ [29. 什么是 Python 中的 PYTHONPATH？](#29__Python__PYTHONPATH_276)
+ [30. `help()` 和 `dir()` 函数有什么用？](#30_help__dir__299)
+ [31. .py 和 .pyc 文件有什么区别？](#31_py__pyc__308)
+ [32. Python 是如何解释代码的？](#32_Python__316)
+ [33. 在 Python 中，参数是如何通过值或引用传递的？](#33__Python__330)
+ [34. 什么是 Python 中的迭代器？](#34__Python__362)
+ [35. 如何在 Python 中删除文件？](#35__Python__395)
+ [36. 什么是 Python 中的 `split()` 和 `join()` 函数？](#36__Python__split__join__421)
+ [37. 什么是 `\*args` 和 `\*\*kwargs`？](#37__args__kwargs_434)
+ [38. 什么是负索引，为什么使用负索引？](#38__489)

[Python 面试的高阶问题：华为、阿里巴巴、字节跳动 100+ Python 面试问题总结（三）](#Python__100_Python_httpsblogcsdnneta2360051431articledetails131636227_494)

本文是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，我们创建了一个生成器对象。然后，我们可以通过迭代生成器对象来逐个获取生成器产生的值。

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