# EXERCICIO e os códigos a serem completados estão marcados pelos comentários <COMPLETAR>.
In [4]:
x = 10 # x é um inteiro
print type(x)
x = 1.3 # x é um ponto flutuante
print type(x)
x = "Ola" # x é uma string
print type(x)
x = [1, 5, 10] # x é uma lista
print type(x)
In [5]:
x = 10
for i in range(20):
# Início da repetição For
x = x + 1
if x%2 == 0:
# Instrução se condição verdadeira
x = x + 1
else:
# Instrução se a condição for falsa
x = x + 2
# Fim do bloco de repetição For
print x # Isso está fora do for! Boa Ideia!
In [8]:
def Soma(x,y):
return x+y
def Mult(x,y):
return x*y
def SomaMult(x,y):
return x+y, x*y # múltiplas saídas separadas por vírgula
print Soma(10,2), Mult(100,2), SomaMult(10,2)
# O retorno de múltiplas saídas podem ser atribuídas diretamente para múltiplas variáveis
w,z = SomaMult(100,2)
print w, z
list), tupla (tuple) e dicionários (dict).
In [16]:
lista = [1, 2, True, "palavra"]
tupla = (1, 2, True, "palavra")
lista[1] = 3.0
print lista
In [17]:
tupla[1] = 3.0 # Vai dar erro!
In [9]:
# range(n) gera uma lista de valores entre 0 e n-1
# len(lista) retorna o tamanho de uma lista
def DobraValores(lista):
for i in range(len(lista)):
lista[i] = lista[i]*2
return lista
lista = [1,2,3,4]
lista2 = DobraValores(lista)
print lista, lista2 # As listas são passadas como referência para as funções
In [12]:
dicionario = { "Ana":12, "Joao":13, "Jose":17 } # declaração inicial do dicionário, pode ser {} para dic. vazio
print dicionario["Ana"] # acesso ao elemento pela chave entre colchetes
dicionario["Maria"] = 11 # podemos alterar ou inserir um novo elemento
print dicionario
print "As chaves do dicionário são: ", dicionario.keys()
print "Os valores do dicionário são: ", dicionario.values()
In [14]:
lista = range(10) # gera a lista [0,..,9]
print 8 in lista, 12 in lista
for x in lista:
print x
In [2]:
# Jeito tradicional, mas não otimizado
listaOriginal = [1,2,3,4,5,6,7,8,9]
listaQuadrada = []
for x in listaOriginal:
listaQuadrada.append(x*x)
print listaQuadrada
# Através do List Comprehension
listaQuadrada = [ x*x for x in listaOriginal ]
print listaQuadrada
In [5]:
listaQuadrada = ( x*x for x in listaOriginal )
print listaQuadrada # os elementos ainda não foram calculados
for x in listaQuadrada:
print x # a cada iteração apenas o próximo elemento é calculado, a lista não existe na memória
In [7]:
import os.path
caminho = os.path.join('Data','Aula01') # garante o uso correto de / ou \\ para diretórios
arquivo = os.path.join(caminho,'exemplo.txt')
f = open(arquivo)
for linha in f:
print linha
f.close()
ndarray contendo os elementos [1, 2, 3] e multiplique essa array por 5. Use o comando np.array() para criar a array. Note que um dos possíveis parâmetros para essa função é ums lista do Python. A multiplicação escalar pode ser feita utilizando o operador *.
In [9]:
# Como convenção importaremos a biblioteca numpy como np
import numpy as np
In [10]:
# EXERCICIO
# Crie uma array numpy com os valores 1, 2, 3
arraySimples = [1,2,3]
# Faça o produto escalar multiplicando a array por 5
vezesCinco = np.multiply(arraySimples, 5)
print arraySimples
print vezesCinco
In [12]:
# TESTE do exercício (2a)
assert np.all(vezesCinco == [5, 10, 15]), 'valor incorreto para vezesCinco'
print "Correto!"
* para multiplicar dois vetores ou matrizes, ele executará a multiplicação elemento-a-elemento. Para realizar o produto interno você pode utilizar tanto a função np.dot() ou ndarray.dot(). Ex.: dados os vetores $x$ e $y$ pode realizar a operação como np.dot(x,y) ou x.dot(y).
In [15]:
# EXERCICIO
# A função np.arange(inicio,fim,passo) cria uma lista iniciando em inicio, terminando antes do fim seguindo passo
u = np.arange(0, 5, .5) # np.array([0,0.5,1.0,...,4.5])
v = np.arange(5, 10, .5)
elementoAelemento = u * v
prodInterno = np.dot(u, v)
print 'u: {0}'.format(u)
print 'v: {0}'.format(v)
print '\nelementoAelemento\n{0}'.format(elementoAelemento)
print '\nprodInterno\n{0}'.format(prodInterno)
In [16]:
# TESTE do exercício (2b)
assert np.all(elementoAelemento == [ 0., 2.75, 6., 9.75, 14., 18.75, 24., 29.75, 36., 42.75]), "Valores incorretos para elementoAelemento"
print "Primeiro teste OK"
assert prodInterno==183.75, "Valor incorreto para prodInterno"
print "Segundo teste OK"
np.matrix() quando queremos criar uma matriz a partir de listas do Python. Com esse tipo podemos utilizar o operador * para multiplicação de matrizes, np.multiply() para multiplicação elemento-a-elemento, np.matrix.transpose() ou .T para calcular a transposta e np.linalg.inv() para calcular a inversa de uma matriz quadrada.
In [43]:
# EXERCICIO
from numpy.linalg import pinv # agora podemos utilizar o comando inv() sem preceder com np.linalg
# Criar uma matriz com listas de listas
A = np.matrix([[1,2,3,4],[5,6,7,8]])
print 'A:\n{0}'.format(A)
# Imprima a matriz transposta
print '\nA transposta:\n{0}'.format(np.matrix.transpose(A))
# Multiplique A por sua Transposta
AAt = np.dot(A, np.matrix.transpose(A))
print '\nAAt:\n{0}'.format(AAt)
# Inverta AAt com o comando inv()
AAtInv = pinv(AAt)
print '\nAAtInv:\n{0}'.format(AAtInv)
# Mostre que a matriz vezes sua inversa é a identidade
# .round(n) arredonda os valores para n casas decimais
print '\nAAtInv * AAt:\n{0}'.format((np.multiply(AAt,AAtInv)).round(4))
In [44]:
# TESTE do exercício (2c)
assert np.all(AAt == np.matrix([[30, 70], [70, 174]])), "Valores incorretos para AAt"
print "Primeiro teste OK"
assert np.allclose(AAtInv, np.matrix([[0.54375, -0.21875], [-0.21875, 0.09375]])), "Valor incorreto para AAtInv"
print "Segundo teste OK"
v[:10] seleciona os 10 primeiros elementosv[2:] seleciona os elementos da terceira posição em diantev[-5:] retorna os 5 últimos elementosv[:-5] retorna os elementos do começo até o ultimo-5v[1:3] retorna os elementos 1 e 2
In [45]:
# EXERCICIO
atributos = np.array([1, 2, 3, 4])
print 'atributos:\n{0}'.format(atributos)
# Crie uma array com os 3 últimos elementos de atributos
ultTres = atributos[-3:]
print '\nÚltimos três:\n{0}'.format(ultTres)
In [46]:
# TEST do exercício (2d)
assert np.all(ultTres == [2, 3, 4]), "Valores incorretos para ultTres"
print "Teste OK"
lambda seguido da lista de parâmetros de entrada, precedidos por : e a expressão a ser executada. Por exempo, lambda x, y: x + y é uma função anônima que calcula a soma de dois valores.
In [5]:
# EXERCICIO
# Lembre-se que: "lambda x, y: x + y" cria uma função que adiciona dois valores
mult10 = lambda x : x*10
print mult10(5)
# Note that the function still shows its name as <lambda>
print '\n', mult10
In [6]:
assert mult10(10)==100, "Função incorreta"
print "Teste OK"
In [8]:
import numpy as np
p1 = (1,3)
p2 = (3,7)
euclidiana2D = lambda (x0,y0), (x1,y1): np.sqrt(((x0-x1)**2) + ((y0-y1)**2)) # sqrt é a raíz quadrada
print euclidiana2D(p1,p2)
In [9]:
# Lógica não-funcional
a = 0
def inc():
global a
a = a + 1
# Lógica funcional
def incFn(a):
return a+1
In [12]:
# Função para somar 3 valores
def Soma3(a,b,c):
return a+b+c
# Função que soma apenas dois valores
def Soma2(a,b):
return a+b
# Soma 3 poderia ser criado a partir de Soma2:
Soma3Fn = lambda a,b,c: Soma2(Soma2(a,b),c)
In [14]:
# Cria uma função que calcula a eq. do segundo grau no formato ax^2 + bx + c
def Eq2grau(a,b,c):
def f(x):
return a*x**2 + b*x + c
return f
f = Eq2grau(10,2,1)
print f(10)
In [15]:
# EXERCICIO
# Escreva uma função Soma(x) que retorna uma função que recebe um valor y e soma ao x.
def Soma(x):
def f(y):
return x+y
return f
Soma2 = lambda a,b: Soma(a)(b)
Soma3 = lambda a,b,c: Soma(Soma(a)(b))(c)
print Soma2(1,3), Soma3(1,2,3)
In [16]:
assert Soma3(1,2,3)==6, "Erro na função"
print "Ok"
f e uma lista l.l em que a aplicação de f returna TrueFuncionalW para criar uma sintaxe parecida com a que utilizaremos com o Spark.
In [17]:
class FuncionalW(object):
def __init__(self, data):
self.data = data
def map(self, function):
"""Call `map` on the items in `data` using the provided `function`"""
return FuncionalW(map(function, self.data))
def reduce(self, function):
"""Call `reduce` on the items in `data` using the provided `function`"""
return reduce(function, self.data)
def filter(self, function):
"""Call `filter` on the items in `data` using the provided `function`"""
return FuncionalW(filter(function, self.data))
def __eq__(self, other):
return (isinstance(other, self.__class__)
and self.__dict__ == other.__dict__)
def __getattr__(self, name): return getattr(self.data, name)
def __getitem__(self, k): return self.data.__getitem__(k)
def __repr__(self): return 'FuncionalW({0})'.format(repr(self.data))
def __str__(self): return 'FuncionalW({0})'.format(str(self.data))
In [22]:
# Exemplo de Map
# Criaremos uma lista
lista = FuncionalW(range(10))
# Criar uma função a ser aplicada nessa lista
f = lambda x: x*x
# Programação Imperativa
resultado1 = FuncionalW([])
for x in lista:
resultado1.append(f(x))
print "Resultado: {}".format(resultado1)
# Funcional
print "Resultado usando Map: {}".format(lista.map(f))
In [23]:
# Exemplo de Reduce
# Criaremos uma lista
lista = FuncionalW(range(1,10))
# Criar uma função a ser aplicada nessa lista
f = lambda x,y: x*y
# Programação Imperativa
produtoria = 1
for x in lista:
produtoria = f(produtoria,x)
print "Resultado: {}".format(produtoria)
# Funcional
print "Resultado usando Reduce: {}".format(lista.reduce(f))
In [34]:
# EXERCICIO
dataset = FuncionalW(range(10))
# Multiplique cada elemento por 5
mapResult = dataset.map(lambda x : x*5)
# Filtre eliminando os elementos ímpares
# No Python "x % 2" é o resultado do resto da divisão de x por 2
filterResult = dataset.filter(lambda x: x % 2 == 0)
# Some os elementos
reduceResult = dataset.reduce(lambda x, y : x+y)
print 'mapResult: {0}'.format(mapResult)
print '\nfilterResult: {0}'.format(filterResult)
print '\nreduceResult: {0}'.format(reduceResult)
In [35]:
assert mapResult == FuncionalW([0, 5, 10, 15, 20, 25, 30, 35, 40, 45]),"Valor incorreto para mapResult"
print "Teste 1 OK"
assert filterResult == FuncionalW([0, 2, 4, 6, 8]), "Valor incorreto para filterResult"
print "Teste 2 OK"
assert reduceResult == 45, "Valor incorreto para reduceResult"
print "Teste 3 OK"
In [37]:
dataset = FuncionalW(range(10))
Soma = (dataset
.map(lambda x: x*5)
.filter(lambda x: x%2==0)
.reduce(lambda x,y: x+y)
)
print Soma
In [43]:
# EXERCICIO
# split() divide a string em palavras
Texto = FuncionalW("Esse texto tem varias palavras cada linha tem palavras escritas Esse texto esta escrito".split())
# Vamos fazer uma contagem da palavra 'palavras' no texto
# Crie uma função lambda que recebe duas entradas e retorna se são iguais ou não
Igual = lambda x,y: x == y
# Crie uma função lambda que utiliza a função Igual para detectar se a entrada é igual a palavra 'palavras'
DetectaPalavra = lambda x: Igual(x,"palavras")
# 1) Filtre as palavras iguais a 'palavras'
# 2) Mapeie todos os elementos para o valor 1
# 3) Reduza para a somatória
contagem = (Texto
.filter(DetectaPalavra)
.map(lambda x: 1)
.reduce(lambda x,y : x + y)
)
print "Existem {} ocorrências de 'palavras'".format(contagem)
In [ ]:
In [ ]: