Dies ist ein Versuch, die 3. Ausgabe des Python-Tutorials zu lesen und zu notieren, was Sie gelernt haben.
Und wenn ich mit dem Lesen fertig bin, möchte ich diese Prüfung ablegen Am Ende hat der Test begonnen ...!
** Lass uns anfangen! ** ** **
Grundlegende Prüfung zur Zertifizierung von Python 3 Engineer
Ich hoffe es geht weiter, ich hoffe es geht weiter
list.append(x)
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.append(333)
>>> a
[66.25, 333, 333, 1, 1234.5, 333]
list.extend(L)
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> b = [1, 2, 3]
>>> a.extend(b)
>>> a
[66.25, 333, 333, 1, 1234.5, 1, 2, 3]
list.insert(i, x)
a.insert (0, x) fügt es am Anfang der Liste ein
--a.insert (len (a), x) entsprichta.append (x)>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.insert(2, -1)
>>> a
[66.25, 333, -1, 333, 1, 1234.5]
list.remove(x)
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.remove(333)
>>> a
[66.25, 333, 1, 1234.5]
list.pop([i])
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.pop()
1234.5
>>> a
[66.25, 333, 333, 1]
>>> a.pop(2)
333
>>> a
[66.25, 333, 1]
list.clear() --Entfernen Sie alle Elemente aus der Liste
del a [:]>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.clear()
>>> a
[]
list.index(x)
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.index(1)
3
list.count(x)
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
list.sort(key=None, reverse=False)
>>> a = [333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
>>> a.sort(reverse=True)
>>> a
[1234.5, 333, 333, 66.25, 1, -1]
list.reverse() --Reverse Listenelemente vorhanden
>>> a = [333, 1234.5, 1, 333, -1, 66.25]
>>> a.reverse()
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
list.copy()
>>> a = [333, 1234.5, 1, 333, -1, 66.25]
>>> a.copy()
[333, 1234.5, 1, 333, -1, 66.25]
append (), um Elemente oben im Stapel zu laden
--Verwenden Sie nicht indiziertes pop (), um Elemente vom oberen Rand des Stapels abzurufen>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack
[3, 4, 5]
>>> stack.pop()
5
>>> stack
[3, 4]
append und pop am Ende der Liste sind schnell, aber insert und pop am Anfang der Liste sind langsam collection.deque, um Warteschlangen zu implementieren **
--deque wurde entwickelt, um das Hinzufügen und Knallen von Elementen am Anfang und am Ende zu beschleunigen>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")
>>> queue.append("Graham")
>>> queue.popleft()
'Eric'
>>> queue.popleft()
'John'
>>> queue
deque(['Michael', 'Terry', 'Graham'])
Ein Programm, das eine Liste von Quadraten generiert
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Ein Programm, das eine Liste von Quadraten generiert (bei Verwendung des Lamdba-Ausdrucks)
>>> squares = list(map(lambda x: x**2, range(10)))
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Ein Programm, das eine Liste von Quadraten generiert (bei Verwendung der Listeneinbeziehung)
>>> squares = [x**2 for x in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Ein Listeneinschluss besteht aus einem Ausdruck, gefolgt von einer "for" -Klausel, gefolgt von null oder mehr for "-Klauseln oder" if "-Klauseln, die alle in Klammern ([]) eingeschlossen sind.
Sie erhalten eine neue Liste von Werten, die den ersten Ausdruck im Kontext der nachfolgenden Klauseln "for" und "if" auswerten.
Bei der folgenden Listeneinbeziehung werden beispielsweise Elemente aus zwei Listen verwendet und zu einem Taple zusammengefasst, wenn sie nicht identisch sind.
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x !=y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Dies entspricht dem folgenden Programm
>>> combs = []
>>> for x in [1,2,4]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (4, 3), (4, 1)]
Beachten Sie, dass sowohl für als auch if-Anweisungen im folgenden Programm in derselben Reihenfolge vorliegen. Kreisklammern sind erforderlich, wenn der Ausdruck tapul ist
>>> #Generieren Sie eine neue Liste mit doppelten Werten
>>> vec = [-4, -2, 0, 2, 4]
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> #Filtern, um negative Zahlen zu entfernen
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> #Funktion auf alle Elemente anwenden
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> #Rufen Sie für jedes Element eine Methode auf
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> #Binärer Taple(Numerischer Wert,Quadratischer Preis)Generieren Sie eine Liste von
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> #Ein Fehler tritt auf, wenn der Taple nicht in Klammern steht.
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> #Glätten Sie die Liste (eine Dimension) mit zwei für
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Listeneinschlüsse können zusammengesetzte Ausdrücke und verschachtelte Funktionen enthalten
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
Eine 3x4-Matrix mit 3 Listen der Länge 4
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
Vertauschen Sie Zeilen und Spalten
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Das obige Programm entspricht
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Das heißt, äquivalent zu
>>> transposed = []
>>> for i in range(4):
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Verwenden Sie realistisch gesehen integrierte Funktionen für komplexe Abläufe In diesen Situationen kann die Funktion "zip" verwendet werden
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
pop () Methode gibt sie keinen Wert zurück>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
del kann auch verwendet werden, um eine ganze Variable zu löschen
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
--Taple besteht aus durch Kommas getrennten Werten
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> #Taples können verschachtelt werden
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> #Taple kann nicht geändert werden
>>> t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Kann variable Objekte speichern
>>> v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
Die Ausgabe-Taples sind immer in Klammern eingeschlossen, sodass auch verschachtelte Taples korrekt interpretiert werden. Es ist nicht möglich, einem Element in einem Tupel zuzuweisen, aber es ist möglich, ein Tupel zu generieren, das veränderbare Objekte wie Listen enthält.
Taples sehen aus wie Listen, werden jedoch in unterschiedlichen Situationen verwendet und haben unterschiedliche Verwendungszwecke. Taples sind ** unveränderlich **, und es ist üblich, eine Folge von unterschiedlichen Elementen zu erstellen und auf jedes entpackende Element oder über einen Index (oder sogar ein Attribut im Fall eines Namensmonats-Taples) zuzugreifen.
Listen sind ** veränderbar **, bestehen normalerweise aus ähnlichen Elementen und können durch Durchlaufen der Liste aufgerufen werden.
Es gibt ein besonderes Problem beim Erstellen eines Tapples mit 0 oder 1 Elementen (es ist nicht von anderen Typen zu unterscheiden, da kein Trennzeichen-Komma vorhanden ist), sodass die Syntax einen Ausweg hat, um diese zu behandeln. Zunächst wird ein leerer Zapfen hergestellt, indem zwei Klammern geleert werden. Und ein Element wird durch Hinzufügen eines Kommas nach einem Wert erstellt
>>> empty = ()
>>> singleton = 'hello',
>>> len(empty)
0
>>> singleton
('hello',)
Der folgende Satz ist ein Beispiel für die Verpackung von Tapples (Taple-Packung) 12345, 54321, hallo! Sind in einem Taple
>>> t = 12345, 54321, 'hello!'
>>> t
(12345, 54321, 'hello!')
Die folgende Verarbeitung wird als ** Sequenzentpacken ** bezeichnet, und jede Sequenz kann universell erfolgen. Zum Entpacken einer Sequenz benötigen Sie auf der linken Seite eine Liste von Variablen, die der Länge der Sequenz entspricht. Beachten Sie, dass die Mehrfachzuweisung nur eine Kombination aus Tapple-Packing und Sequence-Unpacking ist.
>>> t = 12345, 54321, 'hello!'
>>> x, y, z = t
>>> x
12345
>>> y
54321
>>> z
'hello!'
set () verwenden, um das Set zu generieren (das gesamte Unternehmen generiert ein leeres Wörterbuch).>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)
{'orange', 'pear', 'banana', 'apple'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
Demonstrieren Sie festgelegte Operationen, indem Sie zwei Wörtern nicht überlappende (eindeutige) Zeichen entnehmen
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> #Einzigartiger Charakter von a
>>> a
{'b', 'r', 'a', 'd', 'c'}
>>> #Zeichen, die in a, aber nicht in b existieren
>>> a - b
{'r', 'b', 'd'}
>>> #Zeichen in a oder b
>>> a | b
{'l', 'm', 'b', 'z', 'r', 'a', 'd', 'c'}
>>> #Zeichen, die sowohl in a als auch in b existieren
>>> a & b
{'a', 'c'}
>>> #Gelegentliche Zeichen in a oder b
>>> a ^ b
{'m', 'b', 'z', 'r', 'd', 'l'}
Festgelegte Einschlüsse, die Listeneinschlüssen ähneln, werden ebenfalls unterstützt
>>> a = { x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
list (d.keys ()) gibt eine unsortierte Liste aller Schlüssel in diesem Wörterbuch zurück (wenn Sie sortieren möchten, stattdessensortiert (d.keys ()) Zu>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel.keys())
['jack', 'guido', 'irv']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
Der Konstrukt dict erstellt ein Wörterbuch aus einer Folge von Tapples von" key: value "-Paaren.
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
Wörterbücher können aus beliebigen Ausdrücken generiert werden, die mithilfe von Wörterbucheinschlüssen Schlüssel und Werte angeben
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
Wenn der Schlüssel eine einfache Zeichenfolge ist, ist es möglicherweise einfacher, das Paar mit dem Schlüsselwortargument anzugeben.
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}
Wenn Sie ein Wörterbuch durchlaufen, können Sie die Methode "items ()" verwenden, um gleichzeitig den Schlüssel und seinen entsprechenden Wert abzurufen.
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
Wenn Sie eine Sequenz schleifen, können Sie die Funktion enumerate () verwenden, um gleichzeitig den Positionsindex und den entsprechenden Wert abzurufen.
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
Wenn Sie zwei Sequenzen gleichzeitig durchlaufen möchten, können Sie die Einträge beider Unternehmen mit der Funktion zip () koppeln.
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
Um die Sequenz in umgekehrter Reihenfolge zu wiederholen, geben Sie zuerst die Sequenz in Vorwärtsreihenfolge an und rufen Sie dann die Funktion reverse () auf.
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
Verwenden Sie die Funktion sortiert (), um die Sequenz in sortierter Reihenfolge zu durchlaufen
Diese Funktion berührt die ursprüngliche Sequenz nicht und gibt eine neu sortierte Liste zurück
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
Wenn Sie eine Liste in einer Schleife ändern möchten, ist es einfacher und sicherer, eine neue Liste zu erstellen
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not math.isnan(value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]
a <b == c Vergleiche verketten, um festzustellen, ob a kleiner als b und b gleich c ist.und und oder werden häufig als ** Kurzschlussoperatoren ** bezeichnet. Vergleichs- und andere boolesche Ergebnisse können Variablen zugewiesen werden
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
Recommended Posts