[Einführung in Python3 Tag 10] Kapitel 5 Py's Cosmetic Box: Module, Pakete, Programme (5.4-5.7)

5.5 Python-Standardbibliothek

• Python verfügt über eine große Standardbibliothek von Modulen, die viel "nützliche Arbeit" leisten.

5.5.1 Umgang mit nicht vorhandenen Schlüsseln mit setdefault () und defaultdict ()

• Eine Ausnahme wird generiert, wenn versucht wird, mit einem nicht vorhandenen Schlüssel auf ein Wörterbuch zuzugreifen. Sie können Ausnahmen vermeiden, indem Sie die Funktion get () des Wörterbuchs verwenden, um den Standardwert zurückzugeben, wenn der Schlüssel nicht vorhanden ist.
• Die Funktion setdefault () ähnelt get (), fügt jedoch dem Wörterbuch weitere Elemente hinzu, wenn es keinen Schlüssel hat.
• Die Funktion defaultdict () unterscheidet sich von get () darin, dass sie Standardwerte für alle nicht vorhandenen Schlüssel festlegt. ** Das Argument ist eine Funktion. ** Wenn Sie einen Schlüssel verwenden, der nicht vorhanden ist, wird dieser Schlüssel automatisch generiert. Standardwert Wenn das Argument weggelassen wird, lautet der Standardwert Keine.

>>> periodic_table={"Hydrogen":1,"Helium":2}
>>> print(periodic_table)
{'Hydrogen': 1, 'Helium': 2}
#Befindet sich der Schlüssel nicht im Wörterbuch, wird er mit dem neuen Wert hinzugefügt.
>>> carbon=periodic_table.setdefault("Carbon",12)
>>> carbon
12
#Wenn Sie versuchen, einem vorhandenen Schlüssel einen anderen Standardwert zuzuweisen, wird der ursprüngliche Wert zurückgegeben und das Wörterbuch nicht geändert.
>>> helium=periodic_table.setdefault("Helium",457)
>>> helium
2
>>> print(periodic_table)
{'Hydrogen': 1, 'Helium': 2, 'Carbon': 12}

#Importieren Sie defaultdict aus Modulsammlungen.
>>> from collections import defaultdict
#Standardwert für nicht vorhandene Schlüssel(int)Ist eingestellt.
>>> periodic_table=defaultdict(int)
>>> periodic_table["Hydrogen"]=1
#Für einen nicht vorhandenen Schlüssel wird ein Standardwert zurückgegeben.
>>> periodic_table["Lead"]
0
>>> periodic_table
defaultdict(<class 'int'>, {'Hydrogen': 1, 'Lead': 0})

#Importieren Sie defaultdict aus Modulsammlungen
>>> from collections import defaultdict
>>> 
>>> def no_idea():
...     return "Huh?"
... 
>>> bestiary = defaultdict(no_idea)
>>> bestiary["a"]= "A"
>>> bestiary["b"]= "B"
>>> bestiary["a"]
'A'
>>> bestiary["b"]
'B'

#Wenn Sie einen Schlüssel eingeben, der nicht vorhanden ist, wird die durch das Argument defaultdict angegebene Funktion aufgerufen und der Wert zurückgegeben.
>>> bestiary["c"]
'Huh?'
>>> bestiary["v"]
'Huh?'

#defaultdict()Definieren Sie die Standarderstellungsfunktion im Aufruf
>>> bestiary=defaultdict(lambda:"Huh?")
>>> bestiary["E"]
'Huh?'

#int kann eine Möglichkeit sein, einen eigenen Zähler zu erstellen.
>>> from collections import defaultdict
>>> food_counter=defaultdict(int)
>>> for food in ["spam","spam","eggs","spam"]:
...     food_counter[food]+=1
... 
>>> for food,count in food_counter.items():
...     print(food,count)
... 
spam 3
eggs 1

5.5.2 Berechnung der Anzahl der Elemente durch Counter ()

>>> breakfast=["spam","spam","eggs","spam"]
>>> breakfast_counter=Counter(breakfast)
>>> breakfast_counter
Counter({'spam': 3, 'eggs': 1})
#most_common()Die Funktion gibt alle Elemente in absteigender Reihenfolge zurück.
>>> breakfast_counter.most_common()
[('spam', 3), ('eggs', 1)]
#most_common()Wenn eine Ganzzahl als Argument angegeben wird, zählt die Funktion von oben und zeigt die Nummer an.
>>> breakfast_counter.most_common(1)
[('spam', 3)]
>>> breakfast_counter
Counter({'spam': 3, 'eggs': 1})

>>> lunch=["eggs","eggs","bacon"]
>>> lunch_counter=Counter(lunch)
>>> lunch_counter
Counter({'eggs': 2, 'bacon': 1})
#Zähler kombinieren
>>> lunch_counter+breakfast_counter
Counter({'eggs': 3, 'spam': 3, 'bacon': 1})
#Gegenunterschied Artikel, die zum Mittagessen, aber nicht zum Frühstück verwendet werden.
>>> lunch_counter-breakfast_counter
Counter({'eggs': 1, 'bacon': 1})
#Gegenunterschied Was wird beim Frühstück verwendet, aber nicht beim Mittagessen.
>>> breakfast_counter-lunch_counter
Counter({'spam': 3})
#Produktsatzoperator Die allgemeine Nummer ist 1.
>>> breakfast_counter & lunch_counter
Counter({'eggs': 1})
#Summensatzoperator: Verwenden Sie den größeren Zählerwert.
>>> breakfast_counter | lunch_counter
Counter({'spam': 3, 'eggs': 2, 'bacon': 1})

5.5.3 Sortierung der Schlüsselreihenfolge nach OrderdDict ()

--OrderedDict () gibt die Schlüssel vom Iterator in derselben Reihenfolge zurück.

>>> quotes={
...     "M":"A",
...     "L":"O",
...     "C":"N",
...     }
>>> for s in quotes:
...     print(s)
... 
M
L
C

>>> from collections import OrderedDict
>>> quotes=OrderedDict([
...     ("M","A"),
...     ("L","C"),
...     ("C","N"),
...     ])
>>> 

5.5.4 Stapel + Warteschlange = Deck

--duque ist eine Warteschlange mit zwei Enden, die sowohl Stapel- als auch Warteschlangenfunktionen hat. Sie können Elemente an beiden Enden der Sequenz hinzufügen oder entfernen.

>>> def palindrome(word):
...     from collections import deque
...     dq=deque(word)
...     while len(dq)>1:
#popleft()Löscht das Element ganz links und gibt pop zurück()Ist eine Funktion, die das Element ganz rechts löscht und zurückgibt.
...         if dq.popleft()!=dq.pop():
...             return False
...     return True
... 
>>> palindrome("a")
True
>>> palindrome(" ")
True
>>> palindrome("racecar")
True
>>> palindrome("halibut")
False

#Es ist einfacher, Zeichenfolgen in umgekehrter Reihenfolge zu vergleichen.
>>> def another_palindrome(word):
...     return word==word[::-1]
... 
>>> another_palindrome("racecar")
True
>>> another_palindrome("halibut")
False

5.5.5 Iterieren der Codestruktur mit itertools

--itertools enthält itertool-Funktionen für spezielle Zwecke.

#chain()Behandelt das gesamte Argument wie ein iterierbares und durchläuft es.
>>> import itertools
>>> for item in itertools.chain([1,2],["a","b"]):
...     print(item)
... 
1
2
a
b

#cycle()Ist ein unendlicher Iterator, der Elemente zyklisch aus seinen Argumenten zurückgibt.
>>> import itertools
>>> for item in itertools.cycle([1,2]):
...     print(item)
... 
1
2
1
2
1
2
1
2
1
2
1
2
1
2

#accumulate()Berechnet den Wert der Elemente in einem. Standardmäßig wird die Summe berechnet.
>>> import itertools
>>> for item in itertools.accumulate([1,2,3,4]):
...     print(item)
... 
1
3
6
10

##accumulate()Akzeptiert eine Funktion als zweites Argument, und dieses Argument wird anstelle der Addition verwendet.
>>> import itertools
>>> def multiply(a,b):
...     return a*b
... 
>>> for item in itertools.accumulate([1,2,3,4],multiply):
...     print(item)
... 
1
2
6
24

5.5.6 Schöne Anzeige von pprint ()

--print () versucht, die Elemente zur besseren Lesbarkeit auszurichten.

>>> from pprint import pprint
>>> q=OrderedDict([
...     ("Moe","A wise guy,huh?"),
...     ("Larry","Ow!"),
...     ("Curly","Nuyk nyuk!"),
...     ])
>>> 
#Weiter anzeigen.
>>> print(q)
OrderedDict([('Moe', 'A wise guy,huh?'), ('Larry', 'Ow!'), ('Curly', 'Nuyk nyuk!')])

#Richten Sie die Elemente aus und zeigen Sie sie an.
>>> pprint(q)
OrderedDict([('Moe', 'A wise guy,huh?'),
             ('Larry', 'Ow!'),
             ('Curly', 'Nuyk nyuk!')])

5.7 Zuordnung überprüfen

5-1 Erstellen Sie eine Datei mit dem Namen zoo.py und zeigen Sie die Zeichenfolge Open 9-5 täglich darin an. Definieren wir die Stunden () -Funktion. Als nächstes importieren wir das Zoomodul mit dem interaktiven Interpreter und rufen dessen Stunden () -Funktion auf.

zop.py

def hours():
    print("Open 9-5 daily")

Ergebnis

>>> import zoo
>>> zoo.hours()
Open 9-5 daily

5-2 Importieren Sie das Zoo-Modul mit der Namensmenagerie in den interaktiven Interpreter und rufen Sie dessen Stunden () -Funktion auf.

#Importieren Sie den Modulzoo als Menagerie
>>> import zoo as menagerie
>>> menagerie.hours()
Open 9-5 daily

5-3 Bleiben wir im interaktiven Interpreter und importieren und rufen direkt die Stunden () -Funktion des Zoos auf.

>>> from zoo import hours
>>> hours()
Open 9-5 daily

5-4 Stunden () Importieren Sie die Funktion mit den Namensinformationen und rufen Sie sie auf.

>>> from zoo import hours as info
>>> info()
Open 9-5 daily

5-5 Erstellen Sie ein Wörterbuch mit dem Namen plain mit den Schlüssel / Wert-Paaren "a": 1, "b": 2, "c": 3 und zeigen Sie den Inhalt an.

>>> plain={"a":1,"b":2,"c":3}
>>> plain
{'a': 1, 'b': 2, 'c': 3}

5-6 Erstellen Sie ein OrderedDict mit dem Namen fantasie aus demselben Paar wie oben 5-5 und zeigen Sie dessen Inhalt an. Wurde es in derselben Reihenfolge wie normal angezeigt?

>>> from collections import OrderedDict
>>> fancy=OrderedDict([("a",1),("b",2),("c",3)])
>>> fancy
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

5-7 Erstellen Sie ein Standard-Diktat mit dem Namen dict_of_lists und übergeben Sie das Listenargument. Erstellen Sie als Nächstes in einer Operation eine Liste mit dem Namen dict_of_lists ["a"] und fügen Sie den Wert "etwas für a" hinzu. Zum Schluss zeigen wir dict_of_lists ["a"] an.

>>> from collections import defaultdict
>>> dict_of_lists=defaultdict(list)
>>> dict_of_lists["a"]=["something for a"]
>>> dict_of_lists["a"]
['something for a']

Impressionen

Endlich haben wir die zweite Spielhälfte erreicht. Ich habe angefangen, Kapitel 6 zu machen, aber das Konzept von Objekten und Klassen kam heraus. Ich werde morgen weiterhin mein Bestes geben.

Verweise

"Einführung in Python3 von Bill Lubanovic (veröffentlicht von O'Reilly Japan)"