Explorando los puntos suspensivos de Python (...): más que solo sintaxis Sugar
¿Alguna vez te has preguntado para qué se utilizan los tres puntos (...) en Python? ¡Descubra cómo este poderoso operador puede simplificar su código!
Python, un lenguaje conocido por su potencia, tiene algunas joyas ocultas que no siempre reciben la importancia que merece. Según el tema, afirmamos que los puntos suspensivos son una de esas características, con usos que los programadores normalmente no conocen. En términos simples, los puntos suspensivos son un símbolo de tres puntos que se utiliza como marcador de posición para resaltar el código sin terminar o áreas donde se planifica trabajo futuro. Los puntos suspensivos facilitan la división de matrices multidimensionales y son útiles para sugerencias de tipo. Por lo tanto, podemos decir que los puntos suspensivos son una herramienta que puede mejorar el código, permitiendo un código más organizado y simplificando operaciones complejas.
No es necesario importar los puntos suspensivos para usarlo. Profundicemos ahora para comprender lo que la elipsis tiene para ofrecer.
1. Elipsis como marcador de posición
Principalmente en el idioma inglés, tres puntos indican una continuación o representan partes omitidas. De manera similar, en Python, los puntos suspensivos pueden actuar como portadores de código que no se ha implementado hasta ahora. Este enfoque es especialmente útil cuando estás estructurando funciones, clases o incluso módulos completos, lo que te permite dejar partes del código vacías sin causar errores de sintaxis.
Por ejemplo, si estás diseñando un programa y conoces la estructura del código pero aún no has escrito toda la lógica, puedes usar ... para reservar el lugar donde eventualmente irá el código:
def classify():
...
En este contexto, los puntos suspensivos actúan como un marcador de "tareas pendientes", lo que indica que hay más trabajo por hacer. A diferencia de pasar, que actúa como un marcador de posición sin operación, usar... (los puntos suspensivos) indica que una función está intencionalmente incompleta.
2. Elipsis al cortar matrices multidimensionales
El operador de elipsis en Python es una herramienta valiosa para la división de matrices, especialmente en bibliotecas como NumPy, donde el manejo de matrices multidimensionales puede volverse complejo. Considere una matriz 3D en la que desea seleccionar todos los elementos a lo largo de las dos primeras dimensiones mientras recupera elementos en el índice 0 de la última dimensión. Usando el operador de elipsis, puedes hacer esto con:
import numpy as np
# Create a 3D array
arr = np.arange(27).reshape(3, 3, 3)
# Select all elements along the first two dimensions and only index 0 of the last dimension
result = arr[..., 0]
print(result)Output
[[ 0 3 6]
[ 9 12 15]
[18 21 24]]Arr[..., 0] selecciona todos los elementos a lo largo de las dos primeras dimensiones mientras se centra solo en el índice 0 en la tercera dimensión. Este enfoque hace que la manipulación de datos de alta dimensión sea eficiente y mejora la claridad del código cuando se trabaja con grandes conjuntos de datos.
3. Elipsis en los valores de parámetros predeterminados
Los puntos suspensivos (...) también se pueden utilizar como valor de parámetro predeterminado único en funciones de Python, lo que proporciona una alternativa útil cuando Ninguno podría ser un argumento válido. Al utilizar... como valor predeterminado, puede distinguir claramente entre los casos en los que no se proporcionó ningún argumento y los casos en los que Ninguno se pasa intencionalmente como valor.
Entendamoslo con la ayuda de un ejemplo:
def greet(name="Guest", greeting=...):
if greeting is ...:
greeting = "Hello" # Default greeting if none provided
print(f"{greeting}, {name}!")
# Testing different cases
greet("Alice") # Uses default greeting: "Hello, Alice!"
greet("Bob", greeting="Hi") # Custom greeting: "Hi, Bob!"
greet("Charlie", greeting=None)
# Outputs: "None, Charlie!" (explicitly setting greeting to None)En este ejemplo:
- Si no se proporciona el saludo, el valor predeterminado es "Hola".
- Si se proporciona un saludo específico (como "Hola"), la función lo utiliza en lugar del predeterminado.
- Si saludo=Ninguno, muestra "¡Ninguno, {nombre}!", lo que muestra que Ninguno se pasó a propósito, distinto del uso predeterminado.
4. Elipsis como sugerencias tipográficas
Los puntos suspensivos (...) se pueden usar como sugerencias de tipo, especialmente en ciertos contextos donde desea indicar que podrían estar presentes más valores o que algo tiene una estructura variable que no está completamente especificada. A continuación se detallan los dos usos diferentes de los puntos suspensivos como sugerencias de tipo que vamos a analizar:
Para tuplas de longitud desconocida
Las sugerencias de tipo se utilizan para representar elementos que son flexibles o que tienen características no especificadas. Imagínese si desea crear una variable llamada comestibles_list que es una tupla de cadenas, pero no sabe cuántas cadenas habrá en esa tupla. La elipsis garantiza que todos los elementos sean cadenas y al mismo tiempo permite que varíe el número de elementos.
Code Example:
from typing import Tuple
# Allowed:
grocery_list: Tuple[str, ...] = ("apples", "bread", "milk", "eggs", "butter")
grocery_list = ("apples",) # A tuple with a single string is allowed
grocery_list = () # An empty tuple is allowed
# Not allowed:
grocery_list = (1, "bread")
grocery_list = ["apples", "bread"]
grocery_list = ("apples", 2.5)
# Function to print each item in the grocery list
def print_grocery_items(items: Tuple[str, ...]) -> None:
for item in items:
print(f"- {item}")
# Call the function with our grocery list
print_grocery_items(grocery_list)
La definición de variable como grocery_list: Tuple[str, ...]=("apples", "bread") es válida porque ambos elementos son del tipo especificado, mientras que los tipos mixtos como ( 1, "bread") o una lista en lugar de una tupla ["apples", "bread"] no están permitidos.
Para invocables con argumentos flexibles
Los puntos suspensivos se pueden utilizar en sugerencias de tipo para invocables cuando se desconocen el número y los tipos de argumentos. En ocasiones, es posible que necesites pasar una función a otra función sin saber cuáles serán los argumentos de esa función. Por lo tanto, se pueden usar puntos suspensivos para mostrar que la función puede tomar un número opcional de argumentos de cualquier tipo.
Code Example:
from typing import Callable
# A function that takes one number and returns it doubled
def double_value(x: int) -> int:
return x * 2
# A function that takes two numbers and returns their sum
def add_values(x: int, y: int) -> int:
return x + y
# A function that takes an integer, a callable, and optional extra arguments
def apply_action(value: int, action: Callable[..., int], *args: int) -> int:
return action(value, *args)
# Allowed:
print(apply_action(5, double_value)) # Calls double_value(5), which results in 10
print(apply_action(5, add_values, 3)) # Calls add_values(5, 3), which results in 8
# Not Allowed:
apply_action(5, 3)
apply_action(5, double_value, "extra") En el ejemplo anterior,
- La función apply_action toma un número entero (valor), un invocable (acción) y argumentos adicionales opcionales (*args).
- La sugerencia de tipo Invocable[..., int] significa que la acción invocable puede tomar cualquier número de argumentos de cualquier tipo, pero debe devolver un int.
- La función apply_action puede manejar ambos escenarios de funciones double_value y add_values debido a los puntos suspensivos (...) en la sugerencia de tipo.
- Los ejemplos que no funcionan resaltan que el invocable debe ser una función y que los argumentos adicionales deben coincidir con el tipo de entrada esperado de la función.
Esto mantiene la coherencia de tipos y al mismo tiempo proporciona flexibilidad en los argumentos pasados al invocable.