Básico: Colab, Python, Numpy E Pandas: 2.1. Ambiente Google Colaboratory Ou

08/05/24, 10:31 2.
Básico: Colab, Python, NumPy e Pandas — <h2 style="color:#cc0000;"><b>Introdução à Visualização de Dados</b></h2><p style="font-size:80%;color:#cc0000;">com Python</p>
Open in Colab
2. Básico: Colab, Python, NumPy e Pandas

Para uma introdução à visualização de dados com Python é esperado que você tenha alguma familiaridade com linguages
de programação, Python e mesmo alguns pacotes como o NumPy e o Pandas. Isso é essencial se você estiver fazendo a trilha
de programação de leitura deste livro. De qualquer modo, cobriremos aqui os principais recursos e funções do Python,
NumPy e Pandas que empregaremos neste livro e você pode recorrer à documentação ou outras referências online desses
pacotes para maiores detalhes. Há também uma introdução ao ambiente Google Colab que empregamos para criar este
livro e que você pode empregar para executar e explorar os códigos aqui apresentados.
Caso você já domine ou esteja confortável com esses recursos você pode pular este capítulo e seguir para o próximo.
2.1. Ambiente Google Colaboratory ou Colab

O Google Colaboratory ou Colab é um ambiente que permite você escrever código Python diretamente em seu navegador,
sem nenhuma configuração ou instalação de software, e que ainda fornece acesso a recursos para processamento e
compartilhamento fácil de código (GitHub, Google Drive etc.). Para acesso a esse ambiente basta você entrar no seu
navegador https://colab.research.google.com/.
2.1.1. Python Notebooks

Python notebooks (ou Jupyter notebooks) combinam em um único documento código executável, texto e saídas dos
programas e podem incluir imagens, HTML e até textos LT
A
EX. Em um ambiente interativo, como o Colab, você pode
editar os códigos e textos, e executar os programas produzindos as saídas no próprio documento. É uma forma bastante
útil de criar e publicar códigos e todo o material deste livro foi criado em Python notebooks para que você possa
reproduzir e alterar os códigos que são fornecidos.
Se você estiver acessando um Python notebooks, aqui está uma célula de código com um breve script Python que você
poderá executar calculando um valor, armazenando-o em uma variável e exibindo em seguida o resultado:
segundos_do_dia = 24 * 60 * 60
segundos_do_dia
86400
2.1.2. Células de Código

As células de código podem conter qualquer script ou conjunto de comandos Python.
# imports
import numpy as np
import matplotlib.pyplot as plt
cores = 'rgbcmyk'
label = ['red','green','blue','cyan','magenta','yellow','black']
# 'input' não suportado para edição de JupyterBooks, comente e tire os

comentários conforme indicado para execução no Colab
# n = int( input('Entre com um número inteiro: ') ) # Tire o

comentário
n = 12 # Comente aqui
cor = n % len(cores)
x = 200 + np.random.randn(100)
plt.plot(x,color=cores[cor])
plt.title(label[cor].upper(),fontsize=14)
plt.show()
https://meusite.mackenzie.br/rogerio/MyBook/_build/html/c0_parte_1.html 1/19
08/05/24, 10:31 2. Básico: Colab, Python, NumPy e Pandas — <h2 style="color:#cc0000;"><b>Introdução à Visualização de Dados</b></h2><p style="font-size:80%;color:#cc0000;">com Python</p>
★ Alerta importante: ao trabalhar com um Python notebook todas as células compartilham o mesmo espaço de execução.
Assim as variáveis de criadas e alteradas em uma célula são imediatamente acessíveis a todas as demais células. Independente da
ordem em que aparecem.
As células de código não são programas independentes e seus resultados persistem após cada execução. Como você pode
executar qualquer célula a qualquer momento a ideia execução sequencial do programa é aqui um pouco modificada.
x = np.random.randint(10) # gera um valor aleatório entre 0 e 100
# Você pode executar essa célula uma vez, mas ganhará um erro ao
executá-la novamente
print(x)
del x
2.1.3. Células de Texto

As células de texto são criadas em formato Markdown. Se você estiver empregando o Colab pode clicar duas vezes no texto
para editar uma célula e empregar barra de ferramentas para formatar o texto ou, se estiver mais familiarizado com a
notação Markdown, pode escrever diretamente a formatação.
2.1.3.1. Formatando Títulos
### **Título 3**

#### **Título 4**
##### **Título 5**
Produz:
2.1.4. Título 3
2.1.4.1. Título 4
2.1.4.1.1. Título 5
2.1.4.2. Formatando Textos
**bold**
*italic*
Produz:
bold
italic
2.1.4.3. Identação
‘>’ (ident) não suportado para edição de JupyterBooks, tire os comentários ``` para execução no Colab.
> indent 1
>> indent 2
2.1.4.4. Formatando Listas
* item
* item
* item
ou
1. item 1
2. item 2
3. item 3
Produz:
item
item
item ou
1. item 1
2. item 2
3. item 3
Você ainda pode editar textos em formato HTML ou LT

A
E
X e para saber mais você pode explorar a barra de ferramentas
do Colab ou consultar os tutoriais disponíveis do Colab.
2.1.5. Salvando e abrindo um Colab notebook

Seus Python notebooks podem ser salvos no seu Google Drive ou ainda no GitHub. Eu dou preferência por usar o GitHub e
lá você poderá acessar os códigos deste livro. Se empregar o Google Drive tenha em mente que as alterações do seu
notebook são salvas automaticamente enquanto você edita. Se você não tem familiaridade com esses ambientes
recomendo que você empregue a opção Arquivo > na barra de ferramentas para carregar e salvar seu notebooks em um
arquivo .ipynb.
Arquivo > Fazer download > Fazer download do .ipynb

Arquivo > Fazer upload de um notebook
2.1.6. Python notebook × IDE’s

O uso de Python notebooks é de fácil acesso, compartilha em um só documento código, texto e as saídas dos programas, e
facilita o trabalho colaborativo permitindo o compartilhamento de código na internet (Google Drive, GitHub). É uma
opção bastante aplicada para Ciência de Dados e vem sendo a opção preferencial para aplicações no ensino e, por isso,
empregamos ela aqui em todo o desenvolvimento do texto.
Projetos mais complexos, com vários programas e programas com centenas de linhas de código, podem entretanto exigir
o uso de ambientes integrados de desenvolvimento (IDE’s) como o PyCharm, Visual Code ou o Spyder para maior
produtividade. Note que scripts Python e Python notebooks são arquivos criados com extensões diferentes:
notebooks Python, extensão .ipynb

scripts Python, extensão .py
Caso você opte em explorar os códigos deste livro em um ambiente Python local recomendo a instalação do ambiente
Anaconda, um eco sistema profissional de desenvolvimento Python que inclui, além da linguagem Python ambientes para
edição de notebooks local e o IDE Spyder dentre outros pacotes, e você pode encontrar os links para download no final do
livro.
2.2. Python
Python é uma linguagem bastante poderosa e com muitos recursos. Nessa introdução de Python vamos apenas apresentar
um conjunto de recursos essenciais para que possamos prosseguir na visualização de dados com Python e você pode
consultar diversas fontes online e livros de introdução ao Python para saber mais sobe a linguagem.
2.2.1. Imports básicos

Os import de bibliotecas permite estender o Python adicionando as funcionalidades de uma biblioteca ou pacote Python.
Para nós os seguintes imports serão suficientes para a maior parte deste livro.
import pandas as pd # Pandas para acesso e

manipulação de dados
import numpy as np # NumPy para operações de vetores
e matrizes numéricas (arrays)
import matplotlib.pyplot as plt # Bibliotecas de gráficos e
visuallização de dados
import matplotlib as mpl
# import seaborn as sns
%matplotlib inline
2.2.2. Variáveis e Atribuições

O Python implementa tipos fracos, isto é, você não precisa declarar uma variável antes de empregá-la. Ele será criada e
seu tipo definido automaticamente na primeira atribuição a um rótulo (nome da variável).
inteiro = 123
real = np.pi
texto1 = '123'
texto2 = 'Led Zeppelin'
print(type(inteiro), inteiro)
print(type(real), real)
print(type(texto1), texto1)
<class 'int'> 123

<class 'float'> 3.141592653589793
<class 'str'> 123
<class 'str'> Led Zeppelin
2.2.3. Caracteres e Valores Numéricos

O Python implementa valores numéricos inteiros e de ponto flutuante com as operações básicas, e cadeias de caracteres
(strings).
inteiro = inteiro + 1
real = real + 1
texto1 = texto1 + '4'
texto2 = texto2 + ': Stairway to Heaven'
print(type(inteiro), inteiro)
print(type(real), real)
# edição de valores no estilo C com controles de linha e formatação

print(inteiro, '\n', '\t'*4 , texto2)
print('Valor real {:0.2f}'.format(real)) Print to PDF
<class 'int'> 124

<class 'float'> 4.141592653589793
<class 'str'> 1234
<class 'str'> Led Zeppelin: Stairway to Heaven
124
Led Zeppelin: Stairway to Heaven
Valor real 4.14
2.2.3.1. Integer, Float-point, Boolean
print(3 * 4, 3 + 4, 3 - 4, 3 / 4, 3.14, 4.2e-4 )

print(type(3 * 4), type(3.14), type(4.2e-4) )
print(3 ** 2, 3 // 4, 3 % 4 ) # potência,
divisão inteira e resto da divisão (mod)
print(4 > 3, 4 >= 3, 3 == 3.0, 3 != 4, 3 <= 4 )
print(1 < 2 < 9) # boolean
12 7 -1 0.75 3.14 0.00042

<class 'int'> <class 'float'> <class 'float'>
9 0 3
True True True True True
True
2.2.3.2. NumPy functions

As funções básicas estão disponíveis nativamente, mas para muitas funções matemáticas como funções trigonométricas,
randomização e constantes como o π e e é necessário recorrer a bibliotecas numéricas como o NumPy ou math e, em geral,
empregaremos o NumPy.
import numpy as np
print(np.pi) # pi
print(np.exp(1)) # e
print(5 % 2)
# o mesmo que
print(np.mod(5,2))
print(np.random.rand(1))
print(np.random.sample(10))
3.141592653589793
2.718281828459045
1
1
[0.63306932]
[0.39264834 0.8069128 0.54888492 0.37745742 0.67222565 0.76824892
0.16465848 0.40584095 0.13047434 0.60367705]
2.2.4. Strings
As strings em Python são como arrays de caracteres. Em Python elas são estruturas imutáveis, isto significa que você não
poderá atribuir um valor a uma posição específica de um array em uma string.
A indexação de slices de strings é feita do seguinte modo:
str[ inicio : tamanho ] ou str[ inicio : fim+1 ]
★ As strings iniciam são arrays que iniciam em 0. Em Python o limite superior indica um valor < do índice do
caracter que será exibido e não um índice ≤ como em outras linguagens como C ou Java.
print(texto2[0:7])
print('0123456789012'[0:7])
# e,
# texto2[1] = 'x'
# não funciona uma vez que uma string é imutável em Python
Led Zep
0123456
2.2.5. Operações com Strings

As operações com strings são implementadas como métodos da classe string. Empregue o comando help(str) para listar
os métodos da classe string, ou dir(var) para os métodos de uma variável. Não faremos grandes operações com strings
de dados aqui e os métodos essenciais que precisamos encontram-se abaixo.
str1 ='A arte existe porque a vida não basta. – Ferreira Gullar'
print(str1.find('arte'))
print(str1.lower())
str2 = str1.replace('arte','life')
print(str2)
2
a arte existe porque a vida não basta. – ferreira gullar
A life existe porque a vida não basta. – Ferreira Gullar
2.2.6. Print & Input

O comando input permite a entrada de dados pelo terminal mesmo na execução de Python notebooks. O print exibe a
saída de caracteres e emprega caracteres de controle como \n para salto de linha, \t para tab etc. bem como a formatação
de valores ao estilo da linguagem C.
# Print & Input...
# 'input' não suportado para edição de JupyterBooks, comente e tire os

comentários conforme indicado para execução no Colab
# text = input('Entre com um texto: ') # Tire o comentário aqui

text = 'Texto' # Comente aqui
print(type(text))
# numero = float(input('Entre com um número: ')) # Tire o comentário

aqui
numero = 2.25 # Comente aqui
print('Seu texto: ', text, '\n', 'Seu número: ', '%0.2f'%numero)
<class 'str'>
Seu texto: Texto
Seu número: 2.25
2.2.7. Controles de Fluxo nos Programa
2.2.8. If-Then-Else
Em Python as instruções aninhadas são identadas (tab), o que corresponde ao {} de linguagens como Java e C. Assim,
instruções aninhadas à condição ou laço do programa devem estar à direita da instrução inicial da condição ou laço.
Condição 1 ...
Instrução 1.1 ...
Instrução 2.1 ...
Condição 2 ...
Instrução 2.1 ...
Instrução 3.1...
Instrução N
Instrução 3.1 executará dentro da condição 1, mas fora da condição 2.
a = 1964
b = 1984
if b > a:
print("b is greater than a")
else:
print("a is greater than b")
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
b is greater than a
b is greater than a
★ Fique atento a identação do seu código. Em Python é ela que faz o aninhamento de instruções de código, tendo
assim o mesmo papel dos { } que empregamos em Java ou C.
2.2.9. For & While

For e While empregados para implementar loops ou laços nos programas. Neste livro na maior parte dos casos
empregaremos o for para criar laços de programa. O comando range(inicio, fim, incremento) pode ser empregado
para definir os limites e o incremento de uma variável em um laço do tipo for. Do mesmo modo que na indexação de
strings o limite indicado é um limite superior (< e não ≤ ) e, portanto, o último valor que nunca é atingido.
for i in range(5):
print(i)
if i == 3:
break
0
1
2
3
i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1
1
2
3
As iterações também podem ser feitas sobre listas de valores, numéricos ou não.
for i in [12,18,84]:
print(i)
for nome in ['Adriana','Daniel','Henrique']:

print(nome)
12
18
84
Adriana
Daniel
Henrique
2.2.10. Funções
Funções em Python são definidas com a instrução def. As variáveis de uma função tem escopo local, mas as funções
podem também acessar variáveis globais do seu programa.
def mymax(a,b):
if a > b:
return a
else:
return b
mymax(1984,1964)
1984
2.2.11. Coleções de Dados Básicas

Coleções de dados como Lists, Sets, Tuples e Dictionary desempenham um papel importante tanto para a programação
em geral como para aplicações de análise de dados.
O Python implementa quatro tipos básicos de coleções de dados:
Lista (list( ), [ ]) é uma coleção que é ordenada e mutável podendo ter membros duplicados.
Tupla (tuple( ), ( )) é uma coleção que é ordenada e imutável podendo ter membros duplicados.
Conjunto (set( ), { }) é uma coleção não ordenada e não indexada que não permite membros duplicados.
Dicionário (dict( ), {'key':value} ) é uma coleção desordenada de itens, mutável e indexada, e que não permite
membros duplicados.
Vamos nos deter apenas nas estruturas de listas e dicionários que terão mais utilidade aqui.
2.2.11.1. List
Lista (list) é uma coleção que é ordenada e mutável, e permite haver membros duplicados. Associado a listas você
encontra uma série métodos úteis para esses objetos como adição, busca e remoção de elementos.
mylist = ['A', 'B', 'C', 'A', 'B']
'''
Empregue...
> help(mylist)
para ver todos os métodos associados a listas
Help on list object:

| class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
'''
'\nEmpregue...\n> help(mylist) \npara ver todos os métodos

associados a listas\n\nHelp on list object:\n | class list(object)\n
| list(iterable=(), /)\n | \n | Built-in mutable sequence.\n |
\n | If no argument is given, the constructor creates a new empty
list.\n | The argument must be an iterable if specified.\n | \n |
Methods defined here:\n | \n | __add__(self, value, /)\n |
Return self+value.\n | \n | __contains__(self, key, /)\n |
Return key in self.\n \n'
# Métodos comuns associados a listas

len(mylist) # tamanho
print(mylist.count('B')) # quantos 'B's

print(mylist.index('B')) # índice do primeiro 'B'
print(mylist.index('B', 2)) # índice do primeiro 'B' a partir do
índice 2
mylist.append('D')
print(mylist, 'depois de inserir D')
mylist.sort()
print(mylist, 'depois de ordenar a lista')
mylist[1] = 'ZZ'
print(mylist, 'depois de alterar o elementos de índice 1')
print('A' in mylist)
if 'A' in mylist:
print('Sim, A está na lista')
2
1
4
['A', 'B', 'C', 'A', 'B', 'D'] depois de inserir D
['A', 'A', 'B', 'B', 'C', 'D'] depois de ordenar a lista
['A', 'ZZ', 'B', 'B', 'C', 'D'] depois de alterar o elementos de
índice 1
True
Sim, A está na lista
Listas podem conter quaisquer tipos de elementos, incluindo outras listas, e podem ser empregadas para implementar
arrays numéricos em Python. Entretanto, para operações eficientes sobre arrays numéricos será preferível empregar
arrays do pacote NumPy.
★ Para operações eficientes sobre arrays numéricos é preferível empregar arrays do pacote NumPy.
# Arrays numéricos
mylist = [[1,2,3], [11,22,33], [9,9,9]]
print(mylist[1]) # [11,22,33]
print(mylist[1][0]) # 11
# Arrays de quaisquer tipos de dados

print([ [1,2,3], ['Adriana','Daniel','Henrique'], 3, 'Anna', 2.5 ])
[11, 22, 33]

11
[[1, 2, 3], ['Adriana', 'Daniel', 'Henrique'], 3, 'Anna', 2.5]
2.2.11.2. Percorrendo listas

Percorrer listas é uma operação que empregaremos bastante. Existem basicamente duas forma de percorrer uma lista.
Por índice, empregamos essa forma quando precisamos do índice (posição) ou precisamos alterar os elementos da
lista
Por iterador, empregamos essa forma quando desejamos apenas recuperar (ler) os elementos. Ela não permite
alterar os elementos enquanto percorremos a lista
A segunda forma é um modo elegante que o Python implementa e você não encontrará esse modo em linguagens como C
ou Java. Se não for necessário alterar os elementos ou obter o índice ao percorrer a lista esta será a melhor forma a ser
empregada.
mylist = ['A', 'B', 'C', 'A', 'B']
for i in range(len(mylist)): # empregue esse modo para obter o

índice ou alterar os elementos ao percorrer a lista
print(i, mylist[i])
for item in mylist: # prefira esse modo se não precisar do

índice ou alterar os elementos ao percorrer a lista
print(item)
0 A
1 B
2 C
3 A
4 B
A
B
C
A
B
Também é útil entendermos como popular uma lista com o método append().
mylist = [] # cria a
lista vazia
for elem in ['Beatriz', 'Henrique', 'Adriana', 'Daniel']:

mylist.append(elem) #
adiciona um elemento no final da lista
print(mylist)
['Beatriz', 'Henrique', 'Adriana', 'Daniel']
2.2.11.3. Dictionary
Dicionários (dictionary) são uma coleção desordenada, mutável e indexada em formato de chave: valor. Elas não
aceitam elementos duplicados (chaves), e se você já teve contato com uma estrutura de dados do tipo JSON essa é uma
estrutura bastante semelhante em Python. A principal vantagem dos dicionários é permitir recuperar os valores
diretamente a partir do valor da chave.
aniversarios = {'Beatriz':1978, 'Henrique':2004, 'Adriana':1984,

'Daniel':1996}
print(aniversarios.keys())
print(aniversarios['Adriana'])
dict_keys(['Beatriz', 'Henrique', 'Adriana', 'Daniel'])

1984
Assim como nas listas, os dicionários suportam quaiquer tipos de dados no campo valor, incluindo listas e outros
dicionários.
contatos = { 'Adriana': { 'aniversario': 1984, 'telefone': '6767-6868'

, 'amigos': {'Henrique':2004, 'Anna':1988} } }
print(contatos.keys())
print(contatos['Adriana'])
print(contatos['Adriana']['amigos'])
dict_keys(['Adriana'])
{'aniversario': 1984, 'telefone': '6767-6868', 'amigos':
{'Henrique': 2004, 'Anna': 1988}}
{'Henrique': 2004, 'Anna': 1988}
2.2.11.4. Percorrendo um Dicionário

Podemos percorrer os elementos de um dicionário de diversas formas que combinam percorrer as chaves, os valores ou
ambos:
for key, item in aniversarios.items():

print(key, item)
# ou
for item in aniversarios:
print(item, aniversarios[item])
# ou
for key in aniversarios.keys():
print(key)
# ou
for item in aniversarios.values():
print(item)
Beatriz 1978
Henrique 2004
Adriana 1984
Daniel 1996
Beatriz 1978
Henrique 2004
Adriana 1984
Daniel 1996
Beatriz
Henrique
Adriana
Daniel
1978
2004
1984
1996
2.2.11.5. Populando um Dicionário

Diferente das listas os dicionários não têm um método próprio para adição de uma chave ou valor, e basta fazer uma
atribuição ao dicionário.
lista_nomes = [ 'Carolina', 'Henrique' ]

lista_niver = [ 2001, 2005 ]
mydict = {}
for i in range(len(lista_nomes)):
if lista_nomes[i] not in mydict.keys(): # Se não está no dicionário
acrescenta
mydict[lista_nomes[i]] = lista_niver[i]
if 'Kate' not in mydict.keys(): # Se não está no dicionário

acrescenta
mydict['kate'] = 2002
print(mydict)
{'Carolina': 2001, 'Henrique': 2005, 'kate': 2002}
★ Note que [ ] é o construtor de uma lista, e o mesmo que list(), enquanto { } é o construtor de um dicionário, o
o mesmo que dict(). Ambos, entretanto, têm os elementos referenciados empregando [ ].
2.2.11.6. File Handling

Operações com arquivos tipo texto terão pouco uso aqui. Na maior parte dos casos obtemos dados de tabelas e bases de
dados em DataFrames Pandas. De qualquer modo isso pode ser útil para você em algum caso e um exemplo simples de
gravação e leitura deve bastar.
note = ['This is a note']
f = open("note.txt", "w")
for line in note:
f.write(line)
f.close()
f = open("note.txt", "r")
for line in f:
print(line)
This is a note
Para acesso a arquivos tipo texto via internet, que não estão locais em um diretório da sua máquina ou ambiente virtual
como o Colab, você pode empregar a classe urllib.request ou, se tiver familiaridade com comando Linux, o comando
!wget para fazer o download do arquivo e empregá-lo local como fizemos acima.
import urllib.request
data =
urllib.request.urlopen('https://raw.githubusercontent.com/Rogerio-
mack/Visualizacao-de-Dados-em-Python/main/data/PlayBallcsv.csv')
for line in data:

print(line.decode('utf-8'))
break
Day,Outlook,Temperature,Humidity,Wind,Play ball
2.3. NumPy
O NumPy é um pacote para computação científica em Python que dá suporte para arrays e matrizes multidimensionais e faz
operações e funções matemáticas de modo eficiente.
Na maior parte dos casos empregaremos as funções matemáticas do NumPy como operações para manipulação de
matrizes e vetores, funções trigonométricas, estatísticas e de randomização. O Pandas, pacote de manipulação de dados
que empregamos, é construído sobre o NumPy.
Teremos necessidade aqui de entender apenas algumas poucas classes de NumPy e, assim, um pequeno conjunto de
exemplos será suficiente para nossos propósitos.
2.3.1. Criando arrays

Os arrays podem ser de uma ou mais dimensões mas, diferentemente das listas, e como matrizes numéricas, todos
elementos devem ter o mesmo tamanho e tipo. Eles também são indexados iniciando por 0 e seguem as mesmas regras de
indexação de listas e strings, isto é, o limite superior indica o limite < do range de valores a ser selecionado.
import numpy as np
array1D = np.array([1,2,3])
array2D = np.array([[1,2,3,4],[11,12,13,14],[21,22,23,24]])
print(array1D.ndim, array2D.ndim) # dimensões

print(array1D.shape, array2D.shape) # tamanho de cada dimensão
print(array1D)
print(array2D)
print(array1D[1])
print(array2D[1:3])
print(array2D[1][3])
1 2
(3,) (3, 4)
[1 2 3]
[[ 1 2 3 4]
[11 12 13 14]
[21 22 23 24]]
2
[[11 12 13 14]
[21 22 23 24]]
14
Os arrays NumPy operam como listas indexadas e você pode empregar as mesmas formas de índices e iteração que
empregamos em listas para percorrer arrays NumPy.
for i in range(array1D.shape[0]):
print(i, array1D[i])
for i in range(array2D.shape[0]): # percorre as linhas

for j in range(array2D.shape[1]): # percorre as colunas
print(i, j, array2D[i,j])
for elem in array1D:

print(elem)
for linha in array2D: # percorre as linhas

for coluna in linha: # percorre as colunas
print(coluna)
0 1
1 2
2 3
0 0 1
0 1 2
0 2 3
0 3 4
1 0 11
1 1 12
1 2 13
1 3 14
2 0 21
2 1 22
2 2 23
2 3 24
1
2
3
1
2
3
4
11
12
13
14
21
22
23
24
2.3.2. Operações sobre arrays NumPy

Um dos recursos mais úteis do NumPy que não encontramos em arrays de outras linguagens como C e Java é que diversas
operações podem ser executadas diretamente sobre toda a coleção de dados sem a necessidade de implementar
iterações ou laços de programa.
x = np.array([1,2,3])
print( np.mean(x), np.sum(x), np.power(x,2) )
print( 2*x, x+x, x**2 + 2*x + 1, np.log(x) )
2.0 6 [1 4 9]
[2 4 6] [2 4 6] [ 4 9 16] [0. 0.69314718 1.09861229]
2.3.3. Outras Operações Úteis

Finalmente, abaixo, algumas operações de conversão, randomização e criação de sequencias de valores serão muito úteis
e empregadas ao longo de todo o livro.
x = np.array([1,2,3])
x_list = x.tolist() # convertendo um NumPy array para uma lista

`Python`
print(x, x_list)
np.random.seed(1984) # semente de
geração aleatória
print( np.random.randint(low=1, high=6, size=10) ) # gerando
inteiros aleatórios
print( np.random.rand(4) ) # gerando
valores aleatórios entre [0,1]
print( np.random.sample(5) ) # gerando um
sample de dados aleatórios
print( np.arange( 10, 20, 2) ) # gerando uma lista de valores no

intervalo [10,20[ com incrementos de 2
print( np.linspace( 10, 20, 50) ) # gerando uma lista de valores de

50 valores no intervalo [10,20[
[1 2 3] [1, 2, 3]
[5 4 2 1 1 3 3 2 3 1]
[0.99873856 0.89441845 0.26139183 0.73330439]
[0.14629798 0.17234917 0.61481704 0.59564882 0.68232631]
[10 12 14 16 18]
[10. 10.20408163 10.40816327 10.6122449 10.81632653
11.02040816
11.2244898 11.42857143 11.63265306 11.83673469 12.04081633
12.24489796
12.44897959 12.65306122 12.85714286 13.06122449 13.26530612
13.46938776
13.67346939 13.87755102 14.08163265 14.28571429 14.48979592
14.69387755
14.89795918 15.10204082 15.30612245 15.51020408 15.71428571
15.91836735
16.12244898 16.32653061 16.53061224 16.73469388 16.93877551
17.14285714
17.34693878 17.55102041 17.75510204 17.95918367 18.16326531
18.36734694
18.57142857 18.7755102 18.97959184 19.18367347 19.3877551
19.59183673
19.79591837 20. ]
2.4. Pandas
O Pandas é um pacote Python para manipulação e análise de dados orientada a colunas. Ela organiza os dados em dois
tipos de estruturas, Séries e DataFrames e opera seleções e transformações sobre essas coleções de dados.
DataFrame: você pode imaginar como uma tabela de dados relacionais, com linhas e colunas nomeadas, como no
Excel ou em SQL.
Series: é uma única coluna de dados, e o DataFrame contém um ou mais Series com um nome para cada uma delas.
O DataFrame, implementado em Python, é uma abstração comumente usada para manipulação de dados que tem origem
na linguagem R, mas você encontrará implementações similares também em outras linguagens.
2.4.1. Import da biblioteca

import pandas as pd
import numpy as np
2.4.2. Criando um pd.Series e um pd.DataFrame

Uma pd.Series pode ser criada a partir de uma lista e um pd.Dataframe pode ser criado empregando-se uma estrutura de
dicionário.
# Séries
student_names = pd.Series(['Adriana', 'Carol', 'Daniel'])
age = pd.Series([18, 19, 19])
# DataFrame
students = pd.DataFrame({ 'Student Name': student_names, 'Age': age })
students
Student Name Age
0 Adriana 18
1 Carol 19
2 Daniel 19
2.4.3. Lendo um DataFrame

O uso mais comum do Pandas que faremos é para o acesso a arquivos e bases de dados e o Pandas permite ler e gravar
dados de diferetes fontes como arquivos .csv, .json, .xlsx e arquivos de bancos de dados sql, Mongo etc.
Format Read Save
csv pd.read_csv() df.to_csv()
json pd.read_json() df.to_json()
xlsx pd.read_excel() df.to_excel()
hdf pd.read_hdf() df.to_hdf()
sql pd.read_sql() df.to_sql()
que podem ser acessados local ou pela internet.
tips = pd.read_csv('https://raw.githubusercontent.com/Rogerio-
mack/Visualizacao-de-Dados-em-Python/main/data/tips.csv')
tips.head()
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
O comando df.head() permite exibir o aspecto inicial dos dados a partir de suas primeiras linhas.
2.4.4. Explorando a estrutura básica dos dados

Antes de explorarmos o conteúdo dos dados é útil termos algumas informações sobre a estrutura dos dados que estamos
lidando como os valores que assumem os dados, quantas linhas temos em uma tabela, o número de atributos, o tipo de
dados etc.
tips.shape # nr de linhas e colunas
(244, 7)
len(tips) # número de linhas
244
tips.columns.to_list() # ou tips.columns
['total_bill', 'tip', 'sex', 'smoker', 'day', 'time', 'size']
tips.dtypes # tipo dos atributos
total_bill float64
tip float64
sex object
smoker object
day object
time object
size int64
dtype: object
O comando describe() exibe informações estatísticas sumarizadas dos dados.
tips.describe(include='all')
total_bill tip sex smoker day time
count 244.000000 244.000000 244 244 244 244 244.
unique NaN NaN 2 2 4 2
top NaN NaN Male No Sat Dinner
freq NaN NaN 157 151 87 176
mean 19.785943 2.998279 NaN NaN NaN NaN 2.
std 8.902412 1.383638 NaN NaN NaN NaN 0.
min 3.070000 1.000000 NaN NaN NaN NaN 1.
25% 13.347500 2.000000 NaN NaN NaN NaN 2.
50% 17.795000 2.900000 NaN NaN NaN NaN 2.
75% 24.127500 3.562500 NaN NaN NaN NaN 3.
max 50.810000 10.000000 NaN NaN NaN NaN 6.
2.4.5. Selecionando Dados

Seleções dos dados são bastante importantes. Você nem sempre estará interessado em exibir ou analisar todos os dados.
Por exemplo, você pode ter dados de produção de várias unidades de uma fábrica, mas estar interessado somente em
dados das unidades de São Paulo (seleção de linhas ou casos). Ou, você pode ter dados de vendas com diversas
informações dos produtos (cor, modelo etc.) e dos clientes (nome, CPF etc.) e querer apenas dados de peso e dimensões
do produto, e da origem e destino da compra para analisar os preços de frete (seleção de colunas ou atributos). Mais
frequentemente ainda você vai realizar as duas seleções criando slices dos dados.
2.4.6. Seleção de Colunas, Seleção de Linhas e de Linhas e

Colunas
2.4.7. Selecionando colunas de dados como pd.Series

Como vimos, as colunas de um DataFrame são séries do Pandas e podemos selecionar e operar com cada uma das séries de
um DataFrame. Existem dois modos de seleção
df.<nome do atributo>
df['<nome do atributo>']
eles retornam o mesmo resultado e a segunda forma é sempre necessária quando temos nomes de atributos com espaços
ou caracteres especiais.
print(tips.tip)
# ou
# print(tips['tip'])
0 1.01
1 1.66
2 3.50
3 3.31
4 3.61
...
239 5.92
240 2.00
241 2.00
242 1.75
243 3.00
Name: tip, Length: 244, dtype: float64
Esse conjunto de dados é um pd.Series e podemos fazer uma série de operações sobre essa coleção de dados, como
calcular a soma ou a média de valores.
tip_series = tips['tip']
print(f'Média das gorjetas: USD {tip_series.mean() :.2f} e Total das
gorjetas: USD {tip_series.sum() :.2f}')
Média das gorjetas: USD 3.00 e Total das gorjetas: USD 731.58
Pode ser útil também você transformar uma pd.Series em uma lista Python para que você possa realizar as operações de
listas que você já conhece.
dias = tips.day
dias = dias.to_list()
dias.count('Sat')
87
2.4.8. Selecionando uma ou Mais Colunas como pd.DataFrame
Mas você pode estar interessado na seleção de mais que uma coluna de dados. Para isso você pode simplesmente informar
para o Pandas uma lista de atributos a serem selecionados.
df [ [ <lista-de-colunas> ] ]
Diferentemente da seleção anterior que retorna um Série do Pandas, a seleção desse modo, com uma ou mais colunas
informadas em uma lista, retorna um DataFrame.
A seleção como DataFrame permite a seleção de várias séries de dados (atributos) para construírmos subconjuntos de
dados de interesse. Essas seleções de dados também são DataFrame e todas as operações de DataFrame são aplicáveis.
tips.columns
Index(['total_bill', 'tip', 'sex', 'smoker', 'day', 'time', 'size'],

dtype='object')
selected_tips = tips[['total_bill', 'tip', 'size']]
selected_tips.head() # um novo dataframe com atributos selecionados
total_bill tip size
0 16.99 1.01 2
1 10.34 1.66 3
2 21.01 3.50 3
3 23.68 3.31 2
4 24.59 3.61 4
★ A seleção com uma ou mais colunas informadas em uma lista, retorna um DataFrame. Note que df['tip']
retorna um pd.Series, enquanto, selecionar df[['tip']] retorna um pd.DataFrame de uma única coluna.
De modo geral, você pode empreguar a seleção de pd.Series para selecionar um único atributo, e empregar a seleção
pd.DataFrame quando estiver interessado na criação de subconjuntos de dados.
2.4.9. Selecionando Maiores e Menores

Veremos mais adiante como fazer seleção de linhas, mas aqui é oportuno vermos como selecionar linhas que contenham
os maiores e os menores valores da coleção.
tips.nsmallest(5,'total_bill')
67 3.07 1.00 Female Yes Sat Dinner 1
92 5.75 1.00 Female Yes Fri Dinner 2
111 7.25 1.00 Female No Sat Dinner 1
172 7.25 5.15 Male Yes Sun Dinner 2
149 7.51 2.00 Male No Thur Lunch 2
tips_top3 = tips.nlargest(3,'total_bill')
tips_top3
170 50.81 10.00 Male Yes Sat Dinner 3
212 48.33 9.00 Male No Sat Dinner 4
59 48.27 6.73 Male No Sat Dinner 4
2.4.10. Alterando e Incluindo Colunas de Dados

Muitas vezes é necessário você criar atributos derivados a partir dos dados originais, como converter os valores para R$ ,
criar um atributo com o valor das contas descontado a gorjeta ou o valor da conta divido pelos participantes da mesa.
Essa é uma grande facilidade do Pandas que, a exemplo do NumPy, permite fazer essas operações com um único comando
sobre toda uma coleção de dados sem a necessidade de laços de programa.
dolar_real_rate = 5.8
tips['total_bill'] = tips['total_bill'] * dolar_real_rate #
alterando
tips['tip'] = tips['tip'] * dolar_real_rate #
alterando
tips['total_bill_minus_tips'] = tips['total_bill'] - tips['tip'] #

incluindo um novo atributo
tips['bill_by_head'] = tips['total_bill'] / tips['size'] #
incluindo um novo atributo
tips.head()
total_bill tip sex smoker day time size total_bill_m
2.4.11. Selecionar Linhas
A seleção de linhas é mais interessante por que podemos especificar condições para os valores que buscamos. Por
exemplo, você pode selecionar o tipo de peças que deseja ver em um DataFrame com dados de vários componentes, ou
selecionar a as unidades de fábrica de uma certa cidade que você tem os dados de produção.
O critério de seleção é um predicado lógico e você deve empregar a seguinte sintaxe:
df [ <critério de seleção> ]
Exemplos
df [ nome_coluna == valor ]
df [ nome_coluna != valor ]
df [ nome_coluna > valor ]
Assim, podemos selecionar os dados somente dos não fumantes ou não fumantes:
tips_nao_fumantes = tips[ tips.smoker == 'No' ]

tips_fumantes = tips[ tips.smoker == 'Yes' ]
E podemos com isso já responder algumas questões interessantes que envolvem a proporção dos dados de fumantes e
não fumantes.
print(f'Percentual de Clientes Fumantes {len( tips_fumantes ) / len(

tips ) :.2f} %')
Percentual de Clientes Fumantes 0.38 %
2.4.12. Seleção de Linhas e Colunas
O uso mais geral das seleções é quando fazemos seleções de linhas e colunas dos dados, e às vezes nos referimos a esse
subconjunto dos dados de slice (fatia) dos dados.
A boa prática indica que sempre faremos primeiro a seleção das linhas,
df [ <critério de seleção> ] ...
...Selecionando uma coluna

df [ <critério de seleção> ].nome_coluna pd.Series
df [ <critério de seleção> ]['nome_coluna']
...Selecionando uma ou mais colunas

df [ <critério de seleção> ][ [<lista-de-colunas>] ] pd.DataFrame
Com isso podemos fazer inúmeras seleções de dados que temos interesse em visualizar ou analisar, e responder a muitas
perguntas sobre os dados.
Fumantes ou Mulheres, pagam mais gorjeta (em média) ?
tips[ tips.smoker == 'Yes' ]['tip'].mean() > tips[ tips.smoker == 'No'

]['tip'].mean()
True
tips[ tips.sex == 'Female' ]['tip'].mean() > tips[ tips.sex == 'Male'

]['tip'].mean()
False
As selecões de subconjuntos de dados, com veremos, tem uma papel importante na construção de visualizações e
entendimento dos dados pois, muitas vezes, estamos interessados em comparar diferentes classes ou subconjuntos
dados, como no exemplo abaixo em que observamos os valores das gorjetas de homens e mulheres.
import matplotlib.pyplot as plt

plt.hist(tips[ tips.sex == 'Male' ]['tip'], label='Homens')
plt.hist(tips[ tips.sex == 'Female' ]['tip'], label='Mulheres')
plt.xlabel('Valor das Gorjetas')

plt.ylabel('Quantidades Pagas')
plt.title('Distribuição das Gorjetas', fontsize=14, weight='bold')
plt.legend(title='$\\bf{Gorjetas}$')
plt.show()
O Pandas ainda conta com uma série de operações para manipulação e transformação dos dados como funções de joins e
merge de tabelas, groupby etc. empregaremos eventualmente essas operações ao longo do texto e para maiores detalhes
você poderá consultar a documentação do Pandas ou outras referências online.
By Rogério de Oliveira
© Copyright 2020.

Básico: Colab, Python, Numpy E Pandas: 2.1. Ambiente Google Colaboratory Ou

Enviado por

Direitos autorais:

Formatos disponíveis

Básico: Colab, Python, Numpy E Pandas: 2.1. Ambiente Google Colaboratory Ou

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Básico: Colab, Python, Numpy E Pandas: 2.1. Ambiente Google Colaboratory Ou

Enviado por

Direitos autorais:

Formatos disponíveis

08/05/24, 10:31 2.

2. Básico: Colab, Python, NumPy e Pandas

2.1. Ambiente Google Colaboratory ou Colab

2.1.1. Python Notebooks

2.1.2. Células de Código

# 'input' não suportado para edição de JupyterBooks, comente e tire os

# n = int( input('Entre com um número inteiro: ') ) # Tire o

x = np.random.randint(10) # gera um valor aleatório entre 0 e 100

2.1.3. Células de Texto

2.1.3.1. Formatando Títulos

### **Título 3**

2.1.4.2. Formatando Textos

2.1.4.4. Formatando Listas

Você ainda pode editar textos em formato HTML ou LT

do Colab ou consultar os tutoriais disponíveis do Colab.

2.1.5. Salvando e abrindo um Colab notebook

Arquivo > Fazer download > Fazer download do .ipynb

2.1.6. Python notebook × IDE’s

notebooks Python, extensão .ipynb

2.2.1. Imports básicos

import pandas as pd # Pandas para acesso e

2.2.2. Variáveis e Atribuições

<class 'int'> 123

2.2.3. Caracteres e Valores Numéricos

# edição de valores no estilo C com controles de linha e formatação

<class 'int'> 124

2.2.3.1. Integer, Float-point, Boolean

print(3 * 4, 3 + 4, 3 - 4, 3 / 4, 3.14, 4.2e-4 )

12 7 -1 0.75 3.14 0.00042

2.2.3.2. NumPy functions

A indexação de slices de strings é feita do seguinte modo:

str[ inicio : tamanho ] ou str[ inicio : fim+1 ]

2.2.5. Operações com Strings

2.2.6. Print & Input

# Print & Input...

# 'input' não suportado para edição de JupyterBooks, comente e tire os

# text = input('Entre com um texto: ') # Tire o comentário aqui

# numero = float(input('Entre com um número: ')) # Tire o comentário

print('Seu texto: ', text, '\n', 'Seu número: ', '%0.2f'%numero)

2.2.7. Controles de Fluxo nos Programa

Instrução 3.1 executará dentro da condição 1, mas fora da condição 2.

2.2.9. For & While

for nome in ['Adriana','Daniel','Henrique']:

2.2.11. Coleções de Dados Básicas

O Python implementa quatro tipos básicos de coleções de dados:

mylist = ['A', 'B', 'C', 'A', 'B']

Help on list object:

'\nEmpregue...\n> help(mylist) \npara ver todos os métodos

# Métodos comuns associados a listas

print(mylist.count('B')) # quantos 'B's

# Arrays de quaisquer tipos de dados

[11, 22, 33]

2.2.11.2. Percorrendo listas

mylist = ['A', 'B', 'C', 'A', 'B']

for i in range(len(mylist)): # empregue esse modo para obter o

for item in mylist: # prefira esse modo se não precisar do

for elem in ['Beatriz', 'Henrique', 'Adriana', 'Daniel']:

['Beatriz', 'Henrique', 'Adriana', 'Daniel']

aniversarios = {'Beatriz':1978, 'Henrique':2004, 'Adriana':1984,

### Título 3