Es ist eine Fortsetzung von Tips ① Ich werde es kurz schreiben, daher denke ich, dass es viele Dinge gibt, die nicht streng sind, aber wenn es Fehler gibt, kommentieren Sie bitte ~
Ich habe den Listentyp mehrmals verwendet, damit Sie ihn kennen, aber es ist ein Array ohne angegebene Größe. Da es sich um ein Listenobjekt handelt, ist es in Ordnung, zusätzlich zu a = [] a = list () zu schreiben.
Der Listentyp garantiert die Reihenfolge der Elemente.
python:Python3.5.0
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a.append(0) #Fügen Sie nach Element 0 hinzu
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> a.insert(1,0) #Fügen Sie der angegebenen Indexnummer das Element 0 hinzu
>>> a
[1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> a[0] #Zugriffselement mit Index 0
1
>>> a[2] #Index greift auf das zweite Element zu
2
>>> a[-1] #Index greift von hinten auf das erste Element zu(Es gibt keine 0)
0
>>> a[2:5] #Index greift auf das 2. bis 5. Element zu
[2, 3, 4]
>>> a[2:-2] #Index greift vom ersten zum zweiten Element auf das zweite Element zu
[2, 3, 4, 5, 6, 7, 8]
>>> a[2:-2:2] ##Der Index greift in zwei Schritten vom ersten zum zweiten Element auf das zweite Element zu.
[2, 4, 6, 8]
>>> b = [1.1, 1.2, 1.3, 1.4, 1.5]
>>> a.extend(b) #Listen beitreten
>>> a
[1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1.1, 1.2, 1.3, 1.4, 1.5]
>>> a.pop() #Extrahieren und löschen Sie das letzte Element in der Liste
1.5
>>> a
[1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1.1, 1.2, 1.3, 1.4]
>>> sorted(a) #Sortieren(aufsteigende Reihenfolge)
[0, 0, 1, 1.1, 1.2, 1.3, 1.4, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sorted(a, reverse=True) #Sortieren(absteigende Reihenfolge)
[9, 8, 7, 6, 5, 4, 3, 2, 1.4, 1.3, 1.2, 1.1, 1, 0, 0]
>>> len(a) #Listenlänge
16
Ich bin endlich da ... Dies ist einzigartig für Python! !! Das Beispiel, das früher in der for-Anweisung veröffentlicht wurde
python:Python3.5.0
>>> for i in range(1,10):
... a.append(i)
...
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Dies kann in einer Zeile geschrieben werden.
python:Python3.5.0
>>> a = [i for i in range(1,10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Es mag auf den ersten Blick etwas unangenehm sein, aber es ist sehr praktisch, wenn Sie sich erst einmal daran gewöhnt haben. Übrigens scheint die Ausführungsgeschwindigkeit schneller zu sein als mit einer normalen for-Anweisung.
python:Python3.5.0
>>> a = [i for i in range(1,10) if i % 2 == 0]
>>> a
[2, 4, 6, 8]
>>> a = [i if i % 2 == 0 else i*i for i in range(1,10)]
>>> a
[1, 2, 9, 4, 25, 6, 49, 8, 81]
>>> a = [[j for j in range(i)] for i in range(1,10)]
>>> a
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5, 6], [0, 1, 2, 3, 4, 5, 6, 7], [0, 1, 2, 3, 4, 5, 6, 7, 8]]
>>>
Es kann so viel verschleiert werden, wie Sie möchten, also mäßig ...
Beachten Sie, dass in Python Objekte als Referenz übergeben werden. int / float / str / unicode (2.x-Serie) sieht aus wie das Übergeben von Werten, aber das Übergeben von Referenzen für unveränderliche Objekte (es ist nicht falsch ...). Nun, was Sie beachten sollten, ist, dass der Listentyp als Referenz übergeben wird (dasselbe gilt für den Tappeltyp, den Aggregattyp und den Wörterbuchtyp). Wenn Sie es also als Argument an eine andere Variable oder Funktion übergeben möchten, müssen Sie es explizit kopieren.
python:Python3.5.0
>>> a = [i for i in range(10)]
>>> b = a
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.pop()
9
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> b #b ist auch weg! !!
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> c = list(a) #Dies wird eine Kopie sein(Es werden verschiedene Instanzen generiert)
>>> from copy import copy
>>> d = copy(c) #Kopiermodul kann ebenfalls verwendet werden
>>> a.pop()
8
>>> a
[0, 1, 2, 3, 4, 5, 6, 7]
>>> b
[0, 1, 2, 3, 4, 5, 6, 7]
>>> c
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> d
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>>
Es ist jedoch zu beachten, dass "Liste (a)" und "Kopie (a)" flache Kopien sind. Eine flache Kopie bedeutet, dass tiefe Objekte, wie z. B. solche mit verschachtelten Listen in der Liste, nicht kopiert werden, sondern nur die flachsten Objekte kopiert werden und tiefere Objekte als Referenz übergeben werden (schwer zu erklären). Dies wird mithilfe des Kopiermoduls deepcopy behoben.
python:Python3.5.0
>>> a = [[j for j in range(4)] for i in range(4)]
>>> a
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> from copy import copy
>>> b = copy(a) #Flache Kopie
>>> a[0].pop() #Pop aus der Liste der Elemente
3
>>> a #Geknallte Elemente verschwinden aus der Liste der Elemente
[[0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> b #Das Popup verschwindet aus der Liste der kopierten Listenelemente! !!
[[0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> from copy import deepcopy
>>> c = deepcopy(a) #Tiefe Kopie
>>> a[0].pop()
2
>>> a
[[0, 1], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> b
[[0, 1], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> c #Nicht verschwinden! !!
[[0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> a is b #Die flachsten Objektinstanzen sind unterschiedlich
False
>>> a[0] is b[0] #Objekte, die tiefer als diese gespeichert sind, sind dieselbe Instanz, indem sie als Referenz übergeben werden
True
>>> a[0] is c[0] #deepcopy ↓ Objekte werden ebenfalls als Wert übergeben
False
>>>
Der Tupeltyp wird durch Tupel dargestellt. Der Tapple-Typ ist im Grunde eine Anordnung von Elementen wie eine Liste, aber sobald ein Wert gespeichert ist, kann dieser Wert nicht mehr geändert werden.
python:Python3.5.0
>>> a = tuple() #Leerer Taple
>>> a = (1,2,3,4,5) #1~Taple mit 5 in Ordnung
>>> a[1] #Index greift auf das erste Element zu
2
>>> a[1:3] #Greifen Sie auf die Elemente zu, deren Index vom 1. bis zum 3. reicht
(2, 3)
>>> a[0:5:2] #Greifen Sie in Schritt 2 auf die Elemente mit den Indizes 0 bis 5 zu
(1, 3, 5)
>>> a[0] = 1 #Beim Zuweisen wird eine Fehlermeldung angezeigt
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> a = (1,) #Tapple generieren
>>> a
(1,)
>>> a = (1) #,Ohne es wird es kein Tupel sein
>>> a
1
>>>
Die einzige Einschränkung ist, dass es kein Komma ohne Komma wird.
Der Set-Typ wird durch Set dargestellt. Der kollektive Typ ist eine Sammlung von Elementen wie der Listentyp, aber die Reihenfolge kann nicht garantiert werden, da keine doppelten Elemente zulässig sind.
python:Python3.5.0
>>> a = set() #Leeres Set
>>> a
set([])
>>> a = {i for i in range(10)} #Einschlussnotation
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.add(10) #10 hinzufügen
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> a.add(10) #10 hinzufügen(Es ändert sich nicht, weil es bereits existiert)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> a = set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> a.remove(10) #Löschen 10
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.remove(10) #Löschen 10(Es wird ein Fehler sein, weil es nicht im Element ist)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10
>>> a.add(10)
>>> a.discard(10) #Löschen 10
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.discard(10) #Löschen 10(Wenn nicht, nichts tun)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = {1,2,3,4,5}
>>> b.issubset(a) #Ob b eine Teilmenge von a ist
True
>>> b.issuperset(a) #Ob a eine Teilmenge von b ist
False
>>> c = {2,4,6,8,10,12,14,16,18,20}
>>> a.union(c) #Summensatz von zwei Sätzen
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20])
>>> a.intersection(c) #Produktset aus zwei Sets
set([8, 2, 4, 6])
>>> a.difference(c) #Element von a und nicht Element von c(a-c)einstellen
set([0, 1, 3, 5, 7, 9])
>>> a.symmetric_difference(c) #Exklusive logische Summe zweier Sätze
set([0, 1, 3, 5, 7, 9, 10, 12, 14, 16, 18, 20])
>>> a_copy = a.copy() #Kopie des Sets(Wert übergeben)
>>> a is a_copy #Unterschiedliche Instanzen aufgrund von Wertübergabe
False
>>> a == a_copy #Der Wert ist der gleiche
True
>>> a_copy.update(c) #Fügen Sie dem Zielsatz Elemente anderer Sätze hinzu
>>> a_copy
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20])
>>> a_copy.pop() #Extrahieren und löschen Sie jedes Element
0
>>> a_copy.clear() #Entfernen Sie alle Elemente
>>> a_copy
set([])
>>>
** ~~ @ zakuro9715 wies darauf hin und fügte hinzu und korrigierte Hashing ~~ **
** Das auf Twitter angegebene Hashing wurde behoben. **
Es ist wichtig, dass die Elemente gehasht und sortiert werden, wie dies der Fall ist, wenn Sie das Duplizieren von Elementen als Verwendung des Satzes vermeiden möchten (möglicherweise, um das Duplizieren von Elementen zu vermeiden, möglicherweise). Dies liegt daran, dass die Hash-Tabelle beim Scannen der Elemente verwendet wird, sodass Sie im Durchschnitt mit O (1) * arbeiten können. Andernfalls ist es O (N). Mit anderen Worten, es funktioniert am besten, wenn Sie so etwas wie "a in b" machen. Der Listentyp erfordert N × len (b) -Scans, wenn Sie in N-Schleifen so etwas wie "a in b" ausführen, da die Elemente nicht gehasht sind. Andererseits wird der Aggregattyp (auch der Wörterbuchtypschlüssel) gehasht, sodass ein solcher Scan nicht durchgeführt wird. Wenn daher die Anzahl der Schleifen groß ist und viele Elemente vorhanden sind, wird empfohlen, einen kollektiven Typ zu verwenden und dann die Bedingungen wie "a in b" zu beurteilen.
Der Wörterbuchtyp wird durch dict dargestellt. Im Wörterbuchtyp wird es als Schlüssel / Wert-Paar gespeichert.
** Als Antwort auf den Punkt von @ zakuro9715 habe ich die Schlüsseleinstellungen hinzugefügt und korrigiert ** Die Taste ~~ (oder der Wert) kann für jedes Objekt festgelegt werden. ~~ Der Schlüssel kann gesetzt werden **, wenn es sich um ein Hashobjekt handelt **. (Zum Beispiel können Sie kein Diktat festlegen, das ein Diktat als Schlüssel hat.) Für den Wert kann ein beliebiges Objekt festgelegt werden.
python:Python3.5.0
>>> a = dict() #Generieren Sie einen leeren Wörterbuchtyp
>>> a = {str(i)+u"Th": i*i for i in range(10)}
>>> a
{'Zuerst': 1, '0 ..': 0, '7 ..': 49, '4 ..': 16, '8 ..': 64, '6 ..': 36, '9 ..': 81, 'Fünfte': 25, 'Der Zweite': 4, 'Der dritte': 9}
>>> a["0 .."] #"0 .."Holen Sie sich den Wert des Schlüssels
0
>>> a["Fünfte"] #"Fünfte"Holen Sie sich den Wert des Schlüssels
25
>>> a["10 .."]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: '10 ..'
>>> a.get(u"10 ..") #"10 .."Holen Sie sich den Wert des Schlüssels(Nein, gibt aber None anstelle von error zurück)
>>> a.get(u"10 ..", 100) #"10 .."Holen Sie sich den Wert des Schlüssels. Wenn nicht, wird der im zweiten Argument festgelegte Wert zurückgegeben.
100
>>> a.get(u"9 ..", "100") #"9 .."Holen Sie sich den Wert des Schlüssels. Wenn nicht, wird der im zweiten Argument festgelegte Wert zurückgegeben.
81
>>> a.keys() #Diktieren Sie den Schlüssel_Rückkehr als Objekt namens Schlüssel (Liste in 2 Reihen)
dict_keys(['4 ..', 'Der dritte', 'Fünfte', 'Der Zweite', '8 ..', '0 ..', '9 ..', 'Zuerst', '7 ..', '6 ..'])
>>> a.values() #Diktieren Sie den Wert_Rückgabe als Objekt namens Werte (Liste in 2 Reihen)
dict_values([16, 9, 25, 4, 64, 0, 81, 1, 49, 36])
>>> a.items() #Diktieren Sie den Schlüssel und den Wert Taple_Rückgabe als Objekt mit dem Namen items (Liste in 2 Serien)
dict_items([('4 ..', 16), ('Der dritte', 9), ('Fünfte', 25), ('Der Zweite', 4), ('8 ..', 64), ('0 ..', 0), ('9 ..', 81), ('Zuerst', 1), ('7 ..', 49), ('6 ..', 36)])
>>> "Zuerst" in a #Überprüfen Sie, ob ein Schlüssel vorhanden ist
True
>>> del a["0 .."] #Löschen Sie den Wert des entsprechenden Schlüssels
>>> a.pop(u"Zuerst") #Holen Sie sich den Wert des entsprechenden Schlüssels und löschen Sie ihn
1
>>> a.popitem() #Holen Sie sich einen Artikel und löschen Sie ihn
('4 ..', 16)
>>> a
{'Der dritte': 9, 'Fünfte': 25, 'Der Zweite': 4, '8 ..': 64, '9 ..': 81, '7 ..': 49, '6 ..': 36}
>>> b = a #Als Referenz übergeben
>>> c = a.copy() #Wert übergeben
>>> a is b #Gleiche Instanz
True
>>> a is c #Verschiedene Instanzen
False
>>> a == c #Der Wert ist der gleiche
True
>>> a.clear() #Alles löschen
>>> a
{}
>>> b #Gelöscht, da es sich um dieselbe Instanz handelt
{}
>>> c #Es ändert sich nicht, weil es eine andere Instanz ist
{'9 ..': 81, 'Fünfte': 25, 'Der Zweite': 4, '8 ..': 64, 'Der dritte': 9, '7 ..': 49, '6 ..': 36}
>>>
>>> a = {str(i)+"Th": i*i for i in range(10)} #Wörterbucheinschlussnotation
>>> a_copy = a.copy()
>>> a_copy.update({"0 ..": 10})
>>> a_copy["0 .."]
10
>>>
Es gibt viele nützliche Möglichkeiten zum Zählen und Wiederholen, insbesondere in Listen und Wörterbüchern. Hier sind einige, die Sie mit Ihrem eigenen Urteilsvermögen und Vorurteil verwenden können.
python:Python3.5.0
>>> a = [i for i in range(1,6)]
>>> #Ausgabe mit Indexnummer
>>> for i, num in enumerate(a):
... print "{}Element des zweiten Index:{}".format(i, num)
...
0. Indexelement: 1
Erstes Indexelement: 2
Zweites Indexelement: 3
Drittes Indexelement: 4
Viertes Indexelement: 5
>>> #Es gibt zwei Listen gleichzeitig
>>> b = [str(i)+u"Zweiter Index" for i in range(5)]
>>> for a_num, b_num in zip(a, b):
... print(b_num+u"："+str(a_num))
...
0. Index: 1
1. Index: 2
Zweiter Index: 3
Dritter Index: 4
4. Index: 5
>>> c = [[j**i for j in range(1,5)] for i in range(1,5)]
>>> c
[[1, 2, 3, 4], [1, 4, 9, 16], [1, 8, 27, 64], [1, 16, 81, 256]]
>>> #Kann auch für die Translokation verwendet werden
>>> c_t = [[i, j, k, l] for i, j, k, l in zip(*c)]
>>> c_t
[[1, 1, 1, 1], [2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256]]
>>>
>>> from itertools import product, permutations, combinations, combinations_with_replacement
>>> #Verhalten beim Verschachteln von Anweisungen(Sie können die Verschachtelungstiefe mit Wiederholung angeben)
>>> for pear in product(a, repeat=2):
... print(pear)
...
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(2, 5)
(3, 1)
(3, 2)
(3, 3)
(3, 4)
(3, 5)
(4, 1)
(4, 2)
(4, 3)
(4, 4)
(4, 5)
(5, 1)
(5, 2)
(5, 3)
(5, 4)
(5, 5)
>>> #Bestellung, die keine Abdeckung erlaubt
>>> for pear in permutations(a, 2):
... print(pear)
...
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 1)
(2, 3)
(2, 4)
(2, 5)
(3, 1)
(3, 2)
(3, 4)
(3, 5)
(4, 1)
(4, 2)
(4, 3)
(4, 5)
(5, 1)
(5, 2)
(5, 3)
>>> #Eine Kombination, die keine Abdeckung zulässt
>>> for pear in combinations(a, 2):
... print(pear)
...
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 3)
(2, 4)
(2, 5)
(3, 4)
(3, 5)
(4, 5)
>>> #Kombination, die das Abdecken ermöglicht
>>> for pear in combinations_with_replacement(a, 2):
... print(pear)
...
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 2)
(2, 3)
(2, 4)
(2, 5)
(3, 3)
(3, 4)
(3, 5)
(4, 4)
(4, 5)
(5, 5)
>>>
python:Python3.5.0
>>> from itertools import combinations
>>> from collections import defaultdict, Counter
>>>
>>> #Erstellen eines Wörterbuchs mit verschachtelten Wörterbüchern
>>> a = {}
>>> for key, val in combinations([i for i in range(6)], 2):
... if key not in a:
... a[key] = {}
... a[key][val] = key*val
...
>>> a
{0: {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, 1: {2: 2, 3: 3, 4: 4, 5: 5}, 2: {3: 6, 4: 8, 5: 10}, 3: {4: 12, 5: 15}, 4: {5: 20}}
>>>
>>> a = defaultdict(dict)
>>> for key, val in combinations([i for i in range(6)], 2):
... a[key][val] = key*val
...
>>> a
defaultdict(<type 'dict'>, {0: {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, 1: {2: 2, 3: 3, 4: 4, 5: 5}, 2: {3: 6, 4: 8, 5: 10}, 3: {4: 12, 5: 15}, 4: {5: 20}})
>>>
>>>
>>> #Beim Speichern der Zählung für einen bestimmten Schlüssel im Wörterbuch
>>> a = {}
>>> for key, val in combinations([i for i in range(6)], 2):
... if key in a:
... a[key] += val
... else:
... a[key] = val
...
>>> a
{0: 15, 1: 14, 2: 12, 3: 9, 4: 5}
>>> a = Counter()
>>> for key, val in combinations([i for i in range(6)], 2):
... a[key] += val
>>> a
Counter({0: 15, 1: 14, 2: 12, 3: 9, 4: 5})
>>>
Es gibt andere. Wenn Sie interessiert sind, lesen Sie bitte Referenz.
Dann darüber, wie man eine Funktion schreibt. Als grundlegende Methode zum Schreiben einer Funktion werde ich hier über die Funktionsdefinitionsanweisung / das Schreiben von Argumenten (Standardeinstellung) / den Rückgabewert (Rückgabe, Ausbeute) schreiben.
python:Python3.5.0
>>> #Die grundlegendste Art zu schreiben
>>> def hello():
... print("Hello world!!")
...
>>> hello()
Hello world!!
>>>
>>> #Wie schreibe ich, wenn es ein Argument gibt
>>> def hello_name(name):
... print("Hello {}!!".format(name))
...
>>> hello_name("Guido")
Hello Guido!!
>>>
>>> #So schreiben Sie, wenn das Argument einen Standardwert hat
>>> def hello_name(name="world"):
... print("Hello {}!!".format(name))
...
>>> hello_name()
Hello world!!
>>> hello_name("Guido")
Hello Guido!!
>>>
>>> #Wie schreibe ich, wenn es einen Rückgabewert gibt?
>>> def hello_return(name):
... return "Hello {}!!".format(name)
...
>>> result = hello_return("Guido")
>>> print(result)
Hello Guido!!
>>>
>>> #Rückgabewert(Generatortyp)Wie schreibe ich, wenn es gibt
>>> def hello_yield(name):
... for s in name:
... yield s
...
>>> generater = hello_yield("Hello Guido!!")
>>> generater.next()
'H'
>>> generater.next()
'e'
>>> generater.next()
'l'
>>> generater.next()
'l'
>>> generater.next()
'o'
>>> generater.next()
' '
>>> generater.next()
'G'
>>> generater.next()
'u'
>>> generater.next()
'i'
>>> generater.next()
'd'
>>> generater.next()
'o'
>>> generater.next()
'!'
>>> generater.next()
'!'
>>> generater.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
Als Anfänger mag der Generatorausdruck schwer zu verstehen sein, aber Sie müssen nicht lange überlegen, sondern nur "Denken Sie an den vorherigen Aufrufstatus und geben Sie den nächsten Status mit" next () "zurück. Wenn es keinen nächsten Status gibt, wird eine Ausnahme der StopIteration-Klasse ausgelöst. Es ist daher besser, sie mit try / zu steuern, außer wenn sie tatsächlich verwendet wird.
python:Python3.5.0
>>> generater = hello_yield("Hello Guido!!")
>>> while True:
... try:
... result = generater.next()
... print(result)
... except StopIteration:
... break
...
H
e
l
l
o
G
u
i
d
o
!
!
>>>
Zunächst werde ich die grundlegende Art und Weise, eine Klasse zu schreiben, dort schreiben, da sie sich zwischen 2 Serien und 3 Serien etwas unterscheidet.
python:Python2.7.9
>>> class Hello(object):
... prefix = "Hello "
... def hello(self, name="world"):
... print(self.prefix+name+"!!")
...
>>> HelloInstance = Hello()
>>> HelloInstance.hello()
Hello world!!
>>>
Dies ist ein Schreibstil mit zwei Systemen, der die Basisklasse "Objekt" erbt, bei der es sich um einen neuen Klassenstil handelt. Stellen Sie sicher, dass Sie im ersten Argument der Instanzmethode "Hallo" "self" als reserviertes Wort schreiben. Dies bezieht sich auf sich selbst (Instanz), dies in PHP. Mit anderen Worten, das Schreiben von "Instance.method (val)" wird als "Class.method (self, val)" gelesen. Es gibt auch einen alten Klassenstil, so dass Sie nur "Klasse Hallo:" schreiben können, ohne "Objekt" zu schreiben. Der neue Stil und der alte Stil haben jedoch unterschiedliche Spezifikationen (Vererbungspriorität / Klassenmethode, statische Methode / Eigenschaft), daher wird der neue Klassenstil empfohlen. Dies liegt auch daran, dass wir Verbesserungen vorgenommen haben, ohne die alten Spezifikationen zu brechen. Andererseits wird in der 3. Serie "Klasse Hallo:" der neue Klassenstil in der 2. Serie sein. Die Operation ändert sich nicht, aber ich werde sie vorerst schreiben.
python:Python3.5.0
>>> class Hello:
... prefix = "Hello "
... def hello(self, name="world"):
... print(self.prefix+name+"!!")
...
>>> HelloInstance = Hello()
>>> HelloInstance.hello()
Hello world!!
>>>
Genau genommen handelt es sich nicht um einen Konstruktor, aber Python verfügt über eine Methode namens "init", die beim Erstellen einer Instanz aufgerufen wird. Hier können Sie eine konstruktorähnliche Verarbeitung schreiben.
python:Python3.5.0
>>> class Hello:
... def __init__(self, prefix="Hello "):
... self.prefix = prefix
... def hello(self, name="world"):
... print(self.prefix+name+"!!")
...
>>> HelloInstance = Hello()
>>> HelloInstance.hello()
Hello world!!
>>> HelloInstance.hello("Guido")
Hello Guido!!
>>> HelloInstance = Hello("Hey ")
>>> HelloInstance.hello("Guido")
Hey Guido!!
>>>
Übrigens gibt es eine Methode namens "new", die vor "init" aufgerufen wird.
Es gibt seine eigene Instanz zurück und __init __ wird ausgeführt, wenn seine eigene Instanz zurückgegeben wird.
Sie können __new__ anpassen, um eine andere Instanz als Sie selbst zurückzugeben, aber es gibt keinen Vorteil. .. ..
Nun, es kommt nicht ganz in Frage, und Sie können Metaklassen schreiben, aber ist es für Anfänger? Ich fühle mich so, also werde ich es weglassen.
(Tipps zum Verlassen von Anfängern / Tipps für fortgeschrittene Benutzer werden in einem anderen Artikel geschrieben)
Wenn Sie in Python eine Methode in einer Klasse definieren, handelt es sich um eine Instanzmethode, sofern nicht anders angegeben. Wie bereits erwähnt, ist das erste Argument einer Instanzmethode "self", das auf eine eigene Instanz verweist. Sie können jedoch auch Klassenmethoden und statische Methoden schreiben. Die Unterschiede in der Bedienung sowie das Schreiben von Instanzmethoden, Klassenmethoden und statischen Methoden werden im Folgenden gezeigt. Sie verstehen sie jedoch möglicherweise nur, wenn Sie die Objektorientierung überhaupt verstehen.
python:Python3.5.0
>>> class Hello:
... prefix = "Hello "
... def __init__(self, prefix=None):
... if prefix:
... self.prefix = prefix + " "
... def hello(self, name="world"):
... """
...Instanzmethode: Das erste Argument ist self
... """
... print(self.prefix+name+"!!")
... @classmethod
... def hello_cls(cls, name="world"):
... """
...Klassenmethode: Das erste Argument ist cls
... """
... print(cls.prefix+name+"!!")
... @staticmethod
... def hello_stc(name="world"):
... """
...Statische Methode: Das erste Argument ist kein reserviertes Wort
... """
... print(name+"!!")
... @classmethod
... def set_class_prefix(cls, prefix):
... cls.prefix = prefix + " "
...
>>> HelloInstance1 = Hello("Hey") #Instanzpräfix(self.prefix)Zu Hey
>>> HelloInstance1.hello("Guido!!")
Hey Guido!!!!
>>> HelloInstance1.hello_cls("Guido!!") #Da es sich um eine Klassenmethode handelt, ist das Präfix für den Zugriff das Präfix der Klasse
Hello Guido!!!!
>>>
>>> HelloInstance2 = Hello("Hi") #Instanzpräfix(self.prefix)Zu Hey
>>> HelloInstance2.hello("Guido!!")
Hi Guido!!!!
>>> HelloInstance2.hello_cls("Guido!!")
Hello Guido!!!!
>>>
>>> HelloInstance2.set_class_prefix("I'm") #Schreiben Sie Klassenvariablen aus HelloInstance2 neu
>>> HelloInstance2.hello("Guido!!") #Instanzvariablen werden nicht neu geschrieben
Hi Guido!!!!
>>> HelloInstance2.hello_cls("Guido!!") #Klassenvariablen werden neu geschrieben
I'm Guido!!!!
>>> #Eine andere Instanz
>>> HelloInstance1.hello("Guido!!") #Instanzvariablen werden nicht neu geschrieben
Hey Guido!!!!
>>> HelloInstance1.hello_cls("Guido!!") #Da es sich um eine Klassenvariable handelt, wird sie neu geschrieben! !!
I'm Guido!!!!
>>>
>>> Hello.hello_stc() #Statische Methoden können aus der Klasse aufgerufen werden
world!!
>>>
Der zu beachtende Punkt ist, dass sich beim Umschreiben einer Klassenvariablen aus einer Klassenmethode auch die Klassenvariable einer anderen Instanz ändert (es handelt sich um eine Klassenvariable, nicht um eine Instanzvariable, daher ist dies ganz natürlich).
Es sind __ (zwei Unterstriche) wie __name__, __init__, __new__, __call__, die Sie häufig sehen, wenn Sie Python verwenden, aber es wird für spezielle Methoden verwendet.
Hier sind einige gängige Spezialmethoden:
| Spezielle Methode | Funktion | Anwendungsbeispiel |
|---|---|---|
| __doc__ | Dokumentzeichenfolge | Zeigen Sie die Dokumentation zum Objekt an. Objekt.__doc__ |
| __name__ | Importierter Dateiname oder ausführbare Datei | Beim Ausführen einer Datei. wenn__name__ == '__main__' |
| __dict__ | Enthält die Attribute des Objekts | Abrufen von Objektattributen aus Zeichenfolgen usw. |
| __init__ | Methode, die beim Erstellen einer Instanz aufgerufen wird | X = Class() |
| __new__ | Factory-Klasse beim Erstellen einer neuen Instanz von Russ | Es ist auch möglich, eine Metaklasse zu überschreiben und zu erstellen |
| __call__ | Methode, die aufgerufen wird, wenn die Funktion ausgeführt wird | X() |
| __del__ | Methode, die beim Zerstören eines Objekts aufgerufen wird | del object |
| __add__ | Hinzufügen(+)Die Methode, die bei Verwendung des Operators aufgerufen wird | Kann überschrieben und angepasst werden |
| __iter__ | Methode, die während der Schleife aufgerufen wird | für Schleife. Einschlussnotation |
| __getattr__ | Zugriff auf Attribute | X.attr |
| __setattr__ | Zuordnung zum Attribut | X.attr = x |
In Python ist eine Mehrfachvererbung möglich. Hier ist ein Beispiel für Mehrfachvererbung für alle Fälle.
python:Python3.5.0
>>> class Hello:
... prefix = "Hello "
... def say(self, name):
... return self.prefix + name
...
>>>
>>> class Hey:
... prefix = "Hey "
... def say(self, name):
... return self.prefix + name + "!"
...
>>>
>>> class HowAreYou(Hello, Hey):
... def __init__(self, name, *args, **kargs):
... #Initialisierung der übergeordneten Klasse
... #In diesem Beispiel zur übergeordneten Klasse__init__Ist nicht definiert, also wird nichts getan
... super(HowAreYou, self).__init__(*args, **kargs)
... self.name = name
... def output(self):
... greet = self.say(self.name)
... print(greet, "How are you?")
...
>>>
>>> X = HowAreYou("Guido")
>>> X.output()
('Hello Guido', 'How are you?')
>>>
Wie oben erwähnt, ist es so, als würde man eine Klasse erstellen, indem man zwei oder mehr Klassen erbt. Nun, wenn Sie hier erklären, müssen Sie aus der Objektorientierung erklären. Das überlasse ich anderen Artikeln.
Was hier jedoch beachtet werden sollte, ist die Bewegung, wenn "HowAreYou.output ()" ausgeführt wird. Bei Mehrfachvererbung können Attribute miteinander in Konflikt stehen. Auch in diesem Beispiel sagen die Attribute (absichtlich) Konflikt miteinander. In Python wird entschieden, welche übergeordnete Klasse bei der Mehrfachvererbung priorisiert wird. Grundsätzlich hat ① Vorrang vor ② in der Reihenfolge ① "von links nach rechts" ② "von unten nach oben" (② hat in der alten Stilklasse Vorrang vor ①). In diesem Fall gibt "HowAreYou.output ()" "Hello.say ()" Priorität. Ebenso hat "self.prefix" Vorrang vor "Hello.prefix".
Natürlich denke ich, dass es Attribute gibt, bei denen ich mehrere Vererbungen durchführen möchte, aber ich möchte nicht, dass sie miteinander kollidieren (obwohl ich denke, dass es besser ist, so zu gestalten, dass mehrfache Vererbungen nicht durchgeführt werden). Die zu diesem Zeitpunkt verwendete Funktion ist ** Nameman Gring **. Stellen Sie den beiden Attributnamen insbesondere einen Unterstrich voran. Dann wird es automatisch als "_Class__attr" interpretiert.
python:Python3.5.0
>>> class Hello:
... __prefix = "Hello "
... def __say(self, name):
... return self.__prefix + name
...
>>> class Hey:
... __prefix = "Hey "
... def __say(self, name):
... return self.__prefix + name + "!"
...
>>> class HowAreYou(Hello, Hey):
... def __init__(self, name, *args, **kargs):
... #Initialisierung der übergeordneten Klasse
... #In diesem Beispiel zur übergeordneten Klasse__init__Ist nicht definiert, also wird nichts getan
... super(HowAreYou, self).__init__(*args, **kargs)
... self.name = name
... def hello_output(self):
... greet = self._Hello__say(self.name) #Hallo__Rufen Sie an, sagen Sie
... print(greet, "How are you?")
... def hey_output(self):
... greet = self._Hey__say(self.name) #Hey__Rufen Sie an, sagen Sie
... print(greet, "How are you?")
...
>>> X = HowAreYou("Guido")
>>> X.hello_output() #Verwenden Sie Hallo sagen
('Hello Guido', 'How are you?')
>>> X.hey_output() #Verwenden Sie Hey sagen
('Hey Guido!', 'How are you?')
>>> dir(X) #X Attribute anzeigen
['_Hello__prefix', '_Hello__say', '_Hey__prefix', '_Hey__say', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hello_output', 'hey_output', 'name']
>>>
Wie oben erwähnt, fügen Sie einfach zwei Unterstriche (__) hinzu, und vor dem Attributnamen steht der _Klassenname.
** Ich dachte, ich hätte es geschrieben, aber dies ist möglicherweise nicht das, was Anfänger lernen sollten ʕº̫͡ºʔ **
Im Gegensatz zu Java kann Python Attribute nicht ausblenden. Sie können jedoch so etwas tun, indem Sie einen Unterstrich verwenden. Wie bereits erwähnt, kann die Namensverknüpfung verwendet werden, um zu verhindern, dass gleichnamige Attribute in verschiedenen Klassen miteinander kollidieren. Obwohl dies nicht die ursprüngliche Verwendung ist, können Sie mit dieser Funktion die Attribute ausblenden (wie), die Sie wirklich ausblenden möchten. Außerdem haben "_x" und "__x" leicht unterschiedliche Bedeutungen (können richtig verwendet werden), daher werde ich sie erklären.
python:Python3.5.0
>>> class Hello:
... def __init__(self):
... self._prefix = "Hello" #1 Unterstrich
... self.__prefix = "Hey" #2 Unterstriche
...
>>> HelloInstance = Hello()
>>> HelloInstance._prefix #Unterstrich Auf ein Attribut kann zugegriffen werden
'Hello'
>>> HelloInstance.__prefix #Unterstrich Auf die beiden Attribute kann nicht so zugegriffen werden, wie sie sind
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Hello' object has no attribute '__prefix'
>>> HelloInstance._Hello__prefix #Kann unter dem Namen Mangling zugegriffen werden
'Hey'
>>>
Wenn nur ein Unterstrich vorhanden ist, kann darauf zugegriffen werden. Es handelt sich also nur um ein Präfix, um eine lokale Variable als Codierungsstandard anzugeben. Bei zwei Unterstrichen weist die Namensverknüpfung jedoch automatisch einen "Klassennamen" zu, sodass Sie nicht mit demselben Namen darauf zugreifen können. Es kann auf diese Weise nicht vollständig verborgen werden, aber es kann auf pseudo-Weise verborgen werden.
Ich habe es kurz geschrieben, aber ich bin müde, also fahre ich mit ③ fort
Klicken Sie hier für Tipps ① Klicken Sie hier für Tipps ③
Recommended Posts