Aprende Python desde Cero: Guía Completa para Principiantes en Programación

En este apartado, vamos a dar una introducción a Python. Una vez que tenemos Python instalado y configurado, esta sección te servirá como un reforzamiento fundamental antes de que avancemos hacia la construcción de un framework en la siguiente etapa.

Es importante señalar que esta sección es un repaso y no una introducción a la programación desde cero. Por lo tanto, se asume que tienes conocimientos básicos de programación y, preferiblemente, alguna familiaridad con Python.

Consola interactiva de Python

▶

La primera herramienta que puedes emplear es la consola interactiva. Una vez instalado Python y configuradas las variables de entorno, puedes abrir una terminal (CMD, PowerShell, o Terminal) y escribir python.

$ python
Python 3.14.7 (default, Ma 8 2026, 16:59:28) 
[GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

El símbolo >>> indica que la consola está lista para recibir comandos de Python. Es una herramienta ideal para realizar pruebas rápidas, experimentar con funciones o explorar el lenguaje.

Por ejemplo, puedes realizar operaciones matemáticas y ver el resultado inmediatamente:

>>> 10 + 5
15
>>> "Hola" + " " + "Mundo"
'Hola Mundo'

Para salir de la consola interactiva, puedes usar las funciones exit() o quit().

>>> exit()

Archivos de Python (.py)

▶

La forma más común de escribir programas es mediante archivos. En Python, estos archivos tienen la extensión .py. Creemos un archivo llamado hola.py.

Dentro de hola.py, usaremos la función print() para mostrar un mensaje en la terminal. Esta función es esencial para depurar y mostrar resultados.

La función de print() permite imprimir un texto por la terminal o CMD y es una herramienta que usaremos enormemente para hacer rápidamente debug al momento de desarrollar las distintas funcionalidades de nuestra aplicación, así que, siguiendo nuestro ejemplo colocamos:

# hola.py
print("¡Hola, mundo desde un archivo!")

Para ejecutar este archivo, abre una terminal en el directorio donde lo guardaste y ejecuta el siguiente comando:

$ python hola.py

Verás la siguiente salida:

¡Hola, mundo desde un archivo!

Variables y Tipos de Datos

▶

Python es un lenguaje de tipado dinámico, lo que significa que no necesitas declarar el tipo de una variable. Python lo infiere automáticamente en el momento de la asignación.

• Texto: str (ej. "Hola", 'Python')
• Numéricos: int (ej. 10, -5), float (ej. 3.14, -0.5), complex (ej. 1+2j)
• Secuencias: list (ej. [1, "a"]), tuple (ej. (1, "a")), range
• Mapeo: dict (ej. {"clave": "valor"})
• Conjuntos: set (ej. {1, 2, 3}), frozenset
• Booleano: bool (True o False)
• Nulo: NoneType (None)

Puedes usar la función type() para verificar el tipo de una variable.

>>> nombre = "Andrés"
>>> edad = 30
>>> altura = 1.75
>>> es_desarrollador = True
>>> type(nombre)
<class 'str'>
>>> type(edad)
<class 'int'>
>>> type(altura)
<class 'float'>
>>> type(es_desarrollador)
<class 'bool'>

Python no es un lenguaje en el cual debemos de colocar el tipo de dato al momento de declarar la variable, es de tipificado dinámico, lo que significa que Python lo infiera al momento de inicializar un valor:

n = 5

Si no, como en JavaScript se infiere el tipo en base al valor declarado; si es un entero:

n = 5

Si es un flotante:

n = 5.2

O un String:

t = 'text'

Un booleano:

b = True

En python, tenemos una función llamada type() con la cual podemos preguntar el tipo de datos:

>>> t = 'text'
>>> type(t)
<class 'str'>

O para medir la longitud:

>>> t = 'text'
>>> len(t)
4

Operaciones Matemáticas

▶

Las operaciones matemáticas no cambian en absoluto si las comparamos con otros lenguajes de programación, independientemente de si el resultado a operar se encuentra almacenado en una variable, o es un valor fijo o retornado de una función o similar:

>>> a = 10
>>> b = 3
>>> a + b  # Suma
13
>>> a - b  # Resta
7
>>> a * b  # Multiplicación
30
>>> a / b  # División (siempre devuelve un float)
3.333...
>>> a // b # División entera (descarta la parte fraccionaria)
3
>>> a % b  # Módulo (resto de la división)
1
>>> a ** b # Exponenciación (10 elevado a la 3)
1000

Manejo de Strings

▶

La concatenación de strings se realiza con el operador +. Sin embargo, una forma más moderna y legible es usar f-strings.

>>> nombre = "Andrés"
>>> profesion = "desarrollador"
# Forma tradicional
>>> saludo = "Hola, soy " + nombre + " y soy " + profesion + "."
>>> print(saludo)
Hola, soy Andrés y soy desarrollador.

# Usando f-strings (recomendado)
>>> saludo_moderno = f"Hola, soy {nombre} y soy {profesion}."
>>> print(saludo_moderno)
Hola, soy Andrés y soy desarrollador.

Casteo (Conversión de Tipos)

▶

A veces necesitas convertir un tipo de dato a otro. Esto se conoce como casteo.

>>> numero_en_string = "100"
>>> numero_entero = int(numero_en_string)
>>> numero_entero + 50
150

>>> numero_flotante = float("99.5")
>>> numero_flotante
99.5

>>> str(123)
'123'

# Un número diferente de 0 es True, 0 es False
>>> bool(5)
True
>>> bool(0)
False
>>> bool(-1)
True

Si intentas realizar una conversión inválida, Python lanzará un error.

>>> int("hola")
ValueError: invalid literal for int() with base 10: 'hola'

Listas

▶

Las listas son colecciones ordenadas y mutables de elementos. Pueden contener diferentes tipos de datos.

Las listas no son más que una colección de datos, cuando entras a aplicaciones como X, WhatsApp o un correo electrónico como Outlook o Gmail, y ves un listado de correos o mensajes, se emplean estructuras como listas, por lo tanto, las listas son una estructura de lo más empleado en los cuales podemos definir las primitivas como vistos antes u objetos como veremos en el apartado de las clases:

>>> frutas = ["manzana", "banana", "cereza"]
>>> print(frutas)
['manzana', 'banana', 'cereza']

# Acceder a un elemento (los índices empiezan en 0)
>>> frutas[0]
'manzana'

# Acceder al último elemento
>>> frutas[-1]
'cereza'

# Agregar un elemento al final
>>> frutas.append("naranja")
>>> frutas
['manzana', 'banana', 'cereza', 'naranja']

# Eliminar un elemento por su valor
>>> frutas.remove("banana")
>>> frutas
['manzana', 'cereza', 'naranja']

# Longitud de la lista
>>> len(frutas)
3

# Slicing (sublistas)
>>> numeros = [0, 1, 2, 3, 4, 5]
>>> numeros[1:4]  # Elementos desde el índice 1 hasta el 3
[1, 2, 3]

Partiendo de esta lista:

>>> list = [1,2,3]
>>> list
[1, 2, 3]

Para operar con estas listas, también tenemos operaciones para conocer su longitud:

>>> len(list)
3

O para sumar todos los elementos de la lista:

>>> list = [1,2,3]
>>> sum(list)
6

Agregar nuevos elementos al final de la lista:

>>> list.append(5)
>>> list
[1, 2, 3, 5]

O remover un elemento por el valor (no el índice):

>>> list.remove(1)
>>> list
[2, 3, 5]

Obtener un valor de la lista, colocamos el índice comenzando desde cero:

>>> list = [1,2,3]
>>> list[1]
2

Si colocamos un índice que no exista, dará una excepción como la siguiente:

>>> list = [1,2,3]
>>> list[3]
IndexError: list index out of range

Existen muchas otras operaciones que puedes emplear sobre las listas y que puedes consultar en la documentación oficial.

Condicionales (if, elif, else)

▶

Los condicionales permiten ejecutar bloques de código solo si se cumplen ciertas condiciones.

edad = 20

if edad < 18:
    print("Eres menor de edad.")
elif edad >= 18 and edad < 65:
    print("Eres un adulto.")
else:
    print("Eres un adulto mayor.")

Puedes usar los operadores lógicos and, or y not para crear condiciones complejas.

tiene_entrada = True
es_vip = False

if tiene_entrada and es_vip:
    print("Bienvenido a la zona VIP.")
elif tiene_entrada or es_vip:
    print("Bienvenido al evento.")
else:
    print("Necesitas una entrada para acceder.")

• > Devuelve True si el operador de la izquierda es mayor que el operador de la derecha
• < Devuelve True si el operador de la derecha es mayor que el operador de la izquierda
• >= Devuelve True si el operador de la izquierda es mayor o igual que el operador de la derecha
• <= Devuelve True si el operador de la derecha es mayor o igual que el operador de la izquierda
• == Devuelve True si ambos son iguales
• != Devuelve True si ambos no son iguales

Condiciones de verdadero y falso y si la condición a evaluar es verdadero, entonces se ejecuta el bloque de código que gobierna el condicional:

age=15

if age >= 18:
    print("You're of age")

Podemos hacer condiciones complejas anidando varias condiciones con el and:

age=15
woman=False
if age >= 18 and woman:
    print("You are a man of legal age")

En donde se deben de cumplir todas las condiciones para ejecutar el bloque del condicional, o el or, para ejecutar el bloque del condicional con tan solo se cumpla algunas de las condiciones:

age=19
woman=False
if age >= 18 or woman:
    print("Message 1")

age=15
if age >= 18 or woman:
    print("Message 2")

age=15
woman=True
if age >= 18 or woman:
    print("Message 3")

También tenemos el bloque del else que se ejecutaría cuando no se cumple la condición del condicional:

age=19
if age >= 18:
    print("You're of age")
else:
    print("You are a minor")

Y podemos evaluar múltiples condiciones o anidar múltiples condicionales:

age=19
woman=False
age=19
if age >= 18:
    print("You're of age")
elif woman:
    print("You're a woman")
else:
    print("You are a men")

Ciclos (for y while)

▶

El ciclo for se usa para iterar sobre una secuencia (como una lista, tupla, string o rango).

# Iterar sobre una lista
frutas = ["manzana", "banana", "cereza"]
for fruta in frutas:
    print(f"Me gusta la {fruta}")

# Iterar un número de veces con range()
for i in range(5):  # Del 0 al 4
    print(f"Número: {i}")

Una configuración común, es emplear el ciclo for junto con la función range(), la cual, permite crear un rango como el siguiente:

for i in range(0,10):
   print(i)
0 1 2 3 4 5 6 7 8 9

Y de esta manera, la variable i corresponde a un elemento del rango a iterar.

El ciclo while se ejecuta mientras una condición sea verdadera.

contador = 0
while contador < 5:
    print(f"El contador es {contador}")
    contador += 1  # Es crucial incrementar el contador para no crear un bucle infinito

Funciones

▶

Las funciones son bloques de código reutilizables. Se definen con la palabra clave def.

def saludar(nombre: str):
    """Esta función saluda a la persona pasada como argumento."""
    print(f"Hola, {nombre}. ¡Bienvenido!")

# Llamar a la función
saludar("Ana")

Las funciones pueden recibir parámetros y retornar valores usando return.

def sumar(a: int, b: int) -> int:
    """Retorna la suma de dos números enteros."""
    return a + b

resultado = sumar(10, 5)
print(f"El resultado es: {resultado}")  # Salida: El resultado es: 15

Puedes definir valores por defecto para los parámetros.

def potencia(base: int, exponente: int = 2) -> int:
    return base ** exponente

print(potencia(3))      # Usa el exponente por defecto: 9
print(potencia(3, 3))   # Provee un exponente: 27

Como en el caso de los condicionales y ciclos, permiten crear bloques de código, pero, en esta oportunidad lo podemos invocar fácilmente; el bloque de código anterior queda como:

def sum():
  a=5
  b=6
  print("Sum numbers")
  c = a+b
  print("res "+str(c))

Y para invocarlo, empleamos el nombre de la función, en este ejemplo, sum():

sum()

La ventaja que tenemos, es que al estar todo encapsulado (en un scope diferente al global), podemos reutilizar fácilmente la función anterior tantas veces como queramos invocando a dicha función, por ejemplo, si queremos invocar el cuerpo de la función 3 veces, lo invocamos 3 veces:

sum()
sum()
sum()

Parámetros

▶

Con los parámetros, podemos hacer bloques de código realmente reutilizables, por ejemplo, podemos crear una función que reciba un argumento para imprimir por ejemplo, un nombre:

def yourName(name):
    print(name)
    
yourName('andres')

Puedes especificar el tipo:

def yourName(name:str):
  ***

Qué es lo recomendado para evitar trabajar con datos incorrectos, o también que reciba varios parámetros, por ejemplo, para sumarlos:

def sum(a:int, b:int, c:int):
  print("res "+str(a+b+c))
  
sum(1,2,3)

O realizar operaciones matemáticas:

def operations(a:int, b:int, op:str):
  if op == '+':
    print("res "+str(a+b))
  elif op == '-':
    print("res "+str(a-b))
  elif op == '*':
    print("res "+str(a*b))
  elif op == '/':
    print("res "+str(a/b))
operations(1,2,'+')

También, podemos definir valores por defecto:

def operations(a:int, b:int, op:str='*'):
  ***

Y podemos indicar el nombre de los parámetros al momento de invocar la función:

operations(b=2,a=5)

Con la ventaja de que, podemos colocarlos en cualquier orden:

operations(a=5,b=2)

Estas funciones, también pueden retornar un valor, para que luego lo podamos emplear en donde queramos, para ello, podemos emplear la palabra reservada de return:

def operations(a:int, b:int, op:str='*'):
  if op == '+':
    return a+b
  elif op == '-':
    return a-b
  elif op == '*':
    return a*b
  else:
    return a/b
    
n = operations(b=5,a=2)
print("res "+str(n))

También el tipo de retorno, en este ejemplo, sería un flotante (por la división):

def operations(a:int, b:int, op:str='*') -> float:
  if op == '+':
    return a+b
  elif op == '-':
    return a-b
  elif op == '*':
    return a*b
  else:
    return a/b

Por lo tanto, puedes ver una función como una pieza de código diseñada para realizar una tarea y en caso de que sea necesario, retorne un valor producto de la operación realizada.

Más adelante, cuando queramos devolver una página HTML al usuario se emplean funciones que retornan dichas páginas HTML, pero, esto lo veremos más adelante.

Clases y Objetos

▶

▶

Python es un lenguaje orientado a objetos. Las clases son como "planos" para crear objetos. Un objeto es una instancia de una clase.

class Carro:
    # El método constructor __init__ se llama al crear un objeto
    def __init__(self, marca: str, modelo: str, anio: int):
        self.marca = marca
        self.modelo = modelo
        self.anio = anio
        self.encendido = False

    def descripcion(self) -> str:
        return f"Carro: {self.marca} {self.modelo} del {self.anio}"

    def encender(self):
        if not self.encendido:
            self.encendido = True
            print("El carro ha sido encendido.")
        else:
            print("El carro ya estaba encendido.")

# Crear instancias (objetos) de la clase Carro
mi_carro = Carro("Toyota", "Corolla", 2022)
otro_carro = Carro("Ford", "Mustang", 1969)

# Acceder a atributos y llamar a métodos
print(mi_carro.descripcion())
mi_carro.encender()
mi_carro.encender()

Puedes ver que la palabra reservada class, está presente, y esto se debe a que en Python todo es un objeto que no es más que una instancia de una clase:

class MyClass:
  pass

Las clases no son más que un plano en el cual podemos crear todo tipo de objetos que representen al mundo real, como sus primitivas, enteros, flotantes, cadenas de textos o por ejemplo, podemos crear una clase que represente a un auto:

class Car:
  pass

O un animal:

class Animal:
  pass

Como puedes ver, en ambos casos se emplea la palabra reservada class para marcar a ese código como una clase.

Una clase vacía no nos sirve para mucho, para que sea funcional, podemos definir variables y funciones dentro de las clases, cuando definidos variables y funciones dentro de una clase, estos reciben el nombre de atributos y métodos respectivamente:

class Car:
  brand='MyBrand'
  model='MyModel'
  price=50.2
  
  def getCompleteDescription(self):
    return f"{self.brand} - {self.model} - {self.price}"

La palabra reservada self, hace referencia a la instancia de la clase con la cual se puede acceder a sus atributos y métodos.

Para el código anterior, podemos crear una instancia, que no es más que una variable la cual podemos manipular a nuestro antojo, por ejemplo, crear una instancia por algún tipo de carro que vamos a manipular en una aplicación:

>>> car = Car()

Y con esto, acceder a sus métodos y propiedades:

>>> print(car.brand)
>>> print(car.getCompleteDescription())
MyBrand
MyBrand - MyModel - 50.2

Los métodos y propiedades son la forma que tenemos para personalizar la clase, por ejemplo, para cambiar de marca:

car = Car()
car.brand='OtherBrand'
print(car.brand)
print(car.getCompleteDescription())

▶

O emplear el método constructor de la clase, que sería, el método __init__() en el cual, se suministran los argumentos:

class Car:
  # brand='MyBrand'
  # model='MyModel'
  # price=50.2
  
  def __init__(self,brand,model,price):
    self.brand=brand
    self.model=model
    self.price=price
  
  def getCompleteDescription(self):
    return f"{self.brand} - {self.model} - {self.price}"
    
car = Car('OtherBrand','OtherModel',100)
# car.brand='OtherBrand'
print(car.brand)
print(car.getCompleteDescription())

Al emplear el constructor de la clase, no es necesario definir los argumentos desde la clase, se crean automáticamente desde el constructor.

Herencia

▶

La herencia permite que una clase (hija) herede atributos y métodos de otra clase (padre).

class Animal:
    def __init__(self, nombre: str):
        self.nombre = nombre

    def hablar(self):
        # Este método será sobrescrito por las clases hijas
        raise NotImplementedError("La clase hija debe implementar este método")

class Perro(Animal):
    def hablar(self):
        return f"{self.nombre} dice: ¡Guau!"

class Gato(Animal):
    def hablar(self):
        return f"{self.nombre} dice: ¡Miau!"

mi_perro = Perro("Fido")
mi_gato = Gato("Misi")

print(mi_perro.hablar())
print(mi_gato.hablar())

En el ejemplo anterior, tenemos una clase Animal que cuenta con características comunes para un animal, luego, creamos dos clases Dog y Bird para representar a perros y pájaros, que son animales y por lo tanto, heredan de la clase Animal y con esto sus atributos y métodos, que son sobrescritos e inclusive podemos implementar métodos personalizados y atributos como el de other() que no forman parte de la clase Animal.

El uso de las clases y la herencia es fundamental en los frameworks ya que existen clases predefinidas por el framework para definir modelos, controladores/vistas, entre otros tipos y que luego pueden ser personalizadas conservando el comportamiento por defecto.

Módulos

▶

▶

Los módulos son archivos .py que contienen código reutilizable (funciones, clases, variables). Puedes importarlos en otros archivos para usar su funcionalidad.

Los módulos en Python son una parte crucial en el lenguaje de programación y lo que lo diferencian de otros lenguajes de programación y lo que permite que Python sea un lenguaje de programación modular en los que se aprovechan los framework implementados en dicho lenguaje.

Los módulos permiten reutilizar código fácilmente entre otros archivos que corresponden al proyecto.

Un módulo en Python no es más que un archivo con extensión .py que puede contener un conjunto de funciones, variables o clases que luego podemos emplear desde otros archivos que importen dicho módulo.

Los módulos pueden utilizar otros módulos, lo que facilita la reutilización de código y modularización de la aplicación.

Crear un módulo

Imagina que tienes un archivo mi_matematica.py:

# mi_matematica.py
PI = 3.14159

def sumar(a, b):
    return a + b

def restar(a, b):
    return a - b

Importar un módulo

Usando import, podemos importar todo el contenido del módulo definido anteriormente.

Puedes usar este módulo en otro archivo, por ejemplo main.py:

# main.py
import mi_matematica

resultado_suma = mi_matematica.sumar(5, 3)
print(f"La suma es: {resultado_suma}")
print(f"El valor de PI es: {mi_matematica.PI}")

# También puedes importar solo partes específicas
from mi_matematica import restar

resultado_resta = restar(10, 4)
print(f"La resta es: {resultado_resta}")

El bloque if __name__ == "__main__":

Es una buena práctica colocar el código que debe ejecutarse solo cuando el archivo es el programa principal (y no cuando es importado) dentro de este bloque.

# mi_matematica.py
PI = 3.14159

def sumar(a, b):
    return a + b

# Este bloque solo se ejecuta si corres "python mi_matematica.py"
if __name__ == "__main__":
    print("Este es el módulo de matemáticas.")
    print("Probando la función de suma...")
    resultado = sumar(10, 20)
    print(f"10 + 20 = {resultado}")

Y de esta forma, podemos reutilizar el módulo de operaciones matemáticas desde cualquier parte de la aplicación.

Los módulos son una parte fundamental en los frameworks, que al estar organizados en varias carpetas según las capas definidas para representar cada uno de los componentes del MVC o MTV, el manejo de las rutas, entre otros, la forma de unir todas estas capas es mediante módulos que vamos importante en partes específicas del framework

También los módulos son empleados en los frameworks para importar las distintas características del framework y paquetes asociados y poder emplear las mismas.