Python Language
Conjunto

Sintaxis

• empty_set = set () # inicializa un conjunto vacío
• literal_set = {'foo', 'bar', 'baz'} # construye un conjunto con 3 cadenas dentro de él
• set_from_list = set (['foo', 'bar', 'baz']) # llama a la función set para un nuevo conjunto
• set_from_iter = set (x para x en el rango (30)) # usa iterables arbitrarios para crear un conjunto
• set_from_iter = {x para x en [random.randint (0,10) para i en rango (10)]} # notación alternativa

Observaciones

Consigue los elementos únicos de una lista.

Digamos que tienes una lista de restaurantes, tal vez la lees de un archivo. Te preocupas por los restaurantes únicos en la lista. La mejor manera de obtener los elementos únicos de una lista es convertirlos en un conjunto:

restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]
unique_restaurants = set(restaurants)
print(unique_restaurants)
# prints {'Chicken Chicken', "McDonald's", 'Burger King'}

Tenga en cuenta que el conjunto no está en el mismo orden que la lista original; eso es porque los conjuntos no están ordenados , al igual que dict s.

Esto se puede volver a transformar fácilmente en una List con la función de list incorporada de Python, dando otra lista que es la misma que la original pero sin duplicados:

list(unique_restaurants)
# ['Chicken Chicken', "McDonald's", 'Burger King']

También es común ver esto como una sola línea:

# Removes all duplicates and returns another list
list(set(restaurants))

Ahora, cualquier operación que se pueda realizar en la lista original se puede hacer de nuevo.

Operaciones en sets

con otros sets

# Intersection    
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6})  # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6}              # {3, 4, 5}

# Union
{1, 2, 3, 4, 5}.union({3, 4, 5, 6})  # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6}       # {1, 2, 3, 4, 5, 6}

# Difference
{1, 2, 3, 4}.difference({2, 3, 5})  # {1, 4}
{1, 2, 3, 4} - {2, 3, 5}            # {1, 4}

# Symmetric difference with
{1, 2, 3, 4}.symmetric_difference({2, 3, 5})  # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5}                      # {1, 4, 5}

# Superset check
{1, 2}.issuperset({1, 2, 3})  # False
{1, 2} >= {1, 2, 3}           # False

# Subset check
{1, 2}.issubset({1, 2, 3})  # True
{1, 2} <= {1, 2, 3}         # True

# Disjoint check
{1, 2}.isdisjoint({3, 4})  # True
{1, 2}.isdisjoint({1, 4})  # False

con elementos individuales

# Existence check
2 in {1,2,3}      # True
4 in {1,2,3}      # False
4 not in {1,2,3}  # True

# Add and Remove
s = {1,2,3}
s.add(4)        # s == {1,2,3,4}

s.discard(3)    # s == {1,2,4}
s.discard(5)    # s == {1,2,4}

s.remove(2)     # s == {1,4}
s.remove(2)     # KeyError!

Las operaciones de configuración devuelven conjuntos nuevos, pero tienen las versiones locales correspondientes:

Por ejemplo:

s = {1, 2}
s.update({3, 4})   # s == {1, 2, 3, 4}

Conjuntos versus multisets

Los conjuntos son colecciones desordenadas de elementos distintos. Pero a veces queremos trabajar con colecciones desordenadas de elementos que no son necesariamente distintos y hacer un seguimiento de las multiplicidades de los elementos.

Considera este ejemplo:

>>> setA = {'a','b','b','c'}
>>> setA
set(['a', 'c', 'b'])

Al guardar las cadenas 'a' , 'b' , 'b' , 'c' en una estructura de datos establecida, hemos perdido la información sobre el hecho de que 'b' ocurre dos veces. Por supuesto, guardar los elementos en una lista conservaría esta información

>>> listA = ['a','b','b','c']
>>> listA
['a', 'b', 'b', 'c']

pero una lista de estructura de datos introduce un orden adicional innecesario que ralentizará nuestros cálculos.

Para implementar multisets, Python proporciona la clase Counter desde el módulo de collections (a partir de la versión 2.7):

>>> from collections import Counter
>>> counterA = Counter(['a','b','b','c'])
>>> counterA
Counter({'b': 2, 'a': 1, 'c': 1})

Counter es un diccionario donde los elementos se almacenan como claves de diccionario y sus conteos se almacenan como valores de diccionario. Y como todos los diccionarios, es una colección desordenada.

Establecer operaciones usando métodos e incorporaciones

Definimos dos conjuntos a y b

>>> a = {1, 2, 2, 3, 4}
>>> b = {3, 3, 4, 4, 5}

NOTA: {1} crea un conjunto de un elemento, pero {} crea un dict vacío. La forma correcta de crear un conjunto vacío es set() .

Intersección

a.intersection(b) devuelve un nuevo conjunto con elementos presentes tanto en a como en b

>>> a.intersection(b)
{3, 4}

Unión

a.union(b) devuelve un nuevo conjunto con elementos presentes en a y b

>>> a.union(b)
{1, 2, 3, 4, 5}

Diferencia

a.difference(b) devuelve un nuevo conjunto con elementos presentes en a pero no en b

>>> a.difference(b)
{1, 2}
>>> b.difference(a)
{5}

Diferencia simétrica

a.symmetric_difference(b) devuelve un nuevo conjunto con elementos presentes en ya sea a o b pero no en ambas

>>> a.symmetric_difference(b)
{1, 2, 5}
>>> b.symmetric_difference(a)
{1, 2, 5}

NOTA : a.symmetric_difference(b) == b.symmetric_difference(a)

Subconjunto y superconjunto

c.issubset(a) comprueba si cada elemento de c está en a .

a.issuperset(c) comprueba si cada elemento de c está en a .

>>> c = {1, 2}
>>> c.issubset(a)
True
>>> a.issuperset(c)
True

Las últimas operaciones tienen operadores equivalentes como se muestra a continuación:

Conjuntos desunidos

Los conjuntos a y d son disjuntos si ningún elemento en a también está en d y viceversa.

>>> d = {5, 6}
>>> a.isdisjoint(b) # {2, 3, 4} are in both sets
False
>>> a.isdisjoint(d)
True

# This is an equivalent check, but less efficient
>>> len(a & d) == 0
True

# This is even less efficient
>>> a & d == set()
True

Membresía de prueba

El incorporado in palabra clave busca ocurrencias

>>> 1 in a
True
>>> 6 in a
False

Longitud

La función len() incorporada devuelve el número de elementos en el conjunto

>>> len(a)
4
>>> len(b)
3

Conjunto de conjuntos

{{1,2}, {3,4}}

lleva a:

TypeError: unhashable type: 'set'

En su lugar, utilice frozenset :

{frozenset({1, 2}), frozenset({3, 4})}