Konzentration auf "Python Tutorial 3rd Edition", [Python Tutorial] im Web (https://docs.python.org/ja/3.5) Ich habe mir auch /tutorial/index.html angesehen und es tatsächlich ausgeführt. Ich habe lange gebraucht, um diese Notiz zu machen. Die Ausführungsumgebung besteht hauptsächlich aus Befehlen in CentOS7. Schließlich habe ich es mit Jupyer Notebook versucht, aber es war für mich persönlich einfacher.
Python ist eine Interpretersprache
(In der Shell) Starten Sie den Python3.5-Interpreter * 3,5 Punkte variieren je nach Umgebung \ >>> quit () Beendet den Interpreter
python -c Befehl [Argument] ...
Zugriff durch Ausführen von "import sys" sys.argv
Primäre Eingabeaufforderung (>>>) Sekundäre Eingabeaufforderung (...)
Standardmäßig wird Python-Quellcode als UTF-8-codiert behandelt.
| Kann nicht geändert werden | Kann gewechselt werden | Wiederholbar | Reihenfolge | Kartierung | Daten | |
|---|---|---|---|---|---|---|
| bool | ◎ | True,False | ||||
| int | ◎ | ganze Zahl | ||||
| float | ◎ | Gleitkommazahl | ||||
| complex | ◎ | Komplexe Zahl | ||||
| str | ◎ | ◎ | ◎ | String | ||
| list | ◎ | ◎ | ◎ | |||
| tuple | ◎ | ◎ | ◎ | |||
| range | ◎ | ◎ | ◎ | |||
| dict | ◎ | ◎ | ◎ | |||
| set | ◎ | ◎ | ||||
| bytes | ◎ | ◎ | ◎ | binär | ||
| bytearray | ◎ | ◎ | ◎ | |||
| file object | ◎ | ◎ |
Der Operator + - * /% () ist das Bild anderer Sprachen
Operator.
>>> 17 / 3; #Teilung(In Python2"//"Gleiches Ergebnis wie
>>> 17 // 3; # ***Division abrunden***
>>> 5 *** 2; #5 im Quadrat
>>> 0%3 #0/Rest von 3 → 0
3*3.72/1.5
Im interaktiven Modus lautet der zuletzt angezeigte Ausdruck "_」(unterstreichen)Ist zugeordnet.
>>> price = 100.5
>>> tax = 10.5
>>> price * tax
>>> price + _ #Im interaktiven Modus ist der zuletzt angezeigte Ausdruck die Variable "_Ersatz in
>>> _ = 10000 #Eine Substitution ist möglich, sollte jedoch als schreibgeschützt behandelt werden
Fehler bei Verwendung ohne Zuordnung zur Variablen
>>> 'doesn\'t' #Flucht
>>> "doesn't" #In doppelte Anführungszeichen setzen
>>> s = 'First\nSecond'
>>> print(s)
>>> print(r'C:\some\name') #rohe Schnur
Andere(Nicht aufgeführt).
>>> a = 'Py'
>>> b = 'thon'
>>> c = 'Jython'
>>> a = b = c #Mehrfachzuweisung
>>> a #Die letzte Variable gilt für alles
'Jython'
>>> b
'Jython'
>>> c
'Jython'
Dreifache Anführungszeichen (doppelte Anführungszeichen oder einfache Anführungszeichen) können Zeilenumbrüche unverändert behandeln.
>>> '''aaa #Beispiel
... bbb
... ccc
... '''
'aaa\nbbb\nccc\n'
>>> print("""\ #Mehrere Zeilen 1
... Usage: ls
... -r
... -h
... """)
>>> print('''\ #Mehrere Zeilen 2
... Usage: ls
... -r
... -h
... ''')
Die Zeichenkettenkombination verwendet grundsätzlich +. (Leerzeichen sind möglich, aber andere Fehler als Variablen und Zeichenfolgen)
String-Verkettung.
>>> word = 'python'
>>> word2 = 'ium'
>>> 3 * 'un' + 'ium' #Wiederholung
'unununium'
>>> 'Py' + 'thon' #Der Charakter ist +,Jeder Raum kann kombiniert werden
'Python'
>>> 'Py' 'thon'
'Python'
>>> word 'ium' #Variablen und Zeichen können nicht mit Leerzeichen kombiniert werden
File "<stdin>", line 1
word 'ium'
^
SyntaxError: invalid syntax
>>> word word2 #In Leerzeichen können Variablen nicht kombiniert werden
File "<stdin>", line 1
word word2
^
SyntaxError: invalid syntax
>>> word + word2 #Verwenden Sie +, um Variablen und Variablen und Zeichen zu kombinieren
'pythonium'
Manipulation variabler Zeichenfolgen(Indexspezifikation).
>>> word = 'python'
>>> word[2] #***0 ist das erste Zeichen***
't'
>>> word[-2] #***-1 ist das letzte Zeichen***
'o'
Schneiden Schneiden > String [Startindex: Endindex: Anzahl der Schritte]
Index ist zwischen Buchstaben(between)Das linke Ende des ersten Zeichens ist 0.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Manipulation variabler Zeichenfolgen(Schneiden(Ausgeschnitten)Bezeichnung).
>>> word = 'python'
>>> word[0:2] #Beinhaltet das erste Zeichen, aber nicht das letzte Zeichen
'py'
>>> word[2:5] #Beinhaltet das erste Zeichen, aber nicht das letzte Zeichen
'tho'
>>> word[:2] #Start:0 wenn weggelassen
'py'
>>> word[-2:] #Ende:Wenn nicht angegeben, die Größe der Zeichenfolge(Bis zum letzten Zeichen)
'on'
>>> word[:-2] #Start:0 wenn weggelassen
'pyth'
>>> word[0:10:2] #Geben Sie die Anzahl der Schritte an. * Obwohl im Buch nicht erwähnt, werden Fragen in der Scheinprüfung gestellt
'pto'
>>> word[:2] + word[2:] #Entspricht einer Zeichenfolge
'python'
Manipulation variabler Zeichenfolgen(Bezeichnung außerhalb des Bereichs).
>>> word[42] #Die Indexspezifikation lautet NG
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> word[4:42] #Die Schnittspezifikation ist in Ordnung
'on'
Manipulation variabler Zeichenfolgen(String ändern).
>>> word[0] = 'J' #Python-Zeichenfolge kann nicht geändert werden = unveränderlicher Körper(immutable)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> 'J' + word[1:] #Müssen einen neuen String generieren
'Jython'
Manipulation variabler Zeichenfolgen(String-Länge).
>>> word = 'dive\ninto\ncode\t'
>>> print(len(word))
15 #Steuerzeichen werden als ein Zeichen gezählt
>>> d = 'xxxxDIVExxxxDIVExxxxDIVE'
>>> print(d.replace('DIVE', 'CODE', 1))
xxxxCODExxxxDIVExxxxDIVE #Ersetzen Sie nur den ersten Wert
>>> d
'xxxxDIVExxxxDIVExxxxDIVE' #Keine Änderung an der ursprünglichen Zeichenfolge
aufführen.
>>> squares = [1,4,9,16,25]
>>> squares
[1, 4, 9, 16, 25]
>>> squares[0]
1
>>> squares[2]
9
>>> squares[-1]
25
>>> squares[-3:]
[9, 16, 25]
>>> squares[:]
[1, 4, 9, 16, 25]
>>> squares[::]
[1, 4, 9, 16, 25]
>>> squares[:::]
File "<stdin>", line 1
squares[:::]
^
SyntaxError: invalid syntax
Listenverkettung.
>>> squares + [ 100, 1001 ]
[1, 4, 9, 16, 25, 100, 1001]
>>> squares2 = [ 8001, 8002 ]
>>> squares + squares2
[1, 4, 9, 16, 25, 8001, 8002] #Listenwerte ändern sich nicht
Liste kann geändert werden(mutable).
>>> squares[1] = 40000
>>> squares
[1, 40000, 9, 16, 25]
>>> squares.append(216) # append()Methode
>>> squares.append(7**3)
>>> squares
[1, 40000, 9, 16, 25, 216, 343] #Am Ende der Liste hinzufügen
>>> letters = ['a','b','c','d','e','f','g'] #Ein Ersatz für das Schneiden ist ebenfalls möglich
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C','D','E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> letters[:] = []
>>> letters
[]
for i in range(s): print(i)
Die Argumente für Bereich (10) Nr. 1 und 3 können weggelassen werden, wenn Schritt für Schritt von 0 range (5, 10) # 3. Argument kann Schritt für Schritt weggelassen werden Bereich (0, 10, 3) # 0 bis 10 in 3 Schritten
>>> print(range(10)) # (Hinweis)Die Seriennummer des Wertes wird nicht angezeigt
range(0, 10)
·nichts tun. Es wird verwendet, wenn ein syntaktischer Fehler auftritt.
Bei der kleinsten Klasse.
>>> class MyEmptyClass:
... pass
Wenn Sie beim Schreiben von neuem Code keinen bestimmten Code in die Funktion oder die bedingte Anweisung schreiben.
>>> def initlog(*args):
... pass
4.7.1 Standardargumentwert Das bequemste Format ist die Angabe eines Standardwerts für ein oder mehrere Argumente.
def ask_default (a, b, c = 100): # 100 wird auf c gesetzt, wenn das 3. Argument weggelassen wird
Sammeln Sie die an die Funktion übergebenen Argumente in nachfolgenden Funktionsaufrufen.
>>> def f(a, L=[]):
... L.append(a)
... return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]
4.7.2. Schlüsselwortargumente Die Funktion kann auch in Form von "Schlüsselwort = Wert" vorliegen. Beim Aufrufen einer Funktion muss das Positionsargument an erster Stelle und das Schlüsselwortargument an erster Stelle stehen.
>>> def fugafuga(title,content = 'default_content', number = 4):
... print(title, end=' ')
... print(content, end=' ')
... print(number)
...
...
>>> fugafuga(title = 'title_default', content = 'None', number = 5)
title_default None 5
>>> fugafuga(title = 'title_default', number = 5) #Schlüsselwortargumente können weggelassen werden (Argumente in der Mitte können weggelassen werden)
title_default default_content 5
>>> fugafuga(1000) #Positionsargumente sind ebenfalls möglich (Argumente in der Mitte können nicht weggelassen werden)
1000 default_content 4
4.7.3 Optionale Argumentliste Die am wenigsten verwendete Option besteht darin, anzugeben, dass die Funktion mit einer beliebigen Anzahl von Argumenten aufgerufen werden kann.
>>> def write_multiple_items(file, separator, *args):
... file.write(separator.join(args))
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'
>>> def dive_into_code(teacher, *mentor):
... print(teacher)
... print(mentor)
...
>>> dive_into_code('Noro', 'Nakao', 'Miyaoka')
Noro #1. Argument Ort
('Nakao', 'Miyaoka') #Nach dem zweiten Argument
4.7.4. Auspacken der Argumentliste
4.7.5 Lambda-Typ
4.7.6. Auspacken der Argumentliste Dokumentationszeichenfolge
Python hat PEP 8 als Styleguide, dem die meisten Projekte folgen.
Die folgenden Punkte
Listenmethode append(x) extend(L) insert(i,x) remove(x) pop ([i]) Entfernt das Element an der angegebenen Position in der Liste aus der Liste und gibt dieses Element zurück. Wenn nicht angegeben, wird das Element am Ende der Liste als Ziel ausgewählt. Entspricht clear () del a [:] index(x) countx(x) list.sort(key=None,reverse=False) list.reverse() list.copy () Gibt eine flache Kopie der Liste zurück. Entspricht einem [:]. list.count (x) Anzahl der x in der Liste
>>> key = ['001','002','003','002','005','006','003','009']
>>> print(key.count('001'),key.count('002'),key.count('003'))
1 2 2
>>> key.reverse()
>>> key
['009', '003', '006', '005', '002', '003', '002', '001']
>>> key.sort()
>>> key
['001', '002', '002', '003', '003', '005', '006', '009']
>>> key.append('010')
>>> key
['001', '002', '002', '003', '003', '005', '006', '009', '010']
>>> key.insert(2,'020')
>>> key
['001', '002', '020', '002', '003', '003', '005', '006', '009', '010']
>>> key.extend(key)
>>> key
['001', '002', '020', '002', '003', '003', '005', '006', '009', '010', '001', '002', '020', '002', '003', '003', '005', '006', '009', '010']:
Listentypmethode(Pop und anhängen)Kann die Liste als Stapel verwenden.
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack.pop()
6
>>> stack
[3, 4, 5]
Es ist möglich, eine Liste als Warteschlange zu verwenden, aber die Listenmethode ist nicht effizient. Es ist schneller, am Ende der Liste hinzuzufügen oder zu platzieren. Das Einfügen und Einfügen an den Anfang der Liste ist langsam. (Weil es notwendig ist, andere Elemente einzeln zu verschieben). Verwenden Sie collection.deque.
>>> 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'])
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> squares = list(map(lambda x: x**2, range(10))) #Das gleiche wie oben
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> squares = [x**2 for x in range(10)] #Das gleiche wie oben:Listeneinschluss
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [(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)]
>>> #Entspricht dem oben genannten
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y)) #Wenn der Ausdruck ein Taple ist, muss der Tapple eine kreisförmige Klammer haben:Brauchen
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> [[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]]
>>> vec = [-4, -2, 0, 2, 4]
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [(x, x**2) for x in range(6)] #Generieren Sie eine Liste der binären Taples
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> [x, x**2 for x in range(6)] #Fehler, wenn Taple nicht in Klammern steht
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> vec = [[1,2,3], [4,5,6], [7,8,9]] #Glatte Liste (eine Dimension): Verwenden Sie zwei für
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
Vertauschen Sie Zeilen und Spalten in der Matrix.
>>> matrix = [ # matrix = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],]
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)] #Einschlussnotation
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
#Gleichwertig
>>> 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]]
#Entspricht dem Folgenden
>>> 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]]
In der Praxis ist es besser, die integrierte Funktion zip () zu verwenden, als komplizierte Flussausdrücke zu verwenden. zip () -Funktion: Eine Funktion, die Elemente mehrerer iterierbarer Objekte (Listen, Taples usw.) kombiniert.
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
Referenz: Zusätzliche Bestätigung.
>>> [row[i] for row in matrix3] #
[4, 8, 12]
>>> [i for row in matrix3] #
[3, 3, 3]
>>> matrix3
[[1, 2, 3, 4, 99], [5, 6, 7, 8, 91], [9, 10, 11, 12, 92, 93]]
>>> [[row[i] for row in matrix3] for i in range(5)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12], [99, 91, 92]]
>>> [[row[i] for row in matrix3] for i in range(6)]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 1, in <listcomp>
File "<stdin>", line 1, in <listcomp>
IndexError: list index out of range
für a, b, c in zip (A, B, C) # Iterieren Sie mehrere Sequenzen
Referenz: zip().
>>> names = ['Alice', 'Bob', 'Charlie']
>>> ages = [24, 50, 18]
>>> for name, age in zip(names, ages):
... print(name, age)
...
Alice 24
Bob 50
Charlie 18
>>> 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[:] #Löschen Sie alle Werte
>>> a
[]
>>> del a #Löschen Sie die gesamte Variable
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
-Sequenzdatentyp: - Liste, Tupel, Bereich usw. ・ Tupel Sie müssen es nicht in Klammern setzen, wenn Sie einen Taple schreiben Möglicherweise benötigen Sie Klammern (wenn der Tapple Teil eines größeren Ausdrucks war) Sie können die Elemente des Taple nicht ersetzen. Unveränderlich. Das Tupel kann veränderbare Typen wie Listen enthalten. Auf Elemente wird häufig durch Entpacken von Operationen oder Indizes (oder Attributen im Fall von Namedtuples) zugegriffen.
Taple.
>>> t = 12345, 54332, 'hello!'
>>> t
(12345, 54332, 'hello!')
>>> t[0]
12345
>>> u = t, (1, 2, 3, 4, 5)
>>> u #Taples können verschachtelt werden
((12345, 54332, 'hello!'), (1, 2, 3, 4, 5))
>>> t[0] = 88888 #Taple kann nicht geändert werden
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Packen / Auspacken.
>>> t = 12345, 54321, 'hello!' #Taple Pack(tuple packing)
>>> x, y, z = t #Sequenz auspacken(sequence unpacking)
>>> x
12345
>>> y
54321
>>> z
'hello!'
Taple-Methode.
>>> key0 = ('001','002','003','002','005','006','003','009')
>>> key0.count('002')
2
>>> key0.append('099') #Eine Änderungsmethode ist nicht möglich
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
Eine Sammlung ungeordneter Elemente ohne überlappende Elemente
Die grundlegende Verwendung besteht darin, die Existenz zu bestimmen und doppelte Einträge zu beseitigen Unterstützt mathematische Operationen wie Summe (Vereinigung), Produkt (Schnittmenge), Differenz (Differenz) und symmetrische Differenz (symmetrische Differenz)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)
{'banana', 'apple', 'orange', 'pear'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'c', 'd', 'a', 'b', 'r'} # 'abracadabra'Doppelte Elemente entfernt von'abrcd'
(Referenz 2.7)set(['a', 'r', 'b', 'c', 'd'])
>>> a - b #Differenz gesetzt(Gleiches gilt für die Differenzmethode)
{'d', 'r', 'b'}
>>> a | b #Summensatz(Gleiches gilt für die Gewerkschaftsmethode)
{'c', 'z', 'm', 'l', 'd', 'a', 'b', 'r'}
>>> a & b #Produktset(Gleiches gilt für die Schnittmethode): Zeichen, die in a und b wieder existieren
{'c', 'a'}
>>> a ^ b #Exklusiver logischer Summensatz(symmetric_Gleiches gilt für die Differenzmethode): Gelegentliche Zeichen in a oder b
{'d', 'z', 'm', 'r', 'b', 'l'}
Unterstützt die Einbeziehung von Sets.
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
(Außer Reichweite) Element hinzufügen, um myset.add (x) festzulegen Löschen Sie Elemente aus set myset.remove (x) Erstellen Sie einen Set-Typ aus einem Listentyp
>>> mylist = [2, 1, 3, 1]
>>> myset = set(mylist)
>>> print(myset)
{1, 2, 3}
Ein ungeordneter Satz von Schlüsseln (eindeutig) und Werten
Schlüsselwert Es kann nur ein unveränderlicher Typ eingegeben werden Ein Taple kann ein Schlüssel sein, wenn er nur Zeichenfolgen, Zahlen oder andere Taples enthält. Sie können nicht auflisten. )
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape'] #Löschen(Fehler, falls nicht vorhanden)
>>> tel
{'jack': 4098, 'guido': 4127} # 'sape'Wurde gelöscht
>>> tel['irv'] = 4127 # 'irv'Hinzufügen
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127} # 'irv'Position: 3er Serie(3.6.8)Ergebnis in.
(Referenz) {'jack': 4098, 'irv': 4127, 'guido': 4127} # 'irv'Position: Buch,Klicken Sie hier für das Web. 2 System(2.7.5)Wenn Sie dies tun, wird das Ergebnis hier angezeigt. * Sie müssen sich keine Sorgen machen, da keine Bestellung vorliegt.
>>> tel['irv'] = 9999 #Wert bearbeiten
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 9999}
>>> list(tel.keys())
['jack', 'guido', 'irv']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel #Existenzprüfung
True
>>> 'jack' not in tel
False
dict()Der Konstruktor generiert ein Wörterbuch aus einer Liste, die ein Tupel von Schlüssel / Wert-Paaren enthält.
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098} #3er Serie(3.6.8)Ausführungsergebnis in
(Referenz){'sape': 4139, 'jack': 4098, 'guido': 4127} #2 System(2.7.5)Ausführungsergebnis in
Wenn der Schlüssel eine einfache Zeichenfolge ist, definieren Sie ihn mithilfe von Schlüsselwortargumenten und generieren Sie ein Wörterbuch.
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098} #3er Serie(3.6.8)Ausführungsergebnis in
(Referenz){'sape': 4139, 'jack': 4098, 'guido': 4127} #2 System(2.7.5)Ausführungsergebnis in
Generieren Sie ein Wörterbuch aus einem beliebigen Schlüssel / Wert-Paar mithilfe von Wörterbucheinschlussausdrücken.
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>>dic = {'Noro': 1, 'Nakao': 2, 'Miyaoka': 3}
>>>dic['Miyaoka'] += 1
>>>print(dic)
{'Noro': 1, 'Nakao': 2, 'Miyaoka': 4} #1 Zusatz! !!
Wörterbuchmethode update() copy() items() values() del clear()
Beim Durchlaufen eines Wörterbuchs werden Elemente angezeigt()Mit dieser Methode können Sie den Schlüssel und seinen entsprechenden Wert gleichzeitig abrufen..
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
Aufzählung beim Durchlaufen einer Sequenz()Mit Funktionen können Elementindizes und Elemente gleichzeitig abgerufen werden.
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
(0, 'tic') #Elementindex, Wert
(1, 'tac')
(2, 'toe')
Funktion zip, um zwei oder mehr Sequenztypen gleichzeitig zu schleifen()Verwenden Sie diese Option, um jedes Element zu kombinieren.
>>> 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.
Geben Sie den Bereich der Sequenz in Vorwärtsrichtung an, und kehren Sie dann die Funktion um()Anruf.>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
Schleife die Sequenz in sortierter Reihenfolge: sortiert()Verwenden Sie eine Funktion. (Gibt ein neues sortiertes Array zurück, ohne das ursprüngliche Array zu ändern.).
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
In einigen Fällen ist es einfacher und sicherer, eine neue Liste zu erstellen, als die Liste zu ändern.
>>> 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]
Für die in den while- und if-Anweisungen verwendete Bedingung gibt es andere Operatoren sowie Wertevergleiche.
-Operatoren ist und ist nicht: Ob die beiden Objekte tatsächlich dasselbe Objekt sind. Nur für veränderbare Objekte wie Listen von Bedeutung. * Ist jedoch ein unveränderliches Singleton-Objekt wie None Es kann zum Vergleich mit (nur im Internet beschrieben) verwendet werden. - Alle Vergleichsoperatoren haben dieselbe Priorität und beide haben eine niedrigere Priorität als numerische Operatoren. - Vergleichskette: a <b == c Sie können Vergleichsoperationen mit den Test-Booleschen Operatoren kombinieren und und oder, um festzustellen, ob a kleiner als b ist und b und c gleich sind. Ablehnung ist nicht. Es hat eine niedrigere Priorität als andere Vergleichsoperatoren. -Die Booleschen Operatoren und und oder werden oft als Kurzschlussoperatoren bezeichnet. : Operatorargumente werden in der Reihenfolge von links nach rechts ausgewertet, und die Auswertung wird gestoppt, wenn das Ergebnis bestätigt wird.
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
-Sequenzobjekte können mit Objekten mit demselben Sequenztyp verglichen werden. -Im Modul kann der Modulname (der Zeichenfolge) mit der globalen Variablen name abgerufen werden. (Vergleichsmethode) ★★ ・ Vergleiche in lexikalischer Reihenfolge -Wenn die Vergleichsergebnisse aller Elemente der beiden Sequenzen gleich sind, werden die Sequenzen als gleich angesehen. -Wenn eine Sequenz eine Teilsequenz ist, die dem Anfang der anderen entspricht, wird die kürzere Sequenz als die kleinere Sequenz angesehen.
>>> (1, 2, 3) < (1, 2, 4)
True
>>> [1, 2, 3] < [1, 2, 4]
True
>>> (1, 2, 3, 4) < (1, 2, 4)
True
>>> (1, 2) < (1, 2, -1)
True
>>> 'ABC' < 'C' < 'Pascal' < 'Python' #Wörterbuchreihenfolge
True
>>> (1, 2, 3) == (1.0, 2.0, 3.0) #0 und 0.0 ist äquivalent
True
>>> (1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
True
(Memo) Zeichenvergleich: Ich habe ein wenig recherchiert, weil der Standard in der Reihenfolge des Wörterbuchs unbekannt war, aber ich habe ihn nicht sofort verstanden, also habe ich nur die Bewegung untersucht. Zumindest scheint es in der Reihenfolge des Asscii-Codes zu sein.
>>> 'C' < 'c' # 'C':0x43、'c'：0x63
True
>>> 'c' < 'C'
False
>>> 'c' < 'c'
False
>>> 'C' < 'C'
False
>>> '(' < ')' # '(':0x28、')'：0x29
True
>>> ')' < '('
False
TypeError zum Vergleichen von Zeichenfolgen und Zahlen, Listen und Taples.
>>> 'ab' < 3 #Zeichenfolgen und Zahlen.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> (1,3,5) < [1,3,6] #Liste und Taple.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'tuple' and 'list'
>>> import fibo
>>> fibo.fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Ein Modul ist eine Datei, die Python-Definitionen und -Anweisungen enthält. Der Dateiname lautet "Modulname + .py" ・ Wenn Sie die Funktion häufig verwenden möchten, können Sie sie einer lokalen Variablen zuweisen.
>>> import fibo
>>> fib = fibo.fib #Kann einer lokalen Variablen zugewiesen werden(Moduldefinition weggelassen)
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
***
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Es gibt auch eine Variante, die alle im Modul definierten Namen importiert.
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Verwendung der Funktion importlib.reload () (imp.reload () von 3.4 bis 3.3) Aus Effizienzgründen wird jedes Modul nur einmal pro Sitzung des Interpreters importiert. Laden Sie neu, wenn Sie das Modul reparieren und sofort testen möchten.
-Wenn das Skript mit "python fibo.py
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
Reihenfolge beim Importieren eines Moduls namens Spam
Zwischenspeichern Sie jedes kompilierte Modul als "module.version.pyc" -Datei im Verzeichnis "pycache", um das Laden des Moduls zu beschleunigen
# ll -R
drwxr-xr-x 2 root root 33 1. Januar 08:31 __pycache__
-rw-r--r--1 Wurzel Wurzel 376 1. Januar 08:48 fibo.py
./__pycache__:
-rw-r--r--1 Wurzel Wurzel 503 1. Januar 08:31 fibo.cpython-36.pyc
· Python vergleicht das Datum und die Uhrzeit der Quelländerung mit der kompilierten Version und überprüft automatisch, ob die kompilierte Version veraltet ist und neu kompiliert werden muss. -Kompilierte Module sind plattformunabhängig, sodass dieselbe Bibliothek von Systemen mit unterschiedlichen Architekturen gemeinsam genutzt werden kann. ・ Zwei Fälle, in denen der Cache nicht überprüft wird
Kompilieren Sie immer neu, wenn das Modul direkt über die Befehlszeile geladen wird Ohne Quellmodul
Das Winreg-Modul wird nur auf Windows-Systemen bereitgestellt Variablen sys.ps1 und sys.ps2 Definieren Sie die Zeichenfolgen, die in den primären und sekundären Eingabeaufforderungen angezeigt werden sollen
sys.Pfad wird auf den Standardpfad festgelegt, der von der Umgebungsvariablen PYTHONPATH abgerufen wird, oder auf den integrierten Standardwert, wenn PYTHONPATH nicht festgelegt ist..
>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')
Sie können den vom Modul definierten Namen sehen. Gibt eine sortierte Liste von Zeichenfolgen zurück.
>>> import fibo, sys
>>> dir(fibo)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'fib', 'fib2']
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',(Kürzung)
Ohne Argumente, dir()Listet die aktuell definierten Namen auf.
>>> a = [1, 2, 3, 4, 5]
>>> fib = fibo.fib
>>> dir() #Keine Argumente
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'fib', 'fibo', 'sys']
Die Liste der integrierten Funktions- und Variablennamen verwendet die integrierten Standardmodule. * Nicht aufgeführt von dir ()
>>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError',(Kürzung)
So erstellen Sie ein Python-Modul mit dem "Punkt-getrennten Modulnamen"
-Modulname A.B → Repräsentiert das Submodul B des Pakets A. · Autoren von Paketen mit mehreren Modulen müssen sich nicht mehr um die Modulnamen der anderen kümmern -Die Datei init.py ist erforderlich, damit Python ein Verzeichnis als Verzeichnis mit Paketen behandelt. -Im einfachsten Fall kann init.py nur eine leere Datei sein, aber init.py kann Initialisierungscode für das Paket ausführen oder all Variablen setzen.
Importieren Sie einzelne Module aus dem Paket(Fall 1).
>>> import sound.effects.echo
>>> sound.effects.echo.echofilter(input, output, delay=0.7, atten=4) #Muss mit vollem Namen referenziert werden
Importieren Sie einzelne Module aus dem Paket(Fall 2).
>>> from sound.effects import echo
>>> echo.echofilter(input, output, delay=0.7, atten=4) #Verfügbar ohne Paketnamen
Importieren Sie einzelne Module aus dem Paket(Fall 3).
from sound.effects.echo import echofilter
echofilter(input, output, delay=0.7, atten=4) #Methode direkt verfügbar
-Wenn Sie die Syntax "aus Paketimportelement" verwenden item kann ein Submodul (oder Subpaket) des Paketpakets sein Andere im Paket definierte Namen wie Funktionen, Klassen, Variablen usw. Die import-Anweisung prüft zunächst, ob das Element im Paket definiert ist. Wenn nicht definiert, wird versucht, das Modul zu laden, vorausgesetzt, Element ist der Modulname. Wird kein Modul gefunden, wird ein ImportError ausgelöst
-Wenn Sie die Syntax von "import item.subitem.subsubitem" verwenden Jedes Element außer dem letzten Unterelement muss ein Paket sein
Lassen Sie den Paketautor den Paketindex explizit angeben
「from sound.effects import * 」
Unterstützt path als spezielles Attribut Das Attribut path steht vor der Ausführung des Codes in init.py des Pakets. Initialisiert als Liste mit den Verzeichnisnamen, die init.py enthalten
-Wie wird der Wert ausgegeben:
Ausdrucksanweisung Funktion print () Dateiobjekt write () -Methode
-Die Datei, die die Standardausgabe darstellt, kann in sys.stdout referenziert werden. ・ So formatieren Sie die Ausgabe
Verwenden Sie String-Slicing- und Verkettungsoperationen, um die gesamte String-Verarbeitung durchzuführen Verwenden Sie die str.format-Methode Verwenden Sie die Template-Klasse des String-Moduls So konvertieren Sie einen Wert in eine Zeichenfolge: Übergeben Sie den Wert an die Funktion repr () oder str ().
-Die Funktion str () dient zur Rückgabe einer für Menschen lesbaren Darstellung des Werts. Die Funktion repr () soll eine vom Interpreter lesbare Darstellung (oder SyntaxError, wenn keine äquivalente Syntax vorhanden ist) zurückgeben. Für Objekte, die keine spezifische Darstellung haben, die für das menschliche Lesen geeignet ist, gibt str () den gleichen Wert wie repr () zurück.
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> repr(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> str(s)
'The value of x is 32.5, and y is 40000...'
>>> repr(s)
"'The value of x is 32.5, and y is 40000...'"
>>> hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> str((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
>>> repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
Schreiben Sie eine quadratische und eine kubische Tabelle auf zwei Arten.
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
str.rjust (width [, fillchar]) -Methode ・ ・ ・ Gibt eine rechtsbündige Zeichenfolge mit der Länge zurück. Wenn fillchar angegeben ist, wird es mit den angegebenen Zeichen gefüllt. str.ljust (width [, fillchar]) -Methode ・ ・ ・ Gibt eine linksbündige Zeichenfolge mit der Länge zurück. Wenn fillchar angegeben ist, wird es mit den angegebenen Zeichen gefüllt. Wenn Sie Zeichen abschneiden möchten, verwenden Sie Slices und x.ljust (n) [: n]. Round () zum Runden. str.center (width [, fillchar]) -Methode ・ ・ ・ Gibt eine zentrierte Zeichenfolge mit der Länge zurück. Wenn fillchar angegeben ist, wird es mit den angegebenen Zeichen gefüllt. str.zfill () -Methode: Füllt die linke Seite der numerischen Zeichenfolge mit Null
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
str.format () -Methode
Klammern und die Zeichen in ihnen(Dies wird als Formatfeld bezeichnet).
>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"
Die Zahl in Klammern ist str.format()Kann verwendet werden, um die Position des an die Methode übergebenen Objekts darzustellen.
>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam
str.format()Wenn ein Schlüsselwortargument an die Methode übergeben wird, wird sein Wert durch den Namen des Schlüsselwortarguments referenziert.
>>> print('This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.
Sie können auch Ordnungs- und Schlüsselwortargumente kombinieren.
>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',other='Georg'))
The story of Bill, Manfred, and Georg.
'!a'(ascii()Anpassen)Oder'!s'(str()Anpassen)Oder'!r'(repr()Anpassen)Kann vor dem Formatieren des Werts mit konvertiert werden.
>>> contents = 'eels'
>>> print('My hovercraft is full of {}.'.format(contents))
My hovercraft is full of eels.
>>> print('My hovercraft is full of {!r}.'.format(contents))
My hovercraft is full of 'eels'.
Steuerbar, wie Werte durch Formatbezeichner formatiert werden.
>>> import math
>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))
The value of PI is approximately 3.142.
'Geben Sie die minimale Zeichenbreite des Felds an, indem Sie eine Ganzzahl hinzufügen.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print('{0:10} ==> {1:10d}'.format(name, phone))
...
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678
Übergeben Sie das Wörterbuch als Argument und setzen Sie eckige Klammern'[]'Sie können mit auf den Wörterbuchschlüssel verweisen.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Tabelle**] Übergeben als Schlüsselwortargument in Notation.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Zeichenfolgenformatierung mit dem Operator%
>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.
Zweites Argument von open: * Wie fopen in C-Sprache
| Modus | Bewegung | Wenn es eine Datei gibt | Wenn die Datei nicht existiert |
|---|---|---|---|
| r (Standardmäßig) | Schreibgeschützt | Keine Änderung | Error |
| w | Nur zum Schreiben | Größe auf 0 setzen (überschreiben) | Erstelle neu |
| a | Nur zum zusätzlichen Schreiben | Zum Dateiende hinzufügen | Erstelle neu |
| r+ | Lesen und Schreiben | Keine Änderung | Error |
| w+ | Schreiben und Lesen | Größe auf 0 setzen (überschreiben) | Erstelle neu |
| a+ | Lesen und zusätzliches Schreiben | Zum Dateiende hinzufügen | Erstelle neu |
Textmodus und Binärmodus ・ Textmodus (Standard) Zeilenvorschubcode konvertieren Zeilenvorschubcode als EOF (Dateiende) behandeln ・ Binärmodus (b) ・ ・ ・ Geben Sie hier Binärdaten wie JPG und EXE an. Konvertieren Sie keinen Zeilenvorschubcode Behandeln Sie den Zeilenvorschubcode nicht als EOF (Dateiende). Spezifikationsmethode: Kombinieren Sie mit dem obigen Modus und setzen Sie auf 'rb' und 'r + b'. (B kann entweder vorne oder hinten sein, aber b ist hinten)
Datei öffnen.
f = open('workfile','wb')
lesen und lesenline
f.read(size)Einlesen.
f = open('workfile','w')
>>> f.read()
'123\n456\n'
f.read(size)Nach Größe lesen.
>>> f.read(5)
'123\n4' #Gibt eine Zeichenfolge angegebener Bytes zurück
>>> f.read(5)
'56\n' #Wenn die angegebenen Bytes nicht erreicht werden, wird nur die vorhandene Zeichenfolge zurückgegeben.
>>> f.read(5)
'' #Wenn Sie das Ende erreichen''Gib es zurück
Lesen Sie mit readline.
>>> f.readline()
'123\n' #Gibt Zeile für Zeile zurück
>>> f.readline()
'456\n'
>>> f.readline()
'' #Wenn Sie das Ende erreichen''Gib es zurück
Um mehrere Zeilen aus einer Datei zu lesen, schreiben Sie eine Schleife in das Dateiobjekt.
>>> f = open('workfile','r+')
>>> for line in f:
... print(line, end='')
...
123
456
Sie können auch list (f) oder f.readlines () verwenden, wenn Sie jede Zeile der Datei im Listenformat lesen möchten
Datei schreiben.
>>> f = open('workfile','r+')
>>> f.write('This is a test\n') #Datei schreiben
15 #Die Anzahl der geschriebenen Zeichen wird zurückgegeben
>>> f.close()
>>> f = open('workfile','r+') #Überprüfen Sie unten
>>> f.read()
'This is a test\n'
>>> f.close()
Andere Objekttypen müssen vor dem Schreiben konvertiert werden Entweder eine Zeichenfolge (Textmodus) oder ein Byteobjekt (Binärmodus)
>>> f = open('workfile','r+')
>>> value = ('the answer', 42)
>>> s = str(value) #String
>>> value
('the answer', 42)
>>> s
"('the answer', 42)"
>>> f.write(s)
18
>>> f.close()
f.tell () ・ ・ ・ Gibt eine Ganzzahl zurück, die die aktuelle Position in der Datei angibt f.seek (Versatz, Startpunkt) ・ ・ ・ Wenn Sie die aktuelle Position ändern möchten Startpunkt: Dateistart "0" (Standard), aktuelle Position "1", Dateiende "2"
Lesefehler ohne Öffnen der Datei * Web wird beim Lesen und Schreiben von Dateien beschrieben.
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.
Verwenden Sie das Schlüsselwort mit, wenn Sie mit Dateiobjekten arbeiten. Wenn Sie eine Reihe von Untersuchungen beenden, wird die Datei ordnungsgemäß geschlossen und es treten Ausnahmen in der Mitte auf. Viel kürzer als der Aktionsblock der Partei.
Datei öffnen / lesen * Web wird unter Lesen / Schreiben von Dateien beschrieben.
>>> with open('workfile') as f:
... read_data = f.read()
...
>>> f.closed
True
Dateiobjekte verfügen auch über Methoden wie isatty () und truncate (), werden jedoch selten verwendet
Zeichenketten können frei gelesen und in Dateien geschrieben werden, numerische Werte erfordern jedoch einen geringen Aufwand. Die read () -Methode gibt nur einen String zurück, daher müssen Sie eine Funktion wie int () durchlaufen. Wenn es um komplexe Daten geht, ist es kompliziert, dies manuell zu tun.
Python erleichtert die Arbeit mit JSON
>>> import json
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'
>>> import json
>>> x = {'name':'yamada','data':[2,3,4]}
>>> print(json.dumps(x))
{"name": "yamada", "data": [2, 3, 4]}
dump ・ ・ ・ Serialisieren Sie das Objekt einfach in eine Textdatei Laden ・ ・ ・ Deserialisieren
(Siehe) Gurkenmodul Ein Protokoll, mit dem Sie im Gegensatz zu JSON jedes komplexe Python-Objekt serialisieren können. Es ist jedoch nur in Python verfügbar und kann nicht zur Kommunikation mit Anwendungen verwendet werden, die in anderen Sprachen geschrieben sind. Außerdem ist es standardmäßig nicht sicher.
Der Anzeigeinhalt der Fehlermeldung, wenn eine Ausnahme in der Funktion auftritt, ist wichtig
Tritt auf, weil es nicht den von Python festgelegten Regeln entspricht. Fehler bei der Syntaxinterpretation (Analyse) Anzeige: SyntaxError
Selbst wenn der Feldausdruck syntaktisch korrekt ist, tritt bei seiner Ausführung ein Fehler auf. Anzeige: ZeroDivisionError, NameError, TypeError usw. Es gibt eine Liste der integrierten Ausnahmen in Integrierte Ausnahmen.
♯ ## Ausnahmebehandlung Verhalten der try-Anweisung
Geben Sie Handler für verschiedene Ausnahmen an, indem Sie mehrere Ausnahmeklauseln in einer try-Anweisung angeben
... except (RuntimeError, TypeError, NameError):
Variablen können nach dem Ausnahmenamen in der Ausnahmeklausel angegeben werden Die Variable ist an eine Ausnahmeinstanz gebunden, und instance.args enthält die Argumente zum Erstellen der Ausnahmeinstanz. Str () ist in der Ausnahmeinstanz definiert, und die Argumente können direkt gedruckt werden, ohne auf .args zu verweisen.
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print(type(inst))
... print(inst.args)
... print(inst.args)
... x, y = inst.args
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs
Der Ausnahmebehandler behandelt auch Ausnahmen, die innerhalb einer Funktion auftreten, die (auch indirekt) von der try-Klausel aufgerufen wird. (Nicht nur Ausnahmen, die direkt in der try-Klausel auftreten)
else-Klausel (else-Klausel) else ・ ・ Die else-Klausel wird ausgeführt, wenn in der try-Klausel keine Ausnahme ausgelöst wird. Die Anweisung try… without kann optional eine else-Klausel enthalten Wenn es eine else-Klausel gibt, muss sie doch mit Ausnahme der Klauseln eingefügt werden
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
Mit der Raise-Anweisung können Sie bestimmte Ausnahmen auslösen
Sie können Ihre eigenen Ausnahmen in Ihr Programm aufnehmen, indem Sie eine neue Ausnahmeklasse erstellen. Sie können alles definieren, was eine normale Klasse tun kann, aber normalerweise nur dem Handler erlauben, Informationen über den Fehler abzurufen, wenn eine Ausnahme auftritt.
class Error(Exception):
pass
class InputError(Error):
def __init__(self, expression, message): #Überschreiben
self.expression = expression
self.message = message
Die finally-Klausel wird immer vor dem Beenden der try-Anweisung ausgeführt, unabhängig davon, ob eine Ausnahme aufgetreten ist.
Das Problem unten ist, dass die Datei offen bleibt
for line in open("myfile.txt"):
print(line, end="")
Die with-Anweisung stellt sicher, dass Objekte wie Dateien immer sofort und korrekt bereinigt werden.
with open("myfile.txt") as f:
for line in f:
print(line, end="")
Objekte haben Individualität, und demselben Objekt können mehrere Namen zugewiesen werden (aus mehreren Bereichen). (In anderen Sprachen wird es als Aliasing bezeichnet.)
Ein Namespace ist eine Zuordnung von einem Namen zu einem Objekt. Ein Bereich ist ein Bereich von Programmtext, auf den direkt über einen Namespace zugegriffen werden kann.
(Die einfachste Form)
class ClassName:
<Satz 1>
.
.
.
Klassenobjekte unterstützen zwei Arten von Operationen: Attributreferenz und Instanziierung.
Attributreferenz Instanziierung
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
Instanzobjekte unterstützen nur Attributreferenzoperationen. Es gibt zwei Arten von Attributnamen, Datenattribute und Methoden
Datenattribute entsprechen Smalltalk "Instanzvariablen" und C ++ "Datenelementen" Eine Methode ist eine Funktion, die zu einem Objekt "gehört".
· Instanzvariablen sind für eindeutige Daten für jede Instanz · Klassenvariablen gelten für Attribute und Methoden, die von allen Instanzen dieser Klasse gemeinsam genutzt werden
-Datenattribute überschreiben Methodenattribute mit demselben Namen → Verwenden Sie Regeln, die die Möglichkeit einer Kollision minimieren Beginnen Sie den Methodennamen mit einem Großbuchstaben, stellen Sie dem Datenattributnamen eine kurze eindeutige Zeichenfolge (oder nur eine Unterstreichung) voran, verwenden Sie ein Verb für die Methode, verwenden Sie ein Substantiv für das Datenattribut usw. Das erste Argument der Methode heißt self, aber diese Benennung ist nur eine Konvention
class DerivedClassName(BaseClassName):
<Satz 1>
.
.
.
class DerivedClassName(Base1,Base2,Base3):
Wenn das Attribut in DerivedClassName nicht vorhanden ist, wird es zuerst in Base1 und dann rekursiv in der Basisklasse von Base1 gesucht, und wenn es immer noch nicht gefunden wird, in Base2.
In Wirklichkeit ist es jedoch etwas komplizierter Die Reihenfolge der Methodenauflösung wird aufgrund des kollaborativen Aufrufs von super () dynamisch geändert. In anderen Sprachen mit Mehrfachvererbung als Call-Next-Methode bekannt, ist sie leistungsfähiger als der Superaufruf in Sprachen mit nur einer Vererbung.
In Python gibt es keine "privaten" Instanzvariablen. Es ist jedoch üblich, Namen, die mit einem Unterstrich beginnen (z. B. _spam), als privat zu behandeln.
-Datentypen, die benannte Datenelemente gruppieren, wie z. B. Pascals "Datensatz" und C-Sprache "Struktur", werden mithilfe der Shell-Klassendefinition implementiert.
Mit der for-Anweisung können Sie die meisten Containerobjekte durchlaufen.
>>> for element in [1, 2, 3]:
... print(element)
...
1
2
3
>>> for element in (1, 2, 3):
... print(element)
...
1
2
3
>>> for key in {'one':1, 'two':2}:
... print(key)
...
one
two
>>> for char in "123":
... print(char)
...
1
2
3
>>> for line in open("workfile"):
... print(line, end='')
...
0123456789abcdef2)>>>
Hinter den Kulissen ruft die for-Anweisung die Funktion iter () für das Containerobjekt auf.
-Die Funktion gibt ein Iteratorobjekt zurück, das die Methode next () definiert, die nacheinander auf die Elemente im Container zugreift. -Wenn keine weiteren Elemente vorhanden sind, löst die Methode next () eine StopIteration-Ausnahme aus, und die for-Schleife endet mit dem Empfang der Benachrichtigung.
Sie können die Methode next () auch direkt mit der integrierten Funktion next () aufrufen.
>>> s = 'abc'
>>> it = iter(s)
>>> it
<str_iterator object at 0x7fc6cf183eb8>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration #Wirf eine StopIteration-Ausnahme aus
Es ist einfach, Ihrer Klasse iteratives Verhalten hinzuzufügen, wenn Sie die Mechanismen hinter dem Iteratorprotokoll beobachten.
Definieren Sie eine iter () -Methode, die ein Objekt mit einer next () -Methode zurückgibt. Wenn die Klasse die Methode next () definiert, kann die Methode iter () auch einfach self zurückgeben.
>>> class Reverse:
... """Iterator for looping over a sequence backwards."""
... def __init__(self, data):
... self.data = data
... self.index = len(data)
... def __iter__(self):
... return self
... def __next__(self):
... if self.index == 0:
... raise StopIteration
... self.index = self.index - 1
... return self.data[self.index]
...
>>> rev = Reverse('123')
>>> iter(rev)
<__main__.Reverse object at 0x7fc6cf18ec88>
>>> for char in rev:
... print(char)
...
3
2
1
-Generator ist ein übersichtliches und leistungsstarkes Tool zum Erstellen von Iteratoren.
>>> def reverse(data):
... for index in range(len(data)-1, -1, -1):
... yield data[index]
...
>>> for char in reverse('golf'):
... print(char)
...
f
l
o
g
Für einen einfachen Generator gibt es eine einfache Möglichkeit, ihn mithilfe eines Ausdrucks zu codieren. Ein Ausdruck mit einer Syntax ähnlich der Listeneinbeziehung, jedoch mit Klammern anstelle von eckigen Klammern.
>>> sum(i*i for i in range(10))
285
OS-Modul ・ ・ ・ Betriebssystembezogen
>>> import os
>>> os.getcwd()
'/root/sample/test'
>>> os.chdir('/root')
>>> os.system('mkdir today')
0
Verwenden Sie das Import-OS-Format anstelle von OS-Import *
>>> import os
>>> dir(os)
>>> help(os)
Shutil-Modul: Eine übergeordnete Schnittstelle, die für die tägliche Verwaltung von Dateien und Verzeichnissen einfacher zu verwenden ist.
>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
'archive.db'
>>> shutil.move('/build/executables', 'installdir')
'installdir'
glob-Modul ・ ・ ・ Ruft den Dateipfadnamen ab, der dem im Argument angegebenen Muster entspricht
>>> import glob
>>> glob.glob('*.py')
>>> glob.glob('*') #Geben Sie alle Dateinamen im Verzeichnis aus
>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']
Das sys-Modul verfügt auch über Attribute für stdin, stdout und stderr
Das Modul re bietet reguläre Ausdrücke für eine erweiterte Zeichenfolgenverarbeitung
Das Mathematikmodul bietet eine Möglichkeit, auf Funktionen der C-Sprachbibliothek für Gleitkomma-Arithmetik zuzugreifen
>>> import math
>>> math.cos(math.pi / 4)
0.7071067811865476
>>> math.log(1024, 2) # log(x[, base]):x(Mit e als Boden)Natürlicher Logarithmus
10.0
>>> math.sqrt(2) #Holen Sie sich Quadratwurzel
1.4142135623730951
Das Zufallsmodul bietet ein Werkzeug zur Elementauswahl basierend auf Zufallszahlen
>>> import random
>>> random.choice(['apple','pear','banana'])
'pear'
>>> random.sample(range(100), 10)
[6, 49, 57, 72, 31, 25, 35, 90, 30, 76]
>>> random.random()
0.7892340475238878
>>> random.randrange(6)
5
Das Statistikmodul berechnet die grundlegenden statistischen Merkmale numerischer Daten (Mittelwert, Median, Varianz usw.).
SciPy Project bietet viele Module für die numerische Verarbeitung
Die beiden einfachsten Module sind urllib.request, um Daten von einer URL abzurufen, und smtplib, um eine E-Mail zu senden.
Das Datum / Uhrzeit-Modul bietet Klassen zum einfachen und komplexen Bearbeiten von Datum und Uhrzeit.
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2020, 1, 3)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'01-03-20. 03 Jan 2020 is a Friday on the 03 day of January.'
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
20244
Module: zlib, gzip, bz2, lzma, zipfile, tarfile
>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979
timeit Modul
>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.025199586991220713
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.022948098019696772
Das doctest-Modul bietet Tools zum Suchen nach Modulen und Auswerten von Tests, die in die Dokumentzeichenfolge des Programms eingebettet sind.
Batterie enthalten: Eine Bibliothek und eine integrierte Umgebung, die vom Programmierer sofort verwendet werden können, werden im Voraus vorbereitet. Module xmlrpc.client und xmlrpc.server E-Mail-Paket JSON-Paket SQLite3-Modul gettext, locale, codecs package
-Reprlib-Modul: Begrenzt die Ausgabelänge, kann geändert werden, der Standardwert ist jedoch 6 Elemente
reprlib.Repr und Repr.
>>> reprlib.repr('1111122222333334444455555666667777788888')
"'111112222233...6667777788888'" #Unterwegs weggelassen
>>> repr('1111122222333334444455555666667777788888')
"'1111122222333334444455555666667777788888'" #(Vergleich)Ergebnis der Repr
reprlib.Repr und Repr:Kombiniert mit Set Set.
>>> reprlib.repr(set('1111122222333334444455555666667777788888'))
"{'1', '2', '3', '4', '5', '6', ...}" #Machen Sie es einzigartig, indem Sie das Set-Set verwenden und die Rückseite weglassen
>>> repr(set('1111122222333334444455555666667777788888'))
"{'5', '3', '8', '2', '6', '1', '4', '7'}" #(Vergleich)Ergebnis der Repr
>>> reprlib.repr({'d', 'e', 't', 'c', 'n', 'o', 'v', 'i'})
"{'c', 'd', 'e', 'i', 'n', 'o', ...}"
-Druckmodul -Textwrap-Modul: Passt den aus Absätzen bestehenden Text so an, dass er genau in die angegebene Bildschirmbreite passt. ・ Lokales Modul
Das Zeichenfolgenmodul enthält die Template-Klasse, die flexibel ist und eine einfache Syntax hat, die Endbenutzer leicht bearbeiten können.
>>> from string import Template
>>> t = Template('${village}folk send $$10 to $cause.')
>>> t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'
Die Methode replace () löst einen KeyError aus, wenn das Wörterbuch oder das Schlüsselwortargument kein Platzhalteräquivalent enthält.
Strukturmodul ・ ・ ・ Bietet Funktionen wie pack () und unpack (), mit denen binäre Datensatzformate unterschiedlicher Länge ausgeführt werden.
>>> import struct
>>> kind, value = struct.unpack("BxH", data)
>>> data
b'd\x00\xb0\x04'
Threading ist eine Technik zum Aufteilen mehrerer Aufgaben, die nicht in der Reihenfolge ihrer Abhängigkeit angeordnet sind. Das schwierigste Problem beim Erstellen einer Multithread-Anwendung ist die Koordination zwischen Threads, die Daten und Ressourcen gemeinsam nutzen.
Das Protokollierungsmodul bietet ein flexibles Protokollierungssystem mit vielen Funktionen.
>>> import logging
>>> logging.debug('Debugging information')
>>> logging.info('Informational message')
>>> logging.warning('Warning:config file %s not found', 'server.conf')
WARNING:root:Warning:config file server.conf not found
>>> logging.error('Error occurred')
ERROR:root:Error occurred
>>> logging.critical('Critical error -- shutting down')
CRITICAL:root:Critical error -- shutting down
Standardmäßig wird die Ausgabe von info () und debug () unterdrückt und die Ausgabe an Standardfehler gesendet
Python verwaltet den Speicher automatisch (die meisten Objekte werden durch Referenzzählung verwaltet, und die Garbage Collection entfernt Zirkelverweise). Der Speicher wird kurz nach dem letzten Verweis auf das Objekt freigegeben.
Das Dezimalmodul bietet Dezimaldatentypen, die arithmetische Operationen mit schwebenden Dezimalbrüchen unterstützen.
Da die Dezimalklasse exakte Werte darstellen kann, können auch Restwerte und Gleichheitstests berechnet werden, die mit binären Gleitkommazahlen nicht wie erwartet berechnet werden können. Dezimalmodul ・ ・ ・ Arithmetische Berechnung mit der erforderlichen Genauigkeit
pyvenv tutorial-env Erstellen Sie das Verzeichnis tutorial-env, falls es nicht vorhanden ist, und erstellen Sie darin ein Unterverzeichnis, das den Python-Interpreter, Standardbibliotheken und andere verwandte Dateien enthält.
pip search astronomy pip install novas pip install requests==2.6.0 pip install --upgrade requests pip show requests pip list pip freeze > requirements.txt pip install -r requirements.txt pip uninstall request
Lernen nach dem Erlernen des Tutorials und verschiedener Links
IPython bpython
Gleitkommazahlen werden in der Computerhardware als (binäre) Brüche mit einer Basis von 2 dargestellt.
Der Darstellungsfehler hängt mit der Tatsache zusammen, dass einige (tatsächlich die meisten) Dezimalbrüche nicht als binäre (Basis 2) Brüche dargestellt werden können.
>>> from decimal import Decimal
>>> from fractions import Fraction
>>> Fraction.from_float(0.1)
Fraction(3602879701896397, 36028797018963968)
>>> (0.1).as_integer_ratio()
(3602879701896397, 36028797018963968)
>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> format(Decimal.from_float(0.1), '.17')
'0.10000000000000001'
Recommended Posts