Novidade!!! Agora vamos ter canal no Youtube =D

Fala pessoal tudo beleza, estou sumido a correria está forte por aqui. Estou querendo dar um start em um projeto antigo que vem desde o tempo da Faculdade que é fornecer um site onde as pessoas possam aprender um pouco de programação Python e Java comigo =D.

Não sou nenhum guru mas tenho algumas experiências que gostaria de compartilhar, e para começar fiz uma vídeo aula piloto onde todos podem deixar comentários com criticas para melhorar essa bagaça. Clique aqui para assistir.

Pessoal é 100% gratuito e não pretendo cobrar nada hein ... Valeu amigos =D

Manipular semanas com Python

Olá pessoal tudo bem por ai? Faz tempo que eu não atualizava o blog, muitas atividades extra classe e no trampo =D. Inclusive hoje vou falar sobre um assunto no qual tive que utilizar em meu serviço. Trata-se do cálculo de datas com Python, mais especificamente cálculo entre semenas com Python.

O problema era o seguinte, eu tinha que retroceder 12 semanas apartir da data atual, se você nunca manipulou datas em Python já lhe adianto que é muito simples assim como tudo que existe em Python.

Vamos começar a por a mão na massa? Primeira coisa que temos que fazer é recuperar a data atual do sistema:

1 2 3 4 5 6 7 8 9 10

#!/usr/bin/python from datetime import datetime today = datetime.now() print 'Data atual do sistema: %s' % today # imprimindo por extenso print 'Data atual do sistema: %s' % today.strftime('%A, %d of %B of %Y')

Agora que temos a data atual, vamos recuperar o primeiro e último dia da semana atual. Para fazer cálculos de forma simples com Python temos o módulo timedelta.

1 2 3 4 5 6 7 8 9 10 11 12

#!/usr/bin/python # coding: utf-8 from datetime import datetime from datetime import timedelta today = datetime.now() first_day = today - timedelta(days=today.isoweekday()) last_day = first_day + timedelta(days=6) print u'primeiro dia %s' % first_day print u'último dia %s' % last_day

Show de bola, muito fácil até o momento. Agora precisamos regredir doze semanas da data atual, isso pode ser feito da mesma forma que foi utilizada com os dias, mas agora ao invés de dias vamos subtrair semanas. Lembrando que vamos considerar a semana atual como sendo uma semana dentro do intervalo.

1 2 3 4 5 6 7 8 9 10 11 12

#!/usr/bin/python # coding: utf-8 from datetime import datetime from datetime import timedelta today = datetime.now() first_date = today - timedelta(days=today.isoweekday()) twelve_week = first_date - timedelta(weeks=11) print 'Doze semanas atrás: %s' % twelve_week print 'Por extenso: %s' % twelve_week.strftime('%A, %d of %B of %Y')

Com isso eu resolvi o meu problema de voltar semanas utilizando apenas as baterias inclusas do Python.

Até a próxima galerinha, se tiverem dúvidas deixem comentários que responderei!

Calcular Endereço de Rede e Endereço de Broadcast em Python

Fala galera este é um post curto, que tem como objetivo mostrar uma porção de código em Python. O objetivo é ler um número IP e a máscara e calcular o endereço de Rede e de Broadcast do IP. Bom agora chegou a hora de mostrar o código.

Vamos lá nas linhas 4 e 3 li o ip e a mascara respectivamente. Na linha 7 criei duas listas que vão armazenar o endereço de broadcast e endereço de rede.

Nas linhas 9, 10 e 11 fiz um for. Na linha 10 eu adiciono um elemento a lista do endereço de rede aplicando um E lógico, mas antes eu converto os números para inteiros para poder aplicar o operador. Na linha 11 eu calculo a mascara aplicando o OU lógico e negando o endereço da mascara, e com isso aplico um E lógico para que o range do número fique entre 0..255 (8 bits).

Da linha 13 a linha 18 é só perfumaria para exibir o resultado. Se você estiver com dúvidas não deixe para depois escreva um comentário que eu posso ajudar. Bons estudos! 

Construindo Interfaces gráficas com PySide - QWidget

Fala pessoal, estou de volta dessa vez para falar mais de PySide =). Se você ainda não leu os posts anteriores a esse aqui no blog, por favor leia acessando a tag (PySide).

Até agora rabiscamos algumas apps em cima de nosso toolkit gráfico, mas chegou a hora de começar a desvendar o nosso PySide. Vamos falar hoje da classe QWidget que é a base dos componentes: Buttons, Text Fields, Check Box .. etc.

 

QWidget

A classe QWidget é a classe base para todos os objetos de interface do usuário. Portanto uma tela é formada de vários QWidgets, claro que um QWidget é responsável por agrupar os demais. Dai aquela famosa nomenclatura childs and parents ;).

A única coisa que não pode ser agrupada em uma QWidget são as janelas, geralmente janelas tem um contorno e uma barra de título, digo geralmente pois podemos omitir essas características na construção de nossa janela. Em PySide podemos ter uma QWidget sem um pai, quando isso acontece dizemos que temos uma QWidget top-level, essas widgets tem barra de título e ícone. Apesar de poder ter uma widget independente (top-level) isso não é muito usado.

 

Widgets compostas

Widgets compostas são widgets que abrigam outras widgets (filhas). Não existe um número máximo de filhos que uma QWidget pode ter. Pense em um QFrame (ainda não aprendemos sobre ele, mas é uma área onde podemos adicionar objetos) e nele pode ser adicionado vários widgets (botões, campos de texto, campos de seleção, etc).

 

Minha primeira Widget

Vamos lá galera hora de entender o código. O que fazemos nesse código é codificar o evento de duplo clique, quando isso ocorre o titulo da janela altera ... faça o teste.

Como de praxe as primeiras linhas são os importes necessários das classes e módulos que vamos utilizar em nosso programa. Depois definimos nossa classe (Window) que herda de QWidget. Já no construtor alteramos o título de nossa janela para Aplicacao Bala.

Depois definimos um método que na verdade é um tratador de eventos (aprenderemos mais sobre isso nos próximos posts), esse método trata o duplo clique na área da minha QWidget, ou seja, se o usuário clicar duas vezes no interior de minha QWidget, então o método vai ser executado. Quando o método for executado ele vai imprimir no terminal o valor de event e alterar o título da QWidget para funciona!!!.

Agradecimentos

Esse post é só para introduzir a classe QWidget, no posso post vamos trabalhar mais os eventos que podemos ter em nossas widgets. Até a próxima pessoal =).

Construindo interfaces gráficas com PySide - QMenuBar / QMenu / QAction

Fala pessoal, tudo ...

Hoje vou continuar falando de PySide. Vou mostrar como inserir barra de menu, menus e ações.

Motivação

Na grande maioria das vezes quando escrevemos uma interface gráfica precisamos disponibilizar ao nosso usuário uma barra de menu com algumas operações. Fazer a divisão das operações em menus com nomes significativos, facilita o uso do seu software. Hoje em dia a maioria dos softwares fazem o uso de menus para dividir as ações que o programa oferece, um bom exemplo é o seu navegador ... imagine como seria complicado utilizá-lo se ele não tivesse um menu para dividir as operações.

 Mostre o código

Agora é a hora legal, onde o Guilherme para de falar e exibe o código, vamos lá? Veja como é o código e confira a explicação logo em seguida:

Nas linhas 4,5,6 importo os módulos que vou usar em meu programa. Nesse caso mostrei como importar todas as classes presentes no módulo QtGui e QtCore, fazendo dessa maneira você não precisa escrever por nome do módulo mais o nome da classe, por exemplo QtGui.MainWindow.

Da linha 8 à 36 tenho a definição de uma classe que herda de MainWindow (caso você não saiba o que é a MainWindow leia). As novidades começam a surir a partir da linha 14, onde uso o método setGeometry que pede 4 argumentos (posx, posy, largura, altura) para definir a janela.

Na linha 18 eu crio uma barra de menu utilizando o construtor  da classe QMenuBar. Toda MainWindow já possui uma barra de menu por definição, portanto também poderíamos apenas recuperar a QMenuBar sem precisar instanciar uma nova, veja:

Depois da barra de menu criada na linha 19 eu crio um menu utilizando o construtor QMenu. O construtor de QMenu pode ter dois ou um parâmetro, o primeiro parâmetro é o texto que será mostrado na barra de menus, o segundo é o elemento pai do menu. Esse parâmetro exerce o seguinte comportamento, quando a janela pai do menu é destruída o menu também é removido.

Por enquanto já temos o menu e temos a barra de menu, mas ainda falta criar ações para esse menu, ou seja, quais funções vão ser colocadas/agrupadas naquele menu, por exemplo: menu file tem as actions save, open, save as.

Para criar uma ação utilizamos o construtor QAction(), esse construtor pode ter vários parâmetros de configuração como: ícones, teclas de aderência (Ctrl + A), texto exibido na barra de status. Por isso cabe uma consulta um pouco mais detalhada a documentação para poder usar todos os recursos dele. Eu apenas defini o texto de apresentação e a ação (método) que ele executa, acredito que seja o as principais funções dele. O primeiro parâmetro é o texto que vai parecer quando o menu for aberto, o segundo parâmetro é o elemento pai da QAction e o terceiro e ultimo é o nome do método que a ação invoca quando é clicada.

Feito isso basta adicionar a action ao menu, e adicionar o menu na barra de status. Ufa está quase acabando, agora só falta definir o método que a QAction vai chamar, nesse código teremos que criar um método chamado hello().

Nas 34,35 e 36 está mostrando a definição do método hello. Esse método limpa a tela do terminal (Unix like) e escreve o texto Hello World.

No final você deve ter uma janela semelhante a essa em sua área de trabalho ao interpretar o código:

(menu do mac é na barra, em alguns linux isso também ocorre fique atento a esse detalhe).

Ao clicar no menu e na Action sobre o seu terminal deve ter o seguinte resultado:

Bom pessoal é isso ai, qualquer dúvida deixem comentários! Até a próxima e bons estudos.

Construindo interfaces gráficas com PySide - MainWindow

Fala pessoal, hoje vamos aprender como construir uma janela principal utilizando o toolkit gráfico PySide.

PySide é uma versão do PyQt com uma licença diferente, para mais informações vide a documentação oficial.

Motivação

Muitas vezes estamos programando alguns scripts Python, mas pela ausência de GUI nao conseguimos mostrar aos nossos pais os programas que fazemos (brincadeira pessoal).

A motivação aqui, é o fato que programas que possuem uma interface, tornam-se mais amigável  e conseguem alcansar um número  maior de usuários e também conseguem facilitar a execução de tarefas dentro do software.

Mostre o código

Agora é a hora legal, onde o Guilherme para de falar e exibe o código, vamos lá? Veja como é o código e confira a explicacao logo em seguida:

Na primeira linha fazemos a importação dos módulos QtGui e QtCore. Logo após criamos uma classe, que herda de QMainWindow.

Dentro da classe temos apenas 3 linhas, a primeira linha declara o construtor da classe ( __init__() ). Na segunda linha temos a chamada ao construtor da classe pai, nesse caso temos uma chamada ao construtor da classe QMainWindow. Na 3 e ultima linha da classe, chamamos o método serWindowTitle, ele tem um parâmetro do tipo str (string). Esse método altera o título da nossa janela.

Feito isso já temos uma janela escrita em PySide, porém, falta ainda um método para criar uma instância da janela, e iniciar a nossa app. Nas ultima linhas definimos o método main (um velho amigo). Na primeira linha do main temos a importação do módulo sys, logo após criamos uma aplicação. Depois criamos uma instância da classe janela, chamamos o método show() para exibi-la, e por fim mandamos a aplicação executar. 

Se você preferir, não precisamos criar o método main e nem importar o módulo sys ... Veja como ficaria:

O resultado final deve ser uma janela parecida com a que temos na imagem a seguir:

Bom é isso ai pessoal, até a próxima!! Bons estudos :)

Algoritmo produtor / consumidor - Python

Olá pessoal, na aula de SOP (Sistemas Operacionais) da minha faculdade meu professor pediu para que escrevêssemos um algoritmo para simular dois processos (A e B), onde o processo A era um produtor de valores e o processo B era um consumidor de valores.

Também era desejado que os dois processos pudessem operar de forma igual mesmo se os dois possuíssem velocidades diferentes. Exemplo:

[1 caso] Se o processo A (produtor) for mais veloz que o processo B (consumidor) ele deve produzir um número máximo N e logo em seguida dormir. O processo A será ativado novamente quando a lista estiver sem nenhum valor para ser consumido.

[2 caso] Se o processor B (consumidor) for mais veloz que o processo A (produtor) ele deve consumir todo o vetor de valores len(N) e logo em seguida dormir. O processo B (consumidor) será ativado novamente quando a lista estiver preenchida com valores para serem consumidos.

Para fazer esse tarefa usei a linguagem Python, e segue abaixo a minha implementação:

#! /usr/bin/python
# coding:utf-8

from random import randint
from time import sleep
import sys
import os

lista = [] #cria uma lista de valores com nenhum valor inserido
dormir_c = False #flag para desativar/ativar processo B (consumidor)
dormir_p = False #flag para desativar/ativar processo A (produtor)
length_max = int(sys.argv[1]) #tamanho max do vetor

#Processo A (produtor), produz valores para a lista
def produtor():
 global lista, length_max, dormir_c, dormir_p

 if not dormir_p: #verifica se processo está ativo
  while len(lista) < length_max: #verifica se a lista não atingiu seu tamanho máximo
   lista.append(randint(0, 1000)) #adiciona um valor inteiro entre 0 e 1000 à lista
   print 'Olá Sr. Programador eu sou o produtor, olha como está a lista de valores ' + str(lista)
  else:
   print 'Fiz o meu serviço olha como eu deixei a lista cheinha >>> ' + str(lista)
   print 'Agora eu vou tirar uma soneca. [Produtor está tirando uma soneca acorde ele quando a lista estiver vazia] \n'
   dormir_p = True #desativa o processo A
   dormir_c = False #ativa o processo B
   consumidor() #chama o consumidor

#Processo B (consumidor), consome valores da lista      
def consumidor():
 global lista, length_max, dormir_c, dormir_p

 if not dormir_c: #verifica se processo está ativo
  if lista: #verifica se a lista contem valores
   del lista[0] #remove o valor que se encontra no inicio da lista
   print 'Olá Sr. Programador eu sou o consumidor, olha como está a lista de valores' + str(lista)
  else:
   print 'Fiz o meu serviço olha como eu deixei a lista limpinha >>> ' + str(lista)
   print 'Agora eu vou tirar uma soneca. [Consumidor está tirando uma soneca, acorde ele quando a lista possuir valores] \n'
   dormir_c = True #desativa o processo B
   dormir_p = False #ativa o processo A
   produtor() #chama o produtor

while True: #loop infinito
 #inicia a brincadeira
 produtor() 
 consumidor()
 sleep(5) #trava a tela a cada iteração para podermos ver os processos em execução
 print '-----------------------------------------------------------------------------------------------------------------------------------'

Para executar o script, você deve informar o número máximo de itens que a lista pode conter. Esse parâmetro deve ser informado por linha de comando. Desse modo para executarmos nosso script temos que fazer:

user@server$ python algoritmo.py  N

Onde N é um número inteiro aleatório. Quando quiser encerrar a execução basta pressionar Ctrl+C. Espero que gostem do material e até a próxima!

Python - Ler parâmetros informados por linha de comando

Olá pessoal, hoje vou ensinar como ler parâmetros passados por linha de comando utilizando a linguagem de programação Python.

Muitas vezes quando estamos fazendo algum script para executar uma determinada rotina temos que informar alguns parâmetros de configuração.

Para informar parametros no atraves da linha de comando basta escrevelos após o comando de interpretação assim:

#python aula.py guilherme carvalho python

Quando fazemos isso dizemos para rodar o arquivo aula.py e passamos 3 parametros para esse arquivo que são: guilherme, carvalho e python. Esses argumentos são recebidos como uma lista e podemos usalos dentro de nosso codigo.

Para usá-los devemos importar o modulo sys e informar qual a posição do parâmetro que desejamos recuperar.

import sys fname,lname,lang = sys.args[1], sys.args[2], sys.args[3] print 'My name is ' + fname + lname + ". I'm love " + lang

Link para o código no pastebin (http://pastebin.com/awXb0Wgz)

Você pode utilizar todos os métodos de estrutura lista uma vez que sys.argv é uma lista de parâmetros. Outra informação importante é que o primeiro parâmetro é sempre o nome completo do arquivo sendo executado. Bom pessoal espero que tenham curtido! Até o próximo post.

Funções em Python - Variáveis por referência ou valor?

Olá pessoal, hoje vamos aprender um pouco mais de Python e entender como essa linguagem trabalha com variáveis em chamadas de funções.

Quando estamos escrevendo um programa estruturado certamente iremos construir algumas funções para solucionar algum problema. Em muitas linguagens de programação temos a opção de passar valores por refência ou por valor.

Quando passamos valores por referência estamos na verdade passando o endereço de memória onde a variável original aponta, então quem recebe esse endereço tem o que chamamos de acesso direto e toda alteração feita localmente reflete a variável original uma vez que o endereço apontado pela variável local é o mesmo da original.

Quando passamos por valor a variável local recebe uma "cópia" do valor que a variável original armazena, e toda a mudança que a variável local recebe NÃO é refletida na variável original pois a variável local é apenas uma cópia de seu valor.

Em Python não fazemos essa divisão em valor ou referencia. Em Python tudo é objeto, e quando eu digo tudo é tudo mesmo: 1, 10, 45, 543,  *lista, *tuplas, *dicionários, etc.

Então como fazer essa divisão em Python? Ora, muito simples. Dizemos que temos objetos que são mutáveis e objetos que são imutáveis. Objetos mutáveis como o próprio nome diz são objetos que podem mudar no decorrer da interpretação do código e objetos imutáveis são aqueles que não mudam no decorrer do código. Exemplo de objetos imutáveis: 1, 20, 123. O objeto 1 quando iniciamos o programa é 1 e no final dele continua sendo 1.

Agora objetos que são mutáveis temos: *listas, *dicionário, etc. Uma lista pode começar fazia, e no final da interpretação terminar com 10 elementos.

* Estruturas de dados da linguagem Python.

Persistir mudanças em variáveis externas

E agora vem a pergunta: Como fazer uma variável externa recuperar o valor que foi dado à ela dentro de uma função?.

A primeira coisa a ver nesse caso é se a variável a ser passada é mutável ou imutável. Caso ela seja mutável não é preciso fazer nada, toda a mudança que ela receber na função vai ser refletida a variável original .

def adicionarItem(item, lista): lista.append(item) lista = list() adicionarItem(5, lista) adicionarItem(10, lista) print(lista)

Veja que criamos uma lista, onde valores são inseridos e ao final exibimos e comprovamos que os valores foram inseridos na lista. Agora se a variável for imutável devemos retornar o valor calculado dentro da função para a variável externa, fazendo com que ela receba esse valor. Exemplo:

def incrementar(a): a += 1 return a a = 5 a = incrementar(a) print(a)

Temos uma função cujo o seu propósito é incrementar um ao valor original da variável passada. Criamos uma variável com o valor 5 e logo em seguida estamos chamando a função e atribuindo o valor de retorno a nossa variável. Ao final estamos imprimindo o valor calculado pela nossa função. Nesse caso nada de errado aconteceu e o valor 6 foi mostrado como já era previsto. Mas e se não tivéssemos atribuído esse retorno a variável, será que o resultado seria o mesmo? Vamos testar:

def incrementar(a): a += 1 return a a = 5 incrementar(a) print(a)

Opa agora o resultado que foi mostrado na tela foi o número 5 :s!!! Isso não era para estar acontecendo! Na verdade era, em Python temos uma tabela de objetos onde cada objeto tem um ID. Então quando criamos uma variável ela é uma etiqueta para esse ID que por sua vez faz uma referencia a memória. Então quando a variável é criada ela está etiquetando o ID do Objeto 5, é criada uma outra variável só que localmente e essa aponta para ID 6. Como a variável local não é retornada ela morre ou melhor deixa de existir assim que a função acaba de ser interpretada. Bom pessoal por hoje é só espero que tenham gostado. Bons estudos!!!

Manipulando arquivos XML em Python

Fala pessoal hoje vamos aprender como escrever e ler arquivos XML utilizando a linguagem de programação Python.

Na maioria da vezes temos que salvar informações que os usuários ou sistemas geram. Podemos salvar essas informações de várias formas , seja em um banco de dados, em arquivos de texto, na nuvem, etc. Eu diria que a mais tradicional de todas elas seria salvar em um bom banco de dados como (MySQL, PostgreSQL, Oracle) mas em determinadas aplicações o seu uso é desnecessário ou até mesmo inaplicável. Quando isso ocorre devemos então salvar as informações em arquivos de texto, porém, os arquivos de texto não são lá muito elegantes e legíveis.

Eis então que surge os arquivos XML que podemos definir a grosso modo como sendo arquivos de texto estruturados. O XML é muito utilizado hoje para garantir que dois sistemas possam se interagir normalmente. Um bom exemplo seria o sistema de emissão de nota fiscal online onde a troca de informações entre o sistema proprietário e o sistema da receita federal é toda feita através de arquivos no formato XML.

Escrevendo em formato XML

Para escrever em formato XML utilizando Python podemos utilizar a biblioteca ElementTree que já vem nos pacotes de instalação do interpretador Python.

Para utilizar essa biblioteca primeiramente devemos importa-la :

from xml.etree.ElementTree import Element, ElementTree
Feito isso já podemos utilizar todos os recursos de nossa biblioteca. Todo arquivo XML possui o que podemos chamar de Nó Pai ou simplesmente de root e a partir dele vários desmenbramentos que podem ou não ter filhos e assim sucessivamente. Para criar um root fazemos:
root = Element('Agenda')
Agora a partir do root criamos os sub-nos ou filhos de root:

pessoa = Element('Pessoa') cliente = Element('Cliente', nome='Guilherme', idade='19', peso='71', altura='1.63')
Acima criamos dois filhos de agenda, um chamado pessoa e o outro chamado cliente. Como podemos ver pessoa não possui nenhum atributo enquanto o cliente possui 4 atributos: nome, idade, peso, altura. Quando uma tag não possui atributos dizemos que ela é vazia esse é o caso da tag pessoa.

Ainda temos que dar o comando de escrita, ou seja, o comando que vai criar o nosso arquivo XML. Senão fizermos isso ao final da execução programa não teremos um arquivo gerado. Para gerar/escrever um arquivo XML devemos fazer:

root.append(pessoa) root.append(cliente) ElementTree(root).write('agenda.xml');
Perceba que o comando append foi utilizado em root, isso indica que na estrutura root estamos adicionando duas outras estruturas filhas chamadas sucessivamente de pessoa e cliente. Logo após utilizamos o comando write onde passamos o nome do arquivo que será gerado, caso o arquivo exista o mesmo será atualizado caso contrário um novo arquivo será gerado com o nome que foi passado como argumento.

O nosso arquivo XML tem essa seguinte estrutura:

<Agenda> <Pessoa /> <Cliente altura="1.63" idade="19" nome="Guilherme" peso="71" /> </Agenda>

Lendo arquivos no formato XML

Como já sabemos um arquivo XML tem um Nó (node, raíz). Através desse nó principal podemos descobrir e listar os demais nós presentes em nossa estrutura. Vimos que cada nó contido no root nomeamos de filhos ou sub-nós.

Vejamos como abrir um arquivo XML utilizando o ElementTree:

tree = ElementTree(file='agenda.xml')
Após abrir o arquivo devemos então recuperar o elemento root para então recuperar os seus filhos. Para recuperar o elemento root de um arquivo XML fazemos:
r = tree.getroot()
Agora sabemos que r contém o nó root da nossa árvore XML. Portanto para recuperar os outros nós basta percorrer todos os filhos de root. Para percorrer os filhos de um nó utilizamos:
pessoa = r.find('Pessoa') cliente = r.find('Cliente')
Pronto agora os nós estão armazenados em variáveis possibilitando assim a manipulação. Você pode imprimir tags ou atributos utilizando essa biblioteca, veja como é simples:
print (cliente.tag, cliente.attrib)
Muito simples trabalhar com a linguagem Python não é mesmo? Abaixo segue o código completo para que você possa analisar parte a parte. Um abraço a todos e bons estudos!!! from xml.etree.ElementTree import Element, ElementTree """ Escrevendo os dados em formato XML e gerando o arquivo """ # Criando o nó superior "root" root = Element('Agenda') pessoa = Element('Pessoa') cliente = Element('Cliente', nome='Guilherme', idade='19', peso='71', altura='1.63') root.append(pessoa) root.append(cliente) ElementTree(root).write('agenda.xml'); """ Lendo o arquivo XML que foi persistido pela primeira parte do código """ tree = ElementTree(file='agenda.xml') r = tree.getroot() # Lista os elementos abaixo do root print (r.getchildren()) # Encontra a pessoa pessoa = r.find('Pessoa') # Encontra o cliente cliente = r.find('Cliente') print (cliente.tag, cliente.attrib)

Número arbitrário de argumentos em funções

Fala pessoal, hoje vou mostrar como trabalhar com números de argumentos arbitrários em funções.  Muitas vezes temos que fazer um código onde não sabemos quantos argumentos serão passados quando o código estiver em execução.

Em Python podemos receber tipos arbitrários de funções de duas formas. A primeira seria usando tupla e a segunda usando dicionario.

Relembrando conceitos

Tuplas são listas de dados imutáveis. Quando o programa está em execução não podemos modificar os valores contidos nos índices da tupla, ou seja, se no inicio do programa a posição 1 da tupla armazena o dado 'programado' até o final do programa a posição 1 irá armazenar esse dado.

Dicionários são listas de dados que combinam par de chave valor, ou seja, invés de associarmos indices com dados no dicionário adicionamos chaves com dados. Por exemplo:

programador = 'Guilherme'
(chave)         (dado)

E para recuperarmos o dado devemos informar o nome da chave.

Simples não é mesmo? Bom vamos voltar para a ideia central do post.

Trabalhando com N parâmetros na chamada da função

Bom primeiramente vamos imaginar o seguinte cenário: "Elabore um programa que realize a somatória de N números inteiros e exiba o valor calculado". 

Sabemos que vamos trabalhar com muitos parâmetros, porém, não nos foi informado quantos. Sabemos também que são números inteiros ou seja entre dicionários e tuplas qual devemos escolher? Se você falou tuplas acertou.

Para identificar que um parâmetro é uma tupla basta  adicionar * antes de seu nome. Veja:

def funcao (*args):     pass

Com isso definimos uma tupla com o nome de args. Para chamar essa função basta colocar o seu nome e adicionar os números que deseja somar:

funcao (1,2,3,4,5,6,7,8,9,10)

E para compilar você deve colocar o comando python e logo após o nome do seu arquivo. Veja:

>> python arquivo.py

O que apareceu na sua tela? Exatamente nada rsrsrs!! Calma pequeno gafanhoto isso aconteceu porque não implementamos a somatória dos números. Vamos fazer isso então.

Para percorrer todos os valores de uma tupla podemos usar o comando for, que serve para percorrer um tipo de dado que seja Iterator. E por definição uma tupla é iterável. Para somar todos os dados da tupla devemos fazer:

soma = 0 for nro in args:     soma += nro return soma
Agora podemos chamar a função e imprimir o seu retorno:

print ( funcao(1,2,3,4,5,6,7,8,9,10)) >> 55
Viu como foi simples? Então o que fizemos foi o seguinte. Montamos uma estrutura for e varremos essa estrutura pegando os itens um a um e adicionamos os seus valores na variável local chamada soma. Ao final da função retornamos o valor de soma.

Veja o código completo:

arquivo.py

def funcao(*args): soma = 0 for nro in args: soma += nro return soma print (funcao(1,2,3,4,5,6,7,8,9,10))

Agora vamos trocar de cenário: "Elabora um programa que simule uma agenda telefonica. Onde o usuário deve informar o nome e o número do contato."

Bom acho que isso não podemos resolver com tuplas correto? Bem ainda nos resta o dicionário será que ele pode nos ajudar? Se você respondeu sim ... você acertou!

Para identificar que um parâmetro é um dicionário devemos adicionar ** antes de seu nome. Veja:

def funcao (**kwargs):     pass
Com isso definimos um dicionário com o nome de kwargs. Para chamar essa função basta colocar o seu nome e adicionar os nomes e seus respectivos números (contatos):

funcao(PHP=88888888, Python=77777777, Java=21212121, C=28826718)
Como você já sabe, se executarmos o nosso arquivo nada irá ocorrer pois nada foi implementado não é mesmo? Bom então lets programar pequeno gafanhoto.

Já sabemos que o for consegue percorrer objetos que sejam iteráveis, e adivinha só ... o dicionário é iterável o///. Então o nosso código ficará assim:
arquivo.py
def funcao(**kwargs): print ('Name \t Number ') for contato in kwargs: print ("\n{}\t{}".format(contato, kwargs[contato])) funcao(PHP=88888888, Python=77777777, Java=21212121, C=28826718)
Nossa muito fácil né pessoal nem parece que em poucas linhas de código já montamos uma agenda telefônica '-'. Sério pessoal, podemos pegar esse código e mandar ele salvar em um arquivo .txt e Ulalá teremos uma agenda *-*.

Porém você deve estar muito emocionado agora, sim eu sei que está kkk. Mas e se precisarmos de uma tupla, um dicionário e mais 3 parâmetros em uma mesma função será que isso é possível?

SIM É PLENAMENTE POSSÍVEL =). VEJA:

def funcao (arg1, arg2, arg3, *args, **kwargs):     pass
Cabe aqui uma dica. A tupla deve ficar antes do dicionário e o dicionário deve ser sempre o ultimo argumento.

Pessoal o post terminou :'( ... Bons estudos e até a próxima!!!

Encapsular campos em Python 3.x

Encapsulamento de dados é um recurso presente em linguagens que seguem o paradigma orientado a objetos. Esse recurso tem como objetivo restrigir o acesso direto a informação, ou seja, ele protege informações que não devem ser alteradas em qualquer parte do programa. Com isso podemos entender que quem está de fora apenas sabe que o serviço é realizado mas não sabe como o serviço é implementado.

Certamente quando começamos a programar orientado a objetos não vemos os benefícios que o encapsulamento de dados nos proporciona, pois, a primeira vista ele só serve para gerar mais linhas de código.

Hoje vou falar como encapsular dados na linguagem de programação Python versão 3.x. Se você já programou em alguma linguagem .Net (Visual Basic, C#) não sentirá grandes mudanças, porém, se você é um programador Java sentirá uma certa estranheza quando ler o código.

Bom sem mais demora vamos conhecer mais um pouquinho da linguagem Python e sua implementação diferente em POO.

Protegendo minhas variáveis dos Noobs

Na minha opinião o encapsulamento de dados existe, porém, não garante a total segurança do seu código. Antes de você me chamar de louco vou explicar, se você é um programador Java e ficou muito ofendido com o que eu disse ... me desculpe essa não foi a intenssão! Mas Sr.Programador Java, seu código não está seguro só porque o Sr. usa o modificador de acesso private em suas variáveis de instância, se alguém quiser saber quais são as variáveis presentes em determinadas classes de seu sistema ele pode fazer isso utilizando a própria API do Java a nossa querida Reflection. Logicamente que trabalhar com essa API não é algo trivial, porém, pense duas vezes antes de desafiar um nerd dizendo que seu código está 100% seguro.

Em Python a história também não é diferente, se alguém quiser saber quais variáveis sua classe tem essa pessoa vai acabar descobrindo de um jeito ou de outro. Por isso que a ideia principal de Python é que tudo seja public e somente o necessário, seja private. Muitas vezes quando estamos aprendendo POO o pessoal costuma dizer: "Grande parte das vezes sua classe terá atributos de instância privado e métodos públicos". Mais nem sempre é assim, podemos realmente ter variáveis em nossas classes que não precisam serem private.

Bom, se você está certo que precisa ter variáveis private em sua classe e não quer que ela seja acessível fora da classe onde ela foi especificada, então você terá que informar primeiramente que ela será private, para que o interpretador Python saiba disso. Para dizer que um atributo de instância é private em python utilizamos dois underline antes do nome da variável. Exemplo:

class Gato:
    __raca = None
    ...


Com isso dizemos ao interpretador que o atributo raça é privado. Agora temos que construir dois métodos, um para setar (setter) e outro para recuperar (getter) o valor do atributo. No python 3.x foi introduzida uma sintaxe muito elegante para realizar esse serviço. Veja:

class Gato:
    def __init__(self):
        __raca = None

    @property
    def raca(self):
        return __raca

    @raca.setter
    def raca(self, value):
        self.__raca = value


Viu como é simples? Bom o que fizemos foi definir dois métodos (em python pode-se falar função da classe), onde no primeiro definimos o getter e o segundo o definimos o setter. Observe que os dois métodos tem o mesmo nome, mas possuem anotações diferentes. A primeira anotação @property indica o método é um getter e a segunda anotação @raca.setter indica que o método é um setter,  perceba que a segunda anotação é bem diferente da primeira, nela devemos informar o nome do atributo seguido de ponto e a palavra setter.

Podemos definir que um atributo seja apenas read-only. Para fazer isso basta excluir o método setter. Veja:

class Gato:
    def __init__(self):
        __raca = None

    @property
    def raca(self):
        return __raca

Agora observe como fica natural o acesso aos atributos:

if __name__ == '__main__':
    mimo = Gato()
    megui = Gato()

    mimo.raca = 'angorá turco'
    mimo.idade = 2

    megui.raca = 'siames'
    megui.idade = 1

    print('Megui é da raça {}, e tem {} ano(s) de idade.'.format(megui.raca, megui.idade))
    print('Mimo é da raça {}, e tem {} ano(s) de idade.'.format(mimo.raca, mimo.idade))


Pessoal o post se encerra por aqui! Espero que tenham gostado de aprender um pouco mais sobre Python e veja vocês em um próximo post, até lá e BONS ESTUDOS!

MinhaData versão Python

Fala pessoal, estava de boa aqui em casa e resolvi programar um pouco em Python. Implementei a classe MinhaData que originalmente foi escrita em Java.

Quando executei descobri um agravante, o código em Java estava cortando o resultado quando as datas passadas eram muito distantes. Já em Python não tive esse problema e a execução do código também se mostrou mais rápida ... o que o Java fazia em x minutos Python fazia em x/2.

Vamos ver como ficou? Segue o código ai:

MinhaData.py
#-*- encoding: utf-8 -*- import timeit class MinhaData(): def __init__(self, dia, mes, ano): self.dia = dia self.mes = mes self.ano = ano def isBissexto(self, ano): if ano % 4 == 0 and (ano % 100 != 0 or ano % 400 == 0): return True return False def calcDias(self, d1, d2): return abs(self.qtdeDias(d1) - self.qtdeDias(d2)) def qtdeDias(self, data): nroDiasMes = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] dias = 0 for dia in range(1, data.dia+1): dias += 1 for mes in range(data.mes): dias += nroDiasMes[mes] for ano in range(1, data.ano+1): if self.isBissexto(ano): dias += 366 else: dias += 365 return dias if __name__ == '__main__': d1 = MinhaData(21,03,2013) d2 = MinhaData(21,03,1994) print('Intervalo de',d1.calcDias(d1, d2), 'dia(s)')

Pessoal estou preparando um post juntamente com o Guilherme Bueno onde comparamos o desempenho das linguagens de programação: Java, C/C++ e Python executando um mesmo algoritmo ... aguadem. Bons estudos!!!

Python 3 - Leitura de dados com input()

Introdução

Olá pessoal, ultimamente venho estudando a linguagem de programação Python. Quando iniciei meus estudos o Python estava em sua versão 2.7. Nessa versão criei toda a minha base que tenho hoje de Python, porém, o Python foi atualizado para a versão 3. Nessa versão algumas funções foram modificadas consequentemente o modo de utilizá-las também. Hoje foi falar da função de capturar entradas do teclado.

Python 2

Na versão anterior (usada em vários sistemas) para se capturar entradas do teclado era necessário utilizar a função raw_input(). A função raw_input() retorna uma string que pode ser convertida em qualquer tipo númerico de Python. Exemplo:

nome = raw_input('Entre com o nome : ') idade = int(raw_input('Entre com a idade : ')
A primeira linha retorna uma string com o nome que o usuário digitou. A segunda linha retorna uma string com a idade digita e logo em seguida a função int() converte essa string para um valor número inteiro.

Python 3

Na versão 3 do Python a função raw_input() mudou de nome e passou a se chamar apenas input(). A ideia original na versão 3 do Python era que as funções input e raw_input() deixassem de existir. Se isso acontecesse uma simples ação de ler dados do teclado seria algo assim:

import sys print ('Entre com o nome : ') nome = sys.stdin.readline()
Muito mais trabalhoso não é mesmo!!! Portanto a escolha foi substituir raw_input() por input(). Veja como ficaria:

nome = input('Entre com o nome : ') idade = int(input('Entre com a idade : ')

Bom é isso ai galera, se você gosta de Python, Java e programação em geral continue acompanhando o blog. Deixe o seu comentário!!! Abs.

Praticidade em foco: Python + SQLite

Introdução

SQLite é uma biblioteca Open Source escrita em linguagem C, que implementa um interpretador SQL, e provê funcionalidades de banco de dados, usando arquivos, sem a necessidade de um processo servidor separado ou de configuração manual.

A vantagem mais significativa de usar o SQLite é a praticidade, principalmente no uso em aplicativos locais para desktops, aonde usar um SGBD convencional seria desnecessário e complicado de manter. (texto retirado do livro Python para desenvolvedores).

# -*- coding: utf-8 -*- import sqlite3 # Cria uma conexão e um cursor con = sqlite3.connect('contatos.db') cur = con.cursor() # Cria uma tabela sql = 'create table contatos '\ '(id integer primary key, '\ 'nome varchar(100), '\ 'email varchar(100))' cur.execute(sql) # sentença SQL para inserir registros sql = 'insert into contatos values (null, ?, ?)' # Dados recset = [('guilherme', 'gui@gui.com'), ('giovanna', 'gii@gii.com')] # Insere os registros for rec in recset: cur.execute(sql, rec) # Confirma a transação con.commit() # Seleciona todos os registros cur.execute('select * from contatos') # Recupera os resultados recset = cur.fetchall() # Mostra for rec in recset: print '%d: %s(%s)' % rec # Fecha a conexão con.close()

Esse é o jeito tradicional de se conectar a um banco de dados utilizando o Python puro. Também podemos utilizar ferramentas ORM para facilitar e agilizar nosso trabalho. Uma excelente ferramenta ORM para Python é a SQLAlchemy, em posts futuros abordarei mais sobre esse incrível framework.

Arquivo de I/O em Python

Introdução

Escrever em arquivos é uma necessidade que muitas vezes você vai se deparar, seja para criar um arquivo de log ou mesmo para persistir as informações de seu sistema. A manipulação de arquivos em Python ocorre de uma maneira bem simples e tranquila, com apenas 2 linhas de código podemos criar e escrever ou ler um arquivo. 

Criando um arquivo em Python

O função open retorna um objeto de arquivo, e é frequentemente utilizada com dois argumentos: open (arquivo_nome, modo_operacao).

f = open ('arquivo.txt', 'w') f.close ()
O primeiro parâmetro é o nome do arquivo que será aberto, o segundo parâmetro é o modo de operação que esse arquivo será aberto:

• w : Será aberto para edição (write). Quando um arquivo é aberto com 'w' todo os texto que o arquivo tinha antes de ser aberto é perdido.
• r : Será aberto para leitura (read). Quando um arquivo é aberto com 'r' é possível acessar todo o seu conteudo para leitura, porém, nada pode ser inserido ou removido.
• r + : abre o arquivo tanto para leitura quanto para escrita.
• a : Funciona como o 'w', porém, não apaga o texto que havia no arquivo antes do mesmo ser aberto.

Leitura arquivos

Para ler o conteúdo de um arquivo utilizamos f.read (size), que lê todos os dados do arquivo e retornam esses dados como uma string. Se o parâmetro for omitido então todo os conteúdo do arquivo será carregado, caso contrário só será carregado o tamanho em bytes do valor passado por parâmetro. Se o fim do arquivo for atingido f.read () irá retornar um arquivo vazio.

Para ler uma única linha do arquivo utilizamos o comando f.readline (). Se f.readline () retornar uma linha vazia o arquivo acabou.

Também é possível retornar todas as linhas do arquivo com o comando f.readlines (), você ainda pode passar por parâmetro o valor em bytes que deseja carregar (ler) do arquivo. Se o valor for omitido todo o conteúdo do arquivo será omitido.

Ainda na leitura de arquivos podemos utilizar o comando for para realizar essa tarefa. Utilizá-lo é mais eficiente, rápido e resulta em código mais simples.

f = open ('notas.txt', 'r') for line in f: print line f.close ()

Escrita de arquivos

Para escrever algo em um arquivo podemos utilizar o comando f.write ('Guilherme Arthur de Carvalho'). Esse método escreve o conteúdo da string para o arquivo e retorna None.

Como o write só escreve objetos do tipo string, se desejar escrever algo que não seja string é necessário converter o valor para string. Lembrando que quando abrimos um arquivo no modo de operação w todo o conteúdo que existia antes no arquivo é apagado.

Se você deseja apenas adicionar texto para seu arquivo, ou seja, concatenar informações abra ele no modo de operação 'a'.

Laços For e While em Python

Introdução

Laços de repetição são usados para repetir código N vezes dentro de um programa. Em Python temos dois comandos para realizar uma repetição, podemos dizer que usamos um deles quando sabemos a quantidade de iterações (loops) que o código irá fazer, e o outro quando essa quantidade é desconhecida.

For

É a estrutura de repetição mais usada no Python. A instrução aceita não só sequências estáticas, mas também sequências geradas por iteradores. Iteradores são estruturas que permitem iterações, ou seja, acesso aos itens de uma coleção de elementos, de forma sequencial.

Podemos utilizar o comando break para interromper o laço e o comando continue para passar para próxima iteração. Podemos adicionar uma condição else fazendo assim o código presente no else ser executado quando o comando for acabar, o else não será executado se o laço for interrompido pelo comando break.

soma = 0 for i in range (1,10): soma += soma print soma

While

Executa um bloco de código atendendo a uma condição, podemos definir o comando While como um if que repete. Então enquanto a condição que está sendo verificada pelo comando while for satisfeita, o bloco de código presente em seu interior será executado.

i = 0 while (i < 10): print i

O laço while é recomendado quando não sabemos ao certo quantas vezes o comando deve se repetir.

Sintaxe do Python

Introdução

Python é uma linguagem muito produtiva, com poucas linhas de código você pode codificar coisas muito interessantes. Para programar em Python não precisamos usar ponto e vírgula, chaves e outros tantos caracteres de marcação que são comumente esquecidos quando estamos codificando. Isso faz com que o índice de erros seja muito menor facilitando assim o nosso trabalho.

Comentários

Para comentar códigos em Python temos de usar o caractere "jogo da velha" #. Essa é a única forma que temos para comentar códigos na linguagem Python. Qualquer texto adicionado depois desse caractere será ignorado, é válido ressaltar que esse comentário é de linha, ou seja, ele é valido somente na linha em que foi inserido.

Em Python temos os comentários funcionais, que podem ser utilizados para alterar a codificação do arquivo fonte do programa. Se faz necessário alterar a codificação do arquivo do programa para que o mesmo suporte caracteres que não estão presentes na língua inglesa. Exemplo de uso: #-*- encoding: utf-8 -*-.

Comentários funcionais servem também para definir o interpretador que será utilizado para rodar o programa em sistemas UNIX. Exemplo de uso: #!/usr/bin/env.

#!/usr/bin/env #-*- encoding: utf-8 -*- #acima temos um exemplo de comentário funcional, e eu sou um comentário print 21/3 #exemplo de quebra de linha a = 5 + 10 \ - 10 print a

Blocos

Na maioria das linguagens os blocos são delimitados por chaves (Java, C++, C#), quando não os blocos são delimitados por palavras chaves (Delphi, VB, Pascal). Em Python os blocos são delimitados por tabulação (endentação) por padrão usamos 4 espaços. Com essa regra além de deixar o código mais enxuto também deixa-o organizado, pois se ele não estiver endentado o interpretador não irá executar o código.

A linha anterior ao bloco, ou seja, onde ele está contido termina com dois pontos. E pode ser uma estrutura de controle da linguagem ou uma declaração de uma nova estrutura.

a = 10 if a%2 == 0: print "par" else print "impar"

Porque usar python?

Introdução

Quando iniciamos na área de TI nossa primeira escolha é saber de fato em que caminho queremos seguir. Quando decidimos isso ainda temos uma série de escolhas que vamos ter que fazer ao longo de nossas vidas profissionais. Uma dúvida clássica entre os desenvolvedores de software é "Qual é a melhor linguagem de programação". Assim como aquela velha discussão de "Qual é o melhor sistema operacional", a melhor linguagem de programação não existe, o que existe são problemas que cada uma resolve de um jeito diferente isso as tornam boas, mas ao mesmo tempo pode ser um ponto negativo se olharmos de outra perspectiva. Hoje vou falar de Python, uma linguagem que não é a melhor de todas e muito menos à que vai te deixar rico ou resolver todos os seus problemas. Se você é muito fã de C/C++, Java, C# ou derivados que fique claro que eu não estou comparando Python com nenhuma delas, apenas estou mostrando as qualidades que ela possui Ok? Vamos lá!

Qualidade de software

Para muitos, o foco do Python sobre legibilidade, coerência e qualidade do software em geral distingue-se de outras ferramentas no mundo de scripts. Python foi criado para ser legível, e portanto códigos escritos em python são reutilizáveis e sustentáveis  muito mais do que em linguagens tradicionais. A uniformidade de código do Python é fácil de entender, mesmo que você não conheça a linguagem. Além disso Python tem apoio profundo para reutilização de software, conta com mecanismos mais avançados tais como programação orientada a objeto (POO).

Produtividade

Python é mais produtivo do que linguagens compiladas ou esticamente tipadas, tais como C/C++ e Java. Os código escritos em Python geralmente equivalem a um terço ou até mesmo um quinto do tamanho de códigos escritos em C/C++ ou Java. Isso representa menos código para debugar e menos código para manter. Os programas escritos em Python também executam simultaneamente, isso ocorre porque o Python é uma linguagem interpretada sem que haja a necessidade de compilar o código a cada nova alteração.

Portabilidade

A maioria dos programas em Python executam inalterados em todas as principais plataformas de computador. A portabilidade do código entre Linux e Windows, por exemplo, geralmente é apenas uma questão de copiar um código de script entre máquinas. Além disso, Python oferece multiplas opções para a codificação de interfaces gráficas, programas de acesso ao banco de dados, desenvolvimento web, e muito mais.

Suporte a bibliotecas

Python vem com uma grande coleção de modelos reutilizáveis e funcionalidade portátil, conhecida como a biblioteca padrão. Está biblioteca suporta uma vasta gama de tarefas em nível de aplicação. Mais por ser aberto o Python possui muitas bibliotecas disponibilizadas por terceiros que são projetas para trabalhar especificamente com alguns tipos de dados e informações, alguns bons exemplos são: 

• NumPy: Essa biblioteca foi desenhada para a manipulação de vetores e matrizes. Ela é tão poderosa quanto a ferramenta Matilab.
• SQLAlchemy: biblioteca de mapeamento objeto-relacional SQL, provém "de uma suíte completa do conhecido nível-empresarial de padrões de persistência, desenvolvido para eficiência e alta performance no acesso à banco de dados.
• Twisted: Framework completo para trabalhar com protocolos de redes.

Integração

Scripts Python pode facilmente comunicar-se com outras partes de um aplicativo, usando uma variedade de mecanismos de integração. Tais integrações permitem que o Python possa ser utilizado como um personalização do produto e da ferramenta de extensão. Hoje, o código Python pode invocar C e Bibliotecas C++, pode ser chamado de códigos escritos em C e C++ (CPython), pode se integrar com Java (Jython) e. NET (IronPython), pode comunicar através de quadros como COM, pode ser interface com dispositivos mais portas seriais, e pode interagir em redes com SOAP, XML-RPC e CORBA.

Satisfação

Devido a sua facilidade e seu conjunto de ferramentas, Python pode fazer o ato de programar mais prazeroso do que frustrante. Embora isso possa ser um benefício inatingível. Seu efeito sobre a produtividade é um trunfo importante.

Resolução do exercício do curso de Python - Urna

Exercício

Desenvolva uma urna eletrônica utilizando a linguagem de programação Python. O programa deve possuir tupla, dicionário de dados, comandos condicionais e de iteração. O sistema deve computar os votos de todos os candidatos assim como os votos em branco e nulos.
Ao final programa deve informar qual candidato venceu as eleições e mostrar um gráfico semelhante a esse:

Candidato x: ||||||||||||||||||||||||||
Candidato y: |||||||||||||||||||||||||||||||||||||||
Candidato c: |||||||||||||||||||
Candidato b: ||||||||||||||||||||||||||||||||||
Candidato a: ||||

O numero de barras  na frente dos nomes são definidas peçla quantidade de votos que o candidato obteve. Considere que a cidade tenha 200 eleitores.


# -*- coding: utf-8 -*-

t = ('Marcelo ', 'Marcia  ', 'Vermelho', 'Valter  ', 'Branco  ', 'Nulo    ')
d = {t[0]: 0, t[1]: 0, t[2]: 0, t[3]: 0, t[4]: 0, t[5]: 0}

print """
        \nMarcelo    15
        \nMarcia     13
        \nValter     55
        \nVermelho   21
        \nBranco     00
        \nNulo       99
        \n
"""
for i in range(50):
    voto = int(raw_input('Informe o número do seu candidato: '))
   
    if voto == 15:  d[t[0]] += 1
    elif voto == 13: d[t[1]] += 1
    elif voto == 21: d[t[2]] += 1
    elif voto == 55: d[t[3]] += 1
    elif voto == 0: d[t[4]] += 1
    else: d[t[5]] += 1

maior = -1
prefeito = ''

for candidato in d.keys():
    grafico = ''
    for i in range(d[candidato]):
        grafico += '|'
       
    if d[candidato] > maior:
        maior = d[candidato]
        prefeito = candidato
   
    print candidato, ':', grafico
   
print 'O candidato ', prefeito, ' é o novo prefeito de Araraquara!'