4 Estruturas de dados embutidas em Python: dicionários, listas, conjuntos, tuplas

Neste artigo, vamos nos concentrar nas estruturas de dados em Python e ajudá-lo a entender o tópico com clareza. Você descobrirá o que são e como funcionam. Também compartilhamos vários exemplos para garantir que você não tenha dúvidas sobre os tópicos que compartilhamos aqui.

Então, sem mais delongas, vamos começar.

O que são Estruturas de Dados?

As estruturas de dados permitem que você organize e gerencie seus dados de maneira eficaz e eficiente. Eles melhoram a acessibilidade de seus dados. Modificar os dados armazenados também se torna muito mais simples se você tiver estruturas de dados adequadas. Eles permitem que você organize e armazene os dados para que você possa realizar operações nos mesmos posteriormente sem enfrentar nenhum tipo de dificuldade.

Python tem dois tipos de estruturas de dados. As estruturas de dados suportadas implicitamente pelo Python são Set, Dictionary, List e Tuple. Essas são as estruturas de dados internas do Python.

Depois, há estruturas de dados que você pode criar para ter um melhor controle sobre a funcionalidade. Essas são estruturas de dados definidas pelo usuário e incluem Listas Vinculadas, Gráficos, Árvores, Pilhas, Filas e HashMaps. As estruturas de dados definidas pelo usuário também estão disponíveis em outras linguagens de programação.

Leia mais: 6 estruturas de dados mais comumente usadas em R

Estruturas de dados embutidas em Python

Python tem várias estruturas de dados embutidas. Essas estruturas de dados integradas ajudam você a resolver os problemas de programação rapidamente e com muita facilidade. Como mencionamos anteriormente, o Python possui as seguintes estruturas de dados integradas:

• Dicionários
• Listas
• Conjuntos
• Tuplas

Vamos discutir cada um deles em detalhes:

1. Dicionários

Usamos dicionários para armazenar pares chave-valor. Assim como um dicionário físico tem uma palavra armazenada junto com seu significado, um dicionário em Python armazena pares chave-valor. Os termos são as chaves, enquanto os vários significados associados a essas palavras são os valores. Com o valor, você pode acessar as chaves.

Você pode criar um dicionário com chaves de flores. Você também pode usar a função dict() para essa finalidade. Aqui está um exemplo:

my_dict = {} #dicionário vazio

print(my_dict)

my_dict = {1: 'A', 2: 'B'} #dicionário com elementos

print(my_dict)

A saída do código acima:

{}

{1: 'A', 2: 'B'}

Você pode alterar os valores do dicionário através das teclas. Você teria primeiro que acessar as chaves para alterar os valores. Depois de localizar as chaves, basta adicionar o par chave-valor necessário para obter o resultado desejado.

my_dict = {'Primeiro': 'A', 'Segundo': 'B'}

print(my_dict)

my_dict['Second'] = 'C++' #alterando elemento

print(my_dict)

my_dict['Third'] = 'Ruby' #adicionando par chave-valor

print(my_dict)

A saída do código acima:

{'Primeiro': 'A', 'Segundo': 'B'}

{'Primeiro': 'A', 'Segundo': 'C'}

{'Primeiro': 'A', 'Segundo': 'C', 'Terceiro': 'D'}

Você pode excluir os valores em seu dicionário usando a função pop(). A função pop() retorna o valor que você excluiu. Você pode recuperar um par chave-valor por meio da função popitem(). Ele retorna a tupla do par. Você também pode limpar todo o dicionário usando a função clear(). Aqui está o exemplo:

my_dict = {'Primeiro': 'A', 'Segundo': 'B'', 'Terceiro': 'C'}

a = my_dict.pop('Terceiro') #pop elemento

print('Valor:', a)

print('Dicionário:', my_dict)

b = my_dict.popitem() #pop o par chave-valor

print('Chave, par valor:', b)

print('Dicionário', my_dict)

my_dict.clear() #dicionário vazio

print('n', meu_dict)

A saída do código acima:

Valor: C

Dicionário: {'Primeiro': 'A', 'Segundo': 'B'}

Chave, par de valores: ('Segundo', 'B')

Dicionário {'Primeiro': 'A'}

{}

Leia também: Ideias e tópicos do projeto Python

2. Listas

Usamos listas para armazenar dados sequencialmente. Cada elemento da lista tem um endereço, que também é chamado de índice. O valor de índice de uma lista vai de 0 até o último elemento presente em sua lista, e seu nome é indexação positiva. Da mesma forma, quando você volta do último elemento para o primeiro e conta de -1, isso é chamado de indexação negativa.

Você pode criar uma lista usando colchetes e adicionar elementos a eles conforme necessário. Se você deixar os colchetes vazios, a lista não terá nenhum elemento e também estará vazia. Veja um exemplo de lista:

my_list = [] #criar lista vazia

print(minha_lista)

minha_lista = [A, B, C, 'exemplo', Z] #criando lista com dados

print(minha_lista)

A saída do código acima:

[]

[A, B, C, 'exemplo', Z]

Você pode adicionar elementos à sua lista usando as funções insert(), extension() e append(). A função insert() adiciona os elementos que foram passados ​​ao valor do índice. A função insert() também aumenta o tamanho da lista.

Com a função append(), você pode adicionar todos os elementos passados ​​a ela como um único elemento. Por outro lado, a função extend() pode adicionar os elementos um por um.

Aqui está um exemplo:

minha_lista = [A, B, C]

print(minha_lista)

my_list.append([555, 12]) #add como um único elemento

print(minha_lista)

my_list.extend([234, 'more_example']) #add como elementos diferentes

print(minha_lista)

my_list.insert(1, 'insert_example') #add elemento i

print(minha_lista)

Saída do código acima:

[A, B, C]

[A, B, C, [555, 12]]

[A, B, C, [555, 12], 234, 'mais_exemplo']

[A, 'inserir_exemplo', B, C, [555, 12], 234, 'mais_exemplo']

Ao trabalhar com listas, você também encontrará a necessidade de remover alguns elementos. Você pode usar a palavra-chave 'del'. É uma palavra-chave interna do Python e não retorna nada. Se você quiser um elemento de volta, você teria que usar a função pop() e para remover um elemento através de seu valor, você teria que usar a função remove(). Aqui está o exemplo:

minha_lista = [A, B, C, 'exemplo', Z, 10, 30]

del my_list[5] #delete elemento no índice 5

print(minha_lista)

my_list.remove('example') #remove elemento com valor

print(minha_lista)

a = my_list.pop(1) #pop elemento da lista

print('Elemento aberto: ', a, ' Lista restante: ', lista_minha)

my_list.clear() #esvazia a lista

print(minha_lista)

A saída do código acima:

[A, B, C, 'exemplo', Z, 30]

[A, B, C, Z, 30]

Elemento estourado: 2 Lista restante: [A, C, Z, 30]

[]

Você pode passar os valores de índice em Python e obter os valores necessários.

minha_lista = [A, B, C, 'exemplo', Z, 10, 30]

for element in my_list: #acesse os elementos um por um

imprimir(elemento)

print(my_list) #acessar todos os elementos

print(my_list[3]) #access index 3 element

print(my_list[0:2]) #acessar elementos de 0 a 1 e excluir 2

print(my_list[::-1]) #acessar elementos ao contrário

A saída do código acima:

UMA

B

C

exemplo

Z

10

30

[A, B, C, 'exemplo', Z, 10, 30]

exemplo

[A, B]

[30, 10, Z, 'exemplo', 3, 2, 1]

3 partidas

Uma coleção de itens únicos e não ordenados é chamada de conjunto. Portanto, se você repetir os dados por algum motivo, eles aparecerão no conjunto apenas uma vez. Conjuntos em Python são semelhantes aos conjuntos sobre os quais você lê em matemática. De suas propriedades a suas funções, você encontrará muitas semelhanças entre eles.

Você pode criar um conjunto usando as chaves de flores e passando seus valores. Aqui está um exemplo:

my_set = {A, B, C, D, E, E, E} #criar conjunto

print(meu_conjunto)

A saída do código acima:

{A, B, C, D, E}

Como mencionamos anteriormente, você pode executar todas as funções de conjuntos que executa em aritmética nos conjuntos do Python. Com a função union(), você pode combinar os dados presentes em dois conjuntos. A função de interseção() fornece os dados que estão presentes em ambos os conjuntos mencionados.

Você tem a função Difference() que permite excluir os dados disponíveis em ambos os conjuntos e fornece os dados que não são comuns entre eles. A função symmetric_difference() fornece os dados restantes nesses conjuntos.

meu_conjunto = {A, B, C, D}

meu_conjunto_2 = {C, D, E, F}

print(meu_conjunto.union(meu_conjunto_2), '———-', meu_conjunto | meu_conjunto_2)

print(my_set.intersection(my_set_2), '———-', my_set & my_set_2)

print(my_set.difference(my_set_2), '———-', my_set – my_set_2)

print(my_set.symmetric_difference(my_set_2), '———-', my_set ^ my_set_2)

meu_set.clear()

print(meu_conjunto)

A saída do código acima:

{A, B, C, D, E, F} ———- {A, B, C, D, E, F}

{C, D} ———- {C, D}

{A, B} ———- {A, B}

{A, B, E, F} ———- {A, B, E, F}

definir()

Leia também: Salário do desenvolvedor Python na Índia

4. Tuplas

As tuplas são semelhantes às listas, mas depois de inserir dados em uma tupla, você não pode alterá-la, a menos que seja mutável. Compreendê-los pode ser um pouco complicado, mas não se preocupe, nosso código de exemplo pode ajudá-lo nesse sentido. Você pode criar uma tupla com a ajuda da função tuple().

my_tuple = (A, B, C) #criar tupla

print(minha_tupla)

A saída do código acima:

(A,B,C)

O método para acessar valores em tuplas é o mesmo que em listas.

my_tuple2 = (A, B, C, 'Upgrad') # elementos de acesso

para x em my_tuple2:

imprimir(x)

print(my_tuple2)

print(my_tuple2[0])

print(my_tuple2[:])

A saída do código acima:

UMA

B

C

Atualização

(A, B, C, 'Atualização')

UMA

(A, B, C, 'Atualização')

Conclusão

Agora você deve estar familiarizado com as várias estruturas de dados em Python . Esperamos que você tenha achado este artigo útil. As estruturas de dados desempenham um papel significativo para ajudá-lo a organizar, gerenciar e acessar seus dados. Há muitas opções para escolher, e cada uma delas tem seus usos particulares.

Se você quiser saber mais sobre Python e estruturas de dados, dê uma olhada em nossos cursos.

Se você está curioso para aprender sobre python, tudo sobre ciência de dados, confira o PG Diploma in Data Science do IIIT-B & upGrad, criado para profissionais que trabalham e oferece mais de 10 estudos de caso e projetos, workshops práticos práticos, orientação com a indústria especialistas, 1-on-1 com mentores do setor, mais de 400 horas de aprendizado e assistência de trabalho com as principais empresas.