Compreensão do conjunto Python: como e quando usá-los
As compreensões de conjuntos do Python fornecem uma maneira concisa de criar e manipular conjuntos em seu código. Eles geram conjuntos com sintaxe limpa, tornando seu código mais legível e Pythonic. Com a compreensão de conjuntos, você pode criar, transformar e filtrar conjuntos, que são ótimas habilidades para adicionar ao seu kit de ferramentas de programação Python.
Ao final deste tutorial, você entenderá que:
- Python possui compreensões de conjuntos, que permitem criar conjuntos com uma sintaxe concisa.
- Python tem quatro tipos de compreensões: lista, conjunto, dicionário e gerador expressões.
- Uma compreensão do conjunto pode ser escrita como
{expressão para item em iterable [se condição]}
. - Os conjuntos não podem conter duplicados, pois garantem que todos os seus elementos sejam únicos.
Para tirar o máximo proveito deste tutorial, você deve estar familiarizado com os conceitos básicos do Python, como para
loops, iterables, List Compreensões e compreensões de dicionário.
Criando e transformando conjuntos em Python
Na programação Python, pode ser necessário criar, preencher e transformar conjuntos. Para fazer isso, você pode usar set literais, o construtor set()
e loops for
. Nas seções a seguir, você verá rapidamente como usar essas ferramentas. Você também aprenderá sobre compreensões de conjuntos, que são uma maneira poderosa de manipular conjuntos em Python.
Criando conjuntos com literais e set()
Para criar novos conjuntos, você pode usar literais. Um conjunto literal é uma série de elementos fechados em aparelhos encaracolados. A sintaxe de um conjunto literal é mostrada abaixo:
{element_1, element_2,..., element_N}
Os elementos devem ser objetos hashable. Os objetos no literal podem ser duplicados, mas apenas uma instância será armazenada no conjunto resultante. Os conjuntos não permitem elementos duplicados. Aqui está um exemplo rápido de um conjunto:
>>> colors = {"blue", "red", "green", "orange", "green"}
>>> colors
{'red', 'green', 'orange', 'blue'}
>>> colors.add("purple")
>>> colors
{'red', 'green', 'orange', 'purple', 'blue'}
Neste exemplo, você cria um conjunto contendo nomes de cores. Os elementos do conjunto resultante são objetos de string exclusivos. Você pode adicionar novos elementos usando o método .add()
. Lembre-se de que os conjuntos são coleções não ordenadas; portanto, a ordem dos elementos no conjunto resultante não corresponderá à ordem de inserção na maioria dos casos.
Nota: Para saber mais sobre os conjuntos, confira os conjuntos no tutorial do Python.
Você também pode criar um novo conjunto usando o construtor set()
e um iterável de objetos:
>>> numbers = [2, 2, 1, 4, 2, 3]
>>> set(numbers)
{1, 2, 3, 4}
Neste exemplo, você cria um novo conjunto usando set()
com uma lista de valores numéricos. Observe como o conjunto resultante não contém elementos duplicados. Na prática, o construtor set()
é uma ótima ferramenta para eliminar valores duplicados em iteráveis.
Para criar um conjunto vazio, você usa o construtor set()
sem argumentos:
>>> set()
set()
Você não pode criar um conjunto vazio com um literal porque um par de aparelhos encaracolados {}
representa um dicionário vazio, não um conjunto. Para criar um conjunto vazio, você deve usar o construtor set()
.
Usando para
loops para preencher conjuntos
Às vezes, você precisa começar com um conjunto vazio e preenchê-lo com elementos dinamicamente. Para fazer isso, você pode usar um loop for
. Por exemplo, digamos que você deseja criar um conjunto de palavras exclusivas a partir de um texto. Veja como fazer isso com um loop:
>>> unique_words = set()
>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()
>>> for word in text.split():
... unique_words.add(word)
...
>>> unique_words
{
'beautiful',
'ugly',
'better',
'implicit',
'complicated',
'than',
'explicit',
'is',
'complex',
'simple'
}
Neste exemplo, você primeiro cria um conjunto vazio usando set()
. Você aplica letras minúsculas ao texto usando o método .lower()
para tornar a extração de palavras insensível a maiúsculas e minúsculas. Em seguida, você executa um loop em uma lista de palavras extraídas do texto.
Como uma abordagem rápida, você usou o método .split()
para dividir o texto em palavras individuais usando o caractere espacial como um separador.
Nota: o texto usado neste exemplo faz parte do Zen do Python, uma série de princípios que sustentam a filosofia de design do Python.
O loop tenta adicionar uma palavra ao conjunto em cada iteração. No entanto, se uma palavra já estiver no conjunto, nenhuma nova instância será adicionada. É por isso que o conjunto resultante possui apenas uma instância de better
, por exemplo. O loop é legível e claro, mas você pode usar um conjunto de compreensão para tornar seu código ainda mais conciso.
Apresentando compreensões de conjunto
As compreensões de conjunto permitem que você construa conjuntos com um loop for
de uma linha. Se você estiver familiarizado com a compreensão de listas, compreenderá rapidamente a compreensão de conjuntos. Ambas as construções têm sintaxe semelhante. A principal diferença é que as compreensões de conjunto usam chaves em vez de colchetes.
Aqui está a sintaxe para uma compreensão de conjunto:
{expression for member in iterable [if condition]}
Um conjunto de compreensão retorna um novo conjunto. Para construir esse conjunto, você calcula os elementos a partir dos itens de um iterável de entrada. A sintaxe inclui um condicional opcional no final, que você pode usar para filtrar coleções existentes ou gerar elementos condicionalmente.
A sintaxe de compreensão do conjunto consiste em quatro elementos -chave:
- Colchetes: Chaves (
{}
) são usadas para definir a compreensão do conjunto. - A expressão de compreensão: uma expressão que fornece um elemento em cada iteração.
- O membro atual
- o
iterable
: Este pode ser qualquer objeto Iterable Python, incluindo uma lista, tupla, conjunto, gerador ou tipos semelhantes.
O código a seguir mostra como você pode criar um conjunto de palavras únicas usando uma compreensão:
>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()
>>> {word for word in text.split()}
{
'beautiful',
'ugly',
'better',
'implicit',
'complicated',
'than',
'explicit',
'is',
'complex',
'simple'
}
Neste exemplo, você usa uma compreensão definida para extrair palavras exclusivas do texto original. A sintaxe é concisa e clara, melhorando a legibilidade do seu código.
Na prática, quando você não precisa transformar os dados para gerar os elementos do seu conjunto, você pode substituir o loop da seção anterior e a compreensão acima com o seguinte código:
>>> set(text.split())
{
'beautiful',
'ugly',
'better',
'implicit',
'complicated',
'than',
'explicit',
'is',
'complex',
'simple'
}
Neste exemplo, você passa o texto dividido diretamente para o construtor set()
e obtém o mesmo resultado do loop ou compreensão. Você pode fazer isso porque os elementos definidos não precisam percorrer uma transformação.
As compreensões também podem incluir mais de uma cláusula para
. Quando o fazem, o mais à esquerda para
itera sobre a coleção externa, o próximo para
da esquerda para a direita itera o primeiro nível de nidificação e assim por diante.
Para ilustrar, digamos que você tenha uma lista de listas. Cada lista aninhada contém números e você deseja criar um conjunto com seus valores quadrados. Para fazer isso, você pode usar uma compreensão com duas cláusulas for
conforme mostrado abaixo:
>>> matrix = [
... [9, 3, 8, 3],
... [4, 5, 2, 8],
... [6, 4, 3, 1],
... [1, 0, 4, 5],
... ]
>>> {value**2 for row in matrix for value in row}
{64, 1, 0, 4, 36, 9, 16, 81, 25}
Neste exemplo, o primeiro para
loop itera sobre as linhas da sua matriz. O segundo para
loop itera o número em cada linha. Como resultado, você obtém um conjunto de valores quadrados.
É importante observar que, neste exemplo, em vez de ter 16 elementos, você acaba com apenas nove. Isso ocorre porque os elementos definidos são únicos. Quando um elemento é duplicado, a nova instância não é adicionada ao conjunto final.
Alavancando o conjunto de compreensões em Python
Com a compreensão de conjuntos, você pode criar novos conjuntos, transformar os existentes e até mesmo filtrar elementos usando condicionais. Nas seções a seguir, você aprenderá como usar a compreensão de conjuntos para abordar esses casos de uso.
Para começar, você aprenderá como usar compreensões para criar novos conjuntos a partir de iteráveis existentes.
Criando conjuntos a partir de iteráveis
Às vezes, você tem dados iteráveis e deseja criar um conjunto usando os itens de dados para gerar os elementos por meio de alguma transformação de dados.
Por exemplo, digamos que você tenha uma lista de ferramentas e bibliotecas. Você precisa verificar continuamente se uma determinada ferramenta está na lista. Para fazer isso, você usa testes de associação. Você também precisa tornar seu código de código insensível, para que você decida transformar todas as palavras em letras minúsculas.
Os conjuntos são mais eficientes que as listas nos testes de pertinência. Portanto, você também decide converter sua lista de ferramentas em um conjunto de palavras minúsculas:
>>> tools = ["Python", "Django", "Flask", "pandas", "NumPy"]
>>> tools_set = {tool.lower() for tool in tools}
>>> tools_set
{'django', 'numpy', 'flask', 'pandas', 'python'}
>>> "python".lower() in tools_set
True
>>> "Pandas".lower() in tools_set
True
>>> "Numpy".lower() in tools_set
True
Na linha destacada, você usa uma compreensão do conjunto enquanto normaliza todos os valores para minúsculas para garantir comparações consistentes. Em seguida, você usa o no operador
para executar testes de associação e determinar se uma determinada ferramenta está na sua lista original.
Novamente, se você não precisar aplicar nenhuma transformação de dados aos itens da entrada iterável, não precisará usar uma compreensão do conjunto. Você pode usar set (iterable)
em vez disso. No exemplo acima, a transformação consiste em transformar os nomes de ferramentas em minúsculas.
Transformando conjuntos existentes
Você também pode usar as compreensões definidas para transformar rapidamente os conjuntos existentes. Diga que você tem um conjunto de endereços de email digitados pelo usuário. Você percebeu que alguns endereços incluem espaços de liderança e direita, bem como letras maiúsculas, e você deseja consertar isso. Mais importante, você notou que há um endereço de e -mail duplicado.
Você decide limpar isso com uma compreensão:
>>> emails = {
... " alice@example.org ",
... "BOB@example.com",
... "charlie@EXAMPLE.com",
... "David@example.net",
... " bob@example.com",
... "JohnDoe@example.com",
... }
>>> {email.strip().lower() for email in emails}
{
'alice@example.org',
'bob@example.com',
'johndoe@example.com',
'charlie@example.com',
'david@example.net'
}
Na linha destacada, você tem um conjunto de compreensão que remove espaços iniciais e finais de cada endereço usando o método .strip()
. Em seguida, aplica letras minúsculas a todos os endereços usando .lower()
. Como resultado da limpeza, o endereço duplicado é eliminado porque os conjuntos só podem conter itens exclusivos.
Filtrando itens de conjuntos
Às vezes, você precisa filtrar um conjunto existente e criar um novo com elementos que atendam a um determinado requisito ou condição. Por exemplo, diga que deseja filtrar seus endereços de email definidos para extrair apenas os e -mails .com
. Para fazer isso, você pode usar a seguinte compreensão:
>>> emails_set = {
... "alice@example.org",
... "bob@example.com",
... "johndoe@example.com",
... "charlie@example.com",
... "david@example.net",
... }
>>> {email for email in emails_set if email.endswith(".com")}
{'bob@example.com', 'charlie@example.com', 'johndoe@example.com'}
Neste exemplo, você usa uma condicional para criar um conjunto que inclui apenas os endereços de email no domínio .com
.
Decidindo quando usar as compreensões de set
Ao decidir usar uma compreensão de conjunto em vez de um loop regular ou uma combinação de chamadas de função, você deve considerar os seguintes fatores:
- Concisão: a compreensão do conjunto reduz a quantidade de código em comparação com loops
for
equivalentes. - Legabilidade : As compreensões definidas podem tornar seu código mais explícito e legível.
Na prática, você pode usar compreensões de conjunto quando precisar realizar as seguintes operações:
- Crie conjuntos de iteráveis existentes aplicando transformações de dados
- Transforme os elementos de um conjunto existente
- Filtre os elementos de um conjunto existente
Até agora, você aprendeu a fazer todas essas operações usando as compreensões do Set. Ainda assim, você pode encontrar outros bons casos de uso para as compreensões definidas durante sua experiência de codificação em Python.
Além disso, há situações em que o uso de compreensões definidas pode não ser necessário. Por exemplo, se você precisar remover itens duplicados de um iterável, basta usar a seguinte sintaxe:
>>> set([2, 2, 1, 4, 2, 3])
{1, 2, 3, 4}
Se você não precisar transformar os dados de entrada para gerar os elementos definidos, basta usar o construtor set()
. Esta é uma ótima maneira de remover itens duplicados de um iterável. No entanto, é importante observar que os objetos na entrada iterable devem ser hashable e a ordem original dos elementos não será preservada.
Explorando más práticas comuns
Existem algumas práticas ruins que você deseja evitar ao trabalhar com as compreensões definidas no seu código Python. Alguns dos mais comuns incluem:
- Usando expressões complexas em compreensões
- Escrevendo compreensões aninhadas com diversas cláusulas
for
ou condicionais - Tentando acessar variáveis de compreensão de fora
- Executando transformações dispendiosas ao construir os elementos do conjunto
Às vezes, você pode ter uma compreensão definida em que a expressão de compreensão é muito complicada.
Por exemplo, digamos que você criou um conjunto a partir de uma lista de números. Se o número for par, você quer que seja quadrado. Caso contrário, você quer seu cubo. Para fazer isso, você pode usar a seguinte compreensão:
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> {number**2 if number % 2 == 0 else number**3 for number in numbers}
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}
Nesta compreensão, você usa uma expressão relativamente complexa para gerar os elementos do conjunto. Pode ser um desafio ler essa compreensão e decifrar o que ela faz. Quando uma expressão complicada dificulta a leitura do seu código, você pode se beneficiar usando um loop for
regular:
>>> result_set = set()
>>> for number in numbers:
... if number % 2 == 0:
... value = number**2
... else:
... value = number**3
... result_set.add(value)
...
>>> result_set
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}
Este loop produz o mesmo resultado que a compreensão, mas pode ser mais explícito, tornando seu código mais legível.
Compreensões aninhadas com diversas cláusulas for
ou condicionais podem tornar seu código menos legível. Portanto, geralmente você deve evitá-los e usar construções mais legíveis, como um loop regular.
Tentar usar as variáveis que você define em uma compreensão fora da compreensão em si não é possível:
>>> {number**3 for number in range(1, 11)}
{64, 1, 512, 8, 1000, 343, 216, 729, 27, 125}
>>> number
Traceback (most recent call last):
...
NameError: name 'number' is not defined
A variável número
é visível apenas dentro da compreensão. Se você tentar usá -lo fora da compreensão, obterá uma exceção NameError
.
Às vezes, ao trabalhar com compreensões de conjunto, pode ser necessário executar transformações de dados dispendiosas para gerar elementos de conjunto. Nessas situações, você deve estar ciente de que a construção do conjunto final pode levar um tempo considerável. Uma solução possível é usar um gerador que produza os elementos sob demanda.
Conclusão
Você aprendeu detalhadamente sobre as compreensões de conjunto do Python. Eles são uma ferramenta poderosa para criar, transformar e filtrar conjuntos usando sintaxe concisa e limpa. Você também aprendeu algumas práticas inadequadas que deve evitar ao trabalhar com compreensões definidas.
As compreensões de conjunto são uma excelente ferramenta para desenvolvedores Python. Eles fornecem uma maneira Pythonic e simplificada de manipular conjuntos em Python.
Neste tutorial, você tem:
- criado novos conjuntos com uma sintaxe concisa
- transformado conjuntos existentes com compreensões
- filtrado elementos indesejados de conjuntos existentes
- Decidiu quando usar compreensões de conjunto em seu código
Com essas habilidades, você pode escrever um código mais legível e pitônico para processar conjuntos. À medida que você continua a usar as compreensões do Set, você as encontrará como uma ferramenta inestimável.
Perguntas frequentes
Agora que você tem alguma experiência com as compreensões do Set em Python, você pode usar as perguntas e respostas abaixo para verificar seu entendimento e recapitular o que aprendeu.
Essas perguntas frequentes estão relacionadas aos conceitos mais importantes que você abordou neste tutorial. Clique no Mostrar/Ocultar Alternar ao lado de cada pergunta para revelar a resposta:
A compreensão de conjuntos é uma maneira concisa de criar conjuntos em Python usando uma sintaxe semelhante à compreensão de listas. A principal diferença é que uma compreensão de conjunto usa chaves {}
, enquanto uma compreensão de lista usa colchetes []
. O resultado é um conjunto, que é uma coleção não ordenada de elementos únicos.
Você pode criar um conjunto a partir de um iterável usando a sintaxe do conjunto de compreensão: {para membro no iterable}
. Isso avaliará a expressão para cada membro do iterável e adicionará o resultado ao conjunto, garantindo que todos os elementos sejam únicos.
Você deve considerar o uso de compreensões definidas em loops regulares quando deseja criar conjuntos de forma concisa e melhorar a legibilidade do código. Eles são especialmente úteis ao transformar ou filtrar dados de um iterável para gerar elementos de conjunto exclusivos.
As práticas ruins comuns incluem o uso de expressões excessivamente complexas nas compreensões, a escrita de compreensões aninhadas com múltiplas para
cláusulas ou condicionais, tentando acessar variáveis de compreensão fora da compreensão e executar transformações caras que podem degradar o desempenho.
Sim, você pode usar compreensões de conjunto para filtrar elementos adicionando uma condicional no final da compreensão: True
.