Tutorial de estruturas de dados Python

As estruturas de dados são uma forma de organizar e armazenar dados para que eles possam ser acessados e trabalhados com eficiência. Eles definem a relação entre os dados e as operações que podem ser realizadas nos dados. Existem vários tipos de estruturas de dados definidas que facilitam aos cientistas de dados e engenheiros da computação se concentrarem no quadro principal da solução de problemas maiores, em vez de se perderem nos detalhes da descrição e do acesso aos dados.

Neste tutorial, você aprenderá sobre as várias estruturas de dados do Python e verá como elas são implementadas:

• Tipo de dados abstrato e estruturas de dados
• Estruturas de dados primitivas
  • Inteiros
  • Flutuação
  • Cordas
  • Booleano
• Estruturas de dados não primitivas
  • Matrizes
  • Listas
  • Tuplas
  • Dicionário
  • Conjuntos
  • Arquivos

No curso gratuito Intro to Python for Data Science da DataCamp, você pode aprender mais sobre o uso do Python especificamente no contexto da ciência de dados. O curso oferece uma introdução aos conceitos básicos do Python. Com ele, você descobrirá métodos, funções e o pacote NumPy.

Tipo de dados abstrato e estruturas de dados

Como você leu na introdução, as estruturas de dados ajudam você a se concentrar no quadro geral em vez de se perder nos detalhes. Isso é conhecido como abstração de dados.

Agora, as estruturas de dados são, na verdade, uma implementação de tipos abstratos de dados ou ADT. Essa implementação requer uma visão física dos dados usando uma coleção de construções de programação e tipos de dados básicos.

Em geral, as estruturas de dados podem ser divididas em duas categorias na ciência da computação: estruturas de dados primitivas e não primitivas. As primeiras são as formas mais simples de representar dados, enquanto as últimas são mais avançadas: elas contêm estruturas de dados primitivas dentro de estruturas de dados mais complexas para fins especiais.

Estruturas de dados primitivas

Essas são as estruturas de dados mais primitivas ou básicas. Eles são os blocos de construção para a manipulação de dados e contêm valores puros e simples de dados. O Python tem quatro tipos de variáveis primitivas:

• Inteiros
• Flutuação
• Cordas
• Booleano

Nas próximas seções, você saberá mais sobre eles!

Inteiros

Você pode usar um número inteiro para representar dados numéricos e, mais especificamente, números inteiros de infinito negativo a infinito, como 4, 5 ou -1.

Flutuação

"Float" significa "número de ponto flutuante". Você pode usá-lo para números racionais, geralmente terminando com um número decimal, como 1,11 ou 3,14.

Dê uma olhada no DataCamp Light Chunk a seguir e experimente algumas das operações com números inteiros e flutuantes!

Observe que, em Python, você não precisa declarar explicitamente o tipo da variável ou dos seus dados. Isso ocorre porque ela é uma linguagem tipada dinamicamente. As linguagens tipadas dinamicamente são aquelas em que o tipo de dados que um objeto pode armazenar é mutável.

Cadeia de caracteres

As cadeias de caracteres são coleções de alfabetos, palavras ou outros caracteres. Em Python, você pode criar cadeias de caracteres colocando uma sequência de caracteres dentro de um par de aspas simples ou duplas. Por exemplo: 'cake', "cookie", etc.

Você também pode aplicar as operações + em duas ou mais cadeias de caracteres para concatená-las, como no exemplo abaixo:

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

Aqui estão algumas outras operações básicas que você pode executar com cadeias de caracteres; Por exemplo, você pode usar * para repetir uma cadeia de caracteres um determinado número de vezes:

# Repeat
x * 2

'CakeCake'

Você também pode fatiar cadeias de caracteres, o que significa que você seleciona partes de cadeias de caracteres:

# Range Slicing
z1 = x[2:] 

print(z1)

# Slicing
z2 = y[0] + y[1] 

print(z2)

ke
Co

Observe que as cadeias de caracteres também podem ser caracteres alfanuméricos, mas que a operação + ainda é usada para concatenar cadeias de caracteres.

x = '4'
y = '2'

x + y

'42'

O Python tem muitos métodos internos ou funções auxiliares para manipular strings. Substituir uma substring, colocar determinadas palavras em maiúsculas em um parágrafo, encontrar a posição de uma string dentro de outra string são algumas manipulações comuns de string. Dê uma olhada em alguns deles:

• Colocar strings em maiúsculas

str.capitalize('cookie')

'Cookie'

• Recupera o comprimento de uma cadeia de caracteres em caracteres. Observe que os espaços também contam para o resultado final:

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

• Verificar se uma cadeia de caracteres consiste apenas em dígitos

str1.isdigit()

False

str2.isdigit()

True

• Substituir partes de cordas por outras cordas

str1.replace('4 U', str2)

'Cake 404'

• Encontre substrings em outras strings; retorna o índice ou a posição mais baixa dentro da string em que a substring foi encontrada:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

A substring

'cook'

é encontrado no início de

'cookie'

. Como resultado, você se refere à posição dentro de

'cookie'

no qual você encontra essa substring. Nesse caso,

0

é retornado porque você começa a contar as posições a partir de 0!

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

Da mesma forma, a substring

'cook'

é encontrado na posição 12 dentro de

'I got you a cookie'

. Lembre-se de que você começa a contar a partir do 0 e que os espaços contam para as posições!

Você pode encontrar uma lista exaustiva de métodos de string em Python aqui.

Booleano

Esse tipo de dados incorporado pode assumir os valores: True e False, o que geralmente os torna intercambiáveis com os inteiros 1 e 0. Os booleanos são úteis em expressões condicionais e de comparação, como nos exemplos a seguir:

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Comparison expression (Evaluates to false)
if z: # Conditional on truth/false value of 'z'
    print("Cookie")
else: print("No Cookie")

No Cookie

Conversão de tipo de dados

Às vezes, você estará trabalhando no código de outra pessoa e precisará converter um número inteiro em um float ou vice-versa, por exemplo. Ou talvez você descubra que tem usado um número inteiro quando o que realmente precisa é de um float. Nesses casos, você pode converter o tipo de dados das variáveis!

Para verificar o tipo de um objeto em Python, use a função integrada type(), como nas linhas de código abaixo:

i = 4.0
type(i)

float

Quando você altera o tipo de uma entidade de um tipo de dados para outro, isso é chamado de "typecasting". Pode haver dois tipos de conversões de dados possíveis: implícita, denominada coerção, e explícita, geralmente chamada de conversão.

Conversão implícita de tipos de dados

Essa é uma conversão automática de dados, e o compilador lida com isso para você. Dê uma olhada nos exemplos a seguir:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

No exemplo acima, você não precisou alterar explicitamente o tipo de dados de y para realizar a divisão do valor float. O compilador fez isso para você de forma implícita.

Isso é fácil!

Conversão explícita de tipos de dados

Esse tipo de conversão de tipo de dados é definido pelo usuário, o que significa que você precisa informar explicitamente ao compilador para alterar o tipo de dados de determinadas entidades. Considere o trecho de código abaixo para que você entenda isso completamente:

x = 2
y = "The Godfather: Part "
fav_movie = y + x

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly

O exemplo acima gerou um erro porque o compilador não entende que você está tentando executar a concatenação ou a adição devido aos tipos de dados mistos. Você tem um número inteiro e uma cadeia de caracteres que está tentando somar.

Há uma incompatibilidade óbvia.

Para resolver isso, primeiro você precisará converter o int em um string para poder realizar a concatenação.

Observe que nem sempre é possível converter um tipo de dados em outro. Algumas funções de conversão de dados incorporadas que você pode usar aqui são: int(), float(), e str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

Estruturas de dados não primitivas

Os tipos não primitivos são os membros sofisticados da família de estruturas de dados. Eles não armazenam apenas um valor, mas sim uma coleção de valores em vários formatos.

No mundo tradicional da ciência da computação, as estruturas de dados não primitivas são divididas em:

• Matrizes
• Listas
• Arquivos

Matriz

Em primeiro lugar, as matrizes em Python são uma forma compacta de coletar tipos de dados básicos, e todas as entradas em uma matriz devem ser do mesmo tipo de dados. Entretanto, as matrizes não são tão populares no Python, ao contrário de outras linguagens de programação, como C++ ou Java.

Em geral, quando as pessoas falam de matrizes em Python, na verdade estão se referindo a listas. No entanto, há uma diferença fundamental entre eles, e você verá isso daqui a pouco. Para o Python, as matrizes podem ser vistas como uma forma mais eficiente de armazenar um determinado tipo de lista. No entanto, esse tipo de lista tem elementos do mesmo tipo de dados.

No Python, as matrizes são suportadas pelo módulo array e precisam ser importadas antes de você começar a inicializá-las e usá-las. Os elementos armazenados em uma matriz são limitados em seu tipo de dados. O tipo de dados é especificado durante a criação da matriz e especificado usando um código de tipo, que é um único caractere, como o I que você vê no exemplo abaixo:

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

A página de documentação do Python Array fornece mais informações sobre os vários tipos de códigos disponíveis e as funcionalidades fornecidas pelo módulo array.

Lista

As listas em Python são usadas para armazenar coleções de itens heterogêneos. Eles são mutáveis, o que significa que você pode alterar o conteúdo deles sem alterar a identidade. Você pode reconhecer as listas por seus colchetes [ e ] que contêm elementos separados por vírgula ,. As listas são incorporadas ao Python: você não precisa invocá-las separadamente.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Observação: como você viu no exemplo acima com x1, as listas também podem conter itens homogêneos e, portanto, satisfazer a funcionalidade de armazenamento de uma matriz. Isso é bom, a menos que você queira aplicar algumas operações específicas a essa coleção.

O Python fornece muitos métodos para você manipular e trabalhar com listas. Adicionar novos itens a uma lista, remover alguns itens de uma lista e classificar ou inverter uma lista são manipulações comuns de listas. Vamos ver alguns deles em ação:

• Adicione 11 à lista list_num com append(). Por padrão, esse número será adicionado ao final da lista.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Use insert() para inserir 11 no índice ou na posição 0 da lista list_num

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Remova a primeira ocorrência de 'o' de list_char com a ajuda de remove()

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• Remova o item no índice -2 de list_char

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Se quiser saber mais sobre as listas do Python, você pode facilmente percorrer o tutorial 18 Most Common Python List Questions!

Matrizes versus listas

Agora que você já viu listas em Python, talvez esteja se perguntando por que precisa de matrizes. O motivo é que eles são fundamentalmente diferentes em termos das operações que podem ser realizadas neles. Com as matrizes, você pode realizar operações em todos os itens individualmente com facilidade, o que pode não ser o caso das listas. Aqui está uma ilustração:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

Você conseguiu aplicar a função tostring() do array_char porque o Python sabe que todos os itens em uma matriz são do mesmo tipo de dados e, portanto, a operação se comporta da mesma forma em cada elemento. Portanto, as matrizes podem ser muito úteis ao lidar com uma grande coleção de tipos de dados homogêneos. Como o Python não precisa lembrar os detalhes do tipo de dados de cada elemento individualmente, para alguns usos, as matrizes podem ser mais rápidas e usar menos memória em comparação com as listas.

Também vale a pena mencionar a matriz NumPy, já que estamos falando de matrizes. As matrizes NumPy são muito usadas no mundo da ciência de dados para trabalhar com matrizes multidimensionais. Eles são mais eficientes do que o módulo de matriz e as listas do Python em geral. A leitura e a gravação de elementos em uma matriz NumPy são mais rápidas, e elas suportam operações "vetorizadas", como a adição de elementos. Além disso, as matrizes NumPy funcionam de forma eficiente com grandes conjuntos de dados esparsos. Para saber mais, confira o tutorial Python Numpy Array da DataCamp.

Aqui está um código para você começar a usar o NumPy Array:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Tradicionalmente, a estrutura de dados da lista pode ser categorizada em estruturas de dados lineares e não lineares. Stacks e Queues são chamadas de "estruturas de dados lineares", enquanto Graphs e Trees são "estruturas de dados não lineares". Essas estruturas e seus conceitos podem ser relativamente complexos, mas são amplamente usados devido à sua semelhança com modelos do mundo real. Você terá uma visão geral desses tópicos neste tutorial.

Observação: em uma estrutura de dados linear, os itens de dados são organizados sequencialmente ou, em outras palavras, linearmente. Os itens de dados são percorridos em série, um após o outro, e todos os itens de dados em uma estrutura de dados linear podem ser percorridos em uma única execução. Entretanto, em estruturas de dados não lineares, os itens de dados não são organizados sequencialmente. Isso significa que os elementos podem ser conectados a mais de um elemento para refletir uma relação especial entre esses itens. Nem todos os itens de dados em uma estrutura de dados não linear podem ser percorridos em uma única execução.

Pilhas

Uma pilha é um contêiner de objetos que são inseridos e removidos de acordo com o conceito LIFO (Last-In-First-Out, último a entrar, primeiro a sair). Pense em um cenário em que, em um jantar, há uma pilha de pratos, e os pratos são sempre adicionados ou removidos do topo da pilha. Na ciência da computação, esse conceito é usado para avaliar expressões e análise de sintaxe, programar algoritmos/rotinas, etc.

As pilhas podem ser implementadas usando listas em Python. Quando você adiciona elementos a uma pilha, isso é conhecido como operação push, enquanto que quando você remove ou exclui um elemento, isso é chamado de operação pop. Observe que, na verdade, você tem um método pop() à sua disposição quando estiver trabalhando com pilhas em Python:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

Fila

Uma fila é um contêiner de objetos que são inseridos e removidos de acordo com o princípio FIFO (First-In-First-Out). Um excelente exemplo de fila no mundo real é a fila em um guichê de passagens, onde as pessoas são atendidas de acordo com a sequência de chegada e, portanto, a pessoa que chega primeiro também é a primeira a sair. As filas podem ser de vários tipos diferentes.

As listas não são eficientes para a implementação de uma fila, pois append() e pop() do final de uma lista não são rápidos e geram um custo de movimentação de memória. Além disso, a inserção no final e a exclusão do início de uma lista não são tão rápidas, pois exigem uma mudança nas posições dos elementos.

Gráficos

Um gráfico em matemática e ciência da computação é uma rede composta de nós, também chamados de vértices, que podem ou não estar conectados uns aos outros. As linhas ou o caminho que conecta dois nós é chamado de borda. Se a borda tiver uma direção específica de fluxo, será um gráfico direcionado, com a borda de direção sendo chamada de arco. Caso contrário, se nenhuma direção for especificada, o gráfico será chamado de gráfico não direcionado.

Tudo isso pode parecer muito teórico e pode se tornar bastante complexo quando você se aprofunda. No entanto, os gráficos são um conceito importante, especialmente na ciência de dados, e são frequentemente usados para modelar problemas da vida real. As redes sociais, os estudos moleculares em química e biologia, os mapas e os sistemas de recomendação se baseiam nos princípios da teoria de gráficos e grafos.

Aqui, você encontrará uma implementação simples de gráfico usando um dicionário Python para ajudá-lo a começar:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Você pode fazer algumas coisas legais com gráficos, como tentar descobrir se existe um caminho entre dois nós ou encontrar o caminho mais curto entre dois nós, determinando ciclos no gráfico.

O famoso "problema do caixeiro viajante" é, na verdade, encontrar a rota mais curta possível que visita cada nó exatamente uma vez e retorna ao ponto de partida. Às vezes, os nós ou arcos de um gráfico recebem pesos ou custos. Você pode pensar nisso como a atribuição de um nível de dificuldade para caminhar, e você está interessado em encontrar o caminho mais barato ou mais fácil.

Árvores

Uma árvore no mundo real é um ser vivo com suas raízes no solo e os galhos que sustentam as folhas e os frutos ao ar livre. Os galhos da árvore se espalham de forma um tanto organizada. Na ciência da computação, as árvores são usadas para descrever como os dados são, às vezes, organizados, exceto pelo fato de que a raiz está no topo e os galhos e folhas seguem, espalhando-se em direção à base, e a árvore é desenhada invertida em comparação com a árvore real.

Para introduzir um pouco mais de notação, a raiz está sempre no topo da árvore. Mantendo a metáfora da árvore, os outros nós que se seguem são chamados de ramos e o nó final de cada ramo é chamado de folhas. Você pode imaginar cada galho como uma árvore menor em si. A raiz é geralmente chamada de pai e os nós aos quais ela se refere abaixo dela são chamados de filhos. Os nós com o mesmo pai são chamados de irmãos. Você entende por que isso também é chamado de árvore genealógica?

As árvores ajudam a definir cenários do mundo real e são usadas em todos os lugares, desde o mundo dos jogos até o design de analisadores XML, e também o princípio de design do PDF é baseado em árvores. Na ciência de dados, a "Aprendizagem baseada em árvore de decisão" constitui, na verdade, uma grande área de pesquisa. Existem vários métodos famosos, como bagging e boosting, que usam o modelo de árvore para gerar um modelo preditivo. Jogos como o xadrez constroem uma enorme árvore com todas as jogadas possíveis para analisar e aplicar a heurística para decidir qual é a jogada ideal.

Você pode implementar uma estrutura em árvore usando e combinando as várias estruturas de dados que você viu até agora neste tutorial. No entanto, para simplificar, esse tópico será abordado em outro post.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Você aprendeu sobre matrizes e também viu a estrutura de dados de lista. No entanto, o Python oferece muitos tipos diferentes de mecanismos de coleta de dados e, embora eles possam não estar incluídos nos tópicos tradicionais de estrutura de dados da ciência da computação, vale a pena conhecê-los, especialmente no que diz respeito à linguagem de programação Python:

• Tuplas
• Dicionário
• Conjuntos

Tuplas

As tuplas são outro tipo de dados de sequência padrão. A diferença entre tuplas e lista é que as tuplas são imutáveis, o que significa que, uma vez definidas, você não pode excluir, adicionar ou editar nenhum valor dentro delas. Isso pode ser útil em situações em que você pode passar o controle para outra pessoa, mas não quer que ela manipule os dados na sua coleção, mas talvez apenas os veja ou realize operações separadamente em uma cópia dos dados.

Vamos ver como as tuplas são implementadas:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Dicionário

Os dicionários são exatamente o que você precisa se quiser implementar algo semelhante a uma lista telefônica. Nenhuma das estruturas de dados que você viu anteriormente é adequada para uma lista telefônica.

É nesse momento que um dicionário pode ser útil. Os dicionários são compostos de pares de valores-chave. key é usado para identificar o item e value contém, como o nome sugere, o valor do item.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Você pode aplicar muitas outras funcionalidades embutidas nos dicionários:

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Este código mostra um exemplo de uso de um dicionário Python para armazenar e acessar pares de valores-chave.

Primeiro, o código chama a função len() com x_dict como argumento. Isso retorna o número de pares de valores-chave no dicionário, que é 3.

Em seguida, o código chama o método keys() em x_dict. Isso retorna um objeto de visualização que contém as chaves do dicionário. Nesse caso, as chaves são "Prem", "Edward" e "Jorge", conforme mostrado na saída.

Em seguida, o código chama o método values() em x_dict. Isso retorna um objeto de visualização que contém os valores no dicionário. Nesse caso, os valores são 3, 1 e 2, respectivamente, conforme mostrado na saída.

Conjuntos

Os conjuntos são uma coleção de objetos distintos (exclusivos). Eles são úteis para criar listas que contêm apenas valores exclusivos no conjunto de dados. É uma coleção não ordenada, mas mutável, o que é muito útil quando você está analisando um conjunto de dados enorme.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

 in ()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

O código cria dois conjuntos: x_set e y_set. Cada conjunto é criado quando você passa uma cadeia de caracteres como argumento para a função set(). Nesse caso, x_set é criado a partir da string 'CAKE&COKE', enquanto y_set é criado a partir da string 'COOKIE'.

Em seguida, o código imprime cada conjunto usando a função print(). A primeira instrução print() imprime x_set, que contém os caracteres exclusivos da string 'CAKE&COKE'. O resultado mostra que x_set contém os caracteres 'A', '&', 'O', 'E', 'C' e 'K'. Da mesma forma, o segundo comando print() imprime y_set, que contém os caracteres exclusivos da string 'COOKIE'. O resultado mostra que y_set contém os caracteres "I", "O", "E", "C" e "K".

A terceira instrução print() tenta imprimir o conjunto de todos os elementos em x_set que não estão em y_set. No entanto, essa linha de código resulta em um NameError porque a variável x não foi definida. Presumivelmente, essa linha deveria ser print(x_set - y_set) em vez disso.

A quarta instrução print() imprime o conjunto de elementos exclusivos em x_set ou y_set, ou em ambos. O resultado mostra que o conjunto resultante contém todos os caracteres exclusivos de x_set e y_set.

Por fim, a quinta instrução print() imprime o conjunto de elementos que estão em x_set e y_set. O resultado mostra que esse conjunto contém os caracteres "O", "E", "K" e "C".

Arquivos

Os arquivos são tradicionalmente uma parte das estruturas de dados. E, embora o big data seja comum no setor de ciência de dados, uma linguagem de programação sem a capacidade de armazenar e recuperar informações armazenadas anteriormente dificilmente seria útil. Você ainda precisa usar todos os dados armazenados em arquivos nos bancos de dados e aprenderá como fazer isso.

A sintaxe de leitura e gravação de arquivos em Python é semelhante à de outras linguagens de programação, mas muito mais fácil de manusear. Aqui estão algumas das funções básicas que ajudarão você a trabalhar com arquivos usando Python:

• open() para abrir arquivos no seu sistema, o nome do arquivo é o nome do arquivo a ser aberto;
• read() para ler arquivos inteiros;
• readline() para ler uma linha de cada vez;
• write() para gravar uma string em um arquivo e retornar o número de caracteres gravados; e
• close() para fechar o arquivo.

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

O segundo argumento da função open() é o modo de arquivo. Ele permite que você especifique se deseja ler (r), gravar (w), anexar (a) ou ler e gravar (r+).

Para saber mais sobre o manuseio de arquivos em Python, não deixe de conferir esta página.

Você conseguiu!

Viva! Você chegou ao final deste tutorial! Isso deixa você um tópico mais próximo do seu sonho de conquistar o mundo da ciência de dados.

Se você estiver interessado, a caixa de ferramentas de ciência de dados Python do DataCamp, em duas partes, aprofunda-se em funções, iteradores, listas etc.

Faça uma pausa e, quando você estiver pronto, vá para um dos tutoriais recomendados para continuar sua jornada!