curso-python.org

Curso de Python

Conteúdo

• Dia 1
  • Introdução
  • Instalar
  • cmd e interprete
  • Tipos em Python
  • Listas/Dicionários
  • Condicional
  • Loops
• Dia 2
  • Revisão
  • Funções
  • Importar módulos
  • OOP
  • Tratar exceções (exceptions)
• Dia 3
  • Numpy
  • Matplotlib
• Dia 4
  • Matplotlib Continuação
  • Ler e escrever arquivos
  • Abrir arquivos alternativa Pythonica
  • Pandas
  • Sympy
  • Pytest

Dia 1

Introdução

Apresentação

1. Nasser Alkmim

Por que aprender programação

1. Raciocínio lógico
2. Ferramenta que auxiliar na produtividade
   1. Automação
   2. Soluções mais eficientes
3. Poder comunicar essas soluções com outros
4. Exemplo: automatizar baixar dados e trata-los

Python é usada pra que?

Backend

“análises por trás dos panos”

Frontend

“design e interfaces”

Python é popular, por que?

1. simples
2. produtividade
3. legível

Legível

if (10 < 2) is True:
    print('ok')

Python popular, por que?

1. comunidade grande e disposta a ajudar
2. vasta quantidade de bibliotecas
   1. numpy
   2. matplotlib
   3. pandas
   4. scikit-(learn, image, …)

Ementa

1. cmd prompt/idle
2. Strings/Int/Float
3. Listas/Dicionários
4. Condicional/Loops

Instalar

Baixar o Python no site oficial.

Não esquecer de marcar a opção de adicionar o python no path!

cmd e interprete

1. calculadora
2. interpretar/rodar arquivos

Exercício

Testar as operações básicas no cmd prompt

1. +
2. -
3. /
4. *
5. **
6. %
7. boolean (<, >, >=, !=, ==, is, not)

Tipos em Python

Tipos

1. Números: 120, 3.14, 1e3
2. Strings: ‘texto’, “Hello”
3. Listas: [1, [5, ‘string’]]
4. Dicionários: {‘book’: ‘livro’, ‘idadade’: 10}
5. Tuples: (2, ‘tres’)

Strings

str = 'isso é uma string'
print(str, type(str))

Formatar strings

1. format e “\n” e “\t”

nome = 'Joao'
idade = 22
profissao = 'carpiteiro'
print('name: {}, age: {} \t , job: {}'.format(nome, idade, profissao))

Strings exercício

Definir variáveis para seu nome, profissão e hobby Imprimir uma tabela com esses dados usando \n e \t

Listas/Dicionários

O que são?

1. o que pode entrar numa lista??

lista = [1, 30.5, 'casa', [100, 20 , [30, 'hh']]]

Slicing

1. começo : fim : passo
2. onde fica o fim?
3. lista de lista
4. slicing para alterar entrada da lista

lista = [0, 1, 2, 3, 4, 5, 6]
lista[5] = 50
print(lista)

Operações

1. soma de listas
2. escalar * lista

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
print(lista1*2)

Métodos úteis

1. len() -> tamanho da lista
2. método index() e “in-place” sort()
3. dir() -> mostra todos os atributos
4. append() e extend()

lista = [10, 13, 14]
l2 = [1.9, 1.8, 1.6]

Exercício

Dada a lista:

l = [3.99]*5

Mudar o elemento de índice 3 para 10

l = [3]*5
l[3] = 10
print(l)

Exercício

Dada a lista:

l = [20, 33, 40, 100, 18, 38, 21, 10, 16]

Obter os elementos com índice ímpar até o termo 10 (incluindo ele)

1. Usar .index() para encontrar o indice do termo 10
2. Imprimir a lista usando ‘slicing’ de l
3. [inicio:fim:passo] o inicio inclui o passo não

Resultado: l2 = [33, 100, 38, 10]

l = [20, 33, 40, 100, 18, 38, 21, 10, 16]
l2 = l[1:l.index(10)+1:2]
print(l2)

Dicionários

1. arrays associativos
2. acessar valor com chave

dic = {'key': 'value'}
eng2pt = {'book': 'livro', 'table': 'mesa', 'chair': 'cadeira'}
print(eng2pt['table'])

Dictionário são úteis

1. checar se o dicionário tem a chave “in”
2. listar keys() e items()

domicilio = {'num': 10, 'pessoas': 5, 'renda': 1000}
domicilio2 = {'num': 10, 'pessoas': 3, 'renda': 100}

lista = [domicilio, domicilio2]
print(domicilio.items())

Condicional

O que é?

1. if/elif/else
2. sintax, notar a identação do bloco

if 2 < 1:
    print('Essa afirmação é verdadeira')
elif 2 is 3:
    print('teste 2')
else:
    print('caso contrario')

Boolean

1. and/or/not

x = 9
y = 20

if x > y:
    print('x>y é verdadeiro')
elif x>5 and x % 3 == 0:
    print('x é maior que 5 e divisível por 3')
else:
    print('todos os testes foram falsos')

1. in

lista = [20, 30, 50, 100]

if 100 in lista:
    print('esse item esta na lista no indice {}'.format(lista.index(100)))

Dado a lista

l = list(range(10))

checar se 5 está incluso em l e imprimir o índice de 5, depois alterar o valor para 50.

1. Usar in e .index()
2. imprimir com .format()
3. imprimir no final a lista atualizada

l = list(range(10))
print(l)
if 5 in l:
    ind = l.index(5)
    l[ind] = 50
print(l)

Checar vazios

l = []

if l:
    print(l)

Exercício

Usuário entra um número e o programa diz se é divisível por 2 ou não.

1. Usar input()
2. Lembrar que input() retorna str.
3. %

user_var = int(input('Entre com um valor: '))

Loops

for loop

1. sintaxe (notar espaços)
2. qualquer iteravel
3. lista, range

iteravel = [1, 2, 3]
for i in range(10):
    print(i)

break, continue e pass

1. break: pula para o próximo loop
2. continue: pula para o inicio do loop

for i in range(1, 5):
    if i % 5 == 0:
        print(i**2)
        continue
    else:
        pass

List comprehension

1. inline loops

lista = [i**2 for i in range(20)]
print(lista)

Exercicio

Dada a lista:

a = [1, 2, 1, 20, 30, 4, 2.5, 45]

escrever um script que cria uma lista com os os elementos de a menores que 5.

Respota: b = [1, 2, 1, 4, 2.5]

a = [1, 2, 1, 20, 30, 4, 2.5, 45]
b = []
for i in a:
    

while loops

x = 10
while x > 1:
    x -= 1
    print(x)
    if x % 2 == 0:
        x += 10
        continue
    if x % 7 == 0:
        print(x)
        break

Outros iteráveis - zip e enumerate

1. operações entre duas listas

lista1 = [2, 3, 4, 5]
lista2 = [20, 30, 40, 50]

for i, j in zip(lista1, lista2):
    print(i*j)

Outros iteráveis - dicionário

dic = {'toyota':[1e6, 'japao'],
       'bmw': [1e4, 'alemanha']}

for marca, [num, pais] in dic.items():
    print(marca, num, pais)

Exercício

Dado o dicionário:

dic = {'ovo': [12, 'un'], 'leite': [500, 'ml'], 'farinha':[1, 'kg']}

faça um teste para saber se a receita leva leite, e imprima o valor e a unidade.

Resposta: 'Receita leva 500 ml de leite'

E depois saber se leva farinha.

dic = {'ovo': [12, 'un'], 'leite': [500, 'ml'], 'farinha':[1, 'kg']}
ingrediente = 'farinha'
for ingr, [qt, un] in dic.items():
    if ingr is ingrediente:
        print('leva {}, quantidade {}{}'.format(ingr, qt, un))

Exercício

Dado o input inteiro n, criar um dicionário que contenha {i: i**i} com i indo de 1 até n (incluso)

Exemplo: n = 3

Resultado: dic = {1: 1, 2: 4, 3: 9}

Desafio

Escrever um programa que imprimir o seguinte padräo

para n = 4:

- – — ---- — – -

Dica:

1. Usar o fato de que range(inicio, fim, passo) pode ter passo negativo que faz o iterável seguir no sentido contrário.
2. Usar dois loops separados

Dia 2

Revisão

if 5 < 10:
    print('Isso é verdade')
for i in range(10):
    print(i)

Funções

O que é

1. Um conjunto de declarações encapsuladas
2. Um forma de organizar o código - DRY (don’t repeat yourself)
3. Facilitar na hora de encontrar errors (testar código)

Construtor

1. práticas de nomenclatura

def nome_da_funcao(args):
    return args*2
print(nome_da_funcao('lista'))

Exemplo

1. sintaxe
2. docstring
3. default argumento
4. *args, **kwargs

def soma_argumentos(*arg1, **kwargs):
    soma = 0
    for i in arg1:
        soma += i
    return soma**kwargs['potencia']/kwargs['div']
        
soma = soma_argumentos(20, 30, 40, 40, 50, 60, 
                       potencia=2, div=3)
print(soma)

Exercício

Fazer uma função que calcula a soma dos termos ao quadrado de uma lista de tamanho qualquer.

testar com:

vetor = [4, 5, 8, 9] vetor = [50, 20, 10, 30, 50]

def soma_do_quadrado(vetor):
    """calcula o quadrado dos termos do vetor
    Args:
        vetor (list of floats): lista com numeros
    Returns:
        float 
    """
    soma = 0
    for i in vetor:
        soma = soma + i**2
    return soma
print(soma_do_quadrado([1, 2]))

Importar módulos

O que é um módulo?

1. Um arquivo .py com código
2. Útil para reutilizar e organizar código
3. Um conjunto de módulos é um pacote

Usar import

1. testar com import math
2. math define um “namespace” (onde as variáveis do programa livem)
3. acesar as funções no módulo com .
4. factorial, cos, log

import math

print(math.factorial(40))

from package import função

1. Construção que evitar ter que prefixar as funções com o nome do pacote
2. from math import * não é uma boa prática pois contamina o “namespace”

from math import factorial, pi, log, cos, sin

print(factorial(5)/pi)

Import seu próprio módulo

Baixar numpy, matplotlib, pandas

1. pip install numpy
2. pip install matplotlib
3. pip install pandas

OOP

O que é OOP?

1. Programação Orientada Objeto
2. É uma técnica de estruturação do programa (modelagem)
3. Utiliza o conceito de Classes e Objetos
4. Encapsular dados e funções em um lugar só, no objeto

Motivação

Estrutura de dados repetida

# Funcionários (Objeto)
nome1 = 'João'
nome2 = 'Maria'
nome3 = 'Jose'

funcionarios = [nome1, nome2, nome3]

num_funcionarios = len(funcionarios)

# Salario de cada funcionario (Atributo)
salario1 = 10000
salario2 = 12000
salario3 = 8000

class Funcionario:
    def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario
    def calc_imposto(self):
        return self.salario*12.9/100

fun1 = Funcionario('Joao', 1000.5)
fun2 = Funcionario('Mario', 1200.0)

print(fun2.calc_imposto())

Motivação 2

Uma malha com coordenadas, conectividade, numero de nós, número de graus de liberdade, …

O que é uma Classe?

1. É um construtor que define um tipo de dado
2. Criação da classe e instanciação
3. Nomenclatura “CamelCase” PEP8 (Guia de Estilo)
4. funções de objetos: métodos
5. atributos

class NomeDaClasse:
    pass

funcionario = NomeDaClasse()
funcionario.idade = 25
funcionario.nome = 'Joao'

def func(funcionario):
    print(funcionario.idade, funcionario.nome)

func(funcionario)

Mais sobre classes

1. Os dados ficam contidos num container lógico
2. Contém as instruções para criar um objeto
3. Usar quando houver padrões de comportamento, qualidades e sentido nos dados
4. Permite a definição de numenclatura lógica - facilita a compreensão do código

class NomeDaClasse:
    def __init__(self, atributo2):
        self.atributo = 'atributo da instância'
        self.novoatributo = atributo2
objeto = NomeDaClasse(1000)
print(objeto.atributo)          # Depois do '.' acesso aos atributos/métodos
print(objeto.novoatributo)

O que é um objeto, método, atributo?

1. Objeto
   1. Invocar uma classe significa instânciar um objeto
   2. Instância: significa “um exemplo”, ou “um caso”
   3. As classes definem as características inerentes do objeto
2. Atributo
   1. É uma qualidade do objeto
   2. Acessada com ‘.’ objeto.atributo
3. Método
   1. É uma função definida na classe
   2. É do objeto
   3. Acessada com ‘.’ objeto.metodo()

O que é o parâmetro self e o método __init__?

1. self é a própria instância (objeto) criada pela classe
2. Uma forma da classe se referir a si mesma
3. __init__() é um método padrão das clases
   1. quando a classe é instanciada o método __init__() é chamado
   2. usar quando quiser criar um objeto com “atributos iniciais”

class MyClass:
    def __init__(self):
        self.a = 2

Como fica em formato de classe?

class Funcionario:
    'Cria o objeto funcionario'
    contador = 0   # atributo da classe (acessado por todas as instâncias)

    def __init__(self, nome, salario, cargo):
        'Método que inicia a classe'
        self.nome = nome
        self.salario = salario
        self.cargo = cargo
        Funcionario.contador += 1 

    def quantidade(self):
        'Método que mostra o numero de funcionarios'
        print(Funcionario.contador)

func1 = Funcionario('joão', 1500, 'Faxineiro')
func2 = Funcionario('maria', 12000, 'Gerente')
func3 = Funcionario('andre', 20000, 'Engenheiro')

func1.quantidade()

# print(func2.nome, func2.salario)  # Atributos dos objetos
# print(func1.quantidade())       # Invocar um método

Exemplo

1. Fazer uma classe que contenha instruções para dados de um cachorro

class Dog:
    'Classe que define o cachorro'
    def __init__(self, name, breed, color):
        self.name = name        # Aplica os atributos
        self.breed = breed
        self.color = color

    def bark(self):
        print('{} barks!!!'.format(self.name))


meu_cachorro = Dog('Euler', 'Poodle', 'Grey')  # Instânciei a classe e criei o objeto
cachorro_da_marlete = Dog('Branca', 'corgi', 'branca')

print(cachorro_da_marlete.bark())

Branca barks!!!
None

Exercício

Fazer uma classe para uma conta bancária com:

• 1 atributo: balanço da conta
• 2 métodos: um de saque e um de depósito.

Testar:

• Criar um objeto de conta bancaria
• Depositar 1000 reais
• Sacar 2,5 para almoçar
• imprimir o balanço final

class Conta:
    def __init__(self, saldo, dono):
        self.saldo = saldo
        self.dono = dono
    def saque(self, valor):
        self.saldo -= valor
    def deposito(self, valor):
        self.saldo += valor
    def extrato(self):
        print('O saldo do {}  é {}'.format(self.dono, self.saldo))
minhaconta = Conta(0, 'Joao')
minhaconta.saque(2.5)
minhaconta.extrato()
contadoze = Conta(-20000, 'José')
contadoze.deposito(5000)
contadoze.extrato()

Tratar exceções (exceptions)

Construtor

1. try , except , finally e else

lista= [50, 60, 1]
try:
    lista[2] = 2
except IndexError:
    print('Sua lista náo tem indice 2')
print(lista)

Exemplos

1. Tentar acessar uma lista com float
2. Tentar acessar um dicionário com uma chave não existente
3. Importar um módulo não existente
4. Dividir por zero
5. só except não é recomendado: você não vai saber qual erro captou

try:
    v = 1/0
except ZeroDivisionError:
    print('o que vc tentou falhou')

Exercício

Dado o dicionário:

dic = {'cor': 'azul', 'forma': 'circular', 'raio': 2}

tentar acessar a a chave area, e imprimir a mensagem que a chave não existe no dicionário.

1. Usar a excessão KeyError

Dia 3

Numpy

O que é numpy?

1. Biblioteca para computação científica em Python.
2. Um equivalente ao Matlab
3. Operações matriciais/vetoriais com arrays homogenos multidimensionais
4. Kit para álgebra linear

Como usar

1. Baixar a biblioteca

pip install numpy

1. Importar a biblioteca

import numpy as np

Criação de arrays

1. Arrays de rank 1: 1 axis (eixo)
2. o argumento de np.array() é uma lista!

import numpy as np
vetor = np.array([1, 2 , 3, 10, 20])
print(vetor)

Criação de arrays

1. Rank 2, o primeiro axis tem tamanho 2 e o segundo 3
2. Equivalente a uma matrix, primeiro axes são linhas e o segundo as colunas
3. atributo transposta .T

import numpy as np
matriz = np.array([[20, 10, 30], 
                   [19, 29, 39]])
print(matriz)
print(matriz.shape)

Convertendo lista para arrays

import numpy as np
a = [[2, 2, 3], [10, 22, 32]]
A = np.array(a)

print(A, type(A))

Exercício criar um array de rank 3

Criar um array arr com:

1. axis tamanho 2
2. axis tamanho 3
3. axis tamanho 2

obs: os números podem ser aleatórios, sugestão: sequência 1,2,3…

testar: arr.shape

import numpy as np
arr = [
[[1, 2],
[3, 4],
[5, 6]],
[[7, 8],
[9, 10],
[11, 12]]]
arr = np.array(arr)
print(arr.shape)

Iniciando arrays

1. np.zeros()
2. np.ones()
3. np.linspace()
4. np.arange()

import numpy as np

arr = np.arange(0, 10, 20)
print(arr)

Slicing de arrays 1D

1. start:end:step

import numpy as np
A = np.linspace(0, 10, 11)
print(A)
print(A[2:5])

Slicing de arrays 2D

1. [linha, coluna]
2. random.rand(shape) ~ U[0, 1]
3. np.round(número de casas decimais)

import numpy as np
np.random.seed(10)
A = np.round(np.random.rand(5, 3), 1)
print(A)
print(A[0:4, 0:2])

Exercício

Pegar o array de rank 3 e shape (2, 3, 2) e modificar todos os elemento do eixo 1 para 99.

Resultado:

import numpy as np
arr = [
[[1, 2],
[3, 4],
[5, 6]],
[[7, 8],
[9, 10],
[11, 12]]]
arr = np.array(arr)
arr[0, :, :] = 99
print(arr)

Operando arrays 1D

1. Termo a termo
2. Vetorial

import numpy as np
vector_a  = np.array([1, 2, 4, 5])
vector_b  = np.ones(4) * 2
print(vector_a )

Operações com arrays 2D

1. *, @, dot

import numpy as np
A = np.array([[1, 2, 3, 5], [4, 5, 6, 5]])
B = np.array([8, 9, 10, 1])
D = np.array([2, 2, 2, 2])

Solução de sistemas lineares e Alg. Linear

1. linalg.solve()
2. linalg.inv()
3. linalg.det()
4. linalg.eig()

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6], [2, 5, 6]])
B = np.array([8, 9, 10])
# Ax = B
x = np.linalg.solve(A, B)
print(np.linalg.eig(A))

Exercicio solução de sistema linear

Resolver o sistema Ax = b

1. Criar os arrays com np.array()
2. Usar np.linalg.solve() e comparar com o resultado invertendo a matrix com np.linalg.inv()

A = [[3, 4, 5],
    [2, 1, 4],
    [1, 5, 8]]

b = [1, 5, 9]

import numpy as np
A = np.array([[3, 4, 5],
              [2, 1, 4],
              [1, 5, 8]])

b = np.array([[1, 5, 9]])
x = np.linalg.solve(A, b.T)
print(x)

Exercício

Fazer o produto interno de dois vetores

a = [1, 2, 3, 4, 5] b = [3, 4, 5, 6, 7]

import numpy as np
def produto_escalar(v1, v2):
    """Retornar uma escalar """
    soma = 0
    for i, j in zip(v1, v2):
        soma += i * j
    return soma
a = np.array([1, 2, 3, 4, 5])
b = np.array([3, 4, 5, 6, 7])
prod = produto_escalar(a, b)
print(prod)    

Produto interno

a = [1, 2, 3, 4, 5]
b = [3, 4, 5, 6, 7]

sum = 0
for i in range(len(a)):
    sum += a[i] * b[i]
print(sum)

Produto interno pythonic

a = [1, 2, 3, 4, 5]
b = [3, 4, 5, 6, 7]

sum = 0
for ai, bi in zip(a, b):          
    sum += ai*bi
print(sum)

Produto interno numpy

import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array([3, 4, 5, 6, 7])

print(a*b)
print(np.sum(a * b))
print(a @ b)

Produto interno álgebra linear

import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array([3, 4, 5, 6, 7])

print(a @ b)
print(np.dot(a, b))

Polinômios

1. p[0] * x**n + p[1] * x**(n-1) + … + p[n-1]*x + p[n]
2. np.poly1d()
3. np.roots()

import numpy as np
p = np.poly1d([1, 0, 1])        # definir um polinômio em uma 
print(np.roots(p))

Diferenças finitas

Definição, derivada em $x$

$$\dfrac{\mathrm{d} v}{\mathrm{d} x} ≈ \dfrac{v(x + Δ x) - v(x)}{Δ x}$$

Supor $v(x)=sin(x)$

import numpy as np

x = np.linspace(0, 2*np.pi, 10)
v = np.sin(x)

Dx = 2*np.pi/9
dvdx = []
for vi_Dx, vi in zip(v[1:], v[:-1]):
    dvdx.append((vi_Dx - vi)/Dx)

import numpy as np

x = np.linspace(0, 2*np.pi, 10)
y = np.sin(x)
dy_analy = np.cos(x)

dy_numer = [0.0]*len(x)         # criando uma lista com tamanho certo

for i in range(len(y) - 1):
    dy_numer[i] = (y[i+1] - y[i])/(x[i+1] - x[i])

dy_numer[-1] = (y[-1] - y[-2])/(x[-1] - x[-2])  # o ultimo termo

Integral

import numpy as np
import matplotlib.pyplot as plt

x = np.array([0, 0.5, 1, 1.5, 2])  # Conjunto de dados com 5 pontos
y = np.array([0, .125, 1, 3.375, 8])

plt.plot(x, y, 'x')
plt.show()

Exercício

Resolver a integral pela regra trapezoidal:

$$∫ ≈ ∑ \dfrac{f(x) + f(x + Δ x)}{2} Δ x $$

x = np.array([0, 0.5, 1, 1.5, 2]) y = np.array([0, .125, 1, 3.375, 8])

Resposta

import numpy as np

x = np.array([0, 0.5, 1, 1.5, 2])
y = np.array([0, .125, 1, 3.375, 8])

intg = 0
for k in range(len(x) - 1):
    intg += .5 * (y[k] + y[k+1]) * (x[k+1] - x[k])
print(intg)

Integral

import numpy as np

x = np.array([0, 0.5, 1, 1.5, 2])  # Conjunto de dados com 5 pontos
y = x**3                        # integral x4/4 0 a 2 = 4

integral = np.trapz(y, x)

error = (integral - 4)/4

print('Resultado {:.3f} com erro {:.3f}%'.format(integral, error*100))

Matplotlib

O que é?

1. Biblioteca para plotar gráficos 2D (principalmete)
2. Pode ser usada de duas maneiras
   1. Pyplot –> módulo equivalente ao Matlab
   2. OOP –> “pythonic way”

Pyplot interface: Matlab equilavente

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
y2 = np.cos(x)
plt.plot(x, y, '--r', label='sen(x)')
plt.plot(x, y2, ':', label='cos(x)')
plt.xlabel(r'Eixo $x$')
plt.ylabel('Eixo y')
plt.legend()
plt.show()

Exercício

Plotar:

$f(x) = 3 cos(5x + π/2) + cos(4 π/5)$

np.linspace(0, 2 * np.pi) plt.plot(x, y) plt.legend() plt.show()

Exercício solução

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2*np.pi, 100)
y = 3*np.cos(5*x + np.pi/2) + np.cos(4*np.pi/5)
plt.plot(x, y, '-r', label='Exercicio')            # Cria Figure e Axes

# Configurações
plt.xlabel('x Axis')            # Usa o Axes atual
plt.ylabel('y Axis')
plt.title('Plot do Exercício')
plt.xlim(0, 2*np.pi)
plt.grid(alpha=.5)
# plt.ylim(-2, 2)
plt.legend(loc=2)          # lista de strings
plt.show()

Plot de Iso-linhas usando o módulo Pyplot

1. $z(x, y) = sin(x)² + sin(y)²$

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 50)      # 1D array
y = np.linspace(0, 10, 50)      # 1D array
X, Y = np.meshgrid(x, y)        # 2D array

Z = np.sin(X)**2 + np.sin(Y)**2 # Valor em cada ponto do plano (x,y)

c = plt.contourf(X, Y, Z)
plt.contour(X, Y, Z)
cbar = plt.colorbar(c)
cbar.set_label('label')

# Configurações
plt.xlabel('x Axis')
plt.ylabel('y Axis')
plt.title('Plot')
plt.show()

#+RESULTS:[[  0.    2.5   5.    7.5  10. ]
 [  0.    2.5   5.    7.5  10. ]
 [  0.    2.5   5.    7.5  10. ]
 [  0.    2.5   5.    7.5  10. ]
 [  0.    2.5   5.    7.5  10. ]] [[  0.    0.    0.    0.    0. ]
 [  2.5   2.5   2.5   2.5   2.5]
 [  5.    5.    5.    5.    5. ]
 [  7.5   7.5   7.5   7.5   7.5]
 [ 10.   10.   10.   10.   10. ]]

Exercício

Definir a função:

$f(x, y) = \left(1 - \dfrac{x}{2} + x⁵ + y³ \right) \mathrm{e}^{-x^{2} - y^2}$

1. plotar usando plt.contourf() com 8 níveis
2. plotar usando plt.contour() com 8 níveis
3. criar os labels dos níveis plt.clabel()
4. criar color bar com plt.colorbar()

3 Dimensões - 2D arrays

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x = np.linspace(0, 1, 10)
y = np.linspace(-2, 1, 10)

X, Y = np.meshgrid(x, y)        # 2D arrays
Z = (X - 3)**2 + (Y + 1)**2     # Função do espaço (x, y)

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis')  # Cria superfície
plt.show()

3 Dimensões Exemplo - 1D arrays

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

n_angles = 36
n_radii = 8

radii = np.linspace(0.125, 1.0, n_radii)  # raios
angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)  # ângulos

angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)

x = np.append(0, (radii*np.cos(angles)).flatten())
y = np.append(0, (radii*np.sin(angles)).flatten())

z = np.sin(-x*y)                # multiplicação termo a termo

fig = plt.figure()
ax = Axes3D(fig)
ax.plot_trisurf(x, y, z, cmap='viridis')  # Cira superfície
plt.show()

Vantagem da abordagem OOP

1. Flexibilidade
2. Passar axes para funções

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 50)
y = np.sin(x)

fig = plt.figure()              # Pyplot para criar Figure

ax1 = fig.add_axes([.1, .1, .8, .8])
ax2 = fig.add_axes([.2, .55, .3, .3])

ax1.plot(x, y, '-r')
ax2.plot(x, y, '-b')
ax2.set_facecolor('green')
ax2.set_xlim(0, 1)              # Um detalhe
plt.show()

Mayavi

from numpy import linspace, meshgrid, pi, sin, cos

m0 = 4; m1 = 3; m2 = 2; m3 = 3; m4 = 6; m5 = 2; m6 = 6; m7 = 4;

phi = linspace(0, pi)
theta = linspace(0, 2*pi)
phi, theta = meshgrid(phi, theta)
r = sin(m0*phi)**m1 + cos(m2*phi)**m3 + sin(m4*theta)**m5 + cos(m6*theta)**m7

x = r*sin(phi)*cos(theta)
y = r*cos(phi)
z = r*sin(phi)*sin(theta)

from mayavi import mlab
s = mlab.mesh(x, y, z)
mlab.show()

Dia 4

Matplotlib Continuação

Plot histograma

1. Dados aleatórios np.random.normal()
2. plotar histograma de frq. abs e rel com plt.hist()
3. checar se os dados seguem distribuição normal stats.mstats.normaltest()
4. plotar distribuição normal com stats.norm.pdf(x, loc, scale)

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

rv = np.random.uniform(size=1000)  # qualquer dado!
weight = np.ones_like(rv)/float(len(rv))  # freq relativa
plt.hist(rv, bins=10, weights=weight)


plt.show()

Nota: p-value é a probabilidade de que o valor do chi-quadrado

Conceitos gerais matplotlib OOP API

1. Hierarquia

Criar Figure e Axes

1. plt.figure() e .add_axes()
2. plt.subplots()

import numpy as np
import matplotlib.pyplot as plt  # Usa o pyploy para criar o obj Figure apenas!

fig, ax = plt.subplots()
fig.set_facecolor('grey')
ax.set_facecolor('yellow')
plt.show()

Figure contém os Axes filhos

1. .add_axes() [ x_lowerleft, y_lowerleft, comprimento, altura]
2. plt.subplots(nrows, ncols)

import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots(nrows=2, ncols=2)
plt.show()

E onde vejo os dados?

1. Tudo que se vê dentro de um gráfico é chamado de Artist
2. Os Artist são criados por métodos do objeto Axes

Criando Artists

1. subplots retorna 1 objeto axes ou um array de axes
2. fig.tight_layout()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 50)
y = np.sin(x)

fig, ax = plt.subplots()

plt.show()

Exercício

Fazer uma função que criar o gráfico da função sen(x) no intervalo especificado.

1. A função recebe o objeto axes e o intervalo
2. Criar uma figura com 2 axes, um do lado do outro com plt.subplots()
3. plotar sen(x) nos intervalo [0, 2 pi] e [3pi/2, 3.5pi/2]

Ler e escrever arquivos

1. Criar um arquivo de textos
2. Usar open() com ‘r’ e ‘w’
3. Fechar com método .close()

file_handle = open('nome do arquivo', 'r')  # r de read já é DEFAULT
file_handle.close()

Abrir arquivos alternativa Pythonica

with open('filename', 'r') as file_handle:
    data = file_handle.read()
    print(data)

Pandas

O que é?

Biblioteca que cria

1. Estruturas baseadas em arrays: Series (1d) e DataFrames (2d)
2. ferramentas de input e output de dados
3. No que ele é bom: limpar dados de forma automatizada

Series

1. 1D arrays rotulados
2. data: dicionário, numpy array, lista ou escalar
3. index: o rótulo (flexível!)

import pandas as pd

data = [20, 30, 40]
s = pd.Series(data, index=['a', 'b', 'c'])
print(s['a':'b'])

O que é um dataframe?

1. 2D arrays rotulados
2. data: 2d numpy array, dicionáio de: 1D arrays, listas, Series
3. columns, index

import pandas as pd
import numpy as np

dic = {'cidade': ['brasilia', 'sao paulo', 'rio de janeiro'],
       'num de viagens': [1e5, 25e7, 13e6]}
df = pd.DataFrame(dic, index=['a', 'b', 'c'])
print(df)

Exercício

Criar um data frame usando np.random.rand(5, 6) Criar nome paras colunas: list('ABCDEF')

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(5, 6), columns=list('ABCDEF'))
print(df.describe)

Extract data

1. df[‘A’] - coluna
2. df[‘a’:’c’] - slicing de linha (pode usar int também)
3. df.loc[label linha, [label colunas]] - selecionar por label (rótulo)
4. df.iloc[index linha, index colunas] - selecionar por posição igual numpy
5. df.at[linha, col] semelhante ao loc mas mais rápido

import pandas as pd

dic = {'cidade': ['brasilia', 'sao paulo', 'rio de janeiro', 'curitiba'],
       'num de viagens': [3e6, 25e6, 13e6, 2e6]}

df = pd.DataFrame(dic)
print(df.iloc[0])

Boolean index

1. df[df > 1] - todos os valores > 1
2. df[df[‘A’] > 1] - condição apenas na col A

import pandas as pd
import numpy as np

data = np.array([[0.4, -.2, -1.5], [1.2, .17, .11], [.7, 1, .62], [.2, .54, 1], [.4, .23, .8]])

df = pd.DataFrame(data, columns=['A', 'B', 'C'], index=list('abcde'))
print(df[df < 1])

Load data

1. df = pd.read_csv(), df = pd.read_excel(), df = pd.read_table()
2. header, names, sep

import pandas as pd

df = pd.read_csv('data.csv', sep=';', names=list('ABC'))
print(df)

Describe

1. mean(), std()
2. describe()

import pandas as pd
import numpy as np

data = np.array([[0.4, -.2, -1.5], [1.2, .17, .11], [.7, 1, .62], [.2, .54, 1], [.4, .23, .8]])

df = pd.DataFrame(data, columns=['A', 'B', 'C'], index=list('abcde'))
print(df.describe())

Operações básicas

1. +, -, *, / - termo a termo
2. somar colunas - df1.A = df1.A + df2.A
3. somar células - df1.loc['a', 'A'] = df1.A[0] + df2.A[0]
4. .dropna(), .fillna() .drop(label, axis)
5. .append(ignore_index=True)

import pandas as pd
import numpy as np

np.random.seed(100)
df1 = pd.DataFrame(np.random.randn(5,3), columns=['A', 'B', 'C'], index=list('abcde'))

np.random.seed(200)
df2 = pd.DataFrame(np.random.randn(5,3), columns=['A', 'B', 'C'], index=list('abcde'))

Sympy

Integration

1. sp.integrate(f, x)
2. sp.integrate(f, (x, 0, 1))
3. .evalf(2) - aproximação numérica
4. .subs({x: 2})

import sympy as sp

x = sp.Symbol('x')
f = 4*x/(sp.pi*(1+x**2))
print(f)
print(sp.integrate(f, x))

Derivative

import sympy as sp

x = sp.Symbol('x')
f = sp.pi*x**2
sp.pprint(sp.diff(f, x))

Pytest

1. Test driven development

Outros

Resultado

class ContaBancaria:
    def __init__(self, saldoinicial):
        self.balanco = saldoinicial

    def saque(self, quantia):
        self.balanco -= quantia

    def deposito(self, quantia):

        self.balanco += quantia

conta_da_maria = ContaBancaria()
conta_da_maria.deposito()
conta_da_maria.saque(2.5)
print(conta_da_maria.balanco)

Integral

import numpy as np
import matplotlib.pyplot as plt

x = np.array([0, 0.5, 1, 1.5, 2])
y = x**3

x2 = np.linspace(0, 2, 50)
y2 = x2**3

plt.plot(x, y, '--x', label='5 pontos')
plt.plot(x2, y2, label='50 pontos')
plt.legend()

Problema

M = np.zeros((3,3))
print(M)
gl = [0, 2]

m = np.array([[10, 11], [12, 13]])
print(m)

Problema solução bruta

M = np.zeros((3,3))
gl = [0, 2]
m = np.array([[10, 11], [12, 13]])

for i in range(len(gl)):        # loop em 0 e 1
    for j in range(len(gl)):    # loop em 0 e 1
        M[gl[i], gl[j]] = m[i, j]

print(M)

Problema pythonic

M = np.zeros((3,3))
gl = [0, 2]
m = np.array([[10, 11], [12, 13]])

id = np.ix_(gl, gl)             # array (2, 1) e (1, 2)
print(id)

M[id] = m
print(M)