Numa das últimas aulas estivemos a preparar o último teste. Um dos exemplos procurava passar por alguns dos aspectos essenciais: dicionários e ficheiros. O problema consistia em escrever um programa que realizasse quatro tarefas:
1- simular o lançamento de dois dados guardando o resultado da sua soma numa lista,
2- guardar os resultados num ficheiro, com um resultado por linha;
3- construir um dicionário de frequências em que as chaves fossem os números e os valores o número de vezes que ocorreram;
5- apresentar um gráfico de barras com o histograma das frequências. O gráfico seria feito com a ajuda do módulo turtle.
Os três primeiros sub-problemas eram revisitações de algo que já tínhamos feito. A nossa ideia era consolidar os conceitos e aproveitar para mais um exemplo de decomposição de problemas em sub-problemas e das quesdtões que se levantam.
Cada um deles podia ser resolvido de modo simples. Comecemos pelo problema da geração.
import random
def gera_1(n):
lista = list()
for i in range(n):
lista.append(random.randint(1,6)+random.randint(1,6))
return lista
def gera_2(n):
return [random.randint(1,6) + random.randint(1,6) for i in range(n)]
def dado():
return random.randint(1,6)
def gera_3(n):
return [dado()+dado() for i in range(n)]
A primeira solução é a mais básica. A outras duas usam
listas por compreensão, sendo que a última abstrai o problema de lançar o dado.
Guardar os dados gerados num ficheiro também é trivial.
def guarda(ficheiro,dados):
with open(ficheiro,'w') as f_out:
for dado in dados:
f_out.write(str(dado)+'\n')
Aqui usámos o
gestor de contexto with. Finalmente ir buscar os dados ao ficheiro e construir um dicionário de frequências.
def freq(ficheiro):
with open(ficheiro) as f_in:
dados_str = f_in.read().split()
dados_num = [eval(dado) for dado in dados_str]
# dicio frequências
dicio = dict()
for dado in dados_num:
dicio[dado] = dicio.get(dado,0) + 1
return dicio
Estas três soluções têm que ser integradas num único programa. Só precisamos ter em atenção a interface.
def main(n, ficheiro):
# gerar
dados = gera_2(n)
# guardar
guarda(ficheiro, dados)
# frequência
frequencia = freq(ficheiro)
Agora fica a questão das barras e do uso do turtle. Admitamos que queremos fazer um gráfico como o da figura:
Vamos tentar decompor tudo em sub-problemas mais simples: os eixos, as barras e os valores. Vamos começar pelas barras e fazer algo como no caso do lançamento dos dados: começar pela questão de visualizar uma barra.
import turtle
def barra(pos,altura,cor, espessura):
# posiciona
turtle.penup()
turtle.goto(pos)
turtle.pendown()
turtle.setheading(90)
# atributos
turtle.color(cor)
turtle.width(espessura)
# Desenha
turtle.forward(altura)
A ideia desta solução é trivial: posicionar a tartaruga, colocá-la a apontar para norte e avançar um valor igual à altura da barra.
Desenhar um gráfico de barras pode ser agora feito chamando repetidas vezes a função barra.
def grafico_barras(pos_inicial,lista_barras, cor, espessura,delta):
pos = pos_inicial
for altura in lista_barras:
barra(pos,altura,cor, espessura)
# posiciona)
pos = (turtle.xcor()+ delta,0)
turtle.hideturtle()
O parâmetro
delta controla o afastamento entre as barras.
Passemos aos eixos. Pode ser feito de diferentes maneiras. Um exemplo:
def eixos(pos_x, pos_y, tam_x, tam_y):
# posiciona
turtle.penup()
turtle.goto(pos_x, pos_y)
turtle.pendown()
# eixo x
turtle.forward(tam_x)
turtle.write('X', font=('Arial',8,'bold'))
# posiciona
turtle.penup()
turtle.goto(pos_x, pos_y)
turtle.pendown()
# eixo y
turtle.setheading(90)
turtle.forward(tam_y)
turtle.write('Y', font=('Arial',8,'bold'))
turtle.hideturtle()
Usamos a função
write para escrever o nome dos eixos. Notar como se controla a escrita. É evidente que podemos ter o desenho dos eixos e das barras tudo junto:
def grafico_barras_eixos(pos_inicial,lista_barras, cor, espessura,delta):
eixos(pos_inicial[0] -delta, pos_inicial[1], len(lista_barras) * (espessura + delta), max(lista_barras) + delta)
pos = pos_inicial
for altura in lista_barras:
barra(pos,altura,cor, espessura)
# posiciona)
pos = (turtle.xcor()+ delta,0)
turtle.hideturtle()
Notar como se controla a dimensão dos eixos!
Falta acrescentar os números. Mas isso pode ser feito com uma pequena alteração no programa que desenha as barras.
def grafico_barras_eixos(pos_inicial,lista_barras, cor, espessura,delta):
eixos(pos_inicial[0] -delta, pos_inicial[1], len(lista_barras) * (espessura + delta), max(lista_barras) + delta)
pos = pos_inicial
for altura in lista_barras:
barra(pos,altura,cor, espessura)
turtle.pencolor('black')
turtle.write(altura, font=('Arial',8,'bold'))
# posiciona)
pos = (turtle.xcor()+ delta,0)
turtle.hideturtle()
Podemos juntar esta solução ao resto do programa, definindo um novo main.
def main(n, ficheiro):
# gerar
dados = gera_2(n)
print(dados)
# guardar
guarda(ficheiro, dados)
# frequência
frequencia = freq(ficheiro)
print(frequencia)
# gráfico
valores = [frequencia.get(chave,0) for chave in range(1,13)]
grafico_barras_eixos((0,0),valores,'red',5,15)
Se executarmos o programa, no entanto, o resultado não é muito famoso. O problema está no facto de os valores serem muito pequenos. Uma solução simples é definir um
factor de escala que dependerá do número de lançamentos de dados. Interessa-nos uma alteração que aumente muito os valores pequenos de
n e pouco os valores grandes. Uma função candidata a tal é a função logaritmo!
def main(n, ficheiro):
# gerar
dados = gera_2(n)
print(dados)
# guardar
guarda(ficheiro, dados)
# frequência
frequencia = freq(ficheiro)
print(frequencia)
# gráfico
escala = int(math.log(n,10)) # <---
valores = [escala * frequencia.get(chave,0) for chave in range(1,13)]
grafico_barras_eixos((0,0),valores,'red',5,15)
turtle.exitonclick()
Mas podemos promover outra pequena alteração para poder colocar a identificação dos números ao longo dos eixos dos XX.
A mudança principal envolve a função barra.
def barra(pos,altura,cor, espessura,num):
if altura:
# posiciona
turtle.penup()
turtle.goto(pos[0],pos[1]-20)
turtle.write(num)
turtle.goto(pos)
turtle.pendown()
turtle.setheading(90)
# atributos
turtle.color(cor)
turtle.width(espessura)
# Desenha
turtle.forward(altura)
turtle.pencolor('black')
turtle.write(altura, font=('Arial',8,'bold'))
Notar que passámos a fazer aqui toda a parte que interssa saber da barra: valor de x, de y e o desenho.
Para quem gosta de tudo muito direitinho aqui fica o programa final completo.
import random
import operator
import math
def gera_2(n):
return [random.randint(1,6) + random.randint(1,6) for i in range(n)]
# Guardar
def guarda(ficheiro,dados):
with open(ficheiro,'w') as f_out:
for dado in dados:
f_out.write(str(dado)+'\n')
# Frequência
def freq(ficheiro):
with open(ficheiro) as f_in:
dados_str = f_in.read().split()
dados_num = [eval(dado) for dado in dados_str]
# dicio frequências
dicio = dict()
for dado in dados_num:
dicio[dado] = dicio.get(dado,0) + 1
return dicio
# Ver
import turtle
def barra(pos,altura,cor, espessura,num):
if altura:
# posiciona
turtle.penup()
turtle.goto(pos[0],pos[1]-20)
turtle.write(num)
turtle.goto(pos)
turtle.pendown()
turtle.setheading(90)
# atributos
turtle.color(cor)
turtle.width(espessura)
# Desenha
turtle.forward(altura)
turtle.pencolor('black')
turtle.write(altura, font=('Arial',8,'bold'))
def grafico_barras_eixos(pos_inicial,lista_barras, cor, espessura,delta):
eixos(pos_inicial[0] - delta, pos_inicial[1], len(lista_barras) * (espessura + delta), max(lista_barras) + delta)
pos = pos_inicial
for num,altura in enumerate(lista_barras):
barra(pos,altura,cor, espessura,num)
# posiciona
pos = (turtle.xcor()+ delta,pos_inicial[1])
turtle.hideturtle()
def eixos(pos_x, pos_y, tam_x, tam_y):
# posiciona
turtle.penup()
turtle.goto(pos_x, pos_y)
turtle.pendown()
# eixo x
turtle.forward(tam_x)
turtle.write('X', font=('Arial',8,'bold'))
# posiciona
turtle.penup()
turtle.goto(pos_x, pos_y)
turtle.pendown()
# eixo y
turtle.setheading(90)
turtle.forward(tam_y)
turtle.write('Y', font=('Arial',8,'bold'))
turtle.hideturtle()
# MAIN ----------------
def main(n, ficheiro):
# gerar
dados = gera_2(n)
print(dados)
# guardar
guarda(ficheiro, dados)
# frequência
frequencia = freq(ficheiro)
# gráfico
escala = int(math.log(n,10)) # <--
valores = [escala * frequencia.get(chave,0) for chave in range(1,13)]
grafico_barras_eixos((0,0),valores,'red',5,15)
turtle.exitonclick()
if __name__ == '__main__':
main(1000,'/Users/ernestojfcosta/tmp/tudo.txt')
Para quem gosta de experiências, tente executar o programa para
diferentes valores crescentes de n. Os gráficos de barras que são desenhados vão convergir para uma forma de distribuição conhecida em probabilidades: a distribuição normal. é uma boa altura para revisitar a
Lei dos Grandes Números.
Boas Festas!
