Python-Klasse (Python-Lernnotiz ⑦)

Informationen zu Bereichen und Namespaces

Namensraum

Punkt

• Der Namensraum ist die Entsprechung zwischen Namen und Objekten.
• Mit dem Namespace verknüpfte Attribute sind mit Punkten wie "obj.attribute" verbunden

Umfang

Punkt

• Bereich ist der Bereich im Programmtext, auf den direkt über den Namespace mit Bereich zugegriffen werden kann.
• Die Referenzreihenfolge des Geltungsbereichs lautet wie folgt
• Geltungsbereich mit lokalem Namen
• Wenn es eine Funktion gibt, die ↑ umgibt, den Umfang dieser Funktion
• Globaler Umfang des aktuellen Moduls
• Der äußerste Bereich ist ein Bereich mit einem integrierten Namen
• Zuweisungen und Löschungen erfolgen immer im innersten Bereich, sofern nicht die globale Anweisung verwendet wird.
• Verwenden Sie die globale Anweisung, um anzugeben, dass sich die Variable im globalen Bereich befindet
• Nichtlokale Minuten zeigen an, dass sich die Variable in dem Bereich befindet, der den aktuellen Bereich umgibt

Beispiel für Umfang und Namespace

def scope_test():
    def do_local():
        spam = "local spam"
    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
    def do_global():
        global spam
        spam = "global spam"
    spam = "test spam"
    
    do_local()
    print("After local assignment:", spam)
    # After local assignment: test spam
    
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    # After nonlocal assignment: nonlocal spam
    
    do_global()
    print("After global assignment:", spam)
    # After global assignment: nonlocal spam

scope_test()
print("In global scope:", spam)
# In global scope: global spam

Klassendefinition

Syntax der Klassendefinition

Klassendefinition

class className:
    <Satz 1>
    .
    .
    .
    <Satz N.>

Punkt

• Wenn Sie die Klassendefinition eingeben, wird ein neuer Namespace erstellt Wird als lokaler Bereich verwendet (lokale Variablen, lokale Funktionen befinden sich in diesem Bereich)
• Ein Klassenobjekt wird erstellt, wenn die Ausführung der Klassendefinition abgeschlossen ist (im Grunde ist es nur ein Wrapper, der den Namespace umschließt).

Klassenobjekt

Punkt

• Klassenobjekte unterstützen zwei Arten von Operationen: Attributreferenz und Instanziierung.
• Die Attributreferenz erfolgt in der Form obj.name
• Attributreferenzen sind alle Namen, die im Klassennamensraum vorhanden sind ("MyClass.i" und "MyClass.f" sind in den folgenden Fällen gültig).

Attributreferenz

class MyClass:
    """A simple example class"""
    i = 12345
    def f(self):
        return 'hello world'

• Klasseninstanziierung wird wie eine Funktion aufgerufen

Klasseninstanziierung

x = MyClass()

• Wenn zu diesem Zeitpunkt die Methode __init __ () definiert ist, wird __init () __ automatisch für die neu erstellte Instanz aufgerufen.

__init__()Funktion

    def __init__(self):
        self.data = []

• Argumente können für die Funktion __init __ () angegeben werden
• Als Argument wird das zum Zeitpunkt der Instanziierung der Klasse angegebene Argument verwendet

Klasseninstanziierung(Mit Argument)

class Human:
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

x = Human(165, 55)
print('height:', x.height, 'weight:', x.weight)
# height: 165 weight: 55

Instanzobjekt

Punkt

• Die Instanz verfügt über zwei Attributreferenzen: "Datenattribut" und "Methode".

Referenz von Datenattributen und -methoden

class MyClass:
    def __init__(self):
        pass
    def f(self, word):
        print(word)
        
x = MyClass()

#Datenattribute hinzufügen / referenzieren
x.counter = 1 #Datenattribute müssen nicht im Voraus deklariert werden
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter) # 16
del x.counter

#Methodenreferenz
x.f("hello kawauso")

Methodenobjekt

• Methoden können in Variablen gespeichert werden
• Das Merkmal der Methode ist, dass das Objekt der Instanz als erstes Argument übergeben wird.
• Der Aufruf von x.f () entspricht MyClass.f (x)

Speichern Sie das Methodenobjekt in einer Variablen

xf = x.f
xf('hello kawauso again') #Ausgabe: hello kawauso again

Klassenvariablen und Instanzvariablen

Punkt

• Es gibt Klassenvariablen, die den Klassen- und Instanzvariablen gemeinsam sind, die für jede Instanz eindeutig sind.
• Erstellen Sie keine Klassenvariablen, die für jede Instanz geändert werden müssen.

Beispiele für Klassen- und Instanzvariablen

class Dog:
    
    kind = 'Shiba' #Klassenvariable
    
    def __init__(self, name):
        self.name = name #Instanzvariable
        
        
taro = Dog('Taro')
jiro = Dog('Jiro')

#Verweis auf Klassenvariablen
print(taro.kind) #Shiba
print(jiro.kind) #Shiba

#Verweis auf Instanzvariablen
print(taro.name) #Taro
print(jiro.name) #Jiro

Verschiedene andere

Punkt

• Datenattribute überschreiben die Methode mit demselben Namen. Vermeiden Sie daher doppelte Namen mit Namenskonventionen usw.
• Datenattribute können von überall aus bearbeitet werden (nicht von der Klasse ausgeblendet)
• Das erste Argument der Methode ist üblicherweise "self" (kein reserviertes Wort, aber jeder ist daran gewöhnt)
• Der globale Bereich einer Methode ist das Modul, in dem die Methode definiert ist (die Klasse wird niemals als globaler Bereich verwendet).
• Natürlich können auch Funktionen und Module verwendet werden, die in den globalen Bereich importiert wurden.
• Die Methodenklasse selbst ist auch im globalen Bereich definiert, sodass auf sie verwiesen werden kann.

Erbe

Klassenvererbung

Punkt

• Die Vererbung übergibt den Namen der Basisklasse als Argument der Klasse
• Kann von einem anderen Modul übergeben werden

Vererbungsprobe

class base():
    def a(self):
        print('Ich stütze mich.ist ein.base.Rufen Sie b an')
        self.b()
    def b(self):
        print('Ich stütze mich.b.der.Überschrieben von b')

class der(base):
    def b(self):
        print('Ich der.b.')


b = base()
d = der()

b.a()
#Ich stütze mich.ist ein.base.Rufen Sie b an
#Ich stütze mich.b.der.Überschrieben von b

d.a()
#Ich stütze mich.ist ein.base.Rufen Sie b an
#Ich der.b.

• Verwenden Sie die integrierte Funktion "isinstance (obj, int)", um den Instanztyp zu überprüfen
• Verwenden Sie "issubclass ()", um die Klassenvererbung zu überprüfen

Mehrfachvererbung

Punkt

• Python ermöglicht die Klassendefinition mit mehreren Basisklassen

• Es scheint Volumen zu geben, daher werde ich dies separat zusammenfassen

Private Variablen

Punkt

• Python verfügt nicht über private Instanzvariablen, auf die nur innerhalb des Objekts zugegriffen werden kann
• Konventionell sind Namen mit dem Präfix "_" private Teile der API
• Für private Klassenmitglieder gibt es einen Mechanismus namens Name Mandaring, um Namenskonflikte mit Unterklassen zu vermeiden.
• Dies ersetzt alle Bezeichner der Form "__spam" durch die Form "_classname__spam"

Name Mandaring Beispiel

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update #↑ Update()Private Kopie der Methode

class MappingSubclass(Mapping):
    # update()Beim Anbieten einer neuen Signatur von
    #Vorhandenen__init__()Kann verwendet werden, ohne zu zerstören
    def update(self, iterable):
        for item in zip(keys, values):
            self.items_list.append(item)

Andere Dinge

• Verwenden Sie eine leere Klassendefinition, um benannte Datenelemente auszufüllen

class Employee:
    pass

john = Employee()

john.name = 'Jhon Doe'
john.dept = 'computer lab'
john.salary = 1000

• Es ist üblich, eine Klasse, die eine Methode eines bestimmten Datentyps emuliert, an Python-Code zu übergeben, der diesen Datentyp annimmt. Wenn Sie beispielsweise eine Methode "read ()" oder "readline ()" in einer Klasse definieren, die Daten aus einem Zeichenfolgenpuffer abruft, können Sie sie als Argument an eine Funktion übergeben, die Daten von einem Dateiobjekt empfängt und formatiert.
• Instanzmethodenobjekte haben auch Attribute. Für die Methode m () ist das Instanzobjekt m .__ self__ und das der Methode entsprechende Funktionsobjekt ist m .__ func__.

Ausnahmen sind auch Klassen

Punkt

• Benutzerdefinierte Ausnahmen sind ebenfalls Klassen, sodass Sie damit ein erweiterbares hierarchisches Ausnahmesystem erstellen können.

Iterator

Punkt

• Die for-Anweisung ruft intern "iter ()" für das Containerobjekt auf.
• Das Iterator-Objekt hat "next ()", was eine "StopIteration" -Ausnahme auslöst, wenn die Elemente erschöpft sind, und die for-Schleife wird als Antwort darauf beendet.
• Um Ihrer eigenen Klasse das Repeater-Verhalten hinzuzufügen, können Sie diesen Mechanismus verwenden und Folgendes definieren.

__iter__()Wann__next__()

# __next__()Gibt ein Objekt mit einer Methode zurück__iter__()Definieren Sie eine Methode
#Bereits__next()__In der Klasse definiert durch__iter__()Kehre einfach selbst zurück
class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

rev = Reverse('spam')
iter(rev)

for char in rev:
    print(char)

# m
# a
# p
# s

Generator

Punkt

• Generator ist ein einfaches Tool zum Erstellen von Iteratoren
• Schreiben Sie wie eine normale Funktion, aber verwenden Sie "Yield" in dem Teil, der Daten zurückgibt
• Bei jedem Aufruf von next () kehrt der Generator dorthin zurück, wo er beim letzten Mal aufgehört hat.
• Der Generator generiert automatisch die Methoden "iter ()" und "next ()", sodass Iteratoren einfach generiert werden können.
• Der Generator speichert automatisch lokale Variablen und den Ausführungsstatus zwischen Aufrufen
• Der Generator sendet automatisch eine Stopp-Iteration, wenn er fertig ist

Generator Beispiel

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

for char in reverse('golf'):
    print(char)

# f
# l
# o
# g

Generatortyp

Punkt

• Wenn es sich um einen einfachen Generator handelt, verwenden Sie (), um ihn einfach anzuwenden.

Beispiel für einen Generatorausdruck

sum(i*i for i in range(10)) #Quadratische Summe

xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec)) #Innenprodukt

from math import pi, sin
#Sünde Tabelle
sine_table = {x: sin(x*pi/180) for x in range(0, 91)}

#Einzigartige Wörter auf der Seite
unique_words = set(word for line in page for word in line.split())

#Alumni-Präsident
valedictorian = max((student.gpa, student.name) for student in graduates)

data = 'golf'
list(data[i] for i in rage(len(data)-1, 1, -1))