Mudanças entre as edições de "Python 2021 Mod3"
(10 revisões intermediárias pelo mesmo usuário não estão sendo mostradas) | |||
Linha 9: | Linha 9: | ||
==Lista== | ==Lista== | ||
− | + | '''Lista''': É uma estrutura de dados mutável que armazena elementos em um formato desordenado, como uma matriz. | |
<syntaxhighlight lang=python> | <syntaxhighlight lang=python> | ||
Linha 133: | Linha 133: | ||
['a', 'b', 'c'] | ['a', 'b', 'c'] | ||
− | lists[1][0] | + | lists[1][0] |
− | 'a' | + | 'a' |
− | + | ==Tupla== | |
− | Tupla: "lista" imutável que não pode ser manipulada depois de criada. | + | '''Tupla''': É uma "lista" imutável que não pode ser manipulada depois de criada. |
Elas suportam todas as listas de operações, exceto aquelas que modificam a lista. | Elas suportam todas as listas de operações, exceto aquelas que modificam a lista. | ||
+ | <syntaxhighlight lang=python> | ||
# Inicializar uma tupla vazia | # Inicializar uma tupla vazia | ||
y = tuple() | y = tuple() | ||
Linha 149: | Linha 150: | ||
# Criar uma nova tupla de elementos | # Criar uma nova tupla de elementos | ||
x = (1,2,3) | x = (1,2,3) | ||
+ | </syntaxhighlight> | ||
+ | <syntaxhighlight lang=python> | ||
# ERROR: não pode ser adicionado a uma tupla | # ERROR: não pode ser adicionado a uma tupla | ||
x.append(4) | x.append(4) | ||
+ | </syntaxhighlight> | ||
+ | <pre> | ||
--------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ||
NameError Traceback (most recent call last) | NameError Traceback (most recent call last) | ||
Linha 160: | Linha 165: | ||
NameError: name 'x' is not defined | NameError: name 'x' is not defined | ||
+ | </pre> | ||
+ | <syntaxhighlight lang=python> | ||
# Isto é OK porque está criando uma nova tupla com x e (4,5,6) adicionado no final | # Isto é OK porque está criando uma nova tupla com x e (4,5,6) adicionado no final | ||
x + (4,5,6) | x + (4,5,6) | ||
+ | </syntaxhighlight> | ||
− | (1, 2, 3, 4, 5, 6) | + | (1, 2, 3, 4, 5, 6) |
+ | <syntaxhighlight lang=python> | ||
# x NÃO é modificado pela linha anterior | # x NÃO é modificado pela linha anterior | ||
x | x | ||
+ | </syntaxhighlight> | ||
− | (1, 2, 3) | + | (1, 2, 3) |
+ | <syntaxhighlight lang=python> | ||
# Criar uma nova tupla com x aparecendo duas vezes | # Criar uma nova tupla com x aparecendo duas vezes | ||
x * 2 | x * 2 | ||
+ | </syntaxhighlight> | ||
− | (1, 2, 3, 1, 2, 3) | + | (1, 2, 3, 1, 2, 3) |
+ | <syntaxhighlight lang=python> | ||
# Index dos elementos na tupla | # Index dos elementos na tupla | ||
x.index(3) | x.index(3) | ||
+ | </syntaxhighlight> | ||
− | 2 | + | 2 |
+ | <syntaxhighlight lang=python> | ||
# abreviação para | # abreviação para | ||
# (a,b,c) = (1,2,3) | # (a,b,c) = (1,2,3) | ||
Linha 187: | Linha 202: | ||
a,b,c = 1,2,3 | a,b,c = 1,2,3 | ||
+ | </syntaxhighlight> | ||
− | a | + | a |
− | 1 | + | 1 |
− | b | + | b |
− | 2 | + | 2 |
− | c | + | c |
− | 3 | + | 3 |
+ | <syntaxhighlight lang=python> | ||
# Converter uma tupla em uma lista | # Converter uma tupla em uma lista | ||
x = (1,2,3,4) | x = (1,2,3,4) | ||
list(x) | list(x) | ||
+ | </syntaxhighlight> | ||
− | [1, 2, 3, 4] | + | [1, 2, 3, 4] |
+ | <syntaxhighlight lang=python> | ||
# Converter uma lista em uma tupla | # Converter uma lista em uma tupla | ||
x = [1,2,3,4] | x = [1,2,3,4] | ||
tuple(x) | tuple(x) | ||
+ | </syntaxhighlight> | ||
− | (1, 2, 3, 4) | + | (1, 2, 3, 4) |
+ | <syntaxhighlight lang=python> | ||
# Declarar uma nova tupla, nome "person" | # Declarar uma nova tupla, nome "person" | ||
person = ('Jane','Doe', 21) | person = ('Jane','Doe', 21) | ||
Linha 217: | Linha 238: | ||
# "Pacote"/associar cada elemento da tupla com uma etiqueta. Observe a ordem das etiquetas. | # "Pacote"/associar cada elemento da tupla com uma etiqueta. Observe a ordem das etiquetas. | ||
first, last, age = person | first, last, age = person | ||
+ | </syntaxhighlight> | ||
− | first | + | first |
− | 'Jane' | + | 'Jane' |
− | last | + | last |
− | 'Doe' | + | 'Doe' |
− | age | + | age |
− | 21 | + | 21 |
+ | <syntaxhighlight lang=python> | ||
# ERROR: x é uma tupla de 4 valores, mas está tentando descompactar SOMENTE 3 elementos. | # ERROR: x é uma tupla de 4 valores, mas está tentando descompactar SOMENTE 3 elementos. | ||
# Incompatibilidade no tamanho da tupla | # Incompatibilidade no tamanho da tupla | ||
x = (1,2,3,4) | x = (1,2,3,4) | ||
− | |||
a,b,c = x | a,b,c = x | ||
+ | </syntaxhighlight> | ||
+ | <pre> | ||
--------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ||
ValueError Traceback (most recent call last) | ValueError Traceback (most recent call last) | ||
Linha 244: | Linha 268: | ||
ValueError: too many values to unpack (expected 3) | ValueError: too many values to unpack (expected 3) | ||
+ | </pre> | ||
+ | <syntaxhighlight lang=python> | ||
# Isto é OK! | # Isto é OK! | ||
x = [1,2,3,4] | x = [1,2,3,4] | ||
a,b,c,d = x | a,b,c,d = x | ||
+ | </syntaxhighlight> | ||
− | a | + | a |
− | 1 | + | 1 |
− | b | + | b |
− | 2 | + | 2 |
− | c | + | c |
− | 3 | + | 3 |
− | d | + | d |
− | 4 | + | 4 |
− | + | ==Conjunto== | |
− | Conjunto: uma estrutura de dados mutável que armazena objetos não duplicados e imutáveis e ordena os elementos em ordem ascendente. Cada elemento do conjunto é único. | + | '''Conjunto''': É uma estrutura de dados mutável que armazena objetos não duplicados e imutáveis e ordena os elementos em ordem ascendente. Cada elemento do conjunto é único. |
+ | <syntaxhighlight lang=python> | ||
# Inicializar um conjunto vazio | # Inicializar um conjunto vazio | ||
newSet = set() | newSet = set() | ||
newSet | newSet | ||
+ | </syntaxhighlight> | ||
− | set() | + | set() |
+ | <syntaxhighlight lang=python> | ||
# Um conjunto com elementos | # Um conjunto com elementos | ||
ex1 = {1, 2, 2, 1, 1} | ex1 = {1, 2, 2, 1, 1} | ||
ex1 | ex1 | ||
+ | </syntaxhighlight> | ||
− | {1, 2} | + | {1, 2} |
+ | <syntaxhighlight lang=python> | ||
ex2 = {j for j in range(10)} | ex2 = {j for j in range(10)} | ||
ex2 | ex2 | ||
+ | </syntaxhighlight> | ||
− | {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} | + | {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} |
+ | <syntaxhighlight lang=python> | ||
# 2 já existe no ex2. O que acontece se quisermos acrescentar o 2 novamente? | # 2 já existe no ex2. O que acontece se quisermos acrescentar o 2 novamente? | ||
# Nota: A implementação do conjunto NÃO definiu append(), então usaremos add(). | # Nota: A implementação do conjunto NÃO definiu append(), então usaremos add(). | ||
Linha 294: | Linha 328: | ||
ex2.add(50) | ex2.add(50) | ||
ex2 | ex2 | ||
+ | </syntaxhighlight> | ||
− | {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 50, 100} | + | {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 50, 100} |
+ | <syntaxhighlight lang=python> | ||
# objetos mutáveis não podem ser colocados em um conjunto | # objetos mutáveis não podem ser colocados em um conjunto | ||
d_set = {[1,2,3]} | d_set = {[1,2,3]} | ||
d_set | d_set | ||
+ | </syntaxhighlight> | ||
+ | <pre> | ||
--------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ||
TypeError Traceback (most recent call last) | TypeError Traceback (most recent call last) | ||
Linha 311: | Linha 349: | ||
TypeError: unhashable type: 'list' | TypeError: unhashable type: 'list' | ||
+ | </pre> | ||
+ | <syntaxhighlight lang=python> | ||
# Converter uma lista em um conjunto | # Converter uma lista em um conjunto | ||
ages = [10, 5, 4, 5, 2, 1, 5] | ages = [10, 5, 4, 5, 2, 1, 5] | ||
Linha 318: | Linha 358: | ||
set_of_ages | set_of_ages | ||
+ | </syntaxhighlight> | ||
− | {1, 2, 4, 5, 10} | + | {1, 2, 4, 5, 10} |
+ | <syntaxhighlight lang=python> | ||
# Converter um conjunto em uma lista | # Converter um conjunto em uma lista | ||
list_of_ages = list(set_of_ages) | list_of_ages = list(set_of_ages) | ||
list_of_ages | list_of_ages | ||
+ | </syntaxhighlight> | ||
− | [1, 2, 4, 5, 10] | + | [1, 2, 4, 5, 10] |
+ | <syntaxhighlight lang=python> | ||
# Converter um conjunto em uma tupla | # Converter um conjunto em uma tupla | ||
tuple_of_ages = tuple(list_of_ages) | tuple_of_ages = tuple(list_of_ages) | ||
tuple_of_ages | tuple_of_ages | ||
+ | </syntaxhighlight> | ||
− | (1, 2, 4, 5, 10) | + | (1, 2, 4, 5, 10) |
+ | <syntaxhighlight lang=python> | ||
# A ordem é irrelevante na comparação de conjuntos, uma vez que os elementos são ordenados | # A ordem é irrelevante na comparação de conjuntos, uma vez que os elementos são ordenados | ||
{1,2,3} == {2,1,3} | {1,2,3} == {2,1,3} | ||
+ | </syntaxhighlight> | ||
− | True | + | True |
− | + | ==Dicionário== | |
− | Dicionário: uma estrutura de dados que armazena pares de valores chave nos quais as chaves DEVEM ser objetos imutáveis. | + | '''Dicionário''': É uma estrutura de dados que armazena pares de valores chave nos quais as chaves DEVEM ser objetos imutáveis. |
+ | <syntaxhighlight lang=python> | ||
# Inicializar um dicionário vazio | # Inicializar um dicionário vazio | ||
# O mesmo do conjunto, mas com: | # O mesmo do conjunto, mas com: | ||
Linha 351: | Linha 399: | ||
# Declare um dicionário com pares de chaves/valores | # Declare um dicionário com pares de chaves/valores | ||
dict2 = {'a': 5, 'b': 10, 'c': 100, 'd': 9.5} | dict2 = {'a': 5, 'b': 10, 'c': 100, 'd': 9.5} | ||
+ | </syntaxhighlight> | ||
+ | <syntaxhighlight lang=python> | ||
# Acessar dados em um dicionário com uma chave | # Acessar dados em um dicionário com uma chave | ||
dict2['b'] | dict2['b'] | ||
+ | </syntaxhighlight> | ||
− | 10 | + | 10 |
+ | <syntaxhighlight lang=python> | ||
# Atualização do valor de uma chave existente | # Atualização do valor de uma chave existente | ||
dict2['b'] = 50 | dict2['b'] = 50 | ||
dict2['b'] | dict2['b'] | ||
+ | </syntaxhighlight> | ||
− | 50 | + | 50 |
+ | <syntaxhighlight lang=python> | ||
# O que acontece se quisermos ter acesso ao valor de uma chave inexistente? (por exemplo, 'z') | # O que acontece se quisermos ter acesso ao valor de uma chave inexistente? (por exemplo, 'z') | ||
− | |||
# Podemos esperar um ERROR porque esta chave não existe, portanto, não tem valor. | # Podemos esperar um ERROR porque esta chave não existe, portanto, não tem valor. | ||
# Esta é uma suposição correta. | # Esta é uma suposição correta. | ||
dict2['z'] | dict2['z'] | ||
+ | </syntaxhighlight> | ||
+ | <pre> | ||
--------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ||
KeyError Traceback (most recent call last) | KeyError Traceback (most recent call last) | ||
Linha 379: | Linha 434: | ||
KeyError: 'z' | KeyError: 'z' | ||
+ | </pre> | ||
+ | <syntaxhighlight lang=python> | ||
# # Mas se fizermos isso, será que isso ainda retornará um ERROR? | # # Mas se fizermos isso, será que isso ainda retornará um ERROR? | ||
dict2['z'] = 999 | dict2['z'] = 999 | ||
dict2['z'] | dict2['z'] | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | 999 | ||
− | POR QUÊ? | + | '''POR QUÊ?''' |
O bloco de código anterior funciona porque "atualizamos" primeiro o valor da chave, atualizar = inserir (neste caso), e quando queremos acessar o valor desta chave, esta chave já existe no dicionário para o mapeamento atribuído. | O bloco de código anterior funciona porque "atualizamos" primeiro o valor da chave, atualizar = inserir (neste caso), e quando queremos acessar o valor desta chave, esta chave já existe no dicionário para o mapeamento atribuído. | ||
+ | <syntaxhighlight lang=python> | ||
# Os valores no dicionário podem ser misturados | # Os valores no dicionário podem ser misturados | ||
# Vejamos um exemplo com dict{}, um dicionário vazio iniciado acima. | # Vejamos um exemplo com dict{}, um dicionário vazio iniciado acima. | ||
Linha 399: | Linha 460: | ||
dict | dict | ||
+ | </syntaxhighlight> | ||
+ | {'alphabet': ['a', 'b', 'c', 'd', 'e'], | ||
+ | 'check-in': False, | ||
+ | 'greeting': 'hello message', | ||
+ | 'phoneNumber': 8007782346} | ||
+ | |||
+ | <syntaxhighlight lang=python> | ||
# Nota IMPORTANTE: a chave deve ser um objeto imutável (algo que não pode ser modificado) | # Nota IMPORTANTE: a chave deve ser um objeto imutável (algo que não pode ser modificado) | ||
# A string é imutável, porque você não poderia simplesmente apagar um caractere em uma string. Uma string é uma string, do jeito que ela é. | # A string é imutável, porque você não poderia simplesmente apagar um caractere em uma string. Uma string é uma string, do jeito que ela é. | ||
Linha 412: | Linha 480: | ||
dict[['a','b', 'c']] = [False, True, False] | dict[['a','b', 'c']] = [False, True, False] | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | <pre> | ||
+ | --------------------------------------------------------------------------- | ||
+ | |||
+ | TypeError Traceback (most recent call last) | ||
+ | |||
+ | <ipython-input-9-225453b8e002> in <module>() | ||
+ | 8 dict["phoneNumber"] = 8007782346 | ||
+ | 9 | ||
+ | ---> 10 dict[['a','b', 'c']] = [False, True, False] | ||
+ | |||
+ | TypeError: unhashable type: 'list' | ||
+ | </pre> | ||
+ | <syntaxhighlight lang=python> | ||
# Mas como a tupla é imutável, podemos substituir a lista por uma tupla | # Mas como a tupla é imutável, podemos substituir a lista por uma tupla | ||
dict[('a','b', 'c')] = [False, True, False] | dict[('a','b', 'c')] = [False, True, False] | ||
dict | dict | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | {('a', 'b', 'c'): [False, True, False], | ||
+ | 'alphabet': ['a', 'b', 'c', 'd', 'e'], | ||
+ | 'check-in': False, | ||
+ | 'greeting': 'hello message', | ||
+ | 'phoneNumber': 8007782346} | ||
+ | <syntaxhighlight lang=python> | ||
# Podemos também buscar todas as chaves | # Podemos também buscar todas as chaves | ||
dict.keys() | dict.keys() | ||
+ | </syntaxhighlight> | ||
+ | dict_keys(['greeting', 'alphabet', 'check-in', 'phoneNumber', ('a', 'b', 'c')]) | ||
+ | |||
+ | <syntaxhighlight lang=python> | ||
# Ou todos os valores | # Ou todos os valores | ||
dict.values() | dict.values() | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | dict_values(['hello message', ['a', 'b', 'c', 'd', 'e'], False, 8007782346, [False, True, False]]) | ||
+ | <syntaxhighlight lang=python> | ||
# Os elementos de um dicionário também podem retornar como um par. | # Os elementos de um dicionário também podem retornar como um par. | ||
dict.items() | dict.items() | ||
+ | </syntaxhighlight> | ||
− | + | dict_items([('greeting', 'hello message'), ('alphabet', ['a', 'b', 'c', 'd', 'e']), ('check-in', False), ('phoneNumber', 8007782346), (('a', 'b', 'c'), [False, True, False])]) | |
− | |||
Edição atual tal como às 11h05min de 30 de dezembro de 2021
Unidade 3: Estruturas Básicas de Dados
- Objetivos de aprendizagem
- Reconhecer as características chave de cada estrutura. Utilizar corretamente cada estrutura quando apropriado e acessar os dados correspondentes armazenados na estrutura.
Consulte este Doc para obter informações adicionais sobre cada estrutura de dados.
Lista
Lista: É uma estrutura de dados mutável que armazena elementos em um formato desordenado, como uma matriz.
# Iniciar uma lista vazia
list1 = []
# OU
list1 = list()
# Iniciar uma lista com elementos
list2 = ['hello', 'hola', 'olá']
"""
Os elementos da lista NÃO precisam ser do mesmo tipo, mas isto é incomum.
Neste caso, cada lista poderia representar a série de informações sobre uma pessoa,
mas é preciso lembrar quais informações são armazenadas em cada index. ---> Existe uma opção melhor para este propósito - dicionário.
"""
list3 = ["John", "male", 20, False]
# Acess às informações armazenadas na lista por posição ("index")
# Nota: em CS, a primeira posição é SEMPRE 0
print("First element in list2 : "+ list2[0])
print("Second element in list2 : "+ list2[1])
First element in list2 : hello Second element in list2 : hola
# Inserir um novo elemento como um local específico, no index 1
list2.insert(1,'hallo')
list2[1]
'hallo'
# Anexar um novo elemento no FIM da lista
list2.append('bye')
list2
['hello', 'hallo', 'hola', 'olá', 'bye']
# Remover um elemento da lista especificando o elemento que você deseja remover
list2.remove('hello')
# list2 após o 'hello' é REMOVIDA
list2
['hallo', 'hola', 'olá', 'bye']
"""
Outra maneira de remover um elemento: pop()
pop() permite que você identifique uma posição
"""
list2.append("hello")
list2.pop()
list2
['hallo', 'hola', 'olá', 'bye']
"""
As listas também podem ser ordenadas.
O método de ordenação depende de como a interface comparável é implementada para os objetos da lista.
Neste caso da list2, sort() funciona ordenando caracteres individuais na string de acordo com o código ASCII.
"""
list2.sort()
list2
['bye', 'hallo', 'hola', 'olá']
"""
Como a lista é dinâmica, significa que o tamanho da lista aumenta ou diminui à medida que inserimos ou removemos elementos,
poderíamos executar len() para encontrar o tamanho da lista em um determinado momento.
"""
# Como len() retorna int, para concatená-la a uma string, precisamos computá-la.
print("size of list1 = " + str(len(list1)))
print("size of list2 = " + str(len(list2)))
size of list1 = 0 size of list2 = 4
# Imprimir itens na lista como string, separados por uma vírgula
",".join(list2)
'bye,hallo,hola,olá'
# Você também pode ter uma lista de listas. Por exemplo:
lists = []
lists.append([1,2,3])
lists.append(['a','b','c'])
lists
[[1, 2, 3], ['a', 'b', 'c']]
# Da mesma forma, você pode indexar as listas multidimensionais.
lists[1]
['a', 'b', 'c']
lists[1][0]
'a'
Tupla
Tupla: É uma "lista" imutável que não pode ser manipulada depois de criada.
Elas suportam todas as listas de operações, exceto aquelas que modificam a lista.
# Inicializar uma tupla vazia
y = tuple()
y
# Criar uma nova tupla de elementos
x = (1,2,3)
# ERROR: não pode ser adicionado a uma tupla
x.append(4)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-1-ce148ff4c21d> in <module>() 1 # ERROR: não pode ser adicionado a uma tupla ----> 2 x.append(4) NameError: name 'x' is not defined
# Isto é OK porque está criando uma nova tupla com x e (4,5,6) adicionado no final
x + (4,5,6)
(1, 2, 3, 4, 5, 6)
# x NÃO é modificado pela linha anterior
x
(1, 2, 3)
# Criar uma nova tupla com x aparecendo duas vezes
x * 2
(1, 2, 3, 1, 2, 3)
# Index dos elementos na tupla
x.index(3)
2
# abreviação para
# (a,b,c) = (1,2,3)
# Isto também atribui a = 1, b = 2, c = 3
a,b,c = 1,2,3
a
1
b
2
c
3
# Converter uma tupla em uma lista
x = (1,2,3,4)
list(x)
[1, 2, 3, 4]
# Converter uma lista em uma tupla
x = [1,2,3,4]
tuple(x)
(1, 2, 3, 4)
# Declarar uma nova tupla, nome "person"
person = ('Jane','Doe', 21)
# "Pacote"/associar cada elemento da tupla com uma etiqueta. Observe a ordem das etiquetas.
first, last, age = person
first
'Jane'
last
'Doe'
age
21
# ERROR: x é uma tupla de 4 valores, mas está tentando descompactar SOMENTE 3 elementos.
# Incompatibilidade no tamanho da tupla
x = (1,2,3,4)
a,b,c = x
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-45-4acb77e9e93d> in <module>() 3 x = (1,2,3,4) 4 ----> 5 a,b,c = x ValueError: too many values to unpack (expected 3)
# Isto é OK!
x = [1,2,3,4]
a,b,c,d = x
a
1
b
2
c
3
d
4
Conjunto
Conjunto: É uma estrutura de dados mutável que armazena objetos não duplicados e imutáveis e ordena os elementos em ordem ascendente. Cada elemento do conjunto é único.
# Inicializar um conjunto vazio
newSet = set()
newSet
set()
# Um conjunto com elementos
ex1 = {1, 2, 2, 1, 1}
ex1
{1, 2}
ex2 = {j for j in range(10)}
ex2
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
# 2 já existe no ex2. O que acontece se quisermos acrescentar o 2 novamente?
# Nota: A implementação do conjunto NÃO definiu append(), então usaremos add().
# add() irá inserir o novo elemento na posição correta com a ordenação do conjunto
ex2.add(2)
ex2.add(100)
ex2.add(50)
ex2
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 50, 100}
# objetos mutáveis não podem ser colocados em um conjunto
d_set = {[1,2,3]}
d_set
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-55-6b6994b2706f> in <module>() 1 # mutable objects can't go in a set ----> 2 d_set = {[1,2,3]} 3 4 d_set TypeError: unhashable type: 'list'
# Converter uma lista em um conjunto
ages = [10, 5, 4, 5, 2, 1, 5]
set_of_ages = set(ages)
set_of_ages
{1, 2, 4, 5, 10}
# Converter um conjunto em uma lista
list_of_ages = list(set_of_ages)
list_of_ages
[1, 2, 4, 5, 10]
# Converter um conjunto em uma tupla
tuple_of_ages = tuple(list_of_ages)
tuple_of_ages
(1, 2, 4, 5, 10)
# A ordem é irrelevante na comparação de conjuntos, uma vez que os elementos são ordenados
{1,2,3} == {2,1,3}
True
Dicionário
Dicionário: É uma estrutura de dados que armazena pares de valores chave nos quais as chaves DEVEM ser objetos imutáveis.
# Inicializar um dicionário vazio
# O mesmo do conjunto, mas com:
dict = {}
# Declare um dicionário com pares de chaves/valores
dict2 = {'a': 5, 'b': 10, 'c': 100, 'd': 9.5}
# Acessar dados em um dicionário com uma chave
dict2['b']
10
# Atualização do valor de uma chave existente
dict2['b'] = 50
dict2['b']
50
# O que acontece se quisermos ter acesso ao valor de uma chave inexistente? (por exemplo, 'z')
# Podemos esperar um ERROR porque esta chave não existe, portanto, não tem valor.
# Esta é uma suposição correta.
dict2['z']
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-4-132d7852d7b7> in <module>() 4 # Podemos esperar um ERROR porque esta chave não existe, portanto, não tem valor. 5 # Esta é uma suposição correta. ----> 6 dict2['z'] KeyError: 'z'
# # Mas se fizermos isso, será que isso ainda retornará um ERROR?
dict2['z'] = 999
dict2['z']
999
POR QUÊ?
O bloco de código anterior funciona porque "atualizamos" primeiro o valor da chave, atualizar = inserir (neste caso), e quando queremos acessar o valor desta chave, esta chave já existe no dicionário para o mapeamento atribuído.
# Os valores no dicionário podem ser misturados
# Vejamos um exemplo com dict{}, um dicionário vazio iniciado acima.
# Primeiro, vamos inserir alguns pares de chaves/valores no programa.
dict["greeting"] = "hello message"
dict["alphabet"] = ['a', 'b', 'c', 'd', 'e']
dict["check-in"] = False
dict["phoneNumber"] = 8007782346
dict
{'alphabet': ['a', 'b', 'c', 'd', 'e'], 'check-in': False, 'greeting': 'hello message', 'phoneNumber': 8007782346}
# Nota IMPORTANTE: a chave deve ser um objeto imutável (algo que não pode ser modificado)
# A string é imutável, porque você não poderia simplesmente apagar um caractere em uma string. Uma string é uma string, do jeito que ela é.
# Vemos acima que uma lista pode ser um valor no dicionário.
# O que acontece quando tentamos fazer dela uma chave?
# ERROR: tipo inalcançável de lista
# Porque poderíamos modificar a lista inserindo novos elementos, ordenando elementos, apagando elementos ou outras formas de modificá-la, mas ela NÃO PODE ser uma chave
dict[['a','b', 'c']] = [False, True, False]
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-9-225453b8e002> in <module>() 8 dict["phoneNumber"] = 8007782346 9 ---> 10 dict[['a','b', 'c']] = [False, True, False] TypeError: unhashable type: 'list'
# Mas como a tupla é imutável, podemos substituir a lista por uma tupla
dict[('a','b', 'c')] = [False, True, False]
dict
{('a', 'b', 'c'): [False, True, False], 'alphabet': ['a', 'b', 'c', 'd', 'e'], 'check-in': False, 'greeting': 'hello message', 'phoneNumber': 8007782346}
# Podemos também buscar todas as chaves
dict.keys()
dict_keys(['greeting', 'alphabet', 'check-in', 'phoneNumber', ('a', 'b', 'c')])
# Ou todos os valores
dict.values()
dict_values(['hello message', ['a', 'b', 'c', 'd', 'e'], False, 8007782346, [False, True, False]])
# Os elementos de um dicionário também podem retornar como um par.
dict.items()
dict_items([('greeting', 'hello message'), ('alphabet', ['a', 'b', 'c', 'd', 'e']), ('check-in', False), ('phoneNumber', 8007782346), (('a', 'b', 'c'), [False, True, False])])