Lección 1.2 — Variables y tipos de datos en Python
Lección 1.2 — Variables y tipos de datos en Python
Curso de inteligencia artificial desde cero
Bloque 1: Python para inteligencia artificial
Lección 1.2 · Lección 2 de 10 del bloque
Nivel: iniciación
Conocimientos previos: ejecutar archivos Python y utilizar el entorno virtual de la lección 1.1.
Las variables y tipos de datos en Python permiten representar la información que utiliza un programa. Una distancia, el nombre de un archivo o el estado de un entrenamiento necesitan valores que podamos guardar, consultar y transformar.
En esta lección aprenderás a trabajar con números, texto, valores booleanos y ausencia de valor. También convertirás datos introducidos por teclado y crearás un pequeño programa de estimación.
1. Preparar el archivo de la lección
Abre la carpeta curso-ia en Visual Studio Code y activa el entorno virtual que creaste en la lección anterior.
Crea una carpeta llamada leccion-1-2. Dentro, guarda un archivo llamado variables.py.
Para ejecutarlo desde la carpeta curso-ia, utiliza:
python leccion-1-2/variables.py
Puedes probar los ejemplos por separado o añadirlos progresivamente al archivo. Los bloques titulados «Resultado» muestran la salida esperada.
2. Qué es una variable en Python
Una variable permite utilizar un nombre para referirnos a un valor:
distancia_km = 12 print(distancia_km)
Resultado:
12
En esta instrucción:
distancia_km = 12
- distancia_km es el nombre.
- = realiza una asignación.
- 12 es el valor que asociamos al nombre.
Python evalúa la expresión de la derecha y asigna su resultado al nombre de la izquierda. Podemos utilizar una operación:
distancia_km = 5 + 7 print(distancia_km)
Resultado:
12
Con más precisión, los nombres de Python se vinculan a objetos. Esta relación será especialmente importante cuando trabajemos con colecciones.
Cambiar el valor asociado a una variable
Podemos realizar otra asignación:
distancia_km = 12 distancia_km = 15 print(distancia_km)
Resultado:
15
El programa ejecuta las instrucciones en orden. Cuando llega a print(), el nombre está asociado al valor 15.
También podemos utilizar el valor anterior para calcular el siguiente:
ejemplos_procesados = 10 ejemplos_procesados = ejemplos_procesados + 1 print(ejemplos_procesados)
Resultado:
11
Primero se calcula 10 + 1. Después se realiza la asignación.
Una forma abreviada para este caso es:
ejemplos_procesados += 1
Una asignación guarda el resultado de ese momento
Observa este ejemplo:
distancia_km = 10 copia_distancia = distancia_km distancia_km = 20 print(distancia_km) print(copia_distancia)
Resultado:
20 10
Asignar distancia_km a copia_distancia no crea una fórmula que vuelva a ejecutarse cada vez que cambie el primer nombre.
3. Cómo elegir nombres para las variables
Utiliza nombres que expliquen qué representa la información:
numero_ejemplos = 120 tiempo_entrega_min = 18.5 nombre_modelo = "modelo_entregas"
En el curso utilizaremos minúsculas y guiones bajos para separar palabras. Este estilo se conoce como snake_case.
Incluiremos unidades cuando aporten claridad. tiempo_entrega_min resulta más preciso que tiempo.
Estas reglas te ayudarán a empezar:
| Regla | Ejemplo |
|---|---|
| El nombre puede contener letras, números y guiones bajos. | modelo_2 |
| No puede comenzar por un número. | Utiliza modelo_2 en lugar de 2modelo. |
| No puede contener espacios. | Utiliza numero_ejemplos. |
| Distingue mayúsculas y minúsculas. | edad y Edad son nombres diferentes. |
| No puede ser una palabra reservada del lenguaje. | if, for y class tienen funciones propias. |
Evita reutilizar nombres de herramientas que necesitas:
# Evita este nombre para una variable. print = 25
Esa asignación dificulta utilizar después la función print() en el mismo ámbito.
Python admite muchos caracteres Unicode en los identificadores. En nuestros ejemplos utilizaremos nombres sin tildes para facilitar su escritura y uso entre herramientas.
4. Los tipos de datos básicos
El tipo determina qué clase de información representa un objeto y qué operaciones admite.
Comenzaremos con estos:
| Tipo | Información | Ejemplo |
|---|---|---|
| int | Número entero. | 120 |
| float | Número de coma flotante. | 18.5 |
| str | Cadena de texto. | «entrega» |
| bool | Valor lógico. | True |
| NoneType | Tipo del valor especial None. | None |
Puedes consultar el tipo mediante type():
numero_ejemplos = 120 tiempo_min = 18.5 nombre = "entrega" modelo_entrenado = False resultado = None print(type(numero_ejemplos)) print(type(tiempo_min)) print(type(nombre)) print(type(modelo_entrenado)) print(type(resultado))
Resultado:
<class 'int'> <class 'float'> <class 'str'> <class 'bool'> <class 'NoneType'>
El tipo pertenece al objeto
Python permite asociar un mismo nombre a valores de tipos diferentes:
dato = 12 print(type(dato)) dato = "doce" print(type(dato))
Resultado:
<class 'int'> <class 'str'>
Esto se relaciona con su tipado dinámico. Durante la ejecución, el nombre puede vincularse a objetos de tipos distintos.
En un programa suele ser más claro mantener un significado coherente para cada nombre.
5. Números enteros con int
Los enteros sirven para representar cantidades sin parte fraccionaria:
numero_imagenes = 500 intentos_restantes = 3 temperatura_entera = -4
Podemos operar con ellos:
imagenes_iniciales = 500 imagenes_nuevas = 25 total_imagenes = imagenes_iniciales + imagenes_nuevas print(total_imagenes)
Resultado:
525
Los enteros de Python pueden crecer según la memoria disponible. Más adelante veremos que algunas bibliotecas numéricas utilizan enteros con tamaños y límites específicos.
Operadores aritméticos básicos
| Operador | Operación | Ejemplo | Resultado |
|---|---|---|---|
| + | Suma. | 7 + 2 | 9 |
| – | Resta. | 7 – 2 | 5 |
| * | Multiplicación. | 7 * 2 | 14 |
| / | División. | 7 / 2 | 3.5 |
| // | División con redondeo hacia abajo. | 7 // 2 | 3 |
| % | Resto de la división. | 7 % 2 | 1 |
| ** | Potencia. | 7 ** 2 | 49 |
Entre enteros, / produce un float, incluso cuando el resultado matemático es entero:
print(8 / 2)
Resultado:
4.0
La división // redondea hacia abajo. Con negativos, -7 // 2 produce -4.
Los paréntesis permiten indicar cómo agrupar operaciones:
print(2 + 3 * 4) print((2 + 3) * 4)
Resultado:
14 20
Estas operaciones forman parte de la introducción numérica del lenguaje.
6. Números con decimales mediante float
Utilizamos float para representar cantidades como distancias, mediciones y resultados de muchos cálculos:
distancia_km = 4.5 tiempo_min = 18.5 tasa_aprendizaje = 0.01
En el código se utiliza punto decimal:
distancia_km = 4.5
Escribir 4,5 tiene otro significado en Python.
También podemos utilizar notación científica:
tasa_aprendizaje = 1e-3 print(tasa_aprendizaje)
Resultado:
0.001
1e-3 representa uno multiplicado por diez elevado a menos tres.
Por qué algunos resultados tienen decimales inesperados
Prueba:
print(0.1 + 0.2)
Resultado habitual:
0.30000000000000004
Los valores float utilizan una representación binaria de precisión finita. Muchos decimales se almacenan como aproximaciones y las operaciones pueden mostrar pequeñas diferencias.
Podemos controlar la presentación:
resultado = 0.1 + 0.2
print(f"{resultado:.2f}")
Resultado:
0.30
El formato cambia cómo mostramos el número. Para comparar resultados aproximados estudiaremos herramientas como math.isclose(). Cuando necesitemos aritmética decimal específica, conoceremos Decimal.
7. Texto con str
Una cadena de texto se escribe entre comillas:
nombre_modelo = "modelo_entregas" idioma = 'español'
Puedes utilizar comillas simples o dobles, cerrando con el mismo tipo con el que abriste.
Los números entre comillas son texto:
cantidad = 25 cantidad_texto = "25" print(type(cantidad)) print(type(cantidad_texto))
Resultado:
<class 'int'> <class 'str'>
Unir cadenas
El operador + permite concatenar texto:
nombre = "Ana" saludo = "Hola, " + nombre print(saludo)
Resultado:
Hola, Ana
La operación depende de los tipos:
print(10 + 5)
print("10" + "5")
Resultado:
15 105
También podemos contar elementos de una cadena con len():
palabra = "datos" print(len(palabra))
Resultado:
5
Las cadenas permiten muchas más operaciones, como seleccionar partes y sustituir texto. Las iremos incorporando durante las prácticas.
8. Valores lógicos con bool
Un booleano representa uno de estos dos valores:
True False
Se escriben con mayúscula inicial:
modelo_entrenado = False datos_disponibles = True
Una comparación también produce un booleano:
numero_ejemplos = 120 hay_suficientes_ejemplos = numero_ejemplos >= 100 print(hay_suficientes_ejemplos)
Resultado:
True
Los operadores de comparación más habituales son:
| Operador | Significado |
|---|---|
| == | Igual a. |
| != | Distinto de. |
| > | Mayor que. |
| < | Menor que. |
| >= | Mayor o igual que. |
| <= | Menor o igual que. |
Conviene distinguir asignación y comparación:
numero_ejemplos = 120 print(numero_ejemplos == 100)
Resultado:
False
La primera línea asigna. La segunda comprueba.
Podemos combinar condiciones con and, or y not. Las desarrollaremos al estudiar decisiones:
datos_disponibles = True modelo_entrenado = False print(datos_disponibles and modelo_entrenado) print(datos_disponibles or modelo_entrenado) print(not modelo_entrenado)
Resultado:
False True True
9. Representar ausencia de valor con None
None permite indicar que todavía no disponemos de un valor o que una operación no tiene un resultado significativo:
prediccion = None print(prediccion)
Resultado:
None
Es diferente de cero, de una cadena vacía y del texto «None».
Podemos comprobarlo con is None:
prediccion = None print(prediccion is None)
Resultado:
True
Esto permite representar estados como «predicción pendiente» sin confundirlos con una predicción cuyo resultado sea cero.
10. Convertir entre tipos de datos
Las conversiones más habituales utilizan int(), float(), str() y bool():
numero_entero = int("25")
numero_decimal = float("4.5")
texto = str(120)
print(numero_entero + 5)
print(numero_decimal * 2)
print("Ejemplos: " + texto)
Resultado:
30 9.0 Ejemplos: 120
La conversión debe ser compatible con el contenido:
int("veinticinco")
Esta instrucción produce ValueError.
También ocurre con:
int("4.5")
El texto representa un decimal. Podemos convertirlo mediante float(«4.5»).
Convertir un float a int
print(int(4.9)) print(int(-4.9))
Resultado:
4 -4
La conversión descarta la parte fraccionaria hacia cero. Es un comportamiento diferente de redondear al entero más cercano. Las funciones incorporadas documentan estas conversiones.
Cuidado al convertir texto a bool
Una cadena no vacía se considera verdadera:
print(bool(""))
print(bool("False"))
print(bool("0"))
Resultado:
False True True
bool() evalúa si la cadena está vacía. No interpreta palabras como «False» para obtener su significado.
El cero numérico y None también tienen valor lógico falso. Los números distintos de cero tienen valor lógico verdadero.
11. Pedir información con input
input() muestra un mensaje y recoge una línea escrita por la persona:
nombre = input("¿Cómo te llamas? ")
print("Hola,", nombre)
El resultado de input() es una cadena. Para hacer cálculos debemos convertirla:
edad_texto = input("Introduce tu edad: ")
edad = int(edad_texto)
print("El próximo año tendrás", edad + 1)
Si introduces 20, aparecerá:
El próximo año tendrás 21
En este ejemplo esperamos una entrada que represente un entero. Si introduces una palabra, la conversión produce un error. Aprenderemos a validar entradas y gestionar excepciones en las lecciones correspondientes.
12. Mostrar variables con f-strings
Las f-strings permiten insertar valores dentro de un texto. Escribimos f antes de las comillas y colocamos expresiones entre llaves:
nombre = "Ana"
numero_ejemplos = 120
print(f"{nombre} ha preparado {numero_ejemplos} ejemplos.")
Resultado:
Ana ha preparado 120 ejemplos.
También podemos controlar los decimales:
tiempo_estimado = 18.5
print(f"Tiempo estimado: {tiempo_estimado:.2f} minutos")
Resultado:
Tiempo estimado: 18.50 minutos
:.2f muestra dos posiciones decimales. Estas opciones forman parte del formato de cadenas de Python.
13. Ejemplo completo con variables y tipos de datos en Python
Vamos a utilizar la fórmula de entregas del bloque introductorio:
tiempo estimado = minutos por kilómetro × distancia + tiempo base
En esta práctica fijamos los valores de la fórmula para trabajar con tipos y operaciones.
Crea estimar_entrega.py dentro de leccion-1-2:
# Información de la aplicación.
nombre_aplicacion = "Estimador de entregas"
# Parámetros elegidos para este ejercicio.
minutos_por_km = 3.0
tiempo_base_min = 5.0
# Recogemos texto y lo convertimos a número.
distancia_texto = input(
"Introduce la distancia en km usando punto decimal: "
)
distancia_km = float(distancia_texto)
# Calculamos la estimación.
tiempo_estimado_min = (
minutos_por_km * distancia_km + tiempo_base_min
)
# Una comparación produce un booleano.
distancia_positiva = distancia_km > 0
# Mostramos los resultados.
print(f"Aplicación: {nombre_aplicacion}")
print(f"Distancia: {distancia_km:.2f} km")
print(f"Tiempo estimado: {tiempo_estimado_min:.2f} minutos")
print(f"¿La distancia es positiva? {distancia_positiva}")
Ejecútalo:
python leccion-1-2/estimar_entrega.py
Si introduces 4.5, el resultado será:
Introduce la distancia en km usando punto decimal: 4.5 Aplicación: Estimador de entregas Distancia: 4.50 km Tiempo estimado: 18.50 minutos ¿La distancia es positiva? True
Qué tipo utiliza cada variable
| Variable | Tipo | Función |
|---|---|---|
| nombre_aplicacion | str | Identificar la aplicación. |
| minutos_por_km | float | Representar un parámetro de cálculo. |
| tiempo_base_min | float | Representar el tiempo base. |
| distancia_texto | str | Recibir lo escrito por teclado. |
| distancia_km | float | Utilizar la distancia en operaciones. |
| tiempo_estimado_min | float | Guardar el resultado calculado. |
| distancia_positiva | bool | Guardar el resultado de una comparación. |
La comparación informa sobre la distancia. Para impedir el cálculo cuando sea inválida necesitaremos incorporar decisiones mediante condiciones.
14. Errores frecuentes al utilizar variables
Consultar un nombre antes de asignarlo
print(temperatura)
Si temperatura no está definido, aparece NameError.
Primero debemos asignarle un valor:
temperatura = 22 print(temperatura)
Mezclar números y texto en una suma
print("Ejemplos: " + 120)
Esta expresión produce TypeError.
Podemos utilizar:
print("Ejemplos:", 120)
print(f"Ejemplos: {120}")
Confundir mayúsculas y minúsculas
nombre = "Ana" print(Nombre)
nombre y Nombre son identificadores diferentes. Debemos utilizar el que hemos definido.
Escribir los booleanos entre comillas
modelo_entrenado = "False"
Aquí tenemos texto. Para representar el booleano utilizamos:
modelo_entrenado = False
Olvidar guardar el archivo
La terminal ejecuta el contenido guardado en disco. Guarda los cambios antes de volver a ejecutar el programa.
15. Otros detalles que conviene conocer
Constantes por convención
Solemos escribir en mayúsculas los nombres de valores que pretendemos mantener:
MINUTOS_POR_HORA = 60
Es una convención de lectura. Python permite reasignar ese nombre.
Anotaciones de tipos
Podemos documentar el tipo previsto:
numero_ejemplos: int = 120 distancia_km: float = 4.5 nombre_modelo: str = "entregas"
Las anotaciones ayudan al editor y a los analizadores. Por sí solas no obligan al intérprete a rechazar una asignación de otro tipo.
Inmutabilidad
Los números y las cadenas que hemos utilizado son inmutables. Al hacer:
cantidad = 10 cantidad = cantidad + 1
Calculamos un resultado y vinculamos el nombre a ese resultado. Esta distinción cobrará más importancia al estudiar listas y otros objetos modificables.
Relación entre bool e int
En Python, bool es un subtipo de int. Por eso ciertas operaciones numéricas aceptan booleanos. En nuestros programas utilizaremos nombres y tipos que expresen claramente si estamos contando cantidades o representando condiciones.
Ejercicios de autoevaluación
Ejercicio 1. Identificar tipos
Indica el tipo de cada valor:
250 250.0 "250" True None
Ejercicio 2. Seguir las asignaciones
¿Qué muestra este programa?
cantidad = 10 copia = cantidad cantidad = cantidad + 5 print(cantidad) print(copia)
Ejercicio 3. Convertir texto
Tenemos:
numero_texto = "12"
Escribe el código necesario para obtener el número 15 sumando tres.
Ejercicio 4. Mostrar un resultado
Utiliza:
nombre = "Lucía" porcentaje_aciertos = 92.456
Para mostrar:
Lucía ha obtenido un 92.46 % de aciertos.
Ejercicio 5. Representar un resultado pendiente
¿Qué valor utilizarías para indicar que una predicción todavía no está disponible?
Ejercicio 6. Pedir una distancia
Solicita una distancia por teclado, conviértela a float y calcula el doble.
Soluciones explicadas
Solución 1
| Valor | Tipo |
|---|---|
| 250 | int |
| 250.0 | float |
| «250» | str |
| True | bool |
| None | NoneType |
Solución 2
15 10
La nueva asignación a cantidad no cambia el valor asociado a copia.
Solución 3
numero_texto = "12" numero = int(numero_texto) print(numero + 3)
Solución 4
nombre = "Lucía"
porcentaje_aciertos = 92.456
print(
f"{nombre} ha obtenido un "
f"{porcentaje_aciertos:.2f} % de aciertos."
)
Las dos cadenas contiguas dentro de los paréntesis forman un único texto.
Solución 5
prediccion = None
Solución 6
distancia_texto = input("Distancia en km: ")
distancia_km = float(distancia_texto)
print(f"El doble es {distancia_km * 2:.2f} km")
Introduce el decimal con punto, por ejemplo 3.5.
Preguntas frecuentes sobre variables y tipos de datos en Python
¿Hay que declarar el tipo antes de utilizar una variable?
Puedes empezar asignando un valor. Python conoce el tipo del objeto durante la ejecución. Las anotaciones permiten expresar adicionalmente el tipo previsto.
¿Por qué el mismo símbolo puede hacer operaciones distintas?
Los tipos determinan qué operaciones admiten. Por ejemplo, + suma números y concatena cadenas.
¿Puedo utilizar nombres en español?
Sí. En este curso utilizamos nombres descriptivos en español, con guiones bajos para separar palabras.
¿Cuál es la diferencia entre cero y None?
Cero es un valor numérico. None permite representar ausencia de valor. Un resultado cero puede ser perfectamente válido.
¿Es suficiente con estos tipos para trabajar en IA?
Son la base. Después utilizaremos colecciones, matrices y tensores para representar conjuntos de datos y realizar operaciones numéricas.
Documentación de referencia
- Introducción a Python y operaciones básicas.
- Tipos incorporados de Python.
- Funciones incorporadas.
- Entrada, salida y formato de texto.
- Representación de números de coma flotante.
Continúa el curso
Has completado la lección 1.2, la segunda de las diez lecciones del bloque 1: Python para inteligencia artificial.
| Navegación | Contenido |
|---|---|
| Anterior | Lección 1.1 — Preparar el entorno de Python para inteligencia artificial. |
| Siguiente | Lección 1.3 — Listas, tuplas, diccionarios y conjuntos en Python. |
En la siguiente lección agruparemos varios valores para representar colecciones de ejemplos, características y resultados.
