Entrada y Salida en Python

Entrada y Salida en Python

La interacción con el usuario es una parte fundamental de muchos programas. Python proporciona varias formas de obtener datos del usuario (entrada) y mostrar información (salida). En esta lección, exploraremos las principales herramientas y técnicas para manejar la entrada y salida en Python.

Salida de datos con print()

La función print() es la forma más básica y común de mostrar información en Python:

print("Hola, mundo!")  # Muestra: Hola, mundo!

Imprimiendo múltiples valores

Puedes imprimir múltiples valores separándolos por comas:

nombre = "Ana"
edad = 25
print("Nombre:", nombre, "Edad:", edad)  # Muestra: Nombre: Ana Edad: 25

Por defecto, print() separa los valores con un espacio y añade un salto de línea al final.

Personalizando la salida con parámetros

La función print() acepta varios parámetros para personalizar la salida:

# Cambiar el separador entre valores
print("Manzana", "Banana", "Cereza", sep=", ")  # Muestra: Manzana, Banana, Cereza

# Cambiar el carácter final (por defecto es \n, salto de línea)
print("Hola", end=" ")
print("Mundo")  # Muestra: Hola Mundo

# Redirigir la salida a un archivo
with open("salida.txt", "w") as archivo:
    print("Este texto se guarda en un archivo", file=archivo)

Formateo de cadenas

Python ofrece varias formas de formatear cadenas para crear salidas más elaboradas:

1. Método format()

nombre = "Carlos"
edad = 30
print("Hola, me llamo {} y tengo {} años.".format(nombre, edad))
# Muestra: Hola, me llamo Carlos y tengo 30 años.

# Con posiciones específicas
print("Tengo {1} años y me llamo {0}.".format(nombre, edad))
# Muestra: Tengo 30 años y me llamo Carlos.

# Con nombres
print("Hola, {nombre} tienes {edad} años.".format(nombre="Ana", edad=25))
# Muestra: Hola, Ana tienes 25 años.

2. f-strings (Python 3.6+)

Las f-strings son una forma moderna y concisa de formatear cadenas:

nombre = "Carlos"
edad = 30
print(f"Hola, me llamo {nombre} y tengo {edad} años.")
# Muestra: Hola, me llamo Carlos y tengo 30 años.

# Puedes incluir expresiones dentro de las llaves
print(f"El año que viene tendré {edad + 1} años.")
# Muestra: El año que viene tendré 31 años.

# Formateo de números
pi = 3.14159
print(f"El valor de pi es aproximadamente {pi:.2f}")
# Muestra: El valor de pi es aproximadamente 3.14

3. Operador %

Una forma más antigua pero aún válida:

nombre = "Carlos"
edad = 30
print("Hola, me llamo %s y tengo %d años." % (nombre, edad))
# Muestra: Hola, me llamo Carlos y tengo 30 años.

Formateo avanzado de números

# Formato de enteros
print(f"{42:5d}")  # Entero con ancho mínimo de 5 caracteres
# Muestra: '   42' (con espacios a la izquierda)

# Formato de flotantes
print(f"{3.14159:8.2f}")  # Flotante con ancho 8 y 2 decimales
# Muestra: '    3.14'

# Porcentajes
print(f"{0.25:.1%}")  # Formato de porcentaje con 1 decimal
# Muestra: '25.0%'

# Notación científica
print(f"{1000000:.2e}")  # Notación científica con 2 decimales
# Muestra: '1.00e+06'

Entrada de datos con input()

La función input() permite obtener datos del usuario a través de la consola:

nombre = input("¿Cómo te llamas? ")
print(f"Hola, {nombre}!")

Características importantes de input()

1. Siempre devuelve una cadena de texto (string)
2. El programa se detiene hasta que el usuario presiona Enter
3. Puedes mostrar un mensaje opcional como argumento

Conversión de tipos

Como input() siempre devuelve una cadena, a menudo necesitarás convertir la entrada a otros tipos de datos:

# Convertir a entero
edad_str = input("¿Cuántos años tienes? ")
edad = int(edad_str)
print(f"El próximo año tendrás {edad + 1} años.")

# Convertir a flotante
altura_str = input("¿Cuál es tu altura en metros? ")
altura = float(altura_str)
print(f"Tu altura es {altura * 100:.0f} centímetros.")

# Conversión directa
precio = float(input("Introduce el precio: "))
cantidad = int(input("Introduce la cantidad: "))
total = precio * cantidad
print(f"Total a pagar: ${total:.2f}")

Manejo de errores en la entrada

Es importante manejar posibles errores cuando convertimos la entrada del usuario:

try:
    edad = int(input("¿Cuántos años tienes? "))
    print(f"El próximo año tendrás {edad + 1} años.")
except ValueError:
    print("Error: Debes introducir un número entero.")

Entrada y salida de archivos

Python facilita la lectura y escritura de archivos, lo que es esencial para muchas aplicaciones:

Escritura de archivos

# Modo básico
archivo = open("datos.txt", "w")  # 'w' para escribir (sobreescribe si existe)
archivo.write("Hola, mundo!\n")
archivo.write("Esta es la segunda línea.\n")
archivo.close()  # Importante cerrar el archivo

# Usando with (recomendado)
with open("datos.txt", "w") as archivo:
    archivo.write("Hola, mundo!\n")
    archivo.write("Esta es la segunda línea.\n")
# El archivo se cierra automáticamente al salir del bloque with

# Añadir al final de un archivo
with open("datos.txt", "a") as archivo:  # 'a' para append (añadir)
    archivo.write("Esta línea se añade al final.\n")

Lectura de archivos

# Leer todo el contenido de una vez
with open("datos.txt", "r") as archivo:  # 'r' para lectura
    contenido = archivo.read()
    print(contenido)

# Leer línea por línea
with open("datos.txt", "r") as archivo:
    for linea in archivo:
        print(linea.strip())  # strip() elimina espacios y saltos de línea

# Leer todas las líneas en una lista
with open("datos.txt", "r") as archivo:
    lineas = archivo.readlines()
    print(f"El archivo tiene {len(lineas)} líneas")
    for linea in lineas:
        print(f"- {linea.strip()}")

Modos de apertura de archivos

• 'r': Lectura (por defecto)
• 'w': Escritura (sobreescribe)
• 'a': Añadir al final
• 'r+': Lectura y escritura
• 'b': Modo binario (añadir a cualquiera de los anteriores, ej: 'rb')

Ejemplos prácticos

Calculadora interactiva

def calculadora():
    print("Calculadora Simple")
    print("------------------")
    
    try:
        num1 = float(input("Ingresa el primer número: "))
        num2 = float(input("Ingresa el segundo número: "))
        
        print("\nOperaciones disponibles:")
        print("1. Suma")
        print("2. Resta")
        print("3. Multiplicación")
        print("4. División")
        
        operacion = input("\nSelecciona una operación (1-4): ")
        
        if operacion == "1":
            resultado = num1 + num2
            print(f"\nResultado: {num1} + {num2} = {resultado}")
        elif operacion == "2":
            resultado = num1 - num2
            print(f"\nResultado: {num1} - {num2} = {resultado}")
        elif operacion == "3":
            resultado = num1 * num2
            print(f"\nResultado: {num1} * {num2} = {resultado}")
        elif operacion == "4":
            if num2 == 0:
                print("\nError: No es posible dividir entre cero.")
            else:
                resultado = num1 / num2
                print(f"\nResultado: {num1} / {num2} = {resultado}")
        else:
            print("\nOperación no válida.")
    
    except ValueError:
        print("\nError: Debes introducir números válidos.")

calculadora()

Agenda de contactos simple

def agenda_contactos():
    agenda = {}
    
    while True:
        print("\nAgenda de Contactos")
        print("------------------")
        print("1. Ver contactos")
        print("2. Añadir contacto")
        print("3. Buscar contacto")
        print("4. Guardar y salir")
        
        opcion = input("\nSelecciona una opción (1-4): ")
        
        if opcion == "1":
            if not agenda:
                print("La agenda está vacía.")
            else:
                print("\nLista de contactos:")
                for nombre, telefono in agenda.items():
                    print(f"- {nombre}: {telefono}")
        
        elif opcion == "2":
            nombre = input("Nombre: ")
            telefono = input("Teléfono: ")
            agenda[nombre] = telefono
            print(f"Contacto {nombre} añadido correctamente.")
        
        elif opcion == "3":
            buscar = input("Introduce el nombre a buscar: ")
            if buscar in agenda:
                print(f"Teléfono de {buscar}: {agenda[buscar]}")
            else:
                print(f"No se encontró a {buscar} en la agenda.")
        
        elif opcion == "4":
            # Guardar contactos en un archivo
            with open("agenda.txt", "w") as archivo:
                for nombre, telefono in agenda.items():
                    archivo.write(f"{nombre},{telefono}\n")
            print("Agenda guardada. ¡Hasta pronto!")
            break
        
        else:
            print("Opción no válida.")

agenda_contactos()

Registro de temperaturas

def registro_temperaturas():
    print("Registro de Temperaturas Semanales")
    print("---------------------------------")
    
    dias = ["Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"]
    temperaturas = []
    
    # Entrada de datos
    for dia in dias:
        try:
            temp = float(input(f"Temperatura del {dia} (°C): "))
            temperaturas.append(temp)
        except ValueError:
            print("Error: Introduce un número válido.")
            return
    
    # Procesamiento
    temp_max = max(temperaturas)
    temp_min = min(temperaturas)
    temp_prom = sum(temperaturas) / len(temperaturas)
    
    # Salida de resultados
    print("\nResumen de temperaturas:")
    print(f"Temperatura máxima: {temp_max}°C")
    print(f"Temperatura mínima: {temp_min}°C")
    print(f"Temperatura promedio: {temp_prom:.1f}°C")
    
    # Guardar en archivo
    with open("temperaturas.txt", "w") as archivo:
        archivo.write("Registro de Temperaturas\n")
        archivo.write("-----------------------\n")
        for i, dia in enumerate(dias):
            archivo.write(f"{dia}: {temperaturas[i]}°C\n")
        archivo.write(f"\nMáxima: {temp_max}°C\n")
        archivo.write(f"Mínima: {temp_min}°C\n")
        archivo.write(f"Promedio: {temp_prom:.1f}°C\n")
    
    print("\nDatos guardados en 'temperaturas.txt'")

registro_temperaturas()

Entrada y salida avanzada

Argumentos de línea de comandos

Para programas más avanzados, puedes usar argumentos de línea de comandos:

import sys

# sys.argv es una lista con los argumentos
# sys.argv[0] es el nombre del script

if len(sys.argv) > 1:
    print(f"Hola, {sys.argv[1]}!")
else:
    print("Hola, mundo!")

# Ejecución: python script.py Juan
# Salida: Hola, Juan!

Módulo argparse para argumentos más sofisticados

import argparse

def main():
    parser = argparse.ArgumentParser(description='Ejemplo de argumentos de línea de comandos')
    parser.add_argument('nombre', help='Nombre de la persona a saludar')
    parser.add_argument('--edad', type=int, help='Edad de la persona')
    parser.add_argument('--formal', action='store_true', help='Usar saludo formal')
    
    args = parser.parse_args()
    
    if args.formal:
        saludo = f"Estimado/a {args.nombre}"
    else:
        saludo = f"Hola, {args.nombre}"
    
    if args.edad:
        saludo += f", tienes {args.edad} años"
    
    print(saludo)

if __name__ == "__main__":
    main()

# Ejecución: python script.py Juan --edad 30 --formal
# Salida: Estimado/a Juan, tienes 30 años

Entrada y salida con JSON

Para datos estructurados, JSON es un formato muy útil:

import json

# Datos de ejemplo
datos = {
    "nombre": "Ana",
    "edad": 28,
    "ciudad": "Barcelona",
    "hobbies": ["lectura", "natación", "fotografía"]
}

# Guardar datos en formato JSON
with open("datos.json", "w") as archivo:
    json.dump(datos, archivo, indent=4)
    print("Datos guardados en 'datos.json'")

# Leer datos en formato JSON
with open("datos.json", "r") as archivo:
    datos_leidos = json.load(archivo)
    print("\nDatos leídos:")
    print(f"Nombre: {datos_leidos['nombre']}")
    print(f"Edad: {datos_leidos['edad']}")
    print(f"Ciudad: {datos_leidos['ciudad']}")
    print("Hobbies:")
    for hobby in datos_leidos['hobbies']:
        print(f"- {hobby}")

Mejores prácticas

1. Siempre valida la entrada del usuario: No asumas que el usuario ingresará datos en el formato esperado.
2. Usa bloques with para archivos: Garantiza que los archivos se cierren correctamente, incluso si ocurren errores.
3. Proporciona retroalimentación clara: Informa al usuario qué tipo de entrada se espera y si ha ocurrido algún error.
4. Maneja las excepciones adecuadamente: Captura y maneja los errores que puedan surgir durante la entrada/salida.
5. Separa la lógica de entrada/salida de la lógica de negocio: Esto hace que tu código sea más modular y fácil de mantener.

Ejercicios prácticos

1. Crea un programa que solicite al usuario su nombre, edad y ciudad, y luego muestre un mensaje personalizado.
2. Desarrolla una aplicación de notas que permita al usuario añadir, ver y guardar notas en un archivo.
3. Implementa un programa que lea un archivo CSV con datos de estudiantes (nombre, edad, calificación) y calcule el promedio de las calificaciones.
4. Crea una calculadora de IMC (Índice de Masa Corporal) que solicite al usuario su peso y altura, y guarde un registro de los resultados en un archivo.
5. Desarrolla un conversor de divisas que lea tasas de cambio desde un archivo y permita al usuario convertir entre diferentes monedas.

En la próxima lección, exploraremos los comentarios y la documentación en Python, elementos esenciales para escribir código mantenible y comprensible.