Python

¿Qué es Python?

Python es un lenguaje de programación multiparadigma, de alto nivel y con una sintaxis limpia e intuitiva. Es ampliamente utilizado en el desarrollo web, ciencia de datos, automatización de tareas y desarrollo de software general.

Hola Mundo en Python

print("Hola Mundo!")
$ python3 main.py
Hola Mundo!
Probarlo >>

Componentes del ecosistema

  • Intérprete de Python: ejecuta el código línea por línea sin necesidad de una compilación previa manual.
  • PIP (Package Installer for Python): el gestor de paquetes estándar para instalar librerías y dependencias de terceros desde PyPI.
  • Entornos Virtuales (venv): permiten aislar dependencias e instalaciones de proyectos de forma independiente.

Tipos de datos principales

  • Enteros: int (ej. 10, -5).
  • Decimales: float (ej. 3.14, -0.5).
  • Cadenas de texto: str (utiliza comillas simples ' ' o dobles " ").
  • Booleanos: bool (valores True o False).
  • Nulo: NoneType (representado por None).

Variables

Una variable es un contenedor para almacenar datos. Python utiliza tipado dinámico, por lo que no es necesario declarar el tipo de dato manualmente: incluso una misma variable puede guardar después un valor de otro tipo.

Declaración e inicialización

edad = 26               # Se infiere automáticamente como int
texto = "Hola Mundo"    # Se infiere como str
PI = 3.1416             # Por convención, las mayúsculas indican constantes

Probando en el intérprete interactivo

>>> edad = 26
>>> type(edad)
<class 'int'>
>>> edad = "veintiséis"
>>> type(edad)
<class 'str'>

Podés acumular valores en una variable y hasta asignar o intercambiar varias variables en una sola línea:

Acumular e intercambiar variables

total = 0
total += 5      # equivale a total = total + 5

a, b = 1, 2
a, b = b, a     # intercambia los valores
print(a, b)
$ python3 main.py
2 1

Tip: para comentar una línea usá # mensaje y para varias líneas usá triples comillas """ mensaje """.

Operadores

Python ofrece operadores aritméticos, de comparación y lógicos representados con palabras clave claras como and, or y not. Además tiene // para la división entera y ** para las potencias.

Operadores aritméticos, de comparación y lógicos

suma = 5 + 3                    # Aritméticos: +  -  *  /  //  %  **
mayor = edad >= 18              # Comparación: ==  !=  >  <  >=  <=
puede = mayor and activo        # Lógicos: and (y)  or (o)  not (no)

Probando en el intérprete interactivo

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> 7 % 2
1
>>> 2 ** 10
1024
>>> "ja" * 3
'jajaja'
>>> 5 > 3 and not False
True

Tip: para abrir el intérprete interactivo escribí python3 en la terminal, y para salir usá exit().

Condicionales

Las condicionales controlan el flujo del programa según se cumplan o no ciertas condiciones. En vez de llaves, la indentación (sangría) define qué código pertenece a cada bloque.

Estructura if / elif / else

edad = 15

if edad >= 18:
    print("Mayor de edad")
elif edad >= 13:
    print("Adolescente")
else:
    print("Niño")
$ python3 main.py
Adolescente

Estructura match / case (Python 3.10+)

dia = 2

match dia:
    case 1:
        print("Lunes")
    case 2:
        print("Martes")
    case _:
        print("Otro día")
$ python3 main.py
Martes

Qué pasa si nos olvidamos la sangría

if edad >= 18:
print("Mayor de edad")
$ python3 main.py
  File "main.py", line 2
    print("Mayor de edad")
    ^
IndentationError: expected an indented block after 'if' statement on line 1

Bucles e iteraciones

Los bucles nos permiten repetir tareas. Usamos for para iterar sobre secuencias o rangos de números, y while para repetir mientras una condición sea verdadera.

for y while

nombres = ["Ana", "Leo"]

for i in range(3):
    print(i)

contador = 0
while contador < 10:
    contador += 1

for nombre in nombres:
    print(nombre)
$ python3 main.py
0
1
2
Ana
Leo

Tip: range(3) cuenta desde 0 y no incluye el 3. Usá break para interrumpir un bucle y continue para pasar directamente a la siguiente iteración.

Funciones

Las funciones se definen con la palabra clave def. Permiten estructurar código modular, recibir argumentos (que pueden tener un valor por defecto) y retornar valores mediante return.

Declarar y llamar una función

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

def saludar(nombre="Visitante"):
    print(f"Hola {nombre}")

resultado = sumar(4, 6)
print(resultado)
saludar("Ana")
saludar()
$ python3 main.py
10
Hola Ana
Hola Visitante

Tip: la f antes de las comillas (f-string) nos deja meter variables dentro del texto con llaves.

Estructuras de Datos

Python incluye varias estructuras integradas para almacenar colecciones de elementos:

Listas (list)

Secuencias ordenadas y mutables de elementos.

Diccionarios (dict)

Colecciones mutables organizadas mediante pares clave-valor.

Tuplas (tuple)

Secuencias ordenadas pero inmutables (no se pueden modificar).

Conjuntos (set)

Colecciones desordenadas de elementos únicos (sin duplicados).

Índices y porciones de una lista

>>> alumnos = ["Ana", "Leo", "María"]
>>> alumnos[0]
'Ana'
>>> alumnos[-1]
'María'
>>> alumnos[0:2]
['Ana', 'Leo']
>>> len(alumnos)
3
>>> [n * 2 for n in [1, 2, 3]]
[2, 4, 6]

Diccionarios, conjuntos y tuplas

>>> edades = {"Ana": 17, "Leo": 18}
>>> edades["Ana"]
17
>>> set([1, 1, 2, 3, 3])
{1, 2, 3}
>>> punto = (3, 4)
>>> punto[0] = 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Tip: los índices negativos cuentan desde el final, así que alumnos[-1] siempre es el último elemento.

Programación Orientada a Objetos

En Python todo es un objeto. Definimos clases usando la palabra clave class y el método __init__ como constructor para inicializar atributos. El parámetro self representa al objeto actual.

Clases, objetos y herencia

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

    def hacer_sonido(self):
        return "..."

class Perro(Animal):
    def hacer_sonido(self):
        return "¡Guau!"

mi_perro = Perro("Firulais")
print(mi_perro.nombre)
print(mi_perro.hacer_sonido())
$ python3 main.py
Firulais
¡Guau!

Manejo de Excepciones

Cuando ocurre un error que nadie maneja, Python frena el programa y muestra un Traceback que indica el archivo, la línea y el tipo de error. Con los bloques try, except y finally podemos gestionarlo sin que el programa se detenga.

Un error sin manejar

divisor = 0
resultado = 10 / divisor
$ python3 main.py
Traceback (most recent call last):
  File "main.py", line 2, in <module>
    resultado = 10 / divisor
                ~~~^~~~~~~~~
ZeroDivisionError: division by zero

try, except y finally

divisor = 0

try:
    resultado = 10 / divisor
except ZeroDivisionError:
    print("No se puede dividir por cero")
finally:
    print("Fin de la operación")
$ python3 main.py
No se puede dividir por cero
Fin de la operación

Tip: el Traceback se lee de abajo hacia arriba: la última línea dice qué error pasó y las de arriba dónde.