Notizen für 3 Monate, seit ich Python gestartet habe

Ein Hinweis auf gute Techniken, die man als Stolperstein für Anfänger kennen sollte

Dreiecksoperator

Formel: (Variable) = (Wert, wenn Bedingung wahr ist) if (Bedingung) else (Wert, wenn Bedingung falsch ist)

score = 100
result = "good" if score > 80 else "bad"
print(result) # good

else

Es scheint, dass der Zeitpunkt, zu dem die Schleifenverarbeitung beendet ist, genommen werden kann

`while`


i = 0
while i < 3:
    print(i)
    i += 1
else:
    print("while, end")

`for`


for i in range(3):
    print(i)
else:
    print("for, end")

pass

nichts tun. Verwenden Sie diese Option, wenn Sie nur den äußeren Rahmen grob festlegen möchten

def say_hello():
    pass
print(say_hello()) # None

Referenz Verwendung der Python-Pass-Anweisung

format

Klüger, wenn Sie es verwenden können, wenn mehrere Casts wie "str (1)" fortgesetzt werden

text = 'name -> {0:>10s}\nscore -> {1:<10.2f}'.format('sato',30.2)
# name ->Anzeigebreite:10, s:string, >:Richtig gerechtfertigt
# score ->Anzeigebreite:10,2 Stellen nach dem Komma, f:float, >:Links gerechtfertigt
print(text)
# name ->       sato
# score -> 30.20

↓ Dies ist auch praktisch

`Füllen Sie mit Nullen, indem Sie die Anzahl der Ziffern angeben`


print('{:05}'.format(255)) # 00255
print('{:08}'.format(255)) # 00000255

Umfang

Umgang mit globalen Variablen innerhalb einer Funktion

`Fehler, wenn Sie beim Zuweisen nicht global deklarieren`


x = 5 
def add():
    global x #Kann ohne Deklaration nicht umgeschrieben werden
    x += 1
add() 
print(x)

`Sie benötigen keine globale Deklaration, wenn Sie nur darauf verweisen möchten ...`


#Es ist einfacher zu verstehen, wenn Sie global deklarieren, indem Sie sich nur darauf beziehen
x = 5 
def print_x():
    print(x)
print_x()

Um Nebenwirkungen zu vermeiden, ist es jedoch am besten, nicht so weit wie möglich von der Funktion aus auf globale Variablen zuzugreifen.

`Gute Form als Argument zu übergeben`


x = 5 
def add(x):
    x += 1
    return x
x = add(x) 
print(x)

aufführen

`Fallstricke auflisten`


x = ["a", "b", "c"]
y = x.append("d")
print(x) # ['a', 'b', 'c', 'd']Variablen werden ersetzt
print(y) #Keine Rückgabe ist Keine

`Für Saiten`


x = "abcdef"
y = x.upper()
print(x) #abcdef Variable wie sie ist
print(y) #ABCDEF gibt eine Zeichenfolge zurück

Objekttyp	Variablen nach Ausführung der Methode	Was die Methode zurückgibt
String	Variabel wie es ist	String
aufführen	Variablen werden ersetzt	None

Listeneinschlussnotation

Grenzen Sie diejenigen ein, die den Bedingungen entsprechen | if

Bild, das Karte und Filter gleichzeitig verarbeiten kann Wenn die if-Anweisung True ist, wird die Liste erstellt.

`Extrahieren Sie Namen, die e enthalten, und verringern Sie sie`


users = ["Yo", "Ken", "Nao", "Shin", "Lee"]
users = [u.lower() for u in users if u.find("e") != -1]
print(users) # ['ken', 'lee']

Mehrere Listen gleichzeitig schleifen | zip

`Zerlegen Sie "Aiueo ..." und stellen Sie es wieder her`


str_ = list('Aiue Okakikuke Kosashi Suseso')
a = str_[::2] #Das zweite, was von Anfang bis Ende herauskam=Indexnummer ist gerade (einschließlich 0)
b = str_[1::2] #Der zweite von 1 bis zum Ende=Die Indexnummer ist ungerade
print(a) # ['Ah', 'U.', 'Oh', 'Ki', 'Ke', 'Sa', 'Su', 'Damit']
print(b) # ['ich', 'e', 'Oder', 'Ku', 'Dies', 'Shi', 'einstellen']
#Trennzeichenfolge.join(Reihenfolge)
moto = "".join([ _a + _b for _a,_b in zip(a,b) ])
print(moto) #Aiue Okakikuke Kosashi

https://docs.python.jp/3/library/functions.html#zip

Set / Wörterbuch

set => Keine Duplikate, keine Reihenfolge, Suche nach Hash

dictionary => Mehrwert für die Verwendung von Hash im Set

s = {1,2,3,4,5}
print(type(s)) # <class 'set'>

d = {} #Beachten Sie, dass es sich um ein Wörterbuch handelt, wenn es leer ist.
print(type(d)) # <class 'dict'>

Mathematische Arithmetik der Menge

colors1 = {"white","black","red","green"}
colors2 = {"white","black","yellow"}
#Differenz einstellen
print(colors1 - colors2) # {'green', 'red'}
#Ob es im Set enthalten ist
print("blue" in colors2) # False
#Gesamtsumme
colors3 = colors1 | colors2
print(colors3) # {'white', 'green', 'red', 'black', 'yellow'}
#allgemeiner Teil
colors4 = colors1 & colors2
print(colors4) # {'black', 'white'}

Argument mit variabler Länge und Schlüsselwortargument

Taple und Wörterbuchtyp

Beschreibung	Empfangsart
*	Taple
**	Wörterbuchtyp

#Behalten Sie die Reihenfolge der Argumente variabler Länge und der Schlüsselwortargumente bei
def print_args_kwargs(*args, **kwargs):
    print(args) # (1, 2, 3)
    print(kwargs) # {'age': 25, 'name': 'sato'}
print_args_kwargs(1,2,3, age=25, name='sato')

Wörterbuch der Schlüsselwortargumente

`Übergeben Sie das Argument als Wörterbuch`


def say_hello(name, age):
    print(name, age) # sato 25
user = {'name':'sato', 'age':25}
say_hello(**user) # **Wörterbuchtyp

Referenz Einführung in Python (Extra 1): * arg und ** kwarg

Klasse

self

Bezieht sich auf eine Instanz, die aus einer Klasse erstellt wurde. Das erste Argument einer Klasseninstanzmethode oder eines Konstruktors. Es ist leicht zu vergessen. Die mit self verknüpfte Variable heißt "Instanzvariable" und die Methode heißt "Instanzmethode".

Klassenvariablen (Konstanten) und Methoden

Mit der Klasse verknüpfte Variablen werden als "Klassenvariablen" und Methoden als "Klassenmethoden" bezeichnet.

class Player:
    #Klassenvariable
    count = 0
    #Klassenkonstante (oben)
    GUILD = "KoB"
    def __init__(self):
        Player.count += 1
    #Klassenmethode
    @classmethod 
    def show_count(cls):
        #Weil ich mich nicht erhalten habe
        #Instanzvariablen / -methoden können nicht verwendet werden
        print("{} instances".format(cls.count))
        
    #Statische Methode
    #So etwas wie eine Klassenmethode ohne erstes Argument
    #Kann ohne Instanziierung aufgerufen werden
    @staticmethod
    def show_guild():
        print(Player.GUILD)

player01 = Player()
player02 = Player()
player03 = Player()

#Kann ohne Instanziierung aufgerufen werden
print(Player.count) # 3
Player.show_count() # 3 instances

#Wenn es keine Instanzvariable mit demselben Namen gibt, können Sie die Klassenvariable auch von der Instanz aus aufrufen.
print(player01.count) # 3

Player.show_guild() # KoB

Datenverwaltung mit Klassenkonstanten

↓ Es ist bequem, solche Daten zu verwalten

`Verwalten Sie Farben mit Konstanten`


class Color:
    MAIN = '#f00'
    SUB = '#00f'
    FONT = '#fff'
print(Color.MAIN) # #f00

Private Variablen / Methoden

Zwei Unterstriche "__" machen es von außen unzugänglich Ein Unterstrich "_" ist nur die Form

class Player:
    def __init__(self):
        self.name = 'sato'
    def __method(self):
        print(self.name)

player01 = Player()
player01.__method() # error

Private Methoden und Variablen sind nur "Name Mangling". Wenn Sie sie also zwangsweise aufrufen möchten, können Sie dies tun, aber nicht.

Getter Setter

Wird beispielsweise für Variablen verwendet, die extern bearbeitet werden müssen

getter

`offiziell`


class ClassName:
    @property
    def getterName(self):
        return value

class Clock:
    def __init__(self, hour):
        self._hour = hour

    @property
    def hour(self):
        return self._hour

clock = Clock(10)
print(clock.hour) #Sie können wie eine Variable auf die Methode zugreifen
clock.hour = 12 #Der Wert kann nicht geändert werden. AttributeError: can't set attribute

setter

`offiziell`


class ClassName:
    @getterName.setter
    def getterName(self, value):

class Clock:
    def __init__(self, hour):
        self._hour = hour

    @property
    def hour(self):
        return self._hour
    
    @hour.setter
    def hour(self, value):
        self._hour = value

clock = Clock(10)
clock.hour # 10
clock.hour = 6 #Jetzt zugänglich
clock.hour # 6

Lambda-Stil

Lambda-Argument: Ausdruck Gibt die Funktion als Objekt zurück Es ist klug, es zu verwenden, wenn Sie es mit einer anonymen Funktion tun können, anstatt jedes Mal eine Funktion zu erstellen, wenn Sie eine Funktion übergeben

lambda_test = lambda x, y : print('lambda_test : {}, {}'.format(x, y)) # function <lambda>
lambda_test('hello', 'lambda') # lambda_test : hello, lambda

map

map(function, iterable) Passen Sie die Funktion des ersten Arguments an die Liste (Taple) des zweiten Arguments an und geben Sie das Ergebnis zurück

map_obj = map(lambda x : x * 2, range(10))
print(list(map_obj)) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

filter

filter(function, iterable) Wenden Sie die Funktion des ersten Arguments auf die Liste (Taple) des zweiten Arguments an und sammeln Sie das True-Element.

filter_obj = filter(lambda x : x % 2 == 0, range(10))
print(list(filter_obj)) # [0, 2, 4, 6, 8]

Dekorateur

Fügen Sie vor und nach der Funktion eine beliebige Verarbeitung hinzu

import time

def time_log(func):
    def wrapper(*args,**kwargs):
        
        import datetime
        start = datetime.datetime.today()
        print("--- start", func.__name__)
        
        #Funktionsausführung
        func(*args, **kwargs)
        
        end = datetime.datetime.today()
        delta = end - start
        print("--- end", func.__name__, delta, "sec")
    
    return wrapper #Gibt ein Funktionsobjekt zurück

#Fügen Sie die Verarbeitung hinzu, indem Sie den Namen des Dekorateurs beschreiben
@time_log 
def test1():
    print("sleep 1sec")
    time.sleep(1)
    
@time_log
def test2():
    print("sleep 2sec")
    time.sleep(2)
    
test1()
test2()

Referenz http://dotinstall.com/lessons/basic_python_v3 http://www.yoheim.net/