Como se tornar Programador Python Profissional - Curso com Certificado

De todas as inúmeras perguntas e dúvidas que recebemos aqui diariamente, sem dúvidas a mais recorrente é:

Como me tornar um programador Python profissional, trabalhar com isso?

E não é de se surpreender, Python é uma linguagem fantástica, simplesmente linda, apaixonante, simples de aprender, usar e absurdamente poderosa.

Se estudar e programar Python já é bom, imagina:

• Ganhar dinheiro com Python
• Ter seu apartamento ou casa, graças ao Python

• Ter um carro bacana, seguro e bonito, com dinheiro vinda da programação Python

• Fazer viagens, conhecer o mundo e novas culturas, graças ao seu trabalho com Python

E sim, isso é possível!
Faça seu café, sente-se confortavelmente e tire 15min do seu dia para ler algo que pode mudar sua vida.

Programador Python: Tem mercado? Quem precisa ?

Você tem amigos que cursam ou cursaram direito?
Eu tenho (muitos, diga-se de passagem).

Pergunte a eles como está o mercado, o salário...e prepare-se para histórias tristes. É muito, muito difícil conseguir um emprego para quem é formado em cursos como Direito, Administração etc. Nada contra, pelo amor de deus.

Mas o motivo é bem simples: todo bairro hoje em dia tem uma faculdade que oferece esses cursos. E o número de formandos é imenso. Todo santo semestre dezenas de milhares de alunos se formam nessas áreas...e infelizmente não tem vaga pra todo mundo.

Até pra medicina, curso notavelmente conhecido por seu bom salário e a existência de vagas, a coisa está complicando. O salário médio de um médico vem diminuindo, é algo extremamente difícil conseguir uma residência pra se especializar...e muitos tem que ir pra interior, e todos sem exceção, fazem jornadas árduas e longas de trabalho.

E não é pra menos, cada vez mais faculdades, formandos, situação ruim do país...

E pra Python, como está o mercado?

Quantos advogados, engenheiros, estudantes de medicina, economia, administração etc, você conhece? Muitos, aposto.

E programadores? Se conhecer um, já é muito.

Agora outro exercício:

• Olhe pra suas mãos: celular, tablet, notebooke...
• Olhe pra frente: notebook, TV smart, painel digital de um carro...
• Olhe ao redor: em supermercados, ruas, farmácias, pro céu...

Onde não tem programação? Duvido achar um local que não tenha algo com algum software. Pode ir em uma favela ou sertão nordestino que vai ver gente com algum dispositivo digital.

O aumento do uso da tecnologia é MEDONHO. A carência, necessidade de gente nessa área é MONSTRA.

E o tanto de gente nessa área você respondeu: é pouco!
Raro encontrar um programador, alguém que faz isso, vive disso...e não é pra menos, não é algo tão simples.

Quem usa Python?

O segredo da programação no Mercado de Trabalho

Cada vez mais a tecnologia vai estar presente no mundo, inclusive substituindo humanos.

E quem vai sair na vantagem? Quem é da área.
Vão precisa de fazer pra fazer, criar, organizar, ensinar...coisas relacionadas a tecnologia e programação.

Sempre. O mundo vai ser dos programadores, a verdade é essa. Pura, simples e clara.

Desde grandes companhias aéreas, fábricas de carros até o botequim do seu Zé vai precisar de tecnologia, softwares....amigos, tudo, em todo canto, é sério.

Ao contrário de advogados e administradores, que não a demanda é menor e o tanto de gente estudando é cada vez maior, no mundo da programação é o oposto: cada vez mais precisamos de programadores e tá cada vez mais raro achar um.

Não estou tentando de convencer ou 'vender meu peixe', até porque não vamos ganhar nada com isso. Apenas olhe ao seu redor e tire suas conclusões.

Como Ser Programador Python

Tem certeza absoluta da importância e que nunca vai faltar trabalhos para um programador? Excelente.

Vamos mais além: dos programadores, a gigantesca maioria ou sabe PHP ou Java. Nada contra. Mas ache um programador Python, uma linguagem em crescimento exponencial nos Estados Unidos, Japão e Europa. Não acha.

E quem sabe Python, sabe criar sites, fazer aplicativos, serve para trabalhos acadêmicos, etc etc etc. Aprende uma coisa, depois vai ter é dificuldade de qual área seguir, de tantas possibilidades.

Então vamos te ensinar agora como ser um programador Python.
São apenas dois passos.

Passo 1 para ser Programador:
Estude insanamente

Não tem pra onde correr.

Se perguntar aos melhores engenheiros, médicos, físicos, programadores, empresários e tudo mais que imaginar, o que fizeram diferente, a resposta vai ser: me esforcei mais que a maioria.

Sinto te informar, mas fazendo o que todo mundo faz, o tanto que todo mundo faz, você vai ser só mais um.

Quer ser realmente bom, foda, viver bem, ajudar sua família, viajar e tudo mais? Faça mais que a maioria.

• Enquanto a maioria estiver vendo série, estude e programe.
• Enquanto a maioria tá vendo tv e BBB, estude e programe.
• Enquanto a maioria tá dormindo até meio-dia, estude e programe.
• Enquanto a maioria tá perdendo tempo, fazendo nada e vendo o tempo passar, estude e programe.

Não tem segredo nem mistério, é estudar muito, o máximo possível. De noite, no ônibus, dar uma lidinha antes de dormir etc etc.

Pra fazer isso, a gente tá aqui pra te ajudar.
Se estudar pelo Curso Python Progressivo, vai ter um curso completo, bem explicado, com muitos exemplos, exercícios, projetos reais, indicação de vídeos, livros...CONSUMA TUDO!

Estude e tente fazer os programas até chorar em posição fetal (isso acontece muito, até durmo assim vez e outra, de tão acostumado).

Essa é a parte mais importante, é 99% do segredo para se tornar um bom programador Python profissional, é a mais difícil, trabalhosa e custosa.

A segunda parte é, de longe, a mais fácil, simples e barata.

Passo 2 para ser Programador:
Obtenha um certificado

Você pode ser o médico mais foda do universo, mas só vai trabalhar se for formado e tiver seu diploma.

Mesmo Einstein, pra dar aula de Física, teve que se formar e obter certificado (ele odiava aula, faculdade e teve muita dificuldade pra se formar, de tão chato que achava).

Não importa o que vai fazer, é preciso que, digamos, você 'prove' que estudou. No caso do nosso mundo da programação e computação, isso vem por meio de certificado e diploma.

Se não faz faculdade, não tem tempo, dinheiro ou mesmo curso na sua cidade, relaxe totalmente. Um bom programador é reconhecido por seu talento, seu código, seu software, e não se é formado na Uniesquina, ITA ou curso online.

Então, dou aqui a solução pra vocês, que usei:

Clique para obter sua certificação

Curso de Python com Certificado:

Por que fazer ?

Bom, vamos resumir o motivo pela qual você deve fazer o curso acima, o mais rápido possível:

• Preço: é absurdamente barato, chega a ser ridículo o preço R$ 39,90. Pagamento único. Sim, tem que meter a mão no bolso, eu meti, todo mundo que vive de Python já pagou e não existe outro jeito de ter sua certificação

• Tempo de aula: são 72 horas / aula, e você pode aumentar até pra 252 h /aula, para aumentar sua capacitação e certificados

• Acesso: só precisa ter internet. Pode acessar do computador, tablet, celular, no ônibus, no intervalo da escola/faculdade/trabalho. Tá sempre online.

• Disponibilidade: 24 horas. Qualquer dia, qualquer horário, dia de semana, final de semana, feriado...estude quando quiser e quando puder (é aqui que a galera de faculdade sente inveja)

• Ritmo: demore o tempo que quiser, em qualquer aula, explicação, exercícios etc. Faça tudo no seu tempo. Só tem 20 min durante o almoço? Pode ter seu certificado. Só 1h antes de dormir? Opa, aqui mesmo que vai obter seu certificado. Demora pra aprender? Vá devagar, repita...Esqueceu? Volte e estude de novo

• Material: o curso inteiro é bem organizado e dividido por etapas. Tem um banco de perguntas e respostas com dúvidas de outros alunos, além de resumos disponíveis para consulta (usava muito pra relembrar facilmente algo que já tinha estudado, sempre esqueço)

• Certificado: Serve para completar Horas em Atividades Extracurriculares,  em Universidades. Pode contar como Atividades em Concursos Públicos. Pode constar em seu Currículo. Através da Autenticação Digital, confirmam sua conclusão na Brava Cursos Online

Certificado válido em todo território nacional.

Conteúdo do Curso de Python

O curso desenvolverá no aluno a capacidade de:

• Aprender a programar em uma linguagem simples e poderosa
• Resolver problemas utilizando uma linguagem de programação
• Desenvolver seus próprios programas de computador
• Aprender boas práticas de programação
• Conhecer os mais variados aspectos da linguagem Python
• Desenvolver o raciocínio lógico
• Cálculos matemáticos

CONTEÚDO PROGRAMÁTICO:

• Apresentação
• Um pouco mais sobre o criador do Python
• Características da linguagem
• Preparando o ambiente
• Começando a programar em Python
• Variáveis
• Operadores
• Estruturas de controle
• Entrada e saída de dados
• Funções
• Listas
• Manipulando listas em Python
• Arquivos
• Manipulando arquivos em Python
• Cálculos matemáticos
• Criando classes
• Utilizando herança
• Interface gráfica
• Palestra Tkinter
• Criando threads
• Dicionários
• O perigo de importar tudo
• Compactador de arquivos
• Estrutura de dados Fila
• Manipulando o tempo
• Programando Games com Python e CodeSkulptor
• Games com CodeSkulptor
• Bioinformática com Python e Rosalind
• Considerações Finais

Clique aqui para fazer o curso

Gerenciador de Layout: Pack, Grid e Place

Neste tutorial de programação gráfica em Python, vamos aprender melhor como gerenciar o layout de nossos programas de interface gráfica.

• Ler esse conteúdo em PDF: Apostila de Python

Gerenciadores de Layout

Como já aprendemos a usar botões, caixa de entrada, caixa de diálogo, radio e checkbuttons, bem como tratar diversos eventos, chegou a hora de aprender como organizar melhor esse amontado de widgets!

Você deve ter notado que fomos adicionando botões, labels...e eles foram se encaixando em um canto, em outro...se você é dos que gosta de fuçar, certamente mexeu e viu widgets sumirem, ou ficarem desalinhados, feios etc.

Os gerenciadores de layout servem para definirmos melhor o posicionamento de nossos widgets em containers (janelas Tk() ou Frame() por exemplo), de modo a organizar e deixar eles esteticamente melhores.

Existem três principais gerenciadores de layout:

1. pack - vai adicionando os widgets na ordem que forem sendo empacotados
2. grid - adiciona através de posições de linhas e coluna, como uma tabela ou grade (grid)
3. place - adiciona widgets em posições específicas, com tamanhos específicos

Gerenciador de Layout: pack

O gerenciador pack é o que vinhamos usando, no decorrer de nossos tutoriais de programação gráfica em Python, e é o mais básico.

Por padrão, ele vai adicionando os widgets na ordem quem forem empacotados (chamando o método pack() ), de cima pra baixo.

Porém, existem várias opções para empacotar os componentes:

• side - indica de que lado você quer que seja adicionado (TOP, BOTTOM, LEFT e RIGHT). Se quer um alinhamento horizontal, use side=LEFT, por exemplo
• fill - para preencher um espaço. Pode usar como argumneto X, Y ou BOTH, e ele vai cobrir todo o espaçamento horizontal (X), vertical (Y) ou ambos (BOTH)
• expand - pode passar como YES ou NO, para definir se o widget vai preencher todo o espaço extra do container ou não.
• padx e pady - preenchem o ao redor do widget com espaço em branco
• pack_forget - retira um widget empacotado do container que foi inserido anteriormente

Estude o seguinte código, rode o script e veja o resultado você mesmo:

from tkinter import *

class PackDemo( Frame ):
 def __init__(self):
  # Inicializando o frame 
  Frame.__init__(self)
  self.master.title("Gerenciador pack")
  self.master.geometry( "600x250" )
  self.pack( expand = YES, fill = BOTH)
  
  # Botao que adiciona outros, no topo
  self.botao1 = Button(self, text = "Adicionar Botão",
         command = self.adicionarBotao)
  self.botao1.pack(side = TOP)
  
  # Botão 2, no fundo e preenche X e Y
  self.botao2 = Button(self,
           text = "expand = NO, fill = BOTH")
  self.botao2.pack( side = BOTTOM, fill = BOTH )
  
  # Botão3: na esquerda, fill só na horizontal
  self.botao3 = Button( self, text = "expand = YES, fill = X" )
  self.botao3.pack( side = LEFT, expand = YES, fill = X )
  
  # Botão4: na direita, fill só na vertical
  self.botao4 = Button( self, text = "expand = YES, fill = Y" )
  self.botao4.pack( side = RIGHT, expand = YES, fill = Y )
  
  mainloop()
  
 def adicionarBotao( self ):
  Button(self, text = "Botão novo" ).pack(pady = 5)
PackDemo()

Gerenciador de Layout: grid

Como o nome sugere, ele vai dividir o container em uma grade (grid em inglês), assim podemos posicionar os elementos dividino o Frame, por exemplo, em x linhas e y linhas.

Cada posição é chamada de célula, ou seja, cada célular é composta por um valor de linha, um valor de coluna e pode ter um widget

A primeira linha (row) é a 0, a segunda coluna é a de número 1, a terceira é de número 2...

A primeira coluna (column) é a 0, a segunda é a 1, a terceira é a 2...

Definimos a posição de cada widget com o método grid(), que recebe os parâmetros row e column, com a respectiva posição e numeração de cada linha e coluna.

Vamos, por exemplo, cria 9 labels, e exibir eles numa grid três por três, ou seja, 3 linhas e 3 colunas.

O código é o seguinte:

from tkinter import *

class Grid( Frame ):
 def __init__(self):
  # Inicializando o frame 
  Frame.__init__(self)
  self.master.title("Grid")
  self.master.geometry( "80x80" )
  
  # Criando os labels e adicionando
  # com o método grid()
  for linha in range(3):
   for coluna in range(3):
    Label(self.master, text=str(linha)+','+str(coluna)).grid(row=linha,column=coluna)
  
  mainloop()

Grid()

E o resultado:

Veja, o primeiro label é o da posição 0,1

O segundo, na primeira linha e segunda coluna é 0,1

Na primeira linha e terceira coluna temos o 0,2

E assim vai...tente ver uma 'tabela', uma 'grade' ao usar o grid.

Sempre que quiser dispor seus elementos, alinhados por linhas e colunas, use o grid.

Um exemplo comum de programas que usam, são os que tem algum formulário, veja:

Veja como fica bem alinhado e bonitinho.

O código pra fazer isso é:

from tkinter import *

class Grid( Frame ):
 def __init__(self):
  # Inicializando o frame 
  Frame.__init__(self)
  self.master.title("Grid")
  
  Label(self.master, text="Nome").grid(row=0)
  Label(self.master, text="Sobrenome").grid(row=1)

  entrada1 = Entry(self.master)
  entrada2 = Entry(self.master)

  entrada1.grid(row=0, column=1)
  entrada2.grid(row=1, column=1)

  mainloop()

Grid()

Note que quando omitimos alguma opção row ou column, é porque o valor padrão é 0.

Para se aprofundar melhor no manager grid, sugerimos pesquisar mais sobre a opção sticky, os métodos rowconfigure e columnconfigure.

Gerenciador de Layout: place

Esse gerenciador não é tão usado, mas é simples de usar, pois basta dizer onde quer inserir cada widget. Pronto.

Porém, isso complica um pouco as coisas.

Note que o pack e o grid faz muita coisa por você, automaticamente, você se estressa com pouca coisa.

O place é mais 'rigoroso', digamos assim, você precisa 'cravar' locais, saber exatamente onde vai cada coisa, até onde, até que altura, até que largura etc. Não vamos nos aprofundar nele.

Para fazer um programa com essa cara:

Rode este código Python:

from tkinter import *

class Place( Frame ):
 def __init__(self):
  top = Tk()
  top.title("place")
  top.geometry("250x200")
  
  # Label e primeira entrada
  label1 = Label(top, text = "Nota 1")
  label1.place(x = 10,y = 10)
  entrada1 = Entry(top, bd = 5)
  entrada1.place(x = 60,y = 10)
  
  # Label e segunda entrada
  label2 = Label(top,text = "Nota 2")
  label2.place(x = 10,y = 50)
  entrada2 = Entry(top,bd = 5)
  entrada2.place(x = 60,y = 50)
 
  # Label e terceira entrada
  label3 = Label(top,text = "Média")
  label3.place(x = 10,y = 150)
  entrada3 = Entry(top,bd = 5)
  entrada3.place(x = 60,y = 150)

  # Botão
  botao = Button(top, text = "Calcular")
  botao.place(x = 100, y = 100)

  top.mainloop()
Place()

Tratamento de Eventos envolvendo Teclado e Teclas

Agora que já aprendemos a tratar eventos envolvendo mouse (clicar, soltar e arrastar), vamos ver como fazer o event handling com seu teclado, quando o usuário pressionar alguma tecla.

• Download: Apostila Python Progressivo

Eventos de Teclado

Control+C copia, Ctrl+V cola, Alt+F4 fecha a janela etc etc.

Esses são alguns 'atalhos' que conhecemos no dia a dia de quem lida com informática.

Nada mais são que eventos.

O navegador, editor de texto ou qualquer janela que esteja usando, é uma GUI, é uma interface gráfica pro usuário e também responde a eventos, como os de teclado, que vamos estudar agora.

Keyboard Events

• <KeyPress> ou <Key> - Dispara quando qualquer tecla é pressionada
• <KeyRelease> - Dispara quando uma tecla é solta ou liberada
• <KeyPress-tecla> ou <Key-tecla> - Quando uma tecla específica, a tecla, é pressionada
• <KeyRelease-tecla> - Quando a tecla específica é solta ou liberada
• <key> - Abreviação ou atalho, faz o mesmo de <KeyPress-tecla>
• <prefixo-tecla> - Dispara quando você aperta a tecla específica tecla enquanto segura a prefixo. Esse prefixo pode ser Alt, Shift ou Control apenas.

Detectar qual tecla foi pressionada

Vamos colocar esses eventos em prática?

Vamos criar um programa que aguarda o usuário digitar alguma tecla, e exibe na tela qual foi pressionada e quando foi liberada.

Vamos criar a classe KeyboardEvent, que é do tipo Frame.

Inicializamos sua classe master, empacotamos, damos um título e definimos um tamanho.

Depois, vamos criar o objeto mensagem, do tipo StringVar(), que vai ter uma string dentro dela que vai ficar mudando, conforme você pressiona e solta as teclas.

Passamos esse objeto como argumento do parâmetro textvariable, de nossa Label label.

Inicialmente, o texto em mensagem é "Aperte uma tecla", é o que vai aparecer no início. Empacotamos o label.

Agora vamos fazer os binds, associar os eventos ao métodos.

Se apertar qualquer tecla, o evento <KeyPress> chama o método teclaPressionada, que seta a mensagem com uma string mostrando a tecla pressionada, que é armazenada no atributo event.char

O mesmo para <KeyRelease>, que chama o método teclaLiberada quando você solta a tecla.

Para detectarmos teclas como Control, Alt e Shift, temos que usar events específicos.

Por exemplo, para detectar a tecla Alt da esquerda (Left, L), usamos: <KeyPress-Alt_L> e para detectar quando ela foi liberada, usamos <KeyRelease-Alt_L>

Veja como ficou nosso código Python:

from tkinter import *

class KeyboardEvent(Frame):
 def __init__(self):
  Frame.__init__(self)
  self.pack(expand=YES, fill=BOTH)
  self.master.title("Eventos de teclado")
  self.master.geometry("250x50")

  # Label e Stringvar que vao exibir a tecla
  self.mensagem = StringVar()
  self.label = Label(self, textvariable = self.mensagem)
  self.mensagem.set("Aperte uma tecla" )
  self.label.pack()
  
  # Fazendo os binding no frame
  self.master.bind( "<KeyPress>", self.teclaPressionada )
  self.master.bind( "<KeyRelease>", self.teclaLiberada )
  self.master.bind( "<KeyPress-Alt_L>", self.altPressionado )
  self.master.bind( "<KeyRelease-Alt_L>", self.altLiberado )
  
  mainloop()
  
 def teclaPressionada( self, event ):
  self.mensagem.set( "Tecla pressionada: " + event.char )
 def teclaLiberada( self, event ):
  self.mensagem.set( "Tecla solta: " + event.char )
 def altPressionado( self, event ):
  self.mensagem.set( "Alt pressionado" )
 def altLiberado( self, event ):
  self.mensagem.set( "Alt liberado" )

# Chamando a classe
KeyboardEvent()

Tratamento de Eventos com Mouse

Neste tutorial, vamos criar um programa para usar, ao mesmo tempo, 5 tratamento de eventos envolvendo mouse, como clicar, soltar e arrastar.

• Faça o download desse site: Apostila de Python

Eventos com Mouse: <ButtonRelease-1> e <B1-Motion>

Vamos te mostrar como criar um programa que detecta se o mouse está dentro da janela, se está fora, se você clicou em algum ponto, soltou e arrastou, bem como mostra as coordenadas em pixels desses eventos.

Para isso, vamos usar 5 eventos:

1. <Button-1> - Botão 1 do mouse (mais a esquerda) é pressionado
2. <ButtonRelease-1> - Botão 1 é liberado (released)
3. <Enter> - Mouse entrou no frame (janela)
4. <Leave> - Mouse deixou o frame da janela
5. <B1-Motion> - Botão 1 do mouse foi arrastado (clicar e segurar)

Desses cinco, dois são novos: o <ButtonRelease-1> e o <B1-Motion>, mas bem fáceis de entender com a explicação do programa, a seguir.

Vamos lá, inicialmente criamos nossa classe MouseEvent, que herda a Frame, logo é um frame.
Inicializamos a classe master (Frame.__init__), depois empacotamos o frame, definimos um título e seu tamanho.

Depois, vamos criar o objeto StringVar(), que vai ser um label que dinâmico, que vai ficar variando e mudando de valor (alterando seu texto). Inicialmente, definimos o texto "Mouse fora da janela" para ele.

Depois, criamos nosso Label, com o parâmetro textvariable recebendo o objeto StringVar.

Agora vamos fazer os binds.
O primeiro, <Button-1>, chama o método botaoPressionado, que recebe o evento do clique e mostra sua posição através dos atributos event.x e event.y, no label.

O segundo bind é com o evento <ButtonRelease-1>, que chama o método botaoLiberado que faz o mesmo do método anterior, mas mostra onde você soltou o botão do mouse.

Depois vem o <Enter> e o <Leave>, eventos que já estudamos, que identificam se o mouse entrou ou saiu do widget em questão, no caso, o frame.


Por fim, o bind com o evento <B1-Motion>, que vai identificar até onde o mouse estará sendo arrastado (clicar, segura e se mover).

Veja como ficou nosso código Python:

from tkinter import *

class MouseEvent( Frame ):
 def __init__( self ):
  # Criando o frame, título e tamanho
  Frame.__init__( self )
  self.pack( expand = YES, fill = BOTH )
  self.master.title( "Eventos com Mouse" )
  self.master.geometry( "300x200" )
  
  # String com a posição do mouse
  self.mousePosicao = StringVar()
  self.mousePosicao.set( "Mouse fora da janela" )
  
  # Criando e posicionando o label embaixo
  self.positionLabel = Label( self,textvariable = self.mousePosicao )
  self.positionLabel.pack( side = BOTTOM )
  
  # Criando os binds com os eventos de mouse
  self.bind( "<Button-1>", self.botaoPressionado )
  self.bind( "<ButtonRelease-1>", self.botaoLiberado )
  self.bind( "<Enter>", self.entrouJanela )
  self.bind( "<Leave>", self.saiuJanela )
  self.bind( "<B1-Motion>", self.mouseArrastado )
  
  mainloop()
  
 def botaoPressionado( self, event ):
  self.mousePosicao.set( "Pressionado em [ " + str( event.x ) +
        ", " + str( event.y ) + " ]" )
 def botaoLiberado( self, event ):
  self.mousePosicao.set( "Solto em [ " + str( event.x ) +
        ", " + str( event.y ) + " ]" )
 def entrouJanela( self, event ):
  self.mousePosicao.set( "Mouse na janela )
 def saiuJanela( self, event ):
  self.mousePosicao.set( "Mouse fora da janela" )
 def mouseArrastado( self, event ):
  self.mousePosicao.set( "Arrastado até [ " + str( event.x ) +
        ", " + str( event.y ) + " ]" )
  
# Chamando a classe
MouseEvent()

Eventos com Botão - < Enter > e < Leave >

Neste tutorial de Python, vamos aprender como usar dois eventos associados aos botões: o <Enter> e o <Leave>, e vamos ver como tratar events com mouse do usuário.

• Acesse esse conteúdo pelo computador, celular, tablet etc e estude pelo PDF por onde quiser: Apostila de Python

Eventos <Enter> e <Leave> de botões

Agora que já aprendemos a trabalhar com o widget Button, vamos aprender a usar eventos com botões.

Vamos usar dois eventos:

• <Enter> : Quando você passa o mouse por cima do botão
• <Leave>: Quando você tira o mouse de cima do botão

Vamos fazer dois binds:

1. Com o evento <Enter>, que chama o método passou_por_cima
2. Com o evento <Leave>, que chama o método saiu_de_cima

Ou seja, quando você passa o mouse por cima do botão, um event handler é acionado.

Quando você tira o mouse de cima, outro event handler é acionado.

Não devemos esquecer de passar o objeto event para estes métodos de tratamento, é lá que vamos usar o método widget.config() para alterar o relevo do botão.

Esses métodos de tratamento de evento vão simplesmente mudar a textura do botão.

Quando passa o mouse por cima, temos o estilo GROOVE (de entrar, simulando o botão entrando.

Quando tiramos o mouse de cima, acionamos o estilo RAISED (de levantar o botão que tava pra dentro).

E quando apertamos o botão, o método apertou é acionado.

Veja como fica nosso código:

from tkinter import *
from tkinter import messagebox

class ButtonEvent( Frame ):
 def __init__( self ):
  Frame.__init__( self )
  self.pack()
  self.master.title( "Botão" )
  self.master.geometry("120x40")
  
  # Criando botão
  self.botao = Button( self, text = "Clique aqui", command = self.apertou )
  self.botao.bind( "<Enter>", self.passou_por_cima )
  self.botao.bind( "<Leave>", self.saiu_de_cima)
  self.botao.pack( side = LEFT, padx = 5, pady = 5 )
  
  mainloop()
  
 def apertou( self ):
  messagebox.showinfo( "Messagem", "Você apertou o botão" )
 def passou_por_cima( self, event ):
  event.widget.config( relief = GROOVE )
 def saiu_de_cima( self, event ):
  event.widget.config( relief = RAISED )
  
# Chamando a classe
ButtonEvent()

E o resultado:

Exercício de GUI

Crie um programa em GUI que exibe 5 botões.

Quando for criar os objetos do tipo Button, passe o parâmetro relief=ESTILO, onde ESTILO pode ser:

FLAT

RAISED

SUNKEN

GROOVE

RIDGE

E veja a diferença no estilo de botões.

Alguém pode dar um resuminho nos comentários, explicando como fica cada estilo ?

O evento < Return > : Apertando Enter

Neste tutorial, vamos aprender como lidar e tratar o evento de pressionar a tecla enter do teclado, através do <Return> event.

Através de um programinha simples, vamos entender o que ocorre por trás dos panos quando você digita a tecla enter do seu teclado e algo acontece em um programa.

• Estudar esse conteúdo offline: Apostila de Python

<Return> event - Pressionar tecla enter

Sem mais delongas, vamos criar a seguinte aplicação:

• Vamos usar o widget Entry

Na janelinha principal, exibimos um widget do tipo Entry de entrada de dados.
Você digita algo e dá enter.


Ao fazer isso, vai abrir uma nova janela, com o nome do widget e o conteúdo que está dentro dele.
Vamos te mostrar o código, e logo abaixo, a explicação:

from tkinter import *
from tkinter import messagebox

class EntryTeste( Frame ):
 def __init__( self ):
  # Inicializando configurações do frame
  Frame.__init__(self)
  self.pack()
  self.master.title( "<Return> teste" )
  self.master.geometry( "300x50" )
  self.frame = Frame( self )
  self.frame.pack( pady = 5 )
  
  # Criando a caixa de entrada
  self.caixa = Entry( self.frame, name = "caixa1" )
  
  # Fazendo o bind dela com o event handler exibe() 
  self.caixa.bind( "<Return>", self.exibe )
  self.caixa.pack( side = LEFT, padx = 5 )
  
  # Looping pra rodar a GUI
  self.mainloop()
  
 # Event handler
 def exibe(self, event):
  nomeCaixa = event.widget.winfo_name()
  conteudoCaixa = event.widget.get()
  messagebox.showinfo( "Texto na caixa", "Nome do widget: " + nomeCaixa + "\nConteúdo: " + conteudoCaixa )
  
# Criando um objeto
minhaGui = EntryTeste()

A classe onde toda mágica vai acontecer se chama EntryTeste() e ela herda a classe Frame.
Ou seja, ela é um frame também, ela vai ser a janela principal.

Iniciamos o método construtor chamando o construtor da classe base, e em seguida se empacotando.
Com o método master.title(string) definimos o título da janelinha que vai abrir.
Com o método master.geometry("largura x comprimento") definimos o tamanho do frame.

Depois, criamos o frame frame1 que vai ser o container da caixa de entrada, e empacotamos ele com o espaçamento vertical (pad y) de 5 pixels.


Vamos criar a caixa de entrada, objeto de nome caixa do tipo Entry, vamos dar o nome de caixa1 pra esse widget.

Agora vem a parte mais importante, o bind.
Vamos ligar o evento <Return>, que representa o ato de apertar o enter com o event handler de nome exibe, que é um método que será chamado sempre que você der enter.

Esse método recebe o objeto event.
Vamos extrair algumas informações interessantes desse objeto.

Vamos usar: event.widget.winfo_name() pra pegar o nome do widget
E também: event.widget.get() pra pegar o conteúdo que foi digitado na caixa de entrada.

Em seguida, esse método, que é nosso event handler (tratador de eventos), vai exibir uma caixa de diálogo com essas duas informações: nome do widget e conteúdo que você escreveu nele, antes de dar enter.
Conseguiram entender?

Quebrando a cabeça

Não tenha vergonha de ter que ler, reler, quebrar a cabeça, mexer uma coisa aqui, alterar outra ali.
Faz parte do aprendizado.

Rode o código a seguir, e tente entender linha por linha o que está acontecendo.
Se tiver dúvida de algo, não existe em pesquisar no Google, todo programador faz isso, sempre, pro resto da vida, mesmo os melhores do mundo.

from tkinter import *
from tkinter import messagebox

class EntryTeste( Frame ):
 def __init__( self ):
  # Inicializando os frames, títulos e tamanhos
  Frame.__init__( self )
  self.pack( expand = YES, fill = BOTH )
  self.master.title( "Componentes de entrada" )
  self.master.geometry( "325x100" ) # width x length
  
  # Criando o primeiro frame que vai armazenar
  # as duas primeiras caixas de entrada
  self.frame1 = Frame( self )
  self.frame1.pack( pady = 5 )
  
  # Criando a primeira caixa de entrada
  self.text1 = Entry( self.frame1, name = "caixa1" )
  
  # Associando o evento <Return> com o
  # event handler exibe()
  self.text1.bind( "<Return>", self.exibe )
  self.text1.pack( side = LEFT, padx = 5 )
  
  # Criando a segunda caixa e seu bind
  self.text2 = Entry( self.frame1, name = "caixa2" )
  self.text2.insert( INSERT, "Digite um texto aqui" )
  self.text2.bind( "<Return>", self.exibe )
  self.text2.pack( side = LEFT, padx = 5 )
  
  # Segundo frame, com as duas outras caixas
  self.frame2 = Frame( self )
  self.frame2.pack( pady = 5 )
  
  # Criando a caixa que não dá pra editar
  self.text3 = Entry( self.frame2, name = "caixa3" )
  self.text3.insert( INSERT, "Texto ineditável" )
  self.text3.config( state = DISABLED )
  self.text3.bind( "<Return>", self.exibe )
  self.text3.pack( side = LEFT, padx = 5 )
  
  # Criando a caixa estilo senha
  self.text4 = Entry( self.frame2, name = "caixa4", show = "*" )
  self.text4.insert( INSERT, "Texto escondido" )
  self.text4.bind( "<Return>", self.exibe )
  self.text4.pack( side = LEFT, padx = 5 )
  
  mainloop()
 
 def exibe( self, event ):
  # Pegando o nome do widget
  nomeCaixa = event.widget.winfo_name()
  # Pegando o conteúdo do widget
  conteudoCaixa = event.widget.get()
  messagebox.showinfo( "Texto na caixa", nomeCaixa + ": " + conteudoCaixa )
  
# Chamando a classe
EntryTeste()

Tratamento de Eventos: Método bind() e Classe Event (Event Handling Model)

Neste tutorial de GUI, vamos aprender o que são eventos, para que servem, como funcionam bem como fazer seu tratamento (event handling) em programação gráfica no Python.

Acessar conteúdo em PDF: Apostila de Python

Tratamento de Eventos - Event Handling

Dizemos que a programação gráfica é event driven, ou seja, acionada por eventos.

Esses eventos nada mais são que algum tipo de interação da GUI com o usuário, como digitar algum texto, clicar no mouse, fechar uma janela, maximizar, selecionar algum radiobutton etc.

Os programas em GUI são ditos assíncronos, pois eles rodam e ficam lá parados, esperando o usuário fazer algo, diferente de um script puramente textual, que segue uma ordem mais direta e clara.

Em GUI, algo só acontece se você fizer algo acontecer.
E quando você faz algo, algum evento, uma informação, um evento é enviado pro programa, através de um objeto da classe Event.

Para processar ou tratar um evento, precisamos de duas coisas:
bind: o programa tem que ligar, vincular (bind em inglês) um evento a um componente gráfico, um widget
event handler (ou callback): temos que implementar um 'tratador' de eventos

Ou seja, temos que fazer uma ligação de um evento com um componente, por exemplo, clicar num botão, e criar uma maneira de processar esse evento: quando clicar no botão, abra outra janela, por exemplo.

Em outra palavras, o eventi handler nada mais é que um bom e velho conhecido método que é sempre invocado quando um evento ocorre.

Exemplo de Event Handling: bind() e <Button-1>

Para fazermos uma bind num widget, usamos o método bind():

• widget.bind( evento , tratador_do_evento )

Um exemplo de evento é o "<Button-1>"
Ele fica 'de olho' se o primeiro botão do mouse (o mais da esquerda) é pressionado.

Vamos dar um exemplo com o widget do tipo Frame.
Criamos uma janela principal, que é um objeto da classe Tk()
Em seguida, criamos um frame nessa janela principal, de tamanho 100x100

E associamos ao widget meuframe o bind:
meuframe.bind("<Button-1>", tratador_evento)

Pronto. Sempre que alguém clicar no widget o evento <Button-1> ocorre e chamamos o método tratador_evento, enviando pra ele um objeto event.

Este método simplesmente printa no terminal de comando o local que foi printado. Essa informação está nos atributos event.x (posição horizontal) e event.y (posição vertical).



Teste o código:

from tkinter import *

# É o event handler
def tratador_evento(event):
    print("Você clicou na posição:", event.x, event.y)

janela_principal = Tk()
meuframe = Frame(janela_principal, width=100, height=100)
meuframe.bind("<Button-1>", tratador_evento)
meuframe.pack()

janela_principal.mainloop()

O resultado vai ser algo assim:

1. <Button-1> se refere ao botão mais a esquerda do mouse.
2. <Button-2> se refere ao botão do meio, quando existe.
3. <Button-3> é o evento que se refere ao botão mais a direita.

Experimente clicar com o botão mais a direita e veja que nada ocorre.
Troque <Button-1> por <Button-3> e tente novamente.

É como se seu programa GUI ficasse o tempo todo perguntando:
Evento ocorreu? Não? Ok
Evento ocorreu? Não? Tá bom
Evento ocorreu? Não? Tudo certo
....
Evento ocorreu? Sim? Qual? Ah, o <Button-3>, ok, então chama o método tratador_evento, ele que vai tratar ele.
...
Evento ocorreu? Não? ...

O Python fica na espreita, aguardando algum evento ocorrer. Se ocorrer, ele identifica qual foi e chama o handler correspondente.

E o que é esse handler? E o que ele faz?
Simples: o que você quiser, o que você decide, é você quem manda nessa bagaça toda. Vamos aprender um pouco mais como tratar alguns eventos.