Operaciones con conjuntos (por ejemplo, determinar conjuntos de unión, conjuntos producto y subconjuntos) con el tipo de conjunto de Python

Negocio

Python proporciona un tipo de datos incorporado, set, que maneja conjuntos.

El tipo conjunto es una colección de elementos no duplicados (elementos que no tienen el mismo valor, elementos únicos) y puede realizar operaciones de conjunto como conjunto unión, conjunto producto y conjunto diferencia.

En esta sección, se explican las operaciones básicas en las operaciones de conjunto con código de ejemplo.

  • Creación de objetos de conjunto: {},set()
  • notación de inclusión de conjuntos
  • Número de elementos del conjunto:len()
  • Añadir un elemento a un conjunto:add()
  • Eliminar un elemento de un conjunto: discard(),remove(),pop(),clear()
  • Wasset (fusión, unión):|operador,union()
  • Conjuntos de productos (partes comunes, intersecciones, cruces):y operador,intersection()
  • complemento relativo:-operador,difference()
  • conjunto de diferencias de simetría:^ operador,symmetric_difference()
  • subconjunto o no:<= operador,issubset()
  • Conjunto superior o no:>= operador,issuperset()
  • Determinación de si son mutuamente primos o no:isdisjoint()

El tipo set es un tipo mutable que puede añadir y eliminar elementos, y también hay un tipo frozenset que tiene la misma operación de conjunto y otros métodos que el tipo set, pero es inmutable (no se puede modificar añadiendo, eliminando o modificando elementos).

Creación de un objeto de set:: {}, set()

Generado por corchetes de onda {}

Los objetos de tipo conjunto pueden crearse encerrando los elementos entre llaves {}.

Si hay valores duplicados, se ignoran y sólo quedan como elementos los valores únicos.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

Es posible tener diferentes tipos como elementos. Sin embargo, los objetos actualizables, como los tipos de lista, no pueden registrarse. Se permiten las tuplas.

Además, como los tipos de conjuntos no están ordenados, el orden en que se generan no se almacena.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Los tipos diferentes, como int y float, se consideran duplicados si sus valores son equivalentes.

s = {100, 100.0}

print(s)
# {100}

Dado que un corchete vacío {} se considera un tipo de diccionario, se puede crear un objeto de tipo conjunto vacío (empty set) utilizando el constructor que se describe a continuación.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Generado por el constructor set()

Los objetos de tipo set también se pueden crear con el constructor set().

Si se especifica como argumento un objeto iterable, como una lista o una tupla, se genera un objeto conjunto cuyos elementos son sólo valores únicos, excluyendo los elementos duplicados.

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Los tipos frozenset inmutables se crean con el constructor frozenset().

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

Si se omite el argumento, se crea un objeto de tipo conjunto vacío (conjunto vacío).

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Los elementos duplicados pueden eliminarse de una lista o tupla utilizando set(), pero el orden de la lista original no se conserva.

Para convertir un tipo de conjunto en una lista o tupla, utilice list(),tuple().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

Consulte el siguiente artículo para obtener información sobre la eliminación de elementos duplicados conservando el orden, la extracción de sólo elementos duplicados y el procesamiento de elementos duplicados en una matriz bidimensional (lista de listas).

notación de inclusión de conjuntos

Además de las comprensiones de listas, existen las comprensiones de conjuntos. Basta con sustituir los corchetes [] por llaves {} en las comprensiones de listas.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Consulte el siguiente artículo para obtener más información sobre la notación de comprensión de listas.

Número de elementos del conjunto: len()

El número de elementos de un conjunto se puede obtener con la función incorporada len().

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Si desea contar el número de elementos de cada lista que tiene elementos con valores duplicados, etc., consulte el siguiente artículo.

Añadir un elemento a un conjunto: add()

Para añadir un elemento a un conjunto, utilice el método add().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Eliminar un elemento de un conjunto: discard(),remove(),pop(),clear()

Para eliminar un elemento de un conjunto, utilice los métodos discard(), remove(), pop() y clear().

El método discard() elimina el elemento especificado en el argumento. Si se especifica un valor que no existe en el conjunto, no se hace nada.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

El método remove() también elimina el elemento especificado en el argumento, pero se devuelve un error KeyError si se especifica un valor que no existe en el conjunto.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

El método pop() elimina elementos de un conjunto y devuelve sus valores. No es posible seleccionar qué valores eliminar. Un conjunto vacío dará lugar a un error KeyError.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

El método clear() elimina todos los elementos y deja el conjunto vacío.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (fusión, unión): |operador, union()

El conjunto de unión (fusión, unión) se puede obtener con el operador | o el método union().

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

Se pueden especificar múltiples argumentos para un método. Además del tipo de conjunto, también se pueden especificar como argumentos las listas y tuplas que se pueden convertir al tipo de conjunto mediante set(). Lo mismo ocurre con los operadores y métodos posteriores.

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Conjuntos de productos (partes comunes, intersecciones, cruces): y operador, intersection()

El conjunto de productos (parte común, intersección e intersección) se puede obtener con el operador & o el método intersection().

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

complemento relativo: -operador, difference()

El conjunto de diferencias se puede obtener con el operador – o el método difference().

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

conjunto de diferencias de simetría: ^ operador, symmetric_difference()

El conjunto de diferencias simétricas (el conjunto de elementos contenidos en sólo uno de los dos) puede obtenerse con el operador ^ o con symmetric_difference().

Equivale a la disyunción exclusiva (XOR) en las operaciones lógicas.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

subconjunto o no: <= operador, issubset()

Para determinar si un conjunto es un subconjunto de otro conjunto, utilice el operador <= o el método issubset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Tanto el operador <= como el método issubset() devuelven verdadero para conjuntos equivalentes.

Para determinar si es un subconjunto verdadero, utilice el operador <=, que devuelve false para conjuntos equivalentes.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Conjunto superior o no: >= operador, issuperset()

Para determinar si un conjunto es un superconjunto de otro, utilice el operador >= o issuperset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Tanto el operador >= como el método issuperset() devuelven true para conjuntos equivalentes.

Para determinar si es un superconjunto verdadero, utilice el operador >=, que devuelve falso para conjuntos equivalentes.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Determinación de si son mutuamente primos o no: isdisjoint()

Para determinar si dos conjuntos son primos entre sí, utilice el método isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL