2 - Coleções
As coleções são estruturas de dados com diferentes tipos de dados (listas, tuplas, dicionários e conjuntos), permitindo agrupar, organizar e manipular informações nos programas, funcionando como contêineres que nos permitem armazenar e organizar diferentes tipos de informações, como números, textos, objetos, coleções e muito mais.
As coleções são:
- Listas: Coleções ordenadas e mutáveis que podem conter diversos elementos. Aprenderemos como criar, acessar e modificar itens em listas, além de explorar as poderosas técnicas de compreensão de listas para operações mais avançadas.
- Tuplas: Semelhantes às listas, mas imutáveis, as tuplas são ideais para armazenar informações que não devem ser alteradas durante a execução do programa.
- Conjuntos: Coleções não ordenadas que garantem que não haja elementos duplicados. Veremos como usar conjuntos para realizar operações de união, interseção e diferença entre eles.
- Dicionários: Estruturas de chave-valor que nos permitem associar informações de maneira eficiente. Dicionários são amplamente utilizados para armazenar dados em formatos como JSON e são fundamentais em muitas aplicações.
Em Python, as listas, tuplas, dicionários e conjuntos são estruturas de dados que permitem armazenar coleções de elementos, cada uma com características e usos distintos, tornando-as úteis em diferentes situações.
Escolha a estrutura de dados mais adequada para cada situação e como trabalhar com elas em diferentes cenários.
Você descobrirá como usar as coleções para resolver problemas do mundo real e tornar seus programas mais inteligentes e flexíveis.
A prática é a chave para o domínio.
2.1 - Listas
As listas são sequências (coleções) ordenadas de elementos, que podem conter itens de diferentes tipos, como números, textos e outras estruturas de dados, como listas, tuplas, conjuntos e dicionários, entre outras.
Por sequências ordenadas entende-se que a ordem de declaração dos elementos de uma lista é mantida, possuindo um índice crescente, a partir de 0, correspondente ao elemento seguindo a essa ordem.
São definidas com colchetes "[" e "]" e elementos separados por vírgula ",".
São mutáveis, o que significa que é possível adicionar, modificar ou remover elementos após a criação da lista.
frutas = ["maçã", "banana", "laranja"]
numeros = [1, 2, 3, 4, 5]
mistura = [1, "python", True, [6, 7, 8]]
print(frutas)
print(numeros)
print(mistura)Operações com Listas:
- Acessar elementos da lista: Utilize o índice do elemento entre colchetes.
- Modificar elementos da lista: Atribua um novo valor a um elemento usando o índice.
- Adicionar elementos à lista: Utilize os métodos append() ou insert() para adicionar elementos no final ou em uma posição específica, respectivamente.
- Remover elementos da lista: Utilize os métodos remove(), pop() ou del para remover elementos da lista.
- Ordenação: Utilize o método sort() para ordenar a lista em ordem ascendente ou descendente.
- Reversão: Utilize o método reverse() para inverter a ordem da lista.
- Limpar a lista: Utilize o método clear() para remover todos os elementos da lista.
- Combinar listas: Utilize o método extend() para combinar duas ou mais listas.
- Copiar listas: Utilize o método copy() para criar uma cópia da lista.
- Concatenar listas: Utilize o operador "+" para concatenar duas ou mais listas.
2.1.1 - Acessar elementos da lista
Crie um uma nova Lista e imprima os elementos de cada índice.
frutas = ["maçã", "banana", "laranja"]
print(f"Primeira fruta: {frutas[0]}")
print(f"Segunda fruta: {frutas[1]}")
print(f"Terceira fruta: {frutas[2]}")2.1.2 - Modificar elementos da lista
Crie uma nova Lista.
Modifique os elementos da lista com novas frutas usando o índice.
Imprima os elementos da lista de cada índice.
frutas = ["maçã", "banana", "laranja"]
print(f"Primeira, segunda e terceira frutas antes: {frutas[0]}, {frutas[1]} e {frutas[2]}")
frutas[0] = "abacaxí"
frutas[1] = "manga"
frutas[2] = "uva"
print("Alterações: maçã por abacaxí, banana por manga e laranja por uva.")
print(f"Primeira, segunda e terceira frutas depois: {frutas[0]}, {frutas[1]} e {frutas[2]}")2.1.3 - Adicionar elementos à lista
Novos elementos podem ser adicionados ao final da lista com o método append(), novas coleções com o método extend(), ou em uma posição especifica com o método insert().
Adicione novas frutas ao final da lista com o método append().
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
frutas.append("abacaxí")
frutas.append("manga")
frutas.append("uva")
print("Novas frutas adicionadas: abacaxí, manga e uva.")
print(f"Lista depois da adição: {frutas}")Adicione novas frutas ao final da lista com o método extend().
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
frutas.extend(["abacaxí", "manga", "uva"])
print("Novas frutas adicionadas: abacaxí, manga e uva.")
print(f"Lista depois da adição: {frutas}")Adicione novas frutas em posição específica.
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
frutas.insert(1, "abacaxí")
frutas.insert(3, "manga")
frutas.insert(5, "uva")
print("Novas frutas adicionadas: abacaxí, manga e uva, nas posições 1, 3 e 5, respectivamente.")
print(f"Lista depois da adição: {frutas}")2.1.4 - Remover elementos da lista
Elementos podem ser removidos com o método remove(), pop() ou del.
Remova um determinado elemento usando remove() usando o valor do elemento a ser removido.
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
frutas.remove("banana")
print("O elemento 'banana' é removido: frutas.remove('banana')")
print(f"Lista depois da remoção: {frutas}")Remova o último elemento usando pop().
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
frutas.pop()
print("O elemento 'laranja' é removido: frutas.pop()")
print(f"Lista depois da remoção: {frutas}")Remova um elemento determinado de um índice usando pop().
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
frutas.pop(1)
print("O elemento 'banana' é removido: frutas.pop(1)")
print(f"Lista depois da remoção: {frutas}")Remova um determinado elemento de um índice usando del.
frutas = ["maçã", "banana", "laranja"]
print(f"A variável frutas é criada: frutas = {frutas}")
del frutas[1]
print("O elemento 'banana' é removido: del frutas[1]")
print(f"Lista depois da remoção: {frutas}")2.1.5 - Iteração de Listas
Iteração é o processo de percorrer os elementos de uma lista.
A forma mais comum de percorrer os elementos em uma lista é com o laço for.
Crie e imprima os elementos de uma lista com os nomes de frutas.
frutas = ["maçã", "banana", "laranja"]
for fruta in frutas:
print(fruta)Para escrever ou atualizar os elementos, use índices, geralmente combina-se as funções integradas range() e len().
Percorra usando o índice dos elementos de uma lista numérica, imprimindo o quadrado do valor.
valores = [1, 2, 3, 4, 5]
for i in range(len(valores)):
print(valores[i] ** 2)Percorra usando o índice dos elementos de uma lista numérica, modificando o valor com seu quadrado.
for i in range(len(valores)):
valores[i] = valores[i] ** 2
print(f"Valores modificados: {valores}")Um laço de lista vazia não executa o corpo do laço.
print('início')
for x in []:
print('essa instrução nunca será executada')
print('fim')Apesar de uma lista poder conter coleções como listas, tuplas ou dicionários, os elementos que são coleções contam como sendo um único elemento.
Crie uma lista com quatro elementos, sendo os terceiro e quarto elementos que são coleções.
lista_com_colecoes = ['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'],{1, 2, 3}]
print(lista_com_colecoes)2.1.6 - Ordenação de Listas
A ordenação é o processo de organização dos elementos da lista em ordem crescente ou decrescente, usando o método sort(), modificando a ordenação inicial, como foram declarados, dos elementos da lista.
Exemplo:
numeros = [5, 2, 8, 1, 3]
print("Lista original: ", numeros)
numeros.sort()
print("Lista original ordenada:", numeros)A função sorted() retorna uma nova lista ordenada sem alterar a original.
Exemplo:
numeros = [5, 2, 8, 1, 3]
numeros_ordenados = sorted(numeros)
print("Lista ordenada:", numeros_ordenados)
print("Lista original:", numeros)2.1.7 - Reversão de Listas
A reversão é o processo de inverter a ordem dos elementos de uma lista, tupla ou outro objeto iterável.
Exemplo:
numeros = [5, 2, 8, 1, 3]
numeros.reverse()
print("Lista invertida:", numeros)2.1.8 - Agregação de Lista
A agregação é o processo de combinar elementos de uma coleção em um único valor, como soma, média ou máximo.
Em Python, você pode usar as funções sum, max() e min() para realizar agregações.
Exemplo:
numeros = [1, 2, 3, 4, 5]
soma = sum(numeros) # Soma de todos os elementos
media = sum(numeros) / len(numeros) # Média dos elementos
maior = max(numeros) # Maior elemento
menor = min(numeros) # Menor elemento
print(soma)
print(media)
print(maior)
print(menor)2.1.9 - Fatias de listas
O operador de fatiamento [inicial:final] pode ser utilizado com listas.
Sendo omitido o índice inicial, o fatiamento começará a partir do primeiro elemento aos elemento final.
Sendo omitido o índice final, o fatiamento irá até do elemento inicial ao último elemento.
Se você omitir ambos, o fatiamento retornará uma cópia da lista inteira.
letras = ['a', 'b', 'c', 'd', 'e', 'f']
print(f"letras[1:3] = {letras[1:3]}")
print(f"letras[:4] = {letras[:4]}")
print(f"letras[3:] = {letras[3:]}")
print(f"letras[:] = {letras[:]}")Como as listas são mutáveis, pode ser útil fazer uma cópia antes de executar operações que as alterem.
Um operador de fatiamento à esquerda de uma atribuição pode atualizar vários elementos simultaneamente.
letras = ['a', 'b', 'c', 'd', 'e', 'f']
print(f"Lista original letras: {letras}")
letras[1:3] = ['x', 'y']
print("Modificação: letras[1:3] = ['x', 'y']")
print(f"Lista modificada: {letras}")2.1.10 - Compreensão de Listas
A compreensão de listas é uma construção poderosa em Python que permite criar-se listas baseadas em outras sequências ou operações, de forma concisa e elegante, sendo usada frequentemente para filtragem e mapeamento de dados em uma lista existente, retornando uma nova lista com os resultados.
É uma técnica avançada que simplifica o processo de criação de listas e melhora a legibilidade do código.
A sintaxe básica da compreensão de listas é a seguinte:
nova_lista = [expressão for elemento in lista_original if condição]Aqui está uma explicação de cada parte dessa sintaxe:
- nova_lista: É a lista que você deseja criar a partir da compreensão de listas.
- expressão: É uma operação que será aplicada a cada elemento da lista original para criar os elementos da nova lista.
- elemento: É a variável temporária que representa cada elemento da lista original durante as iterações.
- lista_original: É a lista ou objeto iterável que você deseja percorrer para criar a nova lista.
- condição: (opcional) É uma condição que pode ser usada para filtrar elementos da lista original que serão incluídos na nova lista.
Exemplo: Criar uma lista com os quadrados dos números de 0 a 5.
quadrados = [i * i for i in range(0, 6)]
print(quadrados) Compreender a manipulação e compreensão de listas é essencial para a programação, já que as listas são amplamente utilizadas em uma variedade de algoritmos e aplicativos.
Oferecem flexibilidade e são uma maneira poderosa de armazenar e manipular coleções de dados em um programa.
Ela é uma técnica que combina laços for com expressões em uma única linha de código para criar e modificar listas.
Vamos detalhar como usar a compreensão de listas em Python.
2.1.10.1 - Compreensão de Listas Básica
A estrutura básica de uma compreensão de listas consiste em uma expressão que é aplicada a cada item de uma sequência (como uma lista, tupla ou conjunto) usando uma ou mais cláusulas for para iterar sobre a sequência.
Exemplo: Criar uma lista com os quadrados dos números de 1 a 10.
# Criar uma lista com os quadrados dos números de 1 a 10
quadrados = [x**2 for x in range(1, 11)]
print(quadrados)Neste exemplo, a compreensão de listas cria uma nova lista quadrados contendo os quadrados de cada número no intervalo de 1 a 10.
Exemplo: Converter textos para letras maiúsculas:
frutas = ["maçã", "banana", "laranja"]
frutas_maiusculas = [fruta.upper() for fruta in frutas]
print(frutas_maiusculas)Exemplo: Criar uma lista com os rótulos dos sexos: M (Masculino) e F (Feminino).
codigos_sexo = [0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0]
# Um jeito
rotulos_sexo = ["M", "F"]
rotulos_codigos = [rotulos_sexo[codigo] for codigo in codigos_sexo]
print(rotulos_codigos)Neste exemplo, a compreensão de listas cria uma nova lista rotulos_codigos contendo os rótulos dos sexos correspondentes aos valores de codigos_sexo.
2.1.10.2 - Compreensão de Listas com Condições Aninhadas
Você também pode usar condições aninhadas com if para criar compreensões de listas mais complexas:
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9]
resultados = [num**2 if num % 2 == 0 else num**3 for num in numeros]
print(resultados) # Saída: [1, 4, 27, 16, 125, 36, 343, 64, 729]Neste exemplo, os números pares são elevados ao quadrado, enquanto os números ímpares são elevados ao cubo.
Observações:
A compreensão de listas é uma abordagem eficiente para criar listas de forma sucinta e elegante, substituindo a necessidade de usar laços for tradicionais.
Lembre-se de que a legibilidade do código é importante, portanto, use a compreensão de listas com moderação para não tornar o código excessivamente complexo.
A compreensão de listas é uma técnica avançada que torna seu código Python mais eficiente e expressivo. Ao dominar essa construção, você poderá criar listas personalizadas e filtradas com facilidade, melhorando a produtividade em seus projetos de desenvolvimento.
2.1.10.3 - Filtragem com Compreensão de Listas
Além de aplicar uma expressão a cada item da sequência, você pode adicionar uma cláusula if no for para filtrar os elementos que atendam a uma condição específica.
Exemplo: Criar uma lista com os números pares do intervalo de 1 a 10.
# Criar uma lista com os números pares do intervalo de 1 a 10
numeros_pares = [x for x in range(1, 11) if x % 2 == 0]
print(numeros_pares)Neste exemplo, a compreensão de listas cria uma nova lista numeros_pares contendo apenas os números pares do intervalo de 1 a 10.
2.1.10.4 - Compreensão de Listas com Múltiplos for
Você também pode usar múltiplas cláusulas for para criar combinações de elementos de diferentes sequências.
Exemplo: Criar uma lista de tuplas com todas as combinações possíveis de pares (letra, número).
# Lista de letras
letras = ['a', 'b', 'c']
# Lista de números
numeros = [1, 2, 3]
# Lista de tuplas com todas as combinações possíveis de pares (letra, número)
combinacoes = [(letra, numero) for letra in letras for numero in numeros]
print(combinacoes)Neste exemplo, a compreensão de listas cria uma lista de tuplas com todas as combinações possíveis de pares (letra, número) usando as listas letras e numeros.
2.1.10.5 - Compreensão de Listas com Condição em duas etapas
Você pode criar compreensões de listas com condições mais complexas usando if e else na expressão.
Exemplo: Criar uma lista com os números positivos elevados ao quadrado e, para os números negativos, exibir "N/A".
# Criar uma lista com os números positivos e negativos.
numeros = [1, -2, 3, -4, 5]
# Criar uma lista com os quadrados dos números positivos e, para os negativos, exibir "N/A".
resultados = [x**2 if x > 0 else "N/A" for x in numeros]
print(resultados)Neste exemplo, a compreensão de listas cria uma lista de números positivos elevados ao quadrado e, para os números negativos, insere o valor "N/A".
Exemplo: Criar uma lista com os rótulos dos sexos: M (Masculino) e F (Feminino).
codigos_sexo = [0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0]
rotulos_codigos = ["Masculino" if codigo == 0 else "Feminino" for codigo in codigos_sexo]
print(rotulos_codigos)Neste exemplo, a compreensão de listas cria uma nova lista rotulos_codigos contendo os rótulos dos sexos correspondentes aos valores de codigos_sexo.
2.1.11 - Limpar a Lista
O método clear() limpa uma lista.
Exemplo:
numeros = [1, 2, 3, 4, 5]
numeros.clear()
print(numeros)2.1.12 - Filtragem de Listas
A filtragem é o processo de selecionar elementos de uma lista e que atendam a determinados critérios.
Aqui, usaremos filter com uma função lambda para filtrar apenas os números pares de uma lista:
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares = filter(lambda x: x % 2 == 0, numeros)
print(list(pares)) # Output: [2, 4, 6, 8, 10]Neste exemplo, usamos a compreensão de listas para filtrar apenas os números pares da lista numeros.
2.1.13 - Mapeamento
O mapeamento é o processo de aplicar uma função a todos os elementos de uma coleção para obter uma nova coleção com os resultados.
Em Python, você pode usar a compreensão de listas para aplicar mapeamento de dados.
Exemplo:
Exemplo com map e Função Lambda: Vamos usar map para aplicar a função lambda a uma lista de números e calcular os quadrados de cada elemento.
numeros = [1, 2, 3, 4, 5]
quadrados = map(lambda x: x * x, numeros)
print(list(quadrados)) # Output: [1, 4, 9, 16, 25]2.1.14 - Conclusão
A compreensão de listas é uma técnica poderosa em Python que permite criar e modificar listas de forma concisa e eficiente.
Ela combina laços for com expressões em uma única linha de código, tornando o código mais legível e elegante.
Com a compreensão de listas, você pode realizar filtragem, mapeamento e combinação de elementos de diferentes sequências em uma única linha de código.
É uma ferramenta essencial para manipulação de dados em listas e aprimora significativamente a produtividade na programação Python.
2.2 - Tuplas
As tuplas são coleções ordenadas de elementos, assim como as listas, mas imutáveis, o que significa que não é possível alterar seus elementos após a criação.
São declaradas com os valores dos elemento separados por vírgulas ",".
cores = "vermelho", "verde", "azul"
numeros = 1, 2, 3, 4, 5
print(f"cores: {cores}")
print(f"numeros: {numeros}")Para criar uma tupla com um único elemento, é preciso incluir uma vírgula final.
t1 = 'a',
print(f"t1 = {t1} ({type(t1)})")
t2 = ('a')
print(f"t2 = {t2} ({type(t2)})")
t3 = ('a',)
print(f"t3 = {t3} ({type(t3)})")As tuplas podem ter os elementos declarados entre parênteses "(" e ")" e separados por vírgulas ",".
cores = ("vermelho", "verde", "azul")
numeros = (1, 2, 3, 4, 5)
print(f"cores: {cores}")
print(f"numeros: {numeros}")São frequentemente usadas quando os dados precisam ser protegidos contra alterações, preservando seu conteúdo original.
Outra forma de criar uma tupla é com a função integrada tuple(). Sem argumentos, cria uma tupla vazia.
t = tuple()
print(t)Se os argumentos forem uma sequência (texto, lista ou tupla), o resultado é uma tupla com os elementos da sequência.
t = tuple('CIEDA')
print(t)A palavra-reservada tuple() da função integrada não deve ser usada como nome de variável.
Operações com tuplas:
- Acessar elementos da tupla: Utilizar o índice do elemento entre colchetes.
- Iterar tuplas com for: Usar o método for para percorrer cada elemento da tupla.
- Atribuição de Tuplas: Atribuir um novo valor a um elemento usando o índice.
- Decompor tuplas: Desempacotar os elementos de uma tupla.
- Tuplas com argumentos: Utilize a função tuple() para criar uma tupla com argumentos.
2.2.1 - Acessar elementos da tupla
Para accessar elementos da tupla, utilize o índice do elemento com o operador de colchetes, assim como nas listas.
cores = ("vermelho", "verde", "azul")
numeros = (1, 2, 3, 4, 5)
x = ponto[0]
y = ponto[1]
vermelho = cores[0]
verde = cores[1]
azul = cores[2]imprima os valores acima:
print(f"x e y: {x} e {y}")
print(f"vermelho, verde e azul: {vermelho}, {verde} e {azul}")O operador de fatia seleciona vários elementos.
t = ('a', 'e', 'i', 'o', 'u')
print(t[1:3])Entretanto, como as tuplas são imutáveis, se tentar alterar um dos elementos da tupla, vai receber um erro.
t[0] = 'A'A solução é reatribuir uma nova tupla modificada.
t = ('a', 'e', 'i', 'o', 'u')
t = ('A',) + t[1:]
print(t)2.2.2 - Iterar tuplas com for
As tuplas podem ser iteradas:
tupla = ("texto", 2, 3.4, 4 + 3j, True)
for elemento in tupla:
print(elemento)2.2.3 - Atribuição de Tuplas
Muitas vezes, é útil trocar os valores de duas variáveis.
Com a atribuição convencional, usa-se uma variável temporária.
Por exemplo, trocar a e b.
temp = a
a = b
b = tempA atribuição de tuplas é direta.
print(f"a e b antes: {a} e {b}")
a, b = b, a
print(f"a e b depois: {a} e {b}")O lado esquerdo é uma tupla de variáveis; o lado direito é uma tupla de expressões.
Cada valor é atribuído à sua respectiva variável.
Todas as expressões no lado direito são avaliadas antes de todas as atribuições.
O número de variáveis à esquerda e o número de valores à direita precisam ser iguais.
a, b = 1, 2, 3De forma geral, o lado direito pode ter qualquer tipo de sequência (string, lista ou tupla).
Por exemplo, para dividir um endereço de email em um nome de usuário e um domínio, você poderia escrever:
endereco = 'roberto@cieda.com.br'
nome, dominio = endereco.split('@')
print(f"nome: {nome}")
print(f"domínio: {dominio}")O valor de retorno do split é uma lista com dois elementos; o primeiro elemento é atribuído a nome, o segundo a domínio.
2.2.4 - Decompor tuplas
As tuplas podem ser decompostas em várias variáveis:
tupla = ("texto", 2, 3.4, 4 + 3j, True)
x, y, z, w, v = tupla
print("x:", x)
print("y:", y)
print("z:", z)
print("w:", w)
print("v:", v)São bastante utilizadas para retornar valores de funções:
def operacoes_aritmeticas(a, b):
# retorna uma tupla
return a + b, a - b, a * b, a / b
a = 10
b = 5
print(f"a = {a}, b = {b}")
resultados = operacoes_aritmeticas(a, b)
print("resultados:", resultados)
soma, subtracao, multiplicacao, divisao = resultados
print(f"Soma, subtração, Multiplicação e divisão: {soma}, {subtracao}, {multiplicacao} e {divisao}")2.2.5 - Argumentos como Tuplas
As funções podem receber um número variável de argumentos. Um nome de parâmetro que comece com * reúne vários argumentos em uma tupla. Por exemplo, imprimir_todos() recebe qualquer número de argumentos e os exibe:
def imprimir_todos(*args):
print(args)O parâmetro com o prefixo * pode ter qualquer nome que você goste, mas args é o convencional.
imprimir_todos(1, 2.0, '3')Se você tiver uma sequência de valores e quiser passá-la a uma função como argumentos múltiplos, pode usar o operador *.
Por exemplo, o divmod() recebe exatamente dois argumentos; ele não funciona com uma tupla:
t = (7, 3)
divmod(t)No entanto, se você espalhar a tupla, aí funciona.
print(divmod(*t))Muitas das funções integradas usam tuplas com argumentos de comprimento variável.
Por exemplo, max e min podem receber qualquer número de argumentos.
print(f"max(1, 2, 3): {max(1, 2, 3)}") # max(1, 2, 3)
print(f"min(1, 2, 3): {min(1, 2, 3)}") # min(1, 2, 3)Mas usando a função sum, recebe apenas dois argumentos.
sum(1, 2, 3)Escreva uma função chamada somar_todos que receba qualquer número de argumentos e retorne a soma deles.
def somar_todos(*args):
return sum(args)print(f"somar_todos(1, 2, 3): {somar_todos(1, 2, 3)}")2.3 - Conjuntos
Os conjuntos são coleções não ordenadas e não contêm elementos duplicados.
São definidos utilizando chaves "{" e "}" ou utilizando o construtor set().
São mutáveis, permitindo adicionar e remover elementos após a criação.
Não podem conter valores duplicados, o que significa que o conjunto ignora valores já existentes.
Os elementos são desordenados, o que significa que os conjuntos são armazenados em ordem aleatória.
Exemplo:
numeros = {1, 2, 3, 4, 5}
vogais = set(["a", "e", "i", "o", "u"])
sem_repeticao = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5, "e", "o", "a", "i", 7.1, 7.3, 7.2, 7.1, "e", "u", "a", "i", "o", "u"}
print(f"Números: {numeros}")
print(f"Vogais: {vogais}")
print(f"Sem Repetição: {sem_repeticao}")Operações com Conjuntos:
- Adicionar elementos ao conjunto: Utilize o método add() para adicionar um único elemento ou o método update() para adicionar vários elementos de uma vez.
- Remover elementos do conjunto: Utilize o método remove() ou discard() para remover elementos.
- União, interseção e diferença: Utilize os operadores | (união), & (interseção) e - (diferença) para realizar essas operações entre conjuntos.
2.3.1 - Adição de elementos ao conjunto
Usando o método add():
numeros = {1, 2, 3}
numeros.add(4)
numeros.add(5)
print(f"Números: {numeros}")Usando o método update():
numeros = {1, 2, 3}
numeros.update([4, 5])
print(f"Números: {numeros}")2.3.2 - Remoção de elementos do conjunto
Usando o método remove():
numeros = {1, 2, 3}
numeros.remove(2)
print(f"Números: {numeros}")Usando o método discard():
numeros = {1, 2, 3}
numeros.discard(2)
print(f"Números: {numeros}")2.3.3 - União, Interseção e Diferença
As operações de conjuntos comuns são a união, interseção e diferença com os métodos union(), intersection() e difference(), respectivamente.
União
Usando o método union():
numeros_1 = {1, 2, 3, 4, 5}
numeros_2 = {4, 5, 6, 7, 8}
print(numeros_1.union(numeros_2))
print(numeros_1 | numeros_2)Interseção
Usando o método intersection():
numeros_1 = {1, 2, 3, 4, 5}
numeros_2 = {4, 5, 6, 7, 8}
print(numeros_1.intersection(numeros_2))
print(numeros_1 & numeros_2)Diferença
Usando o método difference():
numeros_1 = {1, 2, 3, 4, 5}
numeros_2 = {4, 5, 6, 7, 8}
print(numeros_1.difference(numeros_2))
print(numeros_1 - numeros_2)As listas, tuplas e conjuntos são estruturas de dados essenciais em Python, cada uma com suas particularidades e usos.
As listas são coleções mutáveis que permitem armazenar itens de diferentes tipos e realizar várias operações de adição, remoção e modificação.
As tuplas são coleções imutáveis, ideais para proteger dados que não devem ser alterados.
Os conjuntos são coleções não ordenadas que não permitem elementos duplicados, sendo úteis para operações de conjuntos como união, interseção e diferença.
Conhecer e utilizar corretamente essas estruturas de dados é fundamental para escrever programas Python eficientes e organizados.
2.4 - Dicionários
Os dicionários em Python são estruturas de dados que permitem armazenar pares de chave-valor.
Cada valor é associado a uma chave única, e os dicionários são usados para armazenar e recuperar valores com base nas chaves.
São altamente eficientes para pesquisas e acesso rápido aos dados.
Vamos detalhar como utilizar dicionários em Python.
2.4.1 - Criar Dicionário
Os dicionários são definidos utilizando chaves {}, e os pares de chave-valor separados por dois pontos ":", com cada par sendo separado por vírgula ",".
Primeiro, um dicionário pode ser criado com a função integrada dict(). Sem argumentos, cria um dicionário vazio.
pessoa = dict()
print(f"{pessoa} ({type(pessoa)})")As chaves {} representam um dicionário vazio. Para acrescentar itens ao dicionário, você pode usar colchetes.
pessoa["nome"] = "Pedro"
pessoa["idade"] = 29
pessoa["cidade"] = "Belo Horizonte"
print(f"{pessoa}")Crie um dicionário com pares de chave-valor entre chaves "{" e "}".
pessoa = {"nome": "Pedro", "idade": 29, "cidade": "Belo Horizonte"}
print(f"dicionário: {pessoa}")Neste exemplo, criamos um dicionário retornado na variável pessoa com três pares de chave-valor: "nome": "Pedro", "idade": 29 e "cidade": "Belo Horizonte".
A ordem dos pares chave-valor pode não ser a mesma. Se você digitar o mesmo exemplo no seu computador, pode receber um resultado diferente. Em geral, a ordem dos itens em um dicionário é imprevisível.
Os elementos de um dicionário não são indexados com índices de números inteiros, mas com as chaves, na localização dos valores correspondentes.
A função integrada len() retorna o número de pares chave-valor no dicionário.
print(len(pessoa))2.4.2 - Acessar Chaves e Valores do Dicionário
Para acessar o valor associado a uma chave específica, utilizamos a chave entre colchetes "[" e "]".
Imprima os valores da chave de pessoa.
print(f"nome: {pessoa['nome']}")
print(f"idade: {pessoa['idade']}")
print(f"cidade: {pessoa['cidade']}")Se a chave não estiver no dicionário, ocorre uma exceção.
print(pessoa["profissão"])A excessão pode ser controlada com a cláusula try-except.
try:
print(pessoa["profissão"])
except KeyError:
print("chave 'profissão' não existe")A existência da chave pode ser verificada com a cláusula in.
print("nome" in pessoa)
print("email" in pessoa)Para ver se algo aparece como um valor em um dicionário, você pode usar o método values, que devolve uma coleção de valores, e então usar o operador in.
print("Pedro" in pessoa.values())
print(30 in pessoa.values())2.4.3 - Modificar Valores no Dicionário
O valor associado a uma chave existente no dicionário pode ser alterado com operadores de atribuição.
pessoa["idade"] = 35
print(f"usando '=': {pessoa['idade']}")
pessoa["idade"] += 5
print(f"usando '+=': {pessoa['idade']}")Neste exemplo, alteramos o valor da chave "idade" para 35 e depois adicionamos 5.
2.4.4 - Adicionando e Removendo Pares de Chave-Valor
É possível adicionar novos pares de chave-valor ao dicionário ou remover pares existentes.
pessoa["profissao"] = "Arquiteto" # Adicionando um novo par
print(pessoa)
del pessoa["cidade"] # Removendo uma chave e seu valor
print(pessoa)2.4.5 - Métodos Úteis de Dicionários
Existem vários métodos úteis para manipular dicionários em Python.
- keys(): Retorna uma lista com todas as chaves do dicionário.
- values(): Retorna uma lista com todos os valores do dicionário.
- items(): Retorna uma lista de tuplas contendo os pares chave-valor.
print(pessoa.keys())
print(pessoa.values())
print(pessoa.items())2.4.6 - Verificando a Existência de uma Chave
Você pode verificar se uma chave específica existe no dicionário utilizando o operador in.
print("nome" in pessoa)
print("email" in pessoa)2.4.7 - Compreensão de Dicionário
Assim como as listas, os dicionários também podem ser criados usando compreensão de dicionário, que é uma forma concisa de criar dicionários com base em alguma lógica.
numeros = {x: x**2 for x in range(1, 6)}
print(numeros) # Saída: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}Neste exemplo, usamos a compreensão de dicionário para criar um dicionário com os números de 1 a 5 como chaves e seus quadrados como valores.
Os dicionários são estruturas de dados extremamente úteis em Python para armazenar e acessar dados associados a chaves únicas, permitindo rápida recuperação de valores com base em chaves, tornando-os ideais para gerenciar dados estruturados.
Com os métodos e técnicas adequadas, é possível manipular, modificar e verificar a existência de chaves no dicionário de forma eficiente.
As compreensões de dicionário são uma técnica poderosa para criar dicionários de maneira concisa e elegante.
O conhecimento e o uso correto dos dicionários são essenciais para o desenvolvimento eficiente de programas Python.
