Cerrábamos el módulo 1, en Del problema al algoritmo, con una promesa: que el título, el responsable y la prioridad de una tarea dejarían de estar escritos a mano dentro de un print y pasarían a ser información que el programa maneja. Esta lección cumple esa promesa. La pieza que lo hace posible se llama variable, y es, sin exagerar, el concepto sobre el que se apoya absolutamente todo lo demás del curso.

Tu tareafacil.py actual imprime texto fijo. Si Marta quiere registrar otra tarea, hay que abrir el editor, buscar la línea, cambiar el texto y guardar. Eso no es un programa: es un documento que se ejecuta. Un programa de verdad guarda datos, los consulta, los modifica y calcula con ellos. Para eso necesita sitios donde poner esos datos y nombres con los que referirse a ellos.

En esta lección aprenderás qué es exactamente una variable, cómo se crea con el operador de asignación =, qué nombres puedes ponerle y cuáles conviene ponerle, cuáles son los cinco tipos básicos de dato en Python (int, float, str, bool y None), cómo averiguar el tipo de cualquier valor con type(), y qué significa que Python tenga tipado dinámico. Al final reescribirás tareafacil.py para que la tarea de la Panadería Solé viva en variables.

1. Del texto fijo a los datos con nombre
2. Qué es una variable
3. La asignación: el operador =
4. Reasignación y orden de ejecución
5. Reglas y convenciones para los nombres
6. Comentarios con #
7. Los tipos básicos de Python
8. Inspeccionar el tipo con type()
9. Tipado dinámico: qué significa en la práctica
10. Mutable e inmutable: una primera intuición
11. TareaFácil: la tarea vive en variables
12. Errores comunes y consejos
13. Ejercicios
14. Conclusión

Recuperemos el tareafacil.py con el que cerraste la lección 01-04:

Este programa tiene tres problemas graves, y conviene nombrarlos antes de arreglarlos:

• El dato está atrapado en el texto. «Luis» no es un dato para el programa: es un puñado de letras dentro de una frase más larga. El programa no puede saber quién es el responsable, no puede compararlo con otro nombre, no puede contarlo.
• Repetir un dato obliga a repetirlo literalmente. Si el responsable apareciera en cuatro sitios y la tarea se reasignara a Nuria, habría que cambiar cuatro líneas. Olvidar una es un error garantizado.
• No hay forma de calcular nada. Con texto fijo no se puede decidir si una tarea es urgente, ni contar cuántas hay pendientes, ni nada parecido.

La solución es separar el dato de su presentación. El dato se guarda con un nombre; después se muestra. Así:

Dos líneas, y ya es otro programa. La primera línea guarda el texto "Luis" bajo el nombre responsable. La segunda muestra lo que hay guardado en ese nombre. Si mañana la tarea pasa a Nuria, se cambia una línea y todo lo que use responsable queda actualizado.

Eso es una variable.

Una variable es un nombre que apunta a un valor guardado en la memoria del ordenador.

Conviene detenerse en la palabra apunta, porque es la clave. Mucha gente imagina la variable como una caja que contiene el valor. Es una imagen aceptable al principio, pero la imagen correcta en Python es otra: el valor vive en algún lugar de la memoria, y la variable es una etiqueta pegada a ese valor. La etiqueta no contiene nada; señala.

De ahí salen tres consecuencias prácticas que te ahorrarán confusiones más adelante:

• Un nombre apunta a un solo valor a la vez. Si lo haces apuntar a otro, deja de apuntar al anterior.
• Varios nombres pueden apuntar al mismo valor. No es un caso raro: ocurre continuamente.
• Usar el nombre equivale a usar el valor. Cuando escribes print(responsable), Python sigue la flecha, encuentra "Luis" y trabaja con eso.

Y hay una cuarta consecuencia, más filosófica pero muy útil: el nombre es para ti, no para la máquina. Al ordenador le da igual que la variable se llame responsable o x7. A quien lea el programa dentro de seis meses —probablemente tú— no le dará igual en absoluto.

Crear una variable en Python es tan simple como esto:

La estructura es siempre la misma:

El símbolo = se llama operador de asignación, y funciona de derecha a izquierda: primero se calcula lo que hay a la derecha, y el resultado se asocia al nombre de la izquierda. Es importante interiorizar ese orden desde el principio.

Léelo mentalmente como «pasa a valer» o «apunta a», nunca como «es igual a». Y aquí llegamos a un punto que confunde a casi todo el mundo al empezar.

En matemáticas, x = 5 es una afirmación: declara un hecho que se cumple. En Python, x = 5 es una orden: haz que el nombre x apunte al valor 5.

La diferencia se ve con toda claridad en esta línea, perfectamente válida en Python e imposible en matemáticas:

Matemáticamente, contador = contador + 1 sería absurdo: ningún número es igual a sí mismo más uno. Como orden, es perfectamente sensato:

1. Se evalúa la parte derecha, contador + 1. Python mira cuánto vale contador ahora mismo (0) y suma uno: el resultado es 1.
2. Ese resultado, 1, se asigna al nombre contador, que deja de apuntar al 0 y pasa a apuntar al 1.

Ese último punto es un buen control mental: en Python, a la izquierda del = va siempre un nombre; nunca un valor. Escribir 5 = x produce el error SyntaxError: cannot assign to literal.

Para comparar dos valores y preguntar si son iguales existe otro operador, ==, con dos signos. Lo verás en detalle en Operadores y expresiones. Por ahora quédate con la distinción: un = asigna, dos == comparan.

Una variable puede cambiar de valor tantas veces como quieras. A eso se le llama reasignación, y es de donde viene el nombre «variable»: su valor varía.

Tras la segunda asignación, el nombre estado deja de apuntar a "pendiente" y apunta a "completada". El valor antiguo se pierde: no hay forma de recuperarlo si no lo guardaste en otro sitio.

De aquí sale una regla que gobierna la lectura de cualquier programa: las instrucciones se ejecutan en orden, de arriba abajo, y el valor de una variable en un punto del programa es el que le dio la última asignación anterior a ese punto.

Compruébalo con este ejemplo, que conviene trazar mentalmente antes de leer la respuesta:

Muestra Nuria. La primera línea no «se pierde» ni «entra en conflicto» con la segunda: se ejecuta, y luego la segunda la sustituye. Es exactamente la misma lógica de la prueba de escritorio que practicaste en la lección 01-05, y sigue siendo la mejor herramienta para entender un fragmento de código: apunta en una tabla el valor de cada variable después de cada línea.

Un detalle importante: una variable debe existir antes de usarse. Si intentas mostrar un nombre al que no has asignado nada, Python protesta:

Léelo con calma: «el nombre prioridad no está definido». Casi siempre significa una de dos cosas: o se te ha olvidado la línea de asignación, o la has escrito después de usarla, o hay una errata en el nombre (prioridad frente a prioidad). Los mensajes de error de Python son informativos; cógeles cariño cuanto antes.

Hay dos niveles aquí, y no conviene mezclarlos: las reglas, que si incumples el programa no arranca, y las convenciones, que si incumples el programa funciona pero delatan a un principiante.

Las palabras reservadas son las que Python usa para su propia sintaxis. Hay unas 35: False, None, True, and, as, assert, break, class, continue, def, del, elif, else, except, for, from, global, if, import, in, is, lambda, not, or, pass, raise, return, try, while, with, yield... No hace falta memorizarlas: cualquier editor decente las colorea de forma distinta, y ese cambio de color es la señal de que ese nombre está prohibido.

Técnicamente Python 3 acepta acentos y eñes en los nombres (año = 2026 funciona). No los uses. Complican la escritura, rompen en teclados distintos y ningún proyecto profesional los emplea.

Las convenciones de Python están recogidas en un documento llamado PEP 8, que es la referencia de estilo del lenguaje. Estas son las tres que necesitas ahora:

1. snake_case: minúsculas y guiones bajos. Las palabras se separan con _, todo en minúscula.

2. Nombres con significado. El mejor nombre es el que hace innecesario el comentario que lo explica.

Un buen criterio: si tienes que subir a mirar la asignación para recordar qué guarda una variable, el nombre es malo. Y no temas los nombres largos: tareas_pendientes_de_luis es mejor que tpl. Se escribe una vez y se lee cien.

3. Constantes en MAYÚSCULAS. Cuando un valor no debe cambiar durante la ejecución —una tasa, un límite, un texto fijo—, se nombra en mayúsculas con guiones bajos:

Ojo con un matiz que sorprende a los que vienen de otros lenguajes: Python no impide cambiar una constante. NOMBRE_ESTUDIO = "otra cosa" funcionaría sin protestar. Las mayúsculas son una convención, un aviso a los humanos que leen el código: «esto no se toca». La disciplina la pone el programador, no el lenguaje.

Un comentario es texto que Python ignora por completo al ejecutar. Sirve para explicarle algo a la persona que lea el código.

Se escriben con la almohadilla #. Todo lo que va desde # hasta el final de la línea se ignora:

Hay dos formas de usarlos, ambas visibles arriba: en una línea propia, para explicar el bloque que viene debajo, y al final de una línea de código, para aclarar ese detalle concreto. En este segundo caso, PEP 8 pide dejar al menos dos espacios antes del #.

Un aviso sobre el buen uso, sin extendernos porque la documentación tiene su propia lección en Documentación y comentarios: un comentario debe explicar por qué, no qué. Esto no aporta nada:

Esto sí:

Los comentarios también sirven para desactivar temporalmente una línea mientras pruebas algo, sin borrarla. En la mayoría de editores, Ctrl + / comenta y descomenta la línea donde está el cursor.

Todo valor en Python pertenece a un tipo de dato. El tipo determina qué se puede hacer con ese valor: dos números se pueden restar, dos textos no; un texto se puede poner en mayúsculas, un número no.

Estos son los cinco tipos básicos con los que trabajarás en este módulo:

Vamos uno a uno, porque cada uno tiene su detalle.

Se escriben sin comillas y sin decimales. Pueden ser negativos y no tienen límite práctico de tamaño en Python.

No uses separadores de miles con punto ni con coma: 1.250 no es mil doscientos cincuenta, es el decimal 1,25. Si necesitas legibilidad, Python permite el guion bajo: 1_250_000 es un entero válido y se lee mejor.

Llevan punto decimal, no coma. Este es el error número uno de quien programa en español:

Un aviso que te ahorrará desconcierto más adelante: los float son aproximaciones. El ordenador almacena los decimales en binario y algunos números no tienen representación exacta:

No es un fallo de Python: pasa en casi todos los lenguajes. Para lo que hacemos aquí es irrelevante, pero recuérdalo si algún día programas cálculos con dinero.

Van entre comillas, simples o dobles indistintamente, siempre que abras y cierres con las mismas:

Un texto puede contener espacios, números y símbolos. Y ojo con esto, porque es fuente de confusión constante:

Parecen lo mismo y no lo son. Con 3 se puede hacer aritmética; con "3" no. Esta distinción será el corazón de la lección Conversión de tipos y validación.

También existe la cadena vacía, "": un texto sin ningún carácter. No es lo mismo que None ni que un espacio " ".

Solo tiene dos valores posibles, y se escriben con la primera letra en mayúscula: True y False. Ni true, ni TRUE, ni Verdadero.

Los booleanos son la base de todas las decisiones que tomará el programa a partir del módulo 3. Guardar el estado de una tarea como completada = False es mucho más útil que como estado = "pendiente", porque un booleano se puede evaluar directamente.

None representa que no hay valor. Es un tipo con un único valor posible, y se escribe también con mayúscula inicial.

Es distinto de 0, de "" y de False. 0 es una cantidad, "" es un texto sin caracteres, False es una respuesta negativa; None significa «aquí no hay nada todavía». En TareaFácil lo usaremos, por ejemplo, para una fecha de entrega que aún no se ha fijado: no es una fecha vacía, es que no hay fecha.

Python trae una herramienta para preguntar de qué tipo es un valor: la función type().

Salida:

La palabra class es el vocabulario interno de Python (los tipos son clases, algo que cobrará sentido en el módulo 7); de momento fíjate solo en el nombre entre comillas.

type() es tu mejor aliada cuando algo no funciona como esperas. Compara estos dos casos, aparentemente idénticos:

Al imprimirlos por separado, ambos muestran 3 en pantalla. Pero uno es un número y el otro es texto, y se comportan de forma radicalmente distinta. Cuando un programa haga algo inexplicable con un dato, lo primero es imprimir su type(). Ese reflejo te ahorrará horas.

Una precisión de vocabulario, para hablar con propiedad: type() es una función, y los paréntesis son la forma de «llamarla» pasándole un valor. Ya has usado otra función, print(). Cómo funcionan por dentro y cómo crear las tuyas es el asunto del módulo 4.

En la lección 01-03 vimos que Python tiene tipado dinámico. Ahora podemos ver qué significa eso con código delante.

En un lenguaje de tipado estático como Java o C, al crear una variable declaras su tipo y ese tipo queda fijado para siempre:

En Python no se declara nada. El tipo lo determina el valor asignado, y cambia si asignas otro valor de otro tipo:

Python no protesta en ningún momento. Insistamos en el matiz importante: el tipo pertenece al valor, no al nombre. La variable es una etiqueta, y una etiqueta puede pegarse hoy a un texto y mañana a un número.

Y aquí un consejo que no es opcional: que Python te deje cambiar el tipo de una variable no significa que debas hacerlo. Una variable llamada dias_estimados que unas veces guarda 3 y otras "tres" es una fuente inagotable de errores. La disciplina profesional es clara: un nombre, un propósito, un tipo. Si necesitas otra cosa, crea otra variable.

Hay una distinción que conviene sembrar ya, aunque su alcance completo llegue con las listas del módulo 5.

Algunos valores en Python son inmutables: una vez creados, no se pueden modificar. Los números y las cadenas de texto lo son. Cuando parece que los modificas, en realidad estás creando un valor nuevo y reapuntando la etiqueta.

Mira este ejemplo:

Es tentador pensar que el texto "alta" se ha transformado en "media". No es así. Lo que ha ocurrido es que se ha creado un valor nuevo, "media", y la etiqueta prioridad ha dejado de señalar al primero para señalar al segundo. El texto "alta" no ha cambiado; simplemente ya nadie lo mira.

Se puede comprobar con id(), una función que devuelve un identificador único del valor en memoria. Si el valor fuera el mismo modificado, el identificador se mantendría; si es un valor nuevo, cambia:

(Los números concretos varían en cada ejecución y en cada ordenador; lo único relevante es que son distintos.)

Y ahora la consecuencia práctica, que sí importa desde hoy:

responsable_copia sigue valiendo "Luis". La segunda línea la hizo apuntar al mismo valor que responsable_original, pero la tercera línea reapuntó solo a responsable_original; la otra etiqueta se quedó donde estaba. Con valores inmutables esto funciona siempre de forma intuitiva: reasignar una variable nunca afecta a las demás.

Todos los tipos de esta lección son inmutables, así que de momento vives en el mundo fácil. Guarda la idea: cuando llegues a las listas, donde la copia no se comporta así, sabrás exactamente qué está cambiando y por qué.

Vamos a lo prometido. Reescribimos tareafacil.py para que los cinco datos de la tarea —los cinco que definimos en el requisito R1 de la lección 01-01— dejen de estar escritos dentro de los print y pasen a ser variables.

Abre tu tareafacil.py y sustituye el contenido por esto:

Ejecútalo con python tareafacil.py. Verás la ficha, ahora en dos líneas por dato.

Repasemos las decisiones que se han tomado en ese código, porque ninguna es casual:

• NOMBRE_APP, VERSION y ESTUDIO van en mayúsculas porque son constantes: no cambian durante la ejecución del programa.
• completada es un bool, no el texto "pendiente". Es una elección deliberada: un booleano representa mejor un sí/no y se podrá evaluar directamente cuando lleguen los condicionales. Fíjate además en el nombre: completada se lee como una afirmación que es verdadera o falsa, que es justo como debe leerse un booleano.
• dias_estimados es un int y horas_dedicadas un float. Los días se cuentan enteros; las horas admiten medias.
• fecha_entrega es None, no "". No es una fecha vacía: es que todavía no hay fecha. La diferencia es semántica y es importante.
• Los comentarios explican lo que el nombre no puede decir: los valores admitidos en prioridad, o el porqué del None.

Ahora la mejora de verdad. Cambia estas dos líneas:

Guarda, ejecuta y comprueba que la ficha refleja los cambios. Has modificado dos líneas de datos y no has tocado ni una línea de las que muestran la información. En la versión anterior habrías tenido que editar el texto dentro de los print. Esa separación entre datos y presentación es una de las ideas más rentables de todo el oficio.

Seamos honestos con las limitaciones de esta versión, que son el guion de las tres lecciones siguientes:

Cuatro problemas, cuatro lecciones. Vamos a por ellos por orden.

Confundir = con ==. Uno asigna, dos comparan. Escribir prioridad = "alta" cuando querías preguntar si la prioridad es alta no da error: cambia el valor de la variable silenciosamente. Es de los errores más difíciles de detectar precisamente porque no protesta.

Usar una variable antes de asignarla. NameError: name 'x' is not defined significa siempre lo mismo: ese nombre no existe todavía en ese punto del programa. Comprueba que la asignación está escrita, que está antes y que no hay ninguna errata en el nombre.

Errata en el nombre al reutilizarlo. responsable y responsble son dos variables distintas para Python. La segunda dará NameError, o peor: si por casualidad también existe, tu programa usará el dato equivocado. Deja que el autocompletado del editor escriba los nombres por ti.

Olvidar las comillas en un texto. responsable = Luis (sin comillas) hace que Python busque una variable llamada Luis y falle con NameError. Si es texto, va entre comillas. Siempre.

Escribir decimales con coma. precio = 19,99 no es un decimal. Python interpreta la coma como separador y crea algo que no es un número. En Python los decimales llevan punto.

Escribir true o false en minúscula. En Python son True y False, con mayúscula inicial. NameError: name 'true' is not defined es el aviso.

Poner un número entre comillas sin querer. dias = "3" es texto, no un número. Parece igual al imprimirlo y se comporta de forma completamente distinta. Ante la duda, type().

Nombres de una sola letra. Un x te parecerá clarísimo mientras lo escribes y un jeroglífico tres días después. La única excepción tolerada son los contadores de bucle, que verás en el módulo 3.

Usar palabras reservadas como nombres. Si el editor colorea tu nombre de variable igual que colorea if o for, cámbialo.

Consejo: prueba en el REPL. Antes de escribir algo en el fichero, pruébalo en el intérprete interactivo (python a secas en la terminal, como viste en 01-04). Asigna, imprime, consulta el type(). Es la forma más rápida de convertir una duda en una certeza.

Consejo: nombra primero, programa después. Cuando ataques un problema nuevo, escribe primero la lista de datos que intervienen y ponles nombre. La mitad del diseño de un programa es decidir qué variables existen.

El siguiente programa contiene seis errores. Encuéntralos, explica cada uno y escribe la versión corregida.

a) Indica el tipo de cada valor sin ejecutar nada:

b) Traza este programa en una tabla (una fila por línea, una columna por variable) y di qué imprime:

Escribe un fichero ficha_nuria.py que guarde en variables bien nombradas los datos de esta tarea de Estudio Alba y los muestre por pantalla:

• Título: Cartel para la feria del libro
• Descripción: Formato A2, dos versiones de color
• Responsable: Nuria
• Prioridad: media
• Todavía no está completada
• Se estiman 2 días de trabajo
• Lleva dedicadas 3,5 horas
• La fecha de entrega aún no está acordada
• El cliente de esta tarea no consta todavía

Requisitos: usa el tipo más adecuado para cada dato (no todo str), nombra las variables en snake_case y con significado, incluye una constante en mayúsculas con el nombre del estudio y añade al menos dos comentarios que aporten información real. Termina el programa imprimiendo el type() de tres variables de tipos distintos.

Solución 1.

Los seis errores:

Versión corregida:

Nota: el print original pasaba varios valores separados por comas. Es válido en Python y se estudia en Entrada y salida de datos; aquí lo hemos separado en varios print para no adelantar materia.

Solución 2.

a) Tipos:

Las tres filas interesantes son 12 frente a 12.0, 12 frente a "12" y True frente a "True": parecen lo mismo en pantalla y no lo son.

b) Trazado:

Imprime 10 y luego 5.

La clave está en la línea 4: pendientes recibe el valor que tareas_totales tenía en ese instante (10, porque la línea 3 ya lo había cambiado). No queda «enlazada» a tareas_totales: si después esa variable cambiara, pendientes seguiría valiendo 10. Una asignación copia el valor del momento, no establece una relación permanente.

Solución 3.

Justificación de los tipos elegidos:

• titulo, descripcion, responsable y prioridad son textos: str.
• completada es un sí/no: bool. Es preferible a guardar el texto "pendiente".
• dias_estimados es una cantidad entera: int.
• horas_dedicadas admite medias horas: float, con punto decimal.
• fecha_entrega y cliente no tienen valor todavía: None, no "".

Y la comprobación final imprime <class 'str'>, <class 'int'> y <class 'bool'>.

Has dado el paso que convierte un texto ejecutable en un programa. Ahora sabes que una variable es un nombre que apunta a un valor en memoria; que el = no afirma una igualdad sino que ordena una asignación, evaluando siempre primero la parte derecha; y que reasignar una variable simplemente mueve la etiqueta a otro valor, sin afectar a las demás variables que apuntaran al anterior.

Conoces las reglas de los nombres (letras, dígitos y guion bajo; sin empezar por número; sin palabras reservadas) y, más importante, las convenciones que separan al profesional del aficionado: snake_case, nombres con significado y constantes en MAYÚSCULAS. Dominas los cinco tipos básicos —int, float, str, bool y None—, sabes inspeccionarlos con type() cuando algo no cuadra, entiendes qué implica el tipado dinámico de Python y por qué conviene no abusar de él, y tienes una primera intuición de la inmutabilidad que te será muy útil cuando lleguen las listas.

Y tareafacil.py ya está en su versión 0.2: los cinco datos de la tarea del logotipo de la Panadería Solé viven en variables, y cambiar el responsable es cuestión de editar una línea de datos, no el código que los muestra.

Pero de momento el programa solo guarda información; no hace nada con ella. No sabe decir si la tarea es urgente, ni cuánto falta para la entrega, ni qué porcentaje del encargo lleva hecho Luis. Para eso hacen falta expresiones: combinar variables y valores mediante operadores para producir resultados nuevos. Es exactamente el tema de la siguiente lección, Operadores y expresiones, donde tus variables dejarán de estar quietas y empezarán a calcular.