Funciones

Semestre 02, 2026

El código repetido

A medida que un programa crece, aparecen bloques de código que se repiten.
Copiar y pegar el mismo cálculo en varios lugares parece rápido al principio.
Con el tiempo, esa duplicación se vuelve el punto más frágil del programa.

Tres áreas en tres lugares

Un programa calcula el área de un rectángulo en tres puntos distintos.


area1 = base1 * altura1
print("Área:", area1)

area2 = base2 * altura2
print("Área:", area2)

area3 = base3 * altura3
print("Área:", area3)

Consecuencias de duplicar

Si la fórmula cambia, hay que cambiarla en tres lugares.

Si hay un error, hay que corregirlo en tres lugares.

El programa se vuelve difícil de leer.

Cada cambio arriesga dejar una copia desactualizada.

La solución

Idea central

Escribir el código una sola vez y reutilizarlo cuantas veces sea necesario.

Eso es exactamente lo que hacen las funciones.

Funciones

Definición

Una función es un bloque de código con nombre que realiza una tarea específica. Se define una vez y se puede usar múltiples veces.

El nombre permite invocar todo ese bloque con una sola línea.

Funciones que ya se conocen


print("Hola")
input("Escribe algo: ")
int("42")
float("3.14")

Lo importante

Todas son funciones que Python ya trae incorporadas. Se usan escribiendo su nombre seguido de paréntesis.

Funciones propias

Además de las incorporadas, el programador puede crear las suyas.

Decide cómo se llama la función.

Decide qué tarea realiza.

Decide qué datos recibe.

Decide qué resultado entrega.

Definir una función

Para crear una función se usa la palabra clave def.


def nombre_funcion():
    # bloque de código

Partes de la definición

1La palabra def

Indica que se está definiendo una función.

2El nombre y los paréntesis

Identifican la función y anuncian los datos que recibirá.

3Los dos puntos y la indentación

Abren el bloque y marcan qué líneas pertenecen a la función.

Una función que saluda


def saludar():
    print("¡Hola, bienvenido!")

Atención

Esto define la función, pero no la ejecuta. El código de adentro no corre todavía.

Llamar a una función

Para ejecutarla se escribe su nombre seguido de paréntesis.


def saludar():
    print("¡Hola, bienvenido!")

saludar()

Salida

¡Hola, bienvenido!

Llamar varias veces


saludar()
saludar()
saludar()


¡Hola, bienvenido!
¡Hola, bienvenido!
¡Hola, bienvenido!

Lo importante

El mismo código se ejecutó tres veces sin haberlo escrito tres veces.

Flujo de una llamada

1El programa llega a la llamada

La ejecución se detiene en esa línea.

2El control salta a la función

Se ejecutan sus líneas de arriba hacia abajo.

3El control regresa

El programa continúa en la línea siguiente a la llamada.

Parámetros

Definición

Un parámetro es una variable que la función recibe cuando se llama. Permite que la función trabaje con datos distintos cada vez.


def nombre_funcion(parametro):
    # usar parametro aquí

Un saludo personalizado


def saludar(nombre):
    print("¡Hola,", nombre, "!")

saludar("María")
saludar("Carlos")


def saludar(nombre):
    print("¡Hola,", nombre, "!")

saludar("María")
saludar("Carlos")

def saludar(nombre):

La palabra dentro de los paréntesis es el parámetro. Anuncia que la función necesita un dato para poder trabajar.


def saludar(nombre):
    print("¡Hola,", nombre, "!")

saludar("María")
saludar("Carlos")

print("¡Hola,", nombre + "!")

Dentro de la función, el parámetro se usa como cualquier otra variable. Su valor cambia en cada llamada.


def saludar(nombre):
    print("¡Hola,", nombre, "!")

saludar("María")
saludar("Carlos")

saludar("María")

El valor entre paréntesis es el argumento. Al llamar la función, el parámetro toma ese valor y la salida es ¡Hola, María!


def saludar(nombre):
    print("¡Hola,", nombre, "!")

saludar("María")
saludar("Carlos")

saludar("Carlos")

Cada llamada pasa un argumento distinto y produce un resultado distinto, con una sola definición escrita.

Parámetro y argumento

Término	Dónde aparece	Ejemplo
Parámetro	En la definición de la función	def saludar(nombre):
Argumento	En la llamada a la función	saludar("María")

Forma de recordarlo

El parámetro es el espacio vacío y el argumento es lo que se coloca en ese espacio.

Múltiples parámetros

Una función puede recibir más de un parámetro, separados por comas.


def sumar(a, b):
    resultado = a + b
    print("La suma es:", resultado)

sumar(3, 5)
sumar(10, 20)

Salida del programa


La suma es: 8
La suma es: 30

Cada argumento llena el parámetro que le corresponde.

La misma definición sirve para cualquier par de números.

El orden de los argumentos


def presentar(nombre, edad):
    print("Nombre:", nombre)
    print("Edad:", edad)

presentar("Luis", 20)

Advertencia

Los argumentos se asignan en el mismo orden en que se declararon los parámetros. Al escribir presentar(20, "Luis") los valores quedan invertidos y el programa imprime datos sin sentido.

La instrucción return

Definición

return devuelve un valor al lugar donde se llamó la función. Ese valor puede guardarse en una variable y usarse después.

Hasta ahora las funciones solo imprimían resultados en pantalla.

Imprimir frente a devolver

Solo imprime


def sumar(a, b):
    print(a + b)

sumar(3, 5)

Devuelve el valor


def sumar(a, b):
    return a + b

resultado = sumar(3, 5)

Diferencia

La primera versión muestra el 8 y lo pierde. La segunda lo entrega al programa, que puede guardarlo, operarlo o imprimirlo cuando convenga.

Comparación de las dos formas

Característica	print dentro	return
Guardar el resultado	No	Sí
Usarlo en otra operación	No	Sí
Decidir después si se imprime	No	Sí
Reutilizar la función en otro programa	Difícil	Directo

Área de un rectángulo


def calcular_area(base, altura):
    return base * altura

area = calcular_area(5, 3)
print("El área es:", area)
print("El doble del área es:", area * 2)


def calcular_area(base, altura):
    return base * altura

area = calcular_area(5, 3)
print("El área es:", area)
print("El doble del área es:", area * 2)

def calcular_area(base, altura):

La función recibe dos parámetros. El nombre describe la tarea, así que al leer la llamada se entiende qué hace sin revisar su interior.


def calcular_area(base, altura):
    return base * altura

area = calcular_area(5, 3)
print("El área es:", area)
print("El doble del área es:", area * 2)

return base * altura

La fórmula vive en un solo lugar. El resultado no se imprime, se entrega a quien hizo la llamada.


def calcular_area(base, altura):
    return base * altura

area = calcular_area(5, 3)
print("El área es:", area)
print("El doble del área es:", area * 2)

area = calcular_area(5, 3)

La llamada se comporta como un valor. Python ejecuta la función, obtiene 15 y lo guarda en la variable.


def calcular_area(base, altura):
    return base * altura

area = calcular_area(5, 3)
print("El área es:", area)
print("El doble del área es:", area * 2)

print("El área es:", area)
print("El doble del área es:", area * 2)

El valor devuelto se usa las veces que haga falta. Aquí se imprime y luego se multiplica, algo imposible si la función solo hubiera impreso.

return termina la función

Cuando Python encuentra un return, la función termina de inmediato.


def verificar(numero):
    if numero < 0:
        return "El número es negativo"
    return "El número es positivo o cero"

print(verificar(-5))
print(verificar(10))

Recorrido del ejemplo

Con un número negativo, el primer return termina la función y devuelve su mensaje.
El segundo return solo se alcanza cuando el número no es negativo.
Ninguna línea posterior a un return ejecutado llega a correr.
Una función puede tener varios return, pero solo uno se ejecuta en cada llamada.

Áreas sin duplicar la fórmula


def area_rectangulo(base, altura):
    return base * altura

a1 = area_rectangulo(5, 3)
a2 = area_rectangulo(8, 2)
a3 = area_rectangulo(10, 4)

print("Área 1:", a1)
print("Área 2:", a2)
print("Área 3:", a3)

El problema inicial resuelto

La fórmula aparece una sola vez en el programa.

Un cambio de fórmula se hace en una sola línea.

El nombre de la función explica el cálculo al leerlo.

Un error corregido queda corregido en todas las llamadas.

Calculadora


def sumar(a, b):
    return a + b

def restar(a, b):
    return a - b

def multiplicar(a, b):
    return a * b

x = float(input("Primer número: "))
y = float(input("Segundo número: "))

print("Suma:", sumar(x, y))
print("Resta:", restar(x, y))
print("Multiplicación:", multiplicar(x, y))

Ventaja del diseño

Cada operación vive en su propia función.
Agregar una división nueva no obliga a tocar el resto del programa.
El bloque final se lee casi como una descripción de lo que hace el programa.

Una función con ciclo adentro


def tabla_multiplicar(numero):
    for i in range(1, 11):
        print(numero, "x", i, "=", numero * i)

tabla_multiplicar(3)
tabla_multiplicar(7)

Lo importante

Una función puede contener cualquier estructura vista hasta ahora, como if, while o for.

Funciones que usan otras funciones

Dentro de una función se puede llamar a otra ya definida.


def sumar(a, b):
    return a + b

def promedio(a, b):
    return sumar(a, b) / 2

print(promedio(8, 6))

Construcción por capas

Cada función resuelve una parte pequeña del problema.
Una función de nivel superior combina las anteriores.
El programa crece sin que ninguna función se vuelva enorme.
Así se construyen los programas grandes, capa sobre capa.

Variables locales

Definición

Una variable creada dentro de una función solo existe dentro de ella. Fuera de la función no se puede usar.


def calcular():
    resultado = 100
    print("Dentro:", resultado)

calcular()
print("Fuera:", resultado)   # error

Razón de este comportamiento

Cada función tiene su propio espacio de variables.

Dos funciones distintas no se interfieren entre sí.

Los nombres pueden repetirse sin provocar conflictos.

Para sacar un dato de la función se usa return.

Llamar antes de definir


saludar()

def saludar():
    print("Hola")

Consecuencia

Python lee el archivo de arriba hacia abajo, así que en esa línea la función todavía no existe y el programa falla.

Olvidar los paréntesis


saludar    # no ejecuta nada
saludar()  # ejecuta la función

Consecuencia

Sin paréntesis solo se menciona la función. No hay mensaje de error, el programa simplemente no hace nada.

Número incorrecto de argumentos


def sumar(a, b):
    return a + b

sumar(5)         # falta un argumento
sumar(5, 3, 2)   # sobra un argumento

Regla

La cantidad de argumentos debe coincidir con la cantidad de parámetros declarados.

Olvidar el return


def multiplicar(a, b):
    a * b

resultado = multiplicar(3, 4)
print(resultado)   # None

Consecuencia

La multiplicación se calcula y se descarta. Toda función sin return devuelve None de forma automática.

Confundir imprimir con devolver


def mostrar_doble(x):
    print(x * 2)

resultado = mostrar_doble(5)
print(resultado)   # None

Consecuencia

print muestra el valor en pantalla pero no lo devuelve, así que la variable termina valiendo None. Es el error más frecuente del tema.

Buenas prácticas

Usar nombres descriptivos, como calcular_promedio en lugar de f.

Una función hace una sola cosa y la hace bien.

Devolver el resultado con return en lugar de imprimirlo adentro.

Mantener las funciones cortas, por debajo de veinte líneas.

Organización del programa

Todas las definiciones van al inicio del archivo.
El código que llama a las funciones va después.
Una función larga casi siempre puede dividirse en dos más pequeñas.

Documentar la función

La primera línea del bloque puede ser un texto que explique la tarea.


def calcular_area(base, altura):
    """Devuelve el área de un rectángulo."""
    return base * altura

Ventaja

Quien lea el programa entiende la función sin analizar su contenido.

Tres preguntas antes de escribir la función

1¿Qué tarea resuelve?

2¿Qué datos necesita recibir?

3¿Qué valor debe devolver?

Las respuestas definen el nombre, los parámetros y el return.