En Python, existen varios tipos de datos incorporados y estructuras de datos que puedes utilizar.
Aquí te explico algunos de los más comunes y útiles:
1. Tipos de Datos Básicos:
- Números enteros (
int): Representan números enteros positivos o negativos.
x = 5 y = -10
- Números de punto flotante (
float): Representan números con decimales.
pi = 3.14159
- Cadenas de texto (
str): Representan texto o secuencias de caracteres.
nombre = "Juan"
- Booleanos (
bool): Solo pueden tener dos valores:TrueoFalse.
es_mayor = True
- Nulos (
NoneType): El tipo de dato para representar la ausencia de valor.
x = None
2. Estructuras de Datos:
- Lista (
list): Una colección ordenada que puede contener cualquier tipo de dato y permite duplicados. Es mutable (se puede modificar).
mi_lista = [1, 2, 3, "texto"] mi_lista.append(4) # Añade un elemento print(mi_lista[0]) # Salida: 1
- Diccionario (
dict): Una colección no ordenada de pares clave-valor. Es mutable y las claves deben ser únicas.
mi_diccionario = {"nombre": "Juan", "edad": 25}
print(mi_diccionario["nombre"]) # Salida: Juan
- Tupla (
tuple): Una secuencia ordenada e inmutable de elementos. A diferencia de las listas, las tuplas no pueden modificarse después de ser creadas.
mi_tupla = (10, 20, 30)
- Conjunto (
set): Una colección no ordenada de elementos únicos. Se usa para eliminar duplicados y realizar operaciones de conjuntos como intersección, unión, etc.
mi_set = {1, 2, 3, 4, 4} # El valor 4 aparecerá una sola vez
- Frozenset: Es similar a un
set, pero inmutable. Una vez creado, no se puede modificar.
mi_frozenset = frozenset([1, 2, 3])
3. Tipos Avanzados:
- Bytes (
bytes): Representa una secuencia inmutable de bytes (datos binarios).
datos = b"Hola Mundo"
- Bytearray (
bytearray): Similar abytes, pero mutable. Puedes modificar los valores después de crearlo.
datos_modificables = bytearray(b"Hola")
- Range (
range): Representa una secuencia de números, generalmente usado en bucles (for).
rango = range(1, 10) # Genera números del 1 al 9
- Enumeradores (
enum): Se usa para definir conjuntos de valores constantes con nombres simbólicos.
from enum import Enum
class Color(Enum):
ROJO = 1
VERDE = 2
AZUL = 3
4. Colecciones Especializadas:
Python también proporciona estructuras de datos avanzadas a través del módulo collections:
- Deque (
collections.deque): Una lista doblemente enlazada que permite añadir y eliminar elementos de ambos extremos de manera eficiente.
from collections import deque mi_deque = deque([1, 2, 3]) mi_deque.appendleft(0) # Añadir al inicio
- Namedtuple (
collections.namedtuple): Una tupla que permite acceso a los elementos mediante nombres, como si fuera un objeto.
from collections import namedtuple
Persona = namedtuple('Persona', ['nombre', 'edad'])
juan = Persona(nombre="Juan", edad=25)
print(juan.nombre) # Salida: Juan
- Counter (
collections.Counter): Un diccionario especializado para contar elementos, útil para conteos de frecuencias.
from collections import Counter
conteo = Counter("abracadabra")
print(conteo) # Salida: Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
- Defaultdict (
collections.defaultdict): Similar a un diccionario, pero con un valor por defecto si la clave no existe.
from collections import defaultdict mi_diccionario = defaultdict(int) print(mi_diccionario["clave_inexistente"]) # Salida: 0 (por defecto es un int que empieza en 0)
5. Estructuras de Datos Personalizadas (Clases):
En Python, puedes definir tus propias clases para crear estructuras de datos personalizadas, que te permiten agrupar datos y funciones relacionados.
Ejemplo básico:
class Persona:
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad
def saludar(self):
return f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años."
juan = Persona("Juan", 25)
print(juan.saludar()) # Salida: Hola, mi nombre es Juan y tengo 25 años.
Esto te permite organizar datos y comportamientos de manera más estructurada.
6. Comprehensions (Comprensiones):
Las comprensiones son una forma compacta de crear listas, conjuntos o diccionarios aplicando condiciones o transformaciones en una sola línea de código. Son muy útiles para manipular colecciones de datos de manera eficiente y legible.
- List comprehension:
cuadrados = [x**2 for x in range(5)] print(cuadrados) # Salida: [0, 1, 4, 9, 16]
- Set comprehension:
mi_set = {x for x in range(5)}
print(mi_set) # Salida: {0, 1, 2, 3, 4}
- Dictionary comprehension:
diccionario = {x: x**2 for x in range(5)}
print(diccionario) # Salida: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
7. Funciones Lambda:
Las funciones lambda son funciones anónimas o sin nombre que se definen en una sola línea. Son útiles para operaciones rápidas o como argumentos en otras funciones (como map(), filter() o sorted()).
Ejemplo de una función lambda:
doblar = lambda x: x * 2 print(doblar(5)) # Salida: 10
8. Manejo de Excepciones:
En Python, puedes gestionar errores y excepciones usando try, except, finally. Esto es útil para evitar que tu programa se bloquee si ocurre un error inesperado.
Ejemplo:
try:
resultado = 10 / 0
except ZeroDivisionError:
print("Error: No puedes dividir entre cero.")
finally:
print("Esto siempre se ejecuta.")
9. Iteradores e Iterables:
Un iterador es un objeto que permite recorrer una secuencia (como una lista o tupla) uno a uno. Los iteradores se crean de manera implícita en bucles for y al usar funciones como next(). También puedes crear iteradores personalizados.
Ejemplo básico con iter() y next():
mi_lista = [1, 2, 3] iterador = iter(mi_lista) print(next(iterador)) # Salida: 1 print(next(iterador)) # Salida: 2
10. Generadores:
Los generadores son una forma eficiente de trabajar con iteradores. Se crean con funciones que usan la palabra clave yield en lugar de return, permitiendo que la función retenga su estado entre llamadas.
Ejemplo:
def contador(max):
n = 0
while n < max:
yield n
n += 1
for num in contador(5):
print(num) # Salida: 0, 1, 2, 3, 4
11. Manejo de Archivos:
Python tiene funciones integradas para trabajar con archivos de forma fácil. Puedes abrir, leer, escribir y cerrar archivos utilizando la función open().
Ejemplo de lectura de archivo:
with open('archivo.txt', 'r') as archivo:
contenido = archivo.read()
print(contenido)
El uso de with asegura que el archivo se cierre automáticamente una vez finalizado el bloque.
12. Decoradores:
Los decoradores son una forma de modificar el comportamiento de funciones o métodos. Se usan a menudo en casos como logging, control de acceso, etc.
Ejemplo básico:
def decorador(funcion):
def nueva_funcion():
print("Función decorada")
funcion()
return nueva_funcion
@decorador
def saludar():
print("Hola!")
saludar()
# Salida:
# Función decorada
# Hola!
13. Context Managers:
Los gestores de contexto permiten manejar recursos (como archivos o conexiones) asegurando su correcta liberación una vez finalizados, usando with.
Ejemplo de un gestor de contexto personalizado:
class MiRecurso:
def __enter__(self):
print("Recurso abierto")
return self
def __exit__(self, tipo, valor, traceback):
print("Recurso cerrado")
with MiRecurso():
print("Usando el recurso")
# Salida:
# Recurso abierto
# Usando el recurso
# Recurso cerrado
14. Anotaciones de Tipos:
Python permite anotaciones de tipos para ayudar a la lectura del código y facilitar el uso de herramientas de análisis estático, como mypy.
Ejemplo:
def suma(a: int, b: int) -> int:
return a + b
15. Programación Funcional:
Python admite ciertos conceptos de programación funcional, como las funciones map(), filter(), y reduce().
- map(): Aplica una función a cada elemento de una secuencia.
cuadrados = list(map(lambda x: x**2, [1, 2, 3]))
- filter(): Filtra elementos que cumplen una condición.
pares = list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4]))
- reduce(): Reduce una secuencia a un solo valor (requiere
functools).
from functools import reduce suma_total = reduce(lambda x, y: x + y, [1, 2, 3, 4])
