Guia Completa de Python
Fundamentos del lenguaje de programacion mas popular del mundo
Documento generado automaticamente
Indice de contenidos
1. Introduccion a Python
2. Tipos de datos fundamentales
3. Estructuras de datos
4. Estructuras de control
5. Funciones y decoradores
6. Programacion orientada a objetos
7. Manejo de errores
8. Modulos y paquetes
9. Consejos y buenas practicas
Introduccion a Python
Python es un lenguaje de programacion de alto nivel, interpretado y de proposito general
creado por Guido van Rossum y publicado por primera vez en 1991. Su nombre proviene
del grupo de comedia britanico Monty Python, no de la serpiente como muchos creen.
La filosofia de diseno de Python enfatiza la legibilidad del codigo con el uso de
indentacion significativa. Su lema, recogido en el Zen de Python (PEP 20), incluye
principios como 'Lo bello es mejor que lo feo', 'Explicito es mejor que implicito' y 'Simple
es mejor que complejo'.
Python se ha convertido en uno de los lenguajes mas utilizados del mundo gracias a su
versatilidad. Se emplea en desarrollo web (Django, Flask), ciencia de datos (pandas,
NumPy), inteligencia artificial (TensorFlow, PyTorch), automatizacion, scripting,
desarrollo de juegos y mucho mas.
Una de las grandes ventajas de Python es su enorme ecosistema de bibliotecas. El
Python Package Index (PyPI) contiene mas de 400.000 paquetes que cubren
practicamente cualquier necesidad de desarrollo.
Tipos de datos fundamentales
Python cuenta con un sistema de tipos dinamico y robusto. Los tipos de datos basicos
son:
Numeros enteros (int): representan numeros sin parte decimal. Python maneja enteros
de precision arbitraria, lo que significa que no hay limite en su tamano. Ejemplos: 42, -7,
0, 10000000000000000.
Numeros de punto flotante (float): representan numeros con parte decimal siguiendo el
estandar IEEE 754. Hay que tener cuidado con la precision: 0.1 + 0.2 no es exactamente
0.3. Ejemplos: 3.14, -0.001, 2.0e10.
Cadenas de texto (str): secuencias inmutables de caracteres Unicode. Se pueden definir
con comillas simples, dobles o triples. Soportan interpolacion con f-strings: f'Hola,
{nombre}'. Tienen decenas de metodos utiles como .strip(), .split(), .replace(), .upper(),
.lower() y muchos mas.
Booleanos (bool): representan valores de verdad. Solo existen dos: True y False. Son
subclase de int, donde True equivale a 1 y False a 0.
None: representa la ausencia de valor. Es el equivalente de null en otros lenguajes. Solo
existe una instancia de None en todo el programa.
Estructuras de datos
Python ofrece varias estructuras de datos integradas extremadamente versatiles:
Listas (list): colecciones ordenadas y mutables. Permiten elementos de cualquier tipo y
duplicados. Se crean con corchetes: [1, 'dos', 3.0, True]. Soportan indexacion, slicing,
append, extend, insert, remove, sort y muchas operaciones mas.
Tuplas (tuple): similares a las listas pero inmutables. Una vez creadas no se pueden
modificar. Se usan frecuentemente para retornar multiples valores de una funcion y como
claves de diccionarios. Se crean con parentesis: (1, 2, 3).
Diccionarios (dict): colecciones de pares clave-valor. Las claves deben ser inmutables
(strings, numeros, tuplas). Desde Python 3.7 mantienen el orden de insercion. Ejemplo:
{'nombre': 'Ana', 'edad': 30, 'ciudad': 'Madrid'}.
Conjuntos (set): colecciones no ordenadas de elementos unicos. Utiles para eliminar
duplicados y operaciones matematicas como union, interseccion y diferencia. Se crean
con llaves: {1, 2, 3}.
Cada estructura tiene su caso de uso ideal. Las listas son perfectas para colecciones
ordenadas que cambian, los diccionarios para acceso rapido por clave, los conjuntos
para verificar pertenencia y las tuplas para datos que no deben cambiar.
Estructuras de control
Las estructuras de control dirigen el flujo de ejecucion del programa:
Condicionales (if/elif/else): permiten ejecutar bloques de codigo segun condiciones.
Python no tiene switch/case tradicional, pero desde la version 3.10 incluye match/case
para pattern matching estructural.
Bucle for: itera sobre cualquier objeto iterable (listas, strings, rangos, diccionarios,
archivos, etc.). La funcion range() genera secuencias de numeros. Se puede combinar
con enumerate() para obtener indices y con zip() para iterar sobre multiples secuencias
simultaneamente.
Bucle while: repite un bloque mientras una condicion sea verdadera. Hay que asegurarse
de que la condicion eventualmente sea falsa para evitar bucles infinitos.
Sentencias break y continue: break termina el bucle inmediatamente, continue salta a la
siguiente iteracion. Ambas funcionan con for y while.
Comprensiones: Python ofrece una sintaxis concisa para crear colecciones. Las list
comprehensions [x**2 for x in range(10) if x % 2 == 0] son muy populares. Tambien
existen dict comprehensions, set comprehensions y generator expressions.
Funciones y decoradores
Las funciones son bloques reutilizables de codigo que se definen con la palabra clave
def:
def calcular_area(base, altura):
return base * altura / 2
Python soporta argumentos posicionales, por nombre, valores por defecto, *args
(argumentos variables posicionales) y **kwargs (argumentos variables por nombre).
Funciones lambda: funciones anonimas de una sola expresion. Utiles como argumentos
de funciones como map(), filter() y sorted(). Ejemplo: cuadrado = lambda x: x**2.
Decoradores: funciones que modifican el comportamiento de otras funciones. Se aplican
con la sintaxis @decorador. Son fundamentales en frameworks como Flask (@[Link])
y para patrones comunes como caching, logging, autenticacion y medicion de tiempo.
Generadores: funciones que usan yield en lugar de return para producir una secuencia
de valores de forma perezosa (lazy evaluation). Son extremadamente eficientes en
memoria cuando se trabaja con grandes volumenes de datos.
Closures: funciones que capturan variables de su ambito exterior. Permiten crear fabricas
de funciones y son la base de los decoradores.
Programacion orientada a objetos
Python soporta programacion orientada a objetos de forma completa:
Las clases se definen con la palabra clave class. El metodo __init__ es el constructor. El
parametro self referencia a la instancia actual (equivalente a this en otros lenguajes).
Herencia: Python soporta herencia simple y multiple. La funcion super() permite llamar a
metodos de la clase padre. El MRO (Method Resolution Order) determina el orden de
busqueda en herencia multiple.
Encapsulacion: Python no tiene modificadores de acceso estrictos. Por convencion, un
guion bajo (_atributo) indica uso interno, y doble guion bajo (__atributo) activa name
mangling para mayor privacidad.
Metodos especiales (dunder methods): metodos con doble guion bajo como __str__,
__repr__, __len__, __add__, __eq__ permiten personalizar el comportamiento de los
objetos con operadores y funciones integradas.
Dataclasses: desde Python 3.7, el decorador @dataclass genera automaticamente
__init__, __repr__, __eq__ y otros metodos a partir de anotaciones de tipo, reduciendo
significativamente el codigo repetitivo.
Clases abstractas: el modulo abc permite definir clases abstractas que obligan a las
subclases a implementar ciertos metodos.
Manejo de errores
Python usa excepciones para manejar errores de forma elegante:
El bloque try/except captura excepciones. Se pueden capturar excepciones especificas
(ValueError, TypeError, FileNotFoundError) o genericas (Exception). El bloque else se
ejecuta si no hubo excepcion, y finally se ejecuta siempre.
Python tiene una jerarquia de excepciones integradas: BaseException es la raiz,
Exception es la base para la mayoria de errores. Las mas comunes son ValueError,
TypeError, KeyError, IndexError, FileNotFoundError y AttributeError.
Se pueden crear excepciones personalizadas heredando de Exception:
class MiError(Exception):
def __init__(self, mensaje):
super().__init__(mensaje)
El sentencia raise permite lanzar excepciones manualmente. raise ValueError('dato
invalido') interrumpe la ejecucion y busca el except mas cercano.
Context managers (with): simplifican la gestion de recursos que necesitan limpieza. El
ejemplo clasico es with open('[Link]') as f: que garantiza que el archivo se cierre
aunque ocurra un error.
Modulos y paquetes
Python organiza el codigo en modulos y paquetes:
Un modulo es simplemente un archivo .py. Se importa con import nombre_modulo o from
modulo import funcion. Los modulos evitan la repeticion de codigo y permiten una
organizacion clara del proyecto.
Un paquete es un directorio que contiene un archivo __init__.py y uno o mas modulos.
Los paquetes permiten crear jerarquias de modulos para proyectos grandes.
La biblioteca estandar de Python es extremadamente rica. Incluye modulos para:
- os y pathlib: operaciones del sistema de archivos
- json: lectura y escritura de JSON
- datetime: manejo de fechas y horas
- re: expresiones regulares
- collections: estructuras de datos avanzadas
- itertools: herramientas para iteracion eficiente
- functools: herramientas para funciones de orden superior
- unittest y pytest: testing automatizado
- logging: sistema de registro de eventos
pip es el gestor de paquetes de Python. Permite instalar paquetes de PyPI con pip install
paquete. Se recomienda usar entornos virtuales (venv) para aislar las dependencias de
cada proyecto.
Consejos y buenas practicas
Para escribir codigo Python de calidad, sigue estas recomendaciones:
Sigue PEP 8: la guia de estilo oficial de Python. Usa 4 espacios para indentacion, limita
las lineas a 79 caracteres, usa nombres descriptivos en snake_case para variables y
funciones, y CamelCase para clases.
Usa type hints: las anotaciones de tipo (def suma(a: int, b: int) -> int:) mejoran la
documentacion y permiten deteccion de errores con herramientas como mypy.
Escribe tests: usa pytest o unittest para verificar que tu codigo funciona correctamente.
Apunta a una cobertura de tests razonable para las partes criticas.
Documenta tu codigo: usa docstrings para explicar que hacen las funciones y clases. El
formato Google o NumPy son los mas populares.
Usa entornos virtuales: siempre crea un venv para cada proyecto. Esto evita conflictos
entre dependencias de diferentes proyectos.
Aprovecha las herramientas: usa linters como flake8 o ruff, formateadores como black, y
editores con buen soporte para Python como VS Code o PyCharm.