FUNDAMENTOS DE LA PROGRAMACIÓN
1. Tipos de programas
Los programas son conjuntos de instrucciones que le indican a la computadora qué hacer. Existen diferentes tipos según su función:
- Software de sistema: ayuda al funcionamiento del computador (como Windows o Linux).
- Software de aplicación: permite realizar tareas específicas (como Word o Excel).
- Software de programación: sirve para crear otros programas (como Visual Studio o PyCharm).
Ejemplo:
Microsoft Word es un programa de aplicación que se usa para escribir textos.
2. Programa fuente (código fuente)
Es el conjunto de instrucciones escritas por un programador en un lenguaje de programación. Este código es legible por humanos y necesita ser traducido para que la computadora lo entienda.
Ejemplo:
print("Hola mundo")
Ese texto es un programa fuente en lenguaje Python.
3. Programa objeto (código objeto)
Es la versión del programa fuente que ha sido traducida a lenguaje de máquina, que solo la computadora puede entender.
Ejemplo:
El compilador convierte el código fuente print("Hola mundo") en una serie de números binarios como 10101100....
4. Variables
Una variable es un espacio en la memoria del computador que guarda un valor que puede cambiar durante la ejecución del programa.
Ejemplo:
edad = 10
Aquí, “edad” es una variable que guarda el valor 10.
5. Constantes
Son valores que no cambian durante la ejecución del programa.
Ejemplo:
PI = 3.1416
PI siempre tiene el mismo valor.
6. Tipos de datos
Los tipos de datos definen qué tipo de información puede almacenar una variable. Algunos tipos comunes son:
- Enteros (int): números sin decimales.
- Flotantes (float): números con decimales.
- Cadenas (string): texto.
- Booleanos (bool): valores verdaderos o falsos.
Ejemplo:
nombre = "Luis"
edad = 15
altura = 1.70
activo = True
7. Operaciones de asignación, relacionales y lógicas
Asignación: se usa para guardar un valor en una variable.
Ejemplo: x = 5
Relacionales: comparan dos valores (>, <, ==, !=, etc.).
Ejemplo: x > 3
Lógicas: combinan condiciones (and, or, not).
Ejemplo:
x > 3 and x < 10
8. Secuencias, selección y bucles (loops)
Secuencia: las instrucciones se ejecutan una tras otra en orden.
Ejemplo:
print("Hola")
print("Adiós")
Selección: el programa toma decisiones usando condiciones (if, else).
Ejemplo:
if edad >= 18:
print("Eres adulto")
Bucles: permiten repetir acciones.
Ejemplo:
for i in range(5):
print("Hola")CONCEPTOS BÁSICOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS
La Programación Orientada a Objetos (POO) es una forma de programar que organiza el código en objetos, que representan cosas reales o ideas.
Cada objeto tiene atributos (sus características) y métodos (las acciones que puede realizar).
1. Objetos
Un objeto es una unidad del programa que representa algo del mundo real o imaginario. Puede ser una persona, un auto, un perro o cualquier cosa que tenga características y acciones.
Ejemplo:
Un objeto “Perro” puede tener:
- Atributos: nombre, raza, edad.
- Métodos: ladrar(), correr(), comer().
class Perro:
def __init__(self, nombre):
self.nombre = nombre
def ladrar(self):
print("¡Guau, guau!")
2. Clases
Una clase es como un molde o plantilla que sirve para crear objetos.
Define qué atributos y métodos tendrán los objetos que se creen a partir de ella.
Ejemplo:
class Auto:
def __init__(self, marca, color):
self.marca = marca
self.color = color
De esta clase se pueden crear muchos autos diferentes (objetos).
3. Atributos
Los atributos son las características o datos que describen al objeto.
Por ejemplo, un auto tiene atributos como color, marca o velocidad.
Ejemplo:
self.color = "rojo"
self.marca = "Toyota"
4. Propiedades
Las propiedades permiten acceder o modificar los atributos de un objeto de manera controlada.
Sirven para proteger los datos del objeto y evitar errores.
Ejemplo:
@property
def color(self):
return self._color
@color.setter
def color(self, nuevo_color):
self._color = nuevo_color
5. Métodos
Los métodos son las acciones que un objeto puede realizar.
Son funciones que pertenecen a una clase y describen el comportamiento del objeto.
Ejemplo:
def encender(self):
print("El auto está encendido.")
6. Estructura interna de un objeto
La estructura interna de un objeto incluye sus atributos (datos) y métodos (acciones).
En otras palabras, lo que el objeto sabe (atributos) y lo que puede hacer (métodos).
Ejemplo:
Un objeto “Perro” tiene:
- Atributos: nombre, raza.
- Métodos: ladrar(), correr().
7. Instancia
Una instancia es un objeto creado a partir de una clase.
Si la clase es un molde, la instancia es el objeto real.
Ejemplo:
mi_auto = Auto("Toyota", "rojo")
Aquí mi_auto es una instancia de la clase Auto.
8. Mensaje (interacción entre objetos)
Un mensaje es cuando un objeto se comunica con otro, pidiéndole que ejecute uno de sus métodos.
Esto ocurre cuando un objeto invoca una acción sobre otro.
Ejemplo:
perro1.ladrar()
Aquí, el objeto perro1 recibe el mensaje ladrar().
Principios esenciales de la POO — Definiciones y ejemplos
1) Encapsulamiento
Definición (sencilla y correcta):
El encapsulamiento es la práctica de ocultar los detalles internos de un objeto y exponer solo lo necesario mediante métodos o propiedades controladas. Esto ayuda a proteger los datos y a evitar que otras partes del programa cambien valores directamente y por error. En resumen: la clase guarda sus datos (atributos) «dentro» y brinda formas seguras para verlos o modificarlos.
Ejemplo (muy simple):
class Cuenta:
def __init__(self, saldo):
self._saldo = saldo # atributo "protegido" (no acceder directamente)
def depositar(self, monto):
if monto > 0:
self._saldo += monto
def ver_saldo(self):
return self._saldo
mi_cuenta = Cuenta(100)
mi_cuenta.depositar(50)
print(mi_cuenta.ver_saldo()) # Muestra 150
Aquí _saldo está protegido; solo se cambia usando depositar() y se consulta con ver_saldo().
2) Herencia
Definición (sencilla y correcta):
La herencia permite crear una clase nueva (subclase) que hereda atributos y métodos de otra clase ya existente (superclase). Es como un molde base que se reutiliza y se especializa: la subclase tiene todo lo de la clase padre y puede añadir o cambiar cosas.
Ejemplo (muy simple):
class Animal:
def hablar(self):
print("Sonido")
class Perro(Animal): # Perro hereda de Animal
def hablar(self):
print("¡Guau!")
mi_perro = Perro()
mi_perro.hablar() # Muestra "¡Guau!"
Perro hereda la idea de Animal pero redefine hablar().
3) Polimorfismo
Definición (sencilla y correcta):
El polimorfismo es la capacidad de usar la misma interfaz (por ejemplo, el mismo nombre de método) para objetos de diferentes clases, y que cada objeto responda de forma apropiada. Es decir, distintos objetos pueden hacer la misma acción pero con resultados distintos.
Ejemplo (muy simple):
class Gato:
def hacer_sonido(self):
print("Miau")
class Vaca:
def hacer_sonido(self):
print("Muuu")
animales = [Gato(), Vaca()]
for a in animales:
a.hacer_sonido() # Cada objeto responde de forma diferente
Aunque el método se llama igual (hacer_sonido), cada clase lo implementa a su manera.
4) Abstracción
Definición (sencilla y correcta):
La abstracción consiste en separar lo esencial de lo no esencial: diseñar clases que muestren solo lo necesario para usar un objeto, sin obligar al usuario a conocer los detalles internos. Ayuda a simplificar problemas complejos mostrando una interfaz clara.
Ejemplo (muy simple):
class Televisor:
def encender(self):
# Aquí hay muchos pasos internos (no se ven)
print("Televisor encendido")
def cambiar_canal(self, canal):
print(f"Cambiando al canal {canal}")
tv = Televisor()
tv.encender() # Usuario solo usa métodos sencillos
tv.cambiar_canal(5)
Quien usa Televisor no necesita saber cómo se enciende internamente; solo usa encender() y cambiar_canal().
ACCESO Y CONTROL DENTRO DE LAS CLASES
En la Programación Orientada a Objetos (POO), las clases son estructuras que agrupan atributos (datos) y métodos (acciones).
Para mantener el orden y la seguridad de los datos dentro de una clase, se establecen niveles de acceso y control, llamados modificadores de acceso.
Estos determinan quién puede ver o usar cada parte de la clase.
1. Ámbitos de elementos de una clase
El ámbito se refiere al lugar desde donde puede accederse a un atributo o método.
Por ejemplo, algunos elementos solo pueden usarse dentro de la clase, mientras que otros pueden ser vistos desde fuera.
Esto ayuda a organizar el código y evitar errores, manteniendo las partes importantes protegidas.
2. Métodos y propiedades según su acceso
a) Públicos (public)
Los elementos públicos pueden ser usados desde cualquier parte del programa.
Son como las puertas abiertas de una casa: todos pueden entrar y ver lo que hay.
Ejemplo:
class Persona:
def __init__(self, nombre):
self.nombre = nombre # atributo público
p = Persona("Luis")
print(p.nombre) # Acceso permitido
Aquí nombre es público, y puede verse directamente.
b) Privados (private)
Los elementos privados solo pueden usarse dentro de la clase misma.
Sirven para proteger datos importantes que no deben cambiarse sin control.
En Python, se marcan con dos guiones bajos __.
Ejemplo:
class Cuenta:
def __init__(self, saldo):
self.__saldo = saldo # atributo privado
def ver_saldo(self):
return self.__saldo
cuenta = Cuenta(100)
print(cuenta.ver_saldo()) # Acceso correcto
# print(cuenta.__saldo) → ERROR (no se puede acceder directamente)
c) Protegidos (protected)
Los elementos protegidos pueden usarse dentro de la clase y sus clases hijas (heredadas), pero no directamente desde fuera.
En Python se marcan con un solo guion bajo _.
Ejemplo:
class Animal:
def __init__(self):
self._tipo = "Mamífero"
class Perro(Animal):
def mostrar_tipo(self):
print(self._tipo)
perro = Perro()
perro.mostrar_tipo() # Accede a atributo protegido desde una subclase
3. Métodos especiales
Los métodos especiales son funciones que tienen un propósito específico dentro de la clase.
a) Método Set
Sirve para asignar o cambiar el valor de un atributo privado o protegido.
Es una forma segura de modificar datos.
Ejemplo:
class Alumno:
def __init__(self, nombre):
self.__nombre = nombre
def set_nombre(self, nuevo_nombre):
self.__nombre = nuevo_nombre
a = Alumno("Ana")
a.set_nombre("Carlos")
b) Método Get
Sirve para obtener o mostrar el valor de un atributo privado o protegido.
Es una forma controlada de acceder a los datos.
Ejemplo:
class Alumno:
def __init__(self, nombre):
self.__nombre = nombre
def get_nombre(self):
return self.__nombre
a = Alumno("Ana")
print(a.get_nombre())
c) Constructor
El constructor es un método especial que se ejecuta automáticamente cuando se crea un objeto.
Sirve para inicializar los valores de la clase.
Ejemplo:
class Persona:
def __init__(self, nombre):
self.nombre = nombre
print("Objeto creado")
p = Persona("Luis") # Se ejecuta el constructor
d) Destructor
El destructor se ejecuta automáticamente cuando un objeto se elimina o deja de usarse.
Sirve para liberar memoria o cerrar procesos abiertos.
Ejemplo:
class Persona:
def __del__(self):
print("Objeto eliminado")
p = Persona()
del p # Llama al destructor
Relaciones entre clases
En la Programación Orientada a Objetos (POO), las clases pueden trabajar juntas. Una clase puede compartir características o comportamientos con otra, formando lo que llamamos relaciones entre clases. Estas relaciones permiten reutilizar código, organizar mejor los programas y crear jerarquías lógicas.
Clase base
Una clase base (también llamada clase padre o superclase) es aquella que contiene los atributos y métodos comunes que pueden ser utilizados por otras clases.
Sirve como modelo general para que otras clases hereden su estructura.
Ejemplo:
class Animal:
def __init__(self, nombre):
self.nombre = nombre
def hacer_sonido(self):
print("El animal hace un sonido.")
En este ejemplo, Animal es una clase base que tiene un atributo nombre y un método hacer_sonido().
Subclase (hija)
Una subclase (o clase hija) es una clase que hereda los atributos y métodos de otra clase (la clase base).
Además, puede agregar sus propios métodos y atributos o modificar los heredados.
Ejemplo:
class Perro(Animal):
def hacer_sonido(self):
print("El perro ladra.")
Aquí, la clase Perro hereda de Animal, pero cambia el comportamiento del método hacer_sonido().
Superclase (padre)
El término superclase es sinónimo de clase base. Es la clase de la cual heredan las demás.
En el ejemplo anterior, Animal es la superclase de Perro.
Herencia simple
La herencia simple ocurre cuando una clase hija hereda de una sola clase base.
Esto permite mantener una estructura clara y sencilla en el programa.
Ejemplo:
class Gato(Animal):
def hacer_sonido(self):
print("El gato maúlla.")
En este ejemplo, Gato es una subclase que hereda de Animal, y redefine el método hacer_sonido().
Importancia de las relaciones entre clases
Estas relaciones facilitan la organización del código y evitan escribir lo mismo varias veces.
Si varias clases comparten comportamientos comunes, pueden heredar esos comportamientos de una clase base, lo que hace el programa más limpio, ordenado y fácil de mantener.
Aplicación práctica en Programación Orientada a Objetos (POO)
La aplicación práctica de la Programación Orientada a Objetos consiste en usar los conceptos aprendidos (clases, objetos, herencia, métodos, atributos, etc.) para crear programas reales y funcionales.
En esta etapa, se busca que el estudiante pase de la teoría a la práctica, aplicando paso a paso la lógica de la POO en un proyecto sencillo.
1. Diseño de proyecto POO
El diseño de un proyecto POO es la planificación inicial.
Aquí se decide qué problema se va a resolver, qué clases serán necesarias, qué atributos y métodos tendrá cada clase y cómo se relacionarán entre sí.
El diseño sirve como guía o plano del programa antes de escribir el código.
Ejemplo:
Supongamos que queremos crear un programa para registrar mascotas en una veterinaria.
Podemos diseñar las siguientes clases:
- Clase Animal: nombre, edad, tipo.
- Clase Perro: hereda de Animal, y agrega raza, vacunado.
- Clase Gato: hereda de Animal, y agrega color, castrado.
En el diseño también se dibujan o anotan las relaciones entre las clases y sus funciones principales.
2. Desarrollo del proyecto POO
El desarrollo del proyecto POO es la etapa donde se escribe el código real basado en el diseño.
Se crean las clases, los métodos, y se organizan los objetos para que el programa funcione como se planificó.
En esta parte se aplican los principios de la POO: encapsulamiento, herencia, polimorfismo y abstracción.
Ejemplo:
class Animal:
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad
class Perro(Animal):
def __init__(self, nombre, edad, raza):
super().__init__(nombre, edad)
self.raza = raza
def mostrar(self):
print(f"{self.nombre} es un perro de raza {self.raza}")
Aquí se desarrollan las clases según lo que se diseñó antes.
3. Implementación del proyecto POO
La implementación es el momento de poner en práctica el programa, es decir, probarlo y ejecutarlo.
Se verifican los resultados, se corrigen errores y se asegura que funcione correctamente.
También puede incluir presentar el proyecto terminado o usarlo en la vida real.
Ejemplo:
mi_perro = Perro("Fido", 3, "Labrador")
mi_perro.mostrar()
El programa mostrará:
“Fido es un perro de raza Labrador”
Esto demuestra que el proyecto diseñado y desarrollado funciona como se esperaba.