Anteriormente falamos sobre o objeto Series do Pandas, e neste artigo vamos explorar algumas funções de um outro tipo de objeto muito comum também fornecido pelo módulo Pandas, o DataFrame.

Os DataFrames do Pandas são uma estrutura de dados bastante versátil e poderosa que pode ser usada em análise, manipulação e processamento de dados em Python. Eles são empregados em uma ampla gama de aplicações de várias áreas, incluindo análise de dados, ciência de dados, engenharia, finanças, pesquisa e muito mais.

Algumas das principais aplicações dos DataFrames do Pandas incluem:

• Pré-processamento de Dados: Limpeza, formatação, dados duplicados, valores ausentes, transformação nos dados
• Análise e Exploração de Dados: Importação de dados, Cálculos de Estatística Descritiva (média, mediana, desvio-padrão, etc.).
• Manipulação de Dados: Filtro, seleção e ordenação para extrair informações específicas dos dados; funções de agregação, colunas calculadas
• Análise de Séries Temporais: Manipulação e análise de dados temporais, como séries temporais de preços de ações, dados climáticos, etc.; reamostragem
• Modelagem Estatística e Machine Learning: Criação de conjuntos de treinamento e teste em aprendizado de máquina, divisão de dados para validação cruzada, etc.

entre muitas outras.

Além disso, os DataFrames podem ser integrados com outras bibliotecas, como por exemplo as bibliotecas NumPy, SciPy, Matplotlib e inúmeras outras, permitindo executar diversas tarefas adicionais, como visualização de dados e cálculos complexos sobre os datasets, por exemplo.

O que é um DataFrame?

Um objeto do tipo DataFrame representa uma tabela de dados retangular bidimensional semelhante a uma tabela de banco de dados ou uma planilha do Excel, contendo uma coleção ordenada de colunas, em que cada uma pode ter um tipo de valor diferente (numérico, string, booleano etc.).

O DataFrame possui índices tanto para linha quanto para coluna; pode ser imaginado como um array de objetos Series, todos compartilhando o mesmo índice.

Há várias formas de construir um DataFrame, embora as mais comuns sejam a partir de dados armazenados em bancos de dados, arquivos CSV, arquivos de planilhas como o Excel, dicionários com listas de mesmo tamanho ou ainda a partir de arrays NumPy, entre outras.

Neste tutorial vamos criar DataFrames a partir de dicionários para explorar algumas de suas funcionalidades. Nos próximos tutoriais, vamos trabalhar também com importação de dados de planilhas do Excel, arquivos CSV e tabelas de bancos de dados relacionais, entre outras tarefas.

Criar um DataFrame a partir de um Dicionário

Vamos começar criando um DataFrame de exemplo a partir de um dicionário de dados. Antes disso, precisamos importar o módulo em nosso script:

import pandas as pd

Vamos criar agora um DataFrame a partir de um dicionário que contém nomes de países, quantidade de títulos mundiais da FIFA, e ano em que o país ganhou seu primeiro título.

dicionario={'País':['Brasil','Uruguai','Inglaterra','Espanha','Holanda','Itália','Argentina','Alemanha','França'],
'Ano':[1958,1930,1966,2010,None,1934,1978,1954,1998],
'Titulos':[5,2,1,1,0,4,3,4,2]
}
dados = pd.DataFrame(dicionario)
print(dados)

Saída:

  País       Ano    Titulos
0 Brasil     1958.0       5
1 Uruguai    1930.0       2
2 Inglaterra 1966.0       1
3 Espanha    2010.0       1
4 Holanda    NaN          0
5 Itália     1934.0       4
6 Argentina  1978.0       3
7 Alemanha   1954.0       4
8 França     1998.0       2

Note que na linha correspondente à Holanda a coluna Ano traz o valor NaN, que significa “Not a Number” (Não é um Número), indicando que este dado está ausente (a Holanda ainda não ganhou nenhuma copa, por isso um valor para a coluna de ano não existe!)

Mostrar início ou fim do dataset

Se o conjunto de dados for grande e não quisermos exibi-lo inteiro na tela, podemos imprimir apenas as cinco primeiras ou as cinco últimas linhas com os métodos head() e tail(), respectivamente:

# 5 primeiras linhas
print(dados.head())

# 5 últimas linhas
print(dados.tail())

Por padrão, o Pandas limita o número de linhas exibidas na tela a 60 linhas e o número de colunas a 20 colunas, para evitar saída de grandes volumes de dados.

Manipulação de colunas

Podemos alterar a ordem das colunas passando como parâmetro ao método .DataFrame() uma lista de valores a serem usados como cabeçalho:

dados = pd.DataFrame(dados, columns=['Titulos','País','Ano'])
print(dados)

Para ver apenas os nomes das colunas constituintes do df:

print(dados.columns)

Para imprimir colunas individuais (em vez do DataFrame completo) podemos passar o nome da coluna desejada como valor de índice (entre colchetes), ou então chamar a coluna pelo seu nome como uma propriedade (precedida de um ponto):

print('Países:')
print(dados['País'])
print('\nAnos:')
print(dados.Ano)

Adicionamos uma nova coluna ao DF simplesmente passando seu nome entre colchetes, e atribuindo valores a partir de uma sequência, como uma lista. Podemos inicializar a coluna com um único valor também (mesmo valor em todas as linhas), como por exemplo o valor 0:

# Acrescentar uma coluna ao DataFrame:
dados['Participações'] = 0
print(dados)

# Preencher a coluna com valores de uma lista:
part = [22,14,16,16,11,18,18,20,16]
dados['Participações'] = part
print(dados)

Para excluir uma coluna do DataFrame empregamos a função del:

# Excluir coluna "Participações"
del dados['Participações']
print(dados)

Manipulação de linhas

É possível excluir uma linha usando o método .drop(), passando o número da linha a excluir como um valor de índice. No exemplo a seguir vamos criar um novo DataFrame a partir do atual, excluindo nele a linha 4:

# Excluir a linha 4 (Holanda)
dados2 = dados.drop([4])
print(dados2)

Para excluir várias linhas de uma vez, basta passar uma lista com seus números de índice:

# Excluir as linhas 3, 4 e 5 de uma vez
dados2 = dados.drop([4, 3, 5])
print(dados2)

Para excluir uma linha no DataFrame em si, sem precisar criar uma cópia dele, usamos o parâmetro inplace=True:

# Excluir linhas in loco
dados.drop(4, inplace=True)
print(dados)

Slicing em DataFrames

Podemos retornar um conjunto de linhas passando seus índices, inclusive usando fatiamento (slicing):

# Retornar linhas de 1 a 5:
print(dados[1:5])

Também é possível realizar essa operação usando rótulos em vez de números de índice:

# Fatiamento com rótulos

dicionario={'País':['Brasil','Uruguai','Inglaterra','Espanha','Holanda','Itália','Argentina'],
'Ano':[1958,1930,1966,2010,None,1934,1978],
'Titulos':[5,2,1,1,0,4,3]
}

dados = pd.DataFrame(dicionario, index=['a','b','c','d','e','f','g'])
# Mostra df completo
print(dados, '\n')

# Mostra apenas linhas de rótulos b até e:
print(dados['b':'e'])

Indexação: loc() e iloc()

Podemos realizar indexação com método .loc(), retornando linhas e colunas específicas apenas por meio de seus rótulos:

# Indexação com loc
# Linha b, colunas de País e Títulos
print(dados.loc['b',['País', 'Titulos']])
# Linhas de a a d, coluna de Ano:
print(dados.loc[:'d','Ano'])

Ou ainda indexar com método .iloc(), que retorna as linhas e colunas específicas de acordo com números de índices:

# Indexação com iloc
print(dados.iloc[1,[0, 2]])

Ordenação em Dataframes

Podemos exibir os dados ordenados por índice tanto em ordem crescente quando decrescente com o método sort_index():

# Ordenação por índice
print(dados.sort_index())

# Ordenação por índice em ordem inversa
print(dados.sort_index(ascending=False))

Para ordenar os dados pelos valores de uma coluna específica usamos o método sort_values(), passando os nomes das colunas na ordem em que desejamos a ordenação:
 Ordenação por colunas: ordem alfabética de país
print(dados.sort_values(by='País'))

# Ordem alfabética inversa:
print(dados.sort_values(by='País', ascending=False))

# Ordenação por várias colunas: ordem crescente de títulos e alfabética de países
print(dados.sort_values(by=['Titulos','País']))

# Ou ainda ordem decrescente de títulos e alfabética de países
# Ordenação por várias colunas
print(dados.sort_values(by=['Titulos','País'],
ascending = [False, True]))

Renomear colunas

É possível renomear uma ou mais colunas de um DF usando o método rename(). Para tal, passamos um mapeamento de dicionário para o parâmetro “columns” contendo pares chave:valor nos quais a chave é o nome da coluna a renomear, e o valor é o novo nome que será usado.

Por exemplo, vamos renomear a coluna “Titulos” para “Campeonatos”:

# Renomear uma coluna 
dados2=dados.rename(columns = {'Titulos':'Campeonatos'})
print(dados2.columns)

Uma alternativa é usar o parâmetro axis=’columns’ ou axis=’1′:

# Renomear a coluna de volta
dados2=dados.rename({'Campeonatos':'Titulos'}, axis='columns')
print(dados2.columns)

Para alterar o nome da coluna in loco (sem criar outro df), usamos novamente o parâmetro inplace:

# Renomear coluna no DataFrame atual (inplace).
dados2.rename({'Titulos':'Campeonatos'}, axis='columns', inplace=True)
print(dados2.columns)

Para renomear múltiplas colunas o processo é o mesmo, bastando passá-las como um mapeamento de dicionário.
Por exemplo, vamos renomear as colunas “Campeonatos” e “Ano” para “Titulos” e “Primeiro_Titulo” respectivamente no df dados2:

# Renomear várias colunas de uma vez no DataFrame atual.
dados2.rename({'Campeonatos':'Titulos', 'Ano':'Primeiro_Titulo'}, axis='columns', inplace=True)
print(dados2.columns)

Também podemos renomear todas as colunas de um dataframe de uma vez, passando para isso uma lista com os novos nomes a usar. O comprimento da lista deve ser igual ao número de colunas existentes no df, e as colunas serão renomeadas na ordem em que aparecem.

Note que neste caso renomeamos as colunas SEM usar o método rename().

Por exemplo:

# Renomear colunas com lista
nomes = ['Nação','Ano_Ganhou','Qtde_Titulos']
dados2.columns = nomes
print(dados2.columns)

Renomear colunas adicionando sufixos ou prefixos

Às vezes precisamos renomear colunas adicionando sufixos ou prefixos na forma de uma sequência de caracteres. Podemos fazer isso usando os métodos add_prefix() ou add_suffix(). Por exemplo, vamos adicionar o prefixo “copa_” a todas as colunas do dataframe dados2:

# Renomear todas as colunas adicionando um prefixo
dados2 = dados2.add_prefix('copa_')
print(dados2.columns)

Leia mais aqui: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.add_prefix.html

Para remover um prefixo ou sufixo, podemos usar (entre outros) o método str.replace(), que substitui todas as ocorrências de uma determinada string por outra string (ou nenhuma string, que é o caso). Vamos remover o prefixo “copa_” adicionado anteriormente para testar:

# Remover prefixo com método str.replace
dados2.columns = dados.columns.str.replace('copa_', '')
dados2

Cuidado ao usar esse método para remover prefixos e sufixos, pois se houverem outras sequências de caracteres nos nomes das colunas iguais às que se deseja remover, estas também serão removidas, alterando de forma indesejada os nomes.

No próximo artigo estudaremos algumas técnicas de limpeza e tratamento de dados ausentes ou duplicados em um dataframe.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Como usar o objeto DataFrame da biblioteca Pandas em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O módulo Pandas é uma biblioteca de código aberto em Python que fornece estruturas de dados e ferramentas para análise de dados eficientes e bastante flexíveis. Essa biblioteca é amplamente empregada em tarefas de manipulação, limpeza, análise e transformação de dados em projetos diversos de ciência de dados, análise de dados e engenharia de software em geral.

O Pandas possui duas estruturas de dados principais: os objetos Series e DataFrame. Neste tutorial vamos trabalhar com o objeto Series, e na próxima lição, abordaremos o objeto DataFrame.

Objeto Series

Um Series (“Série”) é um objeto do tipo array unidimensional contendo uma sequência de valores (semelhante a uma lista ou um array do NumPy) e um array associado de rótulos (labels) de dados, chamado de índice.

Ou seja, trata-se de uma estrutura de dados simples cujos valores são armazenados na forma de uma coluna de dados, porém contendo uma coluna de valores de índice associados.

Outra forma de pensar em um Series é como um dicionário ordenado de tamanho fixo, como se fosse um mapeamento entre valores de índices e valores de dados. Ele pode inclusive ser utilizada em alguns contextos em que um dicionário seria empregado.

No geral, usamos Series para guardar dados sobre um atributo em particular no dataset, sendo possível extrair uma coluna de um DataFrame na forma de um objeto Series, ou ainda adicionar uma coluna a um DataFrame a partir de um Series.

Como importar a biblioteca Pandas

Para que possamos criar e usar um objeto Series, primeiramente devemos importar o módulo Pandas (que deve estar instalado):

import pandas as pd

Caso o módulo Pandas não esteja instalado, use um gerenciador de pacotes como o pip ou conda para realizar sua instalação, como segue:

pip install pandas

ou (se estiver usando o Anaconda / Miniconda)

conda install pandas

Como criar um objeto Series

Podemos criar um objeto Series de várias maneiras, incluindo a partir de listas, dicionários, arrays NumPy e até mesmo criar Series vazias. Vejamos cada uma dessas formas com um exemplo.

Criar objeto Series vazio invocando o método Series()

# Objeto Series vazio
serie = pd.Series()
print(serie)

Criar Series a partir de uma lista comum

Uma forma mais comum é criar um objeto Series passando algum tipo de array de dados, como uma lista de valores:

# Series com lista do Python
dados = pd.Series([12, 34, 21, -9, 0, 7])
print(dados)

Saída:

0    12
1    34
2    21
3    -9
4     0
5     7
dtype: int64

Criar objeto Series a partir de um array NumPy

Podemos ainda passar um array NumPy para criar um Series (a biblioteca NumPy deve estar instalada para que o exemplo a seguir funcione):

# Series com array NumPy
import numpy as np

array_numpy = np.array([10, 20, 30, 40, 50, 60])
dados = pd.Series(array_numpy)
print(dados)

Saída:

0    10
1    20
2    30
3    40
4    50
5    60
dtype: int32

Criar Series preenchida com valores repetidos

Além disso, podemos criar um Series preenchido com um dado repetido para todos os índices:

# Series com repetição de itens
serie = pd.Series(33, index = ["num1", "num2", "num3", "num4", "num5"])
print(serie)

Saída:

num1    33
num2    33
num3    33
num4    33
num5    33
dtype: int64

Criar Series a partir de um dicionário

Finalmente, podemos criar um objeto Series passando um dicionário como parâmetro. Neste caso, as chaves serão usadas como índices e os valores serão os itens:

# Series com dicionário
dicionario = {
    'Ano' :1950,
    'Item' : 'TV',
    'Valor' : 250.60
}

serie = pd.Series(dicionario)
print(serie)

Saída:

Ano       1950
Item        TV
Valor    250.6
dtype: object

Outro exemplo de dicionário

dicionario = {'Brasil': 5, 'EUA': 0, 'Inglaterra': 1, 'Argentina': 3}
dados = pd.Series(dicionario)
print(dados)

Saída:

Brasil        5
EUA           0
Inglaterra    1
Argentina     3
dtype: int64

Valores e índices

A representação em string de uma Series exibida interativamente mostra o índice à esquerda e os valores à direita. Como não especificamos um índice para os dados, um índice default constituído dos inteiros de 0 a n-1 (em que n é o tamanho dos dados) é criado.

Podemos obter a representação do array e o objeto de índice de Series por meio de seus atributos de valores (values) e de índice (index), respectivamente:

print('Dados: ', dados.values)
print('Índices: ', dados.index)

Saída:

Dados:  [5 0 1 3]
Índices:  Index(['Brasil', 'EUA', 'Inglaterra', 'Argentina'], dtype='object')

Criar índices personalizados

Com frequência, precisamos criar um Series com um índice que identifique cada ponto de dado com um rótulo. Neste caso passamos o parâmetro index=[] contendo uma lista de valores que serão usados como índices:

dados = pd.Series([12, 34, 21, -9, 0, 7], index=['a','b','c','d','e','f'])
print(dados)

Saída:

a    12
b    34
c    21
d    -9
e     0
f     7
dtype: int64

Podemos usar rótulos no índice quando selecionamos valores únicos ou um conjunto de valores:

print('Dado no índice c: ', dados['c'])
print('\nÍndices b e e:')
print(dados[['b','e']])

Saída:

Dado no índice c:  21

Índices b e e:
b    34
e     0
dtype: int64

Operações Gerais em objetos Series

Agora que sabemos como criar e acessar objetos Series do Pandas, vamos conhecer algumas operações básicas que podemos realizar sobre os índices e dados armazenados na estrutura.

1. Acessar um item

Podemos acessar itens (valores) usando número de posição de índice ou nome de índice (se aplicado):

serie = pd.Series([10, 20, 30, 40, 50], index = ["num1", "num2","num3", "num4", "num5"])
print('Item na posição 0: ', serie[0])
print('Item de índice num3: ', serie['num3'])

Saída:

Item na posição 0:  10
Item de índice num3:  30

2. Descobrir valores máximo e mínimo

Podemos retornar os valores máximo e mínimo de um objeto Series com o emprego dos métodos .max() e .min():

serie = pd.Series([5, 7, 12, 2, 1, 6, 7, 0, -3, 22])
print(f'Menor valor: {serie.min()}')
print(f'Valor mais alto: {serie.max()}')

Saída:

Menor valor: -3
Valor mais alto: 22

Para obter o índice associado ao maior valor usamos o método .idxmax() e o índice do menor valor com .idxmin():

serie = pd.Series([5, 7, 12, 2, 1, 6, 7, 0, -3, 22])
print(f'Valor mais alto: {serie.max()}')
print(f'Índice do maior valor: {serie.idxmax()}')
print(f'Índice do menor valor: {serie.idxmin()}')

Saída:

Valor mais alto: 22
Índice do maior valor: 9
Índice do menor valor: 8

3. Funções de Estatística Descritiva

Diversas funções de estatística descritiva estão disponíveis em objetos Series, na forma de métodos associados, como Média Aritmética Simples, Mediana e Somatório, entre outras.

A média aritmética pode ser obtida com o método .mean():

print(f'Média aritmética: {serie.mean()}')

Saída:

Média aritmética: 5.9

A mediana com .median():

print(f'Mediana dos valores: {serie.median()}')

Saída:

Mediana dos valores: 5.5

E o somatório dos valores com .sum():

print(f'Somatório dos valores: {serie.sum()}')

Saída:

Somatório dos valores: 59

4. Converter objeto Series em lista comum do Python

Podemos converter um objeto Series em uma lista comum do Python com o método .tolist():

serie = pd.Series([5, 7, 12, 2, 1, 6, 7, 0, -3, 22])

# Ver objeto Series
print(serie)

# Criar lista a partir de Series
lista = serie.tolist()

# Ver lista criada
print('Lista: ', lista)

Saída:

0     5
1     7
2    12
3     2
4     1
5     6
6     7
7     0
8    -3
9    22
dtype: int64
Lista:  [5, 7, 12, 2, 1, 6, 7, 0, -3, 22]

5. Mostrar apenas os primeiros e últimos itens da Series

Se a quantidade de itens no objeto Series for grande, talvez você queira ver apenas os primeiros valores para ter uma ideia da natureza dos dados. Neste caso, pode usar o método head(), que retorna os cinco primeiros itens da série.

print(serie.head())

Saída:

0     5
1     7
2    12
3     2
4     1
dtype: int64

Da mesma forma, para mostrar os cinco últimos elementos, usamos o método .tail()

Dependendo da quantidade de itens, o Pandas retorna automaticamente apenas os cinco primeiros e os cinco últimos, sem a necessidade de usar o método .head().

No exemplo a seguir geramos 1000 números aleatórios usando a biblioteca NumPy, e criamos um Series do Pandas com esses valores. Na sequência, imprimimos os valores na tela – somente os cinco primeiros e cinco últimos devem aparecer neste caso, mesmo sem usar os métodos head() e tail():

import pandas as pd
from numpy import random

lista = []
for i in range(1000):
    lista.append(random.randint(250))
dados = pd.Series(lista)
print(dados)

Saída:

0        0
1       39
2      161
3      125
4      147
      ... 
995     24
996     95
997    165
998    144
999     45
Length: 1000, dtype: int64

6. Mostrar os elementos ordenados por valores de índice: método .sort_index()

dicionario = {'Brasil': 5, 'EUA': 0, 'Inglaterra': 1, 'Argentina': 3}
dados = pd.Series(dicionario)
print(dados.sort_index())

Saída:

Argentina     3
Brasil        5
EUA           0
Inglaterra    1
dtype: int64

7. Mostrar os elementos ordenados por valores dos itens: método .sort_values()

dicionario = {'Brasil': 5, 'EUA': 0, 'Inglaterra': 1, 'Argentina': 3}
dados = pd.Series(dicionario)
print(dados.sort_values())

Saída:

EUA           0
Inglaterra    1
Argentina     3
Brasil        5
dtype: int64

Vamos praticar um pouco agora.

Dataset para exercícios

Escreva um código que gere um objeto Series do Pandas, contendo uma lista com todos os países da União Europeia e suas respectivas populações, com os nomes dos países sendo usados como índices.

# Dicionário contendo os países da União Europeia e suas populações
dados = {
'Austria': 9006398,
'Alemanha': 83289318,
'Bélgica': 11589623,
'Bulgária': 7000039,
'Chipre': 1207361,
'Croácia': 4076246,
'Dinamarca': 5806015,
'Eslováquia': 5459642,
'Eslovênia': 2095861,
'Espanha': 47351567,
'Estônia': 1324820,
'Finlândia': 5523231,
'França': 66977107,
'Grécia': 10423056,
'Hungria': 9775564,
'Irlanda': 4882495,
'Itália': 60233948,
'Letônia': 1906743,
'Lituânia': 2793471,
'Luxemburgo': 613894,
'Malta': 493559,
'Países Baixos': 17134872,
'Polônia': 37974750,
'Portugal': 10286263,
'República Tcheca': 10693939,
'Romênia': 19405156,
'Suécia': 10106005,
}

# Criar um objeto Series a partir do dicionário
populacao_ue = pd.Series(dados)

# Exibir o objeto Series
print(populacao_ue)

Exercícios: Series do Pandas

Vamos treinar agora. Para os próximos exercícios, use o Series populacao_ue criado anteriormente. As respostas estão na sequência, com códigos sugeridos.

01. Imprimir a população da França.

02. Imprimir a lista de países da União Europeia em ordem alfabética.

03. Calcular e imprimir o número total de países na União Europeia.

04. Calcular e imprimir a população média dos países da União Europeia. Mostrar o resultado com duas casas decimais apenas.

05. Encontrar e imprimir o país com a maior população na União Europeia.

06. Filtrar e imprimir os países da União Europeia com população acima de 10 milhões, mostrando o resultado em ordem alfabética de nome de país.

07. Calcular e imprimir a população total da União Europeia.

08. Calcular e imprimir a porcentagem da população da Espanha em relação à população total da União Europeia.

09. Ordenar a Series em ordem decrescente de população e imprimir os cinco primeiros países.

10. Criar uma nova Series com a população de apenas três países da União Europeia e calcular a média da população desses países.
Use como exemplos os países França, Alemanha e Croácia.

11. Como exibir apenas as últimas três linhas do Series Pandas de nome “populacao_ue”?
A. populacao_ue(3:)
B. populacao_ue(1:3)
C. populacao_ue(-3:)
D. populacao_ue(:3)
E. populacao_ue(+3)

12. Podemos criar um objeto Series do Pandas usando:
A. Array NumPy
B. Lista
C. Dicionário
D. Valores repetidos
E. Todos os anteriores

RESPOSTAS DOS EXERCÍCIOS

01.

print(populacao_ue['França'])

02.

print(populacao_ue.sort_index())

03.

numero_paises = len(populacao_ue.index)
print("Número de países na União Europeia:", numero_paises)

04.

populacao_media = populacao_ue.mean()
print(f'População média dos países da União Europeia: {round(populacao_media, 2)}')

05.

pais_maior_populacao = populacao_ue.idxmax()
print("País com maior população na União Europeia:", pais_maior_populacao)

06.

# Filtrar os países da União Europeia com população acima de 10 milhões
paises_mais_10M = populacao_ue[populacao_ue > 10000000]

# Ordenar os países filtrados em ordem alfabética e imprimir
paises_ordenados = paises_mais_10M.sort_index()
print("Países da União Europeia com população acima de 10 milhões, em ordem alfabética:")
print(paises_ordenados)

07.

print(f'População total da União Europeia: {populacao_ue.sum()} habitantes')

08.

populacao_espanha = populacao_ue['Espanha']
populacao_total = populacao_ue.sum()
porcentagem_espanha = (populacao_espanha / populacao_total) * 100
print(f'População da Espanha em relação à população da UE: {porcentagem_espanha:.02f}%')

09.

paises_mais_populosos = populacao_ue.sort_values(ascending=False)
print("Cinco primeiros países mais populosos:")
print(paises_mais_populosos.head())

10.

paises_selecionados = populacao_ue[['França', 'Alemanha', 'Croácia']]
media_populacao_selecionados = paises_selecionados.mean()
print("Média da população:", media_populacao_selecionados)

11.

C. populacao_ue(-3:)

12.

E. Todos os anteriores

É isso aí! No próximo tutorial vamos apresentar o objeto DataFrame (df) do Pandas, mostrando como criar um dataframe e como manipular seu conteúdo pode meio dos métodos e propriedades disponíveis.

O post Como usar o objeto Series da biblioteca Pandas em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Se você estuda ou pesquisa materiais relacionados a bancos de dados ou ciência de dados (ou áreas correlatas), já deve ter se deparado com o termo “dataset” em algum momento. Talvez até já tenha utilizado um em algum projeto, mesmo que não se lembre do fato.

Mas, o que é um data set? Será o mesmo que um database (banco de dados)? Qual a relação entre dataset e database? E quanto de “data” (dados) é necessário para termos um um “set” (conjunto) deles?

Vou responder a essas e  outras perguntas sobre o assunto neste artigo. 

Coleções de dados

Um data set (ou ainda dataset) é, basicamente, uma coleção de dados.

Esses dados podem ser tabulares (na forma de uma tabela), como os encontrados em bancos de dados relacionais, ou ainda podem ser coleções de arquivos ou documentos em formatos variados.

Um grupo de registros pode ser chamado de data set. Em um dataset podemos armazenar os mais variados tipos de informações, tais como registros médicos, dados de sensores, informações científicas, dados estatísticos como dados de censos, e muitas outras.

Esses dados são então utilizados por aplicações para realizar processos de análise, com o intuito de obter informações e novos insights para um negócio.

Onde conseguimos um Data set?

Diversos data sets estão disponíveis para uso pelo público, para pesquisas ou simplesmente aprendizado de alguma tecnologia como Big Data, Machine Learning ou Bancos Relacionais.

Exemplos incluem:

• Dataset Iris Flower
• Banco MNIST

Alguns sites disponibilizam e permitem a publicação de data sets abertos (ou com algum custo), como por exemplo:

• Data Hub – Diretório de data sets abertos gerenciado por uma comunidade
• World Bank Open Data – Dados de Desenvolvimento Mundial do Banco Mundial
• DATA.GOV – Dados abertos do governo dos Estados Unidos da América 
• dados.gov.br – Portal Brasileiro de Dados abertos 
• IMF Data – Dados do Fundo Monetário Internacional (FMI)
• Kaggle Datasets – Sistema de busca de data sets do Kaggle

Os datasets podem ser gerados a partir de inúmeras fontes de dados distintas, como por exemplo dados de compras realizadas pelos usuários de uma loja, avaliações desses usuários sobre os produtos ou serviços adquiridos, preenchimento de formulários e pesquisas online (ou físicas), oriundos de sistemas eletrônicos como sensores de dados físicos, e muitas outras.

Como é composto um Dataset

No geral, um data set consiste de dois componentes básicos: linhas e colunas, mas não exatamente como em uma planilha. Comumente, cada linha de um data set contém dados a respeito de uma informação em particular – similar a uma tabela, mas não necessariamente idêntico. É comum o emprego de arquivos CSV (valores separados por vírgulas) para a criação de datasets.

Como exemplo, podemos considerar o fragmento de conjunto de dados a seguir, que trata de elementos químicos da tabela periódica. Trata-se de uma tabela de dados, na forma de uma planilha, que pode ser importada em programas de análise de dados e manipulada com o emprego de técnicas, funções e bibliotecas específicas.

Data Set de Elementos Químicos – Bóson Treinamentos

Neste exemplo, cada coluna se refere a uma propriedade específica dos elementos químicos, e cada linha contém o conjunto de propriedades de um elemento em particular. Para cada elemento há uma linha de dados.

Já o fragmento do data set openfootball a seguir, armazenado no Github e descoberto a partir do Data Hub, traz dados sobre as finais da Copa do Mundo de Futebol masculino de 1994, realizada nos EUA.

Note que o formato é diferente do exemplo anterior (elementos químicos), tratando-se de um arquivo de texto puro:

Dados da Copa do Mundo 1994 do Data Set OpenFootball

Porém, os dados ainda assim estão armazenados em um formato tabular, com cada linha no geral remetendo a uma partida específica, e cada coluna a uma informação sobre as partidas.

A última linha (linha 41) mostra os dados da final entre Brasil e Itália, e podemos ver que a partida foi realizada no Rose Bowl, em Pasadena, com vitória do Brasil por 3 a 2 nos pênaltis, após empate em 0 x 0 no tempo normal e prorrogação*

*dia memorável, quebrei o lustre da sala da casa de meus avós com uma cabeçada (sem querer) após o pênalti de R. Baggio, ao dar um pulo para comemorar.

Ferramentas usadas para analisar data sets

Muitas ferramentas podem ser empregadas na análise e uso dos dados de um data set, com algumas das mais comuns listadas a seguir:

• Bibliotecas das linguagens R e Python (como o Pandas)
• Tableau
• Microsoft Excel
• Power BI
• QlikView
• RapidMiner
• Linguagem SQL

entre muitos outros pacotes de software e bibliotecas de funções.

Diferença entre Dado, Dataset e Banco de Dados

É muito comum confundir esses termos, pois se referem a conceitos similares entre si. Mas eles não são a mesma coisa. Qual a diferença então entre Data set, Dados e Bancos de Dados (Database)?

Vejamos:

• Dados são observações ou medições brutas (não processadas ou processadas) representadas como texto, números ou outros formatos.
• Data set é uma coleção estruturada de dados, geralmente associados a um assunto específico.
• Já um Banco de Dados é uma coleção organizada de dados, que podem ser armazenados na forma de datasets correlacionados. Esses conjuntos de dados são geralmente armazenados e acessados eletronicamente a partir de um sistema informatizado (como um SGBD) que permite que os dados sejam facilmente acessados, manipulados e atualizados.

Conclusão

Um dataset é um conjunto de dados tabulados e organizados em um arquivo de formato específico (.csv, .xls, .botxt, etc.), empregado em várias áreas das ciências de dados como fonte de informação para pesquisa, estudo, obtenção de informações e treinamento de sistemas de aprendizado de máquina (machine learning) e inteligência artificial, entre outros.

E, falando em Ciência de Dados, quais linguagens de programação são as mais indicadas para trabalhar nessa área? Confira neste artigo: 7 linguagens de programação para Ciência de Dados.

O post O que é um Dataset apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A ciência de dados é uma área do conhecimento que envolve o estudo e a análise de dados dos mais variados tipos, incluindo financeiros, científicos, sociais e econômicos. Seu intuito é a extração de conhecimento, descoberta de informações ocultas e detecção de padrões em conjuntos de dados para auxiliar na tomada de decisões e gerar valor para o negócio.

Por conta disso, uma das profissões / carreiras mais em alta na atualidade é o cargo de Cientista de Dados. 

Um cientista de dados precisa ter um leque de conhecimentos diverso, combinando expertise em várias áreas do conhecimento, como matemática (principalmente estatística e probabilidade), conhecimentos específicos da área do negócio e, naturalmente, linguagens de programação para a criação de algoritmos e aplicações de software que são empregados no dia-a-dia.

E aqui surge a dúvida mais comum entre os aspirantes à ciência de dados: que linguagem de programação aprender? Dada a quantidade de opções existentes, incluindo linguagens de uso geral e linguagens de nicho, quais linguagens de programação seriam mais apropriadas para uso em ciência de dados?

Para ajudar a responder a essas perguntar e dar um direcionamento aos interessados na área, listo a seguir sete linguagens de programação muito importantes e úteis para o trabalho de um cientista de dados atualmente (e para outras áreas, como Big Data, Machine Learning, Inteligência Artificial, e outras).

Vamos lá!

1. Python

Python é, sem sombra de dúvida, a linguagem ideal para iniciantes em ciência de dados e muitas outras áreas da computação). Com Python é possível trabalhar em nichos diversos como aprendizado de máquina, inteligência artificial, análise de dados, visualização de dados, automação de tarefas e como linguagem de propósito geral, tudo graças ao seu extenso conjunto de poderosas bibliotecas, que inclui ferramentas como NumPy, Matplotlib, Pandas, SciPy e muitas outras.

É, atualmente, uma das linguagens mais utilizadas no mundo, e com perspectivas de crescimento ainda maior nos próximos anos.
Além de tudo isso, é uma linguagem ideal para iniciantes em computação, por sua facilidade de uso e curva de aprendizado muito suave.

É uma linguagem de código aberto, orientada a objetos, muito flexível e com uma comunidade de desenvolvedores gigantesca, que facilita enormemente a troca de informações e orientações sobre ouso da linguagem em si e suas bibliotecas.

2. Linguagem R

Outra linguagem de peso no mundo da ciência de dados, é uma das ferramentas open source para análise estatística mais poderosas disponívis, e que pode ser empregada em tarefas como processamento de grandes volumes de dados, modelagem matemática, mineração de dados, cálculos estatísticos (claro!), e ainda por cima possui bibliotecas gráficas de alta qualidade para visualização de dados.

Com R é possível criar aplicações como sistemas de detecção de fraudes financeiras, modelagem de análise de sentimentos e sistemas de recomendação, além de aplicações para áreas tão diversas quanto engenharia, medicina e biologia.

Tarefas como análise de séries temporais, clustering e modelagem linear são algumas dos exemplos de processos que a linguagem R suporta com simplicidade.

Além disso, existem várias interfaces que podem ser usadas com o R para facilitar o trabalho de desenvolvimento de algoritmos e aplicações, tais como o RStudio e Jupyter Notebooks, entre outras.

Comumente usamos Python e R combinados, unindo suas funcionalidades em um par excelente para praticamente qualquer aplicação.

Como contras da linguagem, podemos citar a velocidade de execução e a quantidade de recursos de hardware que scripts escritos em R consomem, especialmente memória RAM.

3. SQL

Linguagem de Consulta Estruturada para Bancos de Dados, é uma das linguagens mais importantes para trabalho com dados e principalmente Big Data, ao combinar capacidades analíticas e de consultas com transacionais. SQL é um conhecimento básico para praticamente qualquer interessado em trabalhar com desenvolvimento de sistemas de todos os tipos, e em ciência de dados é imprescindível.

Em que usamos SQL exatamente? Bem, trata-se de uma linguagem de domínio específico, sendo empregada no gerenciamento de dados armazenados, local ou remotamente.

Note que existem diversos “sabores” de SQL, dependendo da implementação do fabricante – mas todos seguem um mesmo padrão, o ANSI SQL. E um ponto muito favorável do SQL é que essa linguagem se integra com muita facilidade às outras linguagens de programação, sendo extremamente comum desenvolver aplicações que mesclem códigos escritos, por exemplo, em Python ou Java com SQL.

4. Java

Linguagem de propósito geral e alta performance, o Java é empregado no desenvolvimento de algoritmos para machine learning, além de encontrar aplicações em nichos como Big Data e IoT (Internet das Coisas). É vastamente empregada no desenvolvimento de aplicações móveis e para Web.

Muitos frameworks e ferramentas empregadas em Big Data são escritos ou rodam em Java, como por exemplo Apache Spark, Hive e o Hadoop.

Uma das grandes vantagens do Java é a disponibilidade de IDEs de qualidade para o desenvolvimento de aplicações com eficiência e rapidez, incluindo softwares de alta complexidade. Alguns dos IDEs mais comuns incluem o Eclipse, Netbeans e IntelliJ, entre outros menos usados.

Alguns dos nichos onde o Java é mais empregado na área de ciência de dados incluem Aprendizado Profundo (Deep Learning), Processamento de Linguagem Natural (NLP – Natural Language Processing) e Mineração de Dados (Data Mining), entre outras.

Um ponto no qual a linguagem peca é a falta de ferramentas altamente especializadas para trabalho com estatística e cálculos matemáticos avançados, o que pode ser contornado combinando a linguagem Java com outras linguagens mais especializadas como a linguagem R, por exemplo.

5. C/C++

São as linguagens mais antigas listadas neste artigo, e provavelmente as mais difíceis de aprender, mas nem por isso com importância menor: C/C++ (principalmente C++) constitui a principal ferramenta em muitos tipos de sistemas de alta performance, sendo empregada em áreas como Inteligência Artificial, Aprendizado de Máquina e Robótica, onde o processamento de dados analíticos precisa ser feito com muita rapidez e alta performance.

Uma das aplicações mais modernas do C++ é no desenvolvimento de aplicações para veículos autônomos, que necessitam de algoritmos de análise de dados altamente complexos e performáticos, e em muitas aplicações de tempo real onde conjuntos de dados precisam ser tratados praticamente no momento em que são utilizados.

É interessante notar que muitas das linguagens citadas neste artigo são elas próprias escritas em C ou C++, com Python, R e Julia, assim como muitas bibliotecas e frameworks usados em data science, como o TensorFlow, por exemplo.

6. Julia

Inicialmente concebida como uma linguagem para programação científica, é uma linguagem de alto nível extremamente rápida que pode ser usada para o desenvolvimento de diversos tipos de aplicações, sozinha ou em conjunto com bibliotecas C/C++ ou Python.

Sua grande força está nas tarefas de análise numérica, apesar de também poder ser usada como linguagem de programação de propósito geral. É uma linguagem intuitiva, bastante acessível, além de ser de código aberto.

Uma de suas principais aplicações é na área financeira, onde existe a necessidade de realizar cálculos de forma massiva e com muita rapidez, com cálculos de análise de risco ou análise de séries temporais.

Um de seus problemas é o fato de ser uma linguagem relativamente nova e, que por isso, ainda possui uma comunidade de usuários pequena, com menos documentação disponível para consulta.

Porém, permite o interfaceamento (direto ou por pacotes específicos) com bibliotecas de outras linguagens, como Python, R, C++, Matlab e até mesmo Fortran, a´lem de possuir suporta a computação distribuída e computação paralela, o que significa aplicações de elevada performance!

Suas ferramentas de visualização de dados ainda não estão no mesmo nível das ferramentas disponíveis outras linguagens, mas vem melhorando a cada dia.

7. Matlab / Octave

Matlab é um ambiente de computação matemática e uma linguagem proprietária amplamente utilizada em cenários que demandam operações de cálculos avançados.

Encontra aplicações em análise de dados, processamento de imagens, processamento de sinais e, evidentemente, criação de modelos matemáticos por meio da manipulação de matrizes, álgebra linear, análise numérica e outras técnicas, facilitando enormemente a resolução dos problemas matemáticos mais complicados.

É uma linguagem recomendada para trabalho com Big Data e também na Indústria, principalmente de Engenharia. O Matlab traz suporte nativo a diversos formatos de dados empregados em telemetria, sensores, processamento de imagem e vídeo, e muitos outros.

Como ponto talvez negativo do Matlab posso citar o fato de não ser uma linguagem muito rápida, e necessitar de uma licença, de custo relativamente elevado, para ser usada.

O Octave é a principal alternativa ao Matlab, podendo substitui-la no geral em quase todas as tarefas necessárias para análise de dados, com algumas diferenças funcionais. Além disso, é gratuito.

Extra: Matemática

Como citado no início do artigo, conhecimentos em matemática são muito importantes – até mesmo cruciais – para o trabalho na área de data science. Alguns dos tópicos mais relevantes em matemática que é necessário dominar – ou ao menos revisar – incluem:

• Estatística (essencial)
• Probabilidade (essencial)
• Cálculo Integral e Diferencial
• Cálculo Numérico (Álgebra Linear)

Entre outros. Claro que conhecer matemática é benéfico para qualquer área de atuação, principalmente nos domínios da tecnologia, independente do trabalho ser voltado para ciência de dados ou não.

Além disso, tão importante quanto conhecer as linguagens de programação é saber como usar as diversas bibliotecas e frameworks disponíveis para data science, pois, no dia-a-dia do trabalho, é o que você irá usar com mais frequência, e por isso vale a pena investir seu tempo nesse aprendizado.

Conclusão

Neste artigo procurei trazer algumas das linguagens de programação mais indicadas para quem deseja trabalhar com ciência de dados. Note que essas sete linguagens não são as únicas que se prestam a essa tarefa, existindo outras linguagens também interessantes para a área, como Haskell e Lisp, por exemplo. Ciência de Dados é uma área muito vasta, se ramificando em inúmeros caminhos possíveis, e a verdade é que provavelmente você precisará aprender mais do que uma das linguagens citadas – talvez várias delas ao longo de sua carreira e estudos.

Finalmente, tudo o que foi exposto aqui é, basicamente, minha opinião pessoal e minha visão, baseada em meus estudos e experiência de mercado e acadêmica.

Evidentemente vocês podem pensar de forma diferente – talvez achando que uma linguagem deveria ter sido incluída na lista, ou que uma das linguagens que citei não deveria estar aqui – e por isso os convido a postarem seus pensamentos nos comentários logo abaixo, para trocarmos ideias sobre esse assunto tão importante e interessante na atualidade – e certamente pelos anos vindouros.

Até!

O post 7 Linguagens de programação para Ciência de Dados – 2021 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos mostrar como instalar e configurar o IDE Juno, para desenvolvimento em linguagem Julia. O Juno é um ambiente de desenvolvimento para Julia que é instalado junto ao editor de textos Atom, e por isso é necessário ter o Atom pré-instalado em sua máquina – é a partir dele que o Juno será baixado, instalado e configurado.

O website oficial do Juno, com informações detalhadas e manuais de uso é o https://junolab.org.

Instalando o Juno no Windows 10

Vamos seguir os passos abaixo para instalar o IDE Juno em um computador com Windows:

1. É necessário ter a linguagem Julia já instalada na máquina antes de instalar o IDE Juno. Caso não a tenha, siga os passos deste tutorial para instalar a Julia no Windows.

2. Com a linguagem Julia já instalada, baixe e instale o editor Atom, se você ainda não tiver esse editor de textos em seu sistema. Logo após instalá-lo, abra-o.

3. No IDE Atom, vá até Configurações (Ctrl+,), e entre no painel de instalação (Install Packages).

Digite uber-juno na caixa de pesquisa Packages e pressione enter. Clique no botão de instalação do pacote da JunoLab com o mesmo nome (Install).

O Juno será instalado e configurado pelo Atom, incluindo todos os pacotes necessários. Aguarde enquanto o processo é executado

Após o término da instalação, pode ser necessário incluir o caminho do executável do Julia nas configurações do IDE para que seja possível utilizar a linguagem (no meu caso foi). Para isso, clique no menu do Atom em Packages -> Juno -> Settings.

Procure a caixa “Julia Path (The location of the Julia binary)” e nela insira o caminho completo do executável do Julia. Esse caminho pode ser obtido clicando com o botão direito do mouse sobre o ícone do Julia da área de trabalho do Windows, e selecionando Propriedades -> Atalho.
Geralmente o caminho é algo como C:\Users\nome-usuário\AppData\Local\Programs\Julia 1.5.3\bin\julia.exe, onde nome-usuário é o nome do usuário que você usou para se logar no sistema.

Copie e cole o link na caixa Julia Path (retire as aspas, se houverem). Pressione enter para finalizar.

Testar o Juno IDE

Para testar o IDE, clique no menu Juno -> Open REPL. Na seção “Press Enter to start Julia“, pressione a tecla enter para iniciar o ambiente da Julia. Pode demorar um pouco para que o interpretador esteja disponível, portanto, aguarde.

Para testar a linguagem e o IDE, vamos digitar as linhas de código a seguir no interpretador de comandos do Julia para executar um cálculo aritmético simples:

julia> a = 5;
julia> b = 8;
julia> c = a * b / 2;
julia> println(c)

Resultado:

É isso aí! Maiores informações sobre a instalação do Juno IDE, incluindo a resolução de problemas, podem ser obtidas na página de documentação oficial: docs.junolab.org/latest/man/installation/

O post Como instalar o IDE Juno para programação em Julia no Windows apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O matplotlib é uma biblioteca gráfica 2D, que contém uma grande coleção de módulos para trabalho com gráficos e visualização de dados em Python. 

Permite criar representações gráficas de dados de alta qualidade em vários formatos e também ambientes interativos, em inúmeras plataformas. Além de poder ser usado em scripts do Python, também pode ser empregado em Jupyter Notebooks, servidores de aplicação Web e em toolkits de interface gráfica, entre outros.

Com esta biblioteca podemos gerar gráficos de vários tipos, histogramas, scatterplots e muitos outros tipos de visualização de dados, usando poucas linhas de código (afinal, é Python!).

Neste artigo veremos como criar um gráfico simples usando matplotlib e seus módulos. Mas antes, vamos rever dois conceitos importantes que serão necessários: Plano Cartesiano e Geração de Listas em Python.

O Plano Cartesiano

Um plano cartesiano é, basicamente, uma representação gráfica que possui duas linhas numéricas: um eixo x (na horizontal) e um eixo y (na vertical), perpendiculares entre si.

O centro desse gráfico é chamado de Origem (O), e números no lado direito da origem no eixo x são positivos, e os à esquerda são negativos. Da mesma forma, números acima da origem no eixo y são positivos e números abaixo da origem, negativos.

Um ponto no gráfico é a combinação de um par de valores nos eixos x e y. Esse par de valores é chamado de coordenadas, estabelecendo a localização de um ponto qualquer.

A figura a seguir mostra um plano cartesiano com um ponto plotado (na cor roxa), na posição (2,3), que significa valor 2 no eixo x e valor 3 no eixo y:

Plano de coordenadas cartesiano. Gerado em https://www.oliverboorman.biz/projects/tools/cartesian_grid.php

Listas em Python

Usaremos listas para armazenar os dados que serão plotados nos gráficos. Assim, poderemos armazenar os valores dos eixos x e y que deverão ser plotados.

Antes disso, vamos relembrar como criar uma lista, acessar seus elementos individualmente e como iterar por eles.

Criar uma lista

Criamos uma lista atribuindo um conjunto de valores entre colchetes e separados por vírgulas a uma variável, como no exemplo a seguir:

minhaLista = [2, 5, 9, 12]

Criamos neste exemplo uma lista de nome minhaLista, contendo quatro elementos numéricos.

Acessar os elementos da lista

Para acessar um elemento de uma lista basta indicar o número da posição do elemento desejado, entre colchetes, logo após o nome da lista:

minhaLista[0]
minhaLista[3]

Nos dois exemplos acima, acessamos os elementos das posições 0 e 3 da lista. Lembre-se que o primeiro elemento de uma lista é sempre o elemento da posição 0, de modo que o elemento da posição 3 da lista acima é na verdade o quarto elemento armazenado.

Iteração em uma lista

Podemos iterar por uma lista, acessando todos os seus elementos sequencialmente, usando um laço for, como no exemplo a seguir:

for item in minhaLista:
    print(item)

Cada elemento da lista é atribuído à variável item em cada iteração, e seu valor é impresso na tela.

Agora que revisamos a criação de uma lista e o acesso a seus elementos, vamos ver como instalar o matplotlib em seu sistema.

Instalação do matplotlib

A instalação dos pacotes do matplotlib é muito simples. O site oficial da biblioteca é www.matplotlib.org

Instalação no Windows

Para instalar a biblioteca em um computador com Windows execute os seguintes comandos em um prompt:

python -m pip install -U pip
python -m pip install -U matplotlib

Instalação no Linux

Use o gerenciador de pacotes de sua distribuição para realizar a instalação do matplotlib no Linux. Por exemplo:

Debian / Ubuntu:

sudo apt install python3-matplotlib

Fedora:

sudo dnf install python3-matplotlib

Red Hat:

sudo yum install python3-matplotlib

Caso você esteja trabalhando com a distribuição Anaconda, não será necessário baixar e instalar o matplotlib, pois ele já vem instalado por padrão (além de trazer inúmeras outras ferramentas muito úteis para ciência de dados).

Mais informações sobre a instalação do matplotlib podem ser obtidas aqui: https://matplotlib.org/users/installing.html

Criar gráficos com matplotlib

Agora vamos criar gráficos com matplotlib efetivamente usando a biblioteca. Começamos criando duas listas para armazenar os dados dos eixos x e y que serão plotados no gráfico:

eixoX = [1, 2, 3, 4]
eixoY = [2, 5, 9, 12]

Usaremos o módulo pylab para realizar as operações necessárias à plotagem de um gráfico simples.

O PyLab é uma interface para a biblioteca Matplotlib, sendo um módulo pertencente à biblioteca. Este módulo importa o matplotlib.pyplot, para plotagem de gráficos, e o NumPy, para cálculos matemáticos e operações com arrays, em um namespace único.

Importar os módulos necessários:

from pylab import plot, show

Criar o gráfico:

plot(eixoX, eixoY)
show()

A função plot() cria o gráfico e o armazena em um objeto na memória; a função show() o mostra na tela.

Note que, se você não executar a função show(), o gráfico será criado mas não será exibido na tela, ficando armazenado em memória.

Como marcar os pontos no gráfico

Para marcar os pontos no gráfico usamos o parâmetro marker na função plot():

plot(eixoX, eixoY, marker='o')

O valor ‘o’ indica que os pontos serão pequenos círculos. podemos também marcar apenas os pontos no gráfico, sem as linhas que os conectam, da seguinte forma:

plot(eixoX, eixoY, 'o')

Como plotar mais de uma linha no mesmo gráfico

Vamos criar um gráfico que mostre as temperaturas máxima e mínima ao longo dos meses em um determinado local. Precisaremos de três listas:

meses = ['Jan', 'Fev', 'Mar','Abr','Mai','Jun','Jul','Ago','Set','Out','Nov','Dez']
Tmax = [38,39,32,29,26,22,19,15,20,22,25,27]
Tmin = [23,23,22,21,19,16,12,10,16,21,22,22]

Agora passamos as listas em pares meses/temperaturas para a função plot():

from pylab import plot, show, legend
plot(meses,Tmax,meses,Tmin)
legend(['Tmax','Tmin'])
show()

Note que uma cor diferente para cada linha é escolhida automaticamente, para indicar que cada linha corresponde a um conjunto de dados.

Note que também importamos o módulo legend, que nos permitirá adicionar uma legenda ao gráfico, de modo a sabermos qual linha corresponde a qual dado. A função legend() recebe uma lista de nomes como argumento, e usará essa lista para criar a legenda, com os nomes passados correspondendo às listas de valores plotadas no gráfico, em ordem.

A função legend() deve ser executada após a função plot() para funcionar.

Podemos adicionar um título e rótulos aos eixos x e y do gráfico. Para isso usamos as funções title(), xlabel() e ylabel(), que devem ser importadas a partir de seus módulos. Por exemplo, vamos adicionar rótulos e um título ao nosso gráfico:

from pylab import plot, show, legend, title, xlabel, ylabel
meses = ['Jan', 'Fev', 'Mar','Abr','Mai','Jun','Jul','Ago','Set','Out','Nov','Dez']
Tmax = [38,39,32,29,26,22,19,15,20,22,25,27]
Tmin = [23,23,22,21,19,16,12,10,16,21,22,22]
plot(meses,Tmax,meses,Tmin)
title('Temperaturas Máximas e Mínimas do Ano')
xlabel('Mês')
ylabel('Temp/°C')
legend(['Tmax','Tmin'])
show()

Finalmente, vamos configurar os valores máximo e mínimo de cada eixo. Por exemplo, queremos que o eixo y (temperaturas) mostre temperaturas entre 0 e 45 °C. Para isso, usamos a função axis() (importar o módulo axis também):

from pylab import plot, show, legend, title, xlabel, ylabel, axis

Adicionar a Função ao código anterior:

axis(ymin=0,ymax=45)

Resultado:

De forma similar, podemos também usar os parâmetros xmin e xmax na função axis() para determinar os limites numéricos máximo e mínimo no eixo x.

É isso aí! Nesta lição vimos como criar um gráfico bem básico – mas informativo – usando um módulo da biblioteca matplotlib. Na próxima lição vamos nos aprofundar na criação de gráficos mais especializados e em configurações mais complexas destes gráficos.

Até lá!. 

O post Como criar gráficos com matplotlib em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos mostrar como trabalhar com números complexos de forma básica usando a linguagem Python.

Números complexos possuem inúmeras aplicações, como por exemplo nas áreas de mecânica quântica, eletromagnetismo,  cartografia, processamento de sinais, geometria e diversas outras.

Mas o que são números complexos?

Na matemática, podemos classificar os números em duas categorias, os números reais e os números imaginários.

Um número real é aquele que, quando elevado ao quadrado sempre retorna um valor de sinal positivo, independente do número ser positivo ou negativo.

Por exemplo, 5 é um número real, pois 5² = 25 (positivo).
Outros exemplos de números reais:

-3 (-3² = 9)
1/2
34,23

Já números imaginários são números que, ao serem elevados ao quadrado, retornam um resultado negativo.
O número imaginário unitário é i, que simboliza a raiz quadrada de -1. Assim:

i2 = -1

Um número complexo z é a combinação de um número real com um número imaginário.
Assim, temos que:

z = a + bi

onde a é a parte real do número, e bi é a parte imaginária do número.

Exemplos de números complexos:

2 + 4i
-6 + 13i
7 – 5i
0.5 + 2.3i

Números Complexos em Python: o tipo complex

Para declarar uma variável do tipo complex (número complexo), basta atribuir-lhe um valor no formato x + yj. Por exemplo, vamos atribuir o número complexo 3+4j à variável x:

x = 3 + 4j

Note que em Python usamos a letra j para denotar a parte imaginária do número, em vez da letra i, que é usual na matemática convencional (a letra j é empregada em disciplinas de engenharia elétrica e física).
Podemos verificar o tipo da variável x com a função type(): 

type(x)
<class 'complex'>

Outra forma de criar um número complexo é com o emprego da função complex(x,y), que recebe dois parâmetros:

x: Valor da parte real do número complexo
y: Valor da parte imaginária do número complexo

Suponha que você quer criar a variável y, atribuindo-lhe o número complexo 5+2j. Usando a função complex() você pode simplesmente executar:

y = complex(5,2)

E então verificar o tipo da variável:

type(y)
<class 'complex'>

Verifique o conteúdo da variável também:

print(y)
(5+2j)

Operações com números complexos em Python

A linguagem Python nos permite realizar diversas operações usando números complexos, como soma, subtração, multiplicação e divisão, entre outras.

Vejamos alguns exemplos dessas operações básicas.

1 – Definir números complexos para usar nos exemplos de cálculos

a = 1+2j
b = complex(3,4)

2 – Soma de números complexos:

print(a + b)
(4+6j)

3 – Subtração de números complexos:

print(a - b)
(-2-2j)

4 – Multiplicação de números complexos:

print(a * b)
(-5+10j)

5 – Divisão de números complexos:

print(a / b)
(0.44+0.08j)

6 – Podemos obter as partes real e imaginária do número complexo acessando as propriedades real e imag do número, respectivamente:

print(a.real)
print(a.imag)
1.0
2.0

7 – Obter o Conjugado: Um conjugado possui a mesma parte real, porém uma parte imaginária de igual magnitude e sinal oposto. Para calculá-lo usamos o método conjugate():

print(b.conjugate())
(3-4j)

É isso aí! Neste tutorial introduzimos o conceito de números complexos em Python, e apresentamos algumas operações básicas que podem ser realizadas na linguagem. Na parte 2 deste tutorial vamos abordar o modulo cmath, que permite realizar diversas outras operações com números complexos, como cálculos de fase, conversão entre formas polar e retangular, uso de funções trigonométricas e hiperbólicas, funções de classificação, e muito mais.

O post Introdução aos Números Complexos em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos escrever um script em Python que permite calcular as raízes de uma equação do 2º grau (equação quadrática), com os valores das variáveis de entrada fornecidos pelo usuário.

Uma equação do 2º grau é dada por uma expressão do tipo:

ax2 + bx + c = 0

Onde x é uma incógnita, e os valores a, b e c são conhecidos – são os coeficientes da equação, que serão fornecidos pelo usuário ao programa. Os coeficientes são números reais, e o valor do coeficiente a deve ser diferente de zero, caso contrário a equação se torna uma equação de 1° grau.

A fórmula empregada para o cálculo dessas raízes é a famosa Fórmula de Bhaskara, dada por:

O trecho intermediário b² – 4ac também é chamado de “Discriminante”, ou “Delta” da equação.

Os valores de x que satisfazem a essa equação são suas soluções. Este tipo de equação pode ter até duas soluções – que chamaremos de x1 e x2. Se não houver solução com números reais (raízes reais), haverá solução com números complexos.

Também é possível que haja apenas uma solução (x1 = x2). Neste caso, dizemos que a raiz é dupla.

Código

A seguir temos o código que foi empregado na criação do script de exemplo.

# Calcular as Raízes de uma Equação do 2º Grau

def raizes(a, b, c):
    D = (b**2 - 4*a*c)
    x1 = (-b + D**(1/2)) / (2*a)
    x2 = (-b - D**(1/2)) / (2*a)

    print('\nValor de x1: {0}'.format(x1))
    print('Valor de x2: {0}'.format(x2))

if __name__ == '__main__':
    while True:
        print('Calculando as raízes de uma equação de 2º grau\n')
        a = float(input('Entre com o valor de a: '))
        b = float(input('Entre com o valor de b: '))
        c = float(input('Entre com o valor de c: '))
        raizes(a,b,c)

        continua = input('Deseja sair? Digite q ou Enter para novo cálculo:')
        if (continua == 'q'):
            break

Neste script, criamos uma função de nome raizes(), que recebe como parâmetros os valores de a, b e c da equação a ser resolvida e aplica a fórmula apresentada anteriormente. Invocamos  essa função no programa principal, após requisitar os valores ao usuário, dentro de um loop infinito com laço while, para que o script seja repetido quantas vezes o usuário desejar, até ser encerrado com o pressionamento da tecla q.

Teste do script

Para testar nosso programa executamos o script e fornecemos os valores de a, b e c. Suponha que desejamos resolver as equações a seguir:

x² + 3x + 2 = 0

e

4x² + 2x + 3 = 0

Rodamos o script duas vezes, fornecendo os valores solicitados, para obter os valores das raízes das equações:

Note que a primeira equação retorna duas raízes reais, de valores -1 e -2. Já a segunda equação não possui raízes reais, mas o Python calcula as raízes na forma de números complexos, retornando os valores (aproximados) -0.2499 + 0.82915619758885j e -0.2500 – 0.82915619758885j (o python usa a letra j em vez de i para a parte imaginária de um número complexo).

É isso aí! Em breve veremos como gerar um gráfico a partir de uma equação deste tipo, usando a biblioteca matplotlib. Até a próxima!

O post Calcular Raízes de Equação de 2º Grau com Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo trazemos um programa simples para cálculo de tabuadas em Python. O objetivo deste programa é treinar o uso de funções, laços de repetição e entrada de dados do usuário, além de criar um algoritmo matemático que pode ser muito útil em determinadas situações.

Uma tabuada, ou tábua de multiplicação, é uma sequência de multiplicações de um número x qualquer por valores sucessivos incrementais, geralmente de 1 até 10 (mas podendo se estender conforme a necessidade).

A seguir temos o código do script que utilizamos:

# Programa Tabuada em Python
def tabuada(x):
    for cont in range(1,11)
        print('{0} x {1} = {2}'.format(x,cont,x*cont))

if __name__=='__main__':
    num = int(input('Digite um número: '))
    tabuada(num)

Começamos definindo uma função de nome tabuada(), que irá receber como argumento um valor inteiro x, para o qual desejamos calcular sua tabuada (tábua de multiplicação). O programa gera um loop de repetição usando uma estrutura for, que irá repetir 10 vezes a multiplicação do número fornecido pelos valores sequenciais de 1 até 10, e imprimir esses valores na tela (formatados).

No programa principal (main) pedimos ao usuário que entre com um número, usando a função input(), convertemos esse valor para número inteiro e o armazenamos na variável num. Finalmente, passamos a variável num como parâmetro na invocação da função tabuada().

A seguir podemos ver o programa calculando a tabuada do número 9:

Você pode estender o programa para calcular qualquer intervalo de valores na tabuada, como por exemplo uma tábua de  multiplicações de 1 a 20. Experimente modificar o programa para treinar e aprender mais.

É isso aí! Nos próximos artigos criaremos mais algoritmos de cálculos variados em Python. Até!

O post Programa que calcula Tabuada em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.