Taula de continguts[Amaga][Espectacle]
En aquesta conferència, coneixerem les classes, els constructors i l'herència en Python.
Aquests conceptes són realment importants en un programa gran on cal definir diferents tipus.
classes
Les classes són essencials en la programació i no són específiques de Python. Molts altres llenguatges de programació donar suport a la noció de classes. Utilitzem classes per definir nous tipus de dades.
Fins ara, hem après sobre els tipus de dades bàsics de Python com els números, les cadenes i els booleans. Aquests són els tipus de dades bàsics o simples a Python. També hem vist un parell de tipus de dades complexos com llistes i diccionaris.
Tot i que aquests tipus són extremadament útils, no sempre es poden utilitzar per modelar conceptes complexos. Per exemple, penseu en la idea d'un punt o d'un carretó de la compra. Un carretó de la compra no és un booleà ni una llista. És un tipus de dades diferent. Així que podem utilitzar classes per definir nous tipus per modelar conceptes reals.
Ara, anem a definir un nou tipus de dades anomenat punt. Aquest nou tipus tindrà mètodes com hem comprovat abans.
Així ho faràs:
Comencem per definir una classe utilitzant la paraula clau "class" i just després donem un nom a la nostra classe.
class Point
Ara, mireu la convenció de noms que he utilitzat aquí. He posat en majúscula la primera lletra aquí, això és el que anomenem convenció de nomenclatura pascal. Aquesta convenció és diferent de la que fem servir per anomenar les nostres variables i funcions per a les quals sempre fem servir lletres minúscules i separem diverses paraules mitjançant un guió baix. Però quan anomenem classes, no fem servir un guió baix per separar diverses paraules, sinó que posem en majúscula la primera lletra de cada paraula.
Després de definir la nostra classe, s'utilitzen dos punts, que significa que ara està definit un bloc.
class Point:
def move (self):
En aquest bloc, podem definir totes les funcions o mètodes que pertanyen als punts. Per exemple, podem definir una funció anomenada "move" per moure un punt. Tingueu en compte que tan aviat com escrivim parèntesis oberts, PyCharm afegeix automàticament "self" aquí. Aquesta és una paraula clau especial i permeteu-me tornar-hi en breu. Imprimim “move” al terminal.
print("move")
Definim un altre mètode com “dibuixar” i imprimim-lo al terminal.
def draw(self):
print("draw")
Hem acabat amb la definició de la nostra classe "punt". Amb aquest nou tipus, podem crear nous objectes. Una classe simplement defineix el projecte o la plantilla per crear objectes que són les instàncies reals basades en aquest projecte. Per crear un objecte, escrivim el nom de la nostra classe i després l'anomenem com una funció. Això crea un objecte nou i després el retorna. Aleshores podem emmagatzemar aquest objecte en una variable. Deixa'm ensenyar-te:
Aquí hem definit un "punt1" que és un punt tridimensional. Podeu veure que, podem imprimir coordenades individuals al terminal.
Podem utilitzar els dos mètodes "dibuixar" i "moure" amb aquest punt.
Per tant, per resumir, fem servir classes per definir nous tipus i aquests tipus poden tenir mètodes que definim al cos de la classe. Les classes poden tenir atributs que podem establir en qualsevol lloc dels nostres programes.
Constructors
Fins ara, hem après a crear nous tipus mitjançant classes. Ara hi ha un petit problema amb aquesta implementació. Podem crear un objecte puntual sense coordenades x o y utilitzant classes i això no és ideal. Deixa'm ensenyar-te.
Creem un punt i imprimim-lo abans d'establir la coordenada x. L'execució del nostre programa provoca un error d'atribut com aquest:
Significa que l'objecte puntual no té cap atribut anomenat x. Ara el problema és que és possible tenir un objecte puntual sense coordenades x o y. Això no té sentit ja que sempre que parlem d'un punt, hem de saber on es troba aquest punt. Per resoldre aquest problema, utilitzem un constructor. Un constructor és una funció que es crida en el moment de crear un objecte.
Aquí és com fem servir un constructor. Primer, passem els valors de les coordenades x i y al programa anterior.
point = Point(10, 20)
print(point.x)
Ara, hem d'afegir un mètode especial en aquesta classe anomenat constructor. La seva sintaxi és així:
def __init__(self, x, y):
init
és l'abreviatura de inicialitzat, i aquesta és la funció o el mètode que es crida quan es crea un nou objecte de punt. Les x i y s'afegeixen just després self
per afegir dos paràmetres addicionals.
Després d'això, hauríem de mapar les x i y als valors passats, és a dir, 10 i 20
self.x = x
self.y = y
Fem servir la self
per referir-nos a l'objecte actual i després establim l'atribut x a l'argument x passat a la funció “x”. D'aquesta manera, utilitzant init
mètode, podem inicialitzar els nostres objectes. Aquest mètode es coneix com a constructor. Executem el nostre programa.
Ara, podem canviar les coordenades x i y més tard. Actualitzem la coordenada x:
point = Point(10, 20)
point.x = 11
print(point.x)
Ara, la coordenada x s'actualitza al valor 11.
Exercir
Aquí tens un exercici interessant.
Vull que definiu un tipus nou anomenat persona. Aquests objectes "Persona" haurien de tenir un "name
", així com un "talk()
”Mètode.
És una tasca senzilla i no hauria de durar més d'un parell de minuts.
Solució
Comenceu definint la classe "Persona" així:
class Person:
self.name = name
Definirem el constructor més endavant. Ara, podem crear l'objecte "Persona". Diguem-ne Joan
john = Person("John Smith")
print(john.name)
john.talk()
Ara, aneu a la primera part del codi i creeu un constructor.
def __init__(self, name):
El codi final serà així:
També podeu utilitzar cadenes amb format i altres conceptes juntament amb classes i constructors.
Herència
L'herència és un altre concepte associat a les classes que us permeten reutilitzar un codi.
Considereu aquest fragment de codi.
class Dog:
def walk(self):
print("walk")
Hem creat una classe "Gos" amb un mètode de "passejar". En aquest mètode, simplement estem imprimint el missatge de passeig al terminal. Diguem que, en un programa real, hi ha 10 línies de codi en lloc d'una sola línia aquí. En el futur, si es necessita una altra classe per tenir el mètode "walk", haurem de repetir tot aquest codi. Això no és ideal.
A la programació, tenim un principi anomenat DRY que és l'abreviatura de no et repeteixis. Diguem que en el futur descobrim un problema amb el nostre mètode "caminar" i si hem repetit o duplicat aquest mètode en molts altres llocs, haurem de tornar i solucionar aquest problema a cada lloc on ho hem duplicat. codi. Per això, en programació no hem de definir una cosa dues vegades.
Hi ha diferents enfocaments per solucionar aquest problema, però aquí anem a aprendre el que és més fàcil per als principiants i s'anomena herència. En aquest cas, crearem una altra classe "mamífer" i definirem el nostre atribut "caminar" en aquesta classe.
class Mammal:
def walk(self):
print("walk")
Després de definir la nostra classe "Mamífer" podem utilitzar l'herència per passar els atributs com aquest:
Tant les classes de gossos com de gats estan heretant tots els mètodes de classe definits a la seva classe pare. Ara, podem afegir mètodes específics per als gossos com aquest:
class Dog:
def bark(self):
print("bark")
Embolicar!
Es tractava de les classes, els constructors i la reutilització del codi en classes amb conceptes d'herència. Ara estem a prop del final de la nostra sèrie. En aquest punt, hauríeu de poder produir codis bons, llegibles i concisos en Python.
Veurem el concepte de mòduls i paquets a la propera conferència.
Deixa un comentari