Establecer operacións (por exemplo, determinar conxuntos de unión, conxuntos de produtos e subconxuntos) co tipo de conxunto de Python

Negocios

Python proporciona un tipo de datos integrado, set, que manexa conxuntos.

O conxunto de tipos é unha colección de elementos non duplicados (elementos que non teñen o mesmo valor, elementos únicos) e pode realizar operacións de conxunto como conxunto de unión, conxunto de produtos e conxunto de diferenzas.

Nesta sección, as operacións básicas en operacións de conxunto de tipo conxunto explícanse cun código de exemplo.

  • Creación de obxectos conxuntos:{},set()
  • establecer a notación de inclusión
  • Número de elementos do conxunto:len()
  • Engadir un elemento a un conxunto:add()
  • Eliminar un elemento dun conxunto:discard(),remove(),pop(),clear()
  • Wasset (fusión, unión):|operador,union()
  • Conxuntos de produtos (partes comúns, interseccións, interseccións):& operador,intersection()
  • complemento relativo:-operador,difference()
  • conxunto de diferenzas de simetría:^ operador,symmetric_difference()
  • subconxunto ou non:<= operador,issubset()
  • Conxunto superior ou non:>= operador,issuperset()
  • Determinación de se son primos entre sí ou non:isdisjoint()

O tipo de conxunto é un tipo mutable que pode engadir e eliminar elementos, e tamén hai un tipo de conxunto conxelado que ten a mesma operación de conxunto e outros métodos que o tipo de conxunto, pero é inmutable (non se pode modificar engadindo, eliminando ou modificando elementos doutro xeito). ).

Creación do obxecto conxunto::{},set()

Xerado por corchetes de onda {}

Pódense crear obxectos de tipo conxunto encerrando elementos entre chaves {}.

Se hai valores duplicados, ignóranse e só os valores únicos permanecen como elementos.

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

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

É posible ter diferentes tipos como elementos. Non obstante, non se poden rexistrar obxectos actualizables, como os tipos de lista. Permítense tuplas.

Ademais, dado que os tipos de conxuntos non están ordenados, a orde na que se xeran non 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'

Os diferentes tipos, como int e float, considéranse duplicados se os seus valores son equivalentes.

s = {100, 100.0}

print(s)
# {100}

Dado que unha chave baleira {} considérase un tipo de dicionario, pódese crear un obxecto de tipo conxunto baleiro (conxunto baleiro) usando o construtor que se describe a continuación.

s = {}

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

Xerado polo constructor set()

Tamén se poden crear obxectos de tipo set co construtor set().

Especificar un obxecto iterable como unha lista ou unha tupla como argumento xera un obxecto conxunto cuxos elementos só son valores únicos, excluíndo os 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'>

Os tipos frozenset inmutables créanse co construtor frozenset().

fs_l = frozenset(l)

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

Se o argumento se omite, créase un obxecto de tipo conxunto baleiro (conxunto baleiro).

s = set()

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

Os elementos duplicados pódense eliminar dunha lista ou tupla usando set(), pero a orde da lista orixinal non se conserva.

Para converter un tipo de conxunto nunha lista ou tupla, use list(),tupla().

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

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

Consulte o seguinte artigo para obter información sobre como eliminar elementos duplicados mentres se preserva a orde, extraendo só elementos duplicados e procesando elementos duplicados nunha matriz bidimensional (lista de listas).

establecer a notación de inclusión

Ademais das comprensións de lista, hai comprensións establecidas. Simplemente substitúe os corchetes [] por chaves {} nas listas de comprensión.

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

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

Consulte o seguinte artigo para obter máis información sobre a notación de comprensión de listas.

Número de elementos do conxunto:len()

O número de elementos dun conxunto pódese obter coa función incorporada len().

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

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

Se queres contar o número de elementos de cada lista que ten elementos con valores duplicados, etc., consulta o seguinte artigo.

Engadir un elemento a un conxunto:add()

Para engadir un elemento a un conxunto, use o método add().

s = {0, 1, 2}

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

Eliminar un elemento dun conxunto:discard(),remove(),pop(),clear()

Para eliminar un elemento dun conxunto, use os métodos discard(), remove(), pop() e clear().

O método discard() elimina o elemento especificado no argumento. Se se especifica un valor que non existe no conxunto, non se fai nada.

s = {0, 1, 2}

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

s = {0, 1, 2}

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

O método remove() tamén elimina o elemento especificado no argumento, pero se devolve un erro KeyError se se especifica un valor que non existe no conxunto.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

O método pop() elimina elementos dun conxunto e devolve os seus valores. Non é posible seleccionar que valores eliminar. Un conxunto baleiro producirá un erro 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'

O método clear() elimina todos os elementos e deixa o conxunto baleiro.

s = {0, 1, 2}

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

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

O conxunto de unión (fusión, unión) pódese obter co | operador ou o 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}

Pódense especificar varios argumentos para un método. Ademais do tipo de conxunto, tamén se poden especificar como argumentos as listas e tuplas que se poden converter ao tipo de conxunto mediante set(). O mesmo aplícase aos operadores e 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}

Conxuntos de produtos (partes comúns, interseccións, interseccións):& operador,intersection()

O conxunto de produtos (parte común, intersección e intersección) pódese obter co & operador ou o método intersección().

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

O conxunto de diferenzas pódese obter co operador – ou co 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}

conxunto de diferenzas de simetría:^ operador,symmetric_difference()

O conxunto de diferenzas simétricas (o conxunto de elementos contido só nun dos dous) pódese obter co operador ^ ou symmetric_difference().

Equivale á disxunción exclusiva (XOR) nas operacións lóxicas.

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

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

subconxunto ou non:<= operador,issubset()

Para determinar se un conxunto é un subconxunto doutro conxunto, use o operador <= ou o método issubset().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Tanto o operador <= como o método issubset() devolven verdadeiro para conxuntos equivalentes.

Para determinar se é un subconxunto verdadeiro, use o operador <=, que devolve falso para conxuntos equivalentes.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Conxunto superior ou non:>= operador,issuperset()

Para determinar se un conxunto é un superconxunto doutro, use o operador >= ou issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Tanto o operador >= como o método issuperset() devolven verdadeiro para conxuntos equivalentes.

Para determinar se é un superconxunto verdadeiro, use o operador >=, que devolve falso para conxuntos equivalentes.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Determinación de se son primos entre sí ou non:isdisjoint()

Para determinar se dous conxuntos son primos entre si, use o método isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True