GUI Tkinter Python 3.2

GUI do inglês Grafic User Interface ou Interface Gráfica com o Usuário é um tipo de interface que permiti o utilizador a interação com elementos digitais através de gráficos como ícones e outros indicadores visuais, foi criado basicamente se pensando como facilitar a interface CLI do inglês Command Line Interface ou Interface por Linha de Comando.

O recurso mais comum de uma GUI é a janela (window), dentro da janela podemos ter componentes (widgets) que fazem a interação com o usuário, esses widgets possuem recursos e funções para auxiliar o controle da interface com o usuário.

Nessa postagem vamos ver como criar uma janela de login usando Python para isso vamos usar três widgets o Label (rotulo), Entry (Entrada, Caixa de Texto), Button (Botão).

No Python 3.2 a biblioteca Tkinter se escreve em letra minúscula ao contrário da verção 2.7 ou anterior. Para colocar os componentes dentro da janela é necessário escolher um método de empacotamento, no Tkinter temos o pack e o grid.

Como só vamos criar a jenela de login e não vamos associá-la a um banco de dados vamos criar uma função fictícia de Login que somente confere de o usuário está dentro de um determinado array, o que se aproxima de uma função com uso de banco de dados.

Código:

from tkinter import *
from tkinter.messagebox import *
#class para manipular a Tkinter - Não é obrigátório
class frmLogin:
def __init__(self,master):
self.master=master
self.master.title('Login de Usuário')
self.master.geometry('180x70-30+30')

self.lblUser=Label(self.master,text='Usuário: ')
#cria uma variavel para manipular o conteudo da Entry
self.txtUser=StringVar()
self.entUser=Entry(self.master,textvariable=self.txtUser)

self.lblPass=Label(self.master,text='Senha: ')
#cria uma variavel para manipular o conteudo da Entry
self.txtPass=StringVar()
self.entPass=Entry(self.master,textvariable=self.txtPass,show='*')

self.btnLogin=Button(self.master,text='Login',command=self.onLogin)

self.lblUser.grid(column=0,row=0)
self.entUser.grid(column=1,row=0)
self.lblPass.grid(column=0,row=1)
self.entPass.grid(column=1,row=1)
self.btnLogin.grid(column=1,row=2)
def onLogin(self):
users={
'admin':'adm1234',
'pablo':'isnotadmin',
'convidado':''
}
if self.txtUser.get() != '':
try:
if users[self.txtUser.get()] == self.txtPass.get():
showinfo(title='Aviso!',message='Login efetuado com sucesso!')
else:
showwarning(title='Aviso!',message='Usuário ou senha desconhecidos!')
except IndexError:
showwarning(title='Aviso!',message='Usuário desconhecido!')
else:
showwarning(title='Aviso!',message='Digite um usuário!')

if __name__ == "__main__":
Janela = Tk()
frmLogin(Janela)
Janela.mainloop()

Sistema de chat em Python 3.2

Nesta postagem vou mostrar o poder do Python quando o assunto é redes de computadores, com poucos códigos podemos criar um socket cliente/servidor para um sistema de chat, também vou explicar como usar Thread em Python.

Especificamente em informática no ramos de redes de computadores, um Socket pode ser usado para um elo bidirecional de comunicação entre dois programas. A interface padronizada de Socket surgiu originalmente no S.O Unix BSD (Berkeley Software Distribution).

Linha de execução (em inglês: Thread), é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrentemente. O suporte a thread é fornecido pelo próprio sistema operacional (SO) ou por meio de uma biblioteca de linguagem.

Saindo um pouco da teoria e indo para a prática o que vamos fazer é o seguinte, criaremos um arquivo chamado servidor.py que vai criar um bind (vinculo), deixando o programa em espera por uma conexão. E criaremos um arquivo cliente.py que simplesmente irá conectar ao servidor.py e se comunicar com ele. Inicialmente vamos usar uma interface CLI (Command Line Interface), mas depois vou fazer uma postagem sobre esse sistema de chat como GUI (Grafic User Interface).

servidor.py:

from socket import socket,AF_INET,SOCK_STREAM
from threading import Thread

#classe para manipular o socket
class Send:
 def __init__(self):
  self.__msg=''
  self.new=True
  self.con=None
 def put(self,msg):
  self.__msg=msg
  if self.con != None:
   #envia um mensagem atravez de uma conexão socket
   self.con.send(str.encode(self.__msg))
 def get(self):
  return self.__msg
 def loop(self):
  return self.new

#função esperar - Thread
def esperar(tcp,send,host='',port=5000):
 origem=(host,port)
 #cria um vinculo
 tcp.bind(origem)
 #deixa em espera
 tcp.listen(1)
 
 while True:
  #aceita um conexão
  con,cliente=tcp.accept()
  print('Cliente ',cliente,' conectado!')
  #atribui a conexão ao manipulador
  send.con=con
  
  while True:
   #aceita uma mensagem
   msg=con.recv(1024)
   if not msg: break
   print(str(msg,'utf-8'))

if __name__ == '__main__':
 #cria um socket
 tcp=socket(AF_INET,SOCK_STREAM)
 send=Send()
 #cria um Thread e usa a função esperar com dois argumentos
 processo=Thread(target=esperar,args=(tcp,send))
 processo.start()
 
 print('Iniciando o servidor de chat!')
 print('Aguarde alguém conectar!')
 
 msg=input()
 while True:
  send.put(msg)
  msg=input()
 
 processo.join()
 tcp.close()
 exit()

cliente.py:

from socket import socket,AF_INET,SOCK_STREAM
from threading import Thread

#classe para manipular o socket
class Send:
 def __init__(self):
  self.__msg=''
  self.new=True
  self.con=None
 def put(self,msg):
  self.__msg=msg
  if self.con != None:
   #envia um mensagem atravez de uma conexão socket
   self.con.send(str.encode(self.__msg))
 def get(self):
  return self.__msg
 def loop(self):
  return self.new

#função esperar - Thread
def esperar(tcp,send,host='localhost',port=5000):
 destino=(host,port)
 #conecta a um servidor
 tcp.connect(destino)
 
 while send.loop():
  print('Conectado a ',host,'.')
  #atribui a conexão ao manipulador
  send.con=tcp
  while send.loop():
   #aceita uma mensagem
   msg=tcp.recv(1024)
   if not msg: break
   print(str(msg,'utf-8'))

if __name__ == '__main__':
 print('Digite o nome ou IP do servidor(localhost): ')
 host=input()
 
 if host=='':
  host = '127.0.0.1'
 
 #cria um socket
 tcp=socket(AF_INET,SOCK_STREAM)
 send=Send()
 #cria um Thread e usa a função esperar com dois argumentos
 processo=Thread(target=esperar,args=(tcp,send,host))
 processo.start()
 print('')
 
 msg=input()
 while True:
  send.put(msg)
  msg=input()
 
 processo.join()
 tcp.close()
 exit()

Python

A linguagem de programação Python é uma linguagem de programação orientada a objetos POO muito popular em ambientes Like Unix por ser uma linguagem script de desenvolvimento rápido, com o crescimento da linguagem hoje ela é aplicada em muitos meios como websites, programas financeiros, script para administração de redes, projetos científicos, jogos (normalmente usando a pyGame), etc.
Comparando o Python com a linguagem C/C++, vamos perceber muitas diferenças, começando pela declaração de variáveis, no C/C++ é necessário declarar o tipo da variável antes de usá-la e depois atribuir um valor, no Python declaramos uma variável atribuindo um valor a ela.
C/C++:

int valor = 14;

Python:

valor=14

Outra coisa interessante a ser citada é que no C/C++ é necessário colocar um ponto e virgula ( ; ) no final de cada linha, no Python não é necessário. No C/C++ usamos constantemente chaves ( { ) ( } ) para criar códigos de funções e classes, no Python usamos tabulações ou espaçamento padrão (recomendo o uso de tabulações já que agiliza na hora de programar).

C/C++:

int soma(int a,int b)
{
 int resultado;
 resultado = a + b;
 return resultado;
}

Python:

def soma(a,b):
 resultado = a + b
 return resultado

No caso de funções as duas linguagens usa a palavra reservada return, no Python para definirmos uma função usamos a palavra reservada def que pode definir uma função ou procedimento (para definir como procedimento basta não colocar return) ao contrario do C/C++ que toda função tem que ter retorno menos quando o tipo é void.

Segue abaixo um código mostrando como usar os principais recursos da linguagem.

#importado a biblioteca calendar e colocando em cd
import calendar as cd
#definindo um calendario do mes de marco de 2011
calendario=cd.month(2011,3)
print(calendario)

#definindo um funcao de multiplicacao por dois
def mul(a):
r=a*2
return a

#criando um loop
i=0
while i <= 10:
print(mul(i))
i+=1
#crindo uma matriz
ma=['um','dia','depois','de','amanhah']

#percorrendo uma matriz
txt=''
for m in ma:
txt+=m+' '
print(txt)

#condicoes
a='oi'
b='tchauu'
if a == 'oi':
print(a)
if a != b:
print(b)
else:
print(b)

#classes
class soma:
def __init__(self,a,b):
self.a=a
self.b=b
def show(self):
print(self.a+self.b)

s=soma(140,300)
s.show()

Google Public DNS

Assim como o serviço do OpenDNS a Google também possuí um serviço de DNS público que pode ser usado por qualquer um. A configuração do DNS primário e secundário segue abaixo:

Primário: 8.8.8.8
Secundário: 8.8.4.4

Não estranhe o número tão baixo, afinal estamos falando do grande oráculo Google.

Programação Multiplataforma

Hoje em dia é comum ouvirmos falar sobre programação multiplataforma, mas antigamente isso era só para quem era aventureiro, tipo aqueles Nerds (detalhe: sou um deles!) que não tinha nada para fazer e baixavam o GNU/Linux para desvendar seu SO (Sistema Operacional) criando aquele dicionário de códigos que mais parecia uma enciclopédia (detalhe: já fiz isso) só para se orientar.

Antes do ano 2000 a realidade tecnológica no Brasil era retratada da seguinte forma, o publico comum só sabia mexer no MS Windows 98 e no Office 2000 (para aquela época era muita coisa!). Os serviços de hospedagem na internet era só para quem tinha dinheiro, muitos optavam por criar seu próprio servidor por causa do auto custo, mesmo porque não estava começando a se popularizar os e-Commerce no Brasil, no exterior começou a ganhar força sistema operacionais abertos como o GNU/Linux e os BSD ambos Like Unix (baseados no padrão POXIS usado no Unix), os servidores abertos começaram e impregnar a internet já que havia um baixo custo para montá-los além de serem seguros e estáveis comparado com o SO dominante na época o MS Windows NT 4 e o MS Windows 2000 para os mais ousados. Mas não foi nesse momento que a programação multiplataforma ganhou foco, depois de um tempo os sistema operacionais abertos (hoje conhecidos como Software Livre) começaram a ganhar um espaço na casa do cidadão comum (isso no exterior), foi nesse momento que a programação multiplataforma começou a se torna necessária, já que agora não existia mais um padrão definido, nem tudo era MS Windows, existia outros opções como Red Hat Linux, Debiam Linux, Macintosh Mac OS (que depois de alguns anos começou a ganhar força fora dos USA). Agora o programador tinha que escolher um público-alvo para desenvolver seu software, mas surgiu a ideia “porque não desenvolver uma plataforma de programação independente de sistema operacional, foi assim que surgiu o Java da Sun, hoje da Oracle.

Hoje temos diversas opções de plataformas de programação multiplataforma como Java, Python, Ruby, TCL/TK. A vantagem de desenvolver nessas linguagens é o conceito que o que desenvolvermos no GNU/Linux vai funcionar no MS Windows, Mac OS e FreeBSD. A desvantagem é que estamos falando de linguagens script (tirando Java) que não há garantias de proteção do código (no caso de java existe programas de descompilação) o que faz muitos programadores ficarem com medo que seus projetos sejam jogados fora. Mas colocando a realidade em foco, hoje existe tantos programas gratuitos e tantos programas de código aberto que não faz mais sentido esconder o código de fonte de um programa.

Esta postagem é mais como um alerta aos programadores, pense na seguinte hipótese, você é contratado para fazer um programa para um empresa de Logística que atualmente usa MS Windows 2008 Server no servidor da rede e nos computadores locais o MS Windows XP PRO, depois de seis meses em trabalho em grupo o programa está pronto e com poucos bugs (sempre vai existir bugs) depois de um ano seu cliente resolve do nada renovar o patio tecnológico e recebe uma proposta irrecusável da Mac Store de comprar iMac com 70% de desconto no atacado já com os software da Apple instalados e licenciados, seu cliente te liga e fala que quer que o programa que você ver funcione nos iMac e ele precisa disso para ontem (detalhe: ele trocou o SO do servidor para o Ubuntu Server 10.10), daí vem a pergunta, como você vai fazer isso no curto período de um mês que é justamente o tempo até chegar os iMac na empresa, sendo que o seu projeto foi desenvolvido usando Visual Studio 2010 que só cria programas para o MS Windows. Você pode tentar convencer o seu cliente de que ele fez uma grande besteira ao comprar os iMac, porém existe muitos programadores multiplataforma no mercado, você passa a ter um grande problema em suas mãos.

Esse é um dos motivos da importância do desenvolvimento multiplataforma, já independente do que seu cliente usa, o seu programa funciona.