如何在 Python 编程面试中脱颖而出

迭代与enumerate()代替range()

在编码面试中，这种情况可能比其他情况出现得更多：您有一个元素列表，并且需要迭代该列表以访问索引和值。

有一个名为 FizzBu​​zz 的经典编码面试问题，可以通过迭代索引和值来解决。在 FizzBu​​zz 中，您会得到一个整数列表。您的任务是执行以下操作：

1. 替换所有能被整除的整数3和"fizz"
2. 替换所有能被整除的整数5和"buzz"
3. 替换所有可被两者整除的整数3和5和"fizzbuzz"

通常，开发人员会通过以下方式解决这个问题range():

>>> numbers = [45, 22, 14, 65, 97, 72]
>>> for i in range(len(numbers)):
...     if numbers[i] % 3 == 0 and numbers[i] % 5 == 0:
...         numbers[i] = 'fizzbuzz'
...     elif numbers[i] % 3 == 0:
...         numbers[i] = 'fizz'
...     elif numbers[i] % 5 == 0:
...         numbers[i] = 'buzz'
...
>>> numbers
['fizzbuzz', 22, 14, 'buzz', 97, 'fizz']

Range 允许您访问以下元素numbers通过索引，是一个有用的工具对于某些情况。但在这种情况下，如果您想同时获取每个元素的索引和值，则更优雅的解决方案使用枚举（）:

>>> numbers = [45, 22, 14, 65, 97, 72]
>>> for i, num in enumerate(numbers):
...     if num % 3 == 0 and num % 5 == 0:
...         numbers[i] = 'fizzbuzz'
...     elif num % 3 == 0:
...         numbers[i] = 'fizz'
...     elif num % 5 == 0:
...         numbers[i] = 'buzz'
...
>>> numbers
['fizzbuzz', 22, 14, 'buzz', 97, 'fizz']

对于每个元素，enumerate()返回一个计数器和元素值。计数器默认为0，这也是元素的索引。不想从以下时间开始计数0？只需使用可选的start设置偏移量的参数：

>>> numbers = [45, 22, 14, 65, 97, 72]
>>> for i, num in enumerate(numbers, start=52):
...     print(i, num)
...
52 45
53 22
54 14
55 65
56 97
57 72

通过使用start参数中，我们从第一个索引开始访问所有相同的元素，但现在我们的计数从指定的整数值开始。

使用列表推导式代替map()和filter()

“我认为删除 filter() 和 map() 是相当没有争议的[.]”

— Guido van Rossum，Python 的创造者

他可能错误地认为它没有争议，但吉多有充分的理由想要删除地图（）和筛选（）来自Python。原因之一是 Python 支持列表推导式，通常更容易阅读并支持与map()和filter().

让我们首先看一下如何构造一个调用map()以及等效的列表理解：

>>> numbers = [4, 2, 1, 6, 9, 7]
>>> def square(x):
...     return x*x
...
>>> list(map(square, numbers))
[16, 4, 1, 36, 81, 49]

>>> [square(x) for x in numbers]
[16, 4, 1, 36, 81, 49]

两种方法都使用map()和列表理解，返回相同的值，但列表理解更容易阅读和理解。

现在我们可以为filter()及其等效的列表理解：

>>> def is_odd(x):
...    return bool(x % 2)
...
>>> list(filter(is_odd, numbers))
[1, 9, 7]

>>> [x for x in numbers if is_odd(x)]
[1, 9, 7]

就像我们看到的map()， 这filter()和列表理解方法返回相同的值，但列表理解更容易遵循。

来自其他语言的开发人员可能不同意列表推导式比列表推导式更容易阅读。map()和filter()，但根据我的经验，初学者能够更直观地掌握列表推导式。

不管怎样，在编码面试中使用列表推导式很少会出错，因为它会传达出你知道 Python 中最常见的内容。

调试方式breakpoint()代替print()

您可能已经通过添加来调试一个小问题打印（）到您的代码并查看打印出来的内容。这种方法一开始效果很好，但很快就会变得很麻烦。另外，在编码面试环境中，你几乎不希望print() 调用贯穿你的代码。

相反，您应该使用调试器。对于重要的错误，它几乎总是比使用更快print()，并且鉴于调试是编写软件的重要组成部分，它表明您知道如何使用可以让您在工作中快速开发的工具。

如果您使用的是 Python 3.7，则无需导入任何内容，只需调用断点()在代码中您想要放入调试器的位置：

# Some complicated code with bugs

breakpoint()

呼唤breakpoint()会让你陷入pdb，这是默认的 Python 调试器。在 Python 3.6 及更早版本上，您可以通过导入来执行相同的操作pdb明确地：

import pdb; pdb.set_trace()

喜欢breakpoint(), pdb.set_trace()会把你带入pdb调试器。它只是不太干净，而且需要记住一些。

您可能还想尝试其他可用的调试器，但是pdb是标准库的一部分，因此它始终可用。无论您喜欢哪种调试器，在进行编码面试之前都值得尝试一下以适应工作流程。

使用 f 字符串格式化字符串

Python 有很多不同的方法来处理字符串格式化，并且知道使用什么方法可能很棘手。事实上，我们在两篇单独的文章中深入讨论了格式化问题：一篇关于一般字符串格式和一个具体的专注于 f 弦。在编码面试中，如果您（希望）使用 Python 3.6+，建议的格式化方法是 Python 的 f 字符串。

f 字符串支持使用字符串格式化迷你语言，以及强大的字符串插值。这些功能允许您添加变量甚至有效的 Python 表达式，并在将它们添加到之前在运行时对其进行评估。细绳:

>>> def get_name_and_decades(name, age):
...     return f"My name is {name} and I'm {age / 10:.5f} decades old."
...
>>> get_name_and_decades("Maria", 31)
My name is Maria and I'm 3.10000 decades old.

f 字符串允许您放置Maria到字符串中，并通过一个简洁的操作添加她的年龄和所需的格式。

需要注意的一个风险是，如果您输出用户生成的值，那么可能会带来安全风险，在这种情况下模板字符串可能是一个更安全的选择。

对复杂列表进行排序sorted()

许多编码面试问题都需要某种排序，并且有多种有效的方法可以对项目进行排序。除非面试官希望你实现自己的排序算法，通常最好使用排序（）.

您可能已经见过排序最简单的用法，例如对列表进行排序数字或按升序或降序排列的字符串：

>>> sorted([6,5,3,7,2,4,1])
[1, 2, 3, 4, 5, 6, 7]

>>> sorted(['cat', 'dog', 'cheetah', 'rhino', 'bear'], reverse=True)
['rhino', 'dog', 'cheetah', 'cat', 'bear]

默认情况下，sorted()已按升序对输入进行排序，并且reverse关键字参数导致它按降序排序。

值得了解可选关键字参数key它允许您指定一个在排序之前对每个元素调用的函数。添加函数允许自定义排序规则，如果您想对更复杂的数据类型进行排序，这特别有用：

>>> animals = [
...     {'type': 'penguin', 'name': 'Stephanie', 'age': 8},
...     {'type': 'elephant', 'name': 'Devon', 'age': 3},
...     {'type': 'puma', 'name': 'Moe', 'age': 5},
... ]
>>> sorted(animals, key=lambda animal: animal['age'])
[
    {'type': 'elephant', 'name': 'Devon', 'age': 3},
    {'type': 'puma', 'name': 'Moe', 'age': 5},
    {'type': 'penguin', 'name': 'Stephanie, 'age': 8},
]

通过传入一个拉姆达函数返回每个元素的年龄，您可以轻松地按每个字典的单个值对字典列表进行排序。在本例中，字典现在按年龄升序排序。

使用集合存储唯一值

您经常需要从现有数据集中删除重复元素。新开发人员有时会在应该使用集合时使用列表，这会强制所有元素的唯一性。

假设你有一个名为get_random_word()。它总是会从一小组单词中随机返回一个选择：

>>> import random
>>> all_words = "all the words in the world".split()
>>> def get_random_word():
...    return random.choice(all_words)

你应该打电话get_random_word()重复获取 1000 个随机单词，然后返回包含每个唯一单词的数据结构。以下是两种常见的次优方法和一种好的方法。

坏方法

get_unique_words()将值存储在列表中，然后将列表转换为集合：

>>> def get_unique_words():
...     words = []
...     for _ in range(1000):
...         words.append(get_random_word())
...     return set(words)
>>> get_unique_words()
{'world', 'all', 'the', 'words'}

这种方法并不可怕，但它不必要地创建一个列表，然后将其转换为一个集合。面试官几乎总是会注意到（并询问）这种类型的设计选择。

更糟糕的方法

为了避免从列表转换为集合，您现在将值存储在列表中，而不使用任何其他数据结构。然后，您可以通过将新值与列表中当前的所有元素进行比较来测试唯一性：

>>> def get_unique_words():
...     words = []
...     for _ in range(1000):
...         word = get_random_word()
...         if word not in words:
...             words.append(word)
...     return words
>>> get_unique_words()
['world', 'all', 'the', 'words']

这比第一种方法更糟糕，因为您必须将每个新单词与列表中已有的每个单词进行比较。这意味着随着单词数量的增加，查找次数呈二次方增长。换句话说，时间复杂度以 O(N²) 的量级增长。

好方法

现在，您完全跳过使用列表，而是从一开始就使用集合：

>>> def get_unique_words():
...     words = set()
...     for _ in range(1000):
...         words.add(get_random_word())
...     return words
>>> get_unique_words()
{'world', 'all', 'the', 'words'}

除了从一开始就使用集合之外，这可能看起来与其他方法没有太大不同。如果你考虑一下里面发生的事情.add()，它甚至听起来像第二种方法：获取单词，检查它是否已经在集合中，如果没有，则将其添加到数据结构中。

那么为什么使用集合与第二种方法不同呢？

这是不同的，因为集合以允许近恒定时间检查值是否在集合中的方式存储元素，这与需要线性时间查找的列表不同。查找时间的差异意味着时间复杂度添加到集合的速度以 O(N) 的速度增长，在大多数情况下，这比第二种方法的 O(N²) 好得多。

使用生成器节省内存

列表推导式是方便的工具，但有时会导致不必要的内存使用。

想象一下，您被要求求从 1 开始的前 1000 个完全平方数的和。您了解列表推导式，因此您可以快速编写一个可行的解决方案：

>>> sum([i * i for i in range(1, 1001)])
333833500

您的解决方案列出了 1 到 1,000,000 之间的每个完全平方数，并对这些值求和。你的代码返回了正确的答案，但随后你的面试官开始增加你需要求和的完全平方数。

起初，你的函数不断弹出正确的答案，但很快它开始减慢，直到最终该过程似乎永远挂起。这是你最不希望在编码面试中发生的事情。

这里发生了什么？

它会列出您所要求的每个完美正方形，并将它们全部相加。从计算机角度来看，包含 1000 个完全平方数的列表可能并不大，但 1 亿或 10 亿个信息量就相当大了，很容易就会耗尽计算机的可用内存资源。这就是这里发生的事情。

值得庆幸的是，有一种快速方法可以解决内存问题。您只需将方括号替换为圆括号即可：

>>> sum((i * i for i in range(1, 1001)))
333833500

交换括号会将您的列表理解更改为生成器表达式。当您知道要从序列中检索数据，但不需要同时访问所有数据时，生成器表达式非常适合。

不是创建列表，而是生成器表达式返回一个generator目的。该对象知道它当前的状态（例如，i = 49）并且仅在需要时计算下一个值。

所以当sum通过调用迭代生成器对象.__next__()生成器反复检查什么i等于，计算i * i, 增量i内部，并返回正确的值sum。该设计允许生成器用于大量数据序列，因为内存中一次只存在一个元素。

定义字典中的默认值.get()和.setdefault()

最常见的编程任务之一涉及添加、修改或检索可能位于或不位于字典中的项目。 Python 字典具有优雅的功能，可以使这些任务变得干净、简单，但开发人员经常在不必要时显式检查值。

假设你有一本名为cowboy，并且您想知道那个牛仔的名字。一种方法是使用条件显式检查密钥：

>>> cowboy = {'age': 32, 'horse': 'mustang', 'hat_size': 'large'}
>>> if 'name' in cowboy:
...     name = cowboy['name']
... else:
...     name = 'The Man with No Name'
...
>>> name
'The Man with No Name'

该方法首先检查是否namekey在字典中存在，如果存在则返回对应的值。否则，它返回默认值。

虽然显式检查密钥确实有效，但如果您使用，它可以轻松地用一行替换.get():

>>> name = cowboy.get('name', 'The Man with No Name')

get()执行与第一种方法中执行的操作相同的操作，但现在它们是自动处理的。如果键存在，那么将返回正确的值。否则，将返回默认值。

但是，如果您想在访问字典的同时使用默认值更新字典，该怎么办？name钥匙？.get()在这里并没有真正帮助你，所以你只能再次显式检查该值：

>>> if 'name' not in cowboy:
...     cowboy['name'] = 'The Man with No Name'
...
>>> name = cowboy['name']

检查值并设置默认值是一种有效的方法，并且易于阅读，但 Python 再次提供了一种更优雅的方法：.setdefault():

>>> name = cowboy.setdefault('name', 'The Man with No Name')

.setdefault()完成与上面的代码片段完全相同的事情。它检查是否name存在于cowboy，如果是，则返回该值。否则，它设置cowboy['name']到The Man with No Name并返回新值。

处理丢失的字典键collections.defaultdict()

.get()和.setdefault()当您为单个键设置默认值时效果很好，但通常需要为所有可能未设置的键设置默认值，尤其是在编码面试环境中编程时。

假设您有一群学生，您需要跟踪他们的家庭作业成绩。输入值是具有以下格式的元组列表(student_name, grade)，但您希望轻松查找单个学生的所有成绩，而无需迭代列表。

存储成绩数据的一种方法是使用字典将学生姓名映射到成绩列表：

>>> student_grades = {}
>>> grades = [
...     ('elliot', 91),
...     ('neelam', 98),
...     ('bianca', 81),
...     ('elliot', 88),
... ]
>>> for name, grade in grades:
...     if name not in student_grades:
...         student_grades[name] = []
...     student_grades[name].append(grade)
...
>>> student_grades
{'elliot': [91, 88], 'neelam': [98], 'bianca': [81]}

在这种方法中，您迭代学生并检查他们的名字是否已经是字典中的属性。如果没有，请将它们添加到字典中，并使用空列表作为默认值。然后是你附加他们的实际成绩到该学生的成绩列表。

但有一种更干净的方法，使用defaultdict，它扩展了标准dict功能允许您设置默认值，如果密钥不存在，将对其进行操作：

>>> from collections import defaultdict
>>> student_grades = defaultdict(list)
>>> for name, grade in grades:
...     student_grades[name].append(grade)

在本例中，您正在创建一个defaultdict使用的是list()不带参数的构造函数作为默认工厂方法。list()不带参数返回一个空列表，所以defaultdict来电list()如果名称不存在，则允许附加成绩。如果您想变得更奇特，您还可以使用 lambda 函数作为工厂值来返回任意常量。

利用一个defaultdict可以导致更干净的应用程序代码，因为您不必担心键级别的默认值。相反，您可以在defaultdict级别，然后就好像密钥始终存在一样。有关此技术的更多信息，请查看使用 Python defaultdict 类型处理丢失的键.

计算可哈希对象的数量collections.Counter

您有一长串没有标点符号或大写字母的单词，并且您想要计算每个单词出现的次数。

你可以使用字典或defaultdict并增加计数，但是collections.Counter提供了一种更干净、更方便的方法来做到这一点。计数器是一个子类dict使用0作为任何缺失元素的默认值，并且可以更轻松地计算对象的出现次数：

>>> from collections import Counter
>>> words = "if there was there was but if \
... there was not there was not".split()
>>> counts = Counter(words)
>>> counts
Counter({'if': 2, 'there': 4, 'was': 4, 'not': 2, 'but': 1})

当您将单词列表传递给Counter，它存储每个单词以及该单词在列表中出现的次数。

您是否好奇最常见的两个词是什么？只需使用.most_common():

>>> counts.most_common(2)
[('there', 4), ('was', 4)]

.most_common()是一种方便的方法，只需返回n最常见的输入（按计数）。

访问通用字符串组：string常数

现在是问答时间！是'A' > 'a'对或错？

这是错误的，因为 ASCII 代码为A是 65，但是a是97，并且65不大于97。

为什么答案很重要？因为如果你想检查一个字符是否是英文字母的一部分，一种流行的方法是查看它是否介于A和z（ASCII 图表上的 65 和 122）。

检查 ASCII 代码是可行的，但在编码面试中很笨拙且容易搞砸，尤其是当您不记得小写还是大写 ASCII 字符在前时。使用定义为一部分的常量要容易得多字符串模块.

您可以在其中看到一个正在使用的is_upper()，它返回字符串中的所有字符是否都是大写字母：

>>> import string
>>> def is_upper(word):
...     for letter in word:
...         if letter not in string.ascii_uppercase:
...             return False
...     return True
...
>>> is_upper('Thanks Geir')
False
>>> is_upper('LOL')
True

is_upper()迭代中的字母word，并检查字母是否是string.ascii_uppercase。如果打印出来string.ascii_uppercase你会发现它只是一根低级的字符串。该值设置为文字'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

全部string常量只是经常引用的字符串值的字符串。它们包括以下内容：

• string.ascii_letters
• string.ascii_uppercase
• string.ascii_lowercase
• string.digits
• string.hexdigits
• string.octdigits
• string.punctuation
• string.printable
• string.whitespace

这些更容易使用，更重要的是，更容易阅读。

生成排列和组合itertools

面试官喜欢提供现实生活中的场景，让编码面试看起来不那么令人生畏，所以这里有一个人为的例子：你去了一个游乐园，决定找出每一对可以一起坐在过山车上的朋友。

除非生成这些对是面试问题的主要目的，否则生成所有可能的对很可能只是实现可行算法的一个乏味的步骤。您可以使用嵌套自行计算它们for循环，或者你可以使用强大的迭代工具库.

itertools有多种工具用于生成可迭代的输入数据序列，但现在我们只关注两个常见函数：itertools.permutations()和itertools.combinations().

itertools.permutations()构建所有排列的列表，这意味着它是每个可能的输入值分组的列表，其长度与count范围。这r关键字参数让我们指定每个分组中有多少个值：

>>> import itertools
>>> friends = ['Monique', 'Ashish', 'Devon', 'Bernie']
>>> list(itertools.permutations(friends, r=2))
[('Monique', 'Ashish'), ('Monique', 'Devon'), ('Monique', 'Bernie'),
('Ashish', 'Monique'), ('Ashish', 'Devon'), ('Ashish', 'Bernie'),
('Devon', 'Monique'), ('Devon', 'Ashish'), ('Devon', 'Bernie'),
('Bernie', 'Monique'), ('Bernie', 'Ashish'), ('Bernie', 'Devon')]

对于排列，元素的顺序很重要，所以('sam', 'devon')代表不同的配对('devon', 'sam')，这意味着它们都将包含在列表中。

itertools.combinations()构建组合。这些也是输入值的可能分组，但现在值的顺序并不重要。因为('sam', 'devon')和('devon', 'sam')代表同一对，只有其中一个会包含在输出列表中：

>>> list(itertools.combinations(friends, r=2))
[('Monique', 'Ashish'), ('Monique', 'Devon'), ('Monique', 'Bernie'),
('Ashish', 'Devon'), ('Ashish', 'Bernie'), ('Devon', 'Bernie')]

由于值的顺序与组合无关，因此对于同一输入列表，组合的数量少于排列的数量。再次，因为我们设置r到2，每个分组有两个名字。

.combinations()和.permutations()只是强大库的小例子，但当您尝试快速解决算法问题时，即使这两个函数也非常有用。