1.2 · Variables y tipos¶

Objetivos. Al terminar este capítulo podrás: distinguir los tipos básicos de Python (int, float, str, bool), consultar el tipo de un valor, convertir entre tipos de forma segura y tratar el valor None sin confundirlo con False, 0 o una cadena vacía.

Evidencia de logro. Un script que recibe una cantidad como texto, la convierte a número, distingue el caso «sin dato» (None) y muestra el resultado junto con su tipo.

Contexto y motivación¶

Python tiene un tipado dinámico y fuerte. Esto significa que una variable puede referirse a valores de tipos distintos durante la ejecución, pero los valores sí tienen tipo y Python no los convierte automáticamente. Muchos errores habituales al empezar ("1" + 2, int("3.5")) aparecen por no tener en cuenta esta diferencia.

Vocabulario¶

Prerrequisitos¶

Haber completado 1.1 Introducción y entorno: saber ejecutar un script con uv run python y usar print() para mostrar un valor. Todo lo demás se explica aquí.

1. Variables: poner nombre a un valor¶

Una variable es un nombre que se refiere a un valor. Se crea con una asignación: el nombre a la izquierda, el signo = y el valor a la derecha.

precio = 20            # crea la variable precio con el valor 20
unidades = 3
total = precio * unidades
print(total)

precio = 25            # reasignar: precio pasa a valer 25
print(precio)
print(total)           # total NO cambia: se calculó con el valor anterior

Salida esperada:

60
25
60

Tres ideas que conviene fijar desde el principio:

• En Python, = no significa «es igual a» como en matemáticas: significa «guarda el valor de la derecha con el nombre de la izquierda». Para comparar se usa ==, que verás en 1.3.
• Primero se calcula la parte derecha y después se asigna. Por eso total = precio * unidades guarda un número (60), no la fórmula: si luego cambias precio, total no se recalcula solo.
• Si usas una variable que no has creado, Python se detiene con NameError.

print(descuento)   # nunca se ha asignado

Salida esperada (error):

NameError: name 'descuento' is not defined

Cómo nombrar variables. Los nombres pueden llevar letras, números y _, pero no pueden empezar por un número ni contener espacios. Python distingue mayúsculas de minúsculas (precio y Precio son variables distintas) y no permite usar palabras reservadas del lenguaje como if, for o class. La convención de Python es escribir los nombres en minúsculas y separar las palabras con _ (snake_case): precio_total, numero_de_clientes. En este curso usamos nombres descriptivos en español y evitamos las tildes y la ñ en los nombres, aunque Python las admite.

2. Los tipos básicos¶

print(type(42))      # <class 'int'>
print(type(3.14))    # <class 'float'>
print(type("hola"))  # <class 'str'>
print(type(True))    # <class 'bool'>
print(type(None))    # <class 'NoneType'>

Salida esperada:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>

type(valor) devuelve la clase del valor. Los cuatro tipos que usarás más:

Para comprobar si un valor es de un tipo concreto se usa isinstance(valor, tipo), que devuelve True o False:

print(isinstance(42, int))       # True
print(isinstance("42", int))     # False: es texto, aunque parezca un número

Salida esperada:

True
False

Un detalle que sorprende: bool es una subclase de int, así que isinstance(True, int) también da True (y True + True da 2). Es solo una curiosidad del lenguaje; no lo aproveches en tus programas.

3. Dinámico… pero fuerte¶

x = 5
print(x, type(x))    # 5 <class 'int'>

x = "cinco"          # la misma variable ahora guarda texto
print(x, type(x))    # cinco <class 'str'>

Salida esperada:

5 <class 'int'>
cinco <class 'str'>

La variable x cambió de tipo sin problema: eso es el tipado dinámico. Pero Python no convierte solo:

"1" + 2   # TypeError: can only concatenate str (not "int") to str

Salida esperada (error):

TypeError: can only concatenate str (not "int") to str

Ese TypeError es el tipado fuerte: si quieres sumar, convierte antes (int("1") + 2 → 3).

4. Conversiones de tipos¶

print(int("42"))          # texto -> entero
print(float("3.5"))       # texto -> decimal
print(str(123))           # número -> texto
print(int(float("3.5")))  # decimal -> entero (en dos pasos)
print(bool(""))           # cadena vacía -> False
print(bool("False"))      # ¡texto no vacío -> True!
print(bool(None))         # None -> False

Salida esperada:

42
3.5
123
3
False
True
False

Esto importa en cuanto un programa lee datos del exterior. La función input("texto") muestra el texto, espera a que la persona escriba algo y pulse Intro, y devuelve lo escrito siempre como str, aunque sean cifras:

edad_texto = "20"            # lo que devolvería input() si alguien escribe 20
edad = int(edad_texto)       # conversión explícita a entero
print(edad + 1)

Salida esperada:

21

Por eso leer un número con input() y convertirlo con int() o float() es una de las operaciones más habituales al empezar. Si la conversión no es posible, Python avisa con un error:

int("3.5")   # int() no acepta texto con decimales

Salida esperada (error):

ValueError: invalid literal for int() with base 10: '3.5'

Tres detalles que conviene tener presentes:

• int("3.5") falla (ValueError): int() solo entiende enteros; convierte antes a float (int(float("3.5")) → 3). Ojo: int() trunca (quita los decimales), no redondea: int(3.9) es 3.
• bool("False") es True: cualquier texto no vacío cuenta como verdadero.
• bool(None) es False, pero None no es False (son objetos distintos; lo verás en el siguiente punto).

5. Mostrar valores: las f-strings¶

Para imprimir una variable dentro de un texto, la forma moderna es una f-string: se escribe f delante de las comillas y la variable va entre llaves.

nombre = "Ana"
edad = 20

print(f"{nombre} tiene {edad} años")

Salida esperada:

Ana tiene 20 años

Sin f-strings habría que concatenar con + y acordarse de convertir:

print(nombre + " tiene " + str(edad) + " años")   # la forma antigua

Las dos producen lo mismo. La f-string es más legible y es la que se usa en todo el curso. El capítulo 1.9 · Cadenas explica las opciones de formato (decimales, alineación), que aquí no hacen falta.

6. None: «no hay valor»¶

None es el único valor del tipo NoneType y significa «aquí no hay valor», no «cero» ni «cadena vacía». Aparece cuando todavía no tienes el dato:

respuesta = input("¿Cómo te llamas? ")   # el usuario pulsa Enter y no escribe
print(respuesta == "")                   # True: es una cadena vacía

nombre = None                             # todavía no lo sé
print(nombre)                             # None
print(nombre is None)                     # True
print(nombre == "")                       # False: None no es ""

Salida esperada:

True
None
True
False

Regla práctica: comprueba la ausencia con is None, no con ==. Y distingue dos preguntas que se confunden:

• None == "" → False (son valores distintos).
• bool(None) → False (en un if, None se comporta como falso).

Por eso if nombre is None: pregunta «¿no tengo el dato?», mientras que if not nombre: pregunta «¿es un valor vacío o falso?», que también incluye 0, "" y []. Son preguntas distintas: elige la que necesites.

entrada = input("¿Cómo te llamas? ")
nombre = None if entrada == "" else entrada

Errores frecuentes¶

• Usar una variable antes de asignarla (NameError), a menudo por una errata en el nombre: Precio y precio son distintas.
• Confundir = (asignar) con == (comparar).
• "1" + 2 o 1 + "2": mezclar tipos sin convertir.
• int("3.5"): esperar que int() acepte decimales.
• Creer que el texto "False" es falso: bool("False") es True.
• Comprobar None con == "" o == False: usa is None.
• Esperar que input() devuelva None cuando el usuario no escribe nada: devuelve "", y hay que convertirla.

Práctica de transferencia¶

Escribe un script 02_variables_tipos.py con un apartado «Conversiones» que:

1. Pida una cantidad con input() (la recibirás como str).
2. Si el usuario no escribe nada, guarde None en lugar de la cadena vacía y muestre "Sin dato".
3. Si hay dato, lo convierta a float y muestre el doble y su tipo con una f-string.

Pista: la misma forma del recuadro anterior (A if condición else B) sirve para convertir solo cuando hay dato, None if entrada == "" else float(entrada), y para elegir el mensaje, "Sin dato" if cantidad is None else f"...". En 1.4 verás cómo escribir estas decisiones con if en varias líneas.

Qué debes comprobar: ejecútalo tres veces, escribiendo 4, 2.5 y nada. Anota qué ocurre si escribes hola y relaciónalo con el ValueError de la sección 4.

Producto evaluable¶

El mismo 02_variables_tipos.py, con comentarios que expliquen cada conversión y por qué se usa is None en lugar de == "", y al final un comentario con las salidas de tus tres ejecuciones y su interpretación. Este cuaderno se amplía en 1.3 · Operadores y expresiones.

Resumen¶

Siguiente paso¶

Continúa con 1.3 · Operadores y expresiones, que trabaja las operaciones que puedes hacer con estos valores.