Als ich eine Zusammenfassung machte, die auch als Memorandum unter [hier] diente (http://qiita.com/hiroykam/items/2fea445fd2d489354c34), bemerkte oder entdeckte ich sie erneut, daher möchte ich sie hier beschreiben.
Ein Beispiel, das "Hello World" ausgibt. Definieren Sie die Klassenvariable c_var bzw. die Instanzvariable i_var.
class Test(object):
c_var = "Hello"
def __init__(self):
self.i_var = "World"
def __str__(self):
return Test.c_var + " " + self.i_var
print(Test())
Validiert mit einem Muster, das eine Instanzvariable mit demselben Namen wie eine Klassenvariable (exam1) definiert, und einem Muster, das eine Klassenvariable modifiziert ( exam2).
class Test(object):
c_var = "Hello"
def __init__(self):
self.i_var = "World"
def __str__(self):
return Test.c_var + " " + self.i_var
def examine1(self):
self.c_var = "Hey"
return self
def examine2(self):
Test.c_var = "Hey"
return self
t = Test()
print(t.examine1())
print(t.examine2())
print(Test())
Aus dem Ausgabeergebnis ist ersichtlich, dass die Klassenvariable und die Instanzvariable unterschiedlich sind und die Instanzvariable geändert werden kann.
Ausgabeergebnis
Hello World
Hey World
Hey World
Sie können die Instanzvariable mit vars (t) und die Klassenvariable mit vars (Test) überprüfen.
Versuchen Sie nun, die Klassenvariablen mit Klassen- und statischen Methoden anstelle von Methoden zu ändern. Aus dem Ausgabeergebnis werden beide __init__ aufgerufen und die Klassenvariablen wurden geändert.
class Test(object):
c_var = "Hello"
def __init__(self):
self.i_var = "World"
def __str__(self):
return Test.c_var + " " + self.i_var
@classmethod
def class_method(cls):
cls.c_var = "Class"
@staticmethod
def static_method():
Test.c_var = "Static"
Test.class_method()
print(Test())
Test.static_method()
print(Test())
Ausgabeergebnis
Class World
Static World
Lassen Sie uns nun die Änderungen an Klassenvariablen und Instanzvariablen untersuchen, wenn flache und tiefe Kopien erstellt werden. Selbst in einer tiefen Kopie hat sich der Wert der Klassenvariablen geändert.
import copy
class Test(object):
c_var = 2
def __init__(self, obj):
self.i_var = obj
def __str__(self):
return "{0} {1}".format(Test.c_var, self.i_var)
def examine1(self):
self.i_var += 2
return self
def examine2(self):
Test.c_var += 2
return self
a = int(3)
t1 = Test(a)
t1.examine1().examine2()
print(t1)
print(Test(a))
print("--- shallow copy ---")
t2 = copy.copy(t1)
t2.examine1().examine2()
print(t1)
print(t2)
print(Test(a))
print("--- deep copy ---")
t3 = copy.deepcopy(t1)
t3.examine1().examine2()
print(t1)
print(t2)
print(t3)
print(Test(a))
Ausgabeergebnis
4 5
4 3
--- shallow copy ---
6 5
6 7
6 3
--- deep copy ---
8 5
8 7
8 7
8 3
Eine Klasse, die zwei Methoden definiert: "Probe1" und "Prüfen2".
class Test(object):
def __init__(self):
self.i_var = "nothing"
def __str__(self):
return self.i_var
def examine1(self):
self.i_var = "examine1"
return self
def examine2(self):
self.i_var = "examine2"
return self
t1 = Test()
print(t1)
print(t1.examine1())
print(t1.examine2())
Das Ausgabeergebnis ist wie folgt.
Ausgabeergebnis
nothing
examine1
examine2
Als ich hier "print (Test.examin1 ())" wie eine Klassenmethode ausführte, bekam ich natürlich einen Fehler.
Error
examine1() missing 1 required positional argument: 'self'
Ist es also möglich, eine Instanz im ersten Argument "self" anzugeben?
t1 = Test()
print(Test.examine1(t1.examine2()))
print(Test.examine2(t1.examine1()))
Als das obige ausgeführt wurde, wurde das folgende Ergebnis ausgegeben.
Ausgabeergebnis
examine1
examine2
Zusammenfassung präsentierte mir eine anrufbare Klasse, und gleichzeitig war ich mir meines Mangels an Studien sehr bewusst.
class Callable(int):
def __call__(self, *arguments):
print(arguments[0])
a = Callable(5)
print(a)
a(3)
Ausgabeergebnis
5
3
Das Obige bedeutet, dass "a" sowohl als Funktion als auch als Variable verwendet werden kann. Da der Referenzwert der "Callable" -Instanz "a" zugewiesen ist, wird der Wert, der beim Erstellen der Instanz als Argument übergeben wird, durch "print (a)" angezeigt. Wenn "a" wie eine Funktion aufgerufen wird, wird "call" aufgerufen, sodass der Wert des ersten Arguments "print" ist.
Eine Implementierung, die "int" auf "callable" erweitert und das erste Argument als Einheit (Name) in einem Funktionsaufruf behandelt. Ersetzen der Standardklasse "int" durch "int = Callable".
class Callable(int):
def __call__(self, unit):
print("{0} {1}".format(self, unit))
int = Callable
print(int("3") * 4)
int("5")("meters")
int(2017 - 2010)("years old")
12
5 meters
7 years old
Wir haben eine Klasse vorbereitet, die __add__ und __sub__ implementiert. Der Referenzwert ändert sich auch dann nicht, wenn er wie unten gezeigt addiert oder subtrahiert wird. Dies ersetzte auch den Standard "int". Der Wert von "id" hat sich nach dem Austausch nicht geändert.
class MyInt(object):
def __init__(self, v):
self.__v = v
def __add__(self, other):
self.__v += other
return self
def __sub__(self, other):
self.__v -= other
return self
a = int(2)
print(id(a))
a = a + 3
print(id(a))
a = a - 5
print(id(a))
int = MyInt
a = int(3)
print(id(a))
a = a + 3
print(id(a))
a = a - 5
print(id(a))
1983644176
1983644272
1983644112
1736248227544
1736248227544
1736248227544
__mul__, __matmul__, __truediv__, __floordiv__, __mod__, __divmod__, __pow__, __lshift__, __rshift__, __and__, `_xor Entsprechend umsetzen.
Ich habe int bei der Überprüfung von Klassenvariablen und Instanzvariablen verwendet (Teil 3), aber ich habe versucht, es mit dem hier definierten veränderlichen numerischen Objekt zu überprüfen.
Wie bei unveränderlichen Variablen können Klassenvariablen auch bei einer tiefen Kopie im Wert geändert werden.
import copy
class MyInt(object):
def __init__(self, v):
self.__v = v
def __str__(self):
return str(self.__v)
def __add__(self, other):
self.__v += other
return self
def __sub__(self, other):
self.__v -= other
return self
int = MyInt
class Test(object):
c_var = int(2)
def __init__(self, obj):
self.i_var = obj
def __str__(self):
return "{0} {1}".format(Test.c_var, self.i_var)
def examine1(self):
self.i_var += 2
return self
def examine2(self):
Test.c_var += 2
return self
a = int(3)
t1 = Test(a)
t1.examine1().examine2()
print(t1)
print(Test(a))
print("--- shallow copy ---")
t2 = copy.copy(t1)
t2.examine1().examine2()
print(t1)
print(t2)
print(Test(a))
print("--- deep copy ---")
t3 = copy.deepcopy(t1)
t3.examine1().examine2()
print(t1)
print(t2)
print(t3)
print(Test(a))
Ausgabeergebnis
4 5
4 5
--- shallow copy ---
6 7
6 7
6 7
--- deep copy ---
8 7
8 7
8 9
8 7
Recommended Posts