Guía de conjuntos en Python

En Python, un conjunto es una estructura de datos que almacena elementos desordenados. Los elementos establecidos tampoco están indexados. Al igual que una lista, un conjunto permite la adición y eliminación de elementos...

Introducción

En Python, un conjunto es una estructura de datos que almacena elementos desordenados. Los elementos establecidos también están sin indexar. Al igual que una lista, un conjunto permite la adición y eliminación de elementos. Sin embargo, hay algunas características únicas que definen un conjunto y lo separan de otras estructuras de datos:

  • Un conjunto no contiene elementos duplicados
  • Los elementos del conjunto son inmutables, es decir, no se pueden cambiar, pero el conjunto en sí es mutable, es decir, se puede cambiar
  • Dado que los elementos del conjunto no están indexados, los conjuntos no admiten ninguna operación de división o indexación.

En esta guía, veremos cómo crear y usar conjuntos en Python, junto con algunas de las operaciones comunes que ejecutaría contra ellos.

Cómo crear un conjunto en Python

Un conjunto puede contener cualquier cantidad de elementos y los elementos pueden ser de diferentes tipos (colección heterogénea) como números enteros, cadenas, tuplas, etc.

{.icon aria-hidden=“true”}

Nota: Un conjunto no acepta elementos mutables, como listas y diccionarios.

Podemos crear un conjunto pasando todos los elementos del conjunto dentro de llaves {} y separando los elementos usando comas (,):

1
2
num_set = {1, 2, 3, 4, 5, 6}
print(num_set)

Esto dará como resultado:

1
{1, 2, 3, 4, 5, 6}

Acabamos de crear un conjunto de números. También podemos crear un conjunto de valores de cadena:

1
2
string_set = {"Nicholas", "Michelle", "John", "Mercy"}
print(string_set)

Resultando en:

1
{'Michelle', 'Nicholas', 'John', 'Mercy'}

{.icon aria-hidden=“true”}

Nota: Observe cómo los elementos en la salida no están ordenados de la misma manera que los agregamos al conjunto. La razón de esto es que los artículos establecidos no están ordenados. Si vuelve a ejecutar el mismo código, es probable que obtenga una salida con los elementos dispuestos en un orden diferente.

También podemos crear un conjunto con elementos de diferentes tipos:

1
2
mixed_set = {2.0, "Nicholas", (1, 2, 3)}
print(mixed_set)

Verifiquemos que esto produzca un conjunto válido:

1
{2.0, 'Nicholas', (1, 2, 3)}

Todos los elementos del conjunto anterior pertenecen a diferentes tipos. También podemos crear un conjunto a partir de una lista. Esto se puede hacer llamando al método set() integrado de Python:

1
2
num_set = set([1, 2, 3, 4, 5, 6])
print(num_set)

Esto resulta en:

1
{1, 2, 3, 4, 5, 6}

Como se indicó anteriormente, los conjuntos no contienen elementos duplicados. Supongamos que nuestra lista tiene elementos duplicados:

1
2
num_set = set([1, 2, 3, 1, 2])
print(num_set)

El conjunto almacenará solo valores únicos de la lista:

1
{1, 2, 3}

El conjunto esencialmente eliminó los duplicados y devolvió solo uno de cada elemento duplicado. Esto también sucede cuando estamos creando un conjunto desde cero:

1
2
num_set = {1, 2, 3, 1, 2}
print(num_set)

Nuevamente, el conjunto eliminó los duplicados y devolvió solo uno de los elementos duplicados:

1
{1, 2, 3}

Si desea crear un conjunto vacío y usar llaves vacías ({}), creará un diccionario vacío en lugar de un conjunto vacío:

1
2
x = {}
print(type(x)) # <class 'dict'>

Para crear un conjunto vacío en Python simplemente llamamos al método set() sin pasar ningún valor:

1
2
x = set()
print(type(x)) # <class 'set'>

Cómo acceder a los elementos del conjunto en Python

Python no nos proporciona una forma de acceder a un elemento de conjunto individual mediante la notación de subíndice (conjunto[índice]). Sin embargo, podemos usar un ciclo for para iterar a través de todos los elementos de un conjunto:

1
2
3
4
months = set(["Jan", "Feb", "March", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"])

for m in months:
    print(m)

Esto imprimirá cada elemento en un conjunto de meses:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
March
Feb
Dec
Jan
May
Nov
Oct
Apr
June
Aug
Sep
July

También podemos verificar la presencia de un elemento en un conjunto usando la palabra clave in:

1
2
3
months = set(["Jan", "Feb", "March", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"])

print("May" in months)

Dado que ‘Mayo’ está presente en el conjunto de ‘meses’, esto devolverá ‘Verdadero’:

1
True

De manera similar, la búsqueda de un elemento que no existe en el conjunto devuelve Falso:

1
2
3
months = set(["Jan", "Feb", "March", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"])

print("Nicholas" in months)

Esto dará como resultado:

1
False

Cómo agregar elementos a un conjunto de Python

Python nos permite agregar nuevos elementos a un conjunto usando el método add():

1
2
3
4
months = set(["Jan", "March", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"])

months.add("Feb")
print(months)

El elemento Feb se agregará con éxito al conjunto:

1
{'Oct', 'Dec', 'Feb', 'July', 'May', 'Jan', 'June', 'March', 'Sep', 'Aug', 'Nov', 'Apr'}

Si fuera un conjunto de números, no habríamos pasado el nuevo elemento entre comillas como tuvimos que hacer para una cadena:

1
2
3
num_set = {1, 2, 3}
num_set.add(4)
print(num_set)

Lo que agregará 4 a num_set:

1
{1, 2, 3, 4}

En la siguiente sección, discutiremos cómo eliminar elementos de conjuntos.

Cómo eliminar elementos de un conjunto de Python

Python, naturalmente, nos permite eliminar un elemento de un conjunto, pero no podemos eliminarlo a través de un índice porque los elementos del conjunto no están indexados. Los elementos se pueden eliminar utilizando los métodos discard() o remove(), con una referencia a ese elemento específico.

{.icon aria-hidden=“true”}

Nota: Tenga en cuenta que el método discard() no generará un error si el elemento no se encuentra en el conjunto. Sin embargo, si se utiliza el método remove() y no se encuentra el elemento, se generará un error.

desechar()

Demostremos cómo eliminar un elemento usando el método discard():

1
2
3
num_set = {1, 2, 3, 4, 5, 6}
num_set.discard(3)
print(num_set)

El elemento 3 será eliminado del conjunto:

1
{1, 2, 4, 5, 6}

retirar()

De manera similar, el método remove() se puede usar de la siguiente manera:

1
2
3
num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(3)
print(num_set)

Esto producirá el mismo resultado:

1
{1, 2, 4, 5, 6}

¿Eliminar elementos inexistentes? {#eliminación de elementos inexistentes}

Ahora, intentemos eliminar un elemento que no existe en el conjunto. Primero usemos el método discard():

1
2
3
num_set = {1, 2, 3, 4, 5, 6}
num_set.discard(7)
print(num_set)

Ejecutar el código anterior no afectará el conjunto de ninguna manera:

1
{1, 2, 3, 4, 5, 6}

Ahora, veamos qué sucede cuando usamos el método remove() en el mismo escenario:

1
2
3
num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(7)
print(num_set)

En este caso, intentar eliminar un elemento que no existe generará un error:

1
2
3
4
Traceback (most recent call last):
  File "C:\Users\admin\sets.py", line 2, in <module>
    num_set.remove(7)
KeyError: 7

estallido()

Con el método pop(), podemos eliminar y devolver un elemento. Dado que los elementos están desordenados, no podemos decir ni predecir el elemento que se eliminará:

1
2
num_set = {1, 2, 3, 4, 5, 6}
print(num_set.pop())

Esto devolverá el elemento eliminado del conjunto:

1
1

Puede usar el mismo método para eliminar un elemento y devolver los elementos que quedan en el conjunto:

1
2
3
num_set = {1, 2, 3, 4, 5, 6}
num_set.pop()
print(num_set)

Que imprimirá los elementos restantes en el conjunto:

1
{2, 3, 4, 5, 6}

claro()

El método clear() de Python nos ayuda a eliminar todos los elementos de un conjunto:

1
2
3
num_set = {1, 2, 3, 4, 5, 6}
num_set.clear()
print(num_set)

La salida es un set() vacío sin elementos:

1
set()

Unión de conjuntos de Python

Supongamos que tenemos dos conjuntos, A y B. La unión de los dos conjuntos es un conjunto con todos los elementos de ambos conjuntos. Tal operación se logra usando el método union() de Python.

Por ejemplo, supongamos que tenemos dos conjuntos que contienen nombres de meses:

1
2
3
4
5
months_a = set(["Jan", "Feb", "March", "Apr", "May", "June"])
months_b = set(["July", "Aug", "Sep", "Oct", "Nov", "Dec"])

all_months = months_a.union(months_b)
print(all_months)

Después de ejecutar este código, el conjunto all_months contendrá la unión de los conjuntos months_a y months_b:

1
{'Oct', 'Jan', 'Nov', 'May', 'Aug', 'Feb', 'Sep', 'March', 'Apr', 'Dec', 'June', 'July'}

También se puede realizar una unión en más de dos conjuntos, y todos sus elementos se combinarán en un solo conjunto:

1
2
3
4
5
6
7
x = {1, 2, 3}
y = {4, 5, 6}
z = {7, 8, 9}

output = x.union(y, z)

print(output)

Esto dará como resultado:

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

Durante la operación de unión, se ignoran los duplicados y solo se muestra uno de los elementos duplicados:

1
2
3
4
5
6
7
x = {1, 2, 3}
y = {4, 3, 6}
z = {7, 4, 9}

output = x.union(y, z)

print(output)

Esto dará como resultado que el conjunto contenga solo valores únicos de los conjuntos iniciales:

1
{1, 2, 3, 4, 6, 7, 9}

El operador | también se puede usar para encontrar la unión de dos o más conjuntos:

1
2
3
4
months_a = set(["Jan","Feb", "March", "Apr", "May", "June"])
months_b = set(["July", "Aug", "Sep", "Oct", "Nov", "Dec"])

print(months_a | months_b)

Esto producirá el mismo resultado que usar el método unoion():

1
{'Feb', 'Apr', 'Sep', 'Dec', 'Nov', 'June', 'May', 'Oct', 'Jan', 'July', 'March', 'Aug'}

Si desea realizar una unión en más de dos conjuntos, separe los nombres de los conjuntos usando el operador |:

1
2
3
4
5
x = {1, 2, 3}
y = {4, 3, 6}
z = {7, 4, 9}

print(x | y | z)

Esto dará como resultado:

1
{1, 2, 3, 4, 6, 7, 9}

Intersección de conjuntos de Python

Suponga que tiene dos conjuntos, A y B. Su intersección es un conjunto con elementos que están presentes tanto en A como en B.

La operación de intersección en conjuntos se puede lograr usando el operador & o el método intersection():

1
2
3
4
x = {1, 2, 3}
y = {4, 3, 6}

print(x & y)

El único elemento común es 3:

1
{3}

Lo mismo también se puede lograr con el método intersection():

1
2
3
4
5
x = {1, 2, 3}
y = {4, 3, 6}

z = x.intersection(y)
print(z)

Esto también resultará en:

1
{3}

Diferencia entre conjuntos de Python {#difference betweenpythonsets}

Suponga que tiene dos conjuntos A y B. La diferencia entre A y B (A - B) es el conjunto con todos los elementos que están en A pero no en B. En consecuencia, (B - A) es el conjunto con todos los elementos en B pero no en A.

Para determinar las diferencias de conjunto en Python, podemos usar el método difference() o el operador -:

1
2
3
4
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
diff_set = set_a.difference(set_b)
print(diff_set)

El código anterior calcula la diferencia entre set_a y set_b, por lo que forman nuestra salida:

1
{1, 2, 3}

El operador menos (-) también se puede usar para encontrar la diferencia entre los dos conjuntos, como se muestra a continuación:

1
2
3
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
print(set_a - set_b)

Lo que dará como resultado el mismo resultado que usar el método difference():

1
{1, 2, 3}

La diferencia simétrica de los conjuntos A y B es el conjunto con todos los elementos que están en A y B excepto los elementos que son comunes en ambos conjuntos. Se determina usando el método symmetric_difference() de Python o el operador ^:

1
2
3
4
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
symm_diff = set_a.symmetric_difference(set_b)
print(symm_diff)

Esto dará como resultado:

1
{1, 2, 3, 6, 7, 8}

Como dijimos antes, la diferencia simétrica también se puede encontrar usando el operador ^:

1
2
3
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
print(set_a ^ set_b)

Lo que producirá el mismo resultado que antes:

1
{1, 2, 3, 6, 7, 8}

Comparación de conjuntos de Python

Podemos comparar conjuntos dependiendo de los elementos que tengan. De esta forma, podemos saber si un conjunto es un superconjunto o un subconjunto de otro conjunto. El resultado de tal comparación será “Verdadero” o “Falso”.

Para verificar si el conjunto A es un subconjunto del conjunto B, podemos usar la siguiente operación:

1
A <= B

Para verificar si B es un superconjunto de A, podemos usar la siguiente operación:

1
B >= A

Por ejemplo:

1
2
3
4
5
6
7
8
months_a = set(["Jan", "Feb", "March", "Apr", "May", "June"])
months_b = set(["Jan", "Feb", "March", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"])

subset_check = months_a <= months_b
superset_check = months_b >= months_a

print(subset_check)
print(superset_check)

El months_a es el subconjunto de months_b que es, por otro lado, el superconjunto de months_a. Por lo tanto, ejecutar el código anterior producirá:

1
2
True
True

El subconjunto y el superconjunto también se pueden verificar usando los métodos issubset() y issuperset() como se muestra a continuación:

1
2
3
4
5
6
7
8
months_a = set(["Jan","Feb", "March", "Apr", "May", "June"])
months_b = set(["Jan","Feb", "March", "Apr", "May", "June", "July", "Aug", "Sep", "Oct", "Nov", "Dec"])

subset_check = months_a.issubset(months_b)
superset_check = months_b.issuperset(months_a)

print(subset_check)
print(superset_check)

Lo que produce el mismo resultado en el ejemplo anterior:

1
2
True
True

Métodos de conjunto de Python

En las siguientes secciones, discutiremos algunos de los métodos establecidos más comúnmente utilizados proporcionados por Python que aún no hemos discutido.

Copiar()

Este método devuelve una copia del conjunto en cuestión:

1
2
3
4
string_set = {"Nicholas", "Michelle", "John", "Mercy"}
x = string_set.copy()

print(x)

La salida muestra que x es una copia del conjunto string_set:

1
{'John', 'Michelle', 'Nicholas', 'Mercy'}

es disjunto()

Este método verifica si los conjuntos en cuestión tienen una intersección o no. Si los conjuntos no tienen elementos comunes, este método devuelve Verdadero; de lo contrario, devuelve Falso:

1
2
3
4
5
names_a = {"Nicholas", "Michelle", "John", "Mercy"}
names_b = {"Jeff", "Bosco", "Teddy", "Milly"}

x = names_a.isdisjoint(names_b)
print(x)

Los dos conjuntos no tienen elementos comunes, por lo que el resultado es Verdadero:

1
True

largo()

Este método devuelve la longitud de un conjunto, que es el número total de elementos en el conjunto:

1
2
3
names_a = {"Nicholas", "Michelle", "John", "Mercy"}

print(len(names_a))

La salida muestra que el conjunto tiene una longitud de 4:

1
4

Conjunto congelado de Python

Frozenset es una clase con las características de un set, pero una vez asignados sus elementos, no se pueden cambiar. Las tuplas pueden verse como listas inmutables, mientras que los conjuntos congelados pueden verse como conjuntos inmutables.

{.icon aria-hidden=“true”}

Nota: Los conjuntos son mutables y no modificables, lo que significa que no podemos usarlos como claves de diccionario. Conjuntos congelados son hashable y podemos usarlos como claves de diccionario.

Para crear conjuntos congelados, usamos el método frozenset(). Vamos a crear dos conjuntos congelados, X e Y:

1
2
3
4
5
X = frozenset([1, 2, 3, 4, 5, 6])
Y = frozenset([4, 5, 6, 7, 8, 9])

print(X)
print(Y)

Esto dará como resultado:

1
2
frozenset({1, 2, 3, 4, 5, 6})
frozenset({4, 5, 6, 7, 8, 9})

Los conjuntos congelados admiten el uso de métodos de conjuntos de Python como copy(), difference(), symmetric_difference(), isdisjoint(), issubset(), intersection(), issuperset() , y unión().

Conclusión

La guía proporciona una introducción detallada a los conjuntos en Python. La definición matemática de conjuntos es la misma que la definición de conjuntos en Python. Un conjunto es simplemente una colección de elementos desordenados. El conjunto en sí es mutable, pero los elementos del conjunto son inmutables. Sin embargo, podemos agregar y eliminar elementos de un conjunto libremente. En la mayoría de las estructuras de datos, los elementos están indexados. Sin embargo, los elementos del conjunto no están indexados. Esto hace que nos sea imposible realizar operaciones que apunten a elementos específicos del conjunto. nto.

Licensed under CC BY-NC-SA 4.0