Eine persönliche Notiz beim Schreiben von Python. Hauptsächlich beim Lernen auf der folgenden Seite. http://www.tohoho-web.com/python/index.html
python.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#Siehe unten
# http://docs.python.jp/3/library/functions.html
# http://www.tohoho-web.com/python/index.html
# http://docs.python.jp/3.5/
print("In Python scheint ein Fehler aufzutreten, wenn Sie den Zeichencode am Anfang nicht schreiben")
"""
Mehrzeiliger Kommentar
Ursprünglich ist es ein Zeichenfolgenliteral, aber es scheint, dass es auch als Kommentar verwendet wird
"""
print("\n\n----------")
print("○ importieren und drucken")
import random
num = random.randint(1,10)
print("num ist"+str(num))
print("\n\n----------")
print("○ if-Anweisung")
if num == 1:
print("num ist 1")
elif num < 5:
print("num ist 5 oder weniger")
else:
print("Andere")
print("\n\n----------")
print("○ while-Anweisung")
n = 0
while n < 3:
print("while "+str(n))
n += 1
else:
print('while END')
print("Wenn Sie else in die while-Anweisung schreiben, wird else ausgeführt, wenn die while-Bedingung nicht erfüllt ist und die Nachricht beendet wird.")
print("Es wird auch dann ausgeführt, wenn die Bedingungen von Anfang an nicht erfüllt sind.")
print("Wenn es aufgrund eines Bruchs usw. bricht, wird es nicht ausgeführt.")
print("\n\n----------")
print("○ für Satz")
for n in [1, 2, 3]:
print(n) # => 1, 2, 3
else:
print("END")
for n in (1, 2, 3):
print(n) # => 1, 2, 3
for k,v in {'one': 1, 'two': 2, 'three': 3}.items():
print(str(k)+":"+str(v)) # => one:1, two:2, three:3
for c in "123":
print(c) # => 1, 2, 3
for line in open("data.txt"):
print(line) # =>Zeile für Zeile anzeigen
for n in range(3,6):
print(n) # => 3, 4, 5
for c in 'AIUEO':
print(c) # =>Ah,ich,U.,e,Oh
print("Sie können auch else in die for-Anweisung schreiben.")
print("Die Bedeutung ist die gleiche wie während.")
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else:
# loop fell through without finding a factor
print(n, 'is a prime number')
print("\n\n----------")
print("○ printf-ähnliche Methode")
errmsg = "String"
errcode = 12
msg = "Sie können beim Erstellen eines Strings so etwas wie printf ausführen[%s](%d)" % (errmsg, errcode)
print(msg)
print("%(name)s is %(age)d years old." % {'age': 28, 'name': "Tanaka"})
print("\n\n----------")
print("○ Liste und für Anweisung")
a = [1, 2, "AAA", 4, (1+3j)*(2+2j)]
print('Die dritte Zählung von 0'+str(a[3])) # => 4
print("1. bis 2 ..(Nr. 3 ist nicht enthalten)Mit Scheiben"+str(a[1:3])) # => [2, 'AAA']
print("Sie können den Anfang und das Ende weglassen. Bis zur Sekunde"+str(a[:3])) # => [1, 2, 'AAA']
print("Es können auch negative Werte verwendet werden. Von hinten bis zum zweiten(Die zweite selbst ist jedoch nicht enthalten)Ist"+str(a[:-2])) # => [1, 2, 'AAA']
print("Schrittweite(Schritt)Kann auch geändert werden"+str(a[0:1:2])) # => [1, 'AAA']
print("Für die Schrittgröße können negative Werte verwendet werden"+str(a[::-1])) # => [(-4+8j), 4, 'AAA', 2, 1]
print("Sie können den Wert auch ändern")
print("Vorher ändern:"+str(a)) # => [1, 2, 'AAA', 4, (-4+8j)]
a[1]=999
print("Nach der veränderung:"+str(a)) # => [1, 999, 'AAA', 4, (-4+8j)]
print("Sie können auch hinzufügen.")
a.append(777)
print("Nach der veränderung:"+str(a)) # => [1, 999, 'AAA', 4, (-4+8j), 777]
for n in a:
print("[zur Aussage]"+str(n)+"Korrekt")
print("Liste beitreten" + str([1, 2, 3] + [4, 5, 6])) # => [1, 2, 3, 4, 5, 6]
print("len()Finden Sie die Länge mit"+str(len([1, 2, 3]))) # => 3
a = [[1, 2], [3, 4], [5, 6]]
a.append([7,8])
print("Mehrere Listen sind ebenfalls in Ordnung"+str(a)) # => [[1, 2], [3, 4], [5, 6], [7, 8]]
for line in a:
for n in line:
print(str(n)+" ", end="")
print("") # => 1 2
# 3 4
# 5 6
# 7 8
print("a[2][1]Ist"+str(a[2][1])) # => 6
print("\n\n----------")
print("○ Taple")
a = (11,22,33,)
print("Es gibt eine Festwertversion der Liste"+str(a))
print("Zuerst von 0 zählen"+str(a[1])) # => 22
#a[1]=12 # =>Error
print("\n\n----------")
print("○ Wörterbuch")
d = {'Yamada': 30, 'Suzuki': 40, 'Tanaka': 80}
print("Wörterbuch(Assoziatives Array)Es gibt auch"+str(d))
print("Yamada"+str(d["Yamada"]))
for key,val in d.items():
print("[zur Aussage]"+key+"Ist"+str(val))
print("\n\n----------")
print("○ Funktion")
def doublefunc(x):
return x * 2
print("Multiplizieren Sie 7 mit doppelter Funktion"+str(doublefunc(7))) # => 14
a = [1, 2, 3]
print(str(a)+"Funktion verdoppeln"+str(doublefunc(a))) # => [1, 2, 3, 1, 2, 3]
print("\n\n----------")
print("○map")
print("map gibt das Ergebnis der Verarbeitung jedes Elements einzeln zurück")
print("・ Funktionsmethode")
print(map(doublefunc, a)) # => map object
print(list(map(doublefunc, a))) # => [2, 4, 6]
print("・ Lammmethode")
print(map(lambda x: x * 2, a)) # => map object
print(list(map(lambda x: x * 2, a))) # => [2, 4, 6]
print("・ Inklusive Notation")
print([x * 2 for x in a]) # => [2, 4, 6]
print("○filter")
print("filter verarbeitet jedes Element einzeln und gibt nur das wahre zurück")
a = [1, 2, 3]
def kisuucheck(x): return x % 2
print("・ Funktionsmethode")
print(filter(kisuucheck, a)) # => filter object
print("Die seltsamen"+str(list(filter(kisuucheck, a)))) # => [1, 3]
print("・ Lammmethode und Einschlussnotation entfallen")
print("○reduce")
print("Reduzieren Sie Prozesse das erste und zweite Element, verarbeitet das Ergebnis und das dritte und so weiter.")
print("Aber wahrscheinlich, weil es nicht viel verwendet wird, kann es erst nach dem Import in Python3 verwendet werden")
from functools import reduce
a = [1, 2, 3, 4, 5]
def add(x, y): return x + y
print(reduce(add, a)) # => 15 :Funktionsmethode
print(reduce(lambda x, y: x + y, a)) # => 15 :Lambda-Methode
print("○ Einschlussnotation")
a = [1, 2, 3]
print([x * 2 for x in a]) # => [2, 4, 6]
print([x * 2 for x in a if x%2==1]) # => [2,6]
print([[x, x * 2] for x in a]) # => [[1, 2], [2, 4], [3, 6]]
print([(x, x * 2) for x in a]) # => [(1, 2), (2, 4), (3, 6)]
a = [[1, 2], [3, 4], [5, 6]]
print([[x[0]*2,x[1]*3] for x in a]) # => [[2, 6], [6, 12], [10, 18]]
print("○ Einstellen")
print("einstellen(set)Ist eine eindeutige Liste")
a = set(['red', 'blue', 'green'])
b = set(['green', 'yellow', 'white'])
print("setze a ist"+str(a)) # => set(['red', 'blue', 'green'])
print("Satz b ist"+str(b)) # => set(['green', 'yellow', 'white'])
print("a-b ist"+str(a-b)) # => set(['red', 'blue'])
print("a|b ist"+str(a|b)) # => set(['red', 'blue', 'green', 'yellow', 'white'])
print("a&b ist"+str(a&b)) # => set(['green'])
print("a^b ist"+str(a^b)) # => set(['red', 'blue', 'yellow', 'white'])
print("'green'in a ist"+str('green' in a)) # => True
a.add('black')
print("Nach dem Hinzufügen von Schwarz zu a"+str(a)) # => set(['red', 'blue', 'green', 'black'])
a.add('black')
print("Wenn Sie a schwarz hinzufügen"+str(a)) # => set(['red', 'blue', 'green', 'black'])
print("\n\n----------")
print("○ Beachten Sie, dass der Name der integrierten Funktion nach der Reservierung überschrieben werden kann.")
print("list([1,2])Ist"+str(list([1,2]))) # => [1,2]
list_temp = list
list = doublefunc
print("list([1,2])Ist"+str(list([1,2]))) # => [1,2,1,2]
list = list_temp
print("list([1,2])Ist"+str(list([1,2]))) # => [1,2]
print("\n\n----------")
print("○ Ausnahmebehandlung")
mystring = 'ABC'
try:
c = mystring[5] #Ich erhalte eine IndexError-Ausnahme, weil ich nicht das 5. Zeichen habe
except IOError:
print('IOError') #Im Falle einer IOError-Ausnahme wird dieser Block ausgeführt
except IndexError:
print('IndexError') #Im Falle einer IndexError-Ausnahme wird dieser Block ausgeführt
except:
print('Unknown') #Für andere als die oben genannten Ausnahmen wird dieser Block ausgeführt
else:
print('Error not occur') #Wenn keine Ausnahme ausgelöst wird, wird dieser Block ausgeführt
finally:
print('Finally') #Dieser Block wird immer ausgeführt
try:
f = open('sample.txt', 'r')
except:
print('cannot open sample.txt')
else:
lines = f.readlines()
try:
raise SystemError("Sorry, my fault!")
except SystemError as e:
print("SystemError")
print(e)
print("\n\n----------")
print("○with")
print("Wenn Sie mit verarbeiten, wird das Objekt automatisch beendet.")
#Wie schreibe ich ohne mit
f = open("data.txt")
print(f.read())
f.close()
#Wie schreibe ich mit 1
with open("data.txt") as f:
print(f.read())
#Schreiben mit mit 2
f = open("data.txt")
with f:
print(f.read())
print("\n\n----------")
print("○pass")
print("pass macht nichts, wird beim Erstellen einer leeren Funktion usw. verwendet.")
def myfunc():
pass
class MyClass:
pass
print("\n\n----------")
print("○del")
print("del löscht das Objekt")
x = 5
y = [1, 2, 3]
z = MyClass()
del x, y, z
print("\n\n----------")
print("○ In eine Datei mit Drucken drucken")
f = open("gomi.txt", "a")
print("Hello world!", file=f)
f.close()
print("\n\n----------")
print("○exec")
print("Sie können eine Zeichenfolge mit exec ausführen")
exec("print('hello')")
print("\n\n----------")
print("○ Funktion")
print("Funktionsargumente können auch namentlich übergeben werden")
print("Es bestimmt auch den Standardwert für das Argument")
def repeat_msg(msg, repeat=2, a=1):
for i in range(repeat):
print(msg+" a="+str(a))
repeat_msg('Hello') # => Hello a=1, Hello a=1
repeat_msg('Yahho', a=5) # => Yahho a=5, Yahho a=5
print("Sie können auch so etwas wie argv in c-Sprache ausführen")
def func(a1, a2, *args, **params):
print(a1) # => A
print(a2) # => B
print(args) # => ('C', 'D')
print(params) # => {'k1': 'K1', 'k2': 'K2'}
func('A', 'B', 'C', 'D', k1='K1', k2='K2')
args = ('C', 'D')
params = {'k1': 'K1', 'k2': 'K2'}
func('A', 'B', args, params) # => A, B, (('C', 'D'), {'k2': 'K2', 'k1': 'K1'}), {}
func('A', 'B', *args, **params) # => A, B, ('C', 'D'), {'k1': 'K1', 'k2': 'K2'}
print("Sie können auch mehrere Werte zurückgeben")
def func():
return 3, "ABC"
n, s = func()
print(n, s) # => 3 ABC
print("\n\n----------")
print("○ Globale Variablen")
print("Globale Variablen können normalerweise nicht innerhalb einer Funktion referenziert oder geändert werden")
print("Sie können es ändern, indem Sie es als global deklarieren")
count = 0 #Globale Variablen
def func():
global count #Ohne das kannst du dich nicht ändern
print(count) #Kann referenziert werden
count += 1
print(count)
func()
print("Alle globalen und lokalen Variablen sind global()Und Einheimische()Sie können es bei bekommen")
def func():
for k in globals().keys():
print("GLOBAL: %s = %s" % (k, globals()[k]))
for k in locals().keys():
print("LOCAL: %s = %s" % (k, locals()[k]))
func()
print("\n\n----------")
print("○ Lambda-Typ")
print("Lambda-Ausdrücke sind kleine, unbenannte Funktionen.")
print("Das Argument steht vor dem Doppelpunkt und der Rückgabewert danach.")
myfunc = lambda x, y: x + y
print(myfunc(3, 5)) # => 8
print("\n\n----------")
print("○ Iterator")
print("Iterator ist ein Objekt mit einer Wiederholungsfunktion, die in der for-Anweisung verwendet werden kann")
print("__init__()Schreiben Sie den Vorgang am Anfang nur einmal")
print("__iter__()Gibt das Objekt zurück")
print("__next__()Gibt das nächste Element mit StopIteration-Ausnahme zurück, wenn es das Ende erreicht")
class Fib:
def __init__(self, max):
self.max = max
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
fib = self.a
if fib > self.max:
raise StopIteration
self.a, self.b = self.b, self.a + self.b
return fib
for n in Fib(3):
print(n) # => 0, 1, 1, 2, 3
print("Das Obige führt das Folgende automatisch aus")
it = Fib(3).__iter__()
while 1:
try:
n = it.__next__()
print(n) # => 0, 1, 1, 2, 3
except StopIteration:
break
print("\n\n----------")
print("○ Generator")
print("Es wird berechnet, wann das nächste Element verwendet wird, sodass die Speicher- und Verarbeitungseffizienz im Vergleich zum Erstellen und Übergeben eines Arrays anscheinend verbessert wird.")
def funcB(list):
for n in list:
yield n * 2
for n in funcB([1, 2, 3, 4, 5]):
print(n) #=> 2, 4, 6, 8, 10
def readfileB(f):
for line in f:
yield line.rstrip()
f = open("data.txt")
for line in readfileB(f):
if (line == "__END__"):
break
print(line)
f.close()
print("\n\n----------")
print("○ Dekorateur")
print("Die Verarbeitung kann vor und nach der Funktionsausführung hinzugefügt werden")
def mydecolater(func):
import functools
@functools.wraps(func)
def wrapper(*args, **kwargs):
print("Funcname:", func.__name__)
print("Arguments:", args)
print("Keywords:", kwargs)
ret = func(*args, **kwargs)
print("Return:", ret)
return ret
return wrapper
@mydecolater
def func(msg1, msg2, flag=1, mode=2):
"""A sample function"""
print("----", msg1, msg2, "----")
return 1234
n = func("Hello", "Hello2", flag=1)
print(n)
print(repr(func))
print(func.__doc__)
print("\n\n----------")
print("○ Klasse")
class MyClass(object):
"""A simple example class""" #Kommentar von Mie Quart
PI=3.14 #Klassenvariable
def __init__(self): #Konstrukteur
self.name = "" #name ist eine Instanzvariable
def getName(self): # getName()Methode
return self.name
def setName(self, name): # setName()Methode
self.name = name
a = MyClass() #Erstellen Sie eine Instanz der Klasse
a.setName("Tanaka") # setName()Methode aufrufen
print(a.getName()) # getName()Methode aufrufen
print("Python implementiert keinen Bereichssteuerungsmechanismus wie "privat" oder "geschützt", und auf Klassenvariablen und Instanzvariablen kann von überall aus verwiesen werden.(public)Es wird sein.")
print("Klassenvariablen und Instanzvariablen können direkt umgeschrieben werden")
MyClass.PI=3.141592
a.name="Tanaka2"
print("Kann dynamisch hinzugefügt werden")
MyClass.myPI=3
a.age=18
print("Wenn die Instanzvariable nicht vorhanden ist, "Instanz".Beachten Sie, dass sich "Variablenname" auf eine Klassenvariable bezieht.")
print(a.PI) #Da es keine Instanzvariable namens PI gibt, wird auf die Klassenvariable verwiesen.
print(""Beispiel.Eine Instanzvariable wird generiert, wenn "Variablenname" ein Wert zugewiesen wird, und danach wird auf die Instanzvariable verwiesen.")
a.PI=333 #Eine Instanzvariable PI kann getrennt von der Klassenvariablen PI erstellt werden.
print(a.PI) # =>333 Instanzvariablen
print(MyClass.PI) # => 3.141592 Klassenvariablen
print("dir()Wenn Sie verwenden, wird es auf verschiedene Arten angezeigt")
print("MyClass : "+str(dir(MyClass)))
print("MyClass : "+str(dir(a)))
print("\n\n----------")
print("○ Private Variablen")
class MyClass2(object):
_hidden_param=12
__hidden_param2=34
print("Es gibt eine übliche Regel, dass auf Variablen in einer Klasse, die am Anfang einen Unterstrich haben, nicht von außen zugegriffen werden darf. Aber Sie können darauf zugreifen.")
print("2 Wenn Sie darauf stoßen, können Sie in der Klasse normal darauf zugreifen, es ist jedoch schwierig, von außen darauf zuzugreifen. Der Name hat sich leicht geändert. "_Name der Klasse__Es wird "Variablenname".")
print("MyClass2._hidden_param="+str(MyClass2._hidden_param))
#print("MyClass2._hidden_param="+str(MyClass2.__hidden_param2)) #← Dies ist ein Fehler
print("MyClass2._hidden_param="+str(MyClass2._MyClass2__hidden_param2)) #← Das ist OK
print("\n\n----------")
print("○ Konstruktor, Destruktor und String")
class MyClass3(object):
def __init__(self, name):
self.name = name
print("welcome "+str(self.name))
def __str__(self):
return "name is "+self.name
def __del__(self):
print("byebye "+str(self.name))
a = MyClass3("Tanaka")
print(a) # __str__Die als definierte Methode wird automatisch aufgerufen.
del(a)
print("\n\n----------")
print("○ Vererbung")
class MyClass:
def hello(self):
print("Hello")
class MyClass2(MyClass):
def world(self):
print("World")
a = MyClass2()
a.hello() #=> Hello
a.world() #=> World
print("Methodenüberschreibung")
class MyClass:
def hello(self):
print("Hello")
class MyClass2(MyClass):
def hello(self): #Elternklasse Hallo()Methode überschreiben
print("HELLO")
a = MyClass2()
a.hello() #=> HELLO
print("super")
class MyClass1(object):
def __init__(self):
self.val1 = 123
def pripri(self):
print("print1")
class MyClass2(MyClass1):
def __init__(self):
super(MyClass2, self).__init__()
self.val2 = 456
def pripri(self):
super(MyClass2, self).pripri()
print("print2")
a = MyClass2()
print(a.val1) #=> 123
print(a.val2) #=> 456
a.pripri()
print("Mehrfachvererbung")
class MyClassA:
def funcA(self):
print("MyClassA:funcA")
class MyClassB:
def funcB(self):
print("MyClassB:funcB")
class MyClassC(MyClassA, MyClassB):
def funcC(self):
print("MyClassC:funcC")
a = MyClassC()
a.funcA() #MyClassA-Methoden auch
a.funcB() #Sie können auch MyClassB-Methoden verwenden
a.funcC()
print("\n\n----------")
print("○ Modul")
import mymodule
mymodule.myfunc()
print("Für Pakete weggelassen.")
print("Dateiname"+str(__file__))
print("__name__Sie können den Modulnamen mit anzeigen. Wenn per Skript gestartet__main__Wird sein. str(__name__)="+str(__name__))
print("\n\n----------")
print("○pprint")
print("Verwenden Sie pprint, um Informationen wie Arrays leicht lesbar anzuzeigen")
from pprint import pprint
aaa = [0, 1, 2]
ppp = {'taro':{'age': '21', 'name': 'tanaka'}, 'jiro':{'age': '18', 'name': 'tanaka2'},}
pprint(aaa) #=> [0, 1, 2]
pprint(ppp) #=> {'jiro': {'age': '18', 'name': 'tanaka2'},
# 'taro': {'age': '21', 'name': 'tanaka'}}
import os
print("Der aktuelle Pfad ist"+os.getcwd())
print("\n\n----------")
print("○ Zum Debuggen drucken")
print("Wenn Sie es nur beim Debuggen anzeigen möchten, gehen Sie wie folgt vor(Ich weiß nicht, ob es ein guter Weg ist)。")
def null_function(x):
return
myprint=null_function
#myprint=print
myprint("hoge")
print("\n\n----------")
print("○ Teilweise Änderung der Zeichenfolge")
print("Text wie C-Sprache[2]='x'Usw. kann nicht verwendet werden.")
print("weil str unveränderlich ist")
print("Konvertieren Sie es in eine Liste und ändern Sie es dann oder bearbeiten Sie es mit Slices.")
print("Referenz: http://minus9d.hatenablog.com/entry/20130528/1369745960")
text="test string"
#text[2]='S'#Das ist NG
temp=list(text)
temp[2]='S'
text="".join(temp)
print(text) #=> "teSt string"
print("\n\n----------")
print("○ Übergeben von Argumenten nach Wert und Referenz")
print("Funktionsargumente können als Wert oder als Referenz übergeben werden.")
print("Ähnlich wie in der C-Sprache, int,float etc. werden nach Wert, Liste übergeben,Dikt usw. werden als Referenz übergeben.")
print("Aber str wird als Wert übergeben.")
print("Referenz: http://amacbee.hatenablog.com/entry/2016/12/07/004510")
def func1(x):
x[1]=999
y=[0,1,2]
print(y) #=> [0, 1, 2]
func1(y)
print(y) #=> [0, 999, 2]
print("\n\n----------")
print("○ Stoppen Sie die Skriptdatei in der Mitte und aktivieren Sie die Eingabe")
import code; code.InteractiveConsole(locals=dict(globals(),**locals())).interact()
mymodule.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#Modul
def myfunc():
print("Hello!")
Recommended Posts