>>> class car():
... pass
...
#Vererbung der Elternklasse. Geben Sie den Namen der übergeordneten Klasse in () ein.
>>> class yugo(car):
... pass
...
>>> give_me_a_car=car()
>>> give_me_a_yugo=yugo()
>>> class car():
... def exclaim(self):
... print("I am a car!")
...
>>> class yugo(car):
... pass
...
>>> give_me_a_car=car()
>>> give_me_a_yugo=yugo()
>>> give_me_a_car.exclaim()
I am a car!
>>> give_me_a_yugo.exclaim()
I am a car!
#Fahrzeugklasse definieren
>>> class car():
... def exclaim(self):
... print("I am a car")
...
#Definieren Sie die Yugo-Klasse
>>> class yugo(car):
... def exclaim(self):
... print("I am a Yugo! Much like a Car,but more Yugo-ish")
...
#Objekt erstellen
>>> give_me_a_car=car()
>>> give_me_a_yugo=yugo()
#(Objekt.Methode)Rufen Sie die Instanz mit auf
>>> give_me_a_car.exclaim()
I am a car
>>> give_me_a_yugo.exclaim()
I am a Yugo! Much like a Car,but more Yugo-ish
>>> class Person():
... def __init__(self,name):
... self.name=name
...
#Es erbt die Person-Klasse und verwendet dieselben Argumente wie die übergeordnete Klasse, überschreibt jedoch den im Objekt gespeicherten Namenswert.
>>> class MDPerson(Person):
... def __init__(self,name):
... self.name="Docter"+name
...
>>> class JDPerson(Person):
... def __init__(self,name):
... self.name=name+"Esquire"
...
#Objekterstellung
>>> person=Person("Fudd")
>>> docter=MDPerson("Fudd")
>>> lowyer=JDPerson("Fudd")
>>> print(person.name)
Fudd
>>> print(docter.name)
DocterFudd
>>> print(lowyer.name)
FuddEsquire
--Kinderklassen können Methoden hinzufügen, die nicht zur übergeordneten Klasse gehören.
>>> class car():
... def exclaim(self):
... print("I am a car")
...
>>> class yugo(car):
... def exclaim(self):
... print("I am a Yugo! Much like a Car,but more Yugo-ish")
#Wird nur für Kinderklassen benötigt_a_push()Methode hinzufügen
... def need_a_push(self):
... print("A little help here?")
...
>>> give_me_a_car=car()
>>> give_me_a_yugo=yugo()
>>> give_me_a_yugo.need_a_push()
A little help here?
#Allzweck-Autoobjekte können nicht reagieren.
>>> give_me_a_car.need_a_push()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'car' object has no attribute 'need_a_push'
#Übergeordnete Klassendefinition
>>> class Person():
... def __init__(self,name):
... self.name=name
...
#Definition der untergeordneten Klasse
#In der Kinderklasse__init__()Zu definieren ist die übergeordnete Klasse__init__()Ich versuche, eine Methode zu ersetzen, und die übergeordnete Klassenversion wird nicht automatisch aufgerufen. Um das übergeordnete Klassenfeld 0 John aufzurufen, muss es daher explizit aufgerufen werden.
#Beachten Sie, dass wir ein E-Mail-Argument hinzufügen
#super()Extrahiert die Definition der Person der übergeordneten Klasse.
>>> class EmailPerson(Person):
... def __init__(self,name,email):
... super().__init__(name)
... self.email=email
...
#Erstellen Sie ein Objekt der EmailPerson-Klasse
>>> bob=EmailPerson("Bob Frapples","[email protected]")
>>> bob.name
'Bob Frapples'
>>> bob.email
'[email protected]'
--Verwenden Sie super (), um Person dazu zu bringen, denselben Job wie nur ein Personenobjekt auszuführen.
#Finden Sie die Klasse (Auto) des Autoobjekts.
#Autoklasse ausrufen()Übergeben Sie das Autoobjekt als Selbstargument an die Methode.
>>> car=car()
>>> car.exclaim()
I am a car
#Sie können das gleiche Ergebnis wie oben erzielen, indem Sie das Autoobjekt mit der Ausrufungsmethode direkt an die Autoklasse übergeben.
>>> Car.exclaim(car)
I am a car
Einige objektorientierte Sprachen unterstützen das private Objektattribut, auf das von außen nicht direkt zugegriffen werden kann. Eine Setter- und Getter-Methode ist erforderlich, um den Wert des privaten Attributs lesen und schreiben zu können.
Ich habe den Getter und Setter wie folgt verstanden. --Getter → Was, um den Wert zu erhalten --Setter → Was ist beim Zuweisen eines Werts zu verwenden?
#Als Attribut versteckt_Definieren Sie eine Duck-Klasse, die nur Dinge mit dem Wertnamen enthält
>>> class Duck():
... def __init__(self,input_name):
... self.hidden_name=input_name
... def get_name(self):
... print("inside the getter")
... return self.hidden_name
... def set_name(self,input_name):
... print("inside the setter")
... self.hidden_name=input_name
#Zwei Methoden sind als Setter und Getter der Eigenschaft namens Name definiert. Dies wird tatsächlich angezeigt, wenn Sie sich auf den Namen des Duck-Objekts beziehen_name()Die Methode wird aufgerufen.
#Mit der Eigenschaft können Sie steuern, was passiert, wenn auf ein Attribut zugegriffen wird.
... name=property(get_name,set_name)
...
>>> fowl=Duck("Howard")
>>> fowl.name
inside the getter
'Howard'
#Holen Sie sich direkt_name()Kann auch aufgerufen werden
>>> fowl.get_name()
inside the getter
'Howard'
#Zuweisen eines Werts zu den Namenseigenschaftssätzen_Die Namensmethode wird aufgerufen.
>>> fowl.name="Duffy"
inside the setter
>>> fowl.name
inside the getter
'Duffy'
#Direkt eingestellt_name()Kann auch aufgerufen werden
>>> fowl.set_name("Duffy")
inside the setter
>>> fowl.name
inside the getter
'Duffy'
--Eigenschaften können mit Dekorateuren definiert werden.
>>> class Duck():
... def __init__(self,input_name):
... self.hidden_name=input_name
#@Durch die Verwendung von property kann es ohne Verwendung des Attributnamens implementiert werden, und es wird möglich, auf das Attribut zu verweisen.
... @property
... def name(self):
... print("inside the getter")
... return self.hidden_name
... @name.setter
... def name(self,input_name):
... print("inside the setter")
... self.hidden_name=input_name
...
>>> fowl=Duck("Howard")
>>> fowl.name
inside the getter
'Howard'
>>> fowl.name="Donald"
inside the setter
>>> fowl.name
inside the getter
'Donald'
#Die Eigenschaft kann sich auch auf den berechneten Wert beziehen.
>>> class Circle():
... def __init__(self,radius):
... self.radius=radius
... @property
... def diameter(self):
... return 2 * self.radius
...
>>> c=Circle(5)
>>> c.radius
5
>>> c.diameter
10
#Das Radiusattribut kann jederzeit neu geschrieben werden
>>> c.radius=7
>>> c.diameter
14
#Wenn Sie den Eigenschaftssetzer nicht angeben, können Sie den Eigenschaftswert von außen nicht neu schreiben. (Praktisch für schreibgeschützt)
>>> c.diameter=20
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
>>> class Duck():
... def __init__(self,input_name):
... self.__name=input_name
... @property
... def name(self):
... print("inside the getter")
... return self.__name
... @name.setter
... def name(self,input_name):
... print("inside the setter")
... self.__name=input_name
...
>>> fowl=Duck("Howard")
>>> fowl.name
inside the getter
'Howard'
>>> fowl.name="Donald"
inside the setter
>>> fowl.name
inside the getter
'Donald'
#__Zugriff auf Namensattribut nicht möglich
>>> fowl.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Duck' object has no attribute '__name'
#Name Mang Ring
>>> fowl._Duck__name
'Donald'
#self.count(Dies macht es zu einem Attribut der Objektinstanz)Kein.count(Klassenattribute)Beachten Sie, dass es sich bezieht auf. Kinder()In der Methode cls.Ich habe gezählt, aber A..Es kann zählen.
>>> class A():
... count=0
... def __init__(self):
... A.count+=1
... def exclaim(self):
... print("I am an A!")
... @classmethod
... def kids(cls):
... print("A has",cls.count,"little objects.")
...
>>> e=A()
>>> b=A()
>>> w=A()
>>> A.kids()
A has 3 little objects.
#Statische Methodendefinition
>>> class CoyoteWeapon():
... @staticmethod
... def commercial():
... print("This CoyoteWeapon has been brought to you by Acme")
...
#Es kann ausgeführt werden, ohne ein Objekt aus der Klasse zu erstellen.
>>> CoyoteWeapon.commercial()
This CoyoteWeapon has been brought to you by Acme
>>> class Quote():
... def __init__(self,person,words):
... self.person=person
... self.words=words
... def who(self):
... return self.person
... def says(self):
... return self.words + "."
...
#Da die Initialisierungsmethode mit der übergeordneten Klasse identisch ist__init__()Die Methode wird nicht überschrieben.
>>> class QuestionQuote(Quote):
... def says(self):
... return self.words + "?"
...
>>> class ExclamationQuote(Quote):
... def says(self):
... return self.words + "!"
...
>>> hunter=Quote("E","I")
>>> print(hunter.who(),"says:",hunter.says())
E says: I.
>>> hunted1=QuestionQuote("E","I")
>>> print(hunted1.who(),"says:",hunted1.says())
E says: I?
>>> hunted2=ExclamationQuote("E","I")
>>> print(hunted2.who(),"says:",hunted2.says())
E says: I!
#Python ist wer(),says()Jedes Objekt mit einer Methode kann als Objekt mit einer gemeinsamen Schnittstelle (ohne Vererbung) behandelt werden.
>>> class BBrook():
... def who(self):
... return "Brook"
... def says(self):
... return "Babble"
...
>>> brook=BBrook()
>>> def who_says(obj):
... print(obj.who(),"says",obj.says())
...
>>> who_says(hunter)
E says I.
>>> who_says(hunted1)
E says I?
>>> who_says(hunted2)
E says I!
>>> who_says(brook)
Brook says Babble
--__ init__ () initialisiert das neu erstellte Objekt aus der Klassendefinition mit den übergebenen Argumenten.
>>> class Word():
... def __init__(self,text):
... self.text = text
... def equals(self,word2):
... return self.text.lower() == word2.text.lower()
...
>>> first=Word("ha")
>>> second=Word("HA")
>>> third=Word("eh")
>>> first.equals(second)
True
>>> first.equals(third)
False
#equals()Methode__eq__()Ändern Sie den speziellen Namen.
>>> class Word():
... def __init__(self,text):
... self.text = text
... def __eq__(self,word2):
... return self.text.lower() == word2.text.lower()
...
>>> first=Word("ha")
>>> second=Word("HA")
>>> third=Word("eh")
>>> first==second
True
>>> first==third
False
>>> first=Word("ha")
>>> first
<__main__.Word object at 0x10ddeec50>
>>> print(first)
<__main__.Word object at 0x10ddeec50>
#In der Word-Klasse__str__()Oder__repr__()Fügen Sie eine Methode hinzu, damit die Anzeige besser sichtbar ist.
>>> class Word():
... def __init__(self,text):
... self.text = text
... def __eq__(self,word2):
... return self.text.lower() == word2.text.lower()
... def __str__(self):
... return self.text
... def __repr__(self):
... return "Word(" + self.text + ")"
...
>>> first=Word("ha")
#__repr__()verwenden
>>> first
Word(ha)
#__str__()verwenden
>>> print(first)
ha
| Methode | Bedeutung |
|---|---|
| _qe_(x,y) | x == y |
| _ne_(x,y) | x != y |
| _lt_(x,y) | x < y |
| _gt_(x,y) | x > y |
| _le_(x,y) | x <= y |
| _ge_(x,y) | x >= y |
| Methode | Bedeutung |
|---|---|
| _add_(x,y) | x + y |
| _sub_(x,y) | x - y |
| _mul_(x,y) | x * y |
| _floordiv_(x,y) | x // y |
| _truediv_(x,y) | x / y |
| _mod_(x,y) | x % y |
| _pow_(x,y) | x ** y |
| Methode | Bedeutung |
|---|---|
| _str_(x) | str(x) |
| _repr_(x) | repr(x) |
| _len_(x) | len(x) |
#bill(Kuchibashi)、tail(Schwanz)Erstellen Sie ein Objekt und geben Sie es der neuen Duck-Klasse.
>>> class Bill():
... def __init__(self,description):
... self.description=description
...
>>> class Taill():
... def __init__(self,length):
... self.length=length
...
>>> class Duck():
... def __init__(self,bill,tail):
... self.bill=bill
... self.tail=tail
... def about(self):
... print("This duck has a",self.bill.description,"bill and a",self.tail.length,"tail")
...
>>> tail=Taill("long")
>>> bill=Bill("wide orange")
>>> duck=Duck(bill,tail)
>>> duck.about()
This duck has a wide orange bill and a long tail
--Klassen unterstützen die Vererbung, Module jedoch nicht. --Objekte sind am nützlichsten, wenn Sie mehrere Instanzen mit demselben Verhalten (Methoden), aber unterschiedlichen internen Zuständen (Attributen) benötigen. ――Wenn Sie nur eines benötigen, ist ein Modul gut. Unabhängig davon, wie oft ein Programm auf ein Python-Modul verweist, wird nur eine Kopie geladen.
--Named Taples sind Unterklassen von Taples, mit denen Sie nicht nur nach Position ([Offset]), sondern auch nach Name (.name) auf Werte zugreifen können.
--Named Tapples sind keine Datenstruktur, die Python automatisch bereitstellt. Sie müssen daher das Modul herunterladen, um es verwenden zu können. --Vorteile der genannten Taples
>>> from collections import namedtuple
>>> Duck=namedtuple("Duck","bill tail")
>>> duck=Duck("wide orange","long")
#Erstellen Sie einen benannten Taple
>>> duck
Duck(bill='wide orange', tail='long')
#(.name)Sie können mit auf den Wert zugreifen.
>>> duck.bill
'wide orange'
>>> duck.tail
'long'
#Benannte Taples können auch aus einem Wörterbuch erstellt werden.
>>> parts={"bill":"Wide orange","tail":"long"}
#Ente durch Extrahieren der Schlüssel und Werte des Teilewörterbuchs durch Konvertieren der Schlüsselwortargumente in ein Wörterbuch()Als Argument an übergeben.
>>> duck2=Duck(**parts)
>>> duck2
Duck(bill='Wide orange', tail='long')
#Benannte Taples sind unveränderlich, können jedoch einen anderen benannten Tapple mit einem oder mehreren Feldbörsen zurückgeben.
>>> duck3=duck2._replace(tail="M",bill="X")
>>> duck3
Duck(bill='X', tail='M')
#Ente kann auch als Wörterbuch definiert werden.
>>> duck_dict={"bill":"A","tail":"I"}
>>> duck_dict
{'bill': 'A', 'tail': 'I'}
#Sie können dem Wörterbuch Felder hinzufügen.
>>> duck_dict["color"]="green"
>>> duck_dict
{'bill': 'A', 'tail': 'I', 'color': 'green'}
#Kann nicht zu benannten Taples hinzugefügt werden.
>>> duck_dict.color="green"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'color'
>>> class Thing():
... pass
...
>>> example=Thing()
>>> print(Thing)
<class '__main__.Thing'>
>>> print(example)
<__main__.Thing object at 0x10de692d0>
>>> class Thing2():
... letters="abc"
...
>>> print(Thing2.letters)
abc
>>> class Thing3():
... def __init__(self):
... self.letters="xyz"
...
>>> something=Thing3()
>>> print(something.letters)
xyz
>>> class Element():
... def __init__(self,name,symbol,number):
... self.name=name
... self.symbol=symbol
... self.number=number
...
>>> H=Element("Hydogen","H","1")
>>> dictionary={"name":"Hydrogen","symbol":"H","number":"1"}
>>> hydrogen=Element(dictionary["name"],dictionary["symbol"],dictionary["number"])
>>> hydrogen.name
'Hydrogen'
>>> hydrogen.symbol
'H'
>>> hydrogen.number
'1'
#Der Schlüsselname des Wörterbuchs lautet__init()__Da es mit dem Argument von übereinstimmt, kann das Objekt direkt aus dem Wörterbuch initialisiert werden.
>>> hydrogen=Element(**dictionary)
>>> hydrogen.name
'Hydrogen'
>>> hydrogen.symbol
'H'
>>> hydrogen.number
'1'
>>> class Element():
... def __init__(self,name,symbol,number):
... self.name=name
... self.symbol=symbol
... self.number=number
... def dump(self):
... print("name=%s,symbol=%s,number=%s"%(self.name,self.symbol,self.number))
...
>>> hydrogen=Element("A","B","C")
>>> hydrogen.dump()
name=A,symbol=B,number=C
>>> print(hydrogen)
<__main__.Element object at 0x10de9e510>
>>> class Element():
... def __init__(self,name,symbol,number):
... self.name=name
... self.symbol=symbol
... self.number=number
... def __str__(self):
... return ("name=%s,symbol=%s,number=%s"%(self.name,self.symbol,self.number))
...
>>> hydrogen=Element("A","B","C")
#Die Druckfunktion ist für das Objekt__str__()Rufen Sie die Methode auf, um die Zeichenfolgendarstellung abzurufen. Ohne das<__main__.Element object at 0x10de9e510>Gibt eine Zeichenfolge wie z.
>>> print(hydrogen)
name=A,symbol=B,number=C
>>> class Element():
... def __init__(self,name,symbol,number):
... self.__number=number
... self.__symbol=symbol
... self.__name=name
... @property
... def name(self):
... return self.__name
... @property
... def symbol(self):
... return self.__symbol
... @property
... def number(self):
... return self.__number
...
>>> hydrogen=Element("A","B","C")
>>> hydrogen.name
'A'
>>> hydrogen.symbol
'B'
>>> hydrogen.number
'C'
>>> class Bear():
... def eats(self):
... return "berries"
...
>>> class Rabbit():
... def eats(self):
... return "clover"
...
>>> class Octothorse():
... def eats(self):
... return "campers"
...
#Die Objekterstellung wird wie eine Funktion aufgerufen
>>> a=Bear()
>>> b=Rabbit()
>>> c=Octothorse()
>>> print(a.eats())
berries
>>> print(b.eats())
clover
>>> print(c.eats())
campers
>>> class Laser():
... def does(self):
... return "disintegrate"
...
>>> class Claw():
... def does(self):
... return "crush"
...
>>> class SmartPhone():
... def does(self):
... return "ring"
...
#Komposition
>>> class Robot():
... def __init__(self):
... self.laser=Laser()
... self.claw=Claw()
... self.smartphone=SmartPhone()
... def does(self):
... return """I have many attachments:
... My laser,to %s.
... My claw,to %s.
... My smartphone,to %s.""" %(
... self.laser.does(),
... self.claw.does(),
... self.smartphone.does())
...
>>> ro=Robot()
>>> print(ro.does())
I have many attachments:
My laser,to disintegrate.
My claw,to crush.
My smartphone,to ring.
>>>
Ich konnte die Setter und Getter allein aus den Büchern nicht verstehen, aber ich konnte sie herausfinden und verstehen. Ich hatte das Gefühl, dass Klassen und Objekte wichtige Einheiten sind, deshalb habe ich mir viel Zeit genommen, um sie zu verstehen.
Lassen Sie uns ab morgen wieder unser Bestes geben.
"Einführung in Python3 von Bill Lubanovic (veröffentlicht von O'Reilly Japan)"
Recommended Posts