Parámetros de Función en Python

Introducción

En este laboratorio, exploraremos cómo definir y usar funciones con parámetros en Python. Las funciones se vuelven mucho más potentes cuando pueden aceptar entradas, lo que las hace dinámicas y reutilizables.

Cubriremos varios tipos de parámetros de función, incluidos parámetros posicionales, valores predeterminados (default values), argumentos de palabra clave (keyword arguments) y argumentos de longitud variable (variable-length arguments). A través de ejemplos prácticos, aprenderá a crear funciones flexibles que pueden manejar una variedad de entradas.

Definir Funciones con Parámetros Posicionales

Los parámetros nos permiten pasar datos a una función, haciendo que su comportamiento sea adaptable según la entrada que recibe. Empecemos con el tipo más común: los parámetros posicionales. Los argumentos pasados a una función se asignan a estos parámetros basándose en su orden.

Primero, localice el archivo positional_params.py en el explorador de archivos del lado izquierdo del WebIDE y ábralo.

Ahora, definamos una función llamada hello que acepta un parámetro, name. Agregue el siguiente código al archivo positional_params.py:

def hello(name):
    print(f'Hello, {name}!')

hello('John')
hello('Alice')

En este código, name es un parámetro (parameter), que actúa como un marcador de posición en la definición de la función. Cuando llamamos a la función, como hello('John'), el valor 'John' es un argumento (argument) que se asigna al parámetro name.

Para ejecutar el script, abra una nueva terminal en el WebIDE haciendo clic en Terminal -> New Terminal en el menú superior. Luego, ejecute el siguiente comando:

python3 ~/project/positional_params.py

Verá la siguiente salida, que muestra que la función produjo resultados diferentes para argumentos diferentes:

Hello, John!
Hello, Alice!

Si una función se define con parámetros posicionales, debe proporcionar un argumento correspondiente para cada uno al llamarla. Olvidar hacerlo resultará en un error.

Usar Valores de Parámetros Predeterminados

A menudo es útil proporcionar un valor predeterminado para un parámetro. Si no se proporciona un argumento para ese parámetro durante la llamada a la función, se utiliza el valor predeterminado. Esto hace que el parámetro sea opcional.

Veamos qué sucede cuando llamamos a una función sin un argumento requerido. Abra el archivo default_params.py y agregue el siguiente código:

def hello(name):
    print(f'Hello, {name}!')

hello()

Guarde el archivo y ejecútelo desde la terminal:

python3 ~/project/default_params.py

Esto producirá un TypeError porque la función hello esperaba un argumento pero no recibió ninguno.

Traceback (most recent call last):
  File "/home/labex/project/default_params.py", line 4, in <module>
    hello()
TypeError: hello() missing 1 required positional argument: 'name'

Para solucionar esto, podemos asignar un valor predeterminado al parámetro name. Modifique el archivo default_params.py reemplazando su contenido con el siguiente código:

def hello(name="World"):
    print(f'Hello, {name}!')

hello()
hello("Jobs")

Ahora, ejecute el script nuevamente:

python3 ~/project/default_params.py

La salida será:

Hello, World!
Hello, Jobs!

La primera llamada utiliza el valor predeterminado "World", mientras que la segunda llamada utiliza el argumento proporcionado "Jobs".

Regla Importante: En la definición de una función, todos los parámetros sin valores predeterminados deben aparecer antes que cualquier parámetro con valores predeterminados. Por ejemplo, def func(a, b="default") es correcto, pero def func(a="default", b) causará un SyntaxError.

Pasar Argumentos Usando Palabras Clave (Keywords)

Al llamar a una función, puede nombrar explícitamente los parámetros para los que está proporcionando argumentos. Estos se denominan argumentos de palabra clave (keyword arguments). Su principal ventaja es que el orden no importa, lo que puede hacer que su código sea más legible.

Abra el archivo keyword_args.py y agregue el siguiente código:

def person(name, age):
    print(f"{name} is {age} years old.")

## Llamada con argumentos de palabra clave - el orden no importa
person(name="Zhang San", age=25)
person(age=50, name="Li Si")

Guarde el archivo y ejecútelo desde la terminal:

python3 ~/project/keyword_args.py

Verá que ambas llamadas funcionan correctamente, independientemente del orden de los argumentos:

Zhang San is 25 years old.
Li Si is 50 years old.

También puede mezclar argumentos posicionales y de palabra clave en una sola llamada a función. Sin embargo, debe seguir una regla: todos los argumentos posicionales deben preceder a cualquier argumento de palabra clave.

Ahora, reemplace el contenido de keyword_args.py con lo siguiente para ver esta regla en acción:

def person(name, age):
    print(f"{name} is {age} years old.")

## Esta es una mezcla válida de argumentos posicionales y de palabra clave
person("Wang Wu", age=26)

## Esto causaría un SyntaxError: positional argument follows keyword argument
## person(age=28, "Zhao Liu")

Ejecute el script nuevamente. La llamada válida se ejecutará como se espera.

python3 ~/project/keyword_args.py

Salida esperada:

Wang Wu is 26 years old.

Manejar un Número Variable de Argumentos

Las funciones de Python pueden diseñarse para aceptar un número variable de argumentos. Esto es útil cuando no se sabe de antemano cuántos argumentos se pasarán a la función.

Argumentos Posicionales Variables (*args)

Al colocar un asterisco * antes del nombre de un parámetro, puede recopilar un número arbitrario de argumentos posicionales en una tupla (tuple). El nombre args es una convención, pero puede usar cualquier nombre de parámetro válido.

Argumentos de Palabra Clave Variables (**kwargs)

Al colocar un doble asterisco ** antes del nombre de un parámetro, puede recopilar un número arbitrario de argumentos de palabra clave en un diccionario (dictionary). El nombre kwargs también es una convención.

Combinemos estos conceptos. Abra el archivo variable_args.py y agregue el siguiente código:

## Usando *args para sumar un número variable de valores
def calculate_sum(*numbers):
    print(f"Arguments received as a tuple: {numbers}")
    total = sum(numbers)
    print(f"Sum: {total}\n")

## Usando **kwargs para capturar información adicional del perfil
def person_profile(name, age, **other_info):
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Other Info: {other_info}\n")

## Llamando a las funciones
calculate_sum(1, 2, 3)
calculate_sum(10, 20, 30, 40, 50)

person_profile('Wang Wu', 26, gender="Male", job="Writer")
person_profile('Zhao Liu', 28, city="Beijing", status="Active")

Ejecute el script desde la terminal:

python3 ~/project/variable_args.py

La salida muestra que numbers es una tupla y other_info es un diccionario:

Arguments received as a tuple: (1, 2, 3)
Sum: 6

Arguments received as a tuple: (10, 20, 30, 40, 50)
Sum: 150

Name: Wang Wu
Age: 26
Other Info: {'gender': 'Male', 'job': 'Writer'}

Name: Zhao Liu
Age: 28
Other Info: {'city': 'Beijing', 'status': 'Active'}

Explorar Tipos de Parámetros Especiales

Python le permite forzar cómo se pueden pasar los argumentos a una función, haciendo que la firma de su función sea más clara y menos ambigua. Puede especificar parámetros como solo posicionales (positional-only) o solo de palabra clave (keyword-only).

Parámetros Solo Posicionales (/)

Para especificar que los parámetros solo se pueden pasar por posición, colóquelos antes de una barra inclinada hacia adelante (/) en la definición de la función.

Parámetros Solo de Palabra Clave (*)

Para especificar que los parámetros solo se pueden pasar por palabra clave, colóquelos después de un asterisco (*). Si el * no va seguido de un nombre de parámetro, significa que todos los parámetros subsiguientes deben ser solo de palabra clave.

Veamos cómo combinar estos tipos. Abra el archivo special_params.py y agregue el siguiente código. Este ejemplo define una función con parámetros solo posicionales, estándar y solo de palabra clave.

def school_info(name, /, standard_param, *, city):
    print(f'Positional-Only (name): {name}')
    print(f'Standard (standard_param): {standard_param}')
    print(f'Keyword-Only (city): {city}')
    print('---')

## En esta función:
## - `name` debe pasarse por posición.
## - `standard_param` se puede pasar por posición o palabra clave.
## - `city` debe pasarse por palabra clave.

## Llamadas válidas
school_info("Peking University", "PKU", city="Beijing")
school_info("Tsinghua University", standard_param="THU", city="Beijing")

## Ejemplos de llamadas no válidas (comentadas para evitar errores)
## school_info(name="Zhejiang University", "ZJU", city="Hangzhou")  ## TypeError: name is positional-only
## school_info("Fudan University", "FDU", "Shanghai")               ## TypeError: city is keyword-only

Ejecute el script para ver el resultado de las llamadas válidas:

python3 ~/project/special_params.py

La salida será:

Positional-Only (name): Peking University
Standard (standard_param): PKU
Keyword-Only (city): Beijing
---
Positional-Only (name): Tsinghua University
Standard (standard_param): THU
Keyword-Only (city): Beijing
---

Esta sintaxis ayuda a crear funciones robustas y auto-documentadas, reduciendo la ambigüedad sobre cómo deben ser llamadas.

Resumen

En este laboratorio, ha aprendido los fundamentos del uso de parámetros en funciones de Python. Cubrimos cómo definir y llamar funciones con parámetros posicionales, cómo hacer que los parámetros sean opcionales proporcionando valores predeterminados (default values), y cómo usar argumentos de palabra clave (keyword arguments) para un código más legible. También exploró cómo crear funciones flexibles que pueden aceptar un número variable de argumentos posicionales (*args) y de palabra clave (**kwargs). Finalmente, examinamos la sintaxis especial (/ y *) para forzar cómo deben pasarse los argumentos, lo que mejora la claridad y robustez de sus funciones.