Funciones en Python
Introducción: Funciones en Python
Las funciones en Python son uno de los pilares fundamentales de la programación, ya que permiten organizar, reutilizar y simplificar el código. Una función puede entenderse como un bloque de instrucciones diseñado para realizar una tarea específica. En lugar de repetir fragmentos de código, las funciones permiten agruparlos bajo un nombre identificador, facilitando su uso y mantenimiento.
Que Son las Funciones
En programación, una función es un bloque de código organizado y reutilizable que realiza una tarea específica. Las funciones permiten dividir programas complejos en partes más pequeñas y manejables, promoviendo la modularidad, la legibilidad y la reutilización del código.
Sintaxis de una Función en Python
En Python, una función se define mediante la palabra reservada def,
seguida del nombre de la función, un conjunto de parámetros opcionales entre paréntesis y dos puntos :.
El bloque de código interno debe ir indentado (generalmente con cuatro espacios).
Sintaxis básica:
def nombre_de_la_funcion(parametro1, parametro2, ...):
"""Documentación de la función (docstring)"""
# Cuerpo de la función
# ...
return valor_de_retorno
Ejemplo básico:
def saludar():
print("Hola, bienvenido al mundo de Python.")
saludar() # Llamada a la función
En este ejemplo, la función saludar() imprime un mensaje en pantalla. La
llamada a la función se realiza simplemente escribiendo su nombre seguido de paréntesis.
def: Palabra clave que indica el inicio de la definición de una función.- nombre_de_la_funcion: Identificador único que se utiliza para llamar a la función. Debe seguir las reglas de nomenclatura de Python (letras, números y guiones bajos, comenzando con una letra o guión bajo).
- (parametro1, parametro2, ...): Lista opcional de parámetros que la función recibe como entrada. Los parámetros son variables que se utilizan dentro de la función para realizar cálculos o acciones.
:: Dos puntos que indican el final de la línea de definición de la función.- "Documentación de la función (docstring)": Cadena de texto opcional que describe el propósito, los parámetros y el valor de retorno de la función. Es una buena práctica incluir un docstring para documentar el código.
- # Cuerpo de la función: Bloque de código que contiene las instrucciones que se ejecutan cuando se llama a la función. Debe estar indentado.
return valor_de_retorno: Sentencia opcional que devuelve un valor como resultado de la ejecución de la función. Si no se especifica un valor de retorno, la función devuelve None por defecto.
Tipos de Funciones
En Python, existen dos tipos principales de funciones:
- Funciones integradas (built-in functions): Son funciones que ya están
definidas en el lenguaje y se pueden utilizar directamente sin necesidad de importarlas.
Ejemplos:print(),len(),type(),max(),min(). - Funciones definidas por el usuario: Son funciones que el programador crea para realizar tareas específicas.
Argumentos de una Función
Los argumentos son los valores que se pasan a una función cuando se la llama. Python admite diferentes tipos de argumentos:
Argumentos Posicionales
Se pasan a la función en el mismo orden en que se definen los parámetros.
def mostrar_info(nombre, edad):
print(f"Nombre: {nombre}, Edad: {edad}")
mostrar_info("Carlos", 30) # Por posición
Argumentos por Nombre
Se pasan a la función especificando el nombre del parámetro y su valor. Permiten pasar los argumentos en cualquier orden.
def mostrar_info(nombre, edad):
print(f"Nombre: {nombre}, Edad: {edad}")
mostrar_info(edad=25, nombre="Ana") # Por nombre
Argumentos por Defecto
Se definen con un valor predeterminado en la definición de la función. Si no se proporciona un valor para el argumento al llamar a la función, se utiliza el valor por defecto.
def mostrar_info(nombre = "Desconocido", edad = 0):
print(f"Nombre: {nombre}, Edad: {edad}")
mostrar_info(edad=25, nombre="Ana") # Por nombre
Argumentos Variables
En ocasiones, una función necesita recibir una cantidad indefinida de argumentos. Para ello, Python utiliza dos formas especiales:
*args: Para argumentos posicionales variables.**kwargs: Para argumentos con nombre variables.
*args
*numeros es un parámetro especial que permite recibir una cantidad
variable de argumentos. El asterisco * indica que la función puede
aceptar cualquier número de valores, y Python los agrupa automáticamente en una tupla.
def sumar_todo(*numeros):
total = sum(numeros)
return total
print(sumar_todo(2, 5, 7, 10))
Esta función es flexible. Se puede llamar con cualquier cantidad de números:
sumar_todo(1, 2) # devuelve 3
sumar_todo(10, 20, 30, 40) # devuelve 100
sumar_todo(5) # devuelve 5
**kwargs
**persona es un parámetro especial que permite recibir una cantidad
variable de argumentos con nombre (keyword arguments). Los dos asteriscos ** indican que Python agrupa estos argumentos en un diccionario.
def mostrar_datos(**persona):
for clave, valor in persona.items():
print(f"{clave}: {valor}")
mostrar_datos(nombre="Eduardo", edad=35, ciudad="Bogotá")
Ejemplo Argumentos Variables
def saludar(nombre, saludo="Hola"):
"""Saluda a una persona con un saludo personalizado."""
print(f"{saludo}, {nombre}!")
saludar("Juan") # Imprime: Hola, Juan!
saludar("Maria", "Buenos días") # Imprime: Buenos días, Maria!
def sumar(*args):
"""Suma un número variable de argumentos."""
suma = 0
for numero in args:
suma += numero
return suma
print(sumar(1, 2, 3, 4)) # Imprime: 10
def mostrar_datos(**kwargs):
"""Muestra datos de una persona."""
for clave, valor in kwargs.items():
print(f"{clave}: {valor}")
mostrar_datos(nombre="Pedro", edad=30, ciudad="Madrid")
Valores de Retorno
Una función puede devolver un valor utilizando la sentencia return. El
valor de retorno puede ser de cualquier tipo de dato (número, cadena, lista, diccionario, etc.). Si no se
especifica un valor de retorno, la función devuelve None por defecto.
Sintaxis básica:
def cuadrado(numero):
"""Calcula el cuadrado de un número."""
return numero * numero
resultado = cuadrado(5)
print(resultado) # Imprime: 25
print(cuadrado(6)) # Imprime: 36
Aquí, la función devuelve el cuadrado de un número, y ese resultado puede almacenarse en una variable o usarse directamente.
Alcance de las Variables
El alcance de una variable se refiere a la región del código donde la variable es accesible. En Python, existen dos tipos principales de alcance:
- Alcance local: Las variables definidas dentro de una función tienen un alcance local, lo que significa que solo son accesibles dentro de esa función.
- Alcance global: Las variables definidas fuera de cualquier función tienen un alcance global, lo que significa que son accesibles desde cualquier parte del código, incluyendo dentro de las funciones.
Es importante tener en cuenta que si una variable local tiene el mismo nombre que una variable global, la variable local "oculta" a la variable global dentro de la función.
Ejemplo:
mensaje = "Variable global"
def mostrar():
"""Función que muestra el mensaje."""
mensaje_local = "Variable local"
print(mensaje)
print(mensaje_local)
mostrar()
Salida:
Variable global
Variable local
Funciones Lambda (Anónimas)
Las funciones lambda son funciones pequeñas y anónimas que se definen en
una sola línea utilizando la palabra clave lambda. Se utilizan
principalmente para crear funciones simples y concisas que se pueden pasar como argumentos a otras
funciones.
Sintaxis básica:
lambda argumentos: expresión
Ejemplo:
cuadrado = lambda x: x ** 2
print(cuadrado(5))
También pueden combinarse con funciones como map(), filter() o sorted()::
numeros = [1, 2, 3, 4, 5]
cuadrados = list(map(lambda n: n ** 2, numeros))
print(cuadrados)
Recursividad
La recursividad es una técnica de programación en la que una función se llama a sí misma dentro de su propia definición. Se utiliza para resolver problemas que se pueden dividir en subproblemas más pequeños del mismo tipo. Es importante que una función recursiva tenga un caso base que detenga la recursión para evitar un bucle infinito.
def factorial(n):
"""Calcula el factorial de un número de forma recursiva."""
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5)) # Imprime: 120
Decoradores
Los decoradores son una característica poderosa de Python que permite modificar o extender el comportamiento de una función sin modificar su código fuente. Un decorador es una función que toma otra función como argumento y devuelve una nueva función que envuelve a la función original.
def mi_decorador(funcion):
def funcion_envolvente():
print("Antes de llamar a la función.")
funcion()
print("Después de llamar a la función.")
return funcion_envolvente
@mi_decorador
def saludar():
print("Hola!")
saludar()
Salida:
Antes de llamar a la función.
Hola!
Después de llamar a la función.
Mejores Prácticas
- Documentar las funciones: Utilizar docstrings para describir el propósito, los parámetros y el valor de retorno de cada función.
- Mantener las funciones pequeñas y enfocadas: Cada función debe realizar una tarea específica y bien definida.
- Utilizar nombres descriptivos para las funciones y los parámetros: Esto facilita la lectura y comprensión del código.
- Evitar efectos secundarios: Las funciones deben ser lo más puras posible, es decir, no deben modificar el estado global del programa.
- Utilizar argumentos por defecto cuando sea apropiado: Esto facilita la llamada a la función y reduce la cantidad de código repetitivo.
- Considerar el uso de funciones lambda para tareas simples y concisas.
- Utilizar la recursividad con precaución: Asegurarse de que la función recursiva tenga un caso base para evitar un bucle infinito.
- Aprovechar los decoradores para modificar el comportamiento de las funciones de forma elegante y reutilizable.
- Evitar variables globales cuando sea posible.
- Retornar valores útiles en lugar de imprimir directamente dentro de la función.