{"id":395,"date":"2024-12-19T19:42:58","date_gmt":"2024-12-19T19:42:58","guid":{"rendered":"https:\/\/equipomedios.com\/blog\/?p=395"},"modified":"2024-10-18T19:46:23","modified_gmt":"2024-10-18T19:46:23","slug":"programacion-orientada-a-objetos-en-python","status":"publish","type":"post","link":"https:\/\/equipomedios.com\/blog\/programacion-orientada-a-objetos-en-python\/","title":{"rendered":"Programaci\u00f3n orientada a objetos en Python"},"content":{"rendered":"<h1>Programaci\u00f3n orientada a objetos<\/h1>\n<p>La programaci\u00f3n orientada a objetos (POO, u OOP seg\u00fan sus siglas en ingl\u00e9s) es un paradigma de programaci\u00f3n que viene a innovar la forma de obtener resultados. Los objetos manipulan los datos de entrada para la obtenci\u00f3n de datos de salida espec\u00edficos, donde cada objeto ofrece una funcionalidad especial.<\/p>\n<p>Muchos de los objetos predise\u00f1ados de los lenguajes de programaci\u00f3n actuales permiten la agrupaci\u00f3n en bibliotecas o librer\u00edas, sin embargo, muchos de estos lenguajes permiten al usuario la creaci\u00f3n de sus propias bibliotecas.<\/p>\n<div id=\"id2\" class=\"figure align-center\">\n<p><a class=\"reference internal image-reference\" href=\"https:\/\/i0.wp.com\/entrenamiento-python-basico.readthedocs.io\/es\/2.7\/_images\/oop.jpg?ssl=1\"><img decoding=\"async\" src=\"https:\/\/i0.wp.com\/entrenamiento-python-basico.readthedocs.io\/es\/2.7\/_images\/oop.jpg?w=640&#038;ssl=1\" alt=\"..\/_images\/oop.jpg\" data-recalc-dims=\"1\" \/><\/a><\/p>\n<p class=\"caption\"><span class=\"caption-text\">Programaci\u00f3n Orientada a Objetos &#8211; POO<\/span><\/p>\n<\/div>\n<p>Est\u00e1 basada en varias t\u00e9cnicas, como las siguientes:<\/p>\n<ul class=\"simple\">\n<li><span class=\"std std-ref\">herencia<\/span>.<\/li>\n<li>cohesi\u00f3n.<\/li>\n<li><span class=\"std std-ref\">abstracci\u00f3n<\/span>.<\/li>\n<li><span class=\"std std-ref\">polimorfismo<\/span>.<\/li>\n<li>acoplamiento.<\/li>\n<li><span class=\"std std-ref\">encapsulaci\u00f3n<\/span>.<\/li>\n<\/ul>\n<p>La POO tiene sus ra\u00edces en la d\u00e9cada del 60 con el lenguaje de programaci\u00f3n\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Simula<\/span><\/code>\u00a0que en 1967, el cual fue el primer lenguaje que posee las caracter\u00edsticas principales de un lenguaje orientado a objetos.<\/p>\n<p>Smalltalk (de 1972 a 1980) es posiblemente el ejemplo can\u00f3nico, y con el que gran parte de la teor\u00eda de la POO se ha desarrollado. M\u00e1s su uso se populariz\u00f3 a principios de la d\u00e9cada de 1990.<\/p>\n<p>En la actualidad, existe una gran variedad de lenguajes de programaci\u00f3n que soportan la orientaci\u00f3n a objetos.<\/p>\n<p>Los objetivos de la POO son:<\/p>\n<ul class=\"simple\">\n<li>Organizar el c\u00f3digo fuente, y<\/li>\n<li>re-usar c\u00f3digo fuente en similares contextos.<\/li>\n<\/ul>\n<div class=\"admonition note\">\n<p class=\"first admonition-title\">Nota<\/p>\n<p class=\"last\">M\u00e1s informaci\u00f3n consulte el articulo de Wikipedia\u00a0Programaci\u00f3n orientada a objetos.<\/p>\n<\/div>\n<div id=\"poo-en-python\" class=\"section\">\n<h2>POO en Python<\/h2>\n<p>El mecanismo de clases de Python agrega clases al lenguaje con un m\u00ednimo de nuevas sintaxis y sem\u00e1nticas.<\/p>\n<p>En Python las clases es una mezcla de los mecanismos de clase encontrados en\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">C++<\/span><\/code>\u00a0y\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Modula-3<\/span><\/code>.<\/p>\n<p>Como es cierto para los m\u00f3dulos, las clases en Python no ponen una barrera absoluta entre la definici\u00f3n y el usuario, sino que m\u00e1s bien se apoya en la cortes\u00eda del usuario de no \u00abforzar la definici\u00f3n\u00bb.<\/p>\n<p>Sin embargo, se mantiene el poder completo de las caracter\u00edsticas m\u00e1s importantes de las clases: el mecanismo de la herencia de clases permite m\u00faltiples clases base, una clase derivada puede sobrescribir cualquier m\u00e9todo de su(s) clase(s) base, y un m\u00e9todo puede llamar al m\u00e9todo de la clase base con el mismo nombre.<\/p>\n<blockquote>\n<div><em>\u00abLos objetos pueden tener una cantidad arbitraria de datos.\u00bb<\/em><\/div>\n<\/blockquote>\n<p>En terminolog\u00eda de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">C++<\/span><\/code>, todos los miembros de las clases (incluyendo los miembros de datos), son\u00a0<em>p\u00fablicos<\/em>, y todas las funciones miembro son\u00a0<em>virtuales<\/em>.<\/p>\n<p>Como en\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Modula-3<\/span><\/code>, no hay atajos para hacer referencia a los miembros del objeto desde sus m\u00e9todos: la funci\u00f3n m\u00e9todo se declara con un primer argumento expl\u00edcito que representa al objeto, el cual se provee impl\u00edcitamente por la llamada.<\/p>\n<p>Como en\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Smalltalk<\/span><\/code>, las clases mismas son objetos. Esto provee una sem\u00e1ntica para importar y renombrar.<\/p>\n<p>A diferencia de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">C++<\/span><\/code>\u00a0y\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Modula-3<\/span><\/code>, los tipos de datos integrados pueden usarse como clases base para que el usuario los extienda.<\/p>\n<p>Tambi\u00e9n, como en\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">C++<\/span><\/code>\u00a0pero a diferencia de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Modula-3<\/span><\/code>, la mayor\u00eda de los operadores integrados con sintaxis especial (operadores aritm\u00e9ticos, de sub\u00edndice, etc.) pueden ser redefinidos por instancias de la clase.<\/p>\n<p>(Sin haber una terminolog\u00eda universalmente aceptada sobre clases, har\u00e9 uso ocasional de t\u00e9rminos de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Smalltalk<\/span><\/code>\u00a0y\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">C++<\/span><\/code>. Usar\u00eda t\u00e9rminos de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Modula-3<\/span><\/code>, ya que su sem\u00e1ntica orientada a objetos es m\u00e1s cercana a Python que\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">C++<\/span><\/code>, pero no espero que muchos lectores hayan escuchado hablar de \u00e9l).<\/p>\n<p>Algunas particularidades de POO en Python son las siguientes:<\/p>\n<ul class=\"simple\">\n<li>Todo es un objeto, incluyendo los tipos y clases.<\/li>\n<li>Permite herencia m\u00faltiple.<\/li>\n<li>No existen m\u00e9todos ni atributos privados.<\/li>\n<li>Los atributos pueden ser modificados directamente.<\/li>\n<li>Permite \u00abmonkey patching\u00bb.<\/li>\n<li>Permite \u00abduck typing\u00bb.<\/li>\n<li>Permite la sobrecarga de operadores.<\/li>\n<li>Permite la creaci\u00f3n de nuevos tipos de datos.<\/li>\n<\/ul>\n<p>A continuaci\u00f3n se procede a definir algunos conceptos necesarios para entender la POO:<\/p>\n<\/div>\n<div id=\"objetos\" class=\"section\">\n<p>&nbsp;<\/p>\n<h2>Objetos<\/h2>\n<p>Los\u00a0<em>objetos<\/em>\u00a0son abstracci\u00f3n de Python para data. Toda la data en un programa Python es representado por objectos o por relaciones entre objectos. (En cierto sentido, y en el c\u00f3digo modelo de Von Neumann de una \u00abcomputadora almacenada del programa\u00bb tambi\u00e9n es un c\u00f3digo representado por los objetos.)<\/p>\n<p>Cada objeto tiene una identidad, un tipo y un valor. Una identidad de objecto nunca cambia una vez es creada; usted puede pensar eso como la direcci\u00f3n de objeto en memoria. El operador\u00a0<span class=\"std std-ref\">in<\/span>\u00a0compara la identidad de dos objetos; la funci\u00f3n\u00a0<span class=\"std std-ref\">id()<\/span>\u00a0devuelve un n\u00famero entero representando la identidad (actualmente implementado como su direcci\u00f3n).<\/p>\n<p>El\u00a0<em>tipo<\/em>\u00a0de un objeto tambi\u00e9n es inmutable. El tipo de un objeto determina las operaciones que admite el objeto (por ejemplo, \u00ab\u00bftiene una longitud?\u00bb) Y tambi\u00e9n define los valores posibles para los objetos de ese tipo. La funci\u00f3n \u00ab<span class=\"std std-ref\">type()<\/span>\u00bb devuelve el tipo de un objeto (que es un objeto en s\u00ed mismo). El\u00a0<em>valor *de algunos objetos puede cambiar. Se dice que los objetos cuyo valor puede cambiar son *mutables<\/em>; los objetos cuyo valor no se puede cambiar una vez que se crean se llaman\u00a0<em>immutable<\/em>. (El valor de un objeto contenedor inmutable que contiene una referencia a un objeto mutable puede cambiar cuando se cambia el valor de este \u00faltimo; sin embargo, el contenedor todav\u00eda se considera inmutable, porque la colecci\u00f3n de objetos que contiene no se puede cambiar. Por lo tanto, la inmutabilidad no es estrictamente lo mismo que tener un valor incambiable, es m\u00e1s sutil.) La mutabilidad de un objeto est\u00e1 determinada por su tipo; por ejemplo, los n\u00fameros, las cadenas y las tuplas son inmutables, mientras que los diccionarios y las listas son mutables.<\/p>\n<p>Los objetos son la clave para entender la\u00a0<span class=\"std std-ref\">POO<\/span>. Si mira a nuestro alrededor encontrar\u00e1 un sin fin de objetos de la vida real: perro, escritorio, televisor, bicicleta, etc\u2026<\/p>\n<p>En Python puede definir una clase con la palabra reservada\u00a0<span class=\"std std-ref\">class<\/span>, de la siguiente forma:<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"k\">class<\/span> <span class=\"nc\">Persona<\/span><span class=\"p\">:<\/span>\r\n    <span class=\"k\">pass<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>En el ejemplo anterior, el nombre de la clase es\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Persona<\/span><\/code>\u00a0y dentro del bloque de c\u00f3digo usa la sentencia\u00a0<span class=\"std std-ref\">pass<\/span>. Aunque no es requerido por el int\u00e9rprete, los nombres de las clases se escriben por convenci\u00f3n capitalizadas. Las clases pueden (y siempre deber\u00edan) tener comentarios.<\/p>\n<div id=\"id3\" class=\"figure align-center\">\n<p><a class=\"reference internal image-reference\" href=\"https:\/\/i0.wp.com\/entrenamiento-python-basico.readthedocs.io\/es\/2.7\/_images\/objetos_clases.png?ssl=1\"><img decoding=\"async\" src=\"https:\/\/i0.wp.com\/entrenamiento-python-basico.readthedocs.io\/es\/2.7\/_images\/objetos_clases.png?w=640&#038;ssl=1\" alt=\"..\/_images\/objetos_clases.png\" data-recalc-dims=\"1\" \/><\/a><\/p>\n<p class=\"caption\"><span class=\"caption-text\">Diagrama de Objeto Persona<\/span><\/p>\n<\/div>\n<div id=\"estado-de-un-objeto\" class=\"section\">\n<h3>Estado de un objeto<\/h3>\n<p>El conjunto de datos y objetos relacionados con un objeto en un momento dado, se le conoce como \u00abestado\u00bb. Un objeto puede tener m\u00faltiples estados a lo largo de su existencia conforme se relaciona con su entorno y otros objetos.<\/p>\n<div id=\"index-0\" class=\"admonition-todo admonition\">\n<p class=\"last\"><span style=\"color: #666666; font-size: 1.25rem;\">Atributos<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n<div id=\"atributos\" class=\"section\">\n<p>Los atributos o propiedades de los objetos son las caracter\u00edsticas que puede tener un objeto, como el color. Si el objeto es\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Persona<\/span><\/code>, los atributos podr\u00edan ser:\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">cedula<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">nombre<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">apellido<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">sexo<\/span><\/code>, etc\u2026<\/p>\n<p>Los atributos describen el estado de un objeto. Pueden ser de cualquier tipo de dato.<\/p>\n<div class=\"highlight-python notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"k\">class<\/span> <span class=\"nc\">Persona<\/span><span class=\"p\">:<\/span>\r\n    <span class=\"sd\">\"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n    <span class=\"n\">cedula<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"V-13458796\"<\/span>\r\n    <span class=\"n\">nombre<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Leonardo\"<\/span>\r\n    <span class=\"n\">apellido<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Caballero\"<\/span>\r\n    <span class=\"n\">sexo<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"M\"<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>Usted puede probar el c\u00f3digo anterior, si lo transcribe en el\u00a0<span class=\"std std-ref\">consola interactiva<\/span>\u00a0Python como lo siguiente:<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"k\">class<\/span> <span class=\"nc\">Persona<\/span><span class=\"p\">:<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"sd\">\"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">cedula<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"V-13458796\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">nombre<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Leonardo\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">apellido<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Caballero\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">sexo<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"M\"<\/span>\r\n<span class=\"gp\">...<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span> <span class=\"o\">=<\/span> <span class=\"n\">Persona<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"nb\">type<\/span><span class=\"p\">(<\/span><span class=\"n\">macagua<\/span><span class=\"p\">)<\/span>\r\n<span class=\"go\">&lt;type 'classobj'&gt;<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"nb\">dir<\/span><span class=\"p\">(<\/span><span class=\"n\">macagua<\/span><span class=\"p\">)<\/span>\r\n<span class=\"go\">['__doc__', '__module__', 'apellido', 'cedula', 'nombre', 'sexo']<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">cedula<\/span>\r\n<span class=\"go\">'V-13458796'<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">nombre<\/span>\r\n<span class=\"go\">'Leonardo'<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">apellido<\/span>\r\n<span class=\"go\">'Caballero'<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">sexo<\/span>\r\n<span class=\"go\">'M'<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"nb\">print<\/span> <span class=\"s2\">\"El objeto de la clase \"<\/span> <span class=\"o\">+<\/span> <span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"vm\">__name__<\/span> <span class=\"o\">+<\/span><span class=\"s2\">\",\"<\/span> \\\r\n<span class=\"gp\">... <\/span><span class=\"o\">+<\/span> <span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"vm\">__doc__<\/span> <span class=\"o\">+<\/span> <span class=\"s2\">\".\"<\/span>\r\n<span class=\"go\">El objeto de la clase Persona, Clase que representa una Persona.<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"nb\">print<\/span> <span class=\"s2\">\"Hola, mucho gusto, mi nombre es '\"<\/span><span class=\"o\">+<\/span> \\\r\n<span class=\"gp\">... <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">nombre<\/span> <span class=\"o\">+<\/span><span class=\"s2\">\" \"<\/span><span class=\"o\">+<\/span> \\\r\n<span class=\"gp\">... <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">apellido<\/span> <span class=\"o\">+<\/span><span class=\"s2\">\"', <\/span><span class=\"se\">\\n<\/span><span class=\"s2\">mi c\u00e9dula de identidad es '\"<\/span><span class=\"o\">+<\/span>  \\\r\n<span class=\"gp\">... <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">cedula<\/span> <span class=\"o\">+<\/span><span class=\"s2\">\"', y mi sexo es '\"<\/span><span class=\"o\">+<\/span>  \\\r\n<span class=\"gp\">... <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">sexo<\/span> <span class=\"o\">+<\/span><span class=\"s2\">\"'.\"<\/span>\r\n<span class=\"go\">Hola, mucho gusto, mi nombre es 'Leonardo Caballero',<\/span>\r\n<span class=\"go\">mi c\u00e9dula de identidad es 'V-13458796', y mi sexo es 'M'.<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>Si el nombre de un atributo esta encerrado entre dobles guiones bajos son atributos especiales.<\/p>\n<ul class=\"simple\">\n<li>__name__, describe el nombre del objeto o del m\u00e9todo.<\/li>\n<\/ul>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"vm\">__name__<\/span>\r\n<span class=\"go\">'Persona'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<ul class=\"simple\">\n<li>__doc__, contiene la documentaci\u00f3n de un m\u00f3dulo, una clase, o m\u00e9todo especifico, escrita en el formato\u00a0<span class=\"std std-ref\">docstrings<\/span>.<\/li>\n<\/ul>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"vm\">__doc__<\/span>\r\n<span class=\"go\">'Clase que representa una Persona'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>Si el nombre de un atributo esta con dobles guiones bajos al principio son atributos \u00abescondidos\u00bb. A continuaci\u00f3n un pseudo c\u00f3digo que ilustra un ejemplo:<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">ms_windows<\/span><span class=\"o\">.<\/span><span class=\"n\">__privado<\/span>\r\n<span class=\"go\">'True'<\/span>\r\n\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">ms_windows<\/span><span class=\"o\">.<\/span><span class=\"n\">codigo_fuente<\/span><span class=\"o\">.<\/span><span class=\"n\">__no_tocar<\/span>\r\n<span class=\"go\">'True'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>En la secci\u00f3n\u00a0<span class=\"std std-ref\">encapsulaci\u00f3n<\/span>\u00a0se describe esto a m\u00e1s profundidad.<\/p>\n<\/div>\n<div id=\"metodos\" class=\"section\">\n<p>&nbsp;<\/p>\n<h2>M\u00e9todos<\/h2>\n<p>Los m\u00e9todos describen el comportamiento de los objetos de una clase. Estos representan las operaciones que se pueden realizar con los objetos de la clase,<\/p>\n<p>La ejecuci\u00f3n de un m\u00e9todo puede conducir a cambiar el estado del objeto.<\/p>\n<p>Se definen de la misma forma que las funciones normales pero deben declararse dentro de la clase y su primer argumento siempre referencia a la instancia que la llama, de esta forma se afirma que los m\u00e9todos son\u00a0<span class=\"std std-ref\">funciones<\/span>, adjuntadas a\u00a0<span class=\"std std-ref\">objectos<\/span>.<\/p>\n<div class=\"admonition note\">\n<p class=\"first admonition-title\">Nota<\/p>\n<p class=\"last\">Usted puede encontrar ejemplos en las funciones de\u00a0<span class=\"std std-ref\">cadena de caracteres<\/span>,\u00a0<span class=\"std std-ref\">listas<\/span>,\u00a0<span class=\"std std-ref\">diccionarios<\/span>, etc.<\/p>\n<\/div>\n<p>Si el objeto es\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Persona<\/span><\/code>, los m\u00e9todos pueden ser:\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">hablar<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">caminar<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">comer<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">dormir<\/span><\/code>, etc.<\/p>\n<div class=\"highlight-python notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"k\">class<\/span> <span class=\"nc\">Persona<\/span><span class=\"p\">:<\/span>\r\n    <span class=\"sd\">\"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n    <span class=\"n\">cedula<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"V-13458796\"<\/span>\r\n    <span class=\"n\">nombre<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Leonardo\"<\/span>\r\n    <span class=\"n\">apellido<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Caballero\"<\/span>\r\n    <span class=\"n\">sexo<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"M\"<\/span>\r\n    \r\n    <span class=\"k\">def<\/span> <span class=\"nf\">hablar<\/span><span class=\"p\">(<\/span><span class=\"bp\">self<\/span><span class=\"p\">,<\/span> <span class=\"n\">mensaje<\/span><span class=\"p\">):<\/span>\r\n        <span class=\"sd\">\"\"\"Mostrar mensaje de saludo de Persona\"\"\"<\/span>\r\n        <span class=\"k\">return<\/span> <span class=\"n\">mensaje<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>La \u00fanica diferencia sint\u00e1ctica entre la definici\u00f3n de un m\u00e9todo y la definici\u00f3n de una funci\u00f3n es que el primer par\u00e1metro del m\u00e9todo por convenci\u00f3n debe ser el nombre\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">self<\/span><\/code>.<\/p>\n<p>Usted puede probar el c\u00f3digo anterior, si lo transcribe en el\u00a0<span class=\"std std-ref\">consola interactiva<\/span>\u00a0Python como lo siguiente:<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"k\">class<\/span> <span class=\"nc\">Persona<\/span><span class=\"p\">:<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"sd\">\"\"\"Clase que representa una Persona\"\"\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">cedula<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"V-13458796\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">nombre<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Leonardo\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">apellido<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"Caballero\"<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">sexo<\/span> <span class=\"o\">=<\/span> <span class=\"s2\">\"M\"<\/span>\r\n<span class=\"gp\">...<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"k\">def<\/span> <span class=\"nf\">hablar<\/span><span class=\"p\">(<\/span><span class=\"bp\">self<\/span><span class=\"p\">,<\/span> <span class=\"n\">mensaje<\/span><span class=\"p\">):<\/span>\r\n<span class=\"gp\">... <\/span>        <span class=\"sd\">\"\"\"Mostrar mensaje de saludo de Persona\"\"\"<\/span>\r\n<span class=\"gp\">... <\/span>        <span class=\"k\">return<\/span> <span class=\"n\">mensaje<\/span>\r\n<span class=\"gp\">...<\/span>\r\n<span class=\"go\">&gt;&gt;&gt;<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span> <span class=\"o\">=<\/span> <span class=\"n\">Persona<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">Persona<\/span><span class=\"p\">()<\/span><span class=\"o\">.<\/span><span class=\"n\">hablar<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Hola, soy la clase <\/span><span class=\"si\">{0}<\/span><span class=\"s2\">.\"<\/span><span class=\"o\">.<\/span><span class=\"n\">format<\/span><span class=\"p\">(<\/span>\r\n<span class=\"gp\">... <\/span>    <span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"vm\">__name__<\/span><span class=\"p\">))<\/span>\r\n<span class=\"go\">'Hola, soy la clase Persona.'<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"nb\">type<\/span><span class=\"p\">(<\/span><span class=\"n\">Persona<\/span><span class=\"p\">()<\/span><span class=\"o\">.<\/span><span class=\"n\">hablar<\/span><span class=\"p\">)<\/span>\r\n<span class=\"go\">&lt;type 'instancemethod'&gt;<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">Persona<\/span><span class=\"p\">()<\/span><span class=\"o\">.<\/span><span class=\"n\">hablar<\/span><span class=\"o\">.<\/span><span class=\"vm\">__doc__<\/span>\r\n<span class=\"go\">'Mostrar mensaje de saludo de Persona'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>Si crea una instancia de objeto para la clase\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Persona<\/span><\/code>\u00a0e intenta llamar al m\u00e9todo\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">hablar()<\/span><\/code>\u00a0esto lanzara una excepci\u00f3n\u00a0<span class=\"std std-ref\">TypeError<\/span>, como sucede a continuaci\u00f3n:<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span> <span class=\"o\">=<\/span> <span class=\"n\">Persona<\/span>\r\n<span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">macagua<\/span><span class=\"o\">.<\/span><span class=\"n\">hablar<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"Hola Plone\"<\/span><span class=\"p\">)<\/span>\r\n<span class=\"gt\">Traceback (most recent call last):<\/span>\r\n  File <span class=\"nb\">\"&lt;stdin&gt;\"<\/span>, line <span class=\"m\">1<\/span>, in <span class=\"n\">&lt;module&gt;<\/span>\r\n<span class=\"gr\">TypeError<\/span>: <span class=\"n\">unbound method hablar() must be called with Persona instance as first argument (got str instance instead)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<div id=\"index-1\" class=\"admonition-todo admonition\">\n<p class=\"last\"><span style=\"font-size: 1.125rem;\">\u00c1mbito de los m\u00e9todos<\/span><\/p>\n<\/div>\n<div id=\"ambito-de-los-metodos\" class=\"section\">\n<p>Los m\u00e9todos cuentan con un espacio de nombres propio. En caso de no encontrar un nombre en su \u00e1mbito local, buscar\u00e1 en el \u00e1mbito superior hasta encontrar alguna coincidencia.<\/p>\n<p>Los m\u00e9todos pueden acceder y crear atributos dentro del objeto al que pertenecen, anteponiendo la palabra\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">self<\/span><\/code>\u00a0y el operador de atributo \u00ab.\u00bb antes del nombre del atributo en cuesti\u00f3n.<\/p>\n<\/div>\n<div id=\"metodos-especiales\" class=\"section\">\n<p>&nbsp;<\/p>\n<h3>M\u00e9todos especiales<\/h3>\n<p>Las clases en Python cuentan con m\u00faltiples m\u00e9todos especiales, los cuales se encuentran entre dobles guiones bajos\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__&lt;metodo&gt;__()<\/span><\/code>.<\/p>\n<p>Los m\u00e9todos especiales m\u00e1s utilizados son\u00a0<span class=\"std std-ref\">__init__()<\/span>,\u00a0<span class=\"std std-ref\">__str__()<\/span>\u00a0y\u00a0<span class=\"std std-ref\">__del__()<\/span>.<\/p>\n<div id=\"str\" class=\"section\">\n<p>&nbsp;<\/p>\n<h4>__str__()<\/h4>\n<p>El m\u00e9todo\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__str__()<\/span><\/code>\u00a0es un m\u00e9todo especial, el cual se ejecuta al momento en el cual un objeto se manda a mostrar, es decir es una cadena representativa de la clase, la cual puede incluir formatos personalizados de presentaci\u00f3n del mismo.<\/p>\n<div class=\"highlight-python notranslate\">\n<div class=\"highlight\">\n<pre>    <span class=\"k\">def<\/span> <span class=\"fm\">__str__<\/span><span class=\"p\">(<\/span><span class=\"bp\">self<\/span><span class=\"p\">):<\/span>\r\n        <span class=\"sd\">\"\"\"Devuelve una cadena representativa de Persona\"\"\"<\/span>\r\n        <span class=\"k\">return<\/span> <span class=\"s2\">\"<\/span><span class=\"si\">%s<\/span><span class=\"s2\">: <\/span><span class=\"si\">%s<\/span><span class=\"s2\">, <\/span><span class=\"si\">%s<\/span> <span class=\"si\">%s<\/span><span class=\"s2\">, <\/span><span class=\"si\">%s<\/span><span class=\"s2\">.\"<\/span> <span class=\"o\">%<\/span> <span class=\"p\">(<\/span>\r\n            <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"vm\">__doc__<\/span><span class=\"p\">[<\/span><span class=\"mi\">25<\/span><span class=\"p\">:<\/span><span class=\"mi\">34<\/span><span class=\"p\">],<\/span> <span class=\"nb\">str<\/span><span class=\"p\">(<\/span><span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">cedula<\/span><span class=\"p\">),<\/span> <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">nombre<\/span><span class=\"p\">,<\/span> \r\n            <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">apellido<\/span><span class=\"p\">,<\/span> <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">getGenero<\/span><span class=\"p\">(<\/span><span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">sexo<\/span><span class=\"p\">))<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<div id=\"del\" class=\"section\">\n<p>&nbsp;<\/p>\n<h4>__del__()<\/h4>\n<p>El m\u00e9todo\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__del__()<\/span><\/code>\u00a0es un m\u00e9todo especial, el cual se ejecuta al momento en el cual un objeto es descartado por el int\u00e9rprete. El comportamiento de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__del__()<\/span><\/code>\u00a0es muy similar a los \u00abdestructores\u00bb en otros lenguajes.<\/p>\n<\/div>\n<\/div>\n<div id=\"metodos-de-clase\" class=\"section\">\n<p>&nbsp;<\/p>\n<h3>M\u00e9todos de clase<\/h3>\n<p>En ocasiones es necesario contar con m\u00e9todos que interact\u00faen con elementos de la clase de la cual el objeto es instanciado. Python permite definir m\u00e9todos de clase para esto.<\/p>\n<p>Los m\u00e9todos de clase son aquellos que est\u00e1n ligados directamente con los atributos definidos en la clase que los contiene. Para definir un m\u00e9todo de clase se utiliza el decorador\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">@classmethod<\/span><\/code>\u00a0y por convenci\u00f3n se utiliza\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">cls<\/span><\/code>\u00a0como argumento inicial en lugar de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">self<\/span><\/code>.<\/p>\n<p>Del mismo modo, los m\u00e9todos de clase utilizan el prefijo\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">cls<\/span><\/code>\u00a0para referirse a los atributos de la clase.<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre>class &lt;Clase&gt;(object):\r\n    ...\r\n    ...\r\n    @classmethod\r\n    def &lt;metodo&gt;(cls, &lt;argumentos&gt;):\r\n        ...\r\n        ...\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<div id=\"metodos-estaticos\" class=\"section\">\n<p>&nbsp;<\/p>\n<h3>M\u00e9todos est\u00e1ticos<\/h3>\n<p>Los m\u00e9todos est\u00e1ticos hacen referencia a las instancias y m\u00e9todos de una clase. Para definir un m\u00e9todo est\u00e1tico se utiliza el decorador\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">@staticmethod<\/span><\/code>\u00a0y no utiliza ning\u00fan argumento inicial.<\/p>\n<p>Al no utilizar\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">self<\/span><\/code>, los m\u00e9todos est\u00e1ticos no pueden interactuar con los atributos y m\u00e9todos de la instancia.<\/p>\n<p>Para referirse a los elementos de la clase, se debe utilizar el nombre de la clase como prefijo.<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre>class &lt;Clase&gt;(object):\r\n    ...\r\n    ...\r\n    @staticmethod\r\n    def &lt;metodo&gt;(&lt;argumentos&gt;):\r\n        ...\r\n        ...\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<div id=\"interfaces\" class=\"section\">\n<h3>Interfaces<\/h3>\n<p>La forma en que los m\u00e9todos de un objeto pueden ser accedidos por otros objetos se conoce como \u00abinterfaz\u00bb. Una interfaz bien definida permite a objetos de distinta \u00edndole interactuar entre s\u00ed de forma modular. La interfaz define el modo en que los objetos intercambian informaci\u00f3n.<\/p>\n<div id=\"index-2\" class=\"admonition-todo admonition\">\n<p class=\"last\"><span style=\"font-size: 1.125rem;\">Implementaciones<\/span><\/p>\n<\/div>\n<\/div>\n<div id=\"implementaciones\" class=\"section\">\n<p>Una implementaci\u00f3n corresponde al mecanismo interno que se desencadena en un m\u00e9todo cuando \u00e9ste es llamado. Las implementaciones procesan las entradas proveniente de las interfaces y act\u00faan en consecuencia ya sea:<\/p>\n<ul class=\"simple\">\n<li>Modificando el estado del objeto.<\/li>\n<li>Transfiriendo la informaci\u00f3n resultante del proceso interno a trav\u00e9s de la interfaces.<\/li>\n<\/ul>\n<div id=\"index-3\" class=\"admonition-todo admonition\">\n<p class=\"last\"><span style=\"color: #666666; font-size: 1.25rem;\">Clases<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n<div id=\"clases\" class=\"section\">\n<p>Las clases definen las caracter\u00edsticas del\u00a0<span class=\"std std-ref\">objeto<\/span>.<\/p>\n<p>Con todos los conceptos anteriores explicados, se puede decir que una clase es una plantilla gen\u00e9rica de un\u00a0<span class=\"std std-ref\">objeto<\/span>. La clase proporciona variables iniciales de estado (donde se guardan los\u00a0<span class=\"std std-ref\">atributos<\/span>) e implementaciones de comportamiento (<span class=\"std std-ref\">m\u00e9todos<\/span>) necesarias para crear nuevos objetos, son los modelos sobre los cu\u00e1les ser\u00e1n construidos.<\/p>\n<\/div>\n<div id=\"instancias\" class=\"section\">\n<p>&nbsp;<\/p>\n<h2>Instancias<\/h2>\n<p>Ya sabe que una clase es una estructura general del objeto. Por ejemplo, puede decir que la clase\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">Persona<\/span><\/code>\u00a0necesita tener una\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">cedula<\/span><\/code>, un\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">nombre<\/span><\/code>, un\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">apellido<\/span><\/code>\u00a0y una\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">sexo<\/span><\/code>, pero no va a decir cual es\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">cedula<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">nombre<\/span><\/code>,\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">apellido<\/span><\/code>\u00a0y\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">sexo<\/span><\/code>, es aqu\u00ed donde entran las instancias.<\/p>\n<p>Una instancia es una copia espec\u00edfica de la clase con todo su contenido. Por ejemplo:<\/p>\n<div class=\"highlight-default notranslate\">\n<div class=\"highlight\">\n<pre><span class=\"gp\">&gt;&gt;&gt; <\/span><span class=\"n\">persona1<\/span> <span class=\"o\">=<\/span> <span class=\"n\">Persona<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"V-13458796\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"Leonardo\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"Caballero\"<\/span><span class=\"p\">,<\/span> <span class=\"s2\">\"M\"<\/span><span class=\"p\">)<\/span>\r\n<span class=\"gt\">Traceback (most recent call last):<\/span>\r\n  File <span class=\"nb\">\"&lt;stdin&gt;\"<\/span>, line <span class=\"m\">1<\/span>, in <span class=\"n\">&lt;module&gt;<\/span>\r\n<span class=\"gr\">TypeError<\/span>: <span class=\"n\">this constructor takes no arguments<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<p>La excepci\u00f3n\u00a0<span class=\"std std-ref\">TypeError<\/span>\u00a0indica que el\u00a0<em>m\u00e9todo constructor no toma argumentos<\/em>, esto se debe a que la momento de definir la clase a cada atributo se le asigno un valor (tipo de dato).<\/p>\n<p>Usted puede definir el metodo constructor de la clase usando el m\u00e9todo\u00a0<span class=\"std std-ref\">__init__()<\/span>.<\/p>\n<div id=\"metodo-init\" class=\"section\">\n<p>&nbsp;<\/p>\n<h3>M\u00e9todo __init__()<\/h3>\n<p>El m\u00e9todo\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__init__()<\/span><\/code>\u00a0es un m\u00e9todo especial, el cual se ejecuta al momento de instanciar un objeto. El comportamiento de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__init__()<\/span><\/code>\u00a0es muy similar a los\u00a0<strong>\u00abconstructores\u00bb<\/strong>\u00a0en otros lenguajes. Los argumentos que se utilizan en la definici\u00f3n de\u00a0<code class=\"docutils literal notranslate\"><span class=\"pre\">__init__()<\/span><\/code>\u00a0corresponden a los par\u00e1metros que se deben ingresar al instanciar un objeto.<\/p>\n<div class=\"highlight-python notranslate\">\n<div class=\"highlight\">\n<pre>    <span class=\"k\">def<\/span> <span class=\"fm\">__init__<\/span><span class=\"p\">(<\/span><span class=\"bp\">self<\/span><span class=\"p\">,<\/span> <span class=\"n\">cedula<\/span><span class=\"p\">,<\/span> <span class=\"n\">nombre<\/span><span class=\"p\">,<\/span> <span class=\"n\">apellido<\/span><span class=\"p\">,<\/span> <span class=\"n\">sexo<\/span><span class=\"p\">):<\/span>\r\n        <span class=\"sd\">\"\"\"Constructor de clase Persona\"\"\"<\/span>\r\n        <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">cedula<\/span> <span class=\"o\">=<\/span> <span class=\"n\">cedula<\/span>\r\n        <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">nombre<\/span> <span class=\"o\">=<\/span> <span class=\"n\">nombre<\/span>\r\n        <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">apellido<\/span> <span class=\"o\">=<\/span> <span class=\"n\">apellido<\/span>\r\n        <span class=\"bp\">self<\/span><span class=\"o\">.<\/span><span class=\"n\">sexo<\/span> <span class=\"o\">=<\/span> <span class=\"n\">sexo<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<div id=\"funcion-isinstance\" class=\"section\">\n<h3>Funci\u00f3n isinstance()<\/h3>\n<p><code class=\"docutils literal notranslate\"><span class=\"pre\">isinstance()<\/span><\/code>, es una\u00a0<span class=\"std std-ref\">funci\u00f3n integrada<\/span>\u00a0la cual le permite corroborar si un objeto es instancia de una clase.<\/p>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Programaci\u00f3n orientada a objetos La programaci\u00f3n orientada a objetos (POO, u OOP seg\u00fan sus siglas en ingl\u00e9s) es un paradigma de programaci\u00f3n que viene a innovar la forma de obtener resultados. Los objetos manipulan los datos de entrada para la obtenci\u00f3n de datos de salida espec\u00edficos, donde cada objeto ofrece una funcionalidad especial. Muchos de [&hellip;]<\/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-395","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\/395","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=395"}],"version-history":[{"count":2,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/395\/revisions"}],"predecessor-version":[{"id":397,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/395\/revisions\/397"}],"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=395"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/categories?post=395"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/tags?post=395"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}