

 5.1.1.1 Fundamentos de Python: Parte 2



 List of contents
 Module 5 Now
o Back
o Module 5
o 5.1.1 Fundamentos de Python: Parte 2 Now
 Back
 5.1.1 Fundamentos de Python: Parte 2
 5.1.1.1 Fundamentos de Python: Parte 2 Now
 5.1.1.2 Fundamentos de Python: Módulo 5
 5.1.1.3 Módulos
 5.1.1.4 Empleando Módulos
 5.1.1.5 Empleando Módulos
 5.1.1.6 Empleando Módulos
 5.1.1.7 Importando un Módulo | math
 5.1.1.8 Importando un Módulo | math
 5.1.1.9 Importando un Módulo | math
 5.1.1.10 Importando un Módulo | math
 5.1.1.11 Importando un Módulo | * y as
 5.1.1.12 Importando un Módulo | aliasing
 5.1.2.1 Módulos Útiles
 5.1.2.2 Módulos Útiles | math
 5.1.2.3 Módulos Útiles | math
 5.1.2.4 Módulos Útiles | math
 5.1.2.5 Módulos útiles | aleatorio
 5.1.2.6 Módulos Útiles | random
 5.1.2.7 Módulos Útiles | random
 5.1.2.8 Módulos Útiles | random
 5.1.2.9 Módulos Útiles | random
 5.1.2.10 Módulos Útiles | platform
 5.1.2.11 Módulos Útiles | platform
 5.1.2.12 Módulos Útiles | platform
 5.1.2.13 Módulos Útiles | platform
 5.1.2.14 Módulos Útiles | platform
 5.1.2.15 Módulos Útiles | platform
 5.1.2.16 Módulos Útiles
 5.1.3.1 Módulos y Paquetes
 5.1.3.2 Módulos y Paquetes
 5.1.3.3 Módulos y Paquetes
 5.1.3.4 Módulos y Paquetes
 5.1.3.5 Módulos y Paquetes
 5.1.3.6 Módulos y Paquetes
 5.1.3.7 Módulos y Paquetes
 5.1.3.8 Módulos y Paquetes
 5.1.3.9 Módulos y Paquetes
 5.1.3.10 Módulos y Paquetes
 5.1.4.1 Errores: el pan diario del programador
 5.1.4.2 Errores: el pan diario del programador
 5.1.4.3 Errores: el pan diario del programador
 5.1.4.4 Errores: el pan diario del programador
 5.1.4.5 Errores: el pan diario del programador
 5.1.4.6 Errores: el pan diario del programador | try-except
 5.1.4.7 Errores: el pan diario del programador | try-except
 5.1.4.8 Errores: el pan diario del programador | try-except
 5.1.4.9 Errores: el pan diario del programador | try-except
 5.1.4.10 Errores: el pan diario del programador | try-except
 5.1.4.11 Errores: el pan diario del programador | try-except
 5.1.5.1 La anatomía de las excepciones
 5.1.5.2 La anatomía de las excepciones
 5.1.5.3 La anatomía de las excepciones
 5.1.5.4 La anatomía de las excepciones
 5.1.5.5 La anatomía de las excepciones | raise
 5.1.5.6 La anatomía de las excepciones | raise
 5.1.5.7 La anatomía de las excepciones | assert
 5.1.6.1 Excepciones útiles
 5.1.6.2 Excepciones útiles
 5.1.6.3 Excepciones útiles
 5.1.6.4 Leer ints de forma segura Lab
 5.1.7.1 Caracteres y Cadenas
 5.1.7.2 Caracteres y Cadenas
 5.1.7.3 Caracteres y Cadenas
 5.1.8.1 La naturaleza de las cadenas en Python
 5.1.8.2 La naturaleza de las cadenas en Python
 5.1.8.3 La naturaleza de las cadenas en Python
 5.1.8.4 La naturaleza de las cadenas en Python
 5.1.8.5 La naturaleza de las cadenas en Python
 5.1.8.6 La naturaleza de las cadenas en Python
 5.1.8.7 La naturaleza de las cadenas en Python
 5.1.8.8 La naturaleza de las cadenas en Python
 5.1.8.9 La naturaleza de las cadenas en Python
 5.1.8.10 La naturaleza de las cadenas en Python
 5.1.8.11 La naturaleza de las cadenas en Python
 5.1.8.12 La naturaleza de las cadenas en Python
 5.1.8.13 La naturaleza de las cadenas en Python
  5.1.8.14 La naturaleza de las cadenas en Python
 5.1.9.1 Métodos de cadenas
 5.1.9.2 Métodos de cadenas
 5.1.9.3 Métodos de cadenas
 5.1.9.4 Métodos de cadenas
 5.1.9.5 Métodos de cadenas
 5.1.9.6 Métodos de cadenas
 5.1.9.7 Métodos de cadenas
 5.1.9.8 Métodos de cadenas
 5.1.9.9 Métodos de cadenas
 5.1.9.10 Métodos de cadenas
 5.1.9.11 Métodos de cadenas
 5.1.9.12 Métodos de cadenas
 5.1.9.13 Métodos de cadenas
 5.1.9.14 Métodos de cadenas
 5.1.9.15 Métodos de cadenas
 5.1.9.16 Métodos de cadenas
 5.1.9.18 Tu propio split Lab
 5.1.10.1 Cadenas en acción
 5.1.10.2 Cadenas en acción
 5.1.10.3 Cadenas en acción
 5.1.10.4 Cadenas en acción
 5.1.10.6 LABORATORIO: Un Display LED Lab
 5.1.11.1 Cuatro simples programas
 5.1.11.2 Cuatro simples programas
 5.1.11.3 Cuatro simples programas
 5.1.11.4 Cuatro simples programas
 5.1.11.6 LABORATORIO: Mejorando el cifrado César Lab
 5.1.11.7 LABORATORIO: Palíndromos Lab
 5.1.11.8 LABORATORIO: Anagramas Lab
 5.1.11.9 LABORATORIO: El Dígito de la Vida Lab
 5.1.11.10 LABORATIORIO: ¡Encuentra una palabra! Lab
 5.1.11.11 LABORATORIO: Sudoku Lab
o 5.2.1 Module 5 Quiz Quiz
 Back
 5.2.1 Module 5 Quiz
 5.2.1.1 Module 5 Quiz Quiz
o 5.3.1 Module 5 Test Quiz
 Back
 5.3.1 Module 5 Test
 5.3.1.1 Module 5 Test Quiz
 Module 6
o Back
o Module 6
o 6.1.1 Fundamentos de Python: Módulo 6
 Back
 6.1.1 Fundamentos de Python: Módulo 6
 6.1.1.1 Fundamentos de Python: Módulo 6
 6.1.1.2 Los fundamentos de la POO
 6.1.1.3 Los fundamentos de la POO
 6.1.1.4 Los fundamentos de la POO
 6.1.1.5 Los fundamentos de la POO
 6.1.1.6 Los fundamentos de la POO
 6.1.1.7 Los fundamentos de la POO
 6.1.1.8 Los fundamentos de la POO
 6.1.2.1 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.2 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.3 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.4 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.5 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.6 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.7 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.8 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.9 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.10 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.11 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.2.12 Un corto viaje desde el enfoque procedimental hasta el
orientado a objetos
 6.1.3.1 Propiedades de la POO
 6.1.3.2 Propiedades de la POO
 6.1.3.3 Propiedades de la POO
 6.1.3.4 Propiedades de la POO
 6.1.3.5 Propiedades de la POO
 6.1.3.6 Propiedades de la POO
 6.1.3.7 Propiedades de la POO
 6.1.3.8 Propiedades de la POO
 6.1.4.1 POO: Métodos
 6.1.4.2 POO: Métodos
 6.1.4.3 POO: Métodos
 6.1.4.4 POO: Métodos
 6.1.4.5 POO: Métodos
 6.1.4.6 POO: Métodos
 6.1.4.7 POO: Métodos
 6.1.4.8 POO: Métodos
 6.1.4.9 POO: Métodos
 6.1.4.10 POO: Métodos
 6.1.5.1 Fundamentos de POO: Herencia
 6.1.5.2 Fundamentos de POO: Herencia
 6.1.5.3 Fundamentos de POO: Herencia
 6.1.5.4 Fundamentos de POO: Herencia
 6.1.5.5 Fundamentos de POO: Herencia
 6.1.5.6 Fundamentos de POO: Herencia
 6.1.5.7 Fundamentos de POO: Herencia
 6.1.5.8 Fundamentos de POO: Herencia
 6.1.5.9 Fundamentos de POO: Herencia
 6.1.5.10 Fundamentos de POO: Herencia
 6.1.5.11 Fundamentos de POO: Herencia
 6.1.5.12 Fundamentos de POO: Herencia
 6.1.5.13 Fundamentos de POO: Herencia
 6.1.5.14 Fundamentos de POO: Herencia
 6.1.5.15 Fundamentos de POO: Herencia
 6.1.5.16 Fundamentos de POO: Herencia
 6.1.5.17 Fundamentos de POO: Herencia
 6.1.5.18 Fundamentos de POO: Herencia
 6.1.5.19 Fundamentos de POO: Herencia
 6.1.6.1 Excepciones una vez más
 6.1.6.2 Excepciones una vez más
 6.1.6.3 Excepciones una vez más
 6.1.6.4 Excepciones una vez más
 6.1.6.5 Excepciones una vez más
 6.1.6.6 Excepciones una vez más
 6.1.6.7 Excepciones una vez más
 6.1.6.8 Excepciones una vez más
 6.1.7.1 Generadores y cierres
 6.1.7.2 Generadores y cierres
 6.1.7.3 Generadores y cierres
 6.1.7.4 Generadores y cierres
 6.1.7.5 Generadores y cierres
 6.1.7.6 Generadores y cierres
 6.1.7.7 Generadores y cierres
 6.1.7.8 Generadores y cierres
 6.1.7.9 Generadores y cierres
 6.1.7.10 Generadores y cierres
 6.1.7.11 Generadores y cierres
 6.1.7.12 Generadores y cierres
 6.1.7.13 Generadores y cierres
 6.1.7.14 Generadores y cierres
 6.1.8.1 Procesando archivos
 6.1.8.2 Procesando archivos
  6.1.8.3 Procesando archivos
 6.1.8.4 Procesando archivos
 6.1.8.5 Procesando archivos
 6.1.8.6 Procesando archivos
 6.1.8.7 Procesando archivos
 6.1.8.8 Procesando archivos
 6.1.8.9 Procesando archivos
 6.1.8.10 Procesando archivos
 6.1.8.11 Procesando archivos
 6.1.9.1 Trabajando con archivos reales
 6.1.9.2 Trabajando con archivos reales
 6.1.9.3 Trabajando con archivos reales
 6.1.9.4 Trabajando con archivos reales
 6.1.9.5 Trabajando con archivos reales
 6.1.9.6 Trabajando con archivos reales
 6.1.9.7 Trabajando con archivos reales
 6.1.9.8 Trabajando con archivos reales
 6.1.9.9 Trabajando con archivos reales
 6.1.9.10 Trabajando con archivos reales
 6.1.9.11 Trabajando con archivos reales
 6.1.9.12 Trabajando con archivos reales
 6.1.9.13 Trabajando con archivos reales
 6.1.9.14 Trabajando con archivos reales
 6.1.9.15 LABORATORIO: Histograma de frecuencia de caracteres
Lab
 6.1.9.16 LABORATORIO: Histograma de frecuencia de caracteres
ordenado Lab
 6.1.9.17 LABORATORIO: Evaluando los resultados de los
estudiantes Lab
o 6.2.1 Module 6 Quiz Quiz
 Back
 6.2.1 Module 6 Quiz
 6.2.1.1 Module 6 Quiz Quiz
o 6.3.1 Module 6 Test Quiz
 Back
 6.3.1 Module 6 Test
 6.3.1.1 Module 6 Test Quiz
o 6.6.1 Fundamentos de Programación en Python - PCAP
 Back
 6.6.1 Fundamentos de Programación en Python - PCAP
 6.6.1.1 Fundamentos de Programación en Python - PCAP




 Sandbox
Fundamentos de Programación en Python:
Módulo 6

En este módulo, aprenderás sobre:

 Los fundamentos y enfoque de programación orientada a objetos.

 Clases, métodos y objetos.
 Manejo de excepciones.
 Manejo de archivos.
Los conceptos básicos del enfoque
orientado a objetos
Demos un paso fuera de la programación y las computadoras, y analicemos temas de
programación orientada a objetos.

Casi todos los programas y técnicas que has utilizado hasta ahora pertenecen al estilo de
programación procedimental. Es cierto que has utilizado algunos objetos incorporados, pero
cuando nos referimos a ellos, se mencionan lo mínimo posible.

La programación procedimental fue el enfoque dominante para el desarrollo de software

durante décadas de TI, y todavía se usa en la actualidad. Además, no va a desaparecer en el
futuro, ya que funciona muy bien para proyectos específicos (en general, no muy complejos
y no grandes, pero existen muchas excepciones a esa regla).

El enfoque orientado a objetos es bastante joven (mucho más joven que el enfoque
procedimental) y es particularmente útil cuando se aplica a proyectos grandes y complejos
llevados a cabo por grandes equipos formados por muchos desarrolladores.

Este tipo de programación en un proyecto facilita muchas tareas importantes, por ejemplo,
dividir el proyecto en partes pequeñas e independientes y el desarrollo independiente de
diferentes elementos del proyecto.

Python es una herramienta universal para la programación procedimental y

orientada a objetos. Se puede utilizar con éxito en ambas.

Además, puedes crear muchas aplicaciones útiles, incluso si no se sabe nada sobre clases y
objetos, pero debes tener en cuenta que algunos de los problemas (por ejemplo, el manejo
de la interfaz gráfica de usuario) puede requerir un enfoque estricto de objetos.

Afortunadamente, la programación orientada a objetos es relativamente simple.

Enfoque procedimental versus el enfoque
orientado a objetos
En el enfoque procedimental, es posible distinguir dos mundos diferentes y
completamente separados: el mundo de los datos y el mundo del código. El mundo de los
datos está poblado con variables de diferentes tipos, mientras que el mundo del código está
habitado por códigos agrupados en módulos y funciones.

Las funciones pueden usar datos, pero no al revés. Además, las funciones pueden abusar de
los datos, es decir, usar el valor de manera no autorizada (por ejemplo, cuando la función
seno recibe el saldo de una cuenta bancaria como parámetro).

Los datos no pueden usar funciones. ¿Pero es esto completamente cierto? ¿Hay algunos
tipos especiales de datos que pueden usar funciones?

Sí, los hay, los llamados métodos. Estas son funciones que se invocan desde dentro de los
datos, no junto con ellos. Si puedes ver esta distinción, has dado el primer paso en la
programación de objetos.

El enfoque orientado a objetos sugiere una forma de pensar completamente diferente. Los
datos y el código están encapsulados juntos en el mismo mundo, divididos en clases.

Cada clase es como una receta que se puede usar cuando quieres crear un objeto útil.
Puedes producir tantos objetos como necesites para resolver tu problema.

Cada objeto tiene un conjunto de rasgos (se denominan propiedades o atributos; usaremos
ambas palabras como sinónimos) y es capaz de realizar un conjunto de actividades (que se
denominan métodos).

Las recetas pueden modificarse si son inadecuadas para fines específicos y, en efecto,
pueden crearse nuevas clases. Estas nuevas clases heredan propiedades y métodos de los
originales, y generalmente agregan algunos nuevos, creando nuevas herramientas más
específicas.

Los objetos son encarnaciones de las ideas expresadas en clases, como un pastel de queso
en tu plato, es una encarnación de la idea expresada en una receta impresa en un viejo libro
de cocina.

Los objetos interactúan entre sí, intercambian datos o activan sus métodos. Una clase
construida adecuadamente (y, por lo tanto, sus objetos) puede proteger los datos sensibles y
ocultarlos de modificaciones no autorizadas.

No existe un límite claro entre los datos y el código: viven como uno solo dentro de los
objetos.
Todos estos conceptos no son tan abstractos como pudieras pensar al principio. Por el
contrario, todos están tomados de experiencias de la vida real y, por lo tanto, son
extremadamente útiles en la programación de computadoras: no crean vida artificial
reflejan hechos reales, relaciones y circunstancias.

Jerarquías de clase
La palabra clases tiene muchos significados, pero no todos son compatibles con las ideas
que queremos discutir aquí. La clase que nos concierne es como una categoría, como
resultado de similitudes definidas con precisión.

Intentaremos señalar algunas clases que son buenos ejemplos de este concepto.
Veamos por un momento los vehículos. Todos los vehículos existentes (y los que aún no
existen) estan relacionados por una sola característica importante: la capacidad de
moverse. Puedes argumentar que un perro también se mueve; ¿Es un perro un vehículo? No
lo es. Tenemos que mejorar la definición, es decir, enriquecerla con otros criterios,
distinguir los vehículos de otros seres y crear una conexión más fuerte. Consideremos las
siguientes circunstancias: los vehículos son entidades creadas artificialmente que se utilizan
para el transporte, movidos por fuerzas de la naturaleza y dirigidos (conducidos) por
humanos.

Según esta definición, un perro no es un vehículo.

La clase vehículos es muy amplia. Tenemos que definir clases especializadas. Las clases
especializadas son las subclases. La clase vehículos será una superclase para todas ellas.

Nota: la jerarquía crece de arriba hacia abajo, como raíces de árboles, no ramas. La
clase más general y más amplia siempre está en la parte superior (la superclase) mientras
que sus descendientes se encuentran abajo (las subclases).

A estas alturas, probablemente puedas señalar algunas subclases potenciales para la

superclase Vehículos. Hay muchas clasificaciones posibles. Elegimos subclases basadas en
el medio ambiente y decimos que hay (al menos) cuatro subclases:

 Vehículos Terrestres.
 Vehículos Acuáticos.
 Vehículos Aéreos.
 Vehículos Espaciales.

En este ejemplo, discutiremos solo la primera subclase: vehículos terrestres. Si lo deseas,

puedes continuar con las clases restantes.

Los vehículos terrestres pueden dividirse aún más, según el método con el que impactan el
suelo. Entonces, podemos enumerar:
  Vehículos de ruedas.
 Vehículos oruga.
 Aerodeslizadores.

La figura ilustra la jerarquía que hemos creado.

Ten en cuenta la dirección de las flechas: siempre apuntan a la superclase. La clase de nivel
superior es una excepción: no tiene su propia superclase.

Jerarquías de clase: continuación

Otro ejemplo es la jerarquía del reino taxonómico de los animales.

Podemos decir que todos los animales (nuestra clase de nivel superior) se puede dividir en
cinco subclases:

 Mamíferos.
 Reptiles.
 Pájaros.
 Peces.
 Anfibios.

Tomaremos el primero para un análisis más detallado.

Hemos identificado las siguientes subclases:

 Mamíferos salvajes.
 Mamíferos domesticados.

Intenta extender la jerarquía de la forma que quieras y encuentra el lugar adecuado para los
humanos.
¿Qué es un objeto?
Una clase (entre otras definiciones) es un conjunto de objetos. Un objeto es un ser
perteneciente a una clase.

Un objeto es una encarnación de los requisitos, rasgos y cualidades asignados a una

clase específica. Esto puede sonar simple, pero ten en cuenta las siguientes circunstancias
importantes. Las clases forman una jerarquía. Esto puede significar que un objeto que
pertenece a una clase específica pertenece a todas las superclases al mismo tiempo.
También puede significar que cualquier objeto perteneciente a una superclase puede no
pertenecer a ninguna de sus subclases.

Por ejemplo: cualquier automóvil personal es un objeto que pertenece a la clase vehículos
terrestres. También significa que el mismo automóvil pertenece a todas las
superclases de su clase local; por lo tanto, también es miembro de la clase vehículos.
Tu perro (o tu gato) es un objeto incluido en la clase Mamíferos domesticados, lo
que significa explícitamente que también está incluido en la clase animales.

Cada subclase es más especializada (o más específica) que su superclase. Por el contrario,
cada superclase es más general (más abstracta) que cualquiera de sus subclases. Ten en
cuenta que hemos supuesto que una clase solo puede tener una superclase; esto no siempre
es cierto, pero discutiremos este tema más adelante.

Herencia

Definamos uno de los conceptos fundamentales de la programación de objetos, llamado

herencia. Cualquier objeto vinculado a un nivel específico de una jerarquía de clases
hereda todos los rasgos (así como los requisitos y cualidades) definidos dentro de
cualquiera de las superclases.

La clase de inicio del objeto puede definir nuevos rasgos (así como requisitos y cualidades)
que serán heredados por cualquiera de sus superclases.

No deberías tener ningún problema para hacer coincidir esta regla con ejemplos
específicos, ya sea que se aplique a animales o vehículos.
¿Qué contiene un objeto?
La programación orientada a objetos supone que cada objeto existente puede estar
equipado con tres grupos de atributos:

 Un objeto tiene un nombre que lo identifica de forma exclusiva dentro de su

namespace (aunque también puede haber algunos objetos anónimos).
 Un objeto tiene un conjunto de propiedades individuales que lo hacen original,
único o sobresaliente (aunque es posible que algunos objetos no tengan
propiedades).
 Un objeto tiene un conjunto de habilidades para realizar actividades específicas,
capaz de cambiar el objeto en sí, o algunos de los otros objetos.

Hay una pista (aunque esto no siempre funciona) que te puede ayudar a identificar
cualquiera de las tres esferas anteriores. Cada vez que se describe un objeto y se usa:

 Un sustantivo: probablemente se este definiendo el nombre del objeto.

 Un adjetivo: probablemente se este definiendo una propiedad del objeto.
 Un verbo: probablemente se este definiendo una actividad del objeto.

Dos ejemplos deberían servir como un buen ejemplo:

 Max es un gato grande que duerme todo el día.

Nombre del objeto = Max

Clase de inicio = Gato
 Propiedad = Tamaño (grande)
Actividad = Dormir (todo el día)

 Un Cadillac rosa pasó rápidamente.

Nombre del objeto = Cadillac

Clase de inicio = Vehículo terrestre
Propiedad = Color (rosa)
Actividad = Pasar (rápidamente)

Tu primera clase
La programación orientada a objetos es el arte de definir y expandir clases. Una clase es
un modelo de una parte muy específica de la realidad, que refleja las propiedades y
actividades que se encuentran en el mundo real.

Las clases definidas al principio son demasiado generales e imprecisas para cubrir el mayor
número posible de casos reales.

No hay obstáculo para definir nuevas subclases más precisas. Heredarán todo de su
superclase, por lo que el trabajo que se utilizó para su creación no se desperdicia.

La nueva clase puede agregar nuevas propiedades y nuevas actividades y, por lo tanto,
puede ser más útil en aplicaciones específicas. Obviamente, se puede usar como una
superclase para cualquier número de subclases recién creadas.

El proceso no necesita tener un final. Puedes crear tantas clases como necesites.

La clase que se define no tiene nada que ver con el objeto: la existencia de una clase no
significa que ninguno de los objetos compatibles se creará automáticamente. La clase
en sí misma no puede crear un objeto: debes crearlo tu mismo y Python te permite hacerlo.
Es hora de definir la clase más simple y crear un objeto. Echa un vistazo al siguiente
ejemplo:

class ClaseSimple:

pass

Hemos definido una clase. La clase es bastante pobre: no contiene propiedades ni

actividades. Esta vacía, pero eso no importa por ahora. Cuanto más simple sea la clase,
mejor para nuestros propósitos.

La definición comienza con la palabra clave reservada class. La palabra clave

reservada es seguida por un identificador que nombrará la clase (nota: no lo confundas
con el nombre del objeto: estas son dos cosas diferentes).

A continuación, se agregan dos puntos:), como clases, como funciones, forman su propio
bloque anidado. El contenido dentro del bloque define todas las propiedades y actividades
de la clase.

La palabra clave reservada pass llena la clase con nada. No contiene ningún método ni
propiedades.

Tu primer objeto

La clase recién definida se convierte en una herramienta que puede crear nuevos objetos.
La herramienta debe usarse explícitamente, bajo demanda.

Imagina que deseas crear un objeto (exactamente uno) de la clase ClaseSimple.

Para hacer esto, debes asignar una variable para almacenar el objeto recién creado de esa
clase y crear un objeto al mismo tiempo.

Se hace de la siguiente manera:

miPrimerObjeto = ClaseSimple()

Nota:

 El nombre de la clase intenta fingir que es una función, ¿puedes ver esto? Lo discutiremos
pronto.
 El objeto recién creado está equipado con todo lo que trae la clase; Como esta clase está
completamente vacía, el objeto también está vacío.

El acto de crear un objeto de la clase seleccionada también se llama instanciación

(ya que el objeto se convierte en una instancia de la clase).
 Dejemos las clases en paz por un breve momento, ya que ahora diremos algunas
palabras sobre pilas. Sabemos que el concepto de clases y objetos puede no estar
completamente claro todavía. No te preocupes, te explicaremos todo muy pronto.

¿Qué es una pila?

Una pila es una estructura desarrollada para almacenar datos de una manera muy
específica.. Imagina una pila de monedas. No puedes poner una moneda en ningún otro
lugar sino en la parte superior de la pila. Del mismo modo, no puedes sacar una moneda de
la pila desde ningún lugar que no sea la parte superior de la pila. Si deseas obtener la
moneda que se encuentra en la parte inferior, debes eliminar todas las monedas de los
niveles superiores.

El nombre alternativo para una pila (pero solo en la terminología de TI) es UEPS (LIFO
son sus siglas en íngles). Es una abreviatura para una descripción muy clara del
comportamiento de la pila: Último en Entrar - Primero en Salir (Last In - First Out). La
moneda que quedó en último lugar en la pila saldrá primero.

Una pila es un objeto con dos operaciones elementales, denominadas convencionalmente

push (cuando un nuevo elemento se coloca en la parte superior) y pop (cuando un
elemento existente se retira de la parte superior).

Las pilas se usan muy a menudo en muchos algoritmos clásicos, y es difícil imaginar la
implementación de muchas herramientas ampliamente utilizadas sin el uso de pilas.

Implementemos una pila en Python. Esta será una pila muy simple, y te mostraremos cómo
hacerlo en dos enfoques independientes: de manera procedimental y orientado a objetos.
Comencemos con el primero.

La pila: el enfoque procedimental

Primero, debes decidir cómo almacenar los valores que llegarán a la pila. Sugerimos
utilizar el método más simple, y emplear una lista para esta tarea. Supongamos que el
tamaño de la pila no está limitado de ninguna manera. Supongamos también que el último
elemento de la lista almacena el elemento superior.

La pila en sí ya está creada:

pila = []

Estamos listos para definir una función que pone un valor en la pila. Aquí están las
presuposiciones para ello:

 El nombre para la función es push.

 La función obtiene un parámetro (este es el valor que se debe colocar en la pila).
 La función no devuelve nada.
 La función agrega el valor del parámetro al final de la pila.

Así es como lo hemos hecho, echa un vistazo:

def push(val): pila.append(val)

Ahora es tiempo de que una función quite un valor de la pila. Así es como puedes
hacerlo:

 El nombre de la función es pop.

 La función no obtiene ningún parámetro.
 La función devuelve el valor tomado de la pila.
 La función lee el valor de la parte superior de la pila y lo elimina.

La función esta aqui:

def pop(): val = pila[-1] del pila[-1] return val

Nota: la función no verifica si hay algún elemento en la pila.

Armemos todas las piezas juntas para poner la pila en movimiento. El programa completo
empuja (push) tres números a la pila, los saca e imprime sus valores en pantalla. Puedes
verlo en la ventana del editor.

El programa muestra el siguiente texto en pantalla:

1 2 3
Pruébalo.

pila = []

def push(val):

pila.append(val)

def pop():

val = pila[-1]

del pila[-1]

return val

push(3)

push(2)

push(1)

print(pop())

print(pop())

print(pop())

La pila: el enfoque procedimental frente al

enfoque orientado a objetos
La pila procedimental está lista. Por supuesto, hay algunas debilidades, y la
implementación podría mejorarse de muchas maneras (aprovechar las excepciones es una
buena idea), pero en general la pila está completamente implementada, y puedes usarla si lo
necesitas.

Pero cuanto más la uses, más desventajas encontrarás. Éstas son algunas de ellas:

 La variable esencial (la lista de la pila) es altamente vulnerable; cualquiera puede

modificarla de forma incontrolable, destruyendo la pila; esto no significa que se
haya hecho de manera maliciosa; por el contrario, puede ocurrir como resultado de
un descuido, por ejemplo, cuando alguien confunde nombres de variables; imagina
que accidentalmente has escrito algo como esto:
 pila[0] = 0
El funcionamiento de la pila estará completamente desorganizado.

 También puede suceder que un día necesites más de una pila; tendrás que crear otra
lista para el almacenamiento de la pila, y probablemente otras funciones push y
pop.

 También puede suceder que no solo necesites funciones push y pop, pero también
algunas otras funciones; ciertamente podrías implementarlas, pero intenta imaginar
qué sucedería si tuvieras docenas de pilas implementadas por separado.

El enfoque orientado a objetos ofrece soluciones para cada uno de los problemas anteriores.
Vamos a nombrarlos primero:

 La capacidad de ocultar (proteger) los valores seleccionados contra el acceso no

autorizado se llama encapsulamiento; no se puede acceder a los valores
encapsulados ni modificarlos si deseas utilizarlos exclusivamente.

 Cuando tienes una clase que implementa todos los comportamientos de pila
necesarios, puedes producir tantas pilas como desees; no necesitas copiar ni replicar
ninguna parte del código.

 La capacidad de enriquecer la pila con nuevas funciones proviene de la herencia;

puedes crear una nueva clase (una subclase) que herede todos los rasgos existentes
de la superclase y agregue algunos nuevos.
Ahora escribamos una nueva implementación de pila desde cero. Esta vez, utilizaremos el
enfoque orientado a objetos, que te guiará paso a paso en el mundo de la programación de
objetos.

La pila - el enfoque orientado a objetos

Por supuesto, la idea principal sigue siendo la misma. Usaremos una lista como
almacenamiento de la pila. Solo tenemos que saber cómo poner la lista en la clase.

Comencemos desde el principio: así es como comienza la pila de orientada a objetos:

class Pila:

Ahora, esperamos dos cosas de la clase:

 Queremos que la clase tenga una propiedad como el almacenamiento de la pila -

tenemos que "instalar" una lista dentro de cada objeto de la clase (nota: cada
objeto debe tener su propia lista; la lista no debe compartirse entre diferentes pilas).
 Despues, queremos que la lista esté oculta de la vista de los usuarios de la clase.

¿Cómo se hace esto?

A diferencia de otros lenguajes de programación, Python no tiene medios para permitirte

declarar una propiedad como esa.

En su lugar, debes agregar una instrucción específica. Las propiedades deben agregarse a la
clase manualmente.

¿Cómo garantizar que dicha actividad tiene lugar cada vez que se crea una nueva pila?

Hay una manera simple de hacerlo - tienes que equipar a la clase con una función
específica:
  Tiene que ser nombrada de forma estricta.
 Se invoca implícitamente cuando se crea el nuevo objeto.

Tal función es llamada el constructor, ya que su propósito general es construir un nuevo

objeto. El constructor debe saber todo acerca de la estructura del objeto y debe realizar
todas las inicializaciones necesarias.

Agreguemos un constructor muy simple a la nueva clase. Echa un vistazo al código:

class Pila: def __init__(self): print("¡Hola!") objetoPila = Pila()

Expliquemos más a detalle:

 El nombre del constructor es siempre __init__.

 Tiene que tener al menos un parámetro (discutiremos esto más tarde); el
parámetro se usa para representar el objeto recién creado: puedes usar el parámetro
para manipular el objeto y enriquecerlo con las propiedades necesarias; harás uso de
esto pronto.
 Nota: el parámetro obligatorio generalmente se denomina self - es solo una
sugerencía, pero deberías seguirla - simplifica el proceso de lectura y
comprensión de tu código.

El código está en el editor. Ejecútalo ahora.

Aquí está su salida:

¡Hola!

Nota: no hay rastro de la invocación del constructor dentro del código. Ha sido invocado
implícita y automáticamente. Hagamos uso de eso ahora.

class Pila: # define la clase Pila

def __init__(self): # define la función del constructor

print("¡Hola!")

objetoPila = Pila() # instanciando el objeto

La pila - el enfoque orientado a objetos:

continuación
Cualquier cambio que realices dentro del constructor que modifique el estado del parámetro
self se verá reflejado en el objeto recien creado.

Esto significa que puedes agregar cualquier propiedad al objeto y la propiedad permanecerá
allí hasta que el objeto termine su vida o la propiedad se elimine explícitamente.

Ahora agreguemos solo una propiedad al nuevo objeto - una lista para la pila. La
nombraremos listaPila.

Justo como aqui:

class Pila: def __init__(self): self.listaPila = [] objetoPila = Pila()

print(len(objetoPila.listaPila))

Nota:

 Hemos usado la notación punteada, al igual que cuando se invocan métodos. Esta
es la manera general para acceder a las propiedades de un objeto: debes nombrar el
objeto, poner un punto (.) después de el, y especificar el nombre de la propiedad
deseada, ¡no uses paréntesis! No deseas invocar un método, deseas acceder a una
propiedad.
 Si estableces el valor de una propiedad por primera vez (como en el constructor), lo
estás creando; a partir de ese momento, el objeto tiene la propiedad y está listo para
usar su valor.
 Hemos hecho algo más en el código: hemos intentado acceder a la propiedad
listaPila desde fuera de la clase inmediatamente después de que se haya creado el
objeto; queremos verificar la longitud actual de la pila, ¿lo hemos logrado?

Sí, por supuesto: el código produce el siguiente resultado:

Esto no es lo que queremos de la pila. Nosotros queremos que listaPila este escondida
del mundo exterior. ¿Es eso posible?

Sí, y es simple, pero no muy intuitivo.

class Pila:

def __init__(self):

self.listaPila = []

objetoPila = Pila()
print(len(objetoPila.listaPila))

La pila - el enfoque orientado a objetos:

continuación
Echa un vistazo: hemos agregado dos guiones bajos antes del nombre listaPila - nada
mas:

class Pila: def __init__(self): self.__listaPila = [] objetoPila = Pila()

print(len(objetoPila.__listaPila))

El cambio invalida el programa..

¿Por qué?

Cuando cualquier componente de la clase tiene un nombre que comienza con dos guiones
bajos (__), se vuelve privado - esto significa que solo se puede acceder desde la clase.

No puedes verlo desde el mundo exterior. Así es como Python implementa el concepto de
encapsulación.

Ejecuta el programa para probar nuestras suposiciones: una excepción AttributeError

debe ser lanzada.

class Pila:

def __init__(self):

self.listaPila = []

objetoPila = Pila()

print(len(objetoPila.__listaPila))

El enfoque orientado a objetos: una pila

desde cero
Ahora es el momento de que las dos funciones (métodos) implementen las operaciones
push y pop. Python supone que una función de este tipo debería estar inmersa dentro del
cuerpo de la clase - como el constructor.
Queremos invocar estas funciones para agregar (push) y quitar (pop) valores de la
pila. Esto significa que ambos deben ser accesibles para el usuario de la clase (en contraste
con la lista previamente construida, que está oculta para los usuarios de la clase ordinaria).

Tal componente es llamado publico, por ello no puede comenzar su nombre con dos (o
más) guiones bajos. Hay un requisito más - el nombre no debe tener más de un guión
bajo.

Las funciones en sí son simples. Echa un vistazo:

class Pila: def __init__(self): self.__listaPila = [] def push(self,

val): self.__listaPila.append(val) def pop(self): val =
self.__listaPila[-1] del self.__listaPila[-1] return val objetoPila =
Pila() objetoPila.push(3) objetoPila.push(2) objetoPila.push(1)
print(objetoPila.pop()) print(objetoPila.pop()) print(objetoPila.pop())

Sin embargo, hay algo realmente extraño en el código. Las funciones parecen familiares,
pero tienen más parámetros que sus contrapartes procedimentales.

Aquí, ambas funciones tienen un parámetro llamado self en la primera posición de la lista
de parámetros.

¿Es necesario? Si, lo es.

Todos los métodos deben tener este parámetro. Desempeña el mismo papel que el primer
parámetro constructor.

Permite que el método acceda a entidades (propiedades y actividades / métodos) del

objeto. No puedes omitirlo. Cada vez que Python invoca un método, envía implícitamente
el objeto actual como el primer argumento.

Esto significa que el método está obligado a tener al menos un parámetro, que Python
mismo utiliza - no tienes ninguna influencia sobre el.

Si tu método no necesita ningún parámetro, este debe especificarse de todos modos. Si está
diseñado para procesar solo un parámetro, debes especificar dos, ya que la función del
primero sigue siendo la misma.

Hay una cosa más que requiere explicación: la forma en que se invocan los métodos desde
la variable __listaPila.

Afortunadamente, es mucho más simple de lo que parece:

 La primera etapa entrega el objeto como un todo → self.

 A continuación, debes llegar a la lista __listaPila → self.__listaPila.
 Con __listaPila lista para ser usada, puedes realizar el tercer y último paso →
self.__listaPila.append(val).
La declaración de la clase está completa y se han enumerado todos sus componentes. La
clase está lista para usarse.

class Pila:

def __init__(self):

self.__listaPila = []

def push(self, val):

self.__listaPila.append(val)

def pop(self):

val = self.__listaPila[-1]

del self.__listaPila[-1]

return val

objetoPila = Pila()

objetoPila.push(3)

objetoPila.push(2)

objetoPila.push(1)

print(objetoPila.pop())

print(objetoPila.pop())

print(objetoPila.pop())
El enfoque orientado a objetos: una pila
desde cero
Tener tal clase abre nuevas posibilidades. Por ejemplo, ahora puedes hacer que más de una
pila se comporte de la misma manera. Cada pila tendrá su propia copia de datos privados,
pero utilizará el mismo conjunto de métodos.

Esto es exactamente lo que queremos para este ejemplo.

Analiza el código:

class Pila: def __init__(self): self.__listaPila = [] def push(self,

val): self.__listaPila.append(val) def pop(self): val =
self.__listaPila[-1] del self.__listaPila[-1] return val objetoPila1 =
Pila() objetoPila2 = Pila() objetoPila1.push(3)
objetoPila2.push(objetoPila1.pop()) print(objetoPila2.pop())

Existen dos pilas creadas a partir de la misma clase base. Trabajan

independientemente. Puedes crear más si quieres.

Ejecuta el código en el editor y ve qué sucede. Realiza tus propios experimentos.

class Pila:

def __init__(self):

self.__listaPila = []

def push(self, val):

self.__listaPila.append(val)

def pop(self):

val = self.__listaPila[-1]

del self.__listaPila[-1]

return val
objetoPila1 = Pila()

objetoPila2 = Pila()

objetoPila1.push(3)

objetoPila2.push(objetoPila1.pop())

print(objetoPila2.pop())