Ein Memorandum für mich. Ich las O'REILLYs ** erste Python ** und listete auf, was ich für "brauchbar" hielt.
Seien Sie beispielsweise vorsichtig, wenn Sie die folgende Liste verwenden.
[Nicht gut]list_use.py
L = [1, 2, 3] #Listenerstellung
M = L #Listenkopie
M[0] = 5 #Ändern Sie das 0. Element von M.
print M
>>> [5, 2, 3] #Es ist okay, es hat sich geändert.
print L
>>> [5, 2, 3] #Hmm! ?? Ich wollte die Liste von L ...
Wenn Sie in Python einer Variablen einen Wert zuweisen (z. B. x = 1), werden zwei Felder erstellt, ein Feld, das als Variable bezeichnet wird, und ein Objekt, das als Wert bezeichnet wird. Variablen speichern Referenzinformationen zu Objekten, und Zuweisungen zwischen Variablen (z. B. y = x) kopieren die Referenzinformationen.
Wenn daher die Variable L die Referenzinformationen des Objekts [1, 2, 3] hat und dies M = L ist, werden die Referenzinformationen des Objekts [1, 2, 3] in der Variablen M gespeichert. Werden. Das Ändern von M [0] = 5 ist daher ein Vorgang, bei dem Änderungen an dem Objekt vorgenommen werden, auf das sich auch L bezieht. Selbst wenn Sie nur M ändern möchten, ändern Sie auch L. Dies ist eine Einschränkung nur für variable Objekte. Es ist die Listenwörterbuchklasse, die Variabilität aufweist. Achten Sie also auch auf diese. Wenn Sie dies tun, erstellen Sie ein neues Objekt wie folgt.
[OK]list_use.py
L = [1, 2, 3] #Listenerstellung
M = L[:] #Kopieren Sie alle Elemente der Liste
M[0] = 5 #Ändern Sie das 0. Element von M.
print M
>>> [5, 2, 3]
print L
>>> [1, 2, 3] #L ist von der Änderung nicht betroffen!
dict_test.py
D1 = {'spam':2, 'ham':1, 'eggs':3}
print D1.keys()
>>> ['eggs', 'ham', 'spam']
# D1.keys()Holen Sie sich eine Liste der Wörterbuchschlüssel
#Nützlich bei der Verarbeitung des Wörterbuchs in Schlüsselreihenfolge
L = D1.keys()
L.sort()
for x in L:
print x, D1[x]
>>> eggs 3
>>> ham 1
>>> spam 2
dict_marge.py
D1 = {'spam':2, 'ham':1, 'eggs':3}
D2 = {'milk':4, 'ham': 4}
D1.update(D2)
print D1
>>> {'eggs': 3, 'milk': 4, 'ham': 4, 'spam': 2}
#Neue Elemente nur in D2 werden hinzugefügt, Elemente in D1 und D2 werden aktualisiert
create_dict.py
keys = ['spam', 'eggs', 'toast']
vals = [1, 3, 5]
D3 = dict(zip(keys, vals))
print D3
>>> {'toast': 5, 'eggs': 3, 'spam': 1}
use_pickle.py
#Mit Gurke speichern
D = {'a':1, 'b':2}
import pickle
F = open('dump.pkl', 'w')
pickle.dump(D, F) #Mit Gurke serialisieren
F.close()
#Laden Sie von der Gurke
F = open('dump.pkl', 'r')
E = pickle.load(F) #Mit Gurke deserialisieren
print E
>>> {'a':1, 'b':2}
Wie schreibe ich wie wenn Anweisung Ausführung im Wörterbuch. Im Folgenden wird beispielsweise geprüft, ob Elemente im Zweigwörterbuch vorhanden sind.
dict_if.py
branch = {'spam': 2, 'ham': 3, 'eggs': 1}
print branch.get('spam', 'nothing!')
>>> 2
print branch.get('bacon', 'nothing!')
>>> nothing!
Sie können else in while und für Anweisungen verwenden. Andernfalls wird es nicht ausgeführt, wenn es während der Schleife ausbricht, aber es wird ausgeführt, wenn die Schleife bis zum Ende abgeschlossen ist. Beispiel: Verwendungsbeispiel für die folgende Beurteilung von Primzahlen
while_else.py
y = 13
x = y /2
while x > 1:
if y % x == 0:
print y, 'has factor', x
break
x = x -1
else:
print y, 'is prime'
#Unterbrechen Sie, wenn eine teilbare Zahl größer als 1 ist. Ansonsten die Primzahl und Ausgabe in else.
Wenn Sie ein Funktionsargument mit \ * oder \ * \ * definieren, kann das Argument als Tapple- oder Dictionary-Typ empfangen werden. Nützlich, wenn Sie sich nicht sicher sind, wie viele Variablen beim Aufrufen einer Funktion verfügbar sind.
args_test.py
#Der Wert des Arguments wird zu einem Taple.
def f1(*args):
print args
f1()
>>> ()
#Ein leerer Taple wird ausgegeben.
f1(1)
>>> (1, )
#Es wird nur 1 Taple ausgegeben.
f1(1, 2, 3, 4)
>>> (1, 2, 3, 4)
# 1, 2, 3,Es werden 4 Taples ausgegeben
def f2(**args):
print args
f2()
>>> {}
#Ein leeres Wörterbuch wird ausgegeben
f2(a = 1, b = 2)
>>> {'a': 1, 'b': 2}
# {'a': 1, 'b': 2}Wörterbuch wird ausgegeben
Der Name ist ein Wort, das in LISP verwendet wird und von λ abgeleitet zu sein scheint. Wie def wird es verwendet, um eine Funktion zu definieren.
lambda_test.py
L = [(lambda x : x ** 2), (lambda x : x ** 3), (lambda x : x ** 4)]
for f in L:
print f(2)
>>> 4
>>> 8
>>> 16
Wenn def verwendet wird, wird es wie folgt und ist redundant. Darüber hinaus ist es nicht möglich, den Vorgang zu erfassen, ohne den Inhalt zu überprüfen, indem zu jeder Funktion gesprungen wird.
def_use.py
def f1(x): retrun x ** 2
def f2(x): retrun x ** 3
def f3(x): retrun x ** 4
L = [f1(2), f2(2), f3(2)]
for f in L:
print f
>>> 4
>>> 8
>>> 16
Lambda ist wirksam, wenn eine einfache Funktion verwendet wird. Da sich die Formel in unmittelbarer Nähe befindet, ist die Sicht außerdem gut. Es wird oft in der Quelle des Tensorflusses verwendet, so dass es keinen Verlust gibt, an den man sich erinnern muss. Aber ich kann es nicht verstehen. .. Lassen Sie uns dies viele Male überprüfen.
Wird verwendet, wenn Sie dieselbe Funktion auf eine Sequenz wie eine Liste [Zeichenfolge (Zeichen für Zeichen), ein Wörterbuch usw.] anwenden möchten.
map_use.py
def inc(x): return x + 10
L = [11, 12, 13, 14, 15]
print map(inc, L)
>>> [21, 22, 23, 24, 25]
Kann auch in Kombination mit Lambda verwendet werden.
map_lambda.py
L = [1, 2, 3, 4]
print map((lambda x: x + 3), L)
>>> [4, 5, 6, 7]
Wie bei der Karte können Sie eine Funktion auf bestimmte Werte anwenden und das Ergebnis als Liste erhalten.
list_loop1.py
#Einfache Schleife
print [x ** 2 for x in range(5)]
>>> [0, 1, 4, 9, 16]
Dasselbe kann mit map gemacht werden, aber die grundlegende Notation zur Aufnahme von Listen ist einfacher zu schreiben.
list_loop2.py
#Sie können auch Doppelschleifen ausdrücken
print [x + y for x in 'spam' for y in 'SPAM']
>>> ['sS', 'sP', 'sA', 'sM', 'pS', 'pP', 'pA', 'pM', .. , 'mA', 'mM']
list_loop3.py
#Sie können es auch mit if kombinieren
print [(x, y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]
>>> [(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]
list_loop4.py
#Auch gut im Umgang mit Matrix
M = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
N = [[2, 2, 2],
[3, 3, 3],
[4, 4, 4]]
#Nehmen Sie die zweite Zeile von M.
print [row[1] for row in M]
>>> [2, 5, 8]
#Multiplizieren Sie jedes Element
print [[M[row][col] * N[row][col] for col in range(3)] for row in range(3)]
>>> [[2, 4, 6], [12, 15, 18], [28, 32, 36]]
Obwohl es sich um eine Funktion handelt, kann das Ergebnis jederzeit ausgeführt werden, ohne dass das Ergebnis auf einmal zurückgegeben wird. Es gibt keine Rendite und die Rendite wird beschrieben.
genesquare.py
#Generator erstellen
def gensquares(N):
for i in range(N):
yield i ** 2
#Ausführung mit einem Iterator
x = gensquares(5) #Ordnen Sie den Generator x zu
print x.next()
>>> 0
print x.next()
>>> 1
print x.next()
>>> 4
print x.next()
>>> 9
print x.next()
>>> 16
print x.next()
>>> error ...
Suchen Sie im Verzeichnis von sys.path (`` `import sys; print sys.path```). sys.path besteht aus den folgenden vier.
① Arbeitsverzeichnis des Ausführungsprogramms ② Verzeichnis in der Umgebungsvariablen PYTHONPATH ③ Verzeichnis der Standardbibliotheksmodule (Bibliotheksgruppe [sys, math, etc.] von Anfang an gepackt) ④ In der .pth-Datei beschriebenes Verzeichnis (Es scheint myconfig.pth zu sein, aber ich konnte es in meiner Umgebung nicht finden ...)
Im Fall von Mathematik befindet sich ③ beispielsweise in dem Pfad, der durch die folgende mathematische .- Datei erhalten wird. Dies ist einer der Standardbibliothekspfade.
>>> import math; dir(math)
['__doc__', '__file__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>> math.__file__
'/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload/math.so'
Umgekehrt können Sie math nicht verwenden, wenn Sie diese math.so aus dem Standardbibliotheksverzeichnis entfernen.
MacBook-Pro:hoge$ sudo mv /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload/math.so ./
cd ..
MacBook-Pro:work fuga$ python
Python 2.7.10 (default, Jul 14 2015, 19:46:27)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import math
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named math
Wenn Sie bereits über .pyc verfügen, müssen Sie den Bytecode nicht verwenden. Wenn der Zeitstempel der zu importierenden .py-Datei jedoch größer als der .pyc ist, geben Sie ihn per Byte ein. (Weil .pyc alt zu sein scheint) Wenn Sie jedoch .pyc als Datei erstellen, ist dies nicht der Fall. Codieren Sie es einfach per Byte für die Verwendung im aktuellen Ausführungsmodul. Es wird keine .pyc ausgegeben.
Objekterzeugung von oben nach unten.
Das Importziel ist module_test.py und die Importseite ist module_use.py.
module_test.py
def printer(x):
print x
module_use.py
#Import liest das gesamte Modul
import module_test
module_test.pirinter('spam')
>>> spam
#von xxx import yyy liest die yyy-Variable von xxx
from module_test import printer
printer('spam')
>>> spam
Recommended Posts