Funciones en Python — 3 programas que demuestran su poder real
Las funciones en Python práctica real es lo que toca ahora. En el artículo anterior vimos la teoría. Ahora construimos tres programas desde cero en VS Code donde las funciones no son opcionales, son la razón por la que el código funciona bien. Empezamos comparando el mismo programa sin funciones y con funciones para que veas la diferencia con tus propios ojos.
Crea una carpeta llamada practica_funciones y un archivo separado para cada programa. No olvides que a tu disposición tienes pythontutor.com para entender como funciona el código
Tabla de Contenidos
Funciones en Python práctica — Programa 1: Conversor de temperaturas modular
Crea el archivo conversor_temperaturas.py. Primero la versión sin funciones para ver el problema:
# SIN FUNCIONES — código repetitivo y difícil de mantener
print("=== CONVERSOR DE TEMPERATURAS ===\n")
print("1. Celsius a Fahrenheit")
print("2. Celsius a Kelvin")
print("3. Fahrenheit a Celsius")
opcion = int(input("\nElige opción: "))
temp = float(input("Temperatura: "))
if opcion == 1:
resultado = (temp * 9/5) + 32
print(f"{temp}°C = {round(resultado, 2)}°F")
elif opcion == 2:
resultado = temp + 273.15
print(f"{temp}°C = {round(resultado, 2)}K")
elif opcion == 3:
resultado = (temp - 32) * 5/9
print(f"{temp}°F = {round(resultado, 2)}°C")
Funciona, pero si quieres usar alguna de estas conversiones en otro programa tienes que copiar el código. Ahora la versión con funciones:
# CON FUNCIONES — modular y reutilizable
def celsius_a_fahrenheit(celsius):
return round((celsius * 9/5) + 32, 2)
def celsius_a_kelvin(celsius):
return round(celsius + 273.15, 2)
def fahrenheit_a_celsius(fahrenheit):
return round((fahrenheit - 32) * 5/9, 2)
def kelvin_a_celsius(kelvin):
return round(kelvin - 273.15, 2)
def mostrar_menu():
print("=== CONVERSOR DE TEMPERATURAS ===\n")
print("1. Celsius → Fahrenheit")
print("2. Celsius → Kelvin")
print("3. Fahrenheit → Celsius")
print("4. Kelvin → Celsius")
print("5. Conversión completa desde Celsius")
def conversion_completa(celsius):
print(f"\n{celsius}°C equivale a:")
print(f" → {celsius_a_fahrenheit(celsius)}°F")
print(f" → {celsius_a_kelvin(celsius)}K")
print(f" → {celsius_a_celsius_via_fahrenheit(celsius)}°C (via °F, debe ser igual)")
def celsius_a_celsius_via_fahrenheit(celsius):
return fahrenheit_a_celsius(celsius_a_fahrenheit(celsius))
# Programa principal
mostrar_menu()
opcion = int(input("\nElige opción (1-5): "))
temp = float(input("Temperatura: "))
if opcion == 1:
print(f"\n{temp}°C = {celsius_a_fahrenheit(temp)}°F")
elif opcion == 2:
print(f"\n{temp}°C = {celsius_a_kelvin(temp)}K")
elif opcion == 3:
print(f"\n{temp}°F = {fahrenheit_a_celsius(temp)}°C")
elif opcion == 4:
print(f"\n{temp}K = {kelvin_a_celsius(temp)}°C")
elif opcion == 5:
conversion_completa(temp)
else:
print("Opción no válida")
Resultado con opción 5 y temperatura 100:
=== CONVERSOR DE TEMPERATURAS === 1. Celsius → Fahrenheit 2. Celsius → Kelvin 3. Fahrenheit → Celsius 4. Kelvin → Celsius 5. Conversión completa desde Celsius Elige opción (1-5): 5 Temperatura: 100 100°C equivale a: → 212.0°F → 373.15K → 100.0°C (via °F, debe ser igual)
Fíjate en celsius_a_celsius_via_fahrenheit, una función que llama a dos funciones para comprobar que las conversiones son coherentes. Eso es composición de funciones en acción.
Funciones en Python práctica — Programa 2: Mini calculadora modular
Crea el archivo calculadora_modular.py. Este programa muestra cómo separar responsabilidades — cada función hace exactamente una cosa:
# Funciones de cálculo — solo calculan, no imprimen nada
def sumar(a, b):
return a + b
def restar(a, b):
return a - b
def multiplicar(a, b):
return a * b
def dividir(a, b):
if b == 0:
return None # None indica error
return round(a / b, 4)
def potencia(a, b):
return a ** b
def modulo(a, b):
if b == 0:
return None
return a % b
# Funciones de interfaz — solo gestionan entrada/salida
def mostrar_menu():
print("\n=== CALCULADORA MODULAR ===")
print("1. Suma 2. Resta")
print("3. Multiplicar 4. Dividir")
print("5. Potencia 6. Módulo")
print("0. Salir")
def pedir_numeros():
a = float(input("Primer número: "))
b = float(input("Segundo número: "))
return a, b
def mostrar_resultado(operacion, a, b, resultado):
simbolos = {
"suma": "+", "resta": "-", "multiplicar": "×",
"dividir": "/", "potencia": "^", "modulo": "%"
}
simbolo = simbolos.get(operacion, "?")
if resultado is None:
print("Error: no se puede dividir entre cero")
else:
print(f"\n{a} {simbolo} {b} = {resultado}")
# Función principal — coordina todo
def ejecutar_calculadora():
while True:
mostrar_menu()
opcion = input("\nOpción: ")
if opcion == "0":
print("Hasta luego")
break
a, b = pedir_numeros()
if opcion == "1":
mostrar_resultado("suma", a, b, sumar(a, b))
elif opcion == "2":
mostrar_resultado("resta", a, b, restar(a, b))
elif opcion == "3":
mostrar_resultado("multiplicar", a, b, multiplicar(a, b))
elif opcion == "4":
mostrar_resultado("dividir", a, b, dividir(a, b))
elif opcion == "5":
mostrar_resultado("potencia", a, b, potencia(a, b))
elif opcion == "6":
mostrar_resultado("modulo", a, b, modulo(a, b))
else:
print("Opción no válida")
# Punto de entrada del programa
ejecutar_calculadora()
La separación clave aquí es entre funciones de cálculo y funciones de interfaz. Las funciones de cálculo como sumar() o dividir() nunca hacen print, solo calculan y devuelven. Las funciones de interfaz como mostrar_resultado() se encargan de toda la salida. Esto hace el código mucho más fácil de testear y modificar.
Funciones en Python práctica — Programa 3: Piedra papel tijera con funciones
El más divertido. Crea el archivo piedra_papel_tijera.py. Este programa usa funciones para cada responsabilidad del juego:
import random
# Función para obtener la jugada de la máquina
def jugada_maquina():
opciones = ["piedra", "papel", "tijera"]
return random.choice(opciones)
# Función para determinar el ganador
def determinar_ganador(jugador, maquina):
if jugador == maquina:
return "empate"
gana_jugador = {
"piedra": "tijera",
"papel": "piedra",
"tijera": "papel"
}
if gana_jugador[jugador] == maquina:
return "jugador"
else:
return "maquina"
# Función para validar la jugada del usuario
def pedir_jugada():
opciones_validas = ["piedra", "papel", "tijera"]
jugada = input("Elige (piedra/papel/tijera): ").lower().strip()
while jugada not in opciones_validas:
print(f"Opción no válida. Elige entre: {', '.join(opciones_validas)}")
jugada = input("Elige (piedra/papel/tijera): ").lower().strip()
return jugada
# Función para mostrar el resultado de la ronda
def mostrar_resultado_ronda(jugador, maquina, ganador):
emojis = {"piedra": "🪨", "papel": "📄", "tijera": "✂️"}
print(f"\nTú: {emojis[jugador]} {jugador}")
print(f"Máquina: {emojis[maquina]} {maquina}")
if ganador == "empate":
print("→ ¡Empate!")
elif ganador == "jugador":
print("→ ¡Ganaste esta ronda! 🎉")
else:
print("→ La máquina gana esta ronda 🤖")
# Función para mostrar el marcador
def mostrar_marcador(victorias, derrotas, empates):
total = victorias + derrotas + empates
print(f"\n--- Marcador ({total} rondas) ---")
print(f"Tú: {victorias} | Máquina: {derrotas} | Empates: {empates}")
# Función principal del juego
def jugar():
print("=== PIEDRA PAPEL TIJERA ===\n")
victorias = derrotas = empates = 0
rondas = int(input("¿Cuántas rondas quieres jugar? "))
for ronda in range(1, rondas + 1):
print(f"\n--- Ronda {ronda}/{rondas} ---")
jugador = pedir_jugada()
maquina = jugada_maquina()
ganador = determinar_ganador(jugador, maquina)
mostrar_resultado_ronda(jugador, maquina, ganador)
if ganador == "jugador":
victorias += 1
elif ganador == "maquina":
derrotas += 1
else:
empates += 1
mostrar_marcador(victorias, derrotas, empates)
# Resultado final
print("\n=== RESULTADO FINAL ===")
if victorias > derrotas:
print(f"¡Ganaste el juego! {victorias}-{derrotas} 🏆")
elif derrotas > victorias:
print(f"La máquina gana el juego. {victorias}-{derrotas} 🤖")
else:
print(f"¡Empate perfecto! {victorias}-{derrotas} 🤝")
# Punto de entrada
jugar()
Resultado de una partida de 3 rondas:
=== PIEDRA PAPEL TIJERA === ¿Cuántas rondas quieres jugar? 3 --- Ronda 1/3 --- Elige (piedra/papel/tijera): piedra Tú: 🪨 piedra Máquina: ✂️ tijera → ¡Ganaste esta ronda! 🎉 --- Marcador (1 rondas) --- Tú: 1 | Máquina: 0 | Empates: 0 ...
Este programa tiene 7 funciones y cada una hace exactamente una cosa. Si quisieras cambiar las reglas del juego, solo tocas determinar_ganador. Si quisieras cambiar los emojis, solo tocas mostrar_resultado_ronda. Eso es código mantenible.
El patrón que debes llevarte
De los tres programas hay un patrón que se repite y que debes interiorizar:
# PATRÓN: separar cálculo de presentación
# 1. Funciones que calculan — devuelven valores, no imprimen
def calcular_algo(datos):
# lógica aquí
return resultado
# 2. Funciones que validan — comprueban entrada, devuelven valor limpio
def pedir_dato_valido(mensaje):
dato = input(mensaje)
while not es_valido(dato):
dato = input(mensaje)
return dato
# 3. Funciones que muestran — reciben datos, imprimen, no calculan
def mostrar_resultado(datos, resultado):
print(f"...")
# 4. Función principal — coordina todo
def main():
datos = pedir_dato_valido("...")
resultado = calcular_algo(datos)
mostrar_resultado(datos, resultado)
main()
Este patrón es la base de la programación modular y lo verás en todos los proyectos de GCID a partir de ahora.
Resumen y siguiente paso
En este artículo practicaste las funciones en Python con tres programas reales. Viste la diferencia directa entre código sin funciones y con funciones, la separación entre cálculo e interfaz, la composición de funciones llamándose entre sí, y el patrón de función principal que coordina todo.
En el siguiente artículo encontrarás ejercicios propuestos para practicar por tu cuenta.
Python functions — 3 programs that show their real power
In the previous article we covered Python functions theory. Now let’s build three programs where functions aren’t optional, they’re the reason the code works well. We start by comparing the same program without and with functions so you can see the difference with your own eyes.
Program 1 — Modular temperature converter
Without functions first:
# WITHOUT FUNCTIONS — repetitive, hard to maintain
print("=== TEMPERATURE CONVERTER ===\n")
print("1. Celsius to Fahrenheit")
print("2. Celsius to Kelvin")
print("3. Fahrenheit to Celsius")
option = int(input("\nChoose option: "))
temp = float(input("Temperature: "))
if option == 1:
result = (temp * 9/5) + 32
print(f"{temp}°C = {round(result, 2)}°F")
elif option == 2:
result = temp + 273.15
print(f"{temp}°C = {round(result, 2)}K")
elif option == 3:
result = (temp - 32) * 5/9
print(f"{temp}°F = {round(result, 2)}°C")
With functions:
# WITH FUNCTIONS — modular and reusable
def celsius_to_fahrenheit(celsius):
return round((celsius * 9/5) + 32, 2)
def celsius_to_kelvin(celsius):
return round(celsius + 273.15, 2)
def fahrenheit_to_celsius(fahrenheit):
return round((fahrenheit - 32) * 5/9, 2)
def kelvin_to_celsius(kelvin):
return round(kelvin - 273.15, 2)
def show_menu():
print("=== TEMPERATURE CONVERTER ===\n")
print("1. Celsius → Fahrenheit")
print("2. Celsius → Kelvin")
print("3. Fahrenheit → Celsius")
print("4. Kelvin → Celsius")
print("5. Full conversion from Celsius")
def full_conversion(celsius):
print(f"\n{celsius}°C equals:")
print(f" → {celsius_to_fahrenheit(celsius)}°F")
print(f" → {celsius_to_kelvin(celsius)}K")
show_menu()
option = int(input("\nChoose option (1-5): "))
temp = float(input("Temperature: "))
if option == 1:
print(f"\n{temp}°C = {celsius_to_fahrenheit(temp)}°F")
elif option == 2:
print(f"\n{temp}°C = {celsius_to_kelvin(temp)}K")
elif option == 3:
print(f"\n{temp}°F = {fahrenheit_to_celsius(temp)}°C")
elif option == 4:
print(f"\n{temp}K = {kelvin_to_celsius(temp)}°C")
elif option == 5:
full_conversion(temp)
Program 2 — Modular calculator
# Calculation functions — only calculate, never print
def add(a, b): return a + b
def subtract(a, b): return a - b
def multiply(a, b): return a * b
def divide(a, b): return None if b == 0 else round(a / b, 4)
def power(a, b): return a ** b
def modulo(a, b): return None if b == 0 else a % b
# Interface functions — only handle input/output
def show_menu():
print("\n=== MODULAR CALCULATOR ===")
print("1. Add 2. Subtract")
print("3. Multiply 4. Divide")
print("5. Power 6. Modulo")
print("0. Exit")
def get_numbers():
a = float(input("First number: "))
b = float(input("Second number: "))
return a, b
def show_result(operation, a, b, result):
symbols = {"add":"+","subtract":"-","multiply":"×",
"divide":"/","power":"^","modulo":"%"}
symbol = symbols.get(operation, "?")
if result is None:
print("Error: cannot divide by zero")
else:
print(f"\n{a} {symbol} {b} = {result}")
def run_calculator():
operations = {"1":("add",add),"2":("subtract",subtract),
"3":("multiply",multiply),"4":("divide",divide),
"5":("power",power),"6":("modulo",modulo)}
while True:
show_menu()
option = input("\nOption: ")
if option == "0":
print("Goodbye")
break
if option in operations:
a, b = get_numbers()
name, func = operations[option]
show_result(name, a, b, func(a, b))
else:
print("Invalid option")
run_calculator()
Program 3 — Rock paper scissors with functions
import random
def machine_choice():
return random.choice(["rock", "paper", "scissors"])
def determine_winner(player, machine):
if player == machine:
return "draw"
beats = {"rock": "scissors", "paper": "rock", "scissors": "paper"}
return "player" if beats[player] == machine else "machine"
def get_player_choice():
valid = ["rock", "paper", "scissors"]
choice = input("Choose (rock/paper/scissors): ").lower().strip()
while choice not in valid:
print(f"Invalid. Choose: {', '.join(valid)}")
choice = input("Choose (rock/paper/scissors): ").lower().strip()
return choice
def show_round_result(player, machine, winner):
emojis = {"rock": "🪨", "paper": "📄", "scissors": "✂️"}
print(f"\nYou: {emojis[player]} {player}")
print(f"Machine: {emojis[machine]} {machine}")
messages = {"draw": "→ Draw!", "player": "→ You win! 🎉",
"machine": "→ Machine wins! 🤖"}
print(messages[winner])
def show_score(wins, losses, draws):
total = wins + losses + draws
print(f"\n--- Score ({total} rounds) ---")
print(f"You: {wins} | Machine: {losses} | Draws: {draws}")
def play():
print("=== ROCK PAPER SCISSORS ===\n")
wins = losses = draws = 0
rounds = int(input("How many rounds? "))
for round_num in range(1, rounds + 1):
print(f"\n--- Round {round_num}/{rounds} ---")
player = get_player_choice()
machine = machine_choice()
winner = determine_winner(player, machine)
show_round_result(player, machine, winner)
if winner == "player": wins += 1
elif winner == "machine": losses += 1
else: draws += 1
show_score(wins, losses, draws)
print("\n=== FINAL RESULT ===")
if wins > losses: print(f"You win! {wins}-{losses} 🏆")
elif losses > wins: print(f"Machine wins. {wins}-{losses} 🤖")
else: print(f"Perfect draw! {wins}-{losses} 🤝")
play()
The pattern to take away
# PATTERN: separate calculation from presentation
# 1. Calculation functions — return values, never print
def calculate(data):
return result
# 2. Validation functions — check input, return clean value
def ask_valid_input(message):
data = input(message)
while not is_valid(data):
data = input(message)
return data
# 3. Display functions — receive data, print, don't calculate
def show_result(data, result):
print(f"...")
# 4. Main function — coordinates everything
def main():
data = ask_valid_input("...")
result = calculate(data)
show_result(data, result)
main()
