Beschreibt die grundlegende Schreibmethode von Python. Die Version ist 3.4.3.
Kommentare beginnen mit "#".
#Dies ist ein Kommentar
Es gibt Ganzzahlen, Gleitkommazahlen und komplexe Zahlen.
#Vier Regeln
2 + 3 # 5
2 - 3 # -1
2 * 3 # 6
#Die Ganzzahldivision ist eine Gleitkommazahl
2 / 3 # 0.6666666666666666
# //Der ganzzahlige Teil nach der Division kann durch Berechnung extrahiert werden
3 // 2 # 1
# **Es ist eine Kraft
2 ** 10 #1024 2 bis zur 10. Potenz
#Komplexe Zahl
(1+1j) + (2+2j) # (3+3j)Imaginäre Einheit ist j, 1 von 1j kann nicht weggelassen werden
c = 1 + 2j
c.real #1.0 Realteil
c.imag #2.0 Imaginärteil
sequence
Eine Datenstruktur, in der Elemente in numerischer Reihenfolge angeordnet sind. Auf jedes Element kann mit einem Ganzzahlindex ab 0 zugegriffen werden.
Die nächste Datenstruktur ist die Sequenz.
Nehmen wir als Beispiel List, um die Reihenfolge zu erklären.
l = [1,2,3]
l[0] #1 Element 0 Index beginnt mit 0
l[2] #3 Element 2
l[-1] #3 Element 3 Index kann negativ sein
len(l) #Anzahl von 3 Elementen
max(l) #3 Maximalwert
min(l) #1 Mindestwert
l.count(1) #1 Anzahl der Auftritte
1 in l #Gibt an, ob das True-Element enthalten ist
3 in l # False
1 not in l #Falsches Element ist nicht enthalten oder in ist invertiert
#Gibt eine Liste mit einem Bereich zurück
l[:] # [1,2,3]Gibt alle Elemente als Liste zurück
l[1:2] # [2] a:a bis b im b-Format-Gibt Elemente bis 1 in List zurück
l[0:] # [1,2,3] a:Gibt eine Liste von Elementen von a bis zum Ende im Format zurück
l[:2] # [1,2] :b von Anfang an im b-Format-Gibt Elemente bis 1 in List zurück
Eine Sequenz, deren Element ein Zeichen ist. Sie können das Element nicht ändern.
s = "string" #Die Zeichenkette ist"Herauskommen
s = 'string' # 'Aber ok
#Sie können mit dem Integer-Index auf das Zeichen zugreifen
s[0] # 's'
#Element kann nicht geändert werden
s[0] = "S" #Error
#Mehrzeilige Zeichenfolge" or 'Ich werde 3 Stücke zusammenstellen
'''
Mehrere Zeilen
String
'''
#Strings verbinden
"a" + "b" # 'ab'
#Wiederholen Sie die Zeichenfolge
"a" * 2 # 'aa'
#Teilen Sie die Zeichenfolge
"1,2".split(",") # ['1', '2']Liste kehrt zurück
#Saiten kombinieren
",".join(["1","2"]) # '1,2'
#Konvertiert eine Zeichenfolge in eine Zahl
int("0x10", 16) #16 Das zweite Argument ist der Radix
int("10") #10 Wenn das zweite Argument weggelassen wird, wird die Basis als 10 behandelt.
int("10", 2) # 2
float("1.2") # 1.2
#Zahlen in Zeichenfolgen konvertieren
"dec:{0},hex:{0:X},bin:{0:b}".format(16) # 'dec:16,hex:10,bin:10000'
"{0:.2f}".format(3.1415) # '3.14'
list Eine Sequenz, die beliebige Daten als Element enthalten kann. Sie können das Element ändern.
l = [1,2,3] # ,Trennung,"[]"Herauskommen
l[0] #1 Element 0 Index beginnt mit 0
l[2] #3 Element 2
l[-1] #3 Element 3 Index kann negativ sein
#Fügen Sie am Ende ein Element hinzu
ll = l + [4] # ll = [1,2,3,4]Element hinzufügen(+)
l.append(4) # l = [1,2,3,4]Element hinzufügen(append)
#Extrahieren Sie das Element vom Ende
l = [1,2,3]
l.pop #3 Ergebnis l= [1,2]
#Gibt die Elementiteration zurück
l = [2]
l * 2 # [2,2]
#Sie können die Einschlussnotation verwenden, um die Liste zu initialisieren
# []Schreiben Sie die for-Anweisung in
l = [x for x in range(10)] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#Mehrdimensionale Liste
#2D:Warteschlange
m = [[row for row in range(2)] for col in range(3)] # [[0, 1], [0, 1], [0, 1]]
#3D
m = [[[row for row in range(2)] for col in range(3)] for mat in range(4)]
tuple Eine Sequenz, die beliebige Daten als Element enthalten kann. ** Sie können das Element nicht ändern. Dies ist der Unterschied zu List. ** ** **
t = (1,2,3) # ,Trennung,"()"Herauskommen
t[0] = 10 #Fehler, Element kann nicht geändert werden
range Eine Sequenz, die einen numerischen Wert als Element verwenden kann. Sie können das Element nicht ändern. Wird in Kombination mit der for-Anweisung verwendet.
# range(x)Bei 0~x-Repräsentiert 1
# 0~9 wird angezeigt
for i in range(10):
print(i)
# range(x, y)Mit x~y-Repräsentiert 1
# 1~9 wird angezeigt
for i in range(1, 10):
print(i)
# range(x, y, step)Mit x,x+step, x+2*step, ... (y-Bis zu 1)Repräsentiert.
# 1,3,5,7,Repräsentiert 9.
for i in range(1, 10, 2):
print(i)
if
Vergleichsbedingungen können im Format "aaa <x <bbb" angegeben werden.
Sie können in und is Operationen verwenden.
# if .. elif .. else
x = 1
if x == 1:
print("x == 1")
elif x == 2:
print("x == 2")
else:
print("else")
# result : x == 1
# < x <Berechnung
x = 5
if 1 < x < 6:
print("True")
else:
print("False")
# result : True
#in der Arithmetik
if 0 in [1, 2, 3]:
print("True")
else:
print("False")
# result : False
#nicht in arithmetik
if 0 not in [1, 2, 3]:
print("True")
else:
print("False")
# result : True
#is operation, bestimmt, ob es sich um dasselbe Objekt handelt
if [1] is [1]:
print("True")
else:
print("False")
# result : False
l = [1,2,3]
ll = l
if l is ll:
print("True")
else:
print("False")
# result : True
for break / continue ist dasselbe wie in anderen Sprachen. sonst ist charakteristisch. sonst wird ausgeführt, wenn die for-Anweisung bis zum Ende ausgeführt wird. Wenn es in der Pause stoppt, wird else nicht ausgeführt.
# range
for i in range(10):
print(i)
# result : 0~10
# list
for i in [1, 2, 3]:
print(i)
# result : 1~3
# else/break
#Sie können sonst anhängen.
#Andernfalls wird ausgeführt, wenn for bis zum Ende ausgeführt wird.
#Es wird nicht ausgeführt, wenn es bricht.
for i in [1, 2, 3]:
print(i)
if i == 2:
break
else:
print("else")
# result : 1~2,sonst wird nicht angezeigt
while Wie für können Sie noch hinzufügen.
i = 0
while i < 10:
print(i)
if i == 1:
break
i = i + 1
else:
print("else")
# result : 0~1
Sie können eine Funktion aufrufen, indem Sie einen Argumentnamen wie "f (x = 10, y = 20)" angeben. Es ist einfacher zu lesen und Sie können die Reihenfolge der Argumente ändern.
#Definieren Sie eine Funktion, die den Gesamtwert zurückgibt
def sum(l):
val = 0
for i in l:
val = val + i
return val
print(sum([1, 2, 3]))
# result : 6
#Sie können das Standardargument angeben
def add(x=10, y=20):
return x + y
print(add())
# result : 30
#Sie können es aufrufen, indem Sie den Argumentnamen angeben, und Sie können die Reihenfolge der Argumente ändern.
def sub(x, y):
return x - y
print(sub(y=20, x=10))
# result : -10
Eine Datei mit Klassen und Funktionen wird als Modul bezeichnet. Die Erweiterung ist .py. Der Modulname ist der Dateiname ohne .py. Es ist praktisch, häufig verwendete Funktionen in einem Modul so zu organisieren, dass sie wiederverwendet werden können.
#Importieren Sie das Modul mit Import.
import numpy as np #Definieren Sie den Alias mit as
a = np.array([1,2,3]) #Verweisen Sie auf ein Modulmitglied mit dem Alias np
#Wenn Sie beim einfachen Importieren auf ein Modulmitglied verweisen
#Modulname(oder alias)Geändert mit(e.g. np.array)müssen es tun.
#Sie können die Änderung mit von auslassen.
from numpy import array
a = array([1,2,3]) #OK ohne np
# *Es ist auch möglich, alle mit anzugeben
from numpy import *
Durch das Definieren einer Klasse wird ein entsprechendes Klassenobjekt erstellt.
Der Konstruktorname lautet __init__. Nimmt sich selbst als Argument.
self ist ein Schlüsselwort für die Referenzierung Ihres eigenen Objekts.
Klassenobjekte umfassen
Variablen und Methoden haben öffentlichen und privaten Geltungsbereich. Stellen Sie dem Namen "__" voran, um ihn privat zu machen. Auf private Elemente kann nicht von außerhalb der Klasse zugegriffen werden.
#Definieren Sie eine Klasse
class Test:
#Klassenvariable
i = "pub class var" #Öffentlichkeit
__i = "prv class var" #Privat
#Instanzmethode
def method(self):
print("pub inst method")
def __method(self):
print("prv inst method")
#Klassenmethode
@classmethod
def cls_meth(cls):
print("cls_meth")
#Statische Methode
@staticmethod
def stat_meth():
print("stat_meth")
#Konstrukteur
def __init__(self):
#Instanzvariable
self.j = "pub inst var" #Öffentlichkeit
self.__j = "prv inst var" #Privat
print("__init__")
#Öffentlichkeit
print(Test.i) #Klasse Variable Klasse.Namensformat
print(self.i) #Klassenvariable obj.Namensformat
print(self.j) #Instanzvariable obj.Namensformat
self.method() #Methode
#Privat
print(self.__i) #Klasse Variable Klasse.Namensformat
print(self.__j) #Instanzvariable obj.Namensformat
self.__method() #Methode
#Erstellen Sie eine Instanz
t1 = Test()
t2 = Test()
#Variablen durchsuchen
print(Test.i) #1 Klasse variable Klasse.Namensformat
print(t1.i) #1 Klassenvariable obj.Namensformat
print(t1.j) #2 Instanzvariable obj.Namensformat
#Klassenvariablen und gleichnamige Instanzvariablen können definiert werden
#Es ist eine Quelle der Verwirrung, also benutze es nicht so.
t1.i = 10
print(t1.i) # 10 obj.Priorität wird gegeben, um den Namen zu erhalten. Die Klassenvariable i kann nicht von t1 aus referenziert werden
print(Test.i) # 3
print(t2.i) # 3
#Dynamische Variablenaddition
t1.x = 10 #Sie können Instanzvariablen dynamisch hinzufügen.
print(t1.x) # 10
del t1.x #Löschen
Test.x = 20 #Sie können Klassenvariablen dynamisch hinzufügen.
print(Test.x) # 20
del Test.x #Löschen
#Rufen Sie die Methode auf
t1.method()
#t1.__method() #Error
#Klassenmethodenaufruf
Test.cls_meth()
#Statischer Methodenaufruf
Test.stat_meth()
Durch Schreiben von "class Child (Parent)" in die Klassendefinition Sie können eine untergeordnete Klasse definieren, die von Parent erbt.
Auf private Mitglieder der übergeordneten Klasse kann nicht über die untergeordnete Klasse zugegriffen werden. Sie können die Methoden der übergeordneten Klasse aus der untergeordneten Klasse überschreiben. So definieren Sie die Instanzvariablen der übergeordneten Klasse im Konstruktor der untergeordneten Klasse Sie müssen den Konstruktor der übergeordneten Klasse aufrufen.
#Definieren Sie die übergeordnete Klasse
class Parent:
i = "pub class var"
__i = "prv class var"
def __init__(self):
self.j = "pub inst var"
self.__j = "prv inst var"
def meth(self):
print("pub inst meth")
print(self.i)
print(self.__i)
self.__meth()
def meth2(self):
print("pub inst meth2")
print(self.j)
print(self.__j)
def meth3(self):
print("pub inst meth3")
def __meth(self):
print("prv inst meth")
#Definieren Sie eine untergeordnete Klasse
class Child(Parent):
def __init__(self):
#Rufen Sie den Konstruktor der übergeordneten Klasse auf
#Ohne dies wird die Instanzvariable der übergeordneten Klasse nicht definiert
#Meth2 aus der untergeordneten Klasse führt zu einem Fehler
Parent.__init__(self)
#überschreiben
def meth3(self):
print("child pub inst meth3")
def meth4(self):
self.__meth()
#Erstellen Sie eine Instanz
p = Parent()
p.meth()
p.meth2()
p.meth3()
c = Child()
c.meth()
c.meth2()
c.meth3() #Die untergeordnete Klasse meth3 heißt
#c.meth4()
#Wird zu einem Fehler führen
#Die untergeordnete Klasse kann nicht auf private Methoden der übergeordneten Klasse zugreifen
try:
int("xxx") #Eine Ausnahme tritt auf, weil es sich nicht um einen numerischen Wert handelt
except OSError:
print("OSError")
except ValueError:
print("ValueError")
# resutl : ValueError
#Wenn es keine Ausnahmen gibt, wird else ausgeführt
try:
int("10")
except OSError:
print("OSError")
except ValueError:
print("ValueError")
else:
print("NoError")
# resutl : NoError
#Läuft schließlich mit oder ohne Ausnahmen
try:
int("xxx")
except OSError:
print("OSError")
except ValueError:
print("ValueError")
finally:
print("Finally")
# resutl : ValueError Finally
#Sie können mit verwenden, um korrekt zu schließen, auch wenn eine Ausnahme auftritt
with open("tmp.txt", "a") as f:
f.write("test\n")
#Mit der for-Anweisung können Sie alle Zeilen behandeln
with open("tmp.txt", "r") as f:
for ln in f:
print(ln)
Befehlszeilenargumente gehen in sys.argv. sys.argv [0] ist der Skriptname. sys.argv [1] ist das erste Argument.
test.py
import sys
print(sys.argv)
>python test.py param1 param2
['test.py', 'param1', 'param2']
import re
ln = "<tag>1234</tag>"
#Definieren Sie einen regulären Ausdruck.()Sie können mit gruppieren.
r = re.compile("<tag>(.+)</tag>")
#Suche.
m = r.search(ln)
#Wenn es keine Übereinstimmung gibt, ist m Keine
print(m.group(0)) #Die gesamte übereinstimmende Zeichenfolge"<tag>1234</tag>"
print(m.group(1)) # ()Die nach gruppierte Zeichenfolge wird zurückgegeben."1234"
Recommended Posts