在本文中，我将我的一些笔记变成了20 个面试问题，涵盖了数据结构、核心编程概念和 Python 最佳实践。 有趣的是，在数据科学面试中会提出很多这样的问题。

希望你能完成其中的一些并重温你的 Python 技能。

事不宜迟，让我们直接进入。

1. 列表和元组有什么区别？你应该什么时候使用每个？

列表是可变数据结构，而元组是不可变数据结构。
Python 中的可变对象具有更改其值的能力。

列表是动态的：您可以向其中添加项目或覆盖和删除现有项目。
元组是固定大小的：它们没有方法append或extend方法。您也不能从中删除项目。
元组和列表都支持索引并允许使用in运算符检查其中的现有元素。

→ 在某些情况下，我认为元组可能有用。

• 如果您声明一个您知道永远不会更改的项目集合，或者您将只循环而不更改其值，请使用元组。
• 如果您寻找性能，元组比列表更快，因为它们是只读结构。如果您不需要写操作，请考虑使用元组。
• 如果您想防止意外写入不需要更改的数据，元组可以使您的代码更安全。

这是一个代码示例，显示了元组与列表的不同之处。

>>> numbers = [1, 2, 3, 4, 5]
>>> numbers[1] = 100
>>> print(numbers)
[1, 100, 3, 4, 5]

>>> names = ("john", "joe", "alice")
>>> names[0] = "bob")
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-25012ce34a87> in <module>
----> 1 names[0] = "bob"

TypeError: 'tuple' object does not support item assignment

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 多处理和多线程有什么区别？你应该什么时候使用每个？

多处理和多线程是旨在加快代码速度的编程范例。

当您使用多处理时，您可以在进程上并行计算。进程是独立的，不相互通信：它们不共享相同的内存区域，并且相互之间有严格的隔离。在应用方面，多处理适用于 CPU 密集型工作负载。但是，它确实具有与进程数量成正比的大量内存占用。

另一方面，在多线程应用程序中，线程存在于单个进程中。因此，它们共享相同的内存区域：它们可以修改相同的变量并且可以相互干扰。虽然进程是严格并行执行的，但在 Python 中的给定时间点只执行一个线程，这是由于全局解释器锁 ( GIL )。多线程适用于受 IO 限制的应用程序，例如网页抓取或从数据库中获取数据。

→ 如果您想了解有关多线程和多处理的更多信息，我建议您阅读这篇精彩的博客文章，该文章全面介绍了这两个概念。

3. 模块、包和库之间有什么区别？

模块只是一个 Python 文件，旨在导入脚本或其他模块。它包含函数、类和全局变量。

包是模块的集合，它们在文件夹中组合在一起以提供一致的功能。包可以像模块一样被导入。它们通常有一个__init__.py文件告诉 Python 解释器按原样处理它们。

库是包的集合。

4. python 中的多线程有什么问题？

全局解释器锁（或 GIL）可防止 Python 解释器同时执行多个线程。简而言之，GIL 强制在 Python 中的任何时间点只执行一个线程。

这代表了依赖多线程代码的 CPU 密集型应用程序的一个很大的性能瓶颈。

5. 什么是装饰器？你能描述一下装饰器值得使用的情况吗？

装饰器是一个接收函数作为输入并返回函数作为输出的函数。装饰器的目标是在不改变其核心机制的情况下扩展输入函数的行为。

使用装饰器还可以防止您重复自己。它迫使您编写一次通用代码，然后将其用于需要它的每个功能。

装饰器大放异彩的典型用例是日志记录。

例如，想象一下，您希望将传递给程序中调用的每个函数的所有参数值记录到终端。您可以遍历每个函数定义并将其写下来，或者您可以只编写一个装饰器来执行此日志记录任务并将其应用于所有需要它的函数。

将装饰器应用于函数只需在该函数的定义上方添加一行即可。

# 没有装饰器  
def my_awesome_function():      
    # 做一些很棒的事情  
# 带有装饰器  
@my_awesome_decorator 
def my_awesome_function():     
    # 做更棒的事情

1
2
3
4
5
6
7
8
9

下面是一个代码示例，它创建了一个名为的装饰器，该装饰器log记录了传递给函数的参数的值。

import logging


logging.basicConfig(
    format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
    level=logging.INFO,
    datefmt="%Y-%m-%d %H:%M:%S",
    stream=sys.stdout,
)
logger = logging.getLogger("notebook")

def log(func):
    def wrapper(*args, **kwargs):
        output = func(*args, **kwargs)
        msg = f"{func.__name__} was run with the following args: {args} and the following kwargs {kwargs}"
        logger.info(msg)
        return output
    return wrapper


@log
def print_args(*args, **kwargs):
    print(args)
    print(kwargs)


>>> print_args(10, a=2, b="test")
(10,)
{'a': 2, 'b': 'test'}
2022-03-06 18:07:05,248 - notebook - INFO - print_args was run with the following args: (10,) and the following kwargs {'a': 2, 'b': 'test'}

>>> print_args(10, 100, a=2, b="test")
(10, 100)
{'a': 2, 'b': 'test'}
2022-03-06 18:07:05,562 - notebook - INFO - print_args was run with the following args: (10, 100) and the following kwargs {'a': 2, 'b': 'test'}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

装饰器还可以用于其他目的，例如计时功能、验证输入数据、执行访问控制和身份验证、缓存等。

6. 如何正确地将数据写入文件？否则会出什么问题？

使用上下文管理器是关键。

当您使用open没有上下文管理器的语句并且在关闭文件之前发生一些异常时（关闭文件是您在以这种方式打开文件时必须记住的事情）可能会发生内存问题并且文件可能会在此过程中损坏。

当你with用来打开一个文件并且发生异常时，Python 保证该文件是关闭的。

7. 函数参数是按引用传递还是按值传递？

在 Python 中，所有函数参数都是通过引用传递的：这意味着如果将参数传递给函数，则函数将获得对同一对象的引用。

如果对象是可变的并且函数改变了它，则参数将在函数的外部范围内发生变异。让我们看一个例子：

8. 如何覆盖对象的打印方式？

使用 the__str__和__repr__dunder 方法。

这是一个示例，它演示了 Person 类中的实例在打印到控制台时如何被很好地格式化。

9. 编写一个计算整数 n 阶乘的函数

递归是关键

10. is 和 == 运算符有什么区别？

==是一个测试相等性的运算符，而is是一个测试身份的运算符。

两个对象可以具有相同的值，但不一定相同（即具有相同的内存地址）。

请记住，这a is b是id(a) == id(b).

11. 什么时候不应该使用 assert 语句？

该assert语句对于内部测试和完整性检查很有用。

但是，它不应该用于执行数据验证或错误处理，因为出于性能原因，它通常在生产代码中被禁用。

想象一下，如果您使用断言检查管理员权限：这可能会在生产中引入很大的安全漏洞。

assert您可以抛出自定义错误，而不是使用该语句。

# Dangerous code!

def delete_product(user, product_id):
    assert user.is_admin()
    user.delete_product(product_id)

# Handle this properly by raising an error

def delete_product(user, product_id):
    if not user.is_admin():
        raise AuthError("User must have admin privileges")
    else:
        user.delete_product(product_id)
1
2
3
4
5
6
7
8
9
10
11
12
13

12. 什么是 Python 生成器？

Python 生成器是一个生成一系列项目的函数。

生成器看起来像典型的函数，但它们的行为是不同的。对于初学者，return他们不使用语句，而是使用yield语句。

然后，调用生成器函数不会运行该函数：它只会创建一个生成器对象。生成器的代码仅在next函数应用于生成器对象或生成器被迭代时执行（在这种情况下，next函数被隐式调用）

在生成器对象上调用函数的次数next等于yield在生成器函数中调用语句的次数。

您可以使用 for 循环或生成器表达式定义生成器。

>>> def repeat(n, message):
        for _ in range(n):
            yield message	

repeat_hello_five_times = repeat(5, hello)

>>> for message in repeat_hello_five_times:
        print(message)

"hello"
"hello"
"hello"
"hello"
"hello" 


>>> repeat_hello_five_time = ("hello" for _ in range(5))
>>> repeat_hello_five_times
<generator object <genexpr> at 0x7fb64f2362d0>

>>> for message in repeat_hello_five_times:
        print(message)

"hello"
"hello"
"hello"
"hello"
"hello" 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

13. 类方法和静态方法有什么区别？什么时候应该使用哪个？

静态方法是一种对调用它的类或实例有任何了解的方法。这是一种逻辑上属于该类但没有隐式参数的方法。
可以在类或其任何实例上调用静态方法。

类方法是传递给调用它的类的方法，就像self传递给类中的其他实例方法一样。类方法的强制参数不是类实例：它实际上是类本身。

类方法的一个典型用例是提供另一种构造实例的方法：执行此操作的类方法称为类的工厂。

这是一个使用类方法的 Employee 类，该类方法创建实例的方式与类的主构造函数略有不同。

class Employee(object):
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_nale

    @classmethod
    def from_string(cls, name_str):
        first_name, last_name = map(str, name_str.split(' '))
        employee = cls(first_name, last_name)
        return employee

ahmed = Employee.from_string('Ahmed Besbes')
1
2
3
4
5
6
7
8
9
10
11
12

14. 举一个例子说明你如何使用 zip 和枚举

该zip函数将多个迭代作为输入并将它们聚合到一个元组中。例如，如果您想同时遍历两个列表，这可能很有用。

>>> names = ["john", "bob", "alice"]
>>> ages = [10, 16, 20]

>>> for name, age in zip(names, ages):
        print(name, age)

john 10
bob 16
alice 20
1
2
3
4
5
6
7
8
9

该enumerate函数允许循环遍历一个可迭代对象并同时访问正在运行的索引和项目。

>>> names = ["john", "bob", "alice"]
>>> for index, name in enumerate(names):
        print(index, name)
0 john
1 bob
2 alice

1
2
3
4
5
6
7
8

15. 你会如何在给定的函数中使用 *args 和 **kwargs？

*args 和 **kwargs 通过接受可变数量的参数使 Python 函数更加灵活。

• *args 在列表中传递可变数量的非关键字参数
• **kwargs 在字典中传递可变数量的关键字参数

这是一个函数示例，该函数采用可变数量的关键字参数，这些参数收集在名为的字典中data（请注意，它不需要命名kwargs）

16. 给出一个使用 map 的函数式编程示例

>>> numbers = [1, 2, 3, 4, 5]

>>> numbers_times_2 = list(map(lambda n: n * 2, numbers))

>>> numbers_times_2
[2, 4, 6, 8, 10]

1
2
3
4
5
6
7

17. continue 和 break 语句有什么区别

该break语句终止包含它的循环。程序立即移动到循环外部范围内的代码段。

另一方面，该continue语句跳过当前迭代的其余代码并移至下一个迭代。

18. 如何防止函数被调用不必要的时间？

使用缓存。

如果与给定输入关联的输出在一段时间内没有变化，则使用缓存对函数有意义。

一个典型的场景是查询一个 web 服务器：如果你第一次查询一个 URL，并且你知道响应不会改变，你可以缓存结果。

from cachetools import cached, TTLCache

cache = TTLCache(maxsize=100, ttl=86400)

@cached(cache)
def extract_article_content(url):
    response = requests.get(url)
    content = response.content
    return content
    
1
2
3
4
5
6
7
8
9
10
11

19. 给出一些 PEP8 指南

• 每个缩进级别使用 4 个空格。
• 进口应按以下顺序分组：

1. 标准库导入。
2. 相关第三方进口。
3. 本地应用程序/库特定的导入。

• 函数名和变量名应为小写并用下划线分隔
• 类名使用 CapWords 约定。

20. 如何使用具有 2GB RAM 的计算机在 Python 中读取 8GB 文件？

此解决方案适用于任何大型（甚至更大）文件。

当您打开文件时，您需要做的就是将文件对象用作迭代器：在循环此文件对象时，您将一次获取一行，并且前面的行将从内存中清除（即它们是垃圾收集）。

这样，文件将永远不会完全加载到内存中，您的处理将在旅途中完成。

with open("./large_dataset.txt") as input_file:
    for line in input_file:
        process_line(line)

1
2
3
4