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.
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(valoresTrueoFalse). - Nulo:
NoneType(representado porNone).
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.