面试 | 针对有经验的20个高频Python面试问题·进阶篇

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

Python 推导式与装饰器一样，是语法糖结构，可帮助从给定的列表、字典或集合构建经过修改和过滤的列表、字典或集合。使用推导式可节省大量时间和代码，这些代码可能会更加冗长（包含更多代码行）。

• 对整个列表执行数学运算

my_list = [2, 3, 5, 7, 11]
squared_list = [x**2 for x in my_list]    # list comprehension# output => [4 , 9 , 25 , 49 , 121]
squared_dict = {x:x**2 for x in my_list}    # dict comprehension# output => {11: 121, 2: 4 , 3: 9 , 5: 25 , 7: 49}

• 对整个列表执行条件过滤操作

my_list = [2, 3, 5, 7, 11]
squared_list = [x**2 for x in my_list if x%2 != 0]    # list comprehension# output => [9 , 25 , 49 , 121]
squared_dict = {x:x**2 for x in my_list if x%2 != 0}    # dict comprehension# output => {11: 121, 3: 9 , 5: 25 , 7: 49}

• 将多个列表合并为一个

理解允许多个迭代器，因此可以用来将多个列表合并为一个。

a = [1, 2, 3]
b = [7, 8, 9]
[(x + y) for (x,y) in zip(a,b)]  # parallel iterators# output => [8, 10, 12]
[(x,y) for x in a for y in b]    # nested iterators# output => [(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9)]

• 扁平化多维列表

可以采用与嵌套迭代器类似的方法（如上）来展平多维列表或处理其内部元素。

my_list = [[10,20,30],[40,50,60],[70,80,90]]
flattened = [x for temp in my_list for x in temp]
# output => [10, 20, 30, 40, 50, 60, 70, 80, 90]

注意：列表推导与其他语言中的 map 方法具有相同的效果。它们遵循数学集合构建器符号，而不是 Python 中的 map 和 filter 函数。

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

Python 中的装饰器本质上是向 Python 中现有函数添加功能而不改变函数本身结构的函数。它们@decorator_name在 Python 中表示并以自下而上的方式调用。例如：

# decorator function to convert to lowercase
def lowercase_decorator(function):
   def wrapper():
       func = function()
       string_lowercase = func.lower()
       return string_lowercase
   return wrapper
# decorator function to split words
def splitter_decorator(function):
   def wrapper():
       func = function()
       string_split = func.split()
       return string_split
   return wrapper
@splitter_decorator # this is executed next
@lowercase_decorator # this is executed first
def hello():
   return 'Hello World'
hello()   # output => [ 'hello' , 'world' ]

装饰器的优点在于，除了为方法的输出添加功能外，它们甚至可以接受函数的参数，并在将这些参数传递给函数本身之前进一步修改这些参数。内部嵌套函数，即“包装器”函数，在这里起着重要作用。它被实现为强制封装，从而使其自身对全局范围隐藏。

# decorator function to capitalize names
def names_decorator(function):
   def wrapper(arg1, arg2):
       arg1 = arg1.capitalize()
       arg2 = arg2.capitalize()
       string_hello = function(arg1, arg2)
       return string_hello
   return wrapper
@names_decorator
def say_hello(name1, name2):
   return 'Hello ' + name1 + '! Hello ' + name2 + '!'
say_hello('sara', 'ansh')   # output => 'Hello Sara! Hello Ansh!'

3. Python 中的作用域解析是什么？

有时，同一范围内的对象具有相同的名称，但功能不同。在这种情况下，范围解析会自动在 Python 中发挥作用。此类行为的一些示例如下：

• Python 模块“math”和“cmath”具有许多对它们来说都是通用的函数 - log10()、等等。acos()为了exp()解决这种歧义，必须在它们前面加上各自的模块，如math.exp()和cmath.exp()。
• 考虑下面的代码，对象 temp 已全局初始化为 10，然后在函数调用时初始化为 20。但是，函数调用并未全局更改 temp 的值。在这里，我们可以观察到 Python 在全局变量和局部变量之间划了一条清晰的界线，将它们的命名空间视为单独的身份。

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

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

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

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

Python 中的命名空间可确保程序中的对象名称是唯一的，并且可以毫无冲突地使用。Python 将这些命名空间实现为字典，其中“名称作为键”映射到相应的“对象作为值”。这允许多个命名空间使用相同的名称并将其映射到单独的对象。命名空间的一些示例如下：

• 本地命名空间包括函数内部的本地名称。命名空间是为函数调用临时创建的，并在函数返回时清除。
• 全局命名空间包括当前项目中使用的各种导入包/模块的名称。此命名空间是在脚本中导入包时创建的，并持续到脚本执行为止。
• 内置命名空间包含核心 Python 的内置函数和各种类型异常的内置名称。

命名空间的生命周期取决于它们映射到的对象的范围。如果对象的作用域结束，则该命名空间的生命周期也将结束。因此，无法从外部命名空间访问内部命名空间对象。

5.Python 中如何管理内存？

• Python 中的内存管理由Python 内存管理器处理。管理器分配的内存是 Python 专用的私有堆空间。所有 Python 对象都存储在这个堆中，并且是私有的，程序员无法访问。不过，Python 确实提供了一些核心 API 函数来处理私有堆空间。
• 此外，Python 具有内置的垃圾收集功能，用于回收私有堆空间中未使用的内存。

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

Lambda 是 Python 中的一个匿名函数，可以接受任意数量的参数，但只能有一个表达式。它通常用于短时间内需要匿名函数的情况。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

7. 解释如何在 Python 中删除文件？

使用命令os.remove(file_name)

import os
os.remove("ChangedFile.csv")
print("File Removed!")

8. 什么是负指数以及为什么要使用它们？

• 负索引是从列表或元组或字符串末尾开始的索引。
• Arr[-1]表示数组Arr[]的最后一个元素

arr = [1, 2, 3, 4, 5, 6]
#get the last elementprint(arr[-1]) #output 6#get the second last elementprint(arr[-2]) #output 5

9. *args 和 **kwargs 是什么意思？

*参数

• *args 是在函数定义中用来传递可变长度参数的特殊语法。
• “*” 表示可变长度，“args” 是约定俗成的名称。您可以使用任何其他名称。

def multiply(a, b, *argv):
   mul = a * b
   for num in argv:
       mul *= num
   return mul
print(multiply(1, 2, 3, 4, 5)) #output: 120

**关键字

• **kwargs 是在函数定义中用来传递可变长度的关键字参数的特殊语法。
• 这里也只是按照惯例使用“kwargs”。你可以使用任何其他名称。
• 关键字参数是指传递给函数时具有名称的变量。
• 它实际上是变量名称及其值的字典。

def tellArguments(**kwargs):
   for key, value in kwargs.items():
       print(key + ": " + value)
tellArguments(arg1 = "argument 1", arg2 = "argument 2", arg3 = "argument 3")
#output:
# arg1: argument 1
# arg2: argument 2
# arg3: argument 3

10. 解释 Python 中的 split() 和 join() 函数？

• 您可以使用split()函数根据分隔符将字符串拆分为字符串列表。
• 您可以使用join()函数根据分隔符连接字符串列表以得出单个字符串。

string = "This is a string."
string_list = string.split(' ') #delimiter is ‘space’ character or ‘ ‘print(string_list) #output: ['This', 'is', 'a', 'string.']print(' '.join(string_list)) #output: This is a string.

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

• 迭代器是一个对象。
• 它会记住它的状态，即它在迭代过程中的位置（请参阅下面的代码以了解如何操作）
• iter() 方法初始化一个迭代器。
• 它有一个 __next__() 方法，该方法返回迭代中的下一个项并指向下一个元素。到达可迭代对象的末尾时，__next__() 必须返回 StopIteration 异常。
• 它也是可自我迭代的。
• 迭代器是可以用来迭代列表、字符串等可迭代对象的对象。

class ArrayList:
   def __init__(self, number_list):
       self.numbers = number_list
   def __iter__(self):
       self.pos = 0
       return self
   def __next__(self):
       if(self.pos < len(self.numbers)):
           self.pos += 1
           return self.numbers[self.pos - 1]
       else:
           raise StopIteration
array_obj = ArrayList([1, 2, 3])
it = iter(array_obj)
print(next(it)) #output: 2
print(next(it)) #output: 3
print(next(it))
#Throws Exception
#Traceback (most recent call last):
#...
#StopIteration

12. 在 Python 中，参数如何按值或按引用传递？

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

在 Python 中，参数是通过引用传递的，即传递对实际对象的引用。

def appendNumber(arr):
   arr.append(4)
arr = [1, 2, 3]
print(arr)  #Output: => [1, 2, 3]
appendNumber(arr)
print(arr)  #Output: => [1, 2, 3, 4]

13. Python 是如何解释的？

• Python 作为一种语言不是解释型或编译型的。解释型或编译型是实现的属性。Python 是一种通常解释型的字节码（一组解释器可读的指令）。
• 源代码是一个扩展名为.py 的文件。
• Python 将源代码编译为虚拟机的一组指令。Python 解释器是该虚拟机的实现。这种中间格式称为“字节码”。
• .py 源代码首先被编译为 .pyc 字节码。然后，该字节码可以由官方的 CPython 或 PyPy 编译的 JIT（即时编译器）解释。

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

• .py 文件包含程序的源代码。而 .pyc 文件包含程序的字节码。我们在编译 .py 文件（源代码）后获得字节码。.pyc 文件不会为您运行的所有文件创建。它只为您导入的文件创建。
• 在执行 Python 程序之前，Python 解释器会检查已编译的文件。如果文件存在，则虚拟机将执行它。如果未找到，则检查 .py 文件。如果找到，则将其编译为 .pyc 文件，然后 Python 虚拟机将执行它。
• 拥有.pyc 文件可以节省您的编译时间。

15.help() 和 dir() 函数有什么用途？

Python 中的help()函数用于显示模块、类、函数、关键字等的文档。如果未向该函数传递任何参数，则会在控制台上启动help()交互式帮助实用程序。dir()函数尝试返回所调用对象的有效属性和方法列表。它对不同对象的行为不同，因为它旨在生成最相关的数据，而不是完整的信息。

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

16. Python 中的 PYTHONPATH 是什么？

PYTHONPATH 是一个环境变量，您可以设置它来添加 Python 查找模块和包的其他目录。这对于维护您不想安装在全局默认位置的 Python 库特别有用。

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

生成器是按集合方式一次返回一个可迭代项集合的函数。通常，生成器用于以不同的方法创建迭代器。它们使用yield关键字而不是return返回生成器对象。 让我们尝试构建一个斐波那契数的生成器 -

## generate fibonacci numbers upto n
def fib(n):
   p, q = 0, 1
   while(p < n):
       yield p
       p, q = q, p + q
x = fib(10)    # create generator object 
 
## iterating using __next__(), for Python2, use next()
x.__next__()    # output => 0
x.__next__()    # output => 1
x.__next__()    # output => 1
x.__next__()    # output => 2
x.__next__()    # output => 3
x.__next__()    # output => 5
x.__next__()    # output => 8
x.__next__()    # error
 
## iterating using loop
for i in fib(10):
   print(i)    # output => 0 1 1 2 3 5 8

18. 什么是 pickling 和 unpickling？

Python 库提供了一个现成的功能 -序列化。序列化对象是指将其转换为可以存储的格式，以便稍后对其进行反序列化以获取原始对象。这里，pickle模块发挥作用。

酸洗：

• Pickling 是 Python 中序列化过程的名称。Python 中的任何对象都可以序列化为字节流并作为文件转储到内存中。Pickling 过程很紧凑，但 pickle 对象可以进一步压缩。此外，pickle 会跟踪已序列化的对象，并且序列化可跨版本移植。
• 上述过程用到的函数是pickle.dump()。

反腌制：

• Unpickling 是 pickling 的完全逆过程。它反序列化字节流以重新创建文件中存储的对象，并将对象加载到内存中。
• 上述过程用到的函数是pickle.load()。

注意：Python 还有另一个更原始的序列化模块，称为marshall，它主要用于支持Python 中的.pyc 文件，与 pickle 有很大不同。

19.Python中xrange和range有什么区别？

xrange()和range()在功能上非常相似。它们都生成一个整数序列，唯一的区别是xrange()range()返回一个Python 列表，而 xrange()xrange()返回一个xrange 对象。

那么这有什么区别呢？当然有区别，因为与 range() 不同，xrange() 不会生成静态列表，而是随时创建值。这种技术通常与对象类型生成器一起使用，被称为“ yielding ”。

在内存受限的应用程序中，屈服Memory Error至关重要。在这种情况下，像 range() 中那样创建静态列表可能会导致，而 xrange() 可以通过为生成器使用足够的内存（相比之下要少得多）来最佳地处理它。

for i in xrange(10):    # numbers from o to 9
   print i       # output => 0 1 2 3 4 5 6 7 8 9
for i in xrange(1,10):    # numbers from 1 to 9
   print i       # output => 1 2 3 4 5 6 7 8 9
for i in xrange(1, 10, 2):    # skip by two for next
   print i       # output => 1 3 5 7 9

注意：从Python 3.x开始，xrange已被弃用。现在的功能与Python 2.x中完全相同，因为使用 xrange() 比使用 Python 2.x 中的原始 range() 函数要好得多。rangexrange

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

在 Python 中，赋值语句 (=运算符) 不会复制对象。相反，它会在现有对象和目标变量名之间创建绑定。要在 Python 中创建对象的副本，我们需要使用copy模块。此外，使用copy模块为给定对象创建副本有两种方法-

浅拷贝是对象的逐位复制。所创建的复制对象具有原始对象中值的精确副本。如果其中一个值是对其他对象的引用，则仅复制该对象的引用地址。 深拷贝将所有值从源对象递归复制到目标对象，即它甚至复制源对象引用的对象。

from copy import copy, deepcopy
list_1 = [1, 2, [3, 5], 4]
## shallow copy
list_2 = copy(list_1) 
list_2[3] = 7
list_2[2].append(6)
list_2    # output => [1, 2, [3, 5, 6], 7]
list_1    # output => [1, 2, [3, 5, 6], 4]## deep copy
list_3 = deepcopy(list_1)
list_3[3] = 8
list_3[2].append(7)
list_3    # output => [1, 2, [3, 5, 6, 7], 8]
list_1    # output => [1, 2, [3, 5, 6], 4]