{"id":398,"date":"2024-12-21T19:46:57","date_gmt":"2024-12-21T19:46:57","guid":{"rendered":"https:\/\/equipomedios.com\/blog\/?p=398"},"modified":"2024-10-18T19:49:42","modified_gmt":"2024-10-18T19:49:42","slug":"herencia-en-python","status":"publish","type":"post","link":"https:\/\/equipomedios.com\/blog\/herencia-en-python\/","title":{"rendered":"Herencia en Python"},"content":{"rendered":"

Herencia<\/h1>\n

La herencia es una de las premisas y t\u00e9cnicas de la\u00a0POO<\/span>\u00a0la cual permite a los programadores crear una clase general primero y luego m\u00e1s tarde crear clases m\u00e1s especializadas que re-utilicen c\u00f3digo de la clase general. La herencia tambi\u00e9n le permite escribir un c\u00f3digo m\u00e1s limpio y legible.<\/p>\n

<\/span><\/p>\n

Clase Base<\/h2>\n

Clase Base o tambi\u00e9n conocida como\u00a0Clase abstracta<\/em>\u00a0le permite definir una clase que puede heredarse en otras clases los atributos y comportamientos definido en esta.<\/p>\n

\"..\/_images\/clase_abstracta.png\"<\/a><\/p>\n

Clase base o abstracta<\/span><\/p>\n<\/div>\n

Use el diagrama anterior para ilustrar el concepto de la herencia, vea el caso de dos clases que tiene algo en com\u00fan, ambas son personas, con atributos de datos personales y comportamiento t\u00edpicos como hablar, comer, caminar, entonces para eso se crea una clase base llamada\u00a0Persona<\/span><\/code>. A continuaci\u00f3n un ejemplo de la clase\u00a0Persona<\/span><\/code>\u00a0con un m\u00e9todo interno:<\/p>\n

\n
\n
class<\/span> Persona<\/span>(<\/span>object<\/span>):<\/span>\r\n    \"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n\r\n    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> cedula<\/span>,<\/span> nombre<\/span>,<\/span> apellido<\/span>,<\/span> sexo<\/span>):<\/span>\r\n        \"\"\"Constructor de clase Persona\"\"\"<\/span>\r\n        self<\/span>.<\/span>cedula<\/span> =<\/span> cedula<\/span>\r\n        self<\/span>.<\/span>nombre<\/span> =<\/span> nombre<\/span>\r\n        self<\/span>.<\/span>apellido<\/span> =<\/span> apellido<\/span>\r\n        self<\/span>.<\/span>sexo<\/span> =<\/span> sexo<\/span>\r\n\r\n    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n        \"\"\"Devuelve una cadena representativa de Persona\"\"\"<\/span>\r\n        return<\/span> \"<\/span>%s<\/span>: <\/span>%s<\/span>, <\/span>%s<\/span> %s<\/span>, <\/span>%s<\/span>.\"<\/span> %<\/span> (<\/span>\r\n            self<\/span>.<\/span>__doc__<\/span>[<\/span>25<\/span>:<\/span>34<\/span>],<\/span> str<\/span>(<\/span>self<\/span>.<\/span>cedula<\/span>),<\/span> self<\/span>.<\/span>nombre<\/span>,<\/span> \r\n            self<\/span>.<\/span>apellido<\/span>,<\/span> self<\/span>.<\/span>getGenero<\/span>(<\/span>self<\/span>.<\/span>sexo<\/span>))<\/span>\r\n\r\n    def<\/span> hablar<\/span>(<\/span>self<\/span>,<\/span> mensaje<\/span>):<\/span>\r\n        \"\"\"Mostrar mensaje de saludo de Persona\"\"\"<\/span>\r\n        return<\/span> mensaje<\/span>\r\n\r\n    def<\/span> getGenero<\/span>(<\/span>self<\/span>,<\/span> sexo<\/span>):<\/span>\r\n        \"\"\"Mostrar el genero de la Persona\"\"\"<\/span>\r\n        genero<\/span> =<\/span> (<\/span>'Masculino'<\/span>,<\/span>'Femenino'<\/span>)<\/span>\r\n        if<\/span> sexo<\/span> ==<\/span> \"M\"<\/span>:<\/span>\r\n            return<\/span> genero<\/span>[<\/span>0<\/span>]<\/span>\r\n        elif<\/span> sexo<\/span> ==<\/span> \"F\"<\/span>:<\/span>\r\n            return<\/span> genero<\/span>[<\/span>1<\/span>]<\/span>\r\n        else<\/span>:<\/span>\r\n            return<\/span> \"Desconocido\"<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el ejemplo previo, es donde empieza a crear una clase (lo hace con la palabra\u00a0class<\/span><\/code>). La segunda palabra\u00a0Persona<\/span><\/code>\u00a0es el nombre de la clase. La tercera palabra que se encuentra dentro de los par\u00e9ntesis este hace referencia al objeto\u00a0object<\/span>, usando para indicar la clase de la cual precede.<\/p>\n
La clase\u00a0Persona<\/span><\/code>\u00a0tiene los m\u00e9todos\u00a0__init__<\/span><\/code>,\u00a0__str__<\/span><\/code>,\u00a0hablar<\/span><\/code>\u00a0y\u00a0getGenero<\/span><\/code>. Sus atributos son\u00a0cedula<\/span><\/code>,\u00a0nombre<\/span><\/code>,\u00a0apellido<\/span><\/code>\u00a0y\u00a0sexo<\/span><\/code>.<\/p>\n
La instancia de dos nuevos objetos\u00a0Persona<\/span><\/code>\u00a0seria de la siguiente forma:<\/p>\n
\n
\n
persona1<\/span> =<\/span> Persona<\/span>(<\/span>\"V-13458796\"<\/span>,<\/span> \"Leonardo\"<\/span>,<\/span> \"Caballero\"<\/span>,<\/span> \"M\"<\/span>)<\/span>\r\npersona2<\/span> =<\/span> Persona<\/span>(<\/span>\"V-23569874\"<\/span>,<\/span> \"Ana\"<\/span>,<\/span> \"Poleo\"<\/span>,<\/span> \"F\"<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
El m\u00e9todo constructor\u00a0__init__<\/span><\/code>\u00a0es un m\u00e9todo especial el cual debe escribir como:\u00a0MiClase(par\u00e1metros<\/span>\u00a0iniciales<\/span>\u00a0si<\/span>\u00a0hay<\/span>\u00a0cualquiera)<\/span><\/code>.<\/p>\n
Usted puede llamar esos m\u00e9todos y atributos con la siguiente notaci\u00f3n:\u00a0claseinstancia.metodo<\/span><\/code>\u00a0o\u00a0claseinstancia.atributo<\/span><\/code>.<\/p>\n
\n
\n
>>> <\/span>print<\/span> persona1<\/span>.<\/span>nombre<\/span>,<\/span> persona1<\/span>.<\/span>apellido<\/span>\r\n>>> <\/span>print<\/span> persona1<\/span>.<\/span>getGenero<\/span>(<\/span>persona1<\/span>.<\/span>sexo<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
El m\u00e9todo\u00a0__str__<\/span><\/code>\u00a0es un m\u00e9todo usando para imprimir la descripci\u00f3n de la instancia de objeto el cual debe mostrar como:<\/p>\n
\n
\n
print<\/span> \"<\/span>\\n<\/span>\"<\/span> +<\/span> str<\/span>(<\/span>persona1<\/span>)<\/span> +<\/span> \"<\/span>\\n<\/span>\"<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el anterior c\u00f3digo se usan para cierto formato para imprimir la instancia de objeto usando la sentencia\u00a0print<\/span><\/code>, concatenando el car\u00e1cter\u00a0\\n<\/span><\/code>\u00a0para generar un salto de p\u00e1gina y seguidamente convertir a formato cadena de caracteres usando la funci\u00f3n\u00a0str()<\/span><\/code>\u00a0a la instancia de objeto llamada\u00a0persona2<\/span><\/code>.<\/p>\n<\/div>\n
<\/span><\/p>\n
Herencia simple<\/h2>\n
La herencia simple se apoya en el uso de\u00a0clases base<\/span>\u00a0para compartir sus atributos y comportamientos con otros clases derivadas como los siguiente ejemplos el objeto\u00a0Supervisor<\/span><\/code>\u00a0y el objeto\u00a0Obrero<\/span><\/code>.<\/p>\n
\"..\/_images\/poo_herencia.png\"<\/a><\/p>\n
Diagrama de herencia de Objetos<\/span><\/p>\n<\/div>\n
El siguiente es un ejemplo de la clase\u00a0Supervisor<\/span><\/code>\u00a0que derivada de la clase\u00a0Persona<\/span><\/code>\u00a0con funci\u00f3n interna:<\/p>\n
\n
\n
class<\/span> Supervisor<\/span>(<\/span>Persona<\/span>):<\/span>\r\n    \"\"\"Clase que representa a un Supervisor\"\"\"<\/span>\r\n\r\n    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> cedula<\/span>,<\/span> nombre<\/span>,<\/span> apellido<\/span>,<\/span> sexo<\/span>,<\/span> rol<\/span>):<\/span>\r\n        \"\"\"Constructor de clase Supervisor\"\"\"<\/span>\r\n\r\n        # Invoca al constructor de clase Persona<\/span>\r\n        Persona<\/span>.<\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> cedula<\/span>,<\/span> nombre<\/span>,<\/span> apellido<\/span>,<\/span> sexo<\/span>)<\/span>\r\n\r\n        # Nuevos atributos<\/span>\r\n        self<\/span>.<\/span>rol<\/span> =<\/span> rol<\/span>\r\n        self<\/span>.<\/span>tareas<\/span> =<\/span> [<\/span>'10'<\/span>,<\/span>'11'<\/span>,<\/span>'12'<\/span>,<\/span>'13'<\/span>]<\/span>\r\n\r\n    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n        \"\"\"Devuelve una cadena representativa al Supervisor\"\"\"<\/span>\r\n        return<\/span> \"<\/span>%s<\/span>: <\/span>%s<\/span> %s<\/span>, rol: '<\/span>%s<\/span>', sus tareas: <\/span>%s<\/span>.\"<\/span> %<\/span> (<\/span>\r\n            self<\/span>.<\/span>__doc__<\/span>[<\/span>26<\/span>:<\/span>37<\/span>],<\/span> self<\/span>.<\/span>nombre<\/span>,<\/span> self<\/span>.<\/span>apellido<\/span>,<\/span> \r\n            self<\/span>.<\/span>rol<\/span>,<\/span> self<\/span>.<\/span>consulta_tareas<\/span>())<\/span>\r\n\r\n    def<\/span> consulta_tareas<\/span>(<\/span>self<\/span>):<\/span>\r\n        \"\"\"Mostrar las tareas del Supervisor\"\"\"<\/span>\r\n        return<\/span> ', '<\/span>.<\/span>join<\/span>(<\/span>self<\/span>.<\/span>tareas<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Ahora, se crear\u00e1 una nueva clase\u00a0Supervisor<\/span><\/code>\u00a0con los mismos m\u00e9todos y atributos como la clase\u00a0Persona<\/span><\/code>, pero con dos nuevos atributos\u00a0rol<\/span><\/code>\u00a0y\u00a0tareas<\/span><\/code>. No se copia la clase previa, pero si\u00a0se hereda<\/strong>\u00a0de ella.<\/p>\n
La instancia del nuevo objeto\u00a0Supervisor<\/span><\/code>\u00a0seria de la siguiente forma:<\/p>\n
\n
\n
supervisor1<\/span> =<\/span> Supervisor<\/span>(<\/span>\"V-16987456\"<\/span>,<\/span> \"Jen\"<\/span>,<\/span> \"Paz\"<\/span>,<\/span> \"D\"<\/span>,<\/span> \"Chivo\"<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Luego que gener\u00e1 la instancia del nuevo objeto\u00a0Supervisor<\/span><\/code>\u00a0llamada\u00a0supervisor1<\/span><\/code>\u00a0se puede imprimir sus detalles de la siguiente forma:<\/p>\n
\n
\n
print<\/span> \"<\/span>\\n<\/span>\"<\/span> +<\/span> str<\/span>(<\/span>supervisor1<\/span>)<\/span> +<\/span> \"<\/span>\\n<\/span>\"<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Como la instancia de objeto\u00a0supervisor1<\/span><\/code>\u00a0hereda los atributo(s) y m\u00e9todo(s) de la clase\u00a0Persona<\/span><\/code>\u00a0usted puede reusarlo y llamarlo de la siguiente forma:<\/p>\n
\n
\n
print<\/span> \"- Cedula de identidad: <\/span>{0}<\/span>.\"<\/span>.<\/span>format<\/span>(<\/span>supervisor1<\/span>.<\/span>cedula<\/span>)<\/span>\r\nprint<\/span> \"- Nombre completo: <\/span>{0}<\/span> {1}<\/span>.\"<\/span>.<\/span>format<\/span>(<\/span>\r\n\tsupervisor1<\/span>.<\/span>nombre<\/span>,<\/span> supervisor1<\/span>.<\/span>apellido<\/span>)<\/span>\r\nprint<\/span> \"- Genero: <\/span>{0}<\/span>.\"<\/span>.<\/span>format<\/span>(<\/span>\r\n\tsupervisor1<\/span>.<\/span>getGenero<\/span>(<\/span>supervisor1<\/span>.<\/span>sexo<\/span>))<\/span>\r\nprint<\/span> \"- <\/span>{0}<\/span> {1}<\/span> dijo: <\/span>{2}<\/span>\"<\/span>.<\/span>format<\/span>(<\/span>\r\n\tsupervisor1<\/span>.<\/span>nombre<\/span>,<\/span> supervisor1<\/span>.<\/span>apellido<\/span>,<\/span> \r\n\tsupervisor1<\/span>.<\/span>hablar<\/span>(<\/span>\"A trabajar Leonardo!!!\"<\/span>.<\/span>upper<\/span>()))<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Si desea usar los atributo(s) y m\u00e9todo(s) heredados de la clase\u00a0Supervisor<\/span><\/code>\u00a0se puede imprimir de la siguiente forma:<\/p>\n
\n
\n
print<\/span> \"- Rol: <\/span>{0}<\/span>.\"<\/span>.<\/span>format<\/span>(<\/span>supervisor1<\/span>.<\/span>rol<\/span>)<\/span>\r\nprint<\/span> \"- N. Tareas: <\/span>{0}<\/span>.\"<\/span>.<\/span>format<\/span>(<\/span>supervisor1<\/span>.<\/span>consulta_tareas<\/span>())<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
El uso de las clases y la programaci\u00f3n orientada a objetos, le permite a usted que pueda organizar el c\u00f3digo con diferentes clases correspondientes a diferentes objetos que encontrar\u00e1 (una clase\u00a0Persona<\/span><\/code>, una clase\u00a0Carro<\/span><\/code>, una clase\u00a0Departamento<\/span><\/code>, etc.), con sus propios m\u00e9todos y atributos. Luego puede usar la herencia para considerar las variaciones en torno a una clase base y reutilizar el c\u00f3digo. Ej.: a partir de una clase base de\u00a0Persona<\/span><\/code>, usted puede crear clases derivadas como\u00a0Supervisor<\/span><\/code>,\u00a0JefeCuadrilla<\/span><\/code>,\u00a0Obrero<\/span><\/code>, etc.<\/p>\n
\n
\n
print<\/span> \"\"\"<\/span>\\n<\/span>Hola, Soy el <\/span>{0}<\/span> {1}<\/span> {2}<\/span>, mi c\u00e9dula es '<\/span>{3}<\/span>', <\/span>\r\nmi genero '<\/span>{4}<\/span>', con el rol '<\/span>{5}<\/span>' y mis tareas<\/span>\r\nasignadas '<\/span>{6}<\/span>'.\"\"\"<\/span>.<\/span>format<\/span>(<\/span>\r\n    supervisor1<\/span>.<\/span>__doc__<\/span>[<\/span>26<\/span>:<\/span>37<\/span>]<\/span>.<\/span>lower<\/span>(),<\/span>\r\n    supervisor1<\/span>.<\/span>nombre<\/span>,<\/span> supervisor1<\/span>.<\/span>apellido<\/span>,<\/span> supervisor1<\/span>.<\/span>cedula<\/span>,<\/span> \r\n    supervisor1<\/span>.<\/span>getGenero<\/span>(<\/span>supervisor1<\/span>.<\/span>sexo<\/span>),<\/span> supervisor1<\/span>.<\/span>rol<\/span>,<\/span>\r\n    supervisor1<\/span>.<\/span>consulta_tareas<\/span>())<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
Funci\u00f3n issubclass()<\/h3>\n
issubclass()<\/span><\/code>, es una\u00a0funci\u00f3n integrada<\/span>\u00a0la cual le permite corroborar si un objeto es instancia de una clase.<\/p>\n
<\/div>\n
<\/div>\n
\n
\n
\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Herencia m\u00faltiple<\/h2>\n
A diferencia de lenguajes como\u00a0Java<\/em>\u00a0y\u00a0C#<\/em>, el lenguaje\u00a0Python<\/em>\u00a0permite la herencia m\u00faltiple, es decir, se puede heredar de m\u00faltiples clases.<\/p>\n
La herencia m\u00faltiple es la capacidad de una subclase de heredar de m\u00faltiples s\u00faper clases.<\/p>\n
Esto conlleva un problema, y es que si varias s\u00faper clases tienen los mismos atributos o m\u00e9todos, la subclase s\u00f3lo podr\u00e1 heredar de una de ellas.<\/p>\n
En estos casos Python dar\u00e1 prioridad a las clases m\u00e1s a la izquierda en el momento de la declaraci\u00f3n de la subclase:<\/p>\n
\n
\n
class<\/span> Destreza<\/span>(<\/span>object<\/span>):<\/span>\r\n    \"\"\"Clase la cual representa la Destreza de la Persona\"\"\"<\/span>\r\n\r\n    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> area<\/span>,<\/span> herramienta<\/span>,<\/span> experiencia<\/span>):<\/span>\r\n        \"\"\"Constructor de clase Destreza\"\"\"<\/span>\r\n        self<\/span>.<\/span>area<\/span> =<\/span> area<\/span>\r\n        self<\/span>.<\/span>herramienta<\/span> =<\/span> herramienta<\/span>\r\n        self<\/span>.<\/span>experiencia<\/span> =<\/span> experiencia<\/span>\r\n\r\n    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n        \"\"\"Devuelve una cadena representativa de la Destreza\"\"\"<\/span>\r\n        return<\/span> \"\"\"Destreza en el \u00e1rea <\/span>%s<\/span> con la herramienta <\/span>%s<\/span>, <\/span>\r\n        tiene <\/span>%s<\/span> a\u00f1os de experiencia.\"\"\"<\/span> %<\/span> (<\/span>\r\n            str<\/span>(<\/span>self<\/span>.<\/span>area<\/span>),<\/span> self<\/span>.<\/span>experiencia<\/span>,<\/span> self<\/span>.<\/span>herramienta<\/span>)<\/span>\r\n\r\n\r\nclass<\/span> JefeCuadrilla<\/span>(<\/span>Supervisor<\/span>,<\/span> Destreza<\/span>):<\/span>\r\n    \"\"\"Clase la cual representa al Jefe de Cuadrilla\"\"\"<\/span>\r\n\r\n    def<\/span> __init__<\/span>(<\/span>self<\/span>,<\/span> cedula<\/span>,<\/span> nombre<\/span>,<\/span> apellido<\/span>,<\/span> sexo<\/span>,<\/span> \r\n        rol<\/span>,<\/span> area<\/span>,<\/span> herramienta<\/span>,<\/span> experiencia<\/span>,<\/span> cuadrilla<\/span>):<\/span>\r\n        \"\"\"Constructor de clase Jefe de Cuadrilla\"\"\"<\/span>\r\n\r\n        # Invoca al constructor de clase Supervisor<\/span>\r\n        Supervisor<\/span>.<\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> cedula<\/span>,<\/span> nombre<\/span>,<\/span> apellido<\/span>,<\/span> sexo<\/span>,<\/span> \r\n            rol<\/span>)<\/span>\r\n        # Invoca al constructor de clase Destreza<\/span>\r\n        Destreza<\/span>.<\/span>__init__<\/span>(<\/span>self<\/span>,<\/span> area<\/span>,<\/span> herramienta<\/span>,<\/span> experiencia<\/span>)<\/span>\r\n\r\n        # Nuevos atributos<\/span>\r\n        self<\/span>.<\/span>cuadrilla<\/span> =<\/span> cuadrilla<\/span>\r\n\r\n    def<\/span> __str__<\/span>(<\/span>self<\/span>):<\/span>\r\n        \"\"\"Devuelve cadena representativa al Jefe de Cuadrilla\"\"\"<\/span>\r\n        jq<\/span> =<\/span> \"<\/span>{0}<\/span>: <\/span>{1}<\/span> {2}<\/span>, rol '<\/span>{3}<\/span>', tareas <\/span>{4}<\/span>, cuadrilla: <\/span>{5}<\/span>\"<\/span>\r\n        return<\/span> jq<\/span>.<\/span>format<\/span>(<\/span>\r\n            self<\/span>.<\/span>__doc__<\/span>[<\/span>28<\/span>:<\/span>46<\/span>],<\/span> self<\/span>.<\/span>nombre<\/span>,<\/span> self<\/span>.<\/span>apellido<\/span>,<\/span> \r\n            self<\/span>.<\/span>rol<\/span>,<\/span> self<\/span>.<\/span>consulta_tareas<\/span>(),<\/span> self<\/span>.<\/span>cuadrilla<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Method Resolution Order (MRO)<\/h3>\n
Ese es el orden en el cual el m\u00e9todo debe heredar en la presencia de herencia m\u00faltiple. Usted puede ver el MRO usando el atributo\u00a0__mro__<\/span><\/code>.<\/p>\n
\n
\n
>>> <\/span>JefeCuadrilla<\/span>.<\/span>__mro__<\/span>\r\n(<class '__main__.JefeCuadrilla'>,<\/span>\r\n<class '__main__.Supervisor'>,<\/span>\r\n<class '__main__.Persona'>,<\/span>\r\n<class '__main__.Destreza'>,<\/span>\r\n<type 'object'>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
\n
>>> <\/span>Supervisor<\/span>.<\/span>__mro__<\/span>\r\n(<class '__main__.Supervisor'>,<\/span>\r\n<class '__main__.Persona'>,<\/span>\r\n<type 'object'>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
\n
\n
>>> <\/span>Destreza<\/span>.<\/span>__mro__<\/span>\r\n(<class '__main__.Destreza'>,<\/span>\r\n<type 'object'>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
El\u00a0MRO<\/em>\u00a0es calculado en Python de la siguiente forma:<\/p>\n
Un m\u00e9todo en la llamada derivada es siempre llamada antes de m\u00e9todo de la clase base. En nuestro ejemplo, la clase\u00a0JefeCuadrilla<\/span><\/code>\u00a0es llamada antes de las clases\u00a0Supervisor<\/span><\/code>\u00a0o\u00a0Destreza<\/span><\/code>. Esas dos clases son llamada antes de la clase\u00a0Persona<\/span><\/code>\u00a0y la clase\u00a0Persona<\/span><\/code>\u00a0es llamada antes de la clase\u00a0object<\/span><\/code>.<\/p>\n
Si hay herencia m\u00faltiple como\u00a0JefeCuadrilla(Supervisor,<\/span>\u00a0Destreza)<\/span><\/code>, el m\u00e9todo invoca a\u00a0Supervisor<\/span><\/code>\u00a0primero por que ese aparece primero de izquierda a derecha.<\/p>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Herencia La herencia es una de las premisas y t\u00e9cnicas de la\u00a0POO\u00a0la cual permite a los programadores crear una clase general primero y luego m\u00e1s tarde crear clases m\u00e1s especializadas que re-utilicen c\u00f3digo de la clase general. La herencia tambi\u00e9n le permite escribir un c\u00f3digo m\u00e1s limpio y legible. Clase Base Clase Base o tambi\u00e9n […]<\/p>\n","protected":false},"author":1,"featured_media":331,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[39,40],"tags":[],"class_list":["post-398","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programacion","category-python"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/equipomedios.com\/blog\/wp-content\/uploads\/2024\/08\/python-logo-master-v3-TM.png?fit=601%2C203&ssl=1","jetpack_sharing_enabled":true,"jetpack-related-posts":[],"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/398","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/comments?post=398"}],"version-history":[{"count":1,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/398\/revisions"}],"predecessor-version":[{"id":399,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/398\/revisions\/399"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media\/331"}],"wp:attachment":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media?parent=398"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/categories?post=398"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/tags?post=398"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}