5 Tipps und 2 Missverständnisse zur Verwendung von Python-Containern

5 Tipps und 2 Missverständnisse zur Verwendung von Python-Containern

Das Wort „Container“ wird in technischen Python-Artikeln selten erwähnt. Wenn Leute „Container“ sehen, denken sie meistens an den kleinen Blauwal: Docker, aber dieser Artikel hat nichts damit zu tun. Der Container in diesem Artikel ist ein abstraktes Konzept in Python und ein allgemeiner Begriff für Datentypen, die speziell zur Aufnahme anderer Objekte verwendet werden.

In Python gibt es die vier häufigsten integrierten Containertypen: Liste, Tupel, Wörterbuch und Menge. Durch den Einsatz einzeln oder in Kombination können viele Dinge effizient erledigt werden.

Die internen Implementierungsdetails der Python-Sprache selbst stehen ebenfalls in engem Zusammenhang mit diesen Containertypen. Beispielsweise werden die Klasseninstanzattribute von Python, die globalen Variablen globals () usw. alle über Wörterbuchtypen gespeichert.

In diesem Artikel beginne ich zunächst mit der Definition von Containertypen und versuche, einige Best Practices für die tägliche Codierung zusammenzufassen. Später werde ich einige Programmiertipps zu den speziellen Funktionen geben, die jeder Containertyp bietet.

Wovon reden wir, wenn wir über Container sprechen?

Ich habe vorhin eine einfache Definition von „Behälter“ gegeben: Ein Behälter wird speziell zur Aufnahme anderer Objekte verwendet. Diese Definition ist jedoch zu weit gefasst und kann keinen Orientierungswert für unsere tägliche Programmierung bieten. Um Container in Python wirklich zu beherrschen, müssen Sie auf zwei Ebenen beginnen:

·Zugrunde liegende Implementierung: Welche Datenstrukturen werden von den integrierten Containertypen verwendet? Wie läuft eine bestimmte Operation ab?

·Abstraktion auf hoher Ebene: Was bestimmt, ob ein Objekt ein Container ist? Welche Verhaltensweisen definieren einen Container?

Lassen Sie uns nun auf diesen beiden unterschiedlichen Ebenen stehen und Container neu verstehen.

Betrachten Sie Container auf der untersten Ebene

Python ist eine Programmiersprache auf hoher Ebene, und die integrierten Containertypen, die sie bereitstellt, sind das Ergebnis eines hohen Grades der Kapselung und Abstraktion. Im Vergleich zu Namen wie „verknüpfte Liste“, „Rot-Schwarz-Baum“ und „Hash-Tabelle“ beschreiben die Namen aller in Python integrierten Typen nur die funktionalen Eigenschaften dieses Typs. Andere können sie nicht einmal durch diese Namen verstehen ein kleines bisschen internes Detail.

Dies ist einer der Vorteile der Programmiersprache Python. Im Vergleich zu Programmiersprachen wie C, die näher am zugrunde liegenden Computer liegen, hat Python einen integrierten Containertyp neu gestaltet und implementiert, der für Programmierer benutzerfreundlicher ist und ihn vor zusätzlicher Arbeit wie der Speicherverwaltung schützt. Bietet uns eine bessere Entwicklungserfahrung.

Aber wenn das der Vorteil der Python-Sprache ist, warum machen wir uns dann die Mühe, die Implementierungsdetails von Containertypen zu verstehen? Die Antwort lautet: Wenn wir auf Details achten, können wir schneller Code schreiben.

Schnelleren Code schreiben

1. Vermeiden Sie häufiges Erweitern von Listen/Erstellen neuer Listen

Alle integrierten Container Kein Typ schränkt die Kapazität ein. Wenn Sie möchten, können Sie so lange steigende Zahlen in eine leere Liste stopfen, bis der gesamte Speicher der Maschine gefüllt ist.

In den Implementierungsdetails der Python-Sprache wird der Speicher der Liste bei Bedarf zugewiesen [Hinweis 1]. Wenn der Speicher, der derzeit einer bestimmten Liste gehört, nicht ausreicht, wird die Speichererweiterungslogik ausgelöst. Und das Zuweisen von Speicher ist ein kostspieliger Vorgang. In den meisten Fällen hat dies jedoch keine ernsthaften Auswirkungen auf die Leistung Ihres Programms. Wenn die Datenmenge, die Sie verarbeiten, jedoch besonders groß ist, kann es aufgrund der Speicherzuweisung leicht zu Leistungseinbußen im gesamten Programm kommen.

Glücklicherweise ist sich Python dieses Problems schon lange bewusst und hat offizielle Problemlösungsrichtlinien bereitgestellt: „Werde faul“.

Wie erklärt man „faul werden“? Die Entwicklung der Funktion range() ist ein sehr gutes Beispiel.

Wenn Sie in Python 2 range(100000000) aufrufen, müssen Sie mehrere Sekunden warten, um das Ergebnis zu erhalten, da eine riesige Liste zurückgegeben werden muss und viel Zeit in die Speicherzuweisung und -berechnung investiert wird. Aber in Python 3 liefert derselbe Aufruf sofort das Ergebnis. Da die Funktion keine Liste mehr, sondern ein Lazy-Objekt vom Typ „Range“ zurückgibt, wird sie Ihnen die reelle Zahl nur dann zurückgeben, wenn Sie darüber iterieren oder sie aufteilen.

Um die Leistung zu verbessern, wird der eingebaute Funktionsumfang „faul“ gemacht. Um eine zu häufige Speicherzuweisung zu vermeiden, müssen unsere Funktionen beim täglichen Codieren auch faul sein, was Folgendes umfasst:

·Verwenden Sie mehr Ertragsschlüsselwörter und Rückgabegeneratoren Objekt

·Versuchen Sie, Generatorausdrücke anstelle von Listenverständnisausdrücken zu verwenden

 ·Generatorausdruck: (iforinrange(100))

 · Listenverständnisausdruck: [iforinrange(100)]

·Versuchen Sie, vom Modul bereitgestellte Lazy-Objekte zu verwenden:

·Verwenden re.finditer statt re.findall

·Iterierbare Dateiobjekte direkt verwenden: forlineinfp statt forlineinfp.readlines()

2 in Szenarien, in denen viele Vorgänge an der Spitze der Liste stehen

Die Liste wird basierend auf der Array-Struktur (Array) implementiert. Wenn Sie ein neues Mitglied am Anfang der Liste einfügen (list.insert(0,item)), müssen alle anderen Mitglieder dahinter verschoben werden die Operationszeit Die Komplexität ist O(n). Dies führt dazu, dass das Einfügen von Mitgliedern am Anfang der Liste viel langsamer ist als das Anhängen am Ende (die Zeitkomplexität von list.append(item) beträgt O(1)).

Wenn Ihr Code diese Vorgänge viele Male ausführen muss, sollten Sie die Verwendung des Typs „collections.deque“ anstelle einer Liste in Betracht ziehen. Da Deque auf der Grundlage einer doppelendigen Warteschlange implementiert wird, beträgt die Zeitkomplexität O(1), unabhängig davon, ob Elemente am Kopf oder am Ende angehängt werden.

3. Verwenden Sie ein Set/Wörterbuch, um festzustellen, ob ein Mitglied vorhanden ist.

Wenn Sie feststellen müssen, ob ein Mitglied in einem Container vorhanden ist, ist die Verwendung besser geeignet eine Menge als eine Liste. Weil die Zeitkomplexität der Operation itemin[...] O(n) ist, während die Zeitkomplexität von itemin{...} O(1) ist. Dies liegt daran, dass sowohl Wörterbücher als auch Mengen basierend auf der Datenstruktur der Hash-Tabelle implementiert werden.

# 这个例子不是特别恰当，因为当目标集合特别小时，使用集合还是列表对效率的影响微乎其微
# 但这不是重点 :)
VALID_NAMES = ["piglei", "raymond", "bojack", "caroline"]
# 转换为集合类型专门用于成员判断
VALID_NAMES_SET = set(VALID_NAMES)
def validate_name(name):
    if name not in VALID_NAMES_SET:
        # 此处使用了 Python 3.6 添加的 f-strings 特性
        raise ValueError(f"{name} is not a valid name!")

Hinweis: Es wird dringend empfohlen, TimeComplexity – Python Wiki zu lesen, um mehr über die Zeitkomplexität gängiger Containertypen zu erfahren.

Wenn Sie sich für die Implementierungsdetails von Wörterbüchern interessieren, wird auch dringend empfohlen, sich Raymond Hettingers Rede Modern Dictionaries (YouTube) anzusehen

Verwandte Empfehlungen: „Python-Einführungs-Tutorial"

High-Level-Ansicht von Containern

Python ist eine Sprache vom Typ „Ente“: „Wenn Sie einen Vogel sehen, der wie eine Ente geht, schwimmt wie eine Ente und Quacksalber Wie eine Ente kann dieser Vogel als Ente bezeichnet werden. „Wenn wir also sagen, welcher Typ ein Objekt ist, meinen wir eigentlich: Dieses Objekt erfüllt die spezifische Schnittstellenspezifikation des Typs und kann als solche betrachtet werden.“ eine Ente. Verwenden Sie diesen Typ. Das Gleiche gilt für alle eingebauten Containertypen.

Öffnen Sie das Untermodul abc (Abkürzung für „Abstrakte Basisklassen“), das sich unter dem Sammlungsmodul befindet. Dort finden Sie alle Container-bezogenen Schnittstellendefinitionen (abstrakte Klassen) [Anmerkung 2]. Werfen wir einen Blick auf die Schnittstellen, die die integrierten Containertypen erfüllen:

·Liste: erfüllen Iterable, Sequence, MutableSequence und andere Schnittstellen

·Tupel: Erfüllt Iterable, Sequence

·Dictionary (dict): Erfüllt Iterable, Mapping, MutableMapping [Anmerkung 3]

·Set: Erfüllt Iterable, Set, MutableSet [Anmerkung 4]

Jeder integrierte Containertyp ist tatsächlich eine zusammengesetzte Entität, die mehrere Schnittstellendefinitionen erfüllt. Beispielsweise erfüllen alle Containertypen die Schnittstelle „Iterable“, was bedeutet, dass sie alle „Iterable“ sind. Aber umgekehrt sind nicht alle „iterierbaren“ Objekte Container. Obwohl eine Zeichenfolge iteriert werden kann, behandeln wir sie normalerweise nicht als „Container“.

Nachdem wir diese Tatsache verstanden haben, werden wir eines der wichtigsten Prinzipien der objektorientierten Programmierung in Python neu verstehen: die Programmierung für Schnittstellen und nicht für spezifische Implementierungen.

Lassen Sie uns anhand eines Beispiels sehen, wie man „schnittstellenorientierte Programmierung“ in Python versteht.

Schreiben Sie Code mit besserer Skalierbarkeit

Eines Tages erhielten wir eine Anfrage: Es gibt eine Liste mit vielen Benutzerkommentaren, um sie richtig auf der Seite anzuzeigen. Alle Kommentare, die eine bestimmte Länge überschreiten, müssen durch Auslassungspunkte ersetzt werden.

Diese Anforderung ist leicht zu erfüllen, und wir haben schnell die erste Version des Codes geschrieben:

# 注：为了加强示例代码的说明性，本文中的部分代码片段使用了Python 3.5
# 版本添加的 Type Hinting 特性
 
def add_ellipsis(comments: typing.List[str], max_length: int = 12):
    """如果评论列表里的内容超过 max_length，剩下的字符用省略号代替
    """
    index = 0
    for comment in comments:
        comment = comment.strip()
        if len(comment) > max_length:
            comments[index] = comment[:max_length] + '...'
        index += 1
    return comments
comments = [
    "Implementation note",
    "Changed",
    "ABC for generator",
]
print("\n".join(add_ellipsis(comments)))
# OUTPUT:
# Implementati...
# Changed
# ABC for gene...

Im obigen Code empfängt die Funktion add_ellipsis eine Liste als Parameter und iteriert dann es, Ersetzen Sie die Mitglieder, die geändert werden müssen. Das erscheint alles vernünftig, denn die ursprünglichste Anforderung, die wir erhielten, war: „Es gibt eine Liste, in der …“. Was aber, wenn die Kommentare, die wir erhalten, eines Tages nicht mehr in einer Liste, sondern in einem unveränderlichen Tupel gespeichert werden?

In diesem Fall zwingt uns das bestehende Funktionsdesign dazu, add_ellipsis(list(comments)) zu schreiben, was langsamer und hässlicher Code ist.

Programmierung für Containerschnittstellen

Wir müssen Funktionen verbessern, um dieses Problem zu vermeiden. Da die Funktion add_ellipsis stark vom Listentyp abhängt, ist die aktuelle Funktion nicht mehr anwendbar, wenn sich der Parametertyp in ein Tupel ändert (Grund: Beim Zuweisen eines Werts zu comments[index] wird eine TypeError-Ausnahme ausgelöst). Wie kann dieser Teil des Designs verbessert werden? Das Geheimnis besteht darin, dass die Funktion auf dem abstrakten Konzept eines „iterierbaren Objekts“ und nicht auf dem Entitätslistentyp basiert.

Mithilfe der Generatorfunktion kann die Funktion wie folgt geändert werden:

def add_ellipsis_gen(comments: typing.Iterable[str], max_length: int = 12):
    """如果可迭代评论里的内容超过 max_length，剩下的字符用省略号代替
    """
    for comment in comments:
        comment = comment.strip()
        if len(comment) > max_length:
            yield comment[:max_length] + '...'
        else:
            yield comment
print("\n".join(add_ellipsis_gen(comments)))

In der neuen Funktion haben wir den abhängigen Parametertyp von einer Liste in eine iterierbare abstrakte Klasse geändert. Dies hat viele Vorteile. Einer der offensichtlichsten ist: Unabhängig davon, ob der Kommentar aus einer Liste, einem Tupel oder einer Datei stammt, kann die neue Funktion problemlos Folgendes erfüllen:

# 处理放在元组里的评论
comments = ("Implementation note", "Changed", "ABC for generator")
print("\n".join(add_ellipsis_gen(comments)))
# 处理放在文件里的评论
with open("comments") as fp:
    for comment in add_ellipsis_gen(fp):
        print(comment)

Ändern Sie die Abhängigkeit von einem bestimmten Container Der Typ wird zu einer abstrakten Schnittstelle und die Anwendbarkeit von Funktionen wird breiter. Darüber hinaus bietet die neue Funktion weitere Vorteile hinsichtlich der Ausführungseffizienz. Kehren wir nun zur vorherigen Frage zurück. Was macht aus allgemeiner Sicht einen Container aus?

答案是：各个容器类型实现的接口协议定义了容器。不同的容器类型在我们的眼里，应该是 是否可以迭代、 是否可以修改、 有没有长度 等各种特性的组合。我们需要在编写相关代码时，更多的关注容器的抽象属性，而非容器类型本身，这样可以帮助我们写出更优雅、扩展性更好的代码。

Hint：在 itertools 内置模块里可以找到更多关于处理可迭代对象的宝藏。

常用技巧

1. 使用元组改善分支代码

有时，我们的代码里会出现超过三个分支的 if/else 。就像下面这样：

import time
 
def from_now(ts):
    """接收一个过去的时间戳，返回距离当前时间的相对时间文字描述
    """
    now = time.time()
    seconds_delta = int(now - ts)
    if seconds_delta < 1:
        return "less than 1 second ago"
    elif seconds_delta < 60:
        return "{} seconds ago".format(seconds_delta)
    elif seconds_delta < 3600:
        return "{} minutes ago".format(seconds_delta // 60)
    elif seconds_delta < 3600 * 24:
        return "{} hours ago".format(seconds_delta // 3600)
    else:
        return "{} days ago".format(seconds_delta // (3600 * 24))
now = time.time()
print(from_now(now))
print(from_now(now - 24))
print(from_now(now - 600))
print(from_now(now - 7500))
print(from_now(now - 87500))
# OUTPUT:
# less than 1 second ago
# 24 seconds ago
# 10 minutes ago
# 2 hours ago
# 1 days ago

上面这个函数挑不出太多毛病，很多很多人都会写出类似的代码。但是，如果你仔细观察它，可以在分支代码部分找到一些明显的“边界”。比如，当函数判断某个时间是否应该用“秒数”展示时，用到了 60。而判断是否应该用分钟时，用到了 3600。

从边界提炼规律是优化这段代码的关键。如果我们将所有的这些边界放在一个有序元组中，然后配合二分查找模块 bisect。整个函数的控制流就能被大大简化：

import bisect
# BREAKPOINTS 必须是已经排好序的，不然无法进行二分查找
BREAKPOINTS = (1, 60, 3600, 3600 * 24)
TMPLS = (
    # unit, template
    (1, "less than 1 second ago"),
    (1, "{units} seconds ago"),
    (60, "{units} minutes ago"),
    (3600, "{units} hours ago"),
    (3600 * 24, "{units} days ago"),
)
def from_now(ts):
    """接收一个过去的时间戳，返回距离当前时间的相对时间文字描述
    """
    seconds_delta = int(time.time() - ts)
    unit, tmpl = TMPLS[bisect.bisect(BREAKPOINTS, seconds_delta)]
    return tmpl.format(units=seconds_delta // unit)

除了用元组可以优化过多的 if/else 分支外，有些情况下字典也能被用来做同样的事情。关键在于从现有代码找到重复的逻辑与规律，并多多尝试。

2. 在更多地方使用动态解包

动态解包操作是指使用 * 或 ** 运算符将可迭代对象“解开”的行为，在 Python 2 时代，这个操作只能被用在函数参数部分，并且对出现顺序和数量都有非常严格的要求，使用场景非常单一。

def calc(a, b, multiplier=1):
    return (a + b) * multiplier
# Python2 中只支持在函数参数部分进行动态解包
print calc(*[1, 2], **{"multiplier": 10})
# OUTPUT: 30

不过，Python 3 尤其是 3.5 版本后， * 和 ** 的使用场景被大大扩充了。举个例子，在 Python 2 中，如果我们需要合并两个字典，需要这么做：

def merge_dict(d1, d2):
    # 因为字典是可被修改的对象，为了避免修改原对象，此处需要复制一个 d1 的浅拷贝
    result = d1.copy()
    result.update(d2)
    return result
user = merge_dict({"name": "piglei"}, {"movies": ["Fight Club"]})

但是在 Python 3.5 以后的版本，你可以直接用 ** 运算符来快速完成字典的合并操作：

user = {**{"name": "piglei"}, **{"movies": ["Fight Club"]}}

除此之外，你还可以在普通赋值语句中使用 * 运算符来动态的解包可迭代对象。如果你想详细了解相关内容，可以阅读下面推荐的 PEP。

Hint：推进动态解包场景扩充的两个 PEP：

    ·PEP 3132 -- Extended Iterable Unpacking | Python.org

    ·PEP 448 -- Additional Unpacking Generalizations | Python.org

3. 最好不用“获取许可”，也无需“要求原谅”

这个小标题可能会稍微让人有点懵，让我来简短的解释一下：“获取许可”与“要求原谅”是两种不同的编程风格。如果用一个经典的需求：“计算列表内各个元素出现的次数” 来作为例子，两种不同风格的代码会是这样：

# AF: Ask for Forgiveness
# 要做就做，如果抛出异常了，再处理异常
def counter_af(l):
    result = {}
    for key in l:
        try:
            result[key] += 1
        except KeyError:
            result[key] = 1
    return result
# AP: Ask for Permission
# 做之前，先问问能不能做，可以做再做
def counter_ap(l):
    result = {}
    for key in l:
        if key in result:
            result[key] += 1
        else:
            result[key] = 1
    return result

整个 Python 社区对第一种 Ask for Forgiveness 的异常捕获式编程风格有着明显的偏爱。这其中有很多原因，首先，在 Python 中抛出异常是一个很轻量的操作。其次，第一种做法在性能上也要优于第二种，因为它不用在每次循环的时候都做一次额外的成员检查。

不过，示例里的两段代码在现实世界中都非常少见。为什么？因为如果你想统计次数的话，直接用 collections.defaultdict 就可以了：

from collections import defaultdict
 
def counter_by_collections(l):
    result = defaultdict(int)
    for key in l:
        result[key] += 1
    return result

这样的代码既不用“获取许可”，也无需“请求原谅”。整个代码的控制流变得更清晰自然了。所以，如果可能的话，请尽量想办法省略掉那些非核心的异常捕获逻辑。一些小提示：

·操作字典成员时：使用 collections.defaultdict 类型

    ·或者使用 dict[key]=dict.setdefault(key,0)+1 内建函数

·如果移除字典成员，不关心是否存在：

    ·调用 pop 函数时设置默认值，比如 dict.pop(key,None)

·在字典获取成员时指定默认值： dict.get(key,default_value)

·对列表进行不存在的切片访问不会抛出 IndexError 异常： ["foo"][100:200]

4. 使用 next() 函数

next() 是一个非常实用的内建函数，它接收一个迭代器作为参数，然后返回该迭代器的下一个元素。使用它配合生成器表达式，可以高效的实现“从列表中查找第一个满足条件的成员”之类的需求。

numbers = [3, 7, 8, 2, 21]
# 获取并 **立即返回** 列表里的第一个偶数
print(next(i for i in numbers if i % 2 == 0))
# OUTPUT: 8

5. 使用有序字典来去重

字典和集合的结构特点保证了它们的成员不会重复，所以它们经常被用来去重。但是，使用它们俩去重后的结果会丢失原有列表的顺序。这是由底层数据结构“哈希表（Hash Table）”的特点决定的。

>>> l = [10, 2, 3, 21, 10, 3]
# 去重但是丢失了顺序
>>> set(l)
{3, 10, 2, 21}

如果既需要去重又必须保留顺序怎么办？我们可以使用 collections.OrderedDict 模块：

Hint: 在 Python 3.6 中，默认的字典类型修改了实现方式，已经变成有序的了。并且在 Python 3.7 中，该功能已经从 语言的实现细节 变成了为 可依赖的正式语言特性。

但是我觉得让整个 Python 社区习惯这一点还需要一些时间，毕竟目前“字典是无序的”还是被印在无数本 Python 书上。所以，我仍然建议在一切需要有序字典的地方使用 OrderedDict。

常见误区

1. 当心那些已经枯竭的迭代器

在文章前面，我们提到了使用“懒惰”生成器的种种好处。但是，所有事物都有它的两面性。生成器的最大的缺点之一就是：它会枯竭。当你完整遍历过它们后，之后的重复遍历就不能拿到任何新内容了。

numbers = [1, 2, 3]
numbers = (i * 2 for i in numbers)
# 第一次循环会输出 2, 4, 6
for number in numbers:
    print(number)
# 这次循环什么都不会输出，因为迭代器已经枯竭了
for number in numbers:
    print(number)

而且不光是生成器表达式，Python 3 里的 map、filter 内建函数也都有一样的特点。忽视这个特点很容易导致代码中出现一些难以察觉的 Bug。

Instagram 就在项目从 Python 2 到 Python 3 的迁移过程中碰到了这个问题。它们在 PyCon 2017 上分享了对付这个问题的故事。访问文章 Instagram 在 PyCon 2017 的演讲摘要，搜索“迭代器”可以查看详细内容。

2. 别在循环体内修改被迭代对象

这是一个很多 Python 初学者会犯的错误。比如，我们需要一个函数来删掉列表里的所有偶数：

def remove_even(numbers):
   """去掉列表里所有的偶数
   """
    for i, number in enumerate(numbers):
        if number % 2 == 0:
            # 有问题的代码
            del numbers[i]
numbers = [1, 2, 7, 4, 8, 11]
remove_even(numbers)
print(numbers)
# OUTPUT: [1, 7, 8, 11]

注意到结果里那个多出来的“8”了吗？当你在遍历一个列表的同时修改它，就会出现这样的事情。因为被迭代的对象numbers在循环过程中被修改了。遍历的下标在不断增长，而列表本身的长度同时又在不断缩减。这样就会导致列表里的一些成员其实根本就没有被遍历到。

所以对于这类操作，请使用一个新的空列表保存结果，或者利用 yield 返回一个生成器。而不是修改被迭代的列表或是字典对象本身。

Das obige ist der detaillierte Inhalt von5 Tipps und 2 Missverständnisse zur Verwendung von Python-Containern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!