Tipos de Datos Básicos en Python

Tipos de Datos Básicos

Los tipos de datos fundamentales en Python incluyen seis categorías principales:

  • Números: incluyen enteros (int), flotantes (float), booleanos (True/False). Son tipos inmutables.
  • Cadenas de texto (str): secuencia de caracteres, utilizadas para almacenar texto. Son tipos inmutables.
  • Listas (list): secuencia de elementos, permiten almacenar múltiples valores. Son tipos mutables.
  • Tuplas (tuple): secuencia de elementos para representar combinaciones fijas. Son tipos inmutables.
  • Conjuntos (set): colección desordenada de elementos únicos. Son tipos mutables.
  • Diccionarios (dict): colección de pares clave-valor. Son tipos mutables.

Los tipos secuenciales son conjuntos de datos ordenados que pueden ser accedidos mediante índices.

Números

Incluyen enteros, flotantes, booleanos y números complejos. Son tipos inmutables.

Clasificación

  1. Enteros (int): Como 5, 1024, -7. Tamaño prácticamente ilimitado.
  2. Flotantes (float): Como 3.14, 0.001, -9.8.
  3. Booleanos (bool):
  • False: Falso. En Python, además de False, se consideran falsos: 0, "0", 0.0, cadena vacía '', lista vacía [], tupla vacía () y conjunto vacío {}.
  • True: Verdadero.

Operadores

    • Suma
    • Resta
    • Multiplicación
  • / División (resultado es flotante)
  • // División entera (descarta decimales)
  • % Módulo (resto de división)
  • ** Exponenciación

Conversiones de tipo

  • str(): Convierte otros tipos a cadena de texto
  • int(): Convierte cadenas o flotantes a enteros
  • float(): Convierte cadenas o enteros a flotantes

Lista (list, tipo mutable, tipo secuencial)

Una variable puede almacenar múltiples valores de diferentes tipos.

Operaciones con listas

Método Descripción Ejemplo
append()/insert()/extend() Agregar/insertar/expandir [1,2].append(3)
insert() Insertar en posición específica [1,3].insert(1,2)
extend() Extender con elementos de otra lista [1,2].extend([3,4])
index() Obtener índice de elemento [1,2].index(2)
count() Contar ocurrencias [1,2,1,1].count(1)
pop() Eliminar por índice [1,2].pop(0)
remove() Eliminar por elemento [1,2].remove(1)
sort() Ordenar [1,3,2].sort()
reverse() Invertir [1,3,2].reverse()
len() Contar elementos len(mi_lista)

Asignación:

datos = [42, "Hola mundo", ("123", "xyz")]

Acceso por índice:

print(datos[1])

Adición de elementos:

datos.append("nuevo_elemento")  # Agrega al final
datos.extend(["k8s", "openstack", 123])  # Agrega elementos de otra lista
datos.insert(1, "segundo elemento")  # Inserta en posición 1

Eliminación:

datos.pop(1)  # Elimina por índice
datos.remove("k8s")  # Elimina elemento específico
del datos[0]  # Elimina por índice

Modificación:

datos[0] = "Python"  # Modifica por índice

Recorrido:

for elemento in datos:
    print(elemento)

Otros métodos:

# Obtener índice
print(datos.index("nuevo_elemento"))

# Ordenar
numeros = [12, 43, 12, 9, 1]
numeros.sort()
print(numeros)

# Ordenar sin modificar original
numeros = [12, 43, 12, 9, 1]
ordenados = sorted(numeros)
print(ordenados)

# Invertir
numeros = [12, 43, 12, 9, 1]
numeros.reverse()
print(numeros)

Caso de estudio: Contar resultados de lanzamiento de dado

import random

# Simular 6000 lanzamientos de un dado
resultados = [random.randint(1, 6) for _ in range(6000)]

# Contar ocurrencias de cada número
conteo = {i: resultados.count(i) for i in range(1, 7)}

print("Frecuencia de cada número:")
for numero, frecuencia in conteo.items():
    print(f"Número {numero}: {frecuencia} veces")

Invertir cadena de texto

texto = "abcdefg"
# reversed() devuelve un iterador
invertido = list(reversed(texto))
print(invertido)  # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

# Unir los caracteres invertidos
resultado = "".join(reversed(texto))
print(resultado)  # gfedcba

Tupla (tuple, tipo inmutable, tipo secuencial)

  1. Tipo de dato inmutable que es secuencial (admite operaciones de slicing).
  2. Puede almacenar múltiples tipos de datos (listas, diccionarios, cadenas) con anidación.
  3. Al tener un solo elemento, se debe agregar una coma: mi_tupla = ("hola",), ya que () tiene significado de agrupación en Python.

¿Por qué usar tuplas?

A veces es necesario usar múltiples variables para expresar un valor fijo, como coordenadas (x, y). En algoritmos hash, la inmutabilidad es crucial para generar valores hash consistentes. Como objeto inmutable, las tuplas pueden ser claves de diccionario: {(1, 2): 3} es válido.

Métodos de tupla

Dado que son inmutables, tienen pocos métodos incorporados:

Método Descripción Ejemplo
index() Obtener índice de elemento tupla.index(elemento)
count() Contar ocurrencias tupla.count(elemento) 
# Crear tupla
datos = (12, "99", "ask", "qqq")
print(datos[1:3])  # Slicing
print(len(datos))  # Longitud
print(datos.count("99"))  # Contar

# Concatenar tuplas
t1 = (1, 2)
t2 = ("99", "ll", "mm")
print(t1 + t2)  # (1, 2, '99', 'll', 'mm')

Modificación de elementos dentro de tupla

# La tupla en sí es inmutable, pero sus elementos mutables sí pueden modificarse
mi_tupla = (1, 2, ["qq", 22])
mi_tupla[2][1] = "99"  # Modificar elemento de la lista dentro de la tupla
print(mi_tupla)  # (1, 2, ['qq', '99'])

# No se puede reemplazar toda la lista
# mi_tupla[2] = ["nuevo", "lista"]  # Error: tupla inmutable

Empaquetado y desempaquetado

# Empaquetado
valores = 1, 2, "99"
print(valores)  # (1, 2, '99')

# Desempaquetado
x, y, z = valores
print(x, y, z)  # 1 2 99

Comparación entre tuplas y listas

¿Por qué necesitamos tuplas si ya tenemos listas en Python?

  • Las tuplas son inmutables, lo que las hace más adecuadas para entornos multihilo, ya que reduce la sobrecarga de sincronización.
  • Son más eficientes en tiempo de creación que sus contrapartes mutables.
  • Se pueden convertir entre sí:
# Tupla a lista
tupla = (1, "99", "aa")
print(list(tupla))  # [1, '99', 'aa']

# Lista a tupla
lista = [1, "99", "aa"]
print(tuple(lista))  # (1, '99', 'aa')

Resumen de tuplas

Tanto listas como tuplas son tipos de datos contenedores que pueden almacenar múltiples datos organizados en orden. Las listas son mutables, mientras que las tuplas son inmutables. Por lo tanto, las listas permiten agregar, eliminar, modificar, ordenar e invertir, operaciones que no son posibles con las tuplas. Ambos tipos soportan operaciones de concatenación.

Cadena de texto (str, tipo inmutable, tipo secuencial)

  1. Tipo de dato inmutable y secuencial, accesible por índice.
  2. La inmutabilidad significa que no se puede modificar la cadena original; cualquier modificación crea una nueva cadena.
  3. Todos los métodos de cadena devuelven un valor y no modifican la cadena original.
  4. Secuencia finita de cero o más caracteres.

Métodos de cadena

Método Descripción Ejemplo
len() Longitud de la cadena len("texto")
count() Contar ocurrencias cadena.count("a")
find(), index() Buscar índice de primera ocurrencia "texto".find("abc")
replace() Reemplazar subcadena "texto".replace("viejo", "nuevo")
split() Dividir en lista "a,b,c".split(",")
join() Unir con separador "-".join(["a", "b"])
lower()/upper() Convertir a minúsculas/mayúsculas "Hola".lower()
isdigit()/isalpha()/isalnum() Verificar tipo de contenido "123".isdigit()
strip()/lstrip()/rstrip() Eliminar caracteres no deseados " texto ".strip() 
# Unir elementos con separador
texto1 = "a,d,g"
texto2 = "-".join(texto1)
print(texto2)  # a-,-d-,-g

lista = ["1", "a", "c"]
texto3 = "-".join(lista)
print(texto3)  # 1-a-c

# Reemplazar texto
texto4 = "a,e,r"
texto5 = texto4.replace(",", "--")
print(texto5)  # a--e--r

# Buscar subcadena
texto6 = "a,e,r"
print(texto6.find("r"))  # 4

# Dividir cadena
texto7 = "a,e,r"
lista2 = texto7.split(",")
print(lista2)  # ['a', 'e', 'r']

# Eliminar caracteres no deseados
texto8 = "  qwe  "
texto9 = texto8.strip()
print(texto9)  # qwe

texto10 = "baqweab"
texto11 = texto10.strip("ab")
print(texto11)  # qwe

# Slicing
texto12 = "baqweab"
print(texto12[1:2])  # a

# Operador de membresía
texto13 = "hello,world"
texto14 = "goodbye,world"

print("wo" in texto13)    # True
print("wo" not in texto13)  # False
print(texto14 in texto13)  # False

Operaciones con cadenas

  • Comparación: >, <, ==, !=
  • Membresía: in, not in
  • Lógicos: and, or, not
  • Compuestos: +=, -=, *=

Devuelven True o False.

Formato de cadenas

nombre = "ana"
edad = 25
print(f"Me llamo {nombre} y tengo {edad} años")  # Formato f (recomendado)
print("Me llamo {}, tengo {} años".format(nombre, edad))
print("Me llamo %s, tengo %d años" % (nombre, edad))

Caracteres de escape

  • \t - Tabulador
  • \n - Salto de línea
  • \b - Retroceso
  • \r - Retorno de carro
  • \\ - Barra invertida

Conjunto (set, tipo mutable, tipo disperso)

Definición de conjunto

Características:

  • Tipo mutable, pero sus elementos deben ser inmutables.
  • Desordenado: no hay orden específico entre elementos.
  • Único: no permite elementos duplicados (automáticamente elimina duplicados).
  • Puede almacenar múltiples tipos de datos, pero solo elementos inmutables (no puede almacenar listas).
  • Puede almacenar tuplas, cadenas y otros elementos inmutables.
# Crear conjunto
conjunto1 = {"ad", 123}

# {} crea un diccionario, no un conjunto vacío
conjunto_vacio = {}
print(conjunto_vacio)
print(type(conjunto_vacio))

# Para crear un conjunto vacío, usar set()
conjunto2 = set()
print(conjunto2, type(conjunto2))

Métodos de conjunto

  • add(): Agregar elemento
  • remove(): Eliminar elemento (error si no existe)
  • discard(): Eliminar elemento (no da error si no existe)
  • pop(): Eliminar y devolver elemento aleatorio
  • clear(): Vaciar conjunto
  • udpate(): Agregar múltiples elementos de otro conjunto
mi_conjunto = {123, "ad", "qq"}
mi_conjunto.add("aa")     # Agregar elemento
mi_conjunto.remove("ad")  # Eliminar elemento
mi_conjunto.pop()        # Eliminar elemento aleatorio
mi_conjunto.discard(123) # Eliminar elemento (si existe)

otro_conjunto = {"mm", "nn"}
mi_conjunto.update(otro_conjunto)
print(mi_conjunto)

Diccionario (dict, tipo mutable, tipo disperso)

Definición de diccionario

  • Tipo mutable donde las claves (key) deben ser inmutables y no pueden duplicarse.
  • Tipo disperso (no usa índices numéricos).
  • Al agregar elementos, el orden puede cambiar.
  • Cada elemento es un par clave-valor.
# Crear diccionario
usuario = {
    "nombre": "carlos",
    "edad": 30,
    "genero": "masculino",
    "contactos": ["123", 456]
}

Operaciones con diccionarios

# Acceder por clave
print(usuario["nombre"])

# Modificar valor
usuario["edad"] = 31

# Operador de membresía
print("nombre" in usuario)
print("edad" not in usuario)

# Recorrer diccionario
for clave in usuario:
    print(f"{clave}: {usuario[clave]}")

Métodos de diccionario

Método Descripción Ejemplo
dict.get(clave, por_defecto) Obtener valor, devuelve por_defecto si no existe d.get('a', 0)
dict.setdefault(clave, por_defecto) Obtener valor, si no existe lo establece d.setdefault('a', [])
dict.otro) Fusionar con otro diccionario d.update({'b': 2})
dict.pop(clave[, por_defecto]) Eliminar y devolver valor d.pop('a')
dict.popitem() Eliminar y devolver último par clave-valor d.popitem()
dict.clear() Vaciar diccionario d.clear() 
# Obtener valores
print(usuario.get("nombre"))  # Obtener por clave
print(usuario.get("peso", "no especificado"))  # Valor por defecto

# Obtener todas las claves, valores o pares
print(usuario.keys())    # dict_keys(['nombre', 'edad', 'genero', 'contactos'])
print(usuario.values())  # dict_values(['carlos', 31, 'masculino', ['123', 456]])
print(usuario.items())  # dict_items([('nombre', 'carlos'), ...])

# Recorrer pares clave-valor
for k, v in usuario.items():
    print(f"{k}: {v}")

Modificación de diccionarios

# Modificar o agregar elementos
usuario["nombre"] = "carlos gomez"  # Modificar existente
usuario["peso"] = 75              # Agregar nuevo

# Fusionar diccionarios
nuevos_datos = {
    "nombre": "carlos perez",
    "altura": 1.75
}
usuario.update(nuevos_datos)
print(usuario)

Eliminación de elementos

# Eliminar por clave
usuario.pop("nombre")
print(usuario)

# Eliminar último par agregado
usuario.popitem()
print(usuario)

# Eliminar por clave con del
del usuario["edad"]

# Vaciar diccionario
usuario.clear()

Diccionarios anidados

# Estructura anidada
datos = {
    "informacion": {
        "total": 197,
        "registros": [
            {"nombre": "tom", "edad": 18},
            {"nombre": "jerry", "edad": 19}
        ]
    },
    "version": 2.0
}

# Acceder a datos anidados
print(datos["informacion"]["registros"][0]["nombre"])

Diccionarios con múltiples valores

# Un clave con múltiples valores
estudiantes = {
    101: ["maria", "luis", "ana"],
    102: ["juan", "pedro"]
}

# Agregar nuevo estudiante
estudiantes[101].append("sara")
print(estudiantes)

Resumen de tipos de datos

  • Lista: Tipo mutable, puede almacenar múltiples tipos, usa índices. Las operaciones de agregar, eliminar y modificar cambian la lista original sin devolver valor.
  • Tupla: Tipo inmutable, puede almacenar múltiples tipos, usa índices. No puede ser modificada.
  • Cadena: Tipo inmutable, usa índices. Sus métodos siempre devuelven un nuevo valor sin modificar la original.
  • Conjunto: Tipo mutable, desordenado, con elementos únicos e inmutables.
  • Diccionario: Tipo mutable con claves inmutables y valores de cualquier tipo.

Operaciones comunes de tipos secuenciales

Cadenas, listas y tuplas son tipos secuenciales que almacenan elementos ordenados y permiten operaciones por índice y slicing.

# Ejemplos de slicing
numeros = [1, 2, 3, 4, 5]
print(numeros[1:4])   # [2, 3, 4]
print(numeros[::2])   # [1, 3, 5]
print(numeros[::-1])  # [5, 4, 3, 2, 1] (invertido)

Tipos secuenciales vs. dispersos

  • Secuenciales: Colecciones ordenadas con índices y slicing (cadenas, listas, tuplas).
  • Dispersos: Colecciones sin orden específico que no usan índices (conjuntos, diccionarios).

Tipos mutables vs. inmutables

La principal diferencia es si los datos pueden modificarse después de su creación:

  • Mutables: Los datos originales pueden modificarse (listas, conjuntos, diccionarios).
  • Inmutables: Los datos originales no pueden modificarse; cualquier modificación crea un nuevo objeto (cadenas, tuplas).

Objetos iterables

Objetos iterables: aquellos que pueden ser recorridos con un bucle for.

# Ejemplos de iterables
for char in "hola":
    print(char)

for num in [1, 2, 3]:
    print(num)

for item in {"a": 1, "b": 2}:
    print(item)

Etiquetas: Python tipos-de-datos secuencias Colecciones mutable-inmutable

Publicado el 6-14 20:01

Etiquetas populares

©2026 Friki Work