Introdução ao Python 3.6 II

Prévia do material em texto

Introdução ao Python 3.6
March 11, 2018
1 Aula de introdução ao Python 3.6.1 II
1.1 Numpy
Numpy é um biblioteca do Python que nos permite trabalhar com vetores, matrizes e tensores
de forma geral (arrays) de forma mais eficiente que as ferramentas nativas da linguagem que usa
listas.
In [15]: #importando biblioteca
import numpy as np
Criando um array usando a biblioteca Numpy
In [16]: #Criando lista e a convertendo para o formato "Numpy array"
x=np.array([1,2])
print(x)
type(x)
[1 2]
Out[16]: numpy.ndarray
Quando trabalhamos com vetores e matrizes no Python com funções nativas, usamos o con-
ceito de listas e isso significa que o processo por trás é diferente do caso em usamos o conceito de
array do pacote Numpy, por exemplo. Geralmente, quando optamos por trabalhar com arrays ao
invés de listas, os processos ficam mais rápidos:
In [17]: #comparando
lista =[1,2,3,4,5,6,7,8,9]
array=np.arange(10) # função arange(Limite_inferior,Limite_Superior,passo),
# funciona iqual o range normal do python
print("Lista: ",lista)
#tempo de execução do comando
quadradoL=None
%timeit quadradoL = [el**2 for el in lista] #elevar todos elementos ao quadrado
1
Lista: [1, 2, 3, 4, 5, 6, 7, 8, 9]
3.86 µs ± 117 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [18]: print("Array: ",array)
#tempo de execução do comando
quadradoA=None
%timeit quadradoA = array**2 #elevar todos elementos ao quadrado
Array: [0 1 2 3 4 5 6 7 8 9]
776 ns ± 45.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
A diferença pode parecer pequena, mas quando passamos a trabalhar com processos mais
complexos, essa diferença passa a crescer exponencialmente. Por conta comodidade (tempo de
execução e funções) de se trabalhar com o pacote Numpy, vamos usá-lo daqui para frente. Agora
iremos conhecer alguns métodos do pacote para podermos utilizá-lo da melhor maneira.
Primeiramente, vamos aprender a inicializar um array de diversas maneiras com as funções do
Numpy:
In [22]: #inicializando um array
#array unidimencional (vetor)
arrayU=np.array([1,2,3])
print("Array unidimencional: ")
print(arrayU,'\n')
#array bidimencional(matriz)
arrayB=np.array([[1,2,3],[4,5,6],[7,8,9]])
print("Array Bidimencional(matriz): ")
print(arrayB,'\n')
Array unidimencional:
[1 2 3]
Array Bidimencional(matriz):
[[1 2 3]
[4 5 6]
[7 8 9]]
Podemos criar arrays apenas com zeros com o método np.zeros(). Mo argumento do método
colocamos o formato que o array assumirá:
In [23]: #podemos criar um array apenas com zeros
arrayZeros = np.zeros(3)
print("Array de zeros: ",arrayZeros)
#Automaticamente, a função faz com que os números sejam do tipo float
type(arrayZeros[0])
2
Array de zeros: [ 0. 0. 0.]
Out[23]: numpy.float64
In [24]: #basta fazer o seguinte para mudar o tipo da variável
arrayZeros = np.zeros(3,dtype=int)
print("Array de zeros Inteiros: ",arrayZeros)
Array de zeros Inteiros: [0 0 0]
Podemos criar também arrays de números 1 com o método np.ones() e arrays vazios com o
método np.empty():
In [25]: #Array de 1s
arrayOne = np.ones([3,2])
print("array de 1: ")
print(arrayOne)
array de 1:
[[ 1. 1.]
[ 1. 1.]
[ 1. 1.]]
In [26]: #Array vazio
arrayEmpty= np.empty(3) #inicializa com o endereço de memória da variável
print("array vazio: ")
print(arrayEmpty)
array vazio:
[ 0. 0. 0.]
Podemos criar uma matriz identidade facilmente com np.identity() ou np.eye():
In [27]: #Matriz identidade
MatrizIdentidade = np.eye(2) # argumento vai quantidade de 1 que queremos
print(MatrizIdentidade)
[[ 1. 0.]
[ 0. 1.]]
Podemos também criar uma matriz diagonal com o método np.diag:
In [28]: MatrizDiag= np.diag([1,2,3,4])
print("Matriz Diagonal:")
print(MatrizDiag)
3
Matriz Diagonal:
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
Outro comando interessante é o np.linspace(). Com ele nós podemos definir pontos de corte
equidistantes em um intervalo númerica, podendo escolher em quantas vezes queremos dividí-lo.
O Numpy retorna um array com os pontos de corte:
In [29]: #criando intervalo (dividino [0,1] em 5 pontos)
arrayIntervalo = np.linspace(0,1,5)
print("Array Intervalo: ",arrayIntervalo)
Array Intervalo: [ 0. 0.25 0.5 0.75 1. ]
Podemos também modificar um array já criado mudando seu formato (shape) como for
necessário. Usar método np.shape():
In [30]: #criando um array normal
arrayShape = np.array([1,2,3,4])
print("Array com formato inicial: ",arrayShape)
print("Dimensões do array: ",arrayShape.shape)
Array com formato inicial: [1 2 3 4]
Dimensões do array: (4,)
In [31]: #modificando
arrayShape.shape =(2,2)
print("Array modificado: ")
print(arrayShape)
print("Dimensões do array: ",arrayShape.shape)
Array modificado:
[[1 2]
[3 4]]
Dimensões do array: (2, 2)
In [32]: #modificando
arrayShape.shape =(4,1)
print("Array modificado: ")
print(arrayShape)
print("Dimensões do array: ",arrayShape.shape)
4
Array modificado:
[[1]
[2]
[3]
[4]]
Dimensões do array: (4, 1)
É possível também realizar cortes de diversas maneiras no array unidimensional. Agora estu-
daremos como fazer isso:
In [33]: #vamos criar array
arrayCortes = np.arange(1,10)
#podemos printar o array inteiro com [:]
print("Array inicial: ",arrayCortes[:])
#podemos printar o array ao contrário com [::-1]
print("Array ao contrario: ",arrayCortes[::-1])
#podemos cortar do meio pra frente
print("Array do meio pra frente: ",arrayCortes[5:])
#podemos criar um espaço pra cortar e o intervalo de cada corte
print("Array cortado compassado ",arrayCortes[2:7:2]) # no espaço entre os index 2 e 7,
#pega de 2 em 2 números
Array inicial: [1 2 3 4 5 6 7 8 9]
Array ao contrario: [9 8 7 6 5 4 3 2 1]
Array do meio pra frente: [6 7 8 9]
Array cortado compassado [3 5 7]
O mesmo vale para matrizes:
In [34]: #criando matriz bidimencional
arrayCortes.shape= (3,3)
print("Matriz inicial: ")
print(arrayCortes)
Matriz inicial:
[[1 2 3]
[4 5 6]
[7 8 9]]
In [35]: #podemos imprimir só uma coluna específica
print("Matriz Coluna: ")
print(arrayCortes[:,1])
5
Matriz Coluna:
[2 5 8]
In [36]: #ou uma linha específica
print("Matriz Linha: ")
print(arrayCortes[1,:])
Matriz Linha:
[4 5 6]
In [37]: #até mesmo um pedaço da matriz
print("Matriz pedaço: ")
print(arrayCortes[1:,1:])
Matriz pedaço:
[[5 6]
[8 9]]
Podemos usar esses comandos para substituir valores em um array com mais facilidade:
In [38]: #mudando valores da matriz
arrayCortes[1:,1:]=99
print("Matriz Novos valores: ")
print(arrayCortes)
Matriz Novos valores:
[[ 1 2 3]
[ 4 99 99]
[ 7 99 99]]
Agora vamos ver alguns métodos matemáticos do Numpy:
In [39]: #Criando array
A = np.arange(9,0,-1)
print("Array Inicial: ",A)
Array Inicial: [9 8 7 6 5 4 3 2 1]
In [40]: #Ordenando o array
A.sort()
print("Array ordenado: ",A)
Array ordenado: [1 2 3 4 5 6 7 8 9]
6
In [41]: #Soma elementos do array
print("Array somado: ",A.sum())
Array somado: 45
In [42]: #Média dos elementos do array
print("Array somado: ",A.mean())
Array somado: 5.0
In [43]: #Maior elemento
print("Array maior elemento: ",A.max())
Array maior elemento: 9
In [44]: #Variância
print("Variância: ",A.var())
Variância: 6.66666666667
In [45]: #Desvio Padrão
print("Desvio Padrão: ",A.std())
Desvio Padrão: 2.58198889747
In [46]: #Transposta de um matriz
A.shape =(3,3)
print("Transposta: ")
print(A.T)
Transposta:
[[1 4 7]
[2 5 8]
[3 6 9]]
In [47]: #Determinante
print("Determinante: ")
print(np.linalg.det(A) )
Determinante:
-9.51619735393e-16
In [48]: #Matriz Inversa
print("Inversa: ")
print(np.linalg.inv(A))
7
Inversa:
[[ 3.15251974e+15 -6.30503948e+15 3.15251974e+15]
[ -6.30503948e+15 1.26100790e+16 -6.30503948e+15]
[ 3.15251974e+15 -6.30503948e+15 3.15251974e+15]]
Podemos realizar operações algébricas demaneira muito simples:
In [49]: #Aamos criar arrays
a = np.array([1,2,3,4])
b=np.array([5,6,7,8])
print("Array A: ",a)
print("Array B: ",b)
#Soma
print("Array A - soma: ",a+10)
#Multiplicação
print("Array B - multiplicação: ",b*10)
#Inclusive entre eles
print("Divisao Array A pelo B: ",a/b) #elemento por elemento
Array A: [1 2 3 4]
Array B: [5 6 7 8]
Array A - soma: [11 12 13 14]
Array B - multiplicação: [50 60 70 80]
Divisao Array A pelo B: [ 0.2 0.33333333 0.42857143 0.5 ]
Com matrizes (array bidimencional) é a mesma coisa, com exceção da multiplicação - a vere-
mos agora. Primeiramente, lembremos que para multiplicar duas matrizes (A e B) o número de
colunas da matriz A tem que ser iqual ao número de linhas da Coluna B:
In [52]: A = np.array([1,2,3,4])
B=np.array([5,6,7,8])
A.shape=(2,2)
B.shape=(2,2)
print("Matriz A: ")
print(A, "\n")
print("Matriz B: ")
print(B, "\n")
#Matriz A X B
print("Matriz A X B : ")
8
print(A @ B, "\n")
#Array X matriz
print("Array [2,3] x A : ")
print( [2,3] @ A)
#Na aula de Álgebra Linear apresentaremos outra maneira de se realizar
#a multiplicação de matrizes.
Matriz A:
[[1 2]
[3 4]]
Matriz B:
[[5 6]
[7 8]]
Matriz A X B :
[[19 22]
[43 50]]
Array [2,3] x A :
[11 16]
Podemos copiar um array com a função np.copyto():
In [53]: #Criando array original
Original = np.array ([1,2,3])
print( "Array Original: ",Original)
#Fazendo copiar
Copia = np.empty_like(Original) # cria array vazio na mesma forma do Original
np.copyto(Copia,Original)
print( "Array Copia: ", Copia)
Array Original: [1 2 3]
Array Copia: [1 2 3]
Também podemos realizar comparações entre elementos dos arrays:
In [54]: a = np.array([1,2,3,4])
b=np.array([5,2,7,8])
print("Array A: ",a)
print("Array B: ",b)
9
#entre os proprios array
print("Comparação entre A e B: ", a==b)
# do array entre algum numero
print("Elemento do array B > 6: ",b>6 )
Array A: [1 2 3 4]
Array B: [5 2 7 8]
Comparação entre A e B: [False True False False]
Elemento do array B > 6: [False False True True]
2 Exercícios
1- Refaça alguns exercícios feito anteriormente com lista usando o Numpy e compare o tempo de
execução.
2- Crie uma array com 9 entradas, transforme-o em uma matriz 3x3 e faça os exercícios abaixo
com ela.
3- Faça a Multiplicação de uma matriz 3x3 sem utilizar a função de multiplicações de matrizes
da Numpy.
4- Faça a transposta de uma matriz sem utilizar a função de transposta da Numpy.
5- Ache a inversa de uma Matriz 3x3 sem utilizar a função da inversa da Numpy.
3 Pandas
Conheceremos agora uma das bibliotecas mais importantes e mais usadas para fazer a análise de
dados no Python - o Pandas. O Pandas oferece diversas funções que facilitam a manipulação e
visualização dos dados.
In [55]: #Importando a biblioteca
import pandas as pd
Como dito anteriormente, o Pandas facilita a visualização de dados por causa da estrutura que
ele é capaz de comportar as bases de daods - essa estrutura é chamada de DataFrame. Vamos criar
um dicionário e depois transformá-lo em DataFrame para vermos sua estrutura:
In [56]: dicionario = {"País": ["Brasil", "Rússia", "Índia", "China", "África do Sul"],
"Capital": ["Brasília", "Moscou", "Nova Deli", "Pequim", "Pretória"],
"Área": [8.516, 17.10, 3.286, 9.597, 1.221],
"População": [200.4, 143.5, 1252, 1357, 52.9]}
Brics = pd.DataFrame(dicionario)
print(Brics)
Capital País População Área
0 Brasília Brasil 200.4 8.516
1 Moscou Rússia 143.5 17.100
2 Nova Deli Índia 1252.0 3.286
10
3 Pequim China 1357.0 9.597
4 Pretória África do Sul 52.9 1.221
Devido a um bug do Pandas, ele pode mudar a ordem das colunas. Vamos consertar isso agora:
In [57]: Brics = Brics[['País','Capital','Área','População']]
print(Brics)
País Capital Área População
0 Brasil Brasília 8.516 200.4
1 Rússia Moscou 17.100 143.5
2 Índia Nova Deli 3.286 1252.0
3 China Pequim 9.597 1357.0
4 África do Sul Pretória 1.221 52.9
Podemos ver que temos uma estrutura feita em tabela, o que torna a visualização dos dados
muito mais fácil. Agora vamos supor que usaremos uma base de dados grande. Nesse caso,
não podemos colocar toda base de dados no próprio código usando um dicionário, então usamos
um arquivo externo do tipo .csv. Os arquivos csv são arquivos com informações separadas por
vírgulas dispostas em colunas. A biblioteca Pandas entende automaticamente esses dados e os
converte em Data Frame.
. . .
Formato de um .csv:
descrição1,descrição2,. . . ,descriçãoN
dado da descrição1, dado da descrição2,. . . ,dado da descriçãoN
dado da descrição1, dado da descrição2,. . . ,dado da descriçãoN
dado da descrição1, dado da descrição2,. . . ,dado da descriçãoN
Exemplo:
País,Capital,Área,População
Brasil,Brasília,8.516,200.4
Rússia,Moscou,143.5,17.100
. . .
Podemos criar um arquivo .csv de diversar maneiras e as mais fáceis são editar um bloco de
notas e salvá-lo como .csv ou podemos ir no Google Planilhas/Excel e colocar cada dado em uma
coluna e na hora de baixar ou salvar, escolher a opção “csv separado por vírgulas”. No entanto,
geralmente trabalharemos com arquivos csv já prontos, criados por terceiros. Por favor baixe o
arquivo “Pokemon.csv” da nossa pasta para trabalharmos agora:
In [58]: #Abrindo dataset
dataset = pd.read_csv("Pokemon.csv") #Colocamos o caminho do arquivo entre (),
#caso já esteja na pasta do Jupyter Notebook.
#Vamos dar um display no nosso dataset
dataset.head()
Out[58]: # Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque \
0 1 Bulbasaur Grama Veneno 318 45 49 49 65
11
1 2 Ivysaur Grama Veneno 405 60 62 63 80
2 3 Venusaur Grama Veneno 525 80 82 83 100
3 4 Charmander Fogo NaN 309 39 52 43 60
4 5 Charmeleon Fogo NaN 405 58 64 58 80
Sp.Def Velocidade Geração Lendario
0 65 45 1 False
1 80 60 1 False
2 100 80 1 False
3 50 65 1 False
4 65 80 1 False
O metodo .head() mostra apenas as 5 primeiras observações de nosso dataset. Para vermos
todos os nomes de variáveis, usamos o comando .columns. Ademais, podemos contar as linhas e
colunas de nosso dataset com o metodo .count():
In [59]: #Variáveis
dataset.columns
Out[59]: Index(['#', 'Nome', 'Tipo_1', 'Tipo_2', 'Total', 'HP', 'Ataque', 'Defesa',
'Vel.Ataque', 'Sp.Def', 'Velocidade', 'Geração', 'Lendario'],
dtype='object')
In [60]: #contando dados diferentes de vazio por variável
dataset.count()
Out[60]: # 9
Nome 9
Tipo_1 9
Tipo_2 4
Total 9
HP 9
Ataque 9
Defesa 9
Vel.Ataque 9
Sp.Def 9
Velocidade 9
Geração 9
Lendario 9
dtype: int64
Observamos que existem dois contadores no canto esquerdo e isso ocorre pois o dataset usado
já contém um contador e o Pandas gera outro automaticamente. Para tiramos o contador do
Pandas basta fazer o seguinte:
In [61]: #Basta adicionar index_col =0 na hora de pegar o csv
dataset = pd.read_csv("Pokemon.csv",index_col =0)
dataset.tail(3) #mostra os ultimos itens do csv
12
Out[61]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
7 Squirtle Agua NaN 314 44 48 65 50 64
8 Wartortle Agua NaN 405 59 63 80 65 80
9 Blastoise Agua NaN 530 79 83 100 85 105
Velocidade Geração Lendario
#
7 43 1 False
8 58 1 False
9 78 1 False
Podemos também fazer os cortes que desejarmos no csv:
In [62]: #Dando display em um intervalo do dataset
dataset[3:6]
Out[62]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
4 Charmander Fogo NaN 309 39 52 43 60 50
5 Charmeleon Fogo NaN 405 58 64 58 80 65
6 Charizard Fogo Voador 534 78 84 78 109 85
Velocidade Geração Lendario
#
4 65 1 False
5 80 1 False
6 100 1 False
Podemos também escolher determinadas colunas (variáveis) da seguinte forma:
In [63]: dataset['Nome']
Out[63]: #
1 Bulbasaur
2 Ivysaur
3 Venusaur
4 Charmander
5 Charmeleon
6 Charizard
7 Squirtle
8 Wartortle
9 Blastoise
Name: Nome, dtype: object
In [64]: #Também é possívelagrupar as colunas pelo método value_counts()
pd.value_counts(dataset["Tipo_1"])
13
Out[64]: Grama 3
Agua 3
Fogo 3
Name: Tipo_1, dtype: int64
In [65]: #A função "loc" mostra os dados da linha desejada
dataset.loc[dataset['Nome'] == 'Charmander']
Out[65]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
4 Charmander Fogo NaN 309 39 52 43 60 50
Velocidade Geração Lendario
#
4 65 1 False
In [66]: #Podemos também fazer isso para selecionar subconjuntos específicos do dataset
dataset.loc[dataset['Ataque'] > 50]
Out[66]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
2 Ivysaur Grama Veneno 405 60 62 63 80 80
3 Venusaur Grama Veneno 525 80 82 83 100 100
4 Charmander Fogo NaN 309 39 52 43 60 50
5 Charmeleon Fogo NaN 405 58 64 58 80 65
6 Charizard Fogo Voador 534 78 84 78 109 85
8 Wartortle Agua NaN 405 59 63 80 65 80
9 Blastoise Agua NaN 530 79 83 100 85 105
Velocidade Geração Lendario
#
2 60 1 False
3 80 1 False
4 65 1 False
5 80 1 False
6 100 1 False
8 58 1 False
9 78 1 False
Podemos ordenar os dados de acordo com valores de uma variável com o método
“.sort_values”:
In [67]: dataset.sort_values(by='Ataque') #Para inverter a ordem,
#basta adicionar no argumento ascending=False
Out[67]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
7 Squirtle Agua NaN 314 44 48 65 50 64
1 Bulbasaur Grama Veneno 318 45 49 49 65 65
14
4 Charmander Fogo NaN 309 39 52 43 60 50
2 Ivysaur Grama Veneno 405 60 62 63 80 80
8 Wartortle Agua NaN 405 59 63 80 65 80
5 Charmeleon Fogo NaN 405 58 64 58 80 65
3 Venusaur Grama Veneno 525 80 82 83 100 100
9 Blastoise Agua NaN 530 79 83 100 85 105
6 Charizard Fogo Voador 534 78 84 78 109 85
Velocidade Geração Lendario
#
7 43 1 False
1 45 1 False
4 65 1 False
2 60 1 False
8 58 1 False
5 80 1 False
3 80 1 False
9 78 1 False
6 100 1 False
Um outro método muito importante é o .describe(). O método faz uma análise descritiva básica
da base de dados com as principais estatísticas:
In [68]: dataset.describe()
Out[68]: Total HP Ataque Defesa Vel.Ataque Sp.Def \
count 9.000000 9.000000 9.000000 9.000000 9.000000 9.000000
mean 416.111111 60.222222 65.222222 68.777778 77.111111 77.111111
std 93.955368 15.857000 14.584048 18.053932 19.173187 17.961378
min 309.000000 39.000000 48.000000 43.000000 50.000000 50.000000
25% 318.000000 45.000000 52.000000 58.000000 65.000000 65.000000
50% 405.000000 59.000000 63.000000 65.000000 80.000000 80.000000
75% 525.000000 78.000000 82.000000 80.000000 85.000000 85.000000
max 534.000000 80.000000 84.000000 100.000000 109.000000 105.000000
Velocidade Geração
count 9.000000 9.0
mean 67.666667 1.0
std 18.500000 0.0
min 43.000000 1.0
25% 58.000000 1.0
50% 65.000000 1.0
75% 80.000000 1.0
max 100.000000 1.0
In [69]: #Também é possível focar em uma estatística por vez
dataset.mean()
Out[69]: Total 416.111111
HP 60.222222
15
Ataque 65.222222
Defesa 68.777778
Vel.Ataque 77.111111
Sp.Def 77.111111
Velocidade 67.666667
Geração 1.000000
Lendario 0.000000
dtype: float64
In [70]: #É possível também focar em uma só coluna (variável):
dataset["Defesa"].describe()
Out[70]: count 9.000000
mean 68.777778
std 18.053932
min 43.000000
25% 58.000000
50% 65.000000
75% 80.000000
max 100.000000
Name: Defesa, dtype: float64
Se quisermos ver o máximo de uma variável específica, é possível fazer da seguinte forma:
In [71]: dataset["Ataque"].max()
Out[71]: 84
In [72]: #É possível dar display em uma linha específica com uma qualidade qualquer
#No exemplo abaixo queríamos a que tinha maior ataque
dataset.loc[dataset['Ataque'] == dataset["Ataque"].max()]
Out[72]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
6 Charizard Fogo Voador 534 78 84 78 109 85
Velocidade Geração Lendario
#
6 100 1 False
Podemos também adicionar dados na tabela da seguinte forma:
In [73]: dataset['Evolução'] = (1,2,3,1,2,3,1,2,3)
dataset
Out[73]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
1 Bulbasaur Grama Veneno 318 45 49 49 65 65
2 Ivysaur Grama Veneno 405 60 62 63 80 80
16
3 Venusaur Grama Veneno 525 80 82 83 100 100
4 Charmander Fogo NaN 309 39 52 43 60 50
5 Charmeleon Fogo NaN 405 58 64 58 80 65
6 Charizard Fogo Voador 534 78 84 78 109 85
7 Squirtle Agua NaN 314 44 48 65 50 64
8 Wartortle Agua NaN 405 59 63 80 65 80
9 Blastoise Agua NaN 530 79 83 100 85 105
Velocidade Geração Lendario Evolução
#
1 45 1 False 1
2 60 1 False 2
3 80 1 False 3
4 65 1 False 1
5 80 1 False 2
6 100 1 False 3
7 43 1 False 1
8 58 1 False 2
9 78 1 False 3
É possível aplicar funções com dados da tabela para preencher dados na propria tabela:
In [74]: def evolucao(x):
if x == '1':
return "Forma incial"
elif x == 2:
return "Primeira evolução"
elif x == 3:
return "Segunda Evolução"
dataset['Evolução'] = dataset['Evolução'].apply(evolucao)
dataset
Out[74]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
1 Bulbasaur Grama Veneno 318 45 49 49 65 65
2 Ivysaur Grama Veneno 405 60 62 63 80 80
3 Venusaur Grama Veneno 525 80 82 83 100 100
4 Charmander Fogo NaN 309 39 52 43 60 50
5 Charmeleon Fogo NaN 405 58 64 58 80 65
6 Charizard Fogo Voador 534 78 84 78 109 85
7 Squirtle Agua NaN 314 44 48 65 50 64
8 Wartortle Agua NaN 405 59 63 80 65 80
9 Blastoise Agua NaN 530 79 83 100 85 105
Velocidade Geração Lendario Evolução
#
1 45 1 False None
17
2 60 1 False Primeira evolução
3 80 1 False Segunda Evolução
4 65 1 False None
5 80 1 False Primeira evolução
6 100 1 False Segunda Evolução
7 43 1 False None
8 58 1 False Primeira evolução
9 78 1 False Segunda Evolução
Por fim, podemos excluir dados com método “.drop”:
In [75]: #vamos excluir a coluna "Lendario"
dataset.drop(["Lendario"],axis=1,inplace= True)
dataset
Out[75]: Nome Tipo_1 Tipo_2 Total HP Ataque Defesa Vel.Ataque Sp.Def \
#
1 Bulbasaur Grama Veneno 318 45 49 49 65 65
2 Ivysaur Grama Veneno 405 60 62 63 80 80
3 Venusaur Grama Veneno 525 80 82 83 100 100
4 Charmander Fogo NaN 309 39 52 43 60 50
5 Charmeleon Fogo NaN 405 58 64 58 80 65
6 Charizard Fogo Voador 534 78 84 78 109 85
7 Squirtle Agua NaN 314 44 48 65 50 64
8 Wartortle Agua NaN 405 59 63 80 65 80
9 Blastoise Agua NaN 530 79 83 100 85 105
Velocidade Geração Evolução
#
1 45 1 None
2 60 1 Primeira evolução
3 80 1 Segunda Evolução
4 65 1 None
5 80 1 Primeira evolução
6 100 1 Segunda Evolução
7 43 1 None
8 58 1 Primeira evolução
9 78 1 Segunda Evolução
4 Exercícios
1-Crie um arquivo.csv com área, país, capital, população e IDH de coluna usando os países do
Mercosul como base faça as seguintes manipulações com o csv:
a) Organize os países por ordem alfabética e depois por IDH;
b) Descubra a média do IDH do mercosul e selecione todos os países que estiverem acima da
média mostrando todos os seus dados;
18
c) Adicione uma coluna que classifique um país como de Desenvolvido ou Subdesenvolvido
levando em conta o IDH depois tire a tabela de IDH - defina um ponto de corte;
2- Faça o mesmo com os países da União Europeia;
19
	Aula de introdução ao Python 3.6.1 II
	Numpy
	Exercícios
	Pandas
	Exercícios