Cómo las funciones se comunican con su entorno en Python

En este apartado se explorarán las funciones en Python, profundizando en la creación de funciones con y sin parámetros. Se proporcionarán ejemplos prácticos de funciones que reciben uno, dos o tres argumentos, y se explicará el proceso de pasar valores a estas funciones.

Cómo las funciones se comunican con su entorno en Python
Cómo las funciones se comunican con su entorno en Python

Parámetros y Argumentos

En Python, los parámetros y argumentos son conceptos fundamentales al trabajar con funciones. A continuación, se explica cada uno de ellos:

Parámetros

Los parámetros son las variables que se definen en la declaración de una función. Actúan como marcadores de posición para los valores que se pasarán a la función cuando se llame. Los parámetros se especifican dentro de los paréntesis en la definición de la función. 

                  
                    def saludar(nombre, edad):
                    print(f"Hola, {nombre}. Tienes {edad} años.")

En este ejemplo, nombre y edad son los parámetros de la función saludar.

Argumentos

Los argumentos son los valores reales que se pasan a la función cuando se llama. Estos valores se asignan a los parámetros de la función en el orden en que se proporcionan. 

                  
                    saludar("Juan", 30)

En este ejemplo, Juan y 30 son los argumentos que se pasan a la función saludar. El argumento Juan se asigna al parámetro nombre, y el argumento 30 se asigna al parámetro edad.

Paso de Argumentos Posicionales

Cuando los valores se transmiten a una función siguiendo un orden específico, donde cada valor se vincula con su respectivo parámetro según su posición, nos referimos a este método como argumentos posicionales. 

                
                  def suma(a, b):
                    return a + b
                  resultado = suma(3, 5)  # a = 3, b = 5

Paso de Argumentos de Palabra Clave

En Python existe un método alternativo para proporcionar argumentos a una función, que no depende del orden en que se escriben. Este sistema permite identificar cada argumento mediante un nombre específico en lugar de su ubicación en la función. 

                
                  def saludar(nombre, edad):
                  print(f"Hola, {nombre}. Tienes {edad} años.")
                  saludar(edad=30, nombre="Juan")

Mezcla de Argumentos Posicionales y de Palabras Clave

Existe la flexibilidad de utilizar los dos tipos de argumentos en conjunto - únicamente se debe respetar un principio fundamental: los argumentos posicionales tienen que ir ubicados antes que los argumentos nombrados (o de palabra clave). 

                
                  def adding(a, b, c):
                      print(a, "+", b, "+", c, "=", a + b + c)

La función puede ser invocada de la siguiente manera con argumentos posicionales: 

                
                  adding(1, 2, 3)  # Salida: 1 + 2 + 3 = 6

Adicionalmente, existe la posibilidad de emplear la convocatoria mediante argumentos nombrados, tal como se ilustra en el ejemplo siguiente: 

                
                  adding(c = 1, a = 2, b = 3) # Salida: 1 + 2 + 3 = 6

Para finalizar, es posible combinar ambas formas de llamada a la función, tal como se muestra a continuación: 

                
                  adding(3, c = 1, b = 2)  # Salida: 3 + 2 + 1 = 6

Los argumentos posicionales siempre deben preceder a otros tipos de argumentos en la definición de una función. Por ejemplo, el parámetro a debe colocarse en primer lugar.

En la siguiente invocación de la función, se produce una asignación repetida del parámetro a, lo que provoca un error de sintaxis. 

                
                  adding(3, a = 1, b = 2)   # Error

La respuesta de ejecución es: TypeError: adding() got multiple values for argument 'a'

Parámetros por Defecto

Los parámetros por defecto son una característica muy útil que te permite asignar valores predeterminados a los argumentos de una función.

Ejemplos para entender cómo funciona:

                
                  # Ejemplo básico de parámetro por defecto
                  def saludar(nombre="Mundo"):
                      return f"Hola, {nombre}!"
                  # Llamadas a la función
                  print(saludar())  # Imprime: Hola, Mundo!
                  print(saludar("Ana"))  # Imprime: Hola, Ana!
                  # Ejemplo con múltiples parámetros por defecto
                  def crear_perfil(nombre, edad=0, ciudad="Desconocida"):
                      return f"Nombre: {nombre}, Edad: {edad}, Ciudad: {ciudad}"
                  print(crear_perfil("Carlos"))  # Solo nombre
                  print(crear_perfil("María", 25))  # Nombre y edad
                  print(crear_perfil("Juan", 30, "Madrid"))  # Todos los parámetros

Parámetros Variables

En ocasiones, es posible que no se conozca de antemano cuántos argumentos se pasarán a la función. Para manejar esto, Python ofrece la posibilidad de utilizar *args y **kwargs.

Uso de *args

El uso de *args en Python permite que una función reciba un número variable de argumentos posicionales. Esto es especialmente útil cuando no se conoce de antemano cuántos argumentos necesitará manejar la función. Aquí se presenta una explicación detallada sobre su uso:

Sintaxis Básica

  • La notación *args es una convención; el nombre args no es obligatorio, pero es ampliamente utilizado por claridad.
  • Los argumentos pasados de esta forma se agrupan en una tupla. 
                    
                      def ejemplo(*args):
                          for arg in args:
                          print(arg)
                      ejemplo(1, 2, 3, "Python")  # Imprime: 1, 2, 3, Python

Características

  • Los argumentos se tratan como una tupla, lo que significa que son inmutables.
  • Se puede usar en combinación con otros tipos de argumentos, como argumentos normales o **kwargs (para argumentos con nombre). 
                    
                      def combinar_args(nombre, *args):
                          print(f"Nombre: {nombre}")
                          print("Otros argumentos:", args)
                      combinar_args("Juan", 10, 20, "Hola")
                      # Salida:
                      # Nombre: Juan
                      # Otros argumentos: (10, 20, 'Hola')

Ejemplos Prácticos

Suma de Números

                    
                      def suma(*numeros):
                          return sum(numeros)
                      resultado = suma(1, 2, 3, 4)
                      print(resultado)  # Salida: 10

Uso en Funciones que Aceptan Operaciones Variadas 

                    
                      def imprimir_informacion(*datos):
                      for i, dato in enumerate(datos, 1):
                          print(f"Dato {i}: {dato}")
                      imprimir_informacion("Python", 3.9, "es poderoso")
                      # Salida:
                      # Dato 1: Python
                      # Dato 2: 3.9
                      # Dato 3: es poderoso

Consideraciones

  • Aunque *args es útil, no debe usarse si los argumentos de la función tienen una cantidad fija y conocida.
  • No puede usarse como el primer argumento en una función; si se necesita un argumento posicional, este debe definirse antes de *args.

Combinación con **kwargs:

Se puede usar *args junto con **kwargs para manejar tanto argumentos posicionales como argumentos con nombre: 

                    
                      def ejemplo_mixto(*args, **kwargs):
                          print("Posicionales:", args)
                          print("Con nombre:", kwargs)
                      ejemplo_mixto(1, 2, 3, clave1="valor1", clave2="valor2")
                      # Salida:
                      # Posicionales: (1, 2, 3)
                      # Con nombre: {'clave1': 'valor1', 'clave2': 'valor2'}

Uso Avanzado

*args también se puede utilizar para desempaquetar listas o tuplas como argumentos de una función: 

                    
                      def suma(a, b, c):
                          return a + b + c
                      valores = (1, 2, 3)
                      print(suma(*valores))  # Salida: 6

Uso de **kwargs

El uso de **kwargs en Python permite que una función acepte un número variable de argumentos con nombre. La palabra clave **kwargs representa un diccionario que contiene los pares clave-valor pasados a la función. Esto es útil cuando no se conoce de antemano cuántos argumentos con nombre se van a necesitar.

Sintaxis básica

                    
                      def funcion_ejemplo(**kwargs):
                          for clave, valor in kwargs.items():
                          print(f"{clave}: {valor}")

Ejemplo de Uso

  • Llamada a la función con argumentos variables: 
                            
                          funcion_ejemplo(nombre="Juan", edad=25, ciudad="Bogotá")
                          # salida: nombre: Juan
                          # salida: edad: 25
                          # salida: ciudad: Bogotá
  • Uso combinado con *args y parámetros normales: 
                            
                          def ejemplo_combinado(parametro_fijo, *args, **kwargs):
                              print(f"Fijo: {parametro_fijo}")
                              print(f"Args: {args}")
                              print(f"Kwargs: {kwargs}")
                          ejemplo_combinado("Obligatorio", 1, 2, 3, nombre="Ana", edad=30)
                          # Salida: Fijo: Obligatorio
                          # Salida: Args: (1, 2, 3)
                          # Salida: Kwargs: {'nombre': 'Ana', 'edad': 30}

Aplicaciones comunes

  • Personalización de funciones: Permite escribir funciones genéricas que pueden aceptar diferentes configuraciones. 
                            
                            def saludar(**kwargs):
                              if 'nombre' in kwargs:
                                  print(f"Hola, {kwargs['nombre']}!")
                              else:
                                  print("Hola, desconocido.")
                          saludar(nombre="Luis")
                          saludar()
                          # Salida: Hola, Luis!
                          # Salida: Hola, desconocido.
  • Construcción de objetos dinámicos: Se usa para inicializar objetos con atributos variables. 
                              
                            class Persona:
                            def __init__(self, **kwargs):
                                for clave, valor in kwargs.items():
                                    setattr(self, clave, valor)
                            persona = Persona(nombre="Carlos", edad=40, ciudad="Lima")
                            print(persona.nombre)  # Salida: Carlos
                            print(persona.edad)    # Salida: 40
  • Integración con librerías: Librerías como matplotlib o pandas usan **kwargs para aceptar configuraciones flexibles en sus funciones.

Consideraciones

  • **kwargs debe aparecer al final de los parámetros en la definición de una función.
  • Es ideal documentar los posibles argumentos que la función puede aceptar para mantener

COMENTARIOS

Si tiene alguna inquietud, duda o ha encontrado algún error, por favor infórmelo a través del formulario disponible para este propósito.

La política de privacidad, y los términos y condiciones están disponibles en el formulario de contacto.