1.3.-Tipos de datos

1.3. Tipos de datos¶

Idea principal

El tipo de un dato indica qué valor representa y qué operaciones son coherentes con él. Elegir y comprobar los tipos evita errores y permite transformar los datos de entrada en información útil.

En 1.2 usamos variables, operadores y conversiones en pequeños programas. Ahora profundizaremos en los tipos simples y en los principales contenedores de Python. Esta base será necesaria para recorrer, filtrar y procesar colecciones en los siguientes temas.

1. Por qué existen los tipos¶

Un tipo de dato describe qué clase de valor representa un dato y qué operaciones se pueden realizar con él. Los tipos permiten que el programa interprete correctamente los valores y distinga, por ejemplo, entre el número 17 y el texto "17". Aunque ambos se escriben con los mismos dígitos, el primero puede participar en operaciones aritméticas y el segundo está formado por dos caracteres.

>>> 17 + 3
20
>>> "17" + "3"
'173'
>>> 17 + "3"
Traceback (most recent call last):
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Los lenguajes gestionan los tipos de distintas maneras:

En un lenguaje de tipado estático, como Kotlin, el tipo se conoce y se comprueba normalmente antes de ejecutar el programa. El compilador puede detectar muchos errores con antelación.
En un lenguaje de tipado dinámico, como Python, el tipo se asocia al valor durante la ejecución y no es obligatorio escribirlo al crear cada variable.
En un lenguaje de tipado fuerte, como Python o Kotlin, no se mezclan sin más valores incompatibles.
En un lenguaje de tipado débil pueden existir más conversiones implícitas. Esto puede reducir la cantidad de código escrito, pero también ocultar errores.

Estas características no hacen que un lenguaje sea mejor que otro. Representan distintos equilibrios entre flexibilidad, rapidez para escribir y cantidad de errores que se detectan antes de ejecutar el programa.

Aunque Python es dinámico, conocer el tipo de cada dato sigue siendo importante. Elegir y comprobar el tipo adecuado permite:

aplicar operaciones válidas y obtener resultados previsibles;
detectar conversiones incorrectas;
documentar la intención del programa;
facilitar la lectura, las pruebas y el mantenimiento del código.

En Python se puede consultar el tipo actual con type(). También se pueden usar anotaciones de tipo para comunicar qué tipo se espera, aunque Python no las utiliza por sí solo para impedir la ejecución:

nombre: str = "Ada"
edad: int = 36

Las anotaciones ayudan a las herramientas de desarrollo y a quienes leen el código. En cualquier caso, un valor obtenido con input() sigue siendo texto hasta que se convierte explícitamente.

Este contenido trabaja el RA 1 del módulo de Programación.

Código	Descripción
RA 1	Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.
CE d	Se han identificado los distintos tipos de variables y la utilidad específica de cada uno.
CE e	Se ha modificado el código de un programa para crear y utilizar variables.
CE g	Se han clasificado, reconocido y utilizado en expresiones los operadores del lenguaje.
CE h	Se ha comprobado el funcionamiento de las conversiones de tipo explícitas e implícitas.

Qué deberías saber al terminar

Al acabar este apartado deberías poder:

distinguir int, float, str, bool y None;
consultar el tipo de un valor con type();
acceder a caracteres y subcadenas mediante índices y rebanadas;
elegir entre listas, tuplas y diccionarios;
combinar datos con operadores adecuados;
realizar conversiones explícitas y explicar las implícitas.

2. Clasificación de los datos¶

Los tipos simples representan valores individuales, como un número, un texto o un valor lógico. Los tipos compuestos o contenedores agrupan varios valores. En Python todo es un objeto y cada objeto tiene un tipo que determina sus operaciones.

Categoría	Tipos principales	Ejemplos
Simples	`int`, `float`, `str`, `bool`, `NoneType`	`18`, `2.5`, `"FP"`, `True`, `None`
Contenedores	`list`, `tuple`, `dict`	`[1, 2]`, `(1, 2)`, `{"id": 1}`

No confundas “simple” con “poco importante”: una cadena puede contener muchos caracteres, pero se trata como un único objeto de tipo str.

3. Consultar el tipo de un dato¶

La función type() devuelve la clase del objeto:

>>> type(1)
<class 'int'>
>>> type(2.5)
<class 'float'>
>>> type("Hola")
<class 'str'>
>>> type([1, "dos", True])
<class 'list'>
>>> type((1, 2))
<class 'tuple'>
>>> type({"pi": 3.1416})
<class 'dict'>

También puedes comprobar si un objeto es de un tipo con isinstance(valor, tipo), una opción habitual cuando validas datos:

edad = 18
if isinstance(edad, int):
    print("La edad es un entero")

4. Números: `int` y `float`¶

int representa números enteros y float números con parte decimal. Los decimales se escriben con punto, no con coma.

>>> type(-2)
<class 'int'>
>>> type(2.3)
<class 'float'>
>>> 5 / 2
2.5
>>> 5 // 2
2
>>> 5 % 2
1
>>> 2 ** 3
8

Los operadores aritméticos son +, -, *, /, //, % y **. La precedencia sigue, de forma general, este orden: paréntesis, potencias, productos y cocientes, y sumas y restas. Los paréntesis permiten expresar la intención sin ambigüedad.

Las comparaciones numéricas (==, !=, >, <, >=, <=) producen un booleano:

>>> 3 == 3
True
>>> 3.1 <= 3
False
>>> -1 != 1
True

Precisión de los números reales

Los float se representan normalmente en coma flotante y algunos valores decimales no pueden almacenarse con precisión exacta. Para cálculos económicos conviene estudiar tipos o técnicas específicas, como Decimal.

5. Cadenas de texto: `str`¶

Una cadena es una secuencia de caracteres delimitada por comillas simples o dobles. Puede estar vacía, contener espacios o incluir caracteres especiales:

texto = "Python"
vacio = ""
espacio = " "
salto = "\n"
tabulador = "\t"

4.1. Índices y caracteres¶

Los índices empiezan en cero. Los índices negativos cuentan desde el final:

Cadena	`P`	`y`	`t`	`h`	`o`	`n`
Índice positivo	0	1	2	3	4	5
Índice negativo	-6	-5	-4	-3	-2	-1

>>> "Python"[0]
'P'
>>> "Python"[-1]
'n'
>>> "Python"[6]
Traceback (most recent call last):
IndexError: string index out of range

Un índice fuera de rango produce IndexError.

4.2. Subcadenas o rebanadas¶

La forma cadena[inicio:fin:paso] devuelve una parte. El límite final no se incluye:

>>> "Python"[1:4]
'yth'
>>> "Python"[2:]
'thon'
>>> "Python"[:-2]
'Pyth'
>>> "Python"[0:6:2]
'Pto'
>>> "Python"[:]
'Python'

Las cadenas son inmutables: puedes crear una nueva cadena, pero no cambiar un carácter directamente.

4.3. Operaciones y funciones de cadenas¶

Operación	Resultado
`c1 + c2`	Concatena cadenas.
`c * n`	Repite una cadena.
`c1 in c2` / `not in`	Comprueba si aparece una subcadena.
`len(c)`	Devuelve la longitud.
`c.upper()` / `c.lower()`	Cambia a mayúsculas o minúsculas.
`c.title()`	Escribe en formato de título.
`c.split(separador)`	Divide y devuelve una lista.
`min(c)` / `max(c)`	Devuelve el carácter mínimo o máximo según el orden Unicode.

>>> "Me gusta " + "Python"
'Me gusta Python'
>>> "Python" * 2
'PythonPython'
>>> "thon" in "Python"
True
>>> "A,B,C".split(",")
['A', 'B', 'C']
>>> "python".upper()
'PYTHON'

Las comparaciones de cadenas distinguen mayúsculas y minúsculas y siguen el orden Unicode, no necesariamente el orden alfabético humano:

>>> "Python" == "python"
False
>>> "a" > "Z"
True

Para presentar valores es preferible usar f-strings:

>>> moneda = "€"
>>> cambio = 1.12
>>> f"Un euro equivale a {cambio:.2f} {moneda}"
'Un euro equivale a 1.12 €'

El método format() también es válido y permite posiciones, nombres y formatos:

>>> "Un {} vale {} {}".format("€", 1.12, "$")
'Un € vale 1.12 $'
>>> "Un {moneda} vale {cambio:.2f} {otra}".format(
...     moneda="€", cambio=1.12, otra="$"
... )
'Un € vale 1.12 $'

En los marcadores, {:n}, {:>n} y {:^n} alinean a izquierda, derecha o centro; :nd reserva n posiciones para un entero y :n.mf reserva n posiciones con m cifras decimales. Por ejemplo, "Pi vale {:8.4f}".format(3.141592) produce Pi vale 3.1416.

6. Booleanos: `bool`¶

El tipo bool solo tiene True y False. Aparece en comparaciones y controla las condiciones del programa.

>>> not True
False
>>> False or True
True
>>> True and False
False

Tabla de verdad básica:

`x`	`y`	`not x`	`x and y`	`x or y`
`False`	`False`	`True`	`False`	`False`
`False`	`True`	`True`	`False`	`True`
`True`	`False`	`False`	`False`	`True`
`True`	`True`	`False`	`True`	`True`

En un contexto lógico, Python considera falsos False, None, 0, 0.0, las cadenas y contenedores vacíos. La mayoría de los demás valores se consideran verdaderos. Por eso bool("0") es True: la cadena no está vacía.

7. Contenedores¶

Los contenedores permiten agrupar datos. Pueden contener valores de tipos distintos, aunque en un proyecto es recomendable que la estructura sea clara.

6.1. Listas: `list`¶

Una lista es ordenada y mutable. Se escribe entre corchetes:

>>> tareas = ["analizar", "programar", "probar"]
>>> tareas[0]
'analizar'
>>> tareas.append("documentar")
>>> tareas
['analizar', 'programar', 'probar', 'documentar']

Se utiliza cuando el contenido puede cambiar. Admite índices, rebanadas y operaciones como append, remove, sort y len.

6.2. Tuplas: `tuple`¶

Una tupla es una secuencia ordenada e inmutable. Se escribe normalmente entre paréntesis:

>>> coordenada = (40.4, -3.7)
>>> coordenada[0]
40.4

Es adecuada para datos que deben permanecer constantes, como una coordenada o los valores de configuración de una conexión.

6.3. Diccionarios: `dict`¶

Un diccionario relaciona claves con valores y se escribe entre llaves. Las claves deben ser únicas:

>>> alumno = {"nombre": "Ada", "edad": 18}
>>> alumno["nombre"]
'Ada'
>>> alumno["curso"] = "DAW"
>>> alumno
{'nombre': 'Ada', 'edad': 18, 'curso': 'DAW'}

Es útil para representar entidades cuyos datos tienen nombre. Para evitar un KeyError puedes usar get("clave") cuando la clave sea opcional.

8. Conversiones de tipo¶

Una conversión explícita se solicita mediante una función:

int("12")       # 12
float("3.14")   # 3.14
str(3.14)       # "3.14"
bool("")        # False
int(True)       # 1
float(True)     # 1.0

La conversión debe ser válida: int("c") y float("III") producen ValueError. Además, int(3.9) devuelve 3, porque descarta la parte decimal; no redondea.

Una conversión implícita la realiza Python cuando una operación lo permite, por ejemplo al combinar int y float:

>>> 2 + 3.0
5.0

No hay conversión implícita de str a número ni de número a str:

>>> 2 + int("3")
5
>>> "Total: " + str(5)
'Total: 5'

Comprueba la entrada antes de convertirla

Los datos del teclado y de formularios llegan normalmente como texto. Una aplicación fiable valida el formato y contempla errores antes de usar int() o float().

9. Buenas prácticas y errores frecuentes¶

Situación	Problema	Solución
`5 / 2` frente a `5 // 2`	Se necesita saber si se quiere división real o cociente entero.	Elegir el operador y documentar la intención.
`"17"` frente a `17`	Parecen iguales, pero sus tipos y operaciones son distintos.	Comprobar con `type()` y convertir cuando proceda.
Índice `6` en `"Python"`	El último índice es `5`.	Usar `len(cadena) - 1` o una rebanada segura.
`is` para comparar textos	Comprueba identidad, no igualdad de contenido.	Usar `==`.
`bool("0")`	Toda cadena no vacía es verdadera.	Convertir a número si representa una cantidad.
Modificar una tupla o cadena	Son inmutables.	Crear un nuevo valor o usar una lista.

Comprueba tu comprensión

¿Qué tipos tienen "3", 3 y 3.0? ¿Qué estructura elegirías para una lista de tareas que puede cambiar y cuál para una coordenada fija? Justifica cada decisión.

10. Resumen¶

El tipo determina las operaciones válidas y la forma de interpretar un dato.
int, float, str, bool y None representan los valores básicos.
Las cadenas son secuencias indexadas e inmutables; las listas son secuencias mutables; las tuplas son secuencias inmutables y los diccionarios relacionan claves con valores.
type() permite inspeccionar un dato e isinstance() ayuda a validarlo.
Las conversiones explícitas se solicitan con funciones y las implícitas solo ocurren en situaciones concretas.

Idea clave

Elegir el tipo adecuado no es un detalle de sintaxis: es una decisión de diseño. Cuando el programa representa correctamente sus datos, las operaciones, las comprobaciones y la depuración resultan mucho más claras.