set

Es el tipo de conjunto integrado. Un conjunto es una colección mutable y iterable de valores únicos: los elementos del conjunto. El nombre del tipo de un conjunto es "set".

Los conjuntos proporcionan operaciones de tiempo constante para insertar, quitar o verificar la presencia de un valor. Los conjuntos se implementan con una tabla hash y, por lo tanto, al igual que las claves de un diccionario, los elementos de un conjunto deben ser hashables. Un valor se puede usar como elemento de un conjunto solo si se puede usar como clave de un diccionario.

Los conjuntos se pueden construir con la función integrada set(), que devuelve un conjunto nuevo que contiene los elementos únicos de su argumento opcional, que debe ser iterable. Si llamas a set() sin un argumento, se construye un conjunto vacío. Los conjuntos no tienen sintaxis literal.

Las operaciones in y not in verifican si un valor está (o no) en un conjunto:

s = set(["a", "b", "c"])
"a" in s  # True
"z" in s  # False

Un conjunto es iterable y, por lo tanto, se puede usar como operando de un bucle for, una comprensión de lista y las diversas funciones integradas que operan en iterables. Su longitud se puede recuperar con la función integrada len(), y el orden de iteración es el orden en el que se agregaron los elementos por primera vez al conjunto:

s = set(["z", "y", "z", "y"])
len(s)       # prints 2
s.add("x")
len(s)       # prints 3
for e in s:
    print e  # prints "z", "y", "x"

Un conjunto que se usa en un contexto booleano es verdadero si y solo si no está vacío.

s = set()
"non-empty" if s else "empty"  # "empty"
t = set(["x", "y"])
"non-empty" if t else "empty"  # "non-empty"

Los conjuntos se pueden comparar para determinar si son iguales o desiguales con == y !=. Un conjunto s es igual a t si y solo si t es un conjunto que contiene los mismos elementos; el orden de iteración no es importante. En particular, un conjunto no es igual a la lista de sus elementos. Los conjuntos no se ordenan con respecto a otros conjuntos, y fallará cualquier intento de comparar dos conjuntos con <, <=, >, >= o de ordenar una secuencia de conjuntos.

set() == set()              # True
set() != []                 # True
set([1, 2]) == set([2, 1])  # True
set([1, 2]) != [1, 2]       # True

La operación | en dos conjuntos devuelve la unión de los dos conjuntos: un conjunto que contiene los elementos que se encuentran en uno o ambos conjuntos originales.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])

La operación & en dos conjuntos devuelve la intersección de los dos conjuntos: un conjunto que contiene solo los elementos que se encuentran en ambos conjuntos originales.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()

La operación - en dos conjuntos devuelve la diferencia entre ellos: un conjunto que contiene los elementos que se encuentran en el conjunto del lado izquierdo, pero no en el del lado derecho.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])

La operación ^ en dos conjuntos devuelve la diferencia simétrica de los dos conjuntos: un conjunto que contiene los elementos que se encuentran en exactamente uno de los dos conjuntos originales, pero no en ambos.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])

En cada una de las operaciones anteriores, los elementos del conjunto resultante conservan su orden de los dos conjuntos de operandos, con todos los elementos que se extrajeron del lado izquierdo ordenados antes de cualquier elemento que solo estaba presente en el lado derecho.

Las asignaciones aumentadas correspondientes, |=, &=, -= y ^=, modifican el conjunto del lado izquierdo en su lugar.

s = set([1, 2])
s |= set([2, 3, 4])     # s now equals set([1, 2, 3, 4])
s &= set([0, 1, 2, 3])  # s now equals set([1, 2, 3])
s -= set([0, 1])        # s now equals set([2, 3])
s ^= set([3, 4])        # s now equals set([2, 4])

Al igual que todos los valores mutables en Starlark, un conjunto se puede congelar y, una vez congelado, fallarán todas las operaciones posteriores que intenten actualizarlo.

Miembros

• add
• sencillo
• diferencia
• difference_update
• descartar
• intersection
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• eliminar
• symmetric_difference
• symmetric_difference_update
• union
• actualizar

add

None set.add(element)

Se permite add un valor que ya está presente en el conjunto, lo que deja el conjunto sin cambios.

Si necesitas agregar varios elementos a un conjunto, consulta update o la operación de asignación aumentada |=.

Parámetros

borrar

None set.clear()

diferencia

set set.difference(*others)

Si s y t son conjuntos, s.difference(t) es equivalente a s - t. Sin embargo, ten en cuenta que la operación - requiere que ambos lados sean conjuntos, mientras que el método difference también acepta secuencias y diccionarios.

Se permite llamar a difference sin ningún argumento, lo que devuelve una copia del conjunto.

Por ejemplo:

set([1, 2, 3]).difference([2])             # set([1, 3])
set([1, 2, 3]).difference([0, 1], [3, 4])  # set([2])

Parámetros

difference_update

None set.difference_update(*others)

Si s y t son conjuntos, s.difference_update(t) es equivalente a s -= t. Sin embargo, ten en cuenta que la asignación aumentada -= requiere que ambos lados sean conjuntos, mientras que el método difference_update también acepta secuencias y diccionarios.

Se permite llamar a difference_update sin ningún argumento, lo que deja el conjunto sin cambios.

Por ejemplo:

s = set([1, 2, 3, 4])
s.difference_update([2])             # None; s is set([1, 3, 4])
s.difference_update([0, 1], [4, 5])  # None; s is set([3])

Parámetros

descartar

None set.discard(element)

Se permite discard un valor que no está presente en el conjunto, lo que deja el conjunto sin cambios. Si quieres que falle un intento de quitar un elemento no presente, usa remove en su lugar. Si necesitas quitar varios elementos de un conjunto, consulta difference_update o la operación de asignación aumentada -=.

Por ejemplo:

s = set(["x", "y"])
s.discard("y")  # None; s == set(["x"])
s.discard("y")  # None; s == set(["x"])

Parámetros

intersección

set set.intersection(*others)

Si s y t son conjuntos, s.intersection(t) es equivalente a s & t. Sin embargo, ten en cuenta que la operación & requiere que ambos lados sean conjuntos, mientras que el método intersection también acepta secuencias y diccionarios.

Se permite llamar a intersection sin ningún argumento, lo que devuelve una copia del conjunto.

Por ejemplo:

set([1, 2]).intersection([2, 3])             # set([2])
set([1, 2, 3]).intersection([0, 1], [1, 2])  # set([1])

Parámetros

intersection_update

None set.intersection_update(*others)

Si s y t son conjuntos, s.intersection_update(t) es equivalente a s &= t. Sin embargo, ten en cuenta que la asignación aumentada &= requiere que ambos lados sean conjuntos, mientras que el método intersection_update también acepta secuencias y diccionarios.

Se permite llamar a intersection_update sin ningún argumento, lo que deja el conjunto sin cambios.

Por ejemplo:

s = set([1, 2, 3, 4])
s.intersection_update([0, 1, 2])       # None; s is set([1, 2])
s.intersection_update([0, 1], [1, 2])  # None; s is set([1])

Parámetros

isdisjoint

bool set.isdisjoint(other)

Por ejemplo:

set([1, 2]).isdisjoint([3, 4])  # True
set().isdisjoint(set())         # True
set([1, 2]).isdisjoint([2, 3])  # False

Parámetros

issubset

bool set.issubset(other)

Ten en cuenta que siempre se considera que un conjunto es un subconjunto de sí mismo.

Por ejemplo:

set([1, 2]).issubset([1, 2, 3])  # True
set([1, 2]).issubset([1, 2])     # True
set([1, 2]).issubset([2, 3])     # False

Parámetros

issuperset

bool set.issuperset(other)

Ten en cuenta que un conjunto siempre se considera un superconjunto de sí mismo.

Por ejemplo:

set([1, 2, 3]).issuperset([1, 2])     # True
set([1, 2, 3]).issuperset([1, 2, 3])  # True
set([1, 2, 3]).issuperset([2, 3, 4])  # False

Parámetros

pop

unknown set.pop()

Falla si el conjunto está vacío.

Por ejemplo:

s = set([3, 1, 2])
s.pop()  # 3; s == set([1, 2])
s.pop()  # 1; s == set([2])
s.pop()  # 2; s == set()
s.pop()  # error: empty set

quitar

None set.remove(element)

remove falla si el elemento no estaba presente en el conjunto. Si no quieres que se produzca un error cuando intentes quitar un elemento que no está presente, usa discard en su lugar. Si necesitas quitar varios elementos de un conjunto, consulta difference_update o la operación de asignación aumentada -=.

Parámetros

symmetric_difference

set set.symmetric_difference(other)

Si s y t son conjuntos, s.symmetric_difference(t) es equivalente a s ^ t. Sin embargo, ten en cuenta que la operación ^ requiere que ambos lados sean conjuntos, mientras que el método symmetric_difference también acepta una secuencia o un diccionario.

Por ejemplo:

set([1, 2]).symmetric_difference([2, 3])  # set([1, 3])

Parámetros

symmetric_difference_update

None set.symmetric_difference_update(other)

Si s y t son conjuntos, s.symmetric_difference_update(t) es equivalente a la asignación aumentada "s ^= t", que requiere que ambos lados sean conjuntos, mientras que el método symmetric_difference_update también acepta una secuencia o un diccionario.; however, note that the

Por ejemplo:

s = set([1, 2])
s.symmetric_difference_update([2, 3])  # None; s == set([1, 3])

Parámetros

unión

set set.union(*others)

Si s y t son conjuntos, s.union(t) es equivalente a s | t. Sin embargo, ten en cuenta que la operación | requiere que ambos lados sean conjuntos, mientras que el método union también acepta secuencias y diccionarios.

Se permite llamar a union sin ningún argumento, lo que devuelve una copia del conjunto.

Por ejemplo:

set([1, 2]).union([2, 3])                    # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"})  # set([1, 2, 3, 4])

Parámetros

update

None set.update(*others)

Por ejemplo:

s = set()
s.update([1, 2])          # None; s is set([1, 2])
s.update([2, 3], [3, 4])  # None; s is set([1, 2, 3, 4])

Si s y t son conjuntos, s.update(t) es equivalente a s |= t. Sin embargo, ten en cuenta que la asignación aumentada |= requiere que ambos lados sean conjuntos, mientras que el método update también acepta secuencias y diccionarios.

Se permite llamar a update sin ningún argumento, lo que deja el conjunto sin cambios.

Parámetros