Entrada y salida en Python: print() e input() en la práctica

print() muestra valores en el Serial, el canal de texto que el programa usa para hablar con quien lo ejecuta. input() hace lo contrario: detiene el programa, espera que la persona escriba una línea y pulse Enter, y devuelve lo que se escribió. Hay una regla que conviene guardar desde ya: input() devuelve siempre texto, aunque la persona escriba solo números.

Los dos comandos forman la frontera del programa con el mundo. Todo lo que un programa recibe entra por alguna puerta de entrada, y todo lo que produce sale por alguna puerta de salida. Vimos en el artículo Qué es un algoritmo y cómo ejecuta Python tu programa que todo algoritmo tiene una salida. Aquí aprendes a controlar esa salida y a abrir la puerta de entrada, de modo que el mismo programa sirva para valores distintos sin tener que reescribirse.

El problema: el programa que solo sabe una respuesta

Un programa que calcula el doble de 21 tiene el 21 escrito dentro del código. Funciona, pero solo resuelve ese problema. Para calcular el doble de otro número, alguien tiene que abrir el archivo, encontrar el 21, cambiar el valor y ejecutar de nuevo. Con la entrada de datos, el programa pregunta, recibe la respuesta y calcula con ella. El código no cambia y la respuesta cambia en cada ejecución.

Lo mismo vale para la salida. Un programa que calcula el vuelto de una compra pero no muestra nada es inútil para quien lo usa, y uno que muestra 14.0 suelto, sin decir qué es, obliga a la persona a adivinar. Armar un mensaje claro es parte del trabajo, y print() tiene recursos para eso que la mayoría de los principiantes solo descubre después de meses.

print(): mostrar valores

El uso más simple es pasar un valor entre paréntesis. El texto va entre comillas, y los números y las variables van sin comillas. Para mostrar varios valores en la misma línea, sepáralos con comas: print() pone un espacio entre ellos.

print("a", "b", "c")
print("a", "b", "c", sep="-")
print("cargando", end="")
print("...")
print()
print("fin")

Ejecuta el ejemplo y compara cada línea de código con la salida. La primera muestra a b c. La segunda usa el parámetro sep para cambiar el espacio por un guion. La tercera usa end para no saltar de línea al final, y por eso la cuarta continúa en la misma línea y la pantalla muestra cargando.... El print() sin nada dentro solo salta una línea, y así se deja una línea en blanco en la salida.

sep (de separador) y end (de final) son parámetros con nombre, que se escriben siempre después de los valores. Los valores por defecto son un espacio y una nueva línea. Cambiar el end es útil cuando quieres escribir una pregunta y dejar el cursor en la misma línea, o armar una línea de salida por pedazos dentro de un bucle, tema del módulo de repetición.

Comillas, comillas dentro de comillas y caracteres especiales

El texto puede ir entre comillas dobles o comillas simples, da igual, siempre que la apertura y el cierre sean iguales. Eso resuelve el problema del texto que contiene comillas: si la frase tiene comillas dobles, envuelve todo en comillas simples, y viceversa. Cuando aparecen las dos, la barra invertida \ avisa de que el carácter siguiente es parte del texto.

print("Ella dijo: \"hola\"")
print('comillas "dobles" dentro')
print("línea 1\nlínea 2")
print("columna\tcolumna")

El \n es un salto de línea dentro del texto y el \t es una tabulación, un espacio ancho que alinea columnas. Existen porque el teclado no tiene una tecla para escribir "salta una línea aquí" en medio de una frase.

Tres maneras de armar un mensaje

Para juntar texto y variables en una sola frase, Python ofrece caminos distintos. Cada uno tiene su lugar.

nome = "Ana"
idade = 17
print("Nombre:", nome, "Edad:", idade)
print("Nombre: " + nome + ", Edad: " + str(idade))
print(f"{nome} tiene {idade} años")
preco = 3.5
print(f"Precio: R$ {preco:.2f}")

La primera forma usa comas y deja que print() convierta cada valor solo. Es la más fácil y sirve para casi todo al comienzo. La segunda usa el + para pegar trozos de texto, y exige que cada trozo ya sea texto: por eso la edad pasa por str(). La tercera es la f-string, un texto con una f antes de las comillas en el que lo que esté entre llaves se sustituye por el valor de la variable. Deja la frase legible, casi como si estuviera escrita a mano.

Fíjate en la última línea. El trozo :.2f dentro de las llaves manda mostrar el número con dos decimales, y por eso 3.5 aparece como 3.50. Es el formato correcto para dinero, y lo vas a usar muchas veces.

input(): leer lo que la persona escribe

Cuando Python llega a una línea con input(), el programa se detiene ahí. Ninguna línea siguiente se ejecuta hasta que la persona escriba algo y pulse Enter. El texto entre paréntesis, llamado prompt, se muestra antes de la espera para decir qué se espera que escriba.

nome = input("¿Cómo te llamas? ")
print("Hola,", nome)
print("Hola, " + nome + "!")

Si alguien escribe Ana, el Serial queda así:

¿Cómo te llamas? Ana
Hola, Ana
Hola, Ana!

Este ejemplo no tiene el botón "Abrir en el simulador" porque depende de una respuesta tuya. Copia el código al editor de PyPlaca, haz clic en Ejecutar y escribe en el campo Entrada que está debajo de la pestaña Serial. Lo que escribes aparece junto al prompt, como en una terminal de verdad.

En cada paso, el programa queda congelado durante la espera y retoma exactamente desde el punto en que se detuvo. En la placa real, la entrada viene por la terminal serial del computador, conectado por el cable USB, y funciona de la misma manera. Un programa con input() ejecutándose en una ESP32 sin ningún computador conectado se quedaría esperando para siempre, porque no hay ningún teclado conectado a ella. En proyectos de verdad, quienes hacen el papel de la entrada son los botones y los sensores, y esa es la razón de que input() sea más una herramienta de aprendizaje y de prueba que de producto final. La ruta de entradas digitales muestra cómo leer un botón.

El prompt y el espacio al final

El prompt tiene que terminar con un espacio, o el texto escrito se pega a él. Con input("Nombre:"), la salida queda Nombre:Ana, sin separación. Es un detalle de acabado y no rompe nada, pero deja el programa con aspecto descuidado. Escribe input("Nombre: "), con el espacio dentro de las comillas.

También existe input() sin ningún prompt. Funciona, pero la persona se queda mirando una pantalla en blanco sin saber que el programa espera algo. Cuando no haya prompt, usa un print() antes para explicarlo.

Lo que devuelve input() es siempre texto

Este es el punto que más derriba a quien está empezando. Si la persona escribe 5, input() no devuelve el número 5. Devuelve el texto "5", un carácter entre comillas, que el computador trata como cualquier otra palabra. Los textos y los números responden de maneras distintas a las mismas cuentas.

Con texto, el + junta trozos y el * repite. Con número, hacen la cuenta. El código de abajo muestra la diferencia con valores fijos, sin necesidad de escribir nada:

a = "5"
b = "3"
print(a + b)
print(a * 3)
print(int(a) + int(b))
print(type(a), type(int(a)))

La salida muestra 53, después 555, después 8, y por último <class 'str'> <class 'int'>. La función type() revela el tipo de un valor, y es la primera herramienta para desconfiar cuando una cuenta da un resultado extraño.

La conversión que resuelve el problema es int(), que transforma un texto de dígitos en número entero, y float(), que hace lo mismo para números con parte decimal. Normalmente aplicas la conversión en la misma línea en que lees el dato:

a = int(input("a: "))
b = int(input("b: "))
print(a + b)

Con las entradas 5 y 3, el Serial muestra a: 5, b: 3 y 8. La función input() queda por dentro, devuelve el texto, y int() por fuera lo transforma en número antes de guardarlo en la variable. El artículo sobre conversión de tipos, más adelante en la serie, trata las reglas de estas funciones con más calma.

Una diferencia con el Python del computador aparece cuando la conversión falla. Para int("abc"), MicroPython escribe ValueError: invalid syntax for integer with base 10. El Python de un computador común escribe invalid literal for int() with base 10: 'abc', y muestra el texto que causó el problema. MicroPython no muestra ese texto. La causa es la misma en los dos casos: el texto no tiene la forma de un número.

Errores comunes de quien está empezando

Los escenarios de abajo son los que más suelen aparecer en las primeras clases de laboratorio. En casi todos, el programa parece estar bien para quien lo escribió.

La suma que da 53

El alumno pide dos números, suma y ve 53. Comprueba la cuenta de cabeza, mira el código, ve que usó el + y concluye que el computador se equivocó. En realidad el computador hizo exactamente lo que se le pidió: juntó dos textos. El error es traicionero porque no genera ningún mensaje, y el programa termina como si todo estuviera bien. Cuando el resultado de una suma parezca "pegado", piensa en type() y en int().

La nota con coma

El alumno escribe 7,5, que es como aparece la nota en el boletín, y el programa se rompe con ValueError: invalid syntax for number. La forma de escribir números en Python usa el punto como separador decimal, y la coma no la reconoce float(). Existen dos salidas: pedir que la persona escriba con punto, o cambiar la coma antes de convertir.

texto = input("Nota: ")
nota = float(texto.replace(",", "."))
print(nota)
print(nota * 2)

Con la entrada 7,5, el Serial muestra Nota: 7,5, 7.5 y 15.0. El método replace() cambia todos los trozos de texto iguales al primer argumento por el segundo, y quien lo llama es el propio texto, antes de que float() reciba el resultado.

Un caso parecido es escribir 7.5 cuando el programa convierte con int(). int() solo acepta dígitos enteros, y int("7.5") da el mismo ValueError. Si el valor puede tener decimales, usa float().

El Enter sin escribir nada

El alumno pulsa Enter para "ver qué pasa" y el programa se cae. Cuando la persona no escribe nada, input() devuelve un texto vacío, "". int("") no tiene ningún dígito que convertir y da ValueError, con el mismo mensaje del caso de las letras. El programa solo va a estar a prueba de este problema cuando aprendas a tratar errores, en el último módulo de la serie, pero ya vale la pena probar con el campo vacío para ver cómo se comporta tu código.

Número pegado con texto

Es común escribir print("Total: " + total) cuando total es un número. Python protesta, en la línea del print, con TypeError: unsupported types for __add__: 'str', 'float'. El + entre texto y número no sabe qué hacer. Hay tres salidas, y todas funcionan: convertir con str(total), usar la coma (print("Total:", total)) o usar una f-string (print(f"Total: {total}")). En la práctica, las tres muestran Total: 14.0 para el mismo valor.

El nombre entre comillas que no es variable

Otro escenario clásico: el alumno escribe print("Hola, nome") y el programa muestra Hola, nome, literalmente, en lugar del nombre escrito. Las comillas dicen "esto es texto, cópialo como está", así que la palabra nome dentro de ellas es solo una palabra. El error se vuelve el opuesto cuando faltan las comillas: print(Ana) busca una variable llamada Ana y termina en NameError. La regla es simple: el texto va entre comillas, la variable va sin ellas.

El print sin paréntesis

Videos y apuntes antiguos de Python enseñaban print "hola", que era la sintaxis de la versión 2 del lenguaje. Quien copia de ese material recibe SyntaxError: invalid syntax, y no se ejecuta ninguna línea del programa, como vimos en el artículo anterior. En la versión actual, print es una función como las demás y necesita paréntesis.

Ejercicio: dividir la cuenta del restaurante

Escribe un programa que pregunte el nombre de quien está pagando, el valor total de la cuenta y el número de personas, y muestre cuánto paga cada uno, con dos decimales. Piensa primero en los pasos en español: tres entradas, una división, una salida.

Una respuesta posible:

nome = input("Nombre: ")
conta = float(input("Valor de la cuenta: "))
pessoas = int(input("Personas: "))
cada = conta / pessoas
print(f"{nome}, cada uno paga R$ {cada:.2f}")

Con las entradas Maria, 90 y 4, el Serial muestra:

Nombre: Maria
Valor de la cuenta: 90
Personas: 4
Maria, cada uno paga R$ 22.50

La cuenta puede tener centavos, por eso usa float(). El número de personas es siempre entero, por eso usa int(). Si escribieras print("Sin formatear:", cada), la salida sería 22.5, sin el cero final, y la f-string con :.2f es lo que garantiza 22.50.

Para que el resultado salga con coma, como se escribe en muchos países, cambia el punto después de formatear: f"{cada:.2f}".replace(".", ",") produce 22,50. Prueba también a cambiar el programa para mostrar la cuenta total en el mismo texto, y después piensa qué ocurre si alguien escribe 0 personas. La respuesta para ese último caso llega cuando lleguemos a las decisiones, con un if que protege la división.

Preguntas frecuentes

¿Puedo pedir un número y usarlo ya como número?

No directamente. input() entrega texto, y la conversión con int() o float() es un paso explícito que escribes tú. La forma más común es envolver el input() con la conversión en la misma línea, como en int(input("Edad: ")).

¿Qué ocurre si escribo espacios antes o después del texto?

input() guarda los espacios, porque forman parte de lo que se escribió. Si la persona escribe Ana , la variable recibe esos mismos espacios. El método strip() quita los que sobran en las puntas, y input().strip() es un hábito útil para nombres y códigos.

¿Se puede usar input() sin el campo de entrada de PyPlaca?

Se puede, en cualquier entorno de Python. En el computador, input() lee del teclado por la terminal. En la ESP32, MicroPython lee del puerto serial USB, el mismo por donde sale el print(), y por eso una terminal serial conectada a la placa también funciona. La ficha de la ESP32 DevKit V1 muestra la placa que reproduce el simulador.

¿print() e input() son las únicas formas de entrada y salida?

Son las más simples. En un programa para la ESP32, la salida puede ser también un LED, una pantalla o un mensaje por la red, y la entrada puede ser un botón, un sensor o un mensaje recibido. La lógica es la misma: recibir, procesar y mostrar.

Para continuar

La ruta Lógica con Python tiene desafíos que usan exactamente lo visto aquí. El Eco del nombre es el más corto, solo leer y mostrar. El Información doble pide dos valores en la misma salida, y el Doble de un número exige la conversión con int(). Para practicar mensajes armados, prueba el Saludo personalizado.

El próximo tema de la serie son las variables y los tipos de datos: int, float, str y bool, y qué acepta cada uno. Para ver print() trabajando junto con el hardware, el artículo Primeros pasos con MicroPython en la ESP32 usa el Serial para comprobar un LED que parpadea.