DEV Community: Giovani Fouz

Comprendiendo el uso del Asterisco (`*`) y Doble Asterisco (`**`) en Python

Giovani Fouz — Sat, 09 Nov 2024 11:15:03 +0000

Cuando trabajamos en Python, a menudo nos encontramos con situaciones en las que necesitamos que nuestras funciones sean flexibles y capaces de manejar diferentes tipos y cantidades de argumentos. Para facilitar esto, Python ofrece dos operadores muy útiles: el asterisco simple (*) y el doble asterisco (**). En este post, exploraremos en detalle su funcionamiento, así como su aplicación en funciones, clases y estructuras de datos como listas y diccionarios.

¿Qué son las estructuras de datos en Python?

Antes de entrar en el uso del asterisco, es importante entender qué son las estructuras de datos. En Python, las estructuras de datos son formas de organizar y almacenar datos en el programa. Las más comunes son:

Listas: Colecciones ordenadas que permiten elementos duplicados.
Tuplas: Similares a las listas, pero son inmutables.
Diccionarios: Colecciones no ordenadas de pares clave-valor.

Estas estructuras son fundamentales para manejar datos en Python y son el contexto donde los operadores * y ** se vuelven particularmente interesantes.

Usos del Asterisco Simple (`*`)

1. Funciones con Argumentos Variables

El asterisco simple se utiliza principalmente en funciones para permitir que acepten un número variable de argumentos posicionales. Esto significa que puedes pasarle cualquier cantidad de argumentos y todos serán tratados como una tupla dentro de la función.

def func(*args):
    for arg in args:
        print(arg)

func(1, 2, 3, 4)

# Esto imprime: 1 2 3 4

Desempaquetado de Listas o Tuplas También puedes usar el asterisco simple para desempaquetar elementos de una lista o tupla al pasar argumentos a una función.

numbers = [1, 2, 3]
print(*numbers)  # Esto imprime: 1 2 3

Este uso del asterisco puede ser muy conveniente cuando tienes una lista de elementos y quieres pasarlos como argumentos a otra función.

Usos del Doble Asterisco (`**`)

Funciones con Argumentos de Palabra Clave El doble asterisco se utiliza para permitir que una función acepte un número variable de argumentos de palabra clave (nombre-valor). Dentro de la función, estos argumentos se almacenan en un diccionario.

def func(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

func(name="Alice", age=30)
# Salida:
# name: Alice
# age: 30

Desempaquetado de Diccionarios Al igual que el asterisco para listas y tuplas, puedes usar el doble asterisco para desempaquetar pares clave-valor desde un diccionario al llamar a una función.

data = {"name": "Alice", "age": 30}
func(**data)  # Osea es lo mismo que: func(name="Alice", age=30)

Usos Avanzados de * y ** en Clases

class MyClass:
    def __init__(self, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs

obj = MyClass(1, 2, a=3, b=4)
print(obj.args)   # (1, 2)
print(obj.kwargs) # {'a': 3, 'b': 4}

En Herencia
Puedes utilizar *args y **kwargs para pasar argumentos al constructor de la clase base, lo que permite que la clase derivada extienda el comportamiento del constructor de la clase base.

class Base:
    def __init__(self, x):
        self.x = x

class Derived(Base):
    def __init__(self, x, *args, **kwargs):
        super().__init__(x)  # Llama al constructor de Base
        # Puedes hacer algo adicional con args y kwargs aquí

d = Derived(10)

Combinaciones de simple y doble asterisco:
A veces, puede ser útil combinar tanto los argumentos posicionales como los de palabra clave en tus funciones para permitir un manejo completo de los datos de entrada:

def mixed_args(a, b, *args, **kwargs):
    print(a, b)
    print(args)
    print(kwargs)

mixed_args(1, 2, 3, 4, x=5, y=6)

#Salida:

# 1 2
# (3, 4)
# {'x': 5, 'y': 6}

Documentación Oficial de Python sobre Funciones
Python para Todos - Curso Gratuito
Real Python - Unpacking in Python
W3Schools - Python Functions (Defining Functions)

Resumen:

args es útil para recibir un número variable de argumentos posicionales, mientras que kwargs es útil para recibir un número variable de argumentos de palabra clave.
Puedes usar simple y doble asterisco para desempaquetar listas/tuplas y diccionarios, respectivamente, al llamar funciones.
Ambos operadores pueden mejorar la flexibilidad y reutilización de tu código, permitiendo funciones que manejan diferentes tipos de entradas de manera eficiente.
Recursos Útiles

React query, hook personalizado.

Giovani Fouz — Sat, 09 Nov 2024 08:02:56 +0000

En aplicaciones de React, es común necesitar acceder a datos de una API externa. Tradicionalmente, muchos desarrolladores utilizan métodos nativos de javascript como fetch dentro de los componentes, lo que puede llevar a problemas de administración del estado y a un manejo complicado de efectos secundarios (side effects). Aquí es donde React Query entra en juego.

¿Qué es React Query?

React Query es una biblioteca destinada a simplificar las operaciones de obtención y manejo de datos en React. Proporciona potentes funciones para:

Efectuar solicitudes de datos de una API.
Almacenar y sincronizar el estado de la UI con los datos.
Realizar refetching automáticamente y gestionar cachés.
Nuestro Hook Personalizado

A continuación, veamos nuestro hook personalizado, useCustomQuery:

import { useQuery } from '@tanstack/react-query';

export type GenericObject = {
  [key: string]: any;
};

export type QueryFunction = (
  url: string,
  token?: string,
) => Promise<GenericObject>;

export const useCustomQuery = (
  queryFunction: QueryFunction,
  url: string,
  queryKey: string[],
  token?: string,
) => {
  const { isPending, isError, data, error, refetch, isLoading } = useQuery<
    GenericObject | GenericObject[]
  >({
    queryKey: [queryKey],
    queryFn: () => queryFunction(url, token),
  });

  return { data, error, isError, isPending, refetch, isLoading };
};

Desglose del Hook

GenericObject y QueryFunction:

Definimos tipos genéricos que facilitan el trabajo con objetos y funciones que realizan fetching de datos. Esto asegura que nuestro código pueda adaptarse a diferentes estructuras de datos que puedan regresar las APIs.

useQuery:

Usamos el hook useQuery de React Query, que maneja automáticamente el estado de nuestras solicitudes. Proporciona propiedades útiles para manejar la carga de datos, errores y refetching.

Esto mejora la calidad del código y reduce bugs.
Interfaces Genéricas: Utilizando interfaces genéricas, podemos definir estructuras de datos que se adaptan a diferentes situaciones. Esto hace que el código sea más reutilizable y fácil de mantener.
Mejor Documentación: El uso de TypeScript como una herramienta de documentación proporcionada por los tipos mejora la comprensión de cómo se deben usar las funciones y qué tipo de datos se esperan.

Enlaces Útiles

React Query:
- Documentación oficial: TanStack Query Documentation
- Guía de inicio rápido: Getting Started with React Query
TypeScript:
- Documentación oficial: TypeScript Documentation
- Guía de TypeScript para React: Using TypeScript with React
GitHub de React Query:
- Repositorio oficial: TanStack Query (React Query) GitHub
Ejemplos y Tutoriales:
- Tutorial de RapidAPI sobre React Query: Getting Started with React Query
- Artículo sobre los beneficios de utilizar React Query: Benefits of Using React Query

Conclusión

Integrar un hook personalizado junto con React Query y TypeScript en tus aplicaciones React transforma la forma en que gestionas las solicitudes de datos. No sólo mejora la experiencia de desarrollo al reducir la carga de lógica de manejo de estado, sino que también enriquece la robustez y facilidad de mantenimiento de tu código.
Espero que encuentren útil este enfoque y les animo a probarlo en sus propios proyectos. ¡Feliz codificación!

Errores Comunes de Pylint. Guía Práctica

Giovani Fouz — Mon, 27 May 2024 09:10:20 +0000

Pylint es una herramienta de análisis estático de código que se utiliza para encontrar errores y mejorar la calidad del código Python. Sin embargo, enfrentarse a los errores que reporta puede ser desalentador, especialmente para los desarrolladores novatos. Aquí exploramos algunos de los errores más comunes que lanza Pylint, cómo resolverlos y cómo podemos beneficiarnos de estas correcciones para escribir un código más limpio y eficiente.

1- C0103: Variable name "x" doesn't conform to snake_case naming style
Error:
Este error se produce cuando el nombre de una variable no sigue la convención de nombres en Python, que es usar snake_case.