No tutorial anterioraprendemos sobre como manipular valores de dados em listas e matrizes de bytes. Python também possui coleções não ordenadas mutáveis, incluindo conjuntos e dicionários.
Vamos revisar esses dois e aprender como manipular os valores/objetos de dados em conjuntos e dicionários.
Conjuntos
Conjuntos são coleções mutáveis não ordenadas de itens. Os itens em um conjunto podem ser quaisquer objetos imutáveis arbitrários e cada um deve ser único. Isso significa que nenhum item duplicado é permitido.
Os conjuntos em Python são semelhantes aos conjuntos matemáticos. Por exemplo, os itens são chamados de elementos do conjunto. Um conjunto é definido pelo construtor set ou usando um par de chaves ({}). Quando um conjunto é criado usando o construtor set , apenas um argumento pode ser passado para ele. Portanto, os elementos do conjunto devem ser agrupados em uma lista como argumento no construtor set .
Aqui estão alguns exemplos válidos:
s1 = {1, 2, 3, 4}
imprimir(s1)
s2 = conjunto(('a', 'b', 'c'))
imprimir(s2)
Os elementos de um conjunto não podem ser objetos mutáveis. Isso significa que listas, conjuntos e dicionários não podem ser elementos de um conjunto. No entanto, strings, bytes, inteiros, flutuantes, números complexos e tuplas podem ser elementos de um conjunto.
Um conjunto vazio pode ser criado usando o construtor set sem um argumento ou por um par vazio de colchetes.
Aqui estão exemplos válidos de conjuntos vazios:
s1 = {}
s2 = conjunto
Como os conjuntos são coleções não ordenadas, seus elementos não estão vinculados a nenhuma chave ou índice. Os elementos de um conjunto não podem ser acessados por chave ou índice, mas é possível testar se um elemento pertence ou não a um conjunto. Quando isso ocorre, os elementos de um conjunto são referenciados pelo seu valor.
Embora os conjuntos possam conter apenas objetos imutáveis, os próprios conjuntos são mutáveis. Assim, é possível adicionar, remover e modificar os elementos de um conjunto. Os objetos imutáveis contidos em um conjunto podem ser manipulados usando operadores, métodos de conjunto e funções internas do Python.
Os conjuntos possuem os seguintes métodos:
Os métodos podem ser aplicados em um conjunto usando a sintaxe set_name.method_name. Aqui estão exemplos válidos dos métodos definidos:
s1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s2 = {2, 4, 6}
s3 = {2, 3}
s2.add(8)
imprimir(s2)
s3.atualização((5, 7, 9, 11))
imprimir(s3)
s3.remove(9)
imprimir(s3)
s3.descartar(11)
imprimir(s3)
uma = s3.pop
imprimir(a)
imprimir(s3)
s3.adicionar(a)
s4 = s3.copiar
imprimir(s4)
s4.claro
imprimir (s4)
s4 = s2.união(s3)
imprimir (s4)
s5 = s2.diferença(s3)
imprimir(s5)
s5 = s2. diferença_simétrica(s3)
imprimir(s5)
s5 = s2.intersecção(s3)
imprimir(s5)
imprimir(s5.isdisjoint(s3))
s1.diferença_atualização(s5)
imprimir(s1)
s1.adicionar(2)
s1.intersection_update(s5)
imprimir(s1)
s1.atualização((0, 1, 3, 4, 5, 6, 7, 8, 9))
s1.metric_difference_update(s5)
imprimir(s1)
imprimir(s3.issubset(s1))
s1.adicionar(2)
imprimir(s3.issubset(s1))
imprimir(s3.issuperset(s1))
imprimir(s1.issuperset(s3))
As seguintes funções internas do Python aceitam conjuntos como argumentos:
Aqui está um exemplo válido de uso de funções em conjuntos:
s1 = {'a', 'c', Nenhum, 'b'}
s2 = {12, 8, 41, 245, 5}
imprimir(len(s1))
imprimir(qualquer(s1))
imprimir(todos(s1))
s1.remove (Nenhum)
imprimir(máx(s1))
imprimir(min(s1))
imprimir(soma(s2))
imprimir(classificado(s1))
imprimir(classificado(s2))
para x em enumerar (classificado (s1)):
imprimir (x)
Esta tabela resume as operações comuns em conjuntos ao usar operadores, instruções, métodos ou funções:
É importante observar que os elementos de um conjunto não possuem ordem, o que significa que não são permitidos elementos duplicados. Ao aplicar o método de união, se dois conjuntos possuírem elementos duplicados, apenas uma cópia da duplicata permanecerá no conjunto.
Da mesma forma, adicionar ou atualizar elementos duplicados em um conjunto não o altera. Um conjunto sempre tem elementos únicos.
Dicionários
Dicionários são uma coleção mutável e não ordenada de pares de valores-chave. As chaves em um dicionário só podem ser objetos imutáveis e “hashable” (únicos). Os valores podem incluir quaisquer objetos arbitrários, imutáveis ou mutáveis.
Um dicionário pode ser definido usando o construtor dict ou um par de chaves ({}). Estes são exemplos válidos de dicionários:
d1 = {x:25, y:57, z:64}
d2 = {'x':25, 'y':57, 'z':64,}
d3 = {'x':25, 57:'y', 'z':8.9j6.5}
d4 = ditado(x=25, y=57, z=64)
d5 = ditado((x, 25), (y, 57), (z, 64))
Os elementos em um dicionário estão vinculados às suas chaves, o que significa que os valores/objetos de dados armazenados em um dicionário podem ser acessados por suas chaves. Essas chaves podem incluir quaisquer objetos hashable — diferentemente das chaves inteiras nas listas.
Aqui está um exemplo de acesso aos elementos de um dicionário por uma chave:
d1 = {'a':25, 'b':57, 'c':92}
imprimir(d1('a'))
Se identificadores forem usados como chaves ou valores, eles deverão ser objetos definidos. Este exemplo é não válido:
d1 = {a:25, b:57, c:92}
imprimir(d1(a))
Aqui está um exemplo válido:
uma = 0
b = 1
c = 2
d1 = {a:25, b:57, c:92}
imprimir(d1(a))
Os elementos de um dicionário também podem ser acessados pelo método get . O ideal sobre a beleza do método get é que ele retorna um Nenhum objeto se a chave não existir. A tentativa de acessar um elemento do dicionário pela chave inexistente resultará em um KeyError.
Este é um exemplo válido de acesso aos elementos do dicionário pelo método get :
d1 = {'a':25, 'b':57, 'c':92}
print(d1.get('a')) # Imprime 25
print(d1.get('d')) # Imprime Nenhum
Os dicionários têm estes métodos:
Esses métodos podem ser aplicados em um dicionário usando a sintaxe dict_name.method_name. Aqui está um exemplo válido dos métodos do dicionário:
d1 = {0:'a', 1:'b', 2:'c', 3:'d'}
print(d1.get(0)) # Imprime 25
print(d1.get(4)) # Imprime Nenhum
print(d1.get(4, 'Não encontrado'))
imprimir(d1.keys )
imprimir(d1.valores )
imprimir(d1.items )
d1.setdefault(4, 'e')
imprimir(d1.items )
d1.update({5:'f', 6:'g'})
imprimir(d1.items )
d1.pop(6)
imprimir(d1.items )
d1.popitem
imprimir(d1.items )
d2 = d1.copiar
d1.claro
imprimir(d1.items )
imprimir(d2.items )
x = (0, 1, 2, 3)
y = 'VAL'
d1 = dict.fromkeys(x, y)
imprimir(d1.items )
imprimir(d2.items )
As seguintes funções internas do Python aceitam dicionários como argumentos:
Este é um exemplo válido de uso de funções em dicionários:
d1 = {0:'a', 1:'b', 2:'c', 3:'d'}
imprimir(len(d1))
imprimir(qualquer(d1))
print(all(d1)) #Returns False pois uma das chaves é 0
d1.pop(0)
imprimir(todos(d1))
d2 = {'LED': 40, 'Sete Segmentos':12, 'Display LCD':4}
imprimir(classificado(d2))
imprimir(classificado(d2, reverso=Verdadeiro))
deff(x):
retornar len(x)
imprimir(classificado(d2, chave=f))
Esta tabela resume as operações comuns em dicionários ao usar operadores, instruções, métodos ou funções:
Os dicionários podem ter valores duplicados, mas nunca chaves duplicadas. As chaves em um dicionário devem ser sempre imutáveis e hasháveis.
No próximo tutorialabordaremos recursos orientados a objetos e padrões de design em Python.
