Neste tutorial, você aprenderá o básico dos conjuntos do Python e os vários métodos de conjunto que você pode usar para modificar os conjuntos do Python.
Os conjuntos são uma das estruturas de dados internas do Python. Quando você precisa trabalhar com uma coleção não repetida de elementos, você usará o conjunto como a estrutura de dados principal.
Nas várias seções a seguir, veremos os fundamentos dos conjuntos python e os métodos de conjunto que você pode usar para trabalhar com eles. Em seguida, aprenderemos como realizar operações comuns de conjunto em Python.
Vamos começar!
últimas postagens
Noções básicas de conjuntos Python
Em Python, um conjunto é uma coleção não ordenada de elementos não repetidos. Isso significa que os elementos em um conjunto devem ser todos distintos.
Você pode adicionar e remover elementos de um conjunto; portanto, o conjunto é uma coleção mutável. Ele pode conter elementos de diferentes tipos de dados. No entanto, os elementos individuais em um conjunto devem ser hashable.
Em Python, diz-se que um objeto é hashável se seu valor de hash nunca muda. A maioria dos objetos imutáveis, como strings, tuplas e dicionários do Python, são hashable.
Aprenderemos detalhadamente sobre a criação de conjuntos. Por enquanto, considere os dois conjuntos a seguir:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
O primeiro conjunto contém três números, uma tupla e uma string. A inicialização do conjunto é executada sem erros. Enquanto o segundo conjunto contém uma lista em vez de uma tupla. Uma lista é uma coleção mutável, não pode ser hash e a inicialização gera um TypeError.
📑 Juntando tudo, podemos definir um conjunto Python como uma coleção mutável de elementos distintos e hashable.
Como criar um conjunto Python
Começaremos aprendendo como criar um conjunto em Python.
#1. Usando inicialização explícita
Você pode criar um conjunto em Python especificando os elementos do conjunto, separados por vírgulas (,) e entre chaves {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Se você já trabalhou com listas Python antes, você sabe que [] inicializa uma lista vazia. Mesmo que um conjunto Python esteja entre chaves {}, você não pode usar um par {} para inicializar um conjunto. Isso ocorre porque {} inicializa um dicionário Python e não um conjunto Python.
py_set2 = {}
type(py_set2)
# Output
dict
Você pode chamar novamente a função type() para verificar se py_set é um dicionário (dict).
#2. Usando a função set()
Se você quiser inicializar um conjunto vazio e adicionar elementos a ele, poderá fazê-lo usando a função set().
py_set3 = set() type(py_set3) # Output set
#3. Lançando outros iteráveis em um conjunto
Outra maneira de criar conjuntos é converter outros iteráveis, como listas e tuplas, em conjuntos, usando set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set
No exemplo acima, py_list contém ‘C’ duas vezes. Mas em py_set4, ‘C’ aparece apenas uma vez, pois o conjunto é uma coleção de elementos distintos. Essa técnica de conversão no conjunto é frequentemente usada para remover duplicatas das listas do Python.
Como adicionar elementos a um conjunto Python
Vamos começar criando um conjunto vazio py_set e trabalhar com ele pelo restante deste tutorial.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Usando o método .add()
Para adicionar elementos a um conjunto, você pode usar o método .add(). set.add(element) adiciona elemento ao conjunto.
Para maior clareza, adicionaremos elementos ao conjunto Python e imprimiremos o conjunto em cada etapa.
▶️ Vamos adicionar a string ‘Python’ como elemento ao py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Em seguida, adicionaremos outro elemento.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
É importante entender que o método .add() só adiciona um elemento ao conjunto se ele ainda não estiver presente. Se o conjunto já contiver o elemento que você deseja adicionar, a operação de adição não terá efeito.
Para verificar isso, vamos tentar adicionar ‘C++’ a py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
O conjunto contém ‘C++’, portanto, a operação de adição não tem efeito.
▶️ Vamos adicionar mais alguns elementos ao conjunto.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Usando o método .update()
Até agora, vimos como adicionar elementos ao conjunto existente – um elemento por vez.
E se você quiser adicionar mais de um elemento a uma sequência de elementos?
Você pode fazer isso usando o método .update() com a sintaxe: set.update(collection) para adicionar elementos na coleção a um conjunto. A coleção pode ser uma lista, tupla, dicionário e assim por diante.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Esse método é útil quando você deseja adicionar uma coleção de elementos a um conjunto sem criar outro objeto na memória.
Na próxima seção, vamos aprender como remover elementos de um conjunto.
Como remover elementos de um conjunto Python
Vamos considerar o seguinte conjunto (py_set antes da operação de atualização).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Usando o método .pop()
set.pop() remove um elemento aleatoriamente do conjunto e o retorna. Vamos chamar o método pop em py_set e ver o que ele retorna.
py_set.pop() # Output 'Rust'
Desta vez, a chamada ao método .pop() retornou a string ‘Rust’.
Nota: Como o método .pop() retorna um elemento aleatoriamente, quando você executa o código no final, você pode obter outro elemento.
Quando examinamos o conjunto, ‘Rust’ não está mais presente no conjunto.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Usando os métodos .remove() e descarte()
Na prática, você pode querer remover elementos específicos do conjunto. Para fazer isso, você pode usar os métodos .remove() e .discard().
set.remove(element) remove elementos do conjunto.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Se tentarmos remover um elemento não presente no conjunto, encontraremos um KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Vamos dar uma olhada em py_set novamente. Agora temos três elementos.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Com a sintaxe set.discard(element), o método .discard() também remove elementos do conjunto.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
No entanto, ele difere do método .remove() porque não gera um KeyError quando tentamos remover um elemento que não está presente.
Se tentarmos remover ‘Scala’ (que não existe) da lista usando o método .discard(), não veremos nenhum erro.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Como acessar elementos de um conjunto Python
Até agora, aprendemos como adicionar e remover elementos de conjuntos Python. No entanto, ainda não vimos como acessar elementos individuais em um conjunto.
Como um conjunto é uma coleção não ordenada, não é indexável. Portanto, se você tentar acessar os elementos de um conjunto usando o índice, encontrará um erro, conforme mostrado.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Então, como você acessa elementos em um conjunto?
Existem duas maneiras comuns de fazer isso:
- Percorra o conjunto e acesse cada elemento
- Verifique se um determinado elemento é um membro do conjunto
▶️ Faça um loop pelo conjunto e acesse os elementos usando um loop for.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
Na prática, você pode querer verificar se um determinado elemento está presente no conjunto usando o operador in.
Nota: elemento em set retorna True se o elemento estiver presente em set; senão ele retorna False.
Neste exemplo, py_set contém ‘C++’ e não contém ‘Julia’ e o operador in retorna True e False, respectivamente.
'C++' in py_set # True 'Julia' in py_set # False
Como encontrar o comprimento de um conjunto Python
Como visto anteriormente, você pode usar a função len() para obter o número de elementos presentes em um conjunto.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Como limpar um conjunto Python
Para limpar um conjunto removendo todos os elementos, você pode usar o método .clear().
Vamos chamar o método .clear() em py_set.
py_set.clear()
Se você tentar imprimi-lo, obterá set() – indicando que o conjunto está vazio. Você também pode chamar a função len() para verificar se o comprimento do conjunto é zero.
print(py_set) # set() print(len(py_set)) # 0
Até agora, aprendemos como realizar operações CRUD básicas em conjuntos Python:
- Criar: usando a função set(), conversão de tipo e inicialização
- Ler: acessar elementos do conjunto usando loops e operador in para teste de associação
- Atualizar: adicionar, remover elementos de conjuntos e atualizar conjuntos
- Excluir: Limpe um conjunto removendo todos os elementos dele
Operações de conjunto comuns, explicadas com código Python
Os conjuntos Python também nos permitem realizar as operações básicas de conjunto. Vamos aprender sobre eles nesta seção.
#1. União de conjuntos em Python
Na teoria dos conjuntos, a união de dois conjuntos é o conjunto de todos os elementos em pelo menos um dos dois conjuntos. Se houver dois conjuntos, A e B, então a união contém elementos que estão presentes apenas em A, apenas em B, e os elementos presentes em A e B.
Para encontrar a união de conjuntos, você pode usar o | ou o .union() o método com a sintaxe: setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Set union é uma operação comutativa; então AUB é o mesmo que BU A. Vamos verificar isso trocando as posições de setA e setB na chamada do método .union().
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Intersecção de conjuntos em Python
Outra operação de conjunto conjunto é essa interseção de dois conjuntos, A e B. A operação de interseção de conjunto retorna um conjunto que contém todos os elementos presentes em A e B.
Para calcular a interseção, você pode usar o operador & ou o método .intersection(), conforme explicado no trecho de código abaixo.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
Neste exemplo, o elemento 9 está presente em setA e setB; então o conjunto de interseção contém apenas este elemento.
Como a união de conjuntos, a interseção de conjuntos também é uma operação comutativa.
setB.intersection(setA)
# Output
{9}
#3. Definir diferença em Python
Dados quaisquer dois conjuntos, a união e a interseção nos ajudam a encontrar os elementos presentes em ambos e pelo menos um dos conjuntos, respectivamente. Por outro lado, a diferença de conjuntos nos ajuda a encontrar os elementos presentes em um conjunto, mas não no outro.
– setA.difference(setB) fornece o conjunto de elementos que estão presentes apenas em setA e não em setB.
– setB.difference(setA) fornece o conjunto de elementos que estão presentes apenas em setB e não em setA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
Claramente, AB não é o mesmo que BA, então a diferença de conjunto não é uma operação comutativa.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Diferença de conjunto simétrico em Python
Enquanto a interseção de conjuntos nos dá elementos presentes em ambos os conjuntos, a diferença de conjuntos simétrica retorna o conjunto de elementos presentes em exatamente um dos conjuntos.
Considere o exemplo a seguir.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Para calcular o conjunto de diferenças simétricas, você pode usar o operador ^ ou o método .symmetric_difference().
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Os elementos 10 e 12 estão presentes tanto no setA quanto no setB. Portanto, eles não estão presentes no conjunto de diferenças simétricas.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Como a operação de diferença de conjunto simétrica coleta todos os elementos que aparecem em exatamente um dos dois conjuntos, o conjunto resultante é o mesmo, independentemente da ordem em que os elementos são coletados. Portanto, uma diferença de conjunto simétrica é uma operação comutativa.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Subconjuntos e superconjuntos em Python
Na teoria dos conjuntos, subconjuntos e superconjuntos ajudam a entender a relação entre dois conjuntos.
Dados dois conjuntos A e B, o conjunto B é um subconjunto do conjunto A se todos os elementos do conjunto B também estiverem presentes no conjunto A. E o conjunto A é o superconjunto do conjunto B.
Considere o exemplo de dois conjuntos: idiomas e idiomas_extended.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
Em Python, você pode usar o método .issubset() para verificar se um determinado conjunto é um subconjunto de outro conjunto.
setA.issubset(setB) retorna True se setA for um subconjunto de setB; caso contrário, ele retorna False.
Neste exemplo, os idiomas são um subconjunto de language_extended.
languages.issubset(languages_extended) # Output True
Da mesma forma, você pode usar o método .issuperset() para verificar se um determinado conjunto é um superconjunto de outro conjunto.
setA.issuperset(setB) retorna True se setA for um superconjunto de setB; caso contrário, ele retorna False.
languages_extended.issuperset(languages) # Output True
Como language_extended é um superconjunto de idiomas, language_extended.issuperset(languages) retorna True, como visto acima.
Conclusão
Espero que este tutorial tenha ajudado você a entender o funcionamento dos conjuntos Python, os métodos de conjunto para operações CRUD e operações comuns de conjunto. Como próximo passo, você pode tentar usá-los em seus projetos Python.
Você pode conferir outros guias detalhados do Python. Feliz aprendizado!