Probá la app en https://buscador-linkedin.streamlit.app/

El otro día me di cuenta que hace ya cuatro años que comparto contenido sobre Python y Ciencia de Datos en LinkedIn y la verdad es que se trata de una experiencia muy interesante que me permitió conectar con muchas personas. Sin embargo, al acumular cientos de publicaciones, encontrar contenido específico puede volverse un verdadero desafío y frecuentemente hay gente preguntándome sobre algo de lo que ya hice muchos posts. Por esta razón, decidí desarrollar un buscador semántico que utiliza inteligencia artificial para encontrar publicaciones relevantes. Este proyecto combina las bibliotecas Sentence Transformers y Streamlit para crear una aplicación sencilla y poderosa que mejora la forma en que se puede interactuar con mi contenido. Al final, además del objetivo de proporcionar una manera más eficaz para buscar entre mis publicaciones, estos conceptos y herramientas les permitirán ir más allá y crear un buscador en base a sus propios datos.

Búsqueda semántica

La búsqueda semántica es un enfoque avanzado para encontrar información relevante, que se basa en el significado de las palabras y las relaciones entre conceptos, en lugar de simplemente buscar coincidencias exactas de texto (como hacen los motores de búsqueda tradicionales). La idea es entender la intención detrás de la consulta del usuario y su contexto, mejorando la precisión de los resultados.

Hay versiones más sofisticadas, pero en su forma básica se basa en encontrar similitudes entre palabras y oraciones en un espacio vectorial, luego de haber construido representaciones numéricas (también conocidas como embeddings) de ellas. Esto se basa en la idea de que palabras que aparecen en contextos similares tienen significados similares.

Cómo funciona el buscador

El corazón de este proyecto es el modelo hiiamsid/sentence_similarity_spanish_es, una variante de BERT entrenada para calcular la similitud entre oraciones en español. El modelo lo descargué de HuggingFace y la idea es transformar tanto las publicaciones de LinkedIn como las consultas de los usuarios en vectores numéricos (embeddings) y luego medir la distancia entre ellos para encontrar el contenido más relevante.

La ventaja de este enfoque es que el buscador no necesita que las palabras de la consulta coincidan exactamente con las palabras de mis publicaciones. Por ejemplo, si alguien busca “visualización de datos”, el sistema puede encontrar publicaciones donde hablé de gráficos con Matplotlib o dashboards con Plotly, aunque esas palabras no estén en la consulta original. Esto es posible porque el modelo entiende que todos esos conceptos están relacionados.

Cómo construí un buscador semántico de mis publicaciones de LinkedIn

Para facilitar la búsqueda de contenido específico entre mis cientos de publicaciones, creé un buscador semántico usando:

• Sentence Transformers: Para convertir textos en vectores (embeddings) y medir similitud.

• Streamlit: Para armar una interfaz web simple y funcional.

• Pandas: Para manipular el archivo CSV con mis publicaciones.

Flujo del Proyecto

Acá pueden encontrar todo el código del proyecto y a continuación pasaré a explicar cada parte del mismo

1. Descarga de mis posts de LinkedIn

En el archivo posts.csv se encuentran todas mis publicaciones de LinkedIn. Cada fila corresponde a un post, con su fecha y el texto completo. Este archivo es la fuente principal de datos para el buscador semántico.

Este archivo fue generado utilizando la herramienta oficial de Descarga de Datos de LinkedIn, que permite exportar un historial completo de tus publicaciones. De esta forma, pude obtener un registro estructurado con el contenido de cada post, listo para procesar y analizar.

2. Creación de representaciones numéricas (embeddings)

Este modelo está finetuneado para calcular similitud entre oraciones en español. La idea es que publicaciones con temas similares (por ejemplo, pandas y limpieza de datos) estén cerca en un espacio vectorial que los contiene.

El código relevante se encuentra en el notebook generar_linkedin_embeddings.ipynb

model = SentenceTransformer('hiiamsid/sentence_similarity_spanish_es')

El flujo es el siguiente:

1. Cargar el CSV de publicaciones.

2. Convertir cada post a un embedding.

3. Guardar los embeddings en un archivo. Los embeddings podrían generarse con cada consulta pero esto es una manera más óptima de hacerlo.

shares_data.to_csv(f'Shares_with_embeddings_{model_type.split("/")[-1]}.csv', index=False)

3. Creación de una app con Streamlit

La idea fue crear una app web sencilla que le permitiera al usuario escribir una consulta y visualizar los potenciales posts de interés.

El código lo pueden encontrar en streamlit_app.py , pero más allá de algunos detalles de diseño para que se vea mejor, el sistema hace lo siguiente:

1. Carga el archivo CSV con publicaciones y embeddings.

2. Compara la consulta con todos mis posts usando la similitud coseno.

3. Devuelve los 5 posts más relevantes.

4. Permite ver una versión abreviada del post e ir con un botón directo al post original.

Puesta en producción

Finalmente la subí Streamlit community cloud, un servicio de Streamlit que tiene una capa gratuita para subir apps con algunas limitaciones.

Probá la app funcionando: https://buscador-linkedin.streamlit.app/

¿Querés armar uno para tu propio buscador con IA?

Si te interesa replicarlo, el código completo está disponible y puede adaptarse a cualquier colección de textos: posts, artículos, papers o documentos internos: https://github.com/GEJ1/buscador-linkedin/

¿Te interesa seguir aprendiendo más sobre Python?

Si este contenido te resultó útil y te interesa leer contenido sobre programación principalmente en Python, ciencia de datos e inteligencia artificial, seguime en mis redes:

🐙 Pueden ver todo el código en es repositorio de Github y si te sirve dejá una estrella ⭐

📘 LinkedIn donde comparto contenido con frecuencia: Gustavo Juantorena

📹 YouTube: Gustavo Juantorena - Programación y Ciencia de Datos

♻️ Si te gustó este post, ¡compartilo para que más personas puedan aprender! Si te quedaron dudas, dejalas en los comentarios

¡Nos vemos en el próximo!

Deja un comentario

Compartir

Compartir Datos y Cerebros

Argumentos posicionales

En Python los parámetros de una función son posicionales por defecto, esto quiere decir que el orden en que le pasamos los argumentos es importante. Veamos un ejemplo:

def juntar_palabras(palabra1, palabra2):     
    return palabra1 + palabra2  

print(juntar_palabras('perro', 'loco')) # Salida: 'perroloco'  

Si hubieramos pasado primero ‘loco’ y luego ‘perro’ el resultado hubiera estado invertido, devolviendo ‘locoperro’.

¿Qué sucede si quiero concatenar 3 palabras? Una opción sería agregar un tercer parámetro a la función:

def juntar_palabras(palabra1, palabra2, palabra3):          
    return palabra1 + palabra2 + palabra3    

print(juntar_palabras('perro', 'loco', 'lindo')) # Salida: 'perrolocolindo'    

¿Y cuándo no sabemos cuántos argumentos va a recibir nuestra función?

Ahí es donde aparece la utilidad de *args:

def juntar_palabras(*args):    
    salida = ''  
    for palabra in args:
        salida += palabra
    return salida
  

print(juntar_palabras('perro', 'loco', 'lindo', 'grande')) # Salida: 'perrolocolindogrande' 

Como se observa en el ejemplo, utilizar *args nos permite recibir una cantidad de argumentos indefinida y utilizarla como si estuvieras pasando una tupla con esos valores.

Argumentos con nombre

Una alternativa que nos permite Python es crear una función con parámetros que tengan nombre (o keyword arguments). De este modo, ya no importará el orden, sino que estaremos asignando un valor a cada variable que podrá ser usado dentro de la función:

def describir_pokemon(tipo, color, tamaño):     
    return f"El Pokemon es {tipo}, {color} y {tamaño}."

print(describir_pokemon(tamaño="pequeño", color="azul", tipo="agua"))
# Salida: 'El Pokemon es tipo agua, color azul y pequeño.'

En este caso, para recibir una cantidad variable de argumentos con nombre tenemos que usar no uno, sino dos asteriscos (**kwargs):

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

describir_atributos(tipo="roca", color="negro", tamaño="grande")  
# Salida:
# tipo: roca
# color: negro
# tamaño: grande

Lo que terminamos obteniendo es un diccionario donde las claves son los nombres de los argumentos y los valores son los datos proporcionados.

La gran mentira sobre args y kwargs 😮

Dado que cuando queremos el comportamiento explicado previamente usamos *args y **kwargs, podríamos creer que se trata de palabras reservadas que tienen un valor particular en el lenguaje (como True, print o def) pero ¡nada más lejos de la realidad! *args y **kwargs son simples convenciones y podríamos obtener el mismo comportamiento con cualquier otro nombre mientras respetemos el patrón de un asterisco para argumentos posicionales y dos para argumentos con nombre:

def ejemplo_posic(*posicionales):
    print("Posicionales:", posicionales)


ejemplo_posic(1, 2, 3)  
# Salida:
# Posicionales: (1, 2, 3)

def ejemplo_con_nombre(**con_nombre):
    print("Con nombre:", con_nombre)

ejemplo_con_nombre(atributo1="valor1", atributo2="valor2")  
# Salida:
# Con nombre: {'atributo1': 'valor1', 'atributo2': 'valor2'}

Unamos lo aprendido 🤝

¿Qué pasa si en una misma función quiero recibir una cantidad desconocida de argumentos posicionales y además una cantidad desconocida de argumentos con nombre? Bueno, tranquilos porque eso es perfectamente válido. Por completitud les voy a dejar un ejemplo con todas las posibilidades, el cual solo es funcional a partir de la versión 3.8 de Python. Se puede definir una función con los siguientes tipos de parámetros en este orden específico:

1. Parámetros posicionales obligatorios (los “normales”).

2. /: Para indicar que todos los parámetros antes de esta barra deben ser posicionales obligatorios.

3. Parámetros posicionales o por nombre.

4. *: Para indicar que todos los parámetros después de * deben ser pasados por nombre (keyword-only). Notar que este es otro uso del *, del cuál todavía no habíamos hablado.

5. *args: Captura una cantidad variable de argumentos posicionales.

6. Parámetros con nombre (keyword-only).

7. **kwargs: Captura una cantidad variable de argumentos con nombre.

def ejemplo_completo(pos1, pos2, /, pos_o_nombre, *, nombre1, nombre2="por defecto", **kwargs):
    print("Posicionales obligatorios:")
    print(f"  pos1: {pos1}")
    print(f"  pos2: {pos2}")
    print("\nPosicionales o por nombre:")
    print(f"  pos_o_nombre: {pos_o_nombre}")
    print("\nSolo por nombre:")
    print(f"  nombre1: {nombre1}")
    print(f"  nombre2: {nombre2}")
    print("\nArgumentos adicionales (**kwargs):")
    for clave, valor in kwargs.items():
        print(f"  {clave}: {valor}")


# Llamada a la función
ejemplo_completo(1, 2, 3, nombre1="valor1", extra1="adicional1", extra2="adicional2")

Posicionales obligatorios:
  pos1: 1
  pos2: 2

Posicionales o por nombre:
  pos_o_nombre: 3

Solo por nombre:
  nombre1: valor1
  nombre2: por defecto

Argumentos adicionales (**kwargs):
  extra1: adicional1
  extra2: adicional2

Una aclaración más es que no es obligatorio pasar “de a uno” los argumentos posicionales y con nombre sino que podemos directamente pasarle la colección, siempre y cuando los desempaquemos con * y **:

mi_lista = [1, 2, 3]
mi_diccionario = {"a":4, "b":5}

def ejemplo_colecciones(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)
    return args, kwargs  # Devuelve args y kwargs como una tupla

print(ejemplo_colecciones(*mi_lista, **mi_diccionario))
# Salida:
# args: (1, 2, 3)
# kwargs: {'a': 4, 'b': 5'}
# ((1, 2, 3), {'a': 4, 'b': 5})

Usando * y ** fuera de una función

Una de las cosas que también suele confundir un poco sobre este tema es que el comportamiento de * y ** cambia fuera de funciones porque en este caso se utilizan para desempaquetar colecciones en otros contextos, tales como la creación de listas, tuplas o diccionarios. En particular * se utiliza para desempaquetar (unpacking) colecciones como listas, sets y tuplas:

# Desempaquetar listas
lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
combinada = [*lista1, *lista2]  # [1, 2, 3, 4, 5, 6]

# Desempaquetar sets
set1 = {1, 2}
set2 = {3, 4}
combinado = {*set1, *set2}  
print(combinado) # Salida: {1, 2, 3, 4}

Mientras que ** Se usa para desempaquetar diccionarios, permitiendo por ejemplo combinar sus claves y valores en un nuevo diccionario:

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
combinado = {**dict1, **dict2} 

print(combinado) # Salida: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Resumiendo, en la definición de funciones * y **, se usan para recolectar entradas dinámicas, mientras que fuera de las funciones, se usan para expandir estructuras en nuevas colecciones.

Conclusiones y resumen

En Python *args, y **kwargs se usan para definir funciones de manera flexible. Además, existe el concepto de desempaquetado de colecciones con * y ** fuera de las funciones, el cual nos permite expandir estructuras en nuevas colecciones.

¿Te interesa seguir aprendiendo más sobre Python?

Si este contenido te resultó útil y te interesa leer contenido sobre programación principalmente en Python, ciencia de datos e inteligencia artificial? Seguime en mis redes:

🐙 Pueden ver todo el código en un Jupyter notebook en Github

📘 LinkedIn donde comparto contenido con frecuencia: Gustavo Juantorena

📹 YouTube: Gustavo Juantorena - Programación y Ciencia de Datos

♻️ Si te gustó este post, ¡compartilo para que más personas puedan aprender! Si te quedaron dudas, dejalas en los comentarios

¡Nos vemos en el próximo!

Compartir

Suscríbete ahora

Deja un comentario

Las comprensiones en Python (comprehensions en inglés) son un tipo de construcción específica de este lenguaje, que permite crear secuencias a partir de otras secuencias o de iterables.

Vamos con un ejemplo: imaginate que querés crear una lista a partir de otra. Una manera de hacerlo sería la siguiente:

lista_inicial = [1, 2, 3]
lista_nueva = [] 

for elemento in lista_inicial: 
    lista_nueva.append(elemento + 1) 

print(lista_nueva) # Salida: [2,3,4]

Bueno, una manera de obtener el mismo resultado en Python utilizando una lista por comprensión sería la siguiente:

lista_nueva = [elemento + 1 for elemento in lista_inicial] 

Más sencillo ¿No?

Filtrado dentro de la comprensión

Además de escribir menos código, otra ventaja es tener una manera fácil de filtrar una lista:

lista1 = [1, 2, 3, 4, 5, 6, 7, 8] 
lista2 = [item * 2 for item in lista1 if item > 5] 

# Filtra los números mayores a 5 y los multiplica por 2

print(lista2) # Salida: [12, 14, 16]

¿Y si tenemos más de una condición? Normalmente utilizaríamos la palabra reservada elif, pero eso no es válido dentro de una comprensión. Sin embargo, se puede simular el comportamiento utilizando expresiones condicionales (if-else) dentro de la comprensión:

lista1 = [1, 2, 3, 4, 5, 6, 7, 8]

# Si el elemento es mayor a 5, lo multiplica por 2; si no, lo multiplica por 3
lista2 = [i * 2 if i > 5 else i * 3 for i in lista1]

print(lista2) # Salida: [3, 6, 9, 12, 15, 12, 14, 16]

Listas por comprensión anidadas

Qué pasa si queremos llevar a este tipo de sintaxis una situación donde tenemos más de un ciclo uno dentro de otro (anidados):

lista1 = [1, 2, 3, 4, 5, 6, 7, 8]

# Usando un bucle estándar 
lista2 = []
for item in lista1:
    if item > 5:
        for factor in [2, 3]:
            lista2.append(item * factor)

print(lista2) # Salida: [12, 18, 14, 21, 16, 24]


# Usando una lista por comprensión anidada

lista2 = [item * factor for item in lista1 if item > 5 for factor in [2, 3]]

print(lista2) # Salida: [12, 18, 14, 21, 16, 24]

Mi recomendación es no abusar de estas expresiones, siguiendo Zen de Python Simple es mejor que complejo y no tiene sentido hacer una comprensión difícil de leer, sino mejor ir por un bucle normal que sea más fácil de entender a simple vista.

Otras comprensiones

Existen otras comprensiones que no se basan en listas pero que permiten tener un comportamiento similar para otras estructuras de datos

Diccionarios por comprensión

Los diccionarios por comprensión se caracterizan por el uso de llaves { } y del par clave:valor separado por dos puntos. En el siguiente ejemplo crearemos un diccionario en base a una lista de palabras donde la clave sea cada palabra tal cual aparece y el valor sea esa misma palabra en mayúsculas:

palabras = ["python", "carpincho", "diccionario"] 

diccionario_nuevo = {palabra: palabra.upper() for palabra in palabras} 

print(diccionario_nuevo) # Salida: {'python': 'PYTHON', 'carpincho': 'CARPINCHO', 'diccionario': 'DICCIONARIO'}

Lo cual equivale a hacer lo siguiente:

palabras = ["python", "carpincho", "diccionario"] 
diccionario_nuevo = {} 

for palabra in palabras: 
    diccionario_nuevo[palabra] = palabra.upper() 

print(diccionario_nuevo) # Salida: {'python': 'PYTHON', 'carpincho': 'CARPINCHO', 'diccionario': 'DICCIONARIO'}

Conjuntos (sets) por comprensión

Los conjuntos (o sets) son colecciones no ordenada de elementos únicos en Python que simulan a los conjuntos matemáticos. Suelen ser menos conocidos aunque son muy útiles ya que no admiten duplicados y permiten operaciones de conjuntos como la unión y la intersección.

Tienen su equivalente por comprensión y aunque la sintaxis es similar no hay que confundirla con la de los diccionarios ya que ambos utilizan llaves, pero los diccionarios tienen los dos puntos ( : ) separando la clave del valor como vimos en la sección anterior.

# Lista con números repetidos
numeros = [1, 2, 3, 4, 5, 3, 2, 1, 4, 5]

# Crear un conjunto vacío
mi_set = set()

# Usar un bucle para calcular los cuadrados de los números mayores a 2
for x in numeros:
    if x > 2:
        mi_set.add(x**2)  # Agregar el cuadrado al conjunto

print(mi_set)  # Salida: {9, 16, 25}

Ahora vamos a hacer lo mismo usando un conjunto por comprensión:

# Lista con números repetidos
numeros = [1, 2, 3, 4, 5, 3, 2, 1, 4, 5]

mi_set_por_comprension = {x**2 for x in numeros if x > 2}

print(mi_set_por_comprension) # Salida: {9, 16, 25}

Generadores por comprensión

Los generadores por comprensión en Python utilizan paréntesis () y son una forma compacta de crear un generador. Los generadores son un tipo especial de iterable que produce elementos uno a uno, en lugar de materializar toda la colección en memoria de inmediato. Veamos un ejemplo:

# Generador para los cuadrados de los números del 1 al 5
generador = (x**2 for x in range(1, 6))

# Los datos se producen de uno en uno y no se almacenan en memoria como ocurre con las listas.

for valor in generador:
    print(valor)

# Salida: 1
# Salida: 4
# Salida: 9
# Salida: 16
# Salida: 25

📝 Conclusiones

Para finalizar te dejo una tabla repasando la sintaxis de cada tipo de comprensión:

Las comprensiones pueden ser útiles para escribir código más “pythónico”, es decir, claro, conciso y mantenible aprovechando las funcionalidad del lenguaje y hasta podría, en ciertos casos, ser computacionalmente más eficiente. Ya sea que decidas usarlas en tu código o tengas que leer el código de otra persona es muy probable que te cruces con ellas, por lo cual espero que te sirva esta información.

¿Te interesa seguir aprendiendo más sobre Python?

Si este contenido te resultó útil y te interesa leer contenido sobre programación principalmente en Python, ciencia de datos e inteligencia artificial? Seguime en mis redes:

🐙 GitHub: https://github.com/GEJ1

📘 LinkedIn: Gustavo Juantorena

📹 YouTube: Gustavo Juantorena - Programación y Ciencia de Datos

Si te gustó el post, ¡Compartilo para que más personas puedan aprender!

Suscríbete ahora

Compartir

Deja un comentario

¿Qué hace especiales a los métodos mágicos?

Los métodos mágicos nos permiten definir cómo los objetos creados con nuestras clases deben comportarse ante operaciones y funciones comunes. Aunque rara vez invocamos estos métodos directamente, Python lo hace por nosotros. Por ejemplo:

• Cuando usamos len(objeto), en realidad se está invocando objeto.__len__().

• Si sumamos dos objetos, como a + b, Python realmente llama a a.__add__(b) (Nota: Acordate de este que al final lo vamos a retomar 😉).

Esto no solo hace que nuestros objetos sean más naturales de usar, sino que también nos permite crear comportamientos personalizados para operaciones específicas.

Ejemplos cotidianos: el poder de len y getitem

Los métodos mágicos como __len__ y __getitem__ son dos de los más conocidos, ya que permiten a nuestras clases comportarse como secuencias.

1. El método __len__: Este método es invocado por la función len(). Permite que nuestra clase pueda devolver su tamaño cuando usemos len(objeto)

2. El método __getitem__: Este método permite que nuestra clase sea "indexable". Al implementarlo, podemos acceder a sus elementos con la sintaxis de corchetes, como si fuera una lista o una tupla.

Veamos cómo estos métodos pueden aplicarse en un ejemplo sencillo con una clase que representa un grupo de carpinchos:

class CarpinchoGrupo:
    def __init__(self, carpinchos):
        self._carpinchos = carpinchos

    def __len__(self):
        contador = 0
        for carpincho in self._carpinchos:
            contador += 1
        return contador

    def __getitem__(self, index):
        return self._carpinchos[index]

# Crear un grupo de carpinchos
grupo = CarpinchoGrupo(['Capy1', 'Capy2', 'Capy3'])

print(len(grupo))  # 3
print(grupo[0])    # 'Capy1'

En este ejemplo:

• __len__: Permite que la función len() funcione con la instancia de CarpinchoGrupo, devolviendo el número de carpinchos en el grupo. Es importante notar que la maner más eficiente de implementar este método hubiera sido la siguiente:

  class CarpinchoGrupo:
      def __init__(self, carpinchos):
          self._carpinchos = carpinchos
  
      def __len__(self):
          return len(self._carpinchos)

  Sin embargo me parece importante mostrar que uno podría implementar el método de la manera que considere más conveniente.

• __getitem__: Permite que la clase sea indexada, como si fuera una lista. Así, podemos acceder a los carpinchos individuales con grupo[0].

Expandiendo el uso de métodos mágicos

Python ofrece una amplia variedad de métodos mágicos que pueden dotar a nuestras clases de comportamientos más complejos2. Algunos ejemplos adicionales son:

• __iter__: Para hacer que nuestros objetos sean iterables.

• __contains__: Nos permite usar el operador in para verificar si un elemento está dentro del objeto.

• __call__: Permite que una instancia de una clase se comporte como una función.

Si bien su implementación no siempre es necesaria, entender cómo funcionan y cómo utilizarlos puede elevar el nivel de nuestras clases, permitiendo un diseño más intuitivo y funcional.

¿Por qué son importantes?

Los métodos mágicos hacen que nuestras clases se sientan "naturales" dentro del ecosistema de Python. En lugar de crear clases que requieren métodos especializados para acceder o modificar datos, podemos hacer que se comporten como tipos nativos del lenguaje, simplificando tanto su uso como su comprensión.

¿Y qué me ibas a decir sobre a + b?

Para reforzar la idea de que cada implementación del método dunder podría tener un comportamiento diferente, esto pasa en Python algunas veces en función del tipo de dato que utilicemos. En el caso del operador “+”, si lo que tenemos a derecha e izquierda son números los va a sumar (2 + 3 devolverá 5), sin embargo si lo que tenemos son listas los va a concatenar ( [2] + [3] devolverá [2, 3]). Veamos un ejemplo con carpinchos que siempre hacen que se entiendan mejor las cosas:

class CarpinchoGrupo:
    def __init__(self, carpinchos):
        self._carpinchos = carpinchos

    def __add__(self, otro_grupo):
        # Combina los carpinchos de ambos grupos en una nueva lista
        return CarpinchoGrupo(self._carpinchos + otro_grupo._carpinchos)

    def __repr__(self):
        return f"CarpinchoGrupo({self._carpinchos})"

# Crear dos grupos de carpinchos
grupo1 = CarpinchoGrupo(['Capy1', 'Capy2'])
grupo2 = CarpinchoGrupo(['Capy3', 'Capy4'])

# Concatenar los dos grupos usando el operador "+"
grupo_combinado = grupo1 + grupo2

# Mostrar el grupo combinado
print(grupo_combinado) # CarpinchoGrupo(['Capy1', 'Capy2', 'Capy3', 'Capy4'])

En este caso el comportamiento del operador “+” para un objeto CarpinchoGrupo es similar al que tiene Python con las listas, pero distinto al que tiene con los números.

Conclusión

Los métodos mágicos son una poderosa herramienta que nos proporciona Python para definir comportamientos personalizados en nuestras clases. Lejos de ser complicados, son simplemente métodos que Python llama automáticamente en segundo plano para realizar tareas cotidianas, como obtener la longitud de un objeto o iterar sobre él. La idea de este breve poste es que no te asustes si te encontras con esas palabras con muchos guiones bajos, sino que te familiriaces con esta poderosa herramienta que te va a ayudar a escribir código más limpio.

¿Te interesa seguir aprendiendo más sobre Python?

Si este contenido te resultó útil y te interesa leer contenido sobre programación principalmente en Python, ciencia de datos e inteligencia artificial? Seguime en en mis redes:

🐙 Github: https://github.com/GEJ1

📘 LinkedIn: Gustavo Juantorena

📹 YouTube: Gustavo Juantorena - Programación y Ciencia de Datos

Si te gustó el post, ¡Compartilo para que más personas puedan aprender!

Compartir

Deja un comentario

Compartir El Substack de Gustavo

Suscríbete ahora