English English French French Spanish Spanish German German
Geekflare cuenta con el apoyo de nuestra audiencia. Podemos ganar comisiones de afiliados comprando enlaces en este sitio.
Comparte en:

Conjuntos en Python: una guía completa con ejemplos de código

Conjuntos de Python
Escáner de seguridad de aplicaciones web Invicti – la única solución que ofrece verificación automática de vulnerabilidades con Proof-Based Scanning™.

En este tutorial, aprenderá los conceptos básicos de Conjuntos de Python y los diversos métodos de conjuntos que puede usar para modificar conjuntos de Python. 

Los conjuntos son una de las estructuras de datos integradas en Python. Cuando necesite trabajar con una colección de elementos que no se repiten, utilizará el conjunto como la estructura de datos de acceso.

En las siguientes secciones, repasaremos los conceptos básicos de los conjuntos de python y los métodos de conjunto que puede usar para trabajar con ellos. Luego aprenderemos cómo realizar operaciones de conjuntos comunes en Python.

Vamos a empezar!

Basics of Python Sets

En Python, un conjunto es una colección desordenada de elementos que no se repiten. Esto significa que todos los elementos de un conjunto deben ser distinto.

Puede agregar y eliminar elementos de un conjunto; por lo tanto, el conjunto es un colección mutable. Puede contener elementos de diferentes tipos de datos. Sin embargo, los elementos individuales de un conjunto deben ser mezclable.

En Python, se dice que un objeto es hashable si su valor hash nunca cambia. La mayoría de los objetos inmutables como cadenas de pitón, tuplas y diccionarios son hash.

Aprenderemos a crear conjuntos en detalle. Por ahora, considere los siguientes dos conjuntos:

py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}

TypeError: unhashable type: 'list'

El primer conjunto contiene tres números, una tupla y una cadena. La inicialización del conjunto se ejecuta sin errores. Mientras que el segundo conjunto contiene una lista en lugar de una tupla. Una lista es una colección mutable, no se puede codificar y la inicialización arroja un TypeError.

📑 Poniéndolo todo junto, podemos definir un conjunto de Python como un mudable colección de distinto y mezclable elementos.

How to Create a Python Set

Comenzaremos aprendiendo cómo crear un conjunto en Python. 

#1. Uso de inicialización explícita

Puede crear un conjunto en Python especificando los elementos del conjunto, separados por comas (,) y encerrado entre un par de llaves {}.

py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)

# Output
set

Si has trabajado con Listas de Python antes, lo sabes [] inicializa una lista vacía. Aunque un conjunto de Python está encerrado entre un par de llaves {}, Que no puede usa un par {} para inicializar un conjunto. Esto es porque {} it inicializa un Diccionario de Python y no un conjunto de Python.

py_set2 = {}
type(py_set2)

# Output
dict

Puede volver a llamar al type() función para verificar que py_set es un diccionario (dict).

#2. Usando la función set()

Si desea inicializar un conjunto vacío y luego agregarle elementos, puede hacerlo usando el set() función.

py_set3 = set()
type(py_set3)

# Output
set

#3. Conversión de otros iterables en un conjunto

Otra forma de crear conjuntos es convertir otros iterables, como listas y tuplas, en conjuntos, usando set(iterable).

py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set

En el ejemplo anterior, py_list contiene 'C' dos veces. Pero en py_set4, 'C' aparece solo una vez, ya que el conjunto es una colección de elementos distintos. Esta técnica de fundición en el conjunto se utiliza a menudo para eliminar duplicados de las listas de Python.

How to Add Elements to a Python Set

Comencemos por crear un conjunto vacío. py_set y trabaje con él durante el resto de este tutorial.

py_set = set()
len(py_set) # returns the length of a set
# Output
0

#1. Usando el método .add()

Para agregar elementos a un conjunto, puede usar el .add() método. set.add(element) añade elemento al conjunto.

Para mayor claridad, agregaremos elementos al conjunto de Python e imprimiremos el conjunto en cada paso.

▶️ Agreguemos la cadena 'Python' como un elemento para py_set.

py_set.add('Python')
print(py_set)

# Output
{'Python'}

A continuación, añadiremos otro elemento.

py_set.add('C++')
print(py_set)

# Output
{'Python', 'C++'}

Es importante comprender que el .add() El método solo agrega un elemento al conjunto si aún no está presente. Si el conjunto ya contiene el elemento que desea agregar, la operación de agregar no tiene efecto.

Para verificar esto, intentemos agregar 'C++' a py_set.

py_set.add('C++')
print(py_set)

# Output
{'Python', 'C++'}

El conjunto contiene 'C++', por lo que la operación de agregar no tiene efecto.

▶️ Agreguemos algunos elementos más al conjunto.

py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)

# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}

#2. Usando el método .update()

Hasta ahora, hemos visto cómo agregar elementos al conjunto existente, un elemento a la vez.

¿Qué sucede si desea agregar más de un elemento a una secuencia de elementos?

Puede hacerlo utilizando el .update() método con la sintaxis: set.update(collection) para agregar elementos en collection a un conjunto los collection puede ser una lista, una tupla, un diccionario, etc.

py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)

# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}

Este método es útil cuando desea agregar una colección de elementos a un conjunto sin crear otro objeto en la memoria.

 En la siguiente sección, aprenderemos cómo eliminar elementos de un conjunto.

Remove Elements from a Python Set

Consideremos el siguiente conjunto (py_set antes de la operación de actualización).

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

#1. Usando el método .pop()

set.pop() elimina un elemento aleatoriamente del conjunto y lo devuelve. Llamemos al método pop en py_set y mira lo que devuelve.

py_set.pop()

# Output
'Rust'

Esta vez, la llamada a .pop()  El método devolvió la cadena 'Rust'.

Nota:: Porque el .pop() método devuelve un elemento al azar, cuando ejecuta el código en su extremo, también podría obtener otro elemento.

Cuando examinamos el conjunto, 'Rust' ya no está presente en el conjunto.

print(py_set)

# Output
{'JavaScript', 'Python', 'C++', 'C'}

#2. Uso de los métodos .remove() y descarte()

En la práctica, es posible que desee eliminar elementos específicos del conjunto. Para ello, puede utilizar el .remove() y .discard() métodos.

set.remove(element) elimina elementos del conjunto.

py_set.remove('C')
print(py_set)

# Output
{'JavaScript', 'Python', 'C++'}

Si intentamos eliminar un elemento que no está presente en el conjunto, nos encontraremos con un KeyError.

py_set.remove('Scala')

# Output
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')

KeyError: 'Scala'

Echemos un vistazo a py_set de nuevo Ahora tenemos tres elementos.

print(py_set)

# Output
{'JavaScript', 'Python', 'C++'}

con la sintaxis set.discard(element), la .discard() El método también elimina elementos del conjunto.

py_set.discard('C++')
print(py_set)

# Output
{'JavaScript', 'Python'}

Sin embargo, se diferencia del .remove() método en que lo hace no levantar un KeyError cuando intentamos eliminar un elemento que no está presente. 

Si tratamos de eliminar 'Scala' (que no existe) de la lista usando el .discard() método, no vemos ningún error.

py_set.discard('Scala') #no error!
print(py_set)

# Output
{'JavaScript', 'Python'}

Access Elements of a Python Set

Hasta ahora, hemos aprendido cómo agregar y quitar elementos de los conjuntos de Python. Sin embargo, aún no hemos visto cómo acceder a elementos individuales en un conjunto.

Como un conjunto es una colección desordenada, no es indexable. Por lo tanto, si intenta acceder a los elementos de un conjunto utilizando el índice, se encontrará con un error, como se muestra.

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

print(py_set[0])

# Output
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])

TypeError: 'set' object is not subscriptable

Entonces, ¿cómo se accede a los elementos de un conjunto?

Hay dos formas comunes de hacer esto:

  • Recorra el conjunto y acceda a cada elemento 
  • Comprobar si un elemento en particular es miembro del conjunto

▶️ Recorra el set y acceda a los elementos usando un for lazo.

for elt in py_set:
  print(elt)

# Output
C++
JavaScript
Python
Rust
C

En la práctica, puede querer verificar si un elemento dado está presente en el conjunto usando el in operador.

Nota:: elementos in planificadas devoluciones True si el elemento está presente en el conjunto; de lo contrario vuelve False.

En este ejemplo, py_set contiene 'C++' y no contiene 'Julia' y el in el operador regresa True y False, respectivamente.

'C++' in py_set
# True
'Julia' in py_set
# False

Find the Length of a Python Set

Como se vio anteriormente, puede usar el len() función para obtener el número de elementos presentes en un conjunto.

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)

# Output: 5

How to Clear a Python Set

Para borrar un conjunto eliminando todos los elementos, puede usar el .clear() método.

Llamemos al .clear() método en py_set

py_set.clear()

Si intenta imprimirlo, obtendrá set() – indicando que el conjunto está vacío. También puede llamar al len() para verificar que la longitud del conjunto es cero.

print(py_set)
# set()
print(len(py_set))
# 0

Hasta ahora, hemos aprendido cómo realizar funciones básicas CRUD operaciones en conjuntos de Python:

  • Crea: Utilizando set() función, conversión de tipos e inicialización
  • Lee: Acceder a elementos del conjunto mediante bucles y in operador para pruebas de pertenencia
  • Noticias: Agregar, eliminar elementos de conjuntos y actualizar conjuntos
  • Borrar: borre un conjunto eliminando todos los elementos de él

Common Set Operations, Explained with Python Code

Los conjuntos de Python también nos permiten realizar las operaciones básicas de conjuntos. Aprenderemos sobre ellos en esta sección.

#1. Unión de Conjuntos

En la teoría de conjuntos, la unión de dos conjuntos es el conjunto de todos los elementos en al menos uno de los dos conjuntos. Si hay dos conjuntos, A y B, entonces la unión contiene elementos que están presentes solo en A, solo en B, y los elementos presentes tanto en A como en B.

Para encontrar la unión de conjuntos, puedes usar el | operador o el .union() el método con la sintaxis: setA.union(setB).

setA = {1,3,5,7,9}
setB = {2,4,6,8,9}

print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

setA.union(setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

La unión de conjuntos es una operación conmutativa; entonces AUB es lo mismo que BU A. Verifiquemos esto intercambiando las posiciones de setA y setB en el capítulo respecto a la .union() llamada al método.

setB.union(setA)

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

#2. Intersección de Conjuntos

Otra operación conjunta de conjuntos es esta intersección de dos conjuntos, A y B. La operación de intersección de conjuntos devuelve un conjunto que contiene todos los elementos presentes tanto en A como en B.

Para calcular la intersección, puede usar el & operador o el .intersection() método, como se explica en el fragmento de código a continuación.

print(setA & setB)

# Output
{9}

setA.intersection(setB)

# Output
{9}

En este ejemplo, el elemento 9 está presente tanto en setA como en setB; por lo que el conjunto de intersección contiene solo este elemento.

Al igual que la unión de conjuntos, la intersección de conjuntos también es una operación conmutativa.

setB.intersection(setA)

# Output
{9}

#3. Establecer diferencia

Dados dos conjuntos cualesquiera, la unión y la intersección nos ayudan a encontrar los elementos presentes en ambos y al menos en uno de los conjuntos, respectivamente. Por otra parte, establecer diferencia nos ayuda a encontrar los elementos presentes en un conjunto pero no en el otro.

python-set-diferencia

setA.difference(setB) da el conjunto de elementos que están presentes sólo en setA y no en setB.

setB.difference(setA) da el conjunto de elementos que están presentes sólo en setB y no en setA.

print(setA - setB)

print(setB - setA)

# Output
{1, 3, 5, 7}
{8, 2, 4, 6}

Claramente, A\B no es lo mismo que B\A, por lo que la diferencia de conjuntos no es una operación conmutativa.

setA.difference(setB)
# {1, 3, 5, 7}

setB.difference(setA)
# {2, 4, 6, 8}

#4. Diferencia de conjuntos simétricos

Aunque la establecer intersección nos da elementos presentes en ambas conjuntos, el diferencia de conjuntos simétricos devuelve el conjunto de elementos presentes en exactamente uno de los conjuntos.

Considere el siguiente ejemplo.

setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}

Para calcular el conjunto de diferencias simétricas, puede usar el ^ operador o el .symmetric_difference() método.

print(setA ^ setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

Los elementos 10 y 12 están presentes en ambos setA y setB. Por lo tanto, no están presentes en el conjunto de diferencias simétricas.

setA.symmetric_difference(setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

Como la operación de diferencia de conjuntos simétrica recopila todos los elementos que aparecen exactamente en uno de los dos conjuntos, el conjunto resultante es el mismo independientemente del orden en que se recopilan los elementos. Por lo tanto, una diferencia de conjunto simétrica es una operación conmutativa.

setB.symmetric_difference(setA)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

#5. Subconjuntos y Superconjuntos

En la teoría de conjuntos, los subconjuntos y superconjuntos ayudan a comprender la relación entre dos conjuntos. 

Dados dos conjuntos A y B, el conjunto B es un subconjunto del conjunto A si todos los elementos del conjunto B también están presentes en el conjunto A. Y el conjunto A es el superconjunto del conjunto B.

Considere el ejemplo de dos conjuntos: languages y languages_extended.

languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}

En Python, puede usar el .issubset() método para comprobar si un conjunto dado es un subconjunto de otro conjunto.

setA.issubset(setB) devoluciones True if setA es un subconjunto de setB; de lo contrario, vuelve False.

En este ejemplo, languages es un subconjunto de languages_extended.

languages.issubset(languages_extended)
# Output
True

Del mismo modo, puede usar el .issuperset() método para verificar si un conjunto dado es un superconjunto de otro conjunto.

setA.issuperset(setB) devoluciones True if setA es un superconjunto de setB; de lo contrario, vuelve False.

languages_extended.issuperset(languages)
# Output
True

As languages_extended es un superconjunto de idiomas, languages_extended.issuperset(languages) devoluciones True, como se ve arriba.

Conclusión

Espero que este tutorial lo haya ayudado a comprender el funcionamiento de los conjuntos de Python, los métodos establecidos para las operaciones CRUD y las operaciones comunes de conjuntos. Como siguiente paso, puede intentar usarlos en su Proyectos de Python.

Puedes consultar otros en profundidad Guías de Python. ¡Feliz aprendizaje!

Gracias a nuestros patrocinadores
Más lecturas interesantes sobre el desarrollo
Impulse su negocio
Algunas de las herramientas y servicios para ayudar a que su negocio crezca.
  • Invicti utiliza Proof-Based Scanning™ para verificar automáticamente las vulnerabilidades identificadas y generar resultados procesables en cuestión de horas.
    Prueba Invicti
  • Web scraping, proxy residencial, administrador de proxy, desbloqueador web, rastreador de motores de búsqueda y todo lo que necesita para recopilar datos web.
    Prueba Brightdata
  • Semrush es una solución de marketing digital todo en uno con más de 50 herramientas en SEO, redes sociales y marketing de contenido.
    Prueba Semrush
  • Intruder es un escáner de vulnerabilidades en línea que encuentra debilidades de ciberseguridad en su infraestructura, para evitar costosas filtraciones de datos.
    Trata Intruder