Laboratórios
(A matéria da P1 está na caixa pontilhada)
1a) Escreva uma classe para manipular objetos
Fração (números
racionais da forma n/d).
A sua classe deve fazer a sobrecarga dos operadores, +, +=,
*, -, /, //, ==, e print.
O operador de igualdade deve simplificar as frações antes de
compará-las (use o MDC).
Levante uma exceção se algum operador for aplicado a um tipo
inválido, ou se for construída uma fração com denominador
nulo.
Implemente os operadores __radd__, __rsub__, __rmul__,
__rdiv__, __rtruediv__ e __rfloordiv__,
para inverter os operadores quando um inteiro estiver à
esquerda do operador: e.g., 2 + Fraction(2,3).
u+v, é traduzido para u.__add__(v)
Se u for um int ou float, nesse caso, é gerada uma
exceção NotImplemented, e o Python a traduz para
type(v).__radd__(v,u)
def __radd__(self, f): return self + f
Nota: os operadores aritméticos não imprimem
coisa alguma, mas apenas retornam objetos
Fracao (que não são listas!!).
1b) Escreva uma classe
Agenda para
criar objetos do tipo livro de endereços.
Utilize um dicionário para associar o nome de um contato a
sua lista de telefones.
Assuma que cada contato possa ter mais de um telefone, e
crie os seguintes métodos:
def __init__(self):
def putPhone(self, name, lista):
def getPhone(self, name, index):
def remContact(self, name):
def __eq__(self, other):
def __str__(self):
def __repr__(self):
def main ():
Nota: tanto repr() como str() não imprimem
coisa alguma, mas apenas retornam uma representação
na forma de uma string.
repr() → formato "%r" → retorna a
representação "oficial" de um objeto
(a representação com a informação completa sobre o objeto):
4b) Escreva um programa que leia um arquivo texto e diga quantas
linhas, letras, bytes, frases, sentenças e palavras existem no
texto. Assuma que sentenças são terminadas pelos caracteres '.',
'?' ou '!'.
4c) Inclua no programa anterior, uma lista de parágrafos
(strings). Ao final, ordene esta lista e imprima os parágrafos
em ordem lexicográfica.
- Adicione uma imagem à sua interface na forma de um label.
global soldier # segura a imagem na memória
soldier = PhotoImage(file='Roman_Soldier.gif')
soldier = soldier.subsample(4, 4) # reduza a imagem por um fator 4
label = Label(master,image=soldier)
Conversão romano ↔ decimal.
Conversão no iphone.
5b) Faça um programa para executar o dns reverso de um dado IP.
Dicas:
Instale o módulo dnspython.
Crie uma interface Tk adequada.
Trate a exceção gerada caso a "query" não consiga determinar
o nome do computador corretamente.
>>> import dns.resolver
>>> import dns.reversename
>>> for a in dns.resolver.query(dns.reversename.from_address('81.200.68.204'), 'PTR'):
... print a
...
www.nominum.com.
DNS Reverso
5c) Faça um programa para desenhar a função sinc(x) =
sin(x)⁄x , usando o componente Canvas do
Tkinter.
Dicas: por L'Hôpital:
lim sin(x)⁄x = 1.
x → 0
Use um canvas [2vx × 2vy] = [512 ×
256]: c = Canvas(top, width=2*vx, height=2*vy); c.pack(expand=True,
fill="both")
Mapeie o espaço de coordenadas do canvas xc ∈
[-vx,vx], no espaço de coordenadas da
função x ∈ [-15π,15π],
através de uma simples regra de três:
(xc + vx ) / 2vx = (x +
15π) / 30π
x = 15π * xc ⁄ vx , x
c
∈ [-vx,vx] (1)
Mapeie o espaço de coordenadas da função y ∈ [0,1] no espaço de
coordenadas do canvas yc ∈ [vy,0]
(lembre-se que o eixo yc cresce para baixo):
(yc - vy) / -vy = (y -
0) / 1 = sin(x)⁄x
yc = int (-sin(x)⁄
x
* vy + vy) (2)
Note que, para centrar a janela, devemos:
aplicar uma translação vx às coordenadas
xc: xc+vx
ou mapear diretamente para o intervalo [0,30π].
Conecte pares de coordenadas
(xc+vx,yc) adjacentes, usando o
método create_line do objeto canvas:
Para cada pixel (xc,0) na linha de
(-vx,0) até (vx,0), calcule a
coordenada x correspondente usando a eq.
(1),
e obtenha a coordenada yc correspondente, a
partir da avaliação da funçao
sin(x)/x aplicada à eq. (2).
Coloque então os pares de coordenadas criadas, numa
lista de pontos: pts +=
[xc+vx,yc]
Chame
c.create_line(*pts, fill="red", width=3), onde pts é a lista com as coordenadas dos pontos do
gráfico.
Para redimensionar o desenho em função das dimensões da janela,
use os métodos canvas.winfo_width() e
canvas.winfo_height(), para obter o tamanho da janela do canvas.
Em seguida, associe um método ao evento de redimensionamento
da janela do canvas:
def resize(e):
canvas.delete(ALL) # apaga todos os elementos do canvas
vx = canvas.winfo_width() // 2
vy = canvas.winfo_heigh() // 2
..... # redesenha o gráfico com os novos tamanhos da janela
....
canvas = Canvas(top, width=vx*2, height=vy*2)
canvas.pack(side='left', expand=YES, fill=BOTH)
canvas.bind("⟨Configure⟩", resize)
- Adicione uma imagem à sua interface na forma de um label.
global soldier # segura a imagem na memória
soldier = PhotoImage(file='Optimus.gif')
soldier = soldier.subsample(8, 8) # reduza a imagem por um fator 8
label = Label(master,image=soldier)
5e) Implemente uma interface gráfica para converter números
decimais reais para o formato binário em ponto flutuante
utilizado pelas CPUs modernas - IEEE 754 (32 bits).
A conversão de um número numa base qualquer para decimal é
feita considerando-se o valor posicional de cada dígito do
número, por exemplo:
No padrão IEEE 754, o sinal é armazenado no bit 32.
O expoente é calculado a partir dos bits 24-31 subtraindo-se
127 (bias).
os expoentes devem estar no intervalo [-127, 128]
que é mapeado para o intervalo [0, 255].
números válidos possuem expoentes no intervalo
[-126, 127].
A mantissa (também conhecida como significando ou fração)
está armazenada nos bits 1-23.
Um bit invisível (ou seja, não armazenado explicitamente)
com valor 1(.0) é "imaginado" à frente da mantissa.
Logo, o bit 23 vale 1/2 (0.1 em binário), bit 22 vale 1/4
(0.01 em binário), etc.
Assim, a mantissa possui um valor entre 0.0 e 1.0
desnormalizada ou entre 1.0 e 2.0, normalizada
(considerando-se o bit invisível).
Se o exponente for menor ou igual a -126 (mapeado em
00000000), o bit 1 (invisível) não é mais usado para
possibilitar um underflow gradual.
Infinito é representado por um expoente igual a 128 e
mantissa nula.
Qualquer coisa com expoente igual a 128 e mantissa não nula,
não é um número (NaN).
Exemplos:
1.00000000000000000000001E-127 = 5.87747245476067E-39 deve
ser escrito como:
0.10000000000000000000000E-126. Neste caso, diz-se
que o número está desnormalizado.
Assim, o menor número representável é:
0.00000000000000000000001E-126 = 1.0E-149 (em
binário) = 1.40129846432482E-45 (em decimal)
-9.125 = -1001.001 = -1.001001 × 2³ em binário
= 1 10000010 00100100000000000000000 em ponto
flutuante IEEE 754
1 bit de sinal = negativo = 1
8 bits de expoente [-127,128] mapeado em [0,255] =
127+3 = 130 = 10000010
23 bits de mantissa = 001001 =
00100100000000000000000
329.390625 = 101001001.011001 = 1.01001001011001
× 2⁸ em binário = 0 10000111
01001001011001000000000 em ponto flutuante IEEE 754
1 bit de sinal = positivo = 0
8 bits de expoente [-127,128] mapeado em [0,255] =
127+8 = 135 = 10000111
23 bits de mantissa = 01001001011001 =
01001001011001000000000
4.4081038E-39 = 1.1 × 2⁻¹²⁸ = 0.011 ×
2⁻¹²⁶ em binário = 0 00000000 0110000000000000000000
em ponto flutuante IEEE 754
1 bit de sinal = positivo = 0
8 bits de expoente [-127,128] mapeado em [0,255] =
00000000 (-128 < -126 ⇒ desnormalizado)
23 bits de mantissa = 011 =
0110000000000000000000
Obs: Erros de arrendondamento
- Nem todo número decimal pode ser expresso exatamente como um
número em ponto flutuante.
- Isto pode ser visto considerando-se o número "0.1" e
examinando-se a sua representação binária,
que pode ser tanto ligeiramente menor ou maior, dependendo do
último bit.
Dicas:
- A implementação não deve mover nunca um número em ponto flutuante
para um inteiro, porque haverá perda de precisão.
- Use uma função mod (resto) que aceite argumentos em ponto
flutuante e retorne um valor em ponto flutuante,
que neste caso, será um resto de 1 dígito e poderá ser transformado
em inteiro sem problema.
em C, é a função
fmod,
e em Java, o operador % já aceita argumentos
float/double.
- Use funções que retornem a parte inteira e fracionária de um
número em ponto flutuante, na forma de números em ponto flutuante.
8a) Escreva uma classe que implemente um relógio digital. A classe
possui três métodos a saber:
Relógio Digital e Cronógrafo
from tkinter import *
from threading import Thread
import time
class digitalClock:
#
# Constructor.
#
# @param clock a label to display the time.
# @param secs number of seconds for time regressive counting.
# @param time string for initializing the time. Just leave the default.
#
#
def __init__(self, clock, secs=0, time=''):
...
#
# Updates the clock display.
#
def tick(self):
...
...
# calls itself every 1000 milliseconds
# to update the time display as needed
self.clock.after(1000, self.tick)
#
# Starts a count down from the number of seconds set to zero.
#
def tickDown(self):
...
## Creates a new thread.
class makeThread (Thread):
## Constructor.
#
# @param func function to be executed in this thread.
#
def __init__(self, func):
Thread.__init__(self)
self.__action = func
self.debug = False
## Obejct destructor.
# In Python, destructors are needed much less, because Python has
# a garbage collector that handles memory management.
# However, there are other resources to be dealt with, such as:
# sockets and database connections to be closed,
# files, buffers and caches to be flushed.
#
def __del__(self):
if (self.debug):
print ("Thread end")
## Method representing the thread's activity.
# This method may be overriden in a subclass.
#
def run(self):
if (self.debug):
print ("Thread begin")
self.__action()
Dicas:
Use a função strftime('%H:%M:%S') do módulo
time
para obter a hora atual.
Use o método after, presente em todo widget do tkinter,
para atualizar o tempo corrente a cada 1000 ms.
Para poder usar o relógio em uma outra aplicação, dispare uma
thread para executar o relógio.
Essa thread deve rodar na thread principal, aquela que contém o mainloop.
Adicione o relógio à interface do exercício 5c), que desenha a
função sinc(x).
8b) Escreva um programa usando o componente Canvas do TkInter,
para desenhar um relógio, cujos ponteiros podem ser quatro tipos
de curvas.
Obs: clicando-se o botão esquerdo do mouse sobre o
relógio deve permitir alterar a forma dos ponteiros e o botão do
meio, a largura.
Isto requer o uso de uma thread separada para atualizar o
relógio.
Dicas:
Tkinter não é seguro em relação a threads.
Todas as ações que interagem com widgets devem ser
executadas dentro da mesma thread, e esta thread
deve ser a thread principal.
Logo, não é uma boa ideia usar um widget fora da
thread que criou o objeto TK (que roda o mainloop).
Para a zona de tempo do Rio de Janeiro, o delta
vale -3 (três horas para trás ou duas, no
horário de verão).
Use o método after, presente em todo widget do tkinter,
para atualizar o tempo corrente a cada 200 ms.
## Movimenta o relógio, redesenhando os ponteiros/dígitos após um certo intervalo de de tempo.
#
def poll():
global root
delta = -3
t = datetime.timetuple(datetime.utcnow()+timedelta(hours = delta))[3:6]
print("{:02d}:{:02d}:{:02d}".format(*t,’02’),end=’\r’)
root.after(200, poll)
Mapeie horas, minutos e segundos em ângulos a partir das 12hs
(π/2).
Lembre-se que o eixo Y cresce para baixo.
Mapeie o retângulo [-1, 1] × [-1, 1] (window) no retângulo
[0, 400] × [0, 400] (viewport),
para transformar as coordenadas do mundo para coordenadas de
tela:
- Utilize o
notify-python,
para exibir mensagens para o usuário, por exemplo, o arquivo de
gravação.
- Utilize o
Tix, uma
extensão do Tk, para implementar dicas de uso, na forma de
Balloon Help,
para os componentes
(widgets)
do tkradio.
- Se não houver uma placa de captura disponível, utilize o
mplayer ou o gstreamer para reproduzir a stream da rádio,
haja vista que quase todas estão disponíveis
online.
# escolha um dos players abaixo, adequado ao seu ambiente de desenvolvimento:
PLAYER = "/usr/bin/vlc" # Linux
PLAYER = "/usr/bin/mplayer" # Linux
PLAYER = "/usr/bin/gst-launch-1.0" # Linux
PLAYER = "/Applications/VLC.app/Contents/MacOS/VLC" # MacOS
PLAYER = "/opt/local/bin/mplayer" # MacOs
PLAYER = "/opt/local/bin/gst-launch-1.0" # MacOs
PLAYER = "C:\\Arquiv~1\\SMPlayer\\mplayer\\mplayer.exe" # Windows
# vlc
param = ["vlc", "-Idummy", "http://playerservices.streamtheworld.com/api/livestream-redirect/SULAMERICA"]
# mplayer
param = ["mplayer", "-quiet", "http://playerservices.streamtheworld.com/api/livestream-redirect/SULAMERICA"]
# gstreamer
param = ["gst-launch-1.0", "playbin", "uri=http://playerservices.streamtheworld.com/api/livestream-redirect/SULAMERICA"]
mpid = os.spawnv ( os.P_NOWAIT, PLAYER, param )
As seis arestas do tetraedro correspondem aos pares de vértices:
0,1 - 0,2 - 0,3 - 1,2 - 1,3 - 2,3
As quatro faces do tetraedro, no sentido anti-horário vistas de
fora, correspondem às triplas de vértices: 0,1,2 - 0,2,3 - 0,3,1
- 2,1,3
Projetar um vértice na tela (espaço 2D) é simplesmente ignorar a
coordenada Z.
Mapeie deslocamentos de mouse na direção X em rotações ao redor
do eixo Y.
Mapeie deslocamentos de mouse na direção Y em rotações ao redor
do eixo X.
Rotação do tetraedro ao redor do eixo x é executada
multiplicando-se duas matrizes: tet = Rx(α)
× tet
def cbMottion(event):
"""Map mouse displacements in Y direction to rotations about X axis,
and mouse displacements in X direction to rotations about Y axis."""
global tet
dx = -(event.y - lastY)
dy = (event.x - lastX)
tet = matMul(ROT_X(EPS(dx)), tet) # EPS is a function of dx, such as dx*π/(0.75*height)
tet = matMul(ROT_Y(EPS(dy)), tet)
drawTet(tet,tetColor)
lastX = event.x
lastY = event.y
Mapeie deslocamentos da rodinha do mouse em rotações ao redor do
eixo Z.
As normais de todas as faces devem ser orientadas
consistentemente, todas apontando para fora ou para dentro do
sólido.
Como os sólidos platônicos são convexos:
basta executar o produto escalar entre o vetor normal da
face e o vetor que liga o centróide da face ao centróide
do sódido.
se o produto for > 0, inverta a direção do vetor normal.
Assim, todas as normais apontarão para fora do sólido.
Apenas no máximo três, das quatro faces do tetraedro, são
visíveis. Um teste simples conhecido como
back face culling
é suficiente para determinar as faces visíveis de sólidos
convexos.
A direção de visão da câmera é paralela ao eixo Z: (0,
0, -1).
Portanto, o produto escalar da normal (apontando para
fora) de uma face, com a direção de visão, deve ser
negativo (ângulo > 90°).
Logo, basta que a componente Z da normal de uma face
seja positiva: Nz > 0 ⇒ face é visível.
13) Usando o PyOpenGL, escreva um programa que desenhe um cubo e
um tetredro, que fiquem girando na tela.
As faces do cubo devem ter cores diferentes e as faces do
tetraedro devem ser coloridas a partir da interpolação das cores
dos seus vértices: vermelho, verde e azul.
14) Usando o cgal-python e o PyOpenGL, escreva um programa que
desenhe o Diagrama de Voronoi,
e a triangulação de Delaunay, a partir de pontos fornecidos com
o mouse.
16) Desenhe uma fractal conhecida como Sierpinski Gasket. A maneira
mais fácil é ir dividindo ao meio, recursivamente, as arestas de um
triângulo inicial. Use uma escala para variar o número de
subdivisões n, gradativamente, e dois labels, para indicar o
número de triângulos vermelhos (3n) e brancos
(3n-1)/2.
17) O programa
mplayertv.py foi implementado
segundo o paradigma "procedural" de programação.
Altere-o usando OO (orientação a objetos), criando uma classe
mplayerTV.
mplayer
Ghost Rider
18) Desafio Linux: escreva um programa python para
"tocar" qualquer arquivo multimedia a partir de qualquer unidade
de CD/DVD do computador.
Dicas:
- O programa mplayertv.py é capaz de "tocar" quase todos os
tipos de arquivos multimedia.
- Arquivos em CD ("iso9660") ou DVD ("udf") , em linux,
normalmente, são montados no diretório "/media/volume do CD" ou
"/run/media/user/volume do CD".
- A informação de todos os pontos de montagem em uso está
armazenada no arquivo "/etc/mtab".
- Use o módulo getcdmp.py, para
descobrir qual o leitor de CD/DVD, o ponto de montagem e o
sistema de arquivos.
Exemplo:
[cascavel:~/bin] getcdmp.py
('/dev/sr1', '/media/BLADE_RUNNER_16X9', 'udf')
[cascavel:~] mplayerdvd.py
Python Version: 2.5.4 - Language = en_US, Charcode = UTF8
Device = /dev/sr1 , Chapter = None , Mount Point = /media/BLADE_RUNNER_16X9 , File system = udf
The Monitor Aspect Ratio is None
[cascavel:~] libdvdread: Using libdvdcss version 1.2.10 for DVD access
