Operações de conjuntos (por exemplo, determinação de conjuntos de união, conjuntos de produtos e subconjuntos) com o tipo de conjunto Python

O negócio

Python fornece um tipo de dados incorporado, conjunto, que trata de conjuntos.

O conjunto de tipo é uma colecção de elementos não duplicados (elementos que não têm o mesmo valor, elementos únicos) e pode realizar operações de conjunto, tais como conjunto de união, conjunto de produtos e conjunto de diferenças.

Nesta secção, as operações básicas em operações de set-type set são explicadas com código de amostra.

  • Criação de conjuntos de objectos: {},set()
  • notação de inclusão definida
  • Número de elementos do conjunto:len()
  • Adicionar um Elemento a um Conjunto:add()
  • Remover um elemento de um conjunto: discard(),remove(),pop(),clear()
  • Wasset (fusão, união):|operador,union()
  • Conjuntos de produtos (peças comuns, intersecções, intersecções):e operador,intersection()
  • complemento relativo:-operador,difference()
  • conjunto de diferenças de simetria:^ operador,symmetric_difference()
  • subconjunto ou não:<= operador,issubset()
  • Conjunto superior ou não:>= operador,issuperset()
  • Determinação se são ou não mutuamente primos:isdisjoint()

O tipo de conjunto é um tipo mutável que pode adicionar e apagar elementos, e há também um tipo de conjunto que tem a mesma operação de conjunto e outros métodos que o tipo de conjunto, mas é imutável (não pode ser modificado adicionando, apagando, ou modificando de outra forma os elementos).

Criação de objecto de conjunto:: {}, set()

Gerado por parênteses de onda {}

Objectos do tipo conjunto podem ser criados enclausurando elementos em braçadeiras {}.

Se houver valores duplicados, estes são ignorados e apenas valores únicos permanecem como elementos.

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

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

É possível ter diferentes tipos como elementos. No entanto, os objectos actualizáveis, tais como tipos de listas, não podem ser registados. Os tuplos são permitidos.

Além disso, uma vez que os tipos definidos são desordenados, a ordem em que são gerados não é armazenada.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Diferentes tipos, tais como int e float, são considerados duplicados se os seus valores forem equivalentes.

s = {100, 100.0}

print(s)
# {100}

Uma vez que uma cinta vazia {} é considerada um tipo de dicionário, um objecto do tipo conjunto vazio (conjunto vazio) pode ser criado usando o construtor descrito a seguir.

s = {}

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

Gerado por conjunto construtor()

Objectos do tipo conjunto também podem ser criados com o conjunto construtor().

Especificar um objecto iterável tal como uma lista ou tuple como argumento gera um conjunto de objectos cujos elementos são apenas valores únicos, com exclusão de 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 imutáveis de frozenset são criados com o construtor frozenset().

fs_l = frozenset(l)

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

Se o argumento for omitido, é criado um objecto do tipo conjunto vazio (conjunto vazio).

s = set()

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

Os elementos duplicados podem ser removidos de uma lista ou tuple utilizando set(), mas a ordem da lista original não é preservada.

Para converter um tipo de conjunto em lista ou tuple, usar lista(),tuple().

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

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

Ver o artigo seguinte para informações sobre a remoção de elementos duplicados preservando a ordem, extraindo apenas elementos duplicados, e processando elementos duplicados numa matriz bidimensional (lista de listas).

notação de inclusão definida

Para além das compreensões de listas, existem também compreensões definidas. Basta substituir os parênteses rectos [] por braçadeiras {} nas compreensões de lista.

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

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

Ver o artigo seguinte para mais informações sobre a notação de compreensão da lista.

Número de elementos do conjunto: len()

O número de elementos de um conjunto pode ser obtido com a função len() incorporada.

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

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

Se quiser contar o número de elementos em cada lista que tem elementos com valores duplicados, etc., consulte o artigo seguinte.

Adicionar um Elemento a um Conjunto: add()

Para adicionar um elemento a um conjunto, usar o método add().

s = {0, 1, 2}

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

Remover um elemento de um conjunto: discard(),remove(),pop(),clear()

Para remover um elemento de um conjunto, utilizar os métodos descartar(), remover(), pop(), e clear().

O método de descarte() apaga o elemento especificado no argumento. Se for especificado um valor que não existe no conjunto, nada é feito.

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() também remove o elemento especificado no argumento, mas um erro KeyError é devolvido se for especificado um valor que não existe no conjunto.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

O método pop() remove elementos de um conjunto e devolve os seus valores. Não é possível seleccionar quais os valores a remover. Um conjunto vazio resultará num 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() remove todos os elementos e torna o conjunto vazio.

s = {0, 1, 2}

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

Wasset (fusão, união): |operador, union()

O conjunto sindical (fusão, união) pode ser obtido com o método | operator 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}

Podem ser especificados múltiplos argumentos para um método. Além do tipo de conjunto, listas e tuplos que podem ser convertidos para o tipo de conjunto por conjunto() também podem ser especificados como argumentos. O mesmo se aplica a operadores e métodos subsequentes.

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}

Conjuntos de produtos (peças comuns, intersecções, intersecções): e operador, intersection()

O conjunto do produto (peça comum, intersecção e intersecção) pode ser obtido com o método & operador ou o método de intersecção().

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 conjunto de diferenças pode ser obtido com o método – operador ou a diferença().

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}

conjunto de diferenças de simetria: ^ operador, symmetric_difference()

O conjunto de diferenças simétricas (o conjunto de elementos contidos em apenas um dos dois) pode ser obtido com o operador ^ ou symmetric_difference().

Equivalente à disjunção exclusiva (XOR) em operações lógicas.

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

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

subconjunto ou não: <= operador, issubset()

Para determinar se um conjunto é um subconjunto de outro conjunto, usar o método <= operador ou o 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() retornam verdadeiros para conjuntos equivalentes.

Para determinar se é um verdadeiro subconjunto, utilizar o operador <=, que retorna falso para conjuntos equivalentes.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Conjunto superior ou não: >= operador, issuperset()

Para determinar se um conjunto é um super conjunto de outro, usar 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() retornam verdadeiros para conjuntos equivalentes.

Para determinar se é um verdadeiro superconjunto, utilizar o operador >=, que retorna falso para conjuntos equivalentes.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Determinação se são ou não mutuamente primos: isdisjoint()

Para determinar se dois conjuntos são primordiais um para o outro, usar o método isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL