>>> class car():
... pass
...
#Héritage de la classe parente. Entrez le nom de la classe parente entre ().
>>> 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!
#définir la classe de voiture
>>> class car():
... def exclaim(self):
... print("I am a car")
...
#Définir la classe yugo
>>> class yugo(car):
... def exclaim(self):
... print("I am a Yugo! Much like a Car,but more Yugo-ish")
...
#Créer un objet
>>> give_me_a_car=car()
>>> give_me_a_yugo=yugo()
#(objet.Méthode)Appeler l'instance avec
>>> 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
...
#Il hérite de la classe Person et prend les mêmes arguments que son parent, mais remplace la valeur de nom stockée dans l'objet.
>>> class MDPerson(Person):
... def __init__(self,name):
... self.name="Docter"+name
...
>>> class JDPerson(Person):
... def __init__(self,name):
... self.name=name+"Esquire"
...
#Création d'objets
>>> person=Person("Fudd")
>>> docter=MDPerson("Fudd")
>>> lowyer=JDPerson("Fudd")
>>> print(person.name)
Fudd
>>> print(docter.name)
DocterFudd
>>> print(lowyer.name)
FuddEsquire
>>> 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")
#Nécessaire uniquement pour les classes enfants_a_push()Ajouter une méthode
... 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?
#Les objets Car à usage général ne peuvent pas réagir.
>>> 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'
#Définition de la classe parent
>>> class Person():
... def __init__(self,name):
... self.name=name
...
#Définition de classe enfant
#En classe enfant__init__()A définir est la classe parente__init__()J'essaye de remplacer une méthode et la version de la classe parente n'est pas appelée automatiquement. Par conséquent, pour appeler le champ de classe parent 0 John, il doit être appelé explicitement.
#Notez que nous ajoutons un argument email
#super()Extrait la définition de Person de la classe parent.
>>> class EmailPerson(Person):
... def __init__(self,name,email):
... super().__init__(name)
... self.email=email
...
#Créer un objet de la classe EmailPerson
>>> bob=EmailPerson("Bob Frapples","[email protected]")
>>> bob.name
'Bob Frapples'
>>> bob.email
'[email protected]'
--Utilisation de super () pour que Person fasse le même travail qu'un simple objet Person.
#Trouvez la classe (voiture) de l'objet voiture.
#Exclamation de classe de voiture()Passez l'objet voiture comme argument auto à la méthode.
>>> car=car()
>>> car.exclaim()
I am a car
#Vous pouvez obtenir le même résultat que ci-dessus en passant l'objet car directement à la classe Car avec la méthode exclaim.
>>> Car.exclaim(car)
I am a car
Certains langages orientés objet prennent en charge l'attribut d'objet privé, qui n'est pas directement accessible de l'extérieur. Une méthode setter et getter est requise pour pouvoir lire et écrire la valeur de l'attribut private.
J'ai compris le getter et le setter comme suit. --Getter → Qu'est-ce que pour obtenir la valeur --Setter → Quoi utiliser lors de l'attribution d'une valeur
#Caché comme attribut_Définissez une classe Duck qui n'a que des éléments avec le nom de valeur
>>> 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
#Deux méthodes sont définies comme setters et getters pour une propriété appelée name. Cela se produira lorsque vous vous référez au nom de l'objet Duck_name()La méthode sera appelée.
#Vous pouvez utiliser la propriété pour contrôler ce qui se passe lors de l'accès à un attribut.
... name=property(get_name,set_name)
...
>>> fowl=Duck("Howard")
>>> fowl.name
inside the getter
'Howard'
#Obtenez directement_name()Peut également être appelé
>>> fowl.get_name()
inside the getter
'Howard'
#Attribution d'une valeur aux jeux de propriétés de nom_La méthode de nom est appelée.
>>> fowl.name="Duffy"
inside the setter
>>> fowl.name
inside the getter
'Duffy'
#Ensemble direct_name()Peut également être appelé
>>> fowl.set_name("Duffy")
inside the setter
>>> fowl.name
inside the getter
'Duffy'
--Les propriétés peuvent être définies avec des décorateurs.
>>> class Duck():
... def __init__(self,input_name):
... self.hidden_name=input_name
#@En utilisant la propriété, il peut être implémenté sans utiliser le nom de l'attribut et il devient possible de faire référence à l'attribut.
... @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'
#La propriété peut également faire référence à la valeur calculée.
>>> 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
#l'attribut radius peut être réécrit à tout moment
>>> c.radius=7
>>> c.diameter
14
#Si vous ne spécifiez pas le paramètre de propriété, vous ne pouvez pas réécrire la valeur de propriété de l'extérieur. (Pratique pour la lecture seule)
>>> 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'
#__Inaccessible à l'attribut de nom
>>> fowl.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Duck' object has no attribute '__name'
#Bague mang prénom
>>> fowl._Duck__name
'Donald'
#self.count(Cela en fait un attribut de l'instance d'objet)Pas un.count(Attributs de classe)Notez qu'il fait référence à. des gamins()Dans la méthode cls.J'ai utilisé count, mais A.Cela peut être compté.
>>> 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.
#Définition de méthode statique
>>> class CoyoteWeapon():
... @staticmethod
... def commercial():
... print("This CoyoteWeapon has been brought to you by Acme")
...
#Il peut être exécuté sans créer d'objet à partir de la classe.
>>> 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 + "."
...
#Puisque la méthode d'initialisation est la même que la classe parente__init__()La méthode n'est pas remplacée.
>>> 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 est qui(),says()Tout objet qui a une méthode peut être traité comme un objet avec une interface commune (sans héritage).
>>> 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__ () initialise l'objet nouvellement créé à partir de la définition de classe avec les arguments passés.
>>> 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()Méthode__eq__()Changez pour le nom spécial.
>>> 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>
#Dans la classe Word__str__()Ou__repr__()Ajoutez une méthode pour rendre l'affichage plus facile à voir.
>>> 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__()utilisation
>>> first
Word(ha)
#__str__()utilisation
>>> print(first)
ha
--Méthode spéciale de comparaison
| Méthode | sens |
|---|---|
| _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 |
--Méthode spéciale pour le calcul arithmétique
| Méthode | sens |
|---|---|
| _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 |
--Autres méthodes spéciales
| Méthode | sens |
|---|---|
| _str_(x) | str(x) |
| _repr_(x) | repr(x) |
| _len_(x) | len(x) |
#bill(Kuchibashi)、tail(queue)Créez un objet et donnez-le à la nouvelle classe Duck.
>>> 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
Les taples nommés sont des sous-classes de taples qui vous permettent d'accéder aux valeurs non seulement par position ([offset]) mais aussi par nom (.name).
Passez deux arguments à la fonction namedtuple.
Nom
Chaîne de champ séparée en blanc
Les tapples nommés ne sont pas une structure de données que Python fournit automatiquement, vous devez donc télécharger le module pour l'utiliser. --Avantages des taples nommés
Comportement comme un objet immuable --Plus spatialement et temporellement plus efficace que les objets
Vous pouvez accéder aux attributs en notation par points au lieu de crochets de style dictionnaire. --Peut être utilisé comme clé de dictionnaire.
>>> from collections import namedtuple
>>> Duck=namedtuple("Duck","bill tail")
>>> duck=Duck("wide orange","long")
#Créer un taple nommé
>>> duck
Duck(bill='wide orange', tail='long')
#(.name)Vous pouvez accéder à la valeur avec.
>>> duck.bill
'wide orange'
>>> duck.tail
'long'
#Les taples nommés peuvent également être créés à partir d'un dictionnaire.
>>> parts={"bill":"Wide orange","tail":"long"}
#Canard en extrayant les clés et les valeurs du dictionnaire de pièces en convertissant les arguments du mot-clé en un dictionnaire()Passer comme argument à.
>>> duck2=Duck(**parts)
>>> duck2
Duck(bill='Wide orange', tail='long')
#Les taples nommés sont immuables, mais peuvent renvoyer un autre tapple nommé avec un ou plusieurs échanges de champ.
>>> duck3=duck2._replace(tail="M",bill="X")
>>> duck3
Duck(bill='X', tail='M')
#canard peut également être défini comme un dictionnaire.
>>> duck_dict={"bill":"A","tail":"I"}
>>> duck_dict
{'bill': 'A', 'tail': 'I'}
#Vous pouvez ajouter des champs au dictionnaire.
>>> duck_dict["color"]="green"
>>> duck_dict
{'bill': 'A', 'tail': 'I', 'color': 'green'}
#Ne peut pas être ajouté aux taples nommés.
>>> 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'
#Le nom clé du dictionnaire est__init()__Puisqu'il correspond à l'argument de, l'objet peut être initialisé directement à partir du dictionnaire.
>>> 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")
#La fonction d'impression est pour l'objet__str__()Appelez la méthode pour obtenir la représentation sous forme de chaîne. Sans cela<__main__.Element object at 0x10de9e510>Renvoie une chaîne telle que.
>>> 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"
...
#La création d'objet s'appelle comme une fonction
>>> 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"
...
#Composition
>>> 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.
>>>
Je ne pouvais pas comprendre les setters et les getters à partir des livres seuls, mais je pouvais les découvrir et les comprendre. J'ai senti que les classes et les objets étaient des unités importantes, j'ai donc mis beaucoup de temps à les comprendre.
Faisons de notre mieux à partir de demain.
"Introduction à Python3 par Bill Lubanovic (publié par O'Reilly Japon)"
Recommended Posts