# Set En Python
**Source:** https://fr.cursos.frogamesformacion.com/pages/blog/set-en-python
**Language:** French

---

![Set en Python, Elimina Automáticamente tus Archivos Duplicados](https://dropinblog.net/cdn-cgi/image/fit=scale-down,format=auto,width=700/34249715/files/portada-post/set-en-python-elimina-automaticamente-tus-archivos-duplicados.png)

# Set en Python, Elimina Automáticamente tus Archivos Duplicados

*![Juan Gabriel Gomila](https://dropinblog.net/cdn-cgi/image/fit=scale-down,width=100/34249715/authors/jb.JPG)*

Juan Gabriel Gomila 

Funcionalidades

  

20/10/2024 5:35pm

11 minutos

Leer el artículo

Audio generated by DropInBlog's Blog Voice AI™ may have slight pronunciation nuances. Learn more

> **En la entrada de hoy aprenderemos qué es un set en Python, las operaciones más habituales y sus aplicaciones avanzadas. Una lectura indispensable para sacarle el máximo partido a este lenguaje.**

Si programas con Python es necesario que conozcas los sets, una estructura de datos poderosa y eficiente que a menudo pasa desapercibida frente a opciones más populares como listas o diccionarios. Sin embargo, los sets ofrecen características únicas que los hacen ideales para ciertos tipos de operaciones. Especialmente cuando se trabaja con **grandes volúmenes de datos que requieren verificación de duplicados** o en operaciones matemáticas como la intersección y la unión.

Un set en Python es una colección ordenada y mutable que permite elementos duplicados. Esto significa que, a diferencia de las listas los elementos de un set son únicos, lo que**elimina la redundancia automáticamente**. Además, la naturaleza ordenada de los sets permite una manipulación más eficiente en muchas situaciones, especialmente cuando se trata de buscar o comparar elementos.

Los sets también son conocidos por su flexibilidad al realizar operaciones matemáticas comunes, como la unión, la intersección y la diferencia, lo que los convierte en una herramienta valiosa en **algoritmos de búsqueda, análisis de datos y resolución de problemas complejos**. Si te ha despertado la curiosidad, en este artículo aprenderás qué son los sets, cómo crearlos, sus operaciones principales y casos avanzados donde pueden marcar la diferencia en tu código Python.

## Definición y Creación de un Set en Python

### a) ¿Qué es un Set en Python?

Un set en Python es una colección desordenada de elementos únicos. A diferencia de otros tipos de colecciones como listas o tuplas, un set permite duplicados. Lo que significa que**cualquier intento de agregar un elemento ya existente simplemente será ignorado**. Esto lo convierte en una herramienta valiosa cuando se necesita garantizar la unicidad de los datos.

Los sets también son mutables, lo que significa que **sus elementos pueden ser modificados después de su creación**. Sin embargo, los elementos dentro del set deben ser inmutables, lo que significa que puedes tener listas o diccionarios como elementos de un set. Pero sí puedes tener tuplas o números.

### b) Sintaxis Básica para Crear un Set en Python

Crear un set en Python es bastante sencillo. Se pueden usar llaves {} o la función set() para definirlos:

```
# Crear un set vacío
mi_set = set()


# Crear un set con elementos
mi_set = {1, 2, 3, 4}
```

Es importante destacar que cuando se usa un **par de llaves vacío {}**, Python lo interpreta como un diccionario. Por lo que siempre debes usar set() para crear sets vacíos.

### c) Características Principales de los Sets

- **Desordenados**: Los sets mantienen ningún tipo de orden en los elementos. A diferencia de las listas o tuplas, los elementos en un set pueden aparecer en cualquier orden y se puede acceder a ellos mediante índices.
- **Sin Duplicados**: Una característica clave de los sets es que permiten duplicados. Si intentas agregar un elemento que ya existe en el set, Python simplemente lo ignorará:

```
mi_set = {1, 2, 3, 3, 4}
print(mi_set)  # Resultado: {1, 2, 3, 4}
```

### d) Ejemplos de Creación de Sets

Puedes crear sets a partir de diferentes tipos de colecciones como **listas o cadenas**. Aquí algunos ejemplos:

```
# Crear un set desde una lista
mi_lista = [1, 2, 2, 3, 4]
mi_set = set(mi_lista)  # Resultado: {1, 2, 3, 4}


# Crear un set desde una cadena
mi_set = set("hola")  # Resultado: {'h', 'o', 'l', 'a'}
```

En definitiva, los sets son extremadamente útiles para eliminar duplicados automáticamente y para **manejar grandes conjuntos de datos** de manera eficiente.

## Operaciones Comunes con un Set en Python

### a) Adición de Elementos

Una de las operaciones más básicas con un set en Python  es la adición de elementos. Esto se puede hacer utilizando el **método add()**, que inserta un nuevo elemento en el set. Como los sets permiten duplicados, si intentas añadir un elemento que ya existe este será ignorado.

```
mi_set = {1, 2, 3}
mi_set.add(4)
print(mi_set)  # Resultado: {1, 2, 3, 4}
```

### b) Eliminación de Elementos

Python ofrece varias formas de eliminar elementos de un set. Entre las más comunes están **remove() y discard()**. La diferencia clave entre ambas es que remove() genera un error si el elemento está en el set, mientras que discard() lo hace.

```
mi_set = {1, 2, 3, 4}
mi_set.remove(3)
print(mi_set)  # Resultado: {1, 2, 4}


mi_set.discard(5)  # No genera error si el elemento existe
```

También puedes utilizar el método **pop()** para eliminar y devolver un elemento arbitrario del set, ya que los sets tienen un orden predecible:

```
mi_set = {1, 2, 3, 4}
elemento_eliminado = mi_set.pop()
print(elemento_eliminado)  # Resultado: 1 (o cualquier otro elemento)
```

### c) Verificación de Pertenencia

Para comprobar si un elemento pertenece a un set en Python se usa el **operador in**. Esta operación es muy rápida en sets, lo que los convierte en una excelente opción cuando se requiere verificar la pertenencia de un elemento en grandes colecciones de datos.

```
mi_set = {1, 2, 3, 4}
print(2 in mi_set)  # Resultado: True
print(5 in mi_set)  # Resultado: False
```

### d) Longitud del Set

Para saber cuántos elementos contiene un set puedes usar la **función len()**, que devuelve el número de elementos únicos en el set.

```
mi_set = {1, 2, 3, 4}
print(len(mi_set))  # Resultado: 4
```

Estas operaciones básicas son fundamentales para trabajar con sets en Python. Gracias a su eficiencia en la **adición, eliminación y verificación de pertenencia**, los sets son una estructura de datos ideal para manejar grandes cantidades de información sin duplicados.

## Operaciones Matemáticas en Sets

Una de las características más útiles de los sets en Python es la capacidad de realizar operaciones matemáticas similares a las que se realizan con conjuntos en matemáticas. Que permiten **comparar, combinar o restar sets** de forma sencilla y eficiente.

### a) Unión de Sets

La operación de unión combina los elementos de dos sets, eliminando duplicados. En Python puedes usar el **método union() o el operador |** para realizar esta operación.

```
set_a = {1, 2, 3}
set_b = {3, 4, 5}
union_set = set_a.union(set_b)
# Resultado: {1, 2, 3, 4, 5}


# También se puede usar el operador |
union_set = set_a | set_b
# Resultado: {1, 2, 3, 4, 5}
```

### b) Intersección de Sets

La intersección de dos sets devuelve los elementos que están presentes en ambos. Para ello puedes usar el **método intersection() o el operador &**.

```
set_a = {1, 2, 3}
set_b = {3, 4, 5}
interseccion_set = set_a.intersection(set_b)
# Resultado: {3}


# Usando el operador &
interseccion_set = set_a & set_b
# Resultado: {3}
```

### c) Diferencia de Sets

La operación de diferencia devuelve los elementos que están en un set pero en el otro. Puedes usar el**método difference() o el operador -** para obtener la diferencia entre dos sets.

```
set_a = {1, 2, 3}
set_b = {3, 4, 5}
diferencia_set = set_a.difference(set_b)
# Resultado: {1, 2}


# Usando el operador -
diferencia_set = set_a - set_b
# Resultado: {1, 2}
```

### d) Diferencia Simétrica

La diferencia simétrica devuelve los elementos que están en uu otro set, pero en ambos. En Python puedes realizar esta operación usando el **método symmetric\_difference() o el operador ^**.

```
set_a = {1, 2, 3}
set_b = {3, 4, 5}
diferencia_simetrica_set = set_a.symmetric_difference(set_b)
# Resultado: {1, 2, 4, 5}


# Usando el operador ^
diferencia_simetrica_set = set_a ^ set_b
# Resultado: {1, 2, 4, 5}
```

### e) Aplicaciones Prácticas

Estas operaciones son útiles en una amplia gama de escenarios, como la manipulación de grandes volúmenes de datos,**filtrado de elementos y la comparación de colecciones**. Por ejemplo, la intersección puede ser utilizada para encontrar elementos comunes entre dos listas grandes. Mientras que la diferencia simétrica es útil para identificar cambios entre conjuntos de datos.

## Aplicaciones Avanzadas de Sets

### a) Eliminación de Duplicados

Ude los usos más comunes de los sets es la eliminación de duplicados en colecciones de datos. Dado que un set permite elementos repetidos, **simplemente convertir una lista a set** eliminará cualquier duplicado de forma automática.

```
mi_lista = [1, 2, 2, 3, 4, 4, 5]
mi_set = set(mi_lista)
print(mi_set)  # Resultado: {1, 2, 3, 4, 5}
```

Este proceso es mucho **más eficiente que recorrer manualmente una lista**y eliminar duplicados, lo que hace que los sets sean ideales cuando se trabaja con grandes volúmenes de datos.

### b) Uso en Algoritmos de Búsqueda

Los sets son extremadamente eficientes en operaciones de búsqueda, ya que utilizan una implementación basada en tablas hash que permite**acceder a los elementos en tiempo constante**. Es decir, O(1). Esto los hace útiles en algoritmos que requieren verificar la pertenencia de un elemento rápidamente.

Por ejemplo, si necesitas saber si **un elemento está en una gran colección de datos**, usar un set es mucho más rápido que usar una lista o tupla.

```
mi_set = {1, 2, 3, 4, 5}
print(3 in mi_set)  # Resultado: True
print(6 in mi_set)  # Resultado: False
```

### c) Comparación de Conjuntos de Datos

Los sets también son útiles en la comparación de grandes conjuntos de datos. Por ejemplo, si tienes dos listas de usuarios y necesitas encontrar los usuarios comunes o aquellos que solo están en una de las listas, las operaciones de **intersección y diferencia de sets** son ideales para esta tarea.

```
usuarios_a = {"Alice", "Bob", "Charlie"}
usuarios_b = {"Charlie", "David", "Emma"}


# Usuarios comunes
comunes = usuarios_a & usuarios_b  # Resultado: {"Charlie"}


# Usuarios exclusivos de la lista A
solo_a = usuarios_a - usuarios_b  # Resultado: {"Alice", "Bob"}
```

### d) Optimización de Memoria y Rendimiento

Debido a su estructura interna, un set en Python  es más eficiente en términos de memoria y rendimiento en comparación con otros tipos de colecciones. Sobre todo cuando el objetivo es **almacenar elementos únicos**. Esto es especialmente útil en grandes bases de datos o sistemas donde la eliminación de duplicados y la rapidez en la búsqueda son críticas.

Como ves, los sets ofrecen un **equilibrio perfecto entre simplicidad y eficiencia**, siendo una herramienta fundamental en situaciones donde el manejo de grandes volúmenes de datos o la necesidad de optimizar el rendimiento son clave.

## Tu Futuro Comienza Hoy con Frogames

Ahora que conoces los fundamentos de los sets en Python y has explorado sus aplicaciones, estás **un paso más cerca de dominar este potente lenguaje de programación**. Sin embargo, aprender a programar va mucho más allá de un elemento en concreto. Debes tener una base sólida que te permita abordar cualquier reto de desarrollo.

### Aprende Programación Sin Pisar la Universidad

Para seguir profundizando en Python y en otros lenguajes clave te animamos a apuntarte a la Parcours des Langages de Programmation  de Frogames, la **academia online líder dirigida por Juan Gabriel Gomila**. Diseñada para ofrecerte más de 130 horas de vídeo, +1140 clases y recursos adicionales, te resultará muy sencillo aprender Python y otros lenguajes esenciales como Java y SQL.

La ruta está pensada para que puedas empezar desde lo más básico y avanzar hacia un nivel experto en un año, **dedicando solo 20 horas a la semana**. Además, recibirás certificados al completar cada curso y tendrás acceso a una comunidad exclusiva para resolver tus dudas en tiempo real.

Frogames también ofrece cursos en áreas como**blockchain, matemáticas, machine learning y análisis de datos**, lo que te permitirá convertirte en un programador versátil y completo.

No dejes pasar esta oportunidad para dominar la programación y **acceder a un sinfín de oportunidades profesionales.** ¡Apúntate hoy mismo y empieza tu camihacia el éxito con Frogames!

¡Nos vemos en clase!

Please enable JavaScript to view the comments powered by Disqus.

« Volver al Blog

## Artículos relacionados

![Constructores en Java, Definición, Funciones, Tipos y Buenas Prácticas](https://dropinblog.net/cdn-cgi/image/fit=scale-down,format=auto,width=700/34249715/files/portada-post/constructores-en-java-definicion-funciones-tipos-y-buenas-practicas.png)

## Constructores en Java, Definición, Funciones, Tipos y Buenas Prácticas

12 minutos

18/10/2024 5:15pm

![Comentarios en JavaScript, Tipos, Mejores Prácticas y Resolución de Errores](https://dropinblog.net/cdn-cgi/image/fit=scale-down,format=auto,width=700/34249715/files/portada-post/comentarios-en-javascript-tipos-mejores-practicas-y-resolucion-de-errores.png)

## Comentarios en JavaScript, Tipos, Mejores Prácticas y Resolución de Errores

11 minutos

23/10/2024 1:10pm

![El Comando DELETE en SQL, Obtén el Máximo Control para Eliminar Datos](https://dropinblog.net/cdn-cgi/image/fit=scale-down,format=auto,width=700/34249715/files/portada-post/el-comando-delete-en-sql-obten-el-maximo-control-para-eliminar-datos.png)

## El Comando DELETE en SQL, Obtén el Máximo Control para Eliminar Datos

11 minutos

14/10/2024 9:00am

CURSO DE REGALO

## Un Curso Gratis Para Ti

Nuestro curso de Unity te sale **Gratuit** .

Aprende a crear tu primer videojuego con el motor de Unity en un curso de
más de 15h de vídeo.

Obtener el curso ahora