介紹

            
              作為一名程序員，除了需要具備解決問題的思路以外，代碼的質(zhì)量和簡潔性也很關(guān)鍵。
python內(nèi)置庫中就有很多簡潔而又優(yōu)雅的操作，這里的知識都來源于網(wǎng)絡(luò)積累，
閑暇時整理下來方便溫故。

            
          

目錄

>選擇正確的內(nèi)置功能

• 使用enumerate()而不是range()進行迭代
• 使用遞推式構(gòu)造列表而不是map()和filter()
• 使用斷點breakpoint()調(diào)試而不是print()
• 使用f-Strings格式化字符串
• 使用sorted()對復(fù)雜列表進行排序

>有效利用數(shù)據(jù)結(jié)構(gòu)

• 使用set存儲唯一值
• 使用生成器節(jié)省內(nèi)存
• 使用.get()和.setdefault()在字典中定義默認值

>利用Python的標準庫

• 使用collections.defaultdict()處理缺少的字典鍵
• 使用collections.Counter計算Hashable對象
• 使用字符串常量訪問公共字符串組
• 使用Itertools生成排列和組合

>選擇正確的內(nèi)置功能

Python有一個大型標準庫，但只有一個內(nèi)置函數(shù)的小型庫，這些函數(shù)總是可用的，不需要導(dǎo)入。

1. 使用enumerate()而不是range()進行迭代

假如你需要遍歷列表，同時訪問索引和值。

有一個名為FizzBuzz的經(jīng)典編碼面試問題可以通過迭代索引和值來解決。在FizzBuzz中，你將獲得一個整數(shù)列表，任務(wù)是執(zhí)行以下操作：

• 用“fizz”替換所有可被3整除的整數(shù)
• 用“buzz”替換所有可被5整除的整數(shù)
• 將所有可被3和5整除的整數(shù)替換為“fizzbuzz” 通常，開發(fā)人員將使用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允許你通過索引訪問數(shù)字元素，并且對于某些特殊情況也是一個很有用的工具。但在這種情況下，我們希望同時獲取每個元素的索引和值，更優(yōu)雅的解決方案使用enumerate()：

            
              >>> 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()返回一個計數(shù)器和元素值。計數(shù)器默認為0，也是元素的索引。 不想在0開始你的計數(shù)？只需使用可選的start參數(shù)來設(shè)置偏移量 ：

            
              >>> 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參數(shù)，我們訪問所有相同的元素，從第一個索引開始，但現(xiàn)在我們的計數(shù)從指定的整數(shù)值開始。

2. 使用遞推式構(gòu)造列表而不是map()和filter()

一般使用者可能錯誤地認為它沒有爭議，但Guido有充分的理由想要從Python中刪除map()和filter()。一個原因是Python支持遞推式構(gòu)造列表，它通常更容易閱讀并支持與map()和filter()相同的功能。

讓我們首先看看我們?nèi)绾螛?gòu)造對map()的調(diào)用以及等效的遞推構(gòu)造列表：

            
              >>> 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()和列表推導(dǎo)的兩種方法都返回相同的值，但列表推導(dǎo)更容易閱讀和理解。下面我們可以對filter()及其等效的列表推導(dǎo)做同樣的事情：

            
              >>> 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和列表推導(dǎo)方法返回相同的值，但列表推導(dǎo)更容易理解。

來自其他語言的開發(fā)人員可能不同意構(gòu)造列表比map和filter更容易閱讀，但根據(jù)我的經(jīng)驗，初學(xué)者能夠更直觀地寫出列表推導(dǎo)。但無論哪種方式，在編碼面試中使用列表推導(dǎo)很少會出錯，因為它會讓你知道Python中最常見的是什么。

• 個人認為，無論是使用列表推導(dǎo)還是map和filter,只要熟練應(yīng)用都可以。

3. 使用斷點breakpoint()調(diào)試而不是print()

你可能通過在代碼中添加print并查看打印出的內(nèi)容來調(diào)試一個小問題。這種方法起初效果很好，但很快變得很麻煩。另外，在編碼面試設(shè)置中，你幾乎不希望在整個代碼中調(diào)用print()。

相反，你應(yīng)該使用調(diào)試器。對于不是很瑣碎的錯誤，它幾乎總是比使用print()更快，并且鑒于調(diào)試是編寫軟件的重要部分，它表明你知道如何使用可以在工作中快速開發(fā)的工具。

如果你使用的是Python 3.7，則無需導(dǎo)入任何內(nèi)容，只需在代碼中要放入調(diào)試器的位置調(diào)用breakpoint() ：

            
              # Some complicated code with bugs
breakpoint()

            
          

調(diào)用breakpoint()會將你帶入pdb，這是默認的Python調(diào)試器。在Python 3.6及更早版本中，你可以通過顯式導(dǎo)入pdb來執(zhí)行相同的操作：

            
              import pdb

pdb.set_trace()

            
          

像breakpoint()一樣，pdb.set_trace()會將你帶入pdb調(diào)試器。它不是那么簡潔，而且需要記住的多一點。你可能想要嘗試其他調(diào)試器，但pdb是標準庫的一部分，因此它始終可用。無論你喜歡哪種調(diào)試器，在進行編碼面試設(shè)置之前，都值得嘗試使用它們來適應(yīng)工作流程。

• 關(guān)于pdb的用法，如果不清楚，我有一篇blog專門整理過點擊跳轉(zhuǎn)

4. 使用f-Strings格式化字符串

Python有很多不同的方法來處理字符串格式化，有時候不知道使用哪個。在coding的面試中，如果使用Python 3.6+，建議的格式化方法是Python的f-strings。

f-strings支持使用字符串格式化迷你語言，以及強大的字符串插值。這些功能允許你添加變量甚至有效的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-string允許你將Maria放入字符串中，并在一個簡潔的操作中添加具有所需格式的年齡。需要注意的一個風(fēng)險是，如果你輸出用戶生成的值，那么可能會帶來安全風(fēng)險，在這種情況下，模板字符串可能是更安全的選擇。

5. 使用sorted()對復(fù)雜列表進行排序

大量的編碼面試問題需要進行某種排序，并且有多種有效的方法可以進行排序。除非面試官希望你實現(xiàn)自己的排序算法，否則通常最好使用sorted()。你可能已經(jīng)看到了排序的最簡單用法，例如按升序或降序排序數(shù)字或字符串列表：

            
              >>> 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()已按升序?qū)斎脒M行排序，而reverse關(guān)鍵字參數(shù)則按降序排序。

值得了解的是可選關(guān)鍵字key，它允許你在排序之前指定將在每個元素上調(diào)用的函數(shù)。添加函數(shù)允許自定義排序規(guī)則，如果要對更復(fù)雜的數(shù)據(jù)類型進行排序，這些規(guī)則特別有用：

            
              >>> 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},
]

            
          

通過傳入一個返回每個元素年齡的lambda函數(shù)，可以輕松地按每個字典的單個值對字典列表進行排序。在這種情況下，字典現(xiàn)在按年齡按升序排序。

>有效利用數(shù)據(jù)結(jié)構(gòu)

算法在面試中得到了很多關(guān)注，但數(shù)據(jù)結(jié)構(gòu)可能更為重要。在coding面試環(huán)境中，選擇正確的數(shù)據(jù)結(jié)構(gòu)會對性能產(chǎn)生重大影響。除了理論數(shù)據(jù)結(jié)構(gòu)之外，Python還在其標準數(shù)據(jù)結(jié)構(gòu)實現(xiàn)中內(nèi)置了強大而方便的功能。這些數(shù)據(jù)結(jié)構(gòu)在面試中非常有用，因為它們默認為你提供了許多功能，讓你可以將時間集中在問題的其他部分。

1. 使用set存儲唯一值

我們通常需要從現(xiàn)有數(shù)據(jù)集中刪除重復(fù)元素。新的開發(fā)人員有時會在列表應(yīng)該使用集合時執(zhí)行此操作，這會強制執(zhí)行所有元素的唯一性。

假裝你有一個名為get_random_word()的函數(shù)。它將始終從一小組單詞中返回一個隨機選擇：

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

            
          

你應(yīng)該重復(fù)調(diào)用get_random_word()以獲取1000個隨機單詞，然后返回包含每個唯一單詞的數(shù)據(jù)結(jié)構(gòu)。以下是兩種常見的次優(yōu)方法和一種好的方法。

糟糕的方法

get_unique_words()將值存儲在列表中，然后將列表轉(zhuǎn)換為集合：

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

            
          

這種方法并不可怕，但它不必要地創(chuàng)建了一個列表，然后將其轉(zhuǎn)換為集合。面試官幾乎總是注意到（并詢問）這種類型的設(shè)計選擇。

更糟糕的做法

為避免從列表轉(zhuǎn)換為集合，你現(xiàn)在可以在不使用任何其他數(shù)據(jù)結(jié)構(gòu)的情況下將值存儲在列表中。然后，通過將新值與列表中當前的所有元素進行比較來測試唯一性：

            
              >>> 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']

            
          

這比第一種方法更糟糕，因為你必須將每個新單詞與列表中已有的每個單詞進行比較。這意味著隨著單詞數(shù)量的增加，查找次數(shù)呈二次方式增長。換句話說，時間復(fù)雜度在O(N^2)的量級上增長。

優(yōu)秀的方法

現(xià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()中發(fā)生了什么，它甚至聽起來像第二種方法：得到單詞，檢查它是否已經(jīng)在集合中，如果沒有，則將其添加到數(shù)據(jù)結(jié)構(gòu)中。

那么為什么使用與第二種方法不同的集合呢？

它們是不同的，因為集合存儲元素的方式允許接近恒定時間檢查值是否在集合中，而不像需要線性時間查找的列表。 查找時間的差異意味著添加到集合的時間復(fù)雜度以O(shè)(N)的速率增長，這在大多數(shù)情況下比第二種方法的O(N^2)好得多。

2. 使用生成器節(jié)省內(nèi)存

前面提到，列表推導(dǎo)是方便的工具，但有時會導(dǎo)致不必要的內(nèi)存使用。想象一下，你被要求找到前1000個完美正方形的總和，從1開始。你知道列表推導(dǎo)，所以你快速編寫一個有效的解決方案：

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

            
          

解決方案會列出1到1,000,000之間的每個完美平方，并對值進行求和。你的代碼會返回正確的答案，但隨后您的面試官會開始增加您需要總和的完美正方形的數(shù)量。

起初，你的功能不斷彈出正確的答案，但很快就開始放慢速度，直到最后這個過程似乎永遠持續(xù)下去。這不是你想要在面試中發(fā)生的一件事。

這里發(fā)生了什么？

它正在列出你要求的每個完美的方塊，并將它們?nèi)考悠饋怼＞哂?000個完美正方形的列表在計算機術(shù)語中可能不會很大，但是1億或10億是相當多的信息，并且很容易占用計算機的可用內(nèi)存資源。這就是這里發(fā)生的事情。

值得慶幸的是，有一種解決內(nèi)存問題的快捷方法。你只需用括號替換方括號：

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

            
          

換出括號會將列表推導(dǎo)更改為生成器表達式。當你知道要從序列中檢索數(shù)據(jù)，但不需要同時訪問所有數(shù)據(jù)的時候，生成器表達式非常適合。

生成器表達式返回生成器對象，而不是創(chuàng)建列表。該對象知道它在當前狀態(tài)中的位置（例如，i = 49）并且僅在被要求時計算下一個值。

因此，當sum通過重復(fù)調(diào)用.__ next __()來迭代生成器對象時，生成器檢查i 等于多少，計算i * i，在內(nèi)部遞增i，并將正確的值返回到sum。該設(shè)計允許生成器用于大量數(shù)據(jù)序列，因為一次只有一個元素存在于內(nèi)存中。

3. 使用.get()和.setdefault()在字典中定義默認值

最常見的編程任務(wù)之一涉及添加，修改或檢索可能在字典中或可能不在字典中的項。Python字典具有優(yōu)雅的功能，可以使這些任務(wù)簡潔明了，但開發(fā)人員通常會在不需要時檢查值。

想象一下，你有一個名為cowboy的字典，你想得到那個cowboy的名字。一種方法是使用條件顯式檢查key：

            
              >>> 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'

            
          

此方法首先檢查字典中是否存在name鍵，如果存在，則返回相應(yīng)的值。否則，它返回默認值。

雖然清楚地檢查key確實有效，但如果使用.get()，它可以很容易地用一行代替：

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

            
          

get()執(zhí)行與第一種方法相同的操作，但現(xiàn)在它們會自動處理。如果key存在，則返回適當?shù)闹怠７駝t，將返回默認值。

但是，如果你想在仍然訪問name的key時使用默認值更新字典呢？ .get()在這里沒有真正幫助你，所以你只需要再次顯式檢查這個值：

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

            
          

檢查values并設(shè)置默認值是一種有效的方法，并且易于閱讀，但Python再次使用.setdefault()提供了更優(yōu)雅的方法：

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

            
          

.setdefault()完成與上面代碼片段完全相同的操作。它檢查cowboy中是否存在名稱，如果是，則返回該值。否則，它將cowboy [‘name’]設(shè)置為The Man with No Name并返回新值。

>利用Python的標準庫

默認情況下，Python提供了許多功能，這些功能只是一個導(dǎo)入語句。它本身就很強大，但知道如何利用標準庫可以增強你的編碼面試技巧。

從所有可用模塊中挑選最有用的部分很困難，因此本節(jié)將僅關(guān)注其實用功能的一小部分。希望這些對您在編碼訪談中有用，并且您希望了解更多有關(guān)這些和其他模塊的高級功能的信息。

1. 使用collections.defaultdict()處理缺少的字典鍵

當你為單個鍵設(shè)置默認值時，.get()和.setdefault()可以正常工作，但通常需要為所有可能的未設(shè)置鍵設(shè)置默認值，尤其是在面試環(huán)境中進行編程時

假裝你有一群學(xué)生，你需要記錄他們在家庭作業(yè)上的成績。輸入值是具有格式（student_name，grade）的元組列表，但是你希望輕松查找單個學(xué)生的所有成績而無需迭代列表。

存儲成績數(shù)據(jù)的一種方法是使用將學(xué)生姓名映射到成績列表的字典：

            
              >>> 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]}

            
          

在這種方法中，你迭代學(xué)生并檢查他們的名字是否已經(jīng)是字典中的屬性。如果沒有，則將它們添加到字典中，并將空列表作為默認值。然后將實際成績附加到該學(xué)生的成績列表中。

但是有一個更簡潔的方法，可以使用defaultdict，它擴展了標準的dict功能，允許你設(shè)置一個默認值，如果key不存在，它將按默認值操作：

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

            
          

在這種情況下，你將創(chuàng)建一個defaultdict，它使用不帶參數(shù)的list構(gòu)造函數(shù)作為默認方法。沒有參數(shù)的list返回一個空列表，因此如果名稱不存在則defaultdict調(diào)用list()，然后再把學(xué)生成績添加上。如果你想更炫一點，你也可以使用lambda函數(shù)作為值來返回任意常量。

利用defaultdict可以使代碼更簡潔，因為你不必擔(dān)心key的默認值。相反，你可以在defaultdict里處理它們一次，然后key就終存在了。

2. 使用collections.Counter計算Hashable對象

假如你有一長串沒有標點符號或大寫字母的單詞，你想要計算每個單詞出現(xiàn)的次數(shù)。

你可以使用字典或defaultdict增加計數(shù)，但collections.Counter提供了一種更清晰，更方便的方法。 Counter是dict的子類，它使用0作為任何缺失元素的默認值，并且更容易計算對象的出現(xiàn)次數(shù)：

            
              >>> 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時，它會存儲每個單詞以及該單詞在列表中出現(xiàn)的次數(shù)。

如果你好奇兩個最常見的詞是什么？只需使用.most_common（）：

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

            
          

.most-common（）是一個方便的方法，只需按計數(shù)返回n個最頻繁的輸入。

3. 使用字符串常量訪問公共字符串組

現(xiàn)在有一個瑣事需要判斷！‘A’>‘a(chǎn)’是真是假？ 這是假的，因為A的ASCII代碼是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_大寫字母的一部分。如果你打印出string.ascii_大寫，你會發(fā)現(xiàn)它只是一個字符串，該值設(shè)置為文本“ABCDEFGHIJKLMNOPQRSTUVWXYZ”。

所有字符串常量都只是經(jīng)常引用的字符串值的字符串。其中包括以下內(nèi)容：

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

這些更容易使用，更重要的是，更容易閱讀。

4. 使用Itertools生成排列和組合

例子：你去游樂園，決定找出每一對可能坐在過山車上的朋友。

除非生成這些配對是面試問題的主要目的，否則很可能生成所有可能的配對只是朝著工作算法前進的一個乏味的步驟。你可以自己用嵌套for循環(huán)計算它們，也可以使用強大的itertools庫。

itertools有多個工具來生成可重復(fù)輸入數(shù)據(jù)序列，但現(xiàn)在我們只關(guān)注兩個常見函數(shù)：itertools.permutations()和itertools.combinations()。

itertools.permutations()構(gòu)建所有排列的列表，這意味著它是輸入值的每個可能分組的列表，其長度與count參數(shù)匹配。r關(guān)鍵字參數(shù)允許我們指定每個分組中有多少值：

            
              >>> 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()生成組合。這些也是輸入值的可能分組，但現(xiàn)在值的順序無關(guān)緊要。因為(‘sam’、‘devon’)和(‘devon’、‘sam’)代表同一對，所以輸出列表中只會包含它們中的一個：

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

            
          

由于值的順序與組合有關(guān)，因此同一輸入列表的組合比排列少。同樣，因為我們將r設(shè)置為2，所以每個分組中都有兩個名稱。

.combinations和.permutations只是強大庫的一個小例子，但是當你試圖快速解決算法問題時，即使這兩個函數(shù)也非常有用。

關(guān)于原文

鏈接：https://realpython.com/python-coding-interview-tips/點擊跳轉(zhuǎn)?感謝python中文社區(qū)