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! 

Iterator - java.util.Iterator (Post relâmpago)

Fala pessoal, hoje vou falar brevemente da Interface Iterator da nossa querida linguagem de programação Java. Será um post muito prático e sem muito explicação da Interface em si.

Iteradores

Geralmente usamos Lists em nosso código Java, usamos o nosso querido foreach para varrer as informações e pronto, mas algumas vezes temos que ler os itens contidos na List sem estar em uma estrutura de repetição. Quando temos esse tipo de problema a solução mais correta em Java é contar com o auxilio de Iterator que nada mais é que uma Interface.

Essa interface Java disponibiliza alguns métodos muitos úteis e que vão ajudar a você percorrer os elementos um a um sem ter que contar com uma estrutura de repetição. Além de percorrer um a um, o Iterator consegue dizer se ainda há elementos a serem lidos possibilitando assim uma construção em bloco de condição. E por fim uma ultima vantagem e a mais incrível do Iterator é poder modificar o número de elementos enquanto ele é varrido em uma construção while.

Hora do código

Haha, agora é a hora que eu paro de falar e começo a programar =p.

Observe e veja, nesse código utilizamos todos os métodos da Interface Iterator: hasNext(), next() e remove(). Segue o código:

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!

Atualizando o Firefox no Slackware - Slackware [14]

Olá pessoal, cansado do Firefox 15 que a instalação do Slackware 14 traz por padrão? Hoje vou mostrar como atualizar o seu Firefox para a versão mais atual (no momento em que escrevi esse post estava na versão 23). Vamos laá então.

Atualizando o Firefox

Bom primeiramente você deve baixar a versão do Firefox que deseja instalar em sua máquina diretamente pelo site do fornecedor https://www.mozilla.org/pt-BR/firefox/fx/.

Página de download do navegador mozilla firefox.

Após o termino do download vá até o diretório e descompacte o pacote baixado. Abaixo fiz uma pequena demonstração de como utilizar a linha de comando nesse caso. Veja:

root@user:# su -
root@user:# wget http://https://www.mozilla.org/pt-BR/firefox/fx/ firefox-23.0.1.tar.bz2
root@user:# tar -jxvf firefox-23.0.1.tar.bz2
root@user:# mv firefox firefox-23
root@user:# mv firefox /usr/lib/
root@user:# rm /usr/bin/firefox
root@user:# cd /usr/bin
root@user:# ln -s /usr/lib/firefox-23/firefox firefox
root@user:# rm -r /usr/lib/firefox-15.0.1/

Pronto pessoal, lembrando que tudo isso pode ser feito utilizando a interface gráfica. Basta que você abra o navegador de arquivos pela linha de comando logado como root. Se tudo deu certo a tela de entrada do firefox deve ser esta:

Agora você já sabe como fazer para ter sempre o firefox mais atual em seu sistema operacional :). Até a próxima pessoal o/

Liberar som para usuário sem privilégios de root [Slackware 14]

Fala pessoal, hoje vou mostrar como liberar o som para usuário comum no Slackware 14. Eu resolvi mudar de SO e apostei minhas fichas no SO do Patrick (criador da distro), como sei que essa distro tem fama por ser leve e muito prática adotei ela como sistema padrão. Nessa transição de SO (Xubuntu p/ Slackware) tive muitas percas e ganhos. Abaixo fiz uma pequena lista delas:

Percas 

• Central de programas
• Facilidade para instalação de pacotes via terminal
• Não ter que compilar pacotes em todas as instalações

Ganhos

• Velocidade e desempenho
• Pacotes default completos
• Estabilidade de SO

Mas como nem tudo são rosas eu tive/tenho vira e mexe um problema aqui e outro acolá. 

Bom chega de conversa vamos fazer o seu som responder ai para que você possa escutar suas músicas e assistir aos seus vídeos. Abra o seu terminal e entre como root:

>> su -
>> [informe sua senha...]

Agora vamos adicionar o seu usuário ao grupo audio, assim ele terá acesso a todos os dispositivos de áudio:

>> usermod -G audio $seu_usuario

Pronto, faça um logoff ou reboot e tudo estará funfando jovem!
Até a próxima pessoal <o/

Estrutura de dados usando C - Pilha

Olá pessoal, como disse no post biblioteca de estrutura de dados estou criando uma biblioteca para facilitar a vida de programadores que desejam utilizar linguagem C para trabalhar com estrutura de dados, assim como de professores e alunos em sala de aula.

Nesse post irei mostrar como usar a stack.h. Essa biblioteca serve para manipular estrutura de dados do tipo pilha, vamos lá?!

Adicionando a biblioteca em seu arquivo C

Meu objetivo não é dizer o que é uma pilha e nem como ela funciona na memória de seu computador (já estou trabalhando em um post para isso). Hoje vamos aprender como facilitar a sua vida na criação e manipulação de uma pilha.

Primeiramente é necessário que você tenha o código fonte da biblioteca que pode ser obtido no no meu repósitorio de código, feito isso salve em um local de seu HD para que possamos utilizá-lo.

Agora crie um arquivo C para que possamos trabalhar =). Importante: crie o arquivo C no mesmo local onde você salvou o código da biblioteca.

Para adicionar a biblioteca a seu arquivo C use o include passando o caminho em que a mesma se encontra. No nosso caso o arquivo C e o código fonte da biblioteca estão no mesmo local. Veja:

#include "stdio.h" #include "stdlib.h" #include "stack.h"

Declarando uma variável do tipo Pilha e criando uma Pilha

Para declarar uma variável do tipo pilha devemos declarar um ponteiro do tipo Stack, e posteriormente para criar uma pilha na memória devemos chamar a função new( ) que retorna a pilha criada. Veja:

/* Declarando variável do tipo Stack */ Stack* pilha; /* Criando uma Pilha */ pilha = new();

Fácil não é? Pronto com isso temos uma pilha alocada em nossa memória, porém, ela ainda está vazia. Vamos ver como fazemos para inserir valores nessa pilha.

Inserindo e removendo valores da pilha

Até a versão atual da biblioteca (1.0 beta) as estruturas de dados trabalham unicamente com o tipo de dado float. Para inserir valores na pilha temos a função push(Stack*, float), e para remover valores temos a função pop(Stack*). Veja:

/* Adicionando valores a pilha */ push(pilha, 10); push(pilha, 20); push(pilha, 30); /* Removendo valores da pilha */ float item_removido = pop(pilha); printf("%f, foi o item removido \n\n", item_removido);
E ai pessoal está fácil? Nem parece linguagem C? kkkk. Ainda temos mais duas funções que devemos saber trabalhar, digamos que você tenha que listar os valores contidos na pilha ... e agora? Calma pequeno gafanhoto eu também fiz essa função ... ufaa ^_^. E a ultima função é talvez uma das mais importantes, ela será a responsável por liberar o espaço de memória ocupado por sua pilha. Vamos ver como utilizá-las!

Listando valores contidos na pilha, e destruindo a pilha

Algo muito importante quando estamos trabalhando com pilhas é listar os valores que estão contidos na pilha, para fazer isso podemos usar a função show(Satck*), antes de encerrar a nossa aplicação devemos limpar a memória para evitarmos que a mesma fica ocupada com os dados que foram utilizados durante a execução de nosso código. Para destruir a pilha temos a função clean(Stack*). Veja:

/* Exibindo os valores presentes na pilha */ printf("Itens da pilha:\n"); show(pilha); /* Limpando a memória */ clean(pilha);

Pronto pessoal, agora podemos fazer qualquer aplicação C utilizando Pilhas =). Em breve está chegando a versão 2.0, fique ligado no blog. Segue o código completo:

#include "stdio.h" #include "stdlib.h" #include "stack.h" /* Sabemos que para usar a ED de Pilha devemos usar o tipo Stack. * Uma vez que haja uma variável do tipo Stack podemos usar os recursos da stack.h =) */ int main() { /* Declarando variável do tipo Stack */ Stack* pilha; /* Criando uma Pilha */ pilha = new(); /* Adicionando valores a pilha */ push(pilha, 10); push(pilha, 20); push(pilha, 30); /* Removendo valores da pilha */ float item_removido = pop(pilha); printf("%f, foi o item removido \n\n", item_removido); /* Exibindo os valores presentes na pilha */ printf("Itens da pilha:\n"); show(pilha); /* Limpando a memória */ clean(pilha); return 0; }

Bom pessoal e aqui termina mais um post! Se você gostou recomende e assine o nosso feed de noticias para ficar a par das novidades =). Até a próxima!