set

Experimental: Esta API es experimental y puede cambiar en cualquier momento. No dependas de ello. Se puede habilitar de forma experimental configurando --experimental_enable_starlark_set.

El tipo de conjunto mutable integrado. Ejemplos de expresiones de conjunto:

x = set()           # x is an empty set
y = set([1, 2, 3])  # y is a set with 3 elements
3 in y              # True
0 in y              # False
len(x)              # 0
len(y)              # 3

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 elementos de un conjunto deben poder generar un hash. x puede ser un elemento de un conjunto solo si x se puede usar como clave de un diccionario.

Un conjunto en sí no se puede convertir en hash. Por lo tanto, no puedes tener un conjunto con otro conjunto como elemento.

No puedes acceder a los elementos de un conjunto por índice, pero puedes iterar sobre ellos y obtener la lista de los elementos de un conjunto en orden de iteración con la función integrada list(). Al igual que con las listas, es un error mutar un conjunto mientras se itera. El orden de iteración coincide con el orden de inserción:

s = set([3, 1, 3])
s.add(2)
# prints 3, 1, 2
for item in s:
    print(item)
list(s)  # [3, 1, 2]

Un conjunto s es igual a t solo si t es un conjunto que contiene los mismos elementos, posiblemente con un orden de iteración diferente. En particular, un conjunto es not igual a su lista de elementos.

Los conjuntos no están ordenados. Las operaciones <, <=, > y >= no están definidas para los conjuntos, y no se puede ordenar una lista de conjuntos, a diferencia de lo que sucede en Python.

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. La operación | tiene una versión de asignación aumentada. s |= t agrega a s todos los elementos de t.

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

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. La operación & tiene una versión de asignación aumentada. s &= t quita de s todos los elementos que no se encuentran en t.

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

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 de la izquierda, pero no en el de la derecha. La operación - tiene una versión de asignación aumentada. s -= t quita de s todos los elementos que se encuentran en t.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])
s = set([1, 2])
s -= set([0, 1])           # s now equals set([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. La operación ^ tiene una versión de asignación aumentada. s ^= t quita de s cualquier elemento de t que se encuentre en s y agrega a s cualquier elemento de t que no se encuentre en s.

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

Miembros

• add
• sencillo
• diferencia
• difference_update
• descartar
• intersección
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• eliminar
• symmetric_difference
• symmetric_difference_update
• sindicato
• actualización

add

None set.add(element)

Parámetros

borrar

None set.clear()

diferencia

set set.difference(*others)

Por ejemplo:

set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])

Parámetros

difference_update

None set.difference_update(*others)

Por ejemplo:

x = set([1, 2, 3, 4])
x.difference_update([2, 3], [3, 4])
# x is now set([1])

Parámetros

descartar

None set.discard(element)

Parámetros

intersección

set set.intersection(*others)

Por ejemplo:

set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])

Parámetros

intersection_update

None set.intersection_update(*others)

Por ejemplo:

x = set([1, 2, 3, 4])
x.intersection_update([2, 3], [3, 4])
# x is now set([3])

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)

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)

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()

quitar

None set.remove(element)

Parámetros

symmetric_difference

set set.symmetric_difference(other)

Por ejemplo:

set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])

Parámetros

symmetric_difference_update

None set.symmetric_difference_update(other)

Por ejemplo:

set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])

Parámetros

unión

set set.union(*others)

Por ejemplo:

set([1, 2]).union([2, 3, 4], [4, 5]) == set([1, 2, 3, 4, 5])

Parámetros

update

None set.update(*others)

Por ejemplo:

x = set([1, 2])
x.update([2, 3], [3, 4])
# x is now set([1, 2, 3, 4])

Parámetros