Conjuntos Python

Neste tutorial, você aprenderá tudo sobre conjuntos Python; como eles são criados, adicionando ou removendo elementos deles e todas as operações realizadas em conjuntos em Python.

Vídeo:conjuntos em Python

Um conjunto é uma coleção não ordenada de itens. Cada elemento do conjunto é único (sem duplicatas) e deve ser imutável (não pode ser alterado).

No entanto, um conjunto em si é mutável. Podemos adicionar ou remover itens dele.

Conjuntos também podem ser usados para realizar operações matemáticas de conjunto como união, interseção, diferença simétrica, etc.

Criando conjuntos Python

Um conjunto é criado colocando todos os itens (elementos) dentro de chaves {} , separados por vírgula ou usando o set() integrado função.

Ele pode ter qualquer número de itens e eles podem ser de diferentes tipos (integer, float, tuple, string etc.). Mas um conjunto não pode ter elementos mutáveis como listas, conjuntos ou dicionários como seus elementos.

# Different types of sets in Python
# set of integers
my_set = {1, 2, 3}
print(my_set)

# set of mixed datatypes
my_set = {1.0, "Hello", (1, 2, 3)}
print(my_set)

Saída

{1, 2, 3}
{1.0, (1, 2, 3), 'Hello'}

Experimente também os exemplos a seguir.

# set cannot have duplicates
# Output: {1, 2, 3, 4}
my_set = {1, 2, 3, 4, 3, 2}
print(my_set)

# we can make set from a list
# Output: {1, 2, 3}
my_set = set([1, 2, 3, 2])
print(my_set)

# set cannot have mutable items
# here [3, 4] is a mutable list
# this will cause an error.

my_set = {1, 2, [3, 4]}

Saída

{1, 2, 3, 4}
{1, 2, 3}
Traceback (most recent call last):
  File "<string>", line 15, in <module>
    my_set = {1, 2, [3, 4]}
TypeError: unhashable type: 'list'

Criar um conjunto vazio é um pouco complicado.

Chaves vazias {} fará um dicionário vazio em Python. Para fazer um conjunto sem nenhum elemento, usamos o set() função sem nenhum argumento.

# Distinguish set and dictionary while creating empty set

# initialize a with {}
a = {}

# check data type of a
print(type(a))

# initialize a with set()
a = set()

# check data type of a
print(type(a))

Saída

<class 'dict'>
<class 'set'>

Modificando um conjunto em Python

Os conjuntos são mutáveis. No entanto, uma vez que eles são desordenados, a indexação não tem significado.

Não podemos acessar ou alterar um elemento de um conjunto usando indexação ou fatiamento. O tipo de dados definido não é compatível.

Podemos adicionar um único elemento usando o add() método e vários elementos usando o update() método. O update() O método pode receber tuplas, listas, strings ou outros conjuntos como seu argumento. Em todos os casos, as duplicatas são evitadas.

# initialize my_set
my_set = {1, 3}
print(my_set)

# my_set[0]
# if you uncomment the above line
# you will get an error
# TypeError: 'set' object does not support indexing

# add an element
# Output: {1, 2, 3}
my_set.add(2)
print(my_set)

# add multiple elements
# Output: {1, 2, 3, 4}
my_set.update([2, 3, 4])
print(my_set)

# add list and set
# Output: {1, 2, 3, 4, 5, 6, 8}
my_set.update([4, 5], {1, 6, 8})
print(my_set)

Saída

{1, 3}
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6, 8}

Removendo elementos de um conjunto

Um item específico pode ser removido de um conjunto usando os métodos discard() e remove() .

A única diferença entre os dois é que o discard() A função deixa um conjunto inalterado se o elemento não estiver presente no conjunto. Por outro lado, o remove() A função irá gerar um erro em tal condição (se o elemento não estiver presente no conjunto).

O exemplo a seguir ilustrará isso.

# Difference between discard() and remove()

# initialize my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)

# discard an element
# Output: {1, 3, 5, 6}
my_set.discard(4)
print(my_set)

# remove an element
# Output: {1, 3, 5}
my_set.remove(6)
print(my_set)

# discard an element
# not present in my_set
# Output: {1, 3, 5}
my_set.discard(2)
print(my_set)

# remove an element
# not present in my_set
# you will get an error.
# Output: KeyError

my_set.remove(2)

Saída

{1, 3, 4, 5, 6}
{1, 3, 5, 6}
{1, 3, 5}
{1, 3, 5}
Traceback (most recent call last):
  File "<string>", line 28, in <module>
KeyError: 2

Da mesma forma, podemos remover e retornar um item usando o pop() método.

Como set é um tipo de dados não ordenado, não há como determinar qual item será exibido. É completamente arbitrário.

Também podemos remover todos os itens de um conjunto usando o clear() método.

# initialize my_set
# Output: set of unique elements
my_set = set("HelloWorld")
print(my_set)

# pop an element
# Output: random element
print(my_set.pop())

# pop another element
my_set.pop()
print(my_set)

# clear my_set
# Output: set()
my_set.clear()
print(my_set)

print(my_set)

Saída

{'H', 'l', 'r', 'W', 'o', 'd', 'e'}
H
{'r', 'W', 'o', 'd', 'e'}
set()

Operações do conjunto Python

Conjuntos podem ser usados para realizar operações matemáticas de conjuntos como união, interseção, diferença e diferença simétrica. Podemos fazer isso com operadores ou métodos.

Vamos considerar os dois conjuntos a seguir para as seguintes operações.

>>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}

Definir União

União de A e B é um conjunto de todos os elementos de ambos os conjuntos.

A união é realizada usando | operador. O mesmo pode ser feito usando o union() método.

# Set union method
# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# use | operator
# Output: {1, 2, 3, 4, 5, 6, 7, 8}
print(A | B)

Saída

{1, 2, 3, 4, 5, 6, 7, 8}

Experimente os exemplos a seguir no shell do Python.

# use union function
>>> A.union(B)
{1, 2, 3, 4, 5, 6, 7, 8}

# use union function on B
>>> B.union(A)
{1, 2, 3, 4, 5, 6, 7, 8}

Definir interseção

Intersecção de A e B é um conjunto de elementos que são comuns em ambos os conjuntos.

A interseção é realizada usando & operador. O mesmo pode ser feito usando o intersection() método.

# Intersection of sets
# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# use & operator
# Output: {4, 5}
print(A & B)

Saída

{4, 5}

Experimente os exemplos a seguir no shell do Python.

# use intersection function on A
>>> A.intersection(B)
{4, 5}

# use intersection function on B
>>> B.intersection(A)
{4, 5}

Definir diferença

Diferença do conjunto B do conjunto A (A - B ) é um conjunto de elementos que estão apenas em A mas não em B . Da mesma forma, B - A é um conjunto de elementos em B mas não em A .

A diferença é realizada usando - operador. O mesmo pode ser feito usando o difference() método.

# Difference of two sets
# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# use - operator on A
# Output: {1, 2, 3}
print(A - B)

Saída

{1, 2, 3}

Experimente os exemplos a seguir no shell do Python.

# use difference function on A
>>> A.difference(B)
{1, 2, 3}

# use - operator on B
>>> B - A
{8, 6, 7}

# use difference function on B
>>> B.difference(A)
{8, 6, 7}

Definir diferença simétrica

Diferença simétrica de A e B é um conjunto de elementos em A e B mas não em ambos (excluindo a interseção).

A diferença simétrica é realizada usando ^ operador. O mesmo pode ser feito usando o método symmetric_difference() .

# Symmetric difference of two sets
# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# use ^ operator
# Output: {1, 2, 3, 6, 7, 8}
print(A ^ B)

Saída

{1, 2, 3, 6, 7, 8}

Experimente os exemplos a seguir no shell do Python.

# use symmetric_difference function on A
>>> A.symmetric_difference(B)
{1, 2, 3, 6, 7, 8}

# use symmetric_difference function on B
>>> B.symmetric_difference(A)
{1, 2, 3, 6, 7, 8}

Outros métodos de conjunto Python

Existem muitos métodos definidos, alguns dos quais já usamos acima. Aqui está uma lista de todos os métodos que estão disponíveis com os objetos definidos:

Método	Descrição
adicionar()	Adiciona um elemento ao conjunto
limpar()	Remove todos os elementos do conjunto
copiar()	Retorna uma cópia do conjunto
diferença()	Retorna a diferença de dois ou mais conjuntos como um novo conjunto
difference_update()	Remove todos os elementos de outro conjunto deste conjunto
descartar()	Remove um elemento do conjunto se for um membro. (Não faça nada se o elemento não estiver em conjunto)
interseção()	Retorna a interseção de dois conjuntos como um novo conjunto
intersection_update()	Atualiza o conjunto com a interseção entre ele e outro
édisjunto()	Retorna `True` se dois conjuntos tiverem uma interseção nula
issubset()	Retorna `True` se outro conjunto contiver este conjunto
issuperconjunto()	Retorna `True` se este conjunto contém outro conjunto
pop()	Remove e retorna um elemento set arbitrário. Aumenta `KeyError` se o conjunto estiver vazio
remover()	Remove um elemento do conjunto. Se o elemento não for um membro, gera um `KeyError`
diferença_simétrica()	Retorna a diferença simétrica de dois conjuntos como um novo conjunto
symmetric_difference_update()	Atualiza um conjunto com a diferença simétrica entre ele e outro
união()	Retorna a união de conjuntos em um novo conjunto
atualizar()	Atualiza o conjunto com a união dele mesmo e de outros

Outras operações de conjunto

Definir teste de associação

Podemos testar se um item existe em um conjunto ou não, usando o in palavra-chave.

# in keyword in a set
# initialize my_set
my_set = set("apple")

# check if 'a' is present
# Output: True
print('a' in my_set)

# check if 'p' is present
# Output: False
print('p' not in my_set)

Saída

True
False

Iterando por meio de um conjunto

Podemos percorrer cada item em um conjunto usando um for ciclo.

>>> for letter in set("apple"):
...     print(letter)
...    
a
p
e
l

Funções incorporadas com conjunto

Funções integradas como all() , any() , enumerate() , len() , max() , min() , sorted() , sum() etc. são comumente usados com conjuntos para realizar diferentes tarefas.

Função	Descrição
todos()	Retorna `True` se todos os elementos do conjunto forem verdadeiros (ou se o conjunto estiver vazio).
qualquer()	Retorna `True` se algum elemento do conjunto for verdadeiro. Se o conjunto estiver vazio, retorna `False` .
enumerar()	Retorna um objeto enumerado. Ele contém o índice e o valor de todos os itens do conjunto como um par.
len()	Retorna o comprimento (o número de itens) no conjunto.
máximo()	Retorna o maior item do conjunto.
min()	Retorna o menor item do conjunto.
classificado()	Retorna uma nova lista ordenada de elementos no conjunto (não ordena o próprio conjunto).
soma()	Retorna a soma de todos os elementos do conjunto.

Python Frozenset

Frozenset é uma nova classe que possui as características de um conjunto, mas seus elementos não podem ser alterados uma vez atribuídos. Enquanto tuplas são listas imutáveis, frozensets são conjuntos imutáveis.

Os conjuntos que são mutáveis não podem ser compartilhados, portanto, não podem ser usados como chaves de dicionário. Por outro lado, os frozensets são hashable e podem ser usados como chaves para um dicionário.

Frozensets podem ser criados usando a função frozenset().

Este tipo de dados suporta métodos como copy() , difference() , intersection() , isdisjoint() , issubset() , issuperset() , symmetric_difference() e union() . Sendo imutável, não possui métodos que adicionam ou removem elementos.

# Frozensets
# initialize A and B
A = frozenset([1, 2, 3, 4])
B = frozenset([3, 4, 5, 6])

Experimente estes exemplos no shell do Python.

>>> A.isdisjoint(B)
False
>>> A.difference(B)
frozenset({1, 2})
>>> A | B
frozenset({1, 2, 3, 4, 5, 6})
>>> A.add(3)
...
AttributeError: 'frozenset' object has no attribute 'add'

Strings Python Dicionário Python

python