herencia de python

Funciones y métodos de Python

La herencia de Python es cuando una subclase usa el código de otra clase. La herencia es una característica esencial en lenguajes orientados a objetos como Python que hace que la codificación sea más fácil y eficiente. 

Python es un lenguaje orientado a objetos, lo que significa que admite la creación de bloques de código reutilizables para ayudar a que el código sea más eficiente. Una de las formas en que esto sucede es a través de la herencia, donde una subclase puede usar código de otra clase.

Por ejemplo, puede tener una clase que almacena & ldquo; cuentas bancarias & rdquo ;, y desea crear una subclase que almacena & ldquo; cuentas bancarias de oro & rdquo; que puede hacer referencia a atributos en las & ldquo; cuentas bancarias & rdquo; clase existente.

En este tutorial, vamos a desglosar los conceptos básicos de la herencia en Python. También vamos a discutir cómo funcionan las clases de Python padre e hijo, y cómo anular atributos y métodos cuando está trabajando con objetos de clases.




Herencia de Python

La herencia es un término que se usa para describir una clase de Python dentro de otra clase. Las clases llamadas subclases o clases secundarias pueden heredar valores de clases principales , de forma similar a como los niños heredan características de sus padres en el mundo real.

La herencia es útil porque nos permite crear subclases que tienen los mismos tipos de valor que una clase principal, sin tener que declarar esos tipos varias veces.




Parent Clases

Las clases principales (también llamadas clases base crean la estructura maestra a la que pueden acceder las subclases. Podemos crear múltiples subclases sin tener que declarar el mismo conjunto de valores comunes sobre el derivado métodos de clase de la clase principal.

Usemos un ejemplo para ilustrar cómo funcionaría esto en acción. Digamos que teníamos un programa que funciona con dos tipos de cuentas bancarias diferentes: principal y secundaria.

El 81% de los participantes afirmaron que se sentían más seguros sobre sus perspectivas laborales en tecnología después de asistir a un bootcamp. amp hoy.

El graduado promedio de bootcamp pasó menos de seis meses en la transición de carrera, desde comenzar un bootcamp hasta encontrar su primer trabajo.

Ambas cuentas son cuentas bancarias, por lo que tendrán valores similares. Pero cada una de estas cuentas puede requerir su propia información única. Por ejemplo, la cuenta de un padre puede admitir un sobregiro, mientras que la cuenta del niño solo puede funcionar con su saldo.

Por lo tanto, si quisiéramos crear un programa con estos valores, primero definiríamos una clase para nuestra cuenta bancaria (una clase principal) y luego crear clases secundarias para los dos tipos de cuentas bancarias & mdash; principal y secundaria & mdash; que queremos respaldar.

A continuación, se muestra un ejemplo de cómo declarar una clase principal para una cuenta bancaria:

 class BankAccount: def __init __ (self, forename, surname, balance): self. forename = nombre self.surname = apellido self.balance = saldo 

Hemos creado la clase BankAccount que almacena tres valores: nombre, apellido y saldo. También podemos agregar métodos a nuestra clase, así:

 class BankAccount: def __init __ (self, forename, apellido, saldo): self.forename = nombre self.surname = apellido self.balance = saldo def getDetails (self): print ("Nombre:", self.forename) print ("Apellido:", self.surname) def getBalance (self): print ("Balance: $", self.balance) 

Nuestra clase ahora almacena tres valores, así como dos métodos nuevos: detalles y saldo. El método detalles se puede utilizar para averiguar el nombre y apellido del titular de la cuenta, y el método balance devolverá el saldo del titular de la cuenta.


Cada método y variable que declaramos en nuestra clase BankAccount será accesible en nuestra clase secundaria.

Para ilustrar nuestra clase en acción, creemos una cuenta bancaria de ejemplo. Podemos hacerlo usando el siguiente código:

Esto creará una cuenta para John Appleseed que contiene $ 100. Ahora que tenemos nuestra cuenta lista, podemos comenzar a hacer referencia a ella como lo haríamos con cualquier otra clase. Aquí hay un ejemplo de nosotros ejecutando el método getBalance () dentro de nuestra cuenta bancaria para averiguar cuánto dinero que tenemos:

 print (account.getBalance ()) 

Nuestro programa devuelve lo siguiente:

 Saldo: $ 100 
 


Clases secundarias

En el ejemplo anterior, declaramos una clase principal que almacena cuentas bancarias. Pero, ¿qué pasa si queremos almacenar información sobre un tipo específico de cuenta, como la cuenta de un niño menor de 18 años? Ahí es donde entran las clases secundarias.

Las clases secundarias, o subclases, heredan valores de la clase principal. Esto significa que cada clase secundaria podrá hacer referencia a los métodos y variables que declaramos en nuestra clase principal.

Entonces, digamos que queremos crear una clase secundaria para una ChildBankAccount . Esta cuenta debe poder devolver la información de la cuenta bancaria de un usuario, su nombre y saldo, y también debe tener un nuevo valor llamado restringido . Este valor se almacenará en la cuenta de un niño porque es menor de 18 años y no es elegible para una cuenta bancaria completa.

Para crear una clase para niños, podemos usar el siguiente código:

 class ChildBankAccount (BankAccount): 

El ChildBankAccount < La clase / code> se convierte en hijo de la clase BankAccount porque BankAccount está entre paréntesis. Si queremos que nuestra clase secundaria tenga exactamente los mismos valores que nuestra clase principal & mdash; BankAccount & mdash; podemos usar la palabra clave pass como esta:

 class ChildBankAccount (BankAccount): pass 

Pero como discutimos anteriormente, nuestra cuenta secundaria necesitará para almacenar un valor especial: una variable que dice que la cuenta del usuario está restringida.

Para lograr este objetivo, vamos a agregar un nuevo valor llamado restringido a nuestro clase infantil. Podemos hacer esto usando el siguiente código:

 class ChildBankAccount (BankAccount): def __init __ (self, forename, apellido, saldo, restringido = Verdadero): self.forename = nombre de pila self.surname = apellido self.balance = balance self.restricted = restringido def isRestricted (self): print ("Esta cuenta está restringida porque el usuario es menor de 18 años". ) 

Ahora, analicemos nuestro código.

En el código anterior, indicamos que queremos que nuestras ChildBankAccounts contengan cuatro valores: nombre, apellido, equilibrado y restringido.

"Career Karma entró en mi vida cuando más lo necesitaba y rápidamente me ayudó a combinar con un bootcamp. Dos meses después de graduarme, encontré el trabajo de mis sueños que se alineaba con mis valores y objetivos en vida! "

Venus, ingeniero de software de Rockbot

Los primeros tres & mdash; nombre, apellido y saldo & mdash; son los mismos que nuestros valores de clase padre pero restringidos  es nuevo y exclusivo de nuestra clase para niños. De forma predeterminada, restringido se establece en True .

Entonces, si creamos una BankAccount estándar (no una ChildBankAccount ), no podremos acceder al valor restringido . Del mismo modo, no podremos acceder al método isRestricted a menos que creemos una ChildBankAccount .

Aquí tienes un ejemplo de cómo creamos una ChildBankAccount y usando los métodos getBalance () y isResticted () para aprender más sobre nuestra clase:

 child_account = ChildBankAccount (" Bill "," Appleseed ", 100) print (child_account.getBalance ()) print (child_account.isRestricted ()) 

Nuestro código devuelve lo siguiente:

 Saldo: $ 100 Esta cuenta está restringida ya que el usuario es menor de 18 años. 

Como puede ver, nuestro programa primero define una nueva ChildBankAccount para Bill Appleseed , cuya cuenta tiene $ 100. Luego, nuestro programa ejecuta el método getBalance () en nuestra clase, que devuelve el saldo del usuario.  getBalance () se declara en nuestra clase principal, BankAccount , pero es accesible para ChildBankAccount a través de herencia .

Nuestro programa también ejecuta el método isRestricted () , que establece que la cuenta del niño está restringida porque es menor de 18 años. Esta clase está declarada en ChildBankAccount , sin embargo, lo que significa que no es accesible para nuestra clase padre BankAccount . Si quisiéramos crear una BankAccount restringida, necesitaríamos cambiar la clase principal.




Redefiniendo los métodos principales

En nuestro ejemplo anterior, declaramos una clase principal llamada BankAccount que almacena información para cuentas bancarias. También creamos una clase secundaria llamada ChildBankAccount que almacena información para los titulares de cuentas menores de 18 años. Esta clase heredó los métodos de la clase BankAccount y también creó el isRestricted () .

Pero, ¿qué pasa si queremos modificar un método de clase padre existente? Supongamos que queremos que nuestro saldo de BankAccount devuelva un mensaje con su saldo y un mensaje que indique Usted es elegible para un sobregiro , pero no queremos que esto aparezca para Titulares de ChildBankAccount .

Para hacer esto, necesitamos anular nuestro método principal.

Aquí está el código para nuestro método principal revisado, BankAccount , que ahora imprime un mensaje a los titulares de cuentas para decirles que son elegibles para un sobregiro cuando verifican su saldo:

 class BankAccount: def __init __ (self, forename, surname, balance): self.forename = forename self.surname = lastname self.balance = balance def getDetails (self): print ("Forename:", self.forename ) print ("Apellido:", self.surname) def getBalance (self): print ("Saldo: $", self.balance) print ("Eres elegible para un sobregiro.") 

Ahora, si creamos una nueva BankAccount para John Appleseed  e imprima su saldo, veremos un mensaje que indica Usted es elegible para un sobregiro . Aquí hay un ejemplo de cómo declaramos una cuenta nueva y verificamos su saldo:

 account = BankAccount ("John "," Appleseed ", 100) print (account.getBalance ()) 

Nuestro código devuelve lo siguiente:

 Saldo: $ 100 Usted es elegible para un sobregiro. 

Pero este cambio también significa que nuestra ChildBankAccount , que hereda sus valores de BankAccount , también verá el mensaje. Este es un ejemplo de cómo creamos una ChildBankAccount y verificamos su saldo ahora que nuestra clase principal BankAccount ha cambiado:

 child_account = ChildBankAccount (" Bill "," Appleseed ", 100) print (child_account.getBalance ()) 

Nuestro código devuelve:

 Saldo: $ 100 Usted es elegible para un sobregiro. 

Debido a que generalmente no se permiten sobregiros a los niños, tendremos que hacer un cambio en nuestro código. Ahora, para hacerlo, tenemos que modificar nuestra clase ChildBankAccount y declarar una nueva función getBalance () .


Aquí está el código para nuestra ChildBankAccount de arriba:

 class ChildBankAccount (BankAccount): def __init __ (self, nombre, apellido, saldo, restringido = verdadero): self.forename = nombre self.surname = apellido self.balance = saldo self.restricted = restringido def isRestricted ( self): print ("Esta cuenta está restringida porque el usuario es menor de 18 años") 

Necesitamos cambiar este código para agregar una nueva función: getBalance () . Esta función funcionará de la misma manera que la que declaramos en nuestra clase principal, pero no incluirá el mensaje sobre sobregiros. Aquí está el código que agregaríamos para declarar nuestra nueva función:

 & hellip; def getBalance (se lf): print ("Balance: $", self.balance) 

Intentemos recuperar el saldo de nuestro hijo ahora:

 child_account = ChildBankAccount (" Bill "," Appleseed ", 100) print (child_account.getBalance ()) 

Nuestro código devuelve lo siguiente:

 Saldo: $ 100 

En En el ejemplo anterior, hemos sobrescrito el método getBalance () en la clase secundaria ChildBankAccount . Nuestro nuevo método getBalance () para ChildBankAccount solo muestra el saldo del usuario. Pero en nuestra clase BankAccount , el método getBalance () muestra tanto el saldo del usuario como el mensaje Usted es elegible para un sobregiro .

La anulación de los métodos principales puede ser útil cuando tiene varios métodos secundarios que pueden usar métodos similares a los de sus padres, pero requieren que se realicen sus propios cambios específicos. Como en el caso anterior, queremos que nuestras cuentas bancarias principales vean un mensaje de sobregiro, pero no nuestras cuentas bancarias secundarias, por lo que anulamos nuestro método principal en ChildBankAccount .




Conclusión < / h2>

La herencia se usa en la programación orientada a objetos para ayudarlo a crear subclases que pueden almacenar valores ya declarados en una clase principal. Esto es útil cuando está creando clases similares que almacenarán valores similares porque puede usar la herencia para crear esas clases sin repetir su código varias veces.

En este tutorial, exploramos el rol de la herencia en Python . También discutimos cómo funcionan la herencia y las clases padre e hijo, luego exploramos cómo anular los métodos padre. ¡Ahora estás listo para trabajar con clases y herencia como un experto en Python!





herencia de python: StackOverflow Questions