Ich bin ein Javaler, also habe ich angefangen, mit Python zu spielen, also mach dir eine Notiz. Wirklich nur eine Notiz.
Mit Eclipse können Sie eine Entwicklungsumgebung erstellen. Es gibt Plejaden All in One für Python.
Sie können es erstellen, indem Sie mit der rechten Maustaste auf Paket-Explorer → "Neu" → "Projekt" → "Pydev-Projekt" klicken.
Es scheint, dass Python auch das Konzept eines Pakets hat. Sie können es erstellen, indem Sie mit der rechten Maustaste auf Paket-Explorer → "Neu" → "Pydev-Paket" klicken.
Python-Quelldateien sind Dateien mit der Erweiterung py Sie können es erstellen, indem Sie mit der rechten Maustaste auf Paket-Explorer → "Neu" → "Pydev-Modul" klicken. Sie können eine Klasse oder eine Hauptvorlage (Ausführungsvorlage) auswählen.
Klicken Sie mit der rechten Maustaste auf die py-Datei mit der Hauptmethode (?) → "Ausführen" → "Python ausführen".
Das "publoc void main (String ... args)" -ähnliche Ding in Java wird wie folgt beschrieben
if __name__ == '__main__':
print("I am a beginner")
"Ich bin ein Anfänger" erscheint auf der Konsole
Vorbereitet durch Auswahl der "Haupt" -Vorlage beim Erstellen eines Pydev-Moduls aus Eclipse
Python definiert Blöcke mit Einrückung.
if __name__ == '__main__':
print("1")
if True:
print("2") #In wenn
print("3") #In wenn
else:
print("4") #In sonst
print("5") #In sonst
print("6") #Verlasse den Block
Wird als 1, 2, 3, 6 ausgegeben
Die Substitution entspricht der Variablendeklaration.
i = 1
s = "String"
b = True
Verwenden Sie "und", "oder", "nicht"
Wenn ein Objekt in einem bedingten Ausdruck verwendet wird, wird es als "falsch" behandelt, wenn es "Keine" ist.
o = None
if not o:
print("o ist keine")
Keine ist Python null (wie)
Wenn eine Zeichenfolge in einem bedingten Ausdruck verwendet wird, wird sie als "falsch" behandelt, wenn sie leer ist.
s = ""
if not s:
print("s ist leer")
Wenn ein numerischer Wert in einem bedingten Ausdruck verwendet wird, wird er als "falsch" behandelt, wenn er 0 ist.
i = 0
if not i:
print("Ich bin 0")
Wenn ein Array (usw.) in einem bedingten Ausdruck verwendet wird, wird es als "falsch" behandelt, wenn es leer ist.
a = []
if not a:
print("a ist leer")
if Ich habe bereits einen Teil der if-Anweisung geschrieben, schreibe ihn aber wie folgt
wenn Bedingung 1:
print("Bedingung 1 ist wahr")
elif Bedingung 2:
print("Bedingung 1 ist falsch")
print("Bedingung 2 ist wahr")
else:
print("Bedingung 1 ist falsch")
print("Bedingung 2 ist falsch")
else if wird als elif geschrieben.
for Die for-Anweisung wird wie folgt beschrieben.
for i in range(10):
print(i) #0 bis 9 werden der Reihe nach ausgegeben
for i in range(3, 7):
print(i) #3 bis 6 werden der Reihe nach ausgegeben
for i in range(1, 12, 2):
print(i) # 1,3,5,7,9,11 wird der Reihe nach ausgegeben
for s in ["A", "B", "C"]:
print(s) #A, B und C werden der Reihe nach ausgegeben
Eine Python for-Anweisung ist wie eine Java-Erweiterung für Anweisung. Es scheint, dass für Anweisungen nach Index Escape-Bedingungen, Inkremente usw. mit range gut ausgeführt werden.
while Die while-Anweisung funktioniert, wenn Sie sie in derselben Atmosphäre wie zuvor schreiben. Es ist so normal, dass ich kein Beispiel schreibe. Aus irgendeinem Grund gibt es eine Syntax namens while ... else, aber ich weiß nicht, wie ich sie verwenden soll. .. ..
switch-case Es scheint, dass es so etwas nicht gibt.
Es wird als "bedingter Ausdruck" und "bedingter Operator" anstelle des Namens des ternären Operators erklärt.
http://docs.python.jp/3.5/reference/expressions.html#conditional-expressions
for i in range(10):
a = "odd number" if i % 2 else "even number" #Derjenige, der "bedingter Ausdruck" genannt wird
print(str(i) + " is an " + a)
list Erstellen Sie eine Instanz mit Javascript-Kleber
items1 = []
items2 = ["A", "B"]
Hinzufügen oder entfernen
items = ["A", "B"]
items.append("C") #Java-Liste#add
items.extend(["D", "E", "F"]) #Java-Liste#addAll
del items[4] #Java-Liste#remove(int)
items.remove("F") #Java-Liste#remove(Object)
size = len(items) #Java-Liste#size
print("size:" + str(size)) # 4
index2 = items[2] #Java-Liste#get
print("index2:" + index2) # C
idx = items.index(index2) #Java-Liste#indexOf
print("idx:" + str(idx)) # 2
for item in items:
print(item) # A,B,C,Ausgabe D in der richtigen Reihenfolge
items2 = items[:] #Erstellen Sie eine kopierte Listeninstanz
print(items2) # ['A', 'B', 'C', 'D'](EnthältdiegleichenElementewieArtikel)
print(items is items2) #False (eine andere Instanz)
items.insert(0, "INS") #Java-Liste#add(int, Object)
print(items) # ['INS', 'A', 'B', 'C', 'D']
Was ist [:]?
items3 = items[1:3] #Listengenerierung, die den Index 1 bis 2 extrahiert
print(items3) # ['B', 'C']
items4 = items[1:] #Listengenerierung, die die gesamte Rückseite aus Index 1 extrahiert
print(items4) # ['B', 'C', 'D']
items5 = items[:3] #Listengenerierung, die alles vor Index 3 extrahiert
print(items5) # ['A', 'B', 'C']
Es gibt ein Konzept namens iterable "iterable". Ähnlich wie Javas Iterable-Klasse. "Iterable" kann mit Pythons for-Anweisung aktiviert werden. Die Liste ist auch "iterierbar", und die Python-Zeichenfolge (str) ist ebenfalls "iterierbar". Es scheint, dass Sie Ihre eigenen machen können, aber diesmal wird es weggelassen.
Es gibt auch.
t = ("A") # tuple
print(type(t))
d = {"A" : 1} # dict
print(type(d))
s = {"A"} # set
print(type(s))
Ich habe die Details nicht untersucht. Referenz unten http://www.tohoho-web.com/python/list.html
Es kann entweder in einfachen oder doppelten Anführungszeichen ausgedrückt werden.
s1 = "I am a beginner"
s2 = 'I am a beginner'
Ich weiß nicht, welches häufiger vorkommt, aber das Gefühl, das ich suche, sind doppelte Anführungszeichen?
Es gibt auch eine Technik mit drei Anführungszeichen.
s = """Python und
Oh Python
Python und"""
print(s)
Ergebnis
Python und
Oh Python
Python und
Verwenden Sie +.
Es gibt keine implizite Besetzung. Verwenden Sie daher Folgendes.
Verwenden Sie str.
i = 10
print("Numerischer Wert zur Zeichenfolge" + str(i))
print("Verketten Sie Zeichenfolgen und Zahlen" + i) #Error
Wenn Sie eine Methode namens "str" erstellen, wird diese aufgerufen, wenn sie in eine Zeichenfolge konvertiert wird.
Die Atmosphäre der Rolle der toString-Methode in Java, wobei __str__ ist (kann nicht direkt aufgerufen werden).
Schreiben Sie def, um es zu definieren.
#Methode definiert durch def
def method1():
print("foo")
#Argumente sind in Klammern angegeben
def method2(arg1, arg2):
print(arg1)
print(arg2)
#Der Rückgabewert wird bei Rückgabe zurückgegeben
def method3():
return "bar"
Wenn Sie sich nicht sicher sind, können Sie es normal übergeben, aber es gibt auch eine seltsame Art des Übergebens (nicht in Java).
def method2(arg1, arg2):
print("---")
print(arg1)
print(arg2)
if __name__ == '__main__':
method2("A", "B") #Gewöhnlich
method2(arg1="A", arg2="B") #Sie können es auch so übergeben (Schlüsselwortargument)
method2(arg2="B", arg1="A") #In diesem Fall scheint die Reihenfolge zufällig zu sein
method2(*["A", "B"]) #Übergeben Sie ein Array
method2(**{"arg2":"B", "arg1":"A"}) #Vorbei diktieren
Die Ergebnisse sind alle gleich
So etwas wie C ++.
#Für das Argument kann ein Standardwert definiert werden. Wenn beim Aufruf ein Argument vorhanden ist, arg2"DefaultArg"Eingeben
def method4(arg1, arg2 = "DefaultArg"):
print("---")
print(arg1)
print(arg2)
if __name__ == '__main__':
method4("A", "B")
method4("A") #Verwenden Sie die Standardeinstellung für das zweite Argument
Ergebnis
---
A
B
---
A
DefaultArg
Unter der Annahme, dass ein Dikt verabschiedet wird, scheint es, dass das erste Argument auch das Standardargument sein kann, aber das scheint unmöglich
def method5(arg1 = "DefaultArg", arg2):
print(arg1)
print(arg2)
Syntax-Fehler
Es gibt eine Methode zum Akzeptieren mit Tupeltyp und eine Methode zum Akzeptieren mit Diktat
# *Ist ein Argument variabler Länge, das der Tupeltyp akzeptiert
def method_variadic_tuple(arg1, *others): #Andere ist ein Argument variabler Länge vom Typ Tupel
print("---" )
print("Erstes Argument:" + arg1)
print("Argument variabler Länge:" + str(others))
print("Variable Länge Argumentlänge:" + str(len(others)))
if __name__ == '__main__':
method_variadic_tuple("A")
method_variadic_tuple("A", "B")
method_variadic_tuple("A", "B", "C")
method_variadic_tuple("A", *("B", "C")) #Es ist auch möglich, es direkt mit Tupel zu übergeben
method_variadic_tuple("A", *["B", "C"]) #Liste ist auch OK
method_variadic_tuple(*("A", "B", "C")) #Alle Tupel können übergeben werden
Ergebnis
---
Erstes Argument:A
Argument variabler Länge:()
Variable Länge Argumentlänge:0
---
Erstes Argument:A
Argument variabler Länge:('B',)
Variable Länge Argumentlänge:1
---
Erstes Argument:A
Argument variabler Länge:('B', 'C')
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:('B', 'C')
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:('B', 'C')
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:('B', 'C')
Variable Länge Argumentlänge:2
# **Ist ein Argument variabler Länge, das als Diktattyp akzeptiert wird
def method_variadic_dict(arg1, **others): #Andere sind Argumente mit variabler Länge vom Typ dikt
print("---" )
print("Erstes Argument:" + arg1)
print("Argument variabler Länge:" + str(others))
print("Variable Länge Argumentlänge:" + str(len(others)))
if __name__ == '__main__':
method_variadic_dict("A")
method_variadic_dict("A", d1="B") #diktieren Sie das Argument mit variabler Länge, das so übergeben wurde
method_variadic_dict("A", d1="B", d2="C")
method_variadic_dict(arg1="A", d1="B", d2="C") #Wenn Sie den Typ dict verwenden, auch das erste Argument=Die verwendete Notation ist sauberer
method_variadic_dict(d1="B", arg1="A", d2="C") #In diesem Fall ist das erste Argument auch in der Mitte in Ordnung
method_variadic_dict("A", **{"d1":"B", "d2":"C"}) #Es ist auch möglich, direkt mit Diktat zu bestehen
method_variadic_dict(**{"arg1":"A" , "d1":"B", "d2":"C"}) #Das erste Argument kann auch diktiert werden.
# method_variadic_dict(*["A", {"d1":"B", "d2":"C"}]) #Ist es wirklich unmöglich, ein Array zu übergeben?
Ergebnis
---
Erstes Argument:A
Argument variabler Länge:{}
Variable Länge Argumentlänge:0
---
Erstes Argument:A
Argument variabler Länge:{'d1': 'B'}
Variable Länge Argumentlänge:1
---
Erstes Argument:A
Argument variabler Länge:{'d1': 'B', 'd2': 'C'}
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:{'d1': 'B', 'd2': 'C'}
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:{'d1': 'B', 'd2': 'C'}
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:{'d1': 'B', 'd2': 'C'}
Variable Länge Argumentlänge:2
---
Erstes Argument:A
Argument variabler Länge:{'d1': 'B', 'd2': 'C'}
Variable Länge Argumentlänge:2
Deklarieren Sie den Klassenklassennamen (Vererbungsquelle).
Wenn Sie die Eclipse-Vorlage verwenden, wird sie wie folgt geschrieben.
class MyClass(object):
'''
classdocs
'''
def __init__(self, params):
'''
Constructor
'''
__init__
Wie Sie bereits aus dem Kommentar (docstring) sehen können, wird der Konstruktor durch Schreiben von "init" definiert.
Das Argument "self" ist Ihre eigene Instanz und schreibt die Parameter, die Sie akzeptieren möchten, danach in den Konstruktor.
if __name__ == '__main__':
obj = MyClass("param") #Streit"param"Generieren Sie MyClass mit und weisen Sie es obj zu
Wenn sich die Feldvariable innerhalb der Instanz befindet, können Sie eine Variable erstellen, indem Sie ihr den Namen "self.field name" zuweisen. Weisen Sie von außen eine Variable zu, in der der Name des Instanzfelds normal gespeichert ist.
Die Methode wird entsprechend der Klasse eingerückt und mit def definiert.
Das erste Argument (ähnlich wie "init") ist "self".
Wenn Sie von außen anrufen, geben Sie ein Argument ohne "Selbst" an und rufen Sie an.
class MyClass(object):
def __init__(self, param):
self.field1 = "field1" # self.Wenn Sie es einem Feldnamen zuweisen, wird es zu einer Feldvariablen.
print("init param:" + param)
def foo(self, param): #Instanzmethode
self.field2 = "field2" #Feldvariablen können jederzeit erstellt werden
print("foo param:" + param)
if __name__ == '__main__':
obj = MyClass("A")
print(obj.field1)
obj.foo("B")
print(obj.field2)
obj.field3 = "field3" #Sie können Feldvariablen von außen erstellen
print(obj.field3)
Ergebnis
init param:A
field1
foo param:B
field2
field3
Express durch Benennung.
Referenz: http://docs.python.jp/3.5/reference/lexical_analysis.html#reserved-classes-of-identifiers http://docs.python.jp/3.5/tutorial/classes.html#tut-private
Wenn Sie am Anfang zwei Unterstriche hinzufügen, ist dieser privat. (Genau genommen gibt es eine Möglichkeit, darauf zuzugreifen, sodass es möglicherweise nicht als privat bezeichnet wird.) Namen mit zwei Unterstrichen, z. B. "hoge", gelten jedoch für Python-Systeme. Geben Sie ihnen daher keinen neuen.
Aus Gewohnheit scheint ein Unterstrich auch nicht öffentlich zu sein.
class MyClass(object):
def foo(self): # public
print("foo" )
def _foo(self): #Nicht öffentlich als Gewohnheit
print("_foo" )
def __foo(self): # private
print("__foo" )
def call_private_foo(self): # __Methode zum Aufrufen von foo
self.__foo() #Private Methoden können aufgerufen werden
if __name__ == '__main__':
obj = MyClass()
obj.foo()
obj._foo()
# obj.__foo() #Kann nicht angerufen werden
obj.call_private_foo()
obj._MyClass__foo() #Genau genommen gibt es eine Möglichkeit, darauf zuzugreifen. ""_Es wurde durch "Klassenname + Methodenname" ersetzt. Es wird jedoch nicht im Speicher von Eclipse angezeigt
Ergebnis
foo
_foo
__foo
__foo
Wenn Sie den als (Objekt) geschriebenen Teil in die Klasse ändern, die Sie erben möchten, können Sie ihn vorerst erben.
Es scheint, dass Mehrfachvererbung möglich ist, aber ich habe nicht das Gefühl, dass ich es als Anfänger beherrschen kann, also werde ich es diesmal weglassen.
Der Konstruktor der übergeordneten Klasse wird nicht nur durch Erben aufgerufen. Rufen Sie es auf, indem Sie "super (eigene Klasse, selbst). Methodenname ()" schreiben, wie unten gezeigt.
class AbsMyClass(object):
def __init__(self):
print("AbsMyClass__init__Hieß")
class MyClass(AbsMyClass):
def __init__(self):
super(MyClass, self).__init__() #Vererbungsquelle__init__Anruf
print("MyClass__init__Hieß")
if __name__ == '__main__':
obj = MyClass()
Ergebnis
AbsMyClass__init__Hieß
MyClass__init__Hieß
Sie können vermeiden, die übergeordnete Klasse "init" aufzurufen, das Timing ist beliebig, Sie können sie so oft aufrufen, wie Sie möchten, und es gibt keine Freiheit. Ich bin neu in Python, daher vergesse ich oft zu schreiben und bin süchtig danach.
Eclipse ergänzt und schreibt. Die Syntax wird weggelassen.
Ich habe [Python Beginner's Memo (Teil 2)] geschrieben (http://qiita.com/ota-meshi/items/e28900e85fa8f25daf30).
Recommended Posts