Es el tipo de conjunto integrado. Un conjunto es una colección iterable y mutable de valores únicos: los elementos del conjunto. El nombre de 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 poder generar un hash. 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 muestra un conjunto nuevo que contiene los elementos únicos de su argumento opcional, que debe ser iterable. Si llamas a set() sin un argumento, se crea un conjunto vacío. Los conjuntos no tienen sintaxis literal.
Las operaciones in y not in comprueban 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 el contexto booleano es verdadero 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 significativo. En particular, un conjunto no es igual a la lista de sus elementos. Los conjuntos no se ordenan en relación con otros conjuntos, y fallará un 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 muestra 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 muestra la intersección de los dos conjuntos: un conjunto que solo contiene 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 muestra la diferencia entre los dos conjuntos: 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 muestra 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 que cualquier elemento que solo estuviera presente en el lado derecho.
Las asignaciones aumentadas correspondientes, |=, &=, -= y ^=, modifican el conjunto de la izquierda.
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 inmovilizar y, una vez inmovilizado, fallarán todas las operaciones posteriores que intenten actualizarlo.
Miembros
- add
- sencillo
- diferencia
- difference_update
- descartar
- intersección
- intersection_update
- isdisjoint
- issubset
- issuperset
- pop
- eliminar
- symmetric_difference
- symmetric_difference_update
- union
- actualización
add
None set.add(element)Se permite add un valor que ya está presente en el conjunto, lo que no cambia el conjunto.
Si necesitas agregar varios elementos a un conjunto, consulta update o la operación de asignación aumentada |=.
Parámetros
| Parámetro | Descripción |
|---|---|
element
|
obligatorio Elemento que se agregará. |
borrar
None set.clear()diferencia
set set.difference(*others)
Si s y t son conjuntos, s.difference(t) equivale 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. Esto muestra 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
| Parámetro | Descripción |
|---|---|
others
|
obligatorio Conjuntos, secuencias de elementos hashables o diccionarios. |
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
| Parámetro | Descripción |
|---|---|
others
|
obligatorio Conjuntos, secuencias de elementos hashables o diccionarios. |
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 fallar en un intento de quitar un elemento que no está presente, usa remove. Si necesitas quitar varios elementos de un set, 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
| Parámetro | Descripción |
|---|---|
element
|
obligatorio Elemento que se descartará. Debe poder generar un hash. |
intersección
set set.intersection(*others)
Si s y t son conjuntos, s.intersection(t) equivale 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. Esto muestra 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
| Parámetro | Descripción |
|---|---|
others
|
obligatorio Conjuntos, secuencias de elementos hashables o diccionarios. |
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
| Parámetro | Descripción |
|---|---|
others
|
obligatorio Conjuntos, secuencias de elementos hashables o diccionarios. |
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
| Parámetro | Descripción |
|---|---|
other
|
obligatorio Un conjunto, una secuencia de elementos que admiten hash o un diccionario. |
issubset
bool set.issubset(other)
Ten en cuenta que un conjunto siempre se considera 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
| Parámetro | Descripción |
|---|---|
other
|
obligatorio Un conjunto, una secuencia de elementos que admiten hash o un diccionario. |
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
| Parámetro | Descripción |
|---|---|
other
|
obligatorio Un conjunto, una secuencia de elementos que admiten hash o un diccionario. |
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 fallar en un intento de quitar un elemento que no está presente, usa discard.
Si necesitas quitar varios elementos de un conjunto, consulta difference_update o la operación de asignación aumentada -=.
Parámetros
| Parámetro | Descripción |
|---|---|
element
|
obligatorio Elemento que se quitará. Debe ser un elemento del conjunto (y ser hashable). |
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
| Parámetro | Descripción |
|---|---|
other
|
obligatorio Un conjunto, una secuencia de elementos que admiten hash o un diccionario. |
symmetric_difference_update
None set.symmetric_difference_update(other)Si s y t son conjuntos, s.symmetric_difference_update(t) es equivalente a "s ^= t; however, note that the ^=". La asignación aumentada requiere que ambos lados sean conjuntos, mientras que el método symmetric_difference_update también acepta una secuencia o un diccionario.
Por ejemplo:
s = set([1, 2]) s.symmetric_difference_update([2, 3]) # None; s == set([1, 3])
Parámetros
| Parámetro | Descripción |
|---|---|
other
|
obligatorio Un conjunto, una secuencia de elementos que admiten hash o un diccionario. |
unión
set set.union(*others)
Si s y t son conjuntos, s.union(t) equivale 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 muestra 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
| Parámetro | Descripción |
|---|---|
others
|
obligatorio Conjuntos, secuencias de elementos hashables o diccionarios. |
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) equivale 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 argumentos, lo que deja el conjunto
sin cambios.
Parámetros
| Parámetro | Descripción |
|---|---|
others
|
obligatorio Conjuntos, secuencias de elementos hashables o diccionarios. |