Variables de salida en Python

La función print() de Python es la herramienta principal para mostrar el valor de las variables en la pantalla. Este capítulo explica todas las formas prácticas de mostrar variables — desde el valor más simple hasta string formateados con múltiples variables — y cubre los errores comunes que suelen cometer los principiantes.

Este capítulo cubre:

• Imprimir una sola variable
• Imprimir múltiples variables con comas (argumentos sep y end)
• Concatenar string con +
• Usar f-strings para incrustar variables en línea
• Convertir valores que no son string con str()

Capítulos relacionados: Variables de Python · Nombres de variables · Format Strings · Variables globales

Imprimir una sola variable

Pasa cualquier variable directamente a print() y Python la convierte a texto de forma automática.

Imprimir una variable de tipo string

Hello, World!

Esto funciona con todos los tipos integrados — números, booleanos, listas, entre otros:

count = 42
price = 9.99
active = True

print(count)
print(price)
print(active)

42
9.99
True

Imprimir múltiples variables

Usando comas

Pasa varias variables a print() separadas por comas. Python inserta un espacio entre ellas por defecto.

name = "Alice"
age = 30
print("Name:", name)
print("Age:", age)

Name: Alice
Age: 30

Puedes pasar tantos argumentos como quieras en una sola llamada a print():

x = 10
y = 20
z = 30
print(x, y, z)

10 20 30

El argumento sep

Usa sep para cambiar el carácter que separa los valores (el valor predeterminado es un espacio):

first = "John"
last = "Doe"
print(first, last, sep="-")

John-Doe

El argumento end

Por defecto, print() añade un salto de línea \n al final. Puedes cambiarlo con end:

print("Loading", end="...")
print("done")

Loading...done

Ambos valores aparecen en la misma línea porque el primer print() no emite un salto de línea.

Concatenación de string con +

Une variables de tipo string con el operador + para construir una sola string de salida:

name = "Alice"
greeting = "Hello, " + name + "!"
print(greeting)

Hello, Alice!

Importante: El operador + solo funciona entre string. Si intentas concatenar una string con un número obtendrás un TypeError:

age = 30
# print("Age: " + age)  # TypeError: can only concatenate str (not "int") to str
print("Age: " + str(age))  # correct — convert age to string first

Age: 30

Usa str() para convertir cualquier valor que no sea string antes de usar +. Cuando usas una coma en lugar de +, Python gestiona la conversión automáticamente, pero pierdes el control sobre el espaciado y el formato.

Mostrar variables con f-strings

Las f-strings (Python 3.6+) son la forma más legible de incrustar variables dentro de texto. Añade el prefijo f a la string y coloca nombres de variables (o cualquier expresión) dentro de {}:

name = "Alice"
score = 95.5
print(f"{name} scored {score:.1f} points")

Alice scored 95.5 points

El :.1f dentro de las llaves es un especificador de formato que redondea el número flotante a un decimal. Las f-strings pueden evaluar cualquier expresión de Python, no solo nombres de variables:

x = 5
y = 2
print(f"{x} + {y} = {x + y}")
print(f"{x} / {y} = {x / y:.2f}")

5 + 2 = 7
5 / 2 = 2.50

Para una guía completa sobre especificadores de formato (alineación, relleno, bases numéricas), consulta Format Strings.

Resultados aritméticos como salida

Python evalúa las expresiones aritméticas antes de imprimirlas. Puedes pasar la expresión directamente a print() sin almacenarla primero en una variable:

Generar salidas basadas en cálculos en Python

7
3
10
2.5
1

Ten en cuenta que dividir dos enteros en Python 3 siempre devuelve un float (2.5, no 2). Usa // para la división entera (por piso):

print(5 // 2)  # 2
print(5 % 2)   # 1

2
1

Comprobar el tipo de una variable

Usa type() dentro de print() para inspeccionar qué tipo contiene una variable — útil para depurar:

x = 42
name = "Alice"
pi = 3.14

print(type(x))
print(type(name))
print(type(pi))

<class 'int'>
<class 'str'>
<class 'float'>

Coma vs. + — Comparación rápida

Para la mayoría del código nuevo, prefiere las f-strings. Son las más legibles y las menos propensas a errores.

Práctica