Python Progressivo

Livro Python Progressivo

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?
Agora isso é possível, com o certificado do curso Python Progressivo.

Curso Python Progressivo com Certificado

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.

Salário quanto ganha um programador Python

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:

Clique aqui, obtenha seu certificado Python Progressivo e entre no mercado de trabalho

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. 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ê estuda no seu ritmo

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 explicações simples, voltadas para iniciantes, muuuuuitos exemplos de código, exercícios resolvidos e questões comentadas. Ah, o material tem mais de 700 páginas. É uma verdadeira bíblia do Python, vai usar como referência pro resto de sua vida

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 Curso Python Progressivo

Certificado válido em todo território nacional.

Você precisa estudar todo o conteúdo do curso Python Progressivo para ser aprovado no exame e obter seu certificado. Depois disso, é zarpar para o mercado de trabalhar e ganhar dinheiro, sem mistério.

Clique aqui e obtenha sua certificação para trabalhar como Programador Python

Curso de Python (Completo, Online e Grátis)

Básico da Linguagem Python

Testes Condicionais: IF ELIF ELSE

Exercícios finais de Testes Condicionais

Laços e Loopings: WHILE e FOR

Exercícios de laço FOR e WHILE

Funções em Python

Módulos

Exercícios de Função
Criando um jogo em Python

Listas

Tuplas

O que é? Para que serve? Como usar ? Quando usar?

Dicionários

Exercícios de Sequências

Arquivos (Files)

Lista de exercícios de Arquivos

Strings em Python

O que é? Como funciona ? Para que serve ? Onde vamos usar ?
Como usar, Acessar caracteres e Descobrir tamanho de string
Strings maiúsculas e minúsculas
String só de letra, número e/ou caractere especial
Juntar e Separar strings: join() e split()
Como Localizar e Substituir algo em uma string
Expressões regulares:
Parte 1: Introdução, Módulo re, recompile, search, objetos Regex e Match
Parte 2: Grupos e parêntesis
Parte 3: Caractere Pipe | (o OU)
Parte 4: Ponto de interrogação (?), Asterisco (*) e Soma (+)
Parte 5: Classes de Caracteres
Parte 6: Início (^) e Final de String ($)
Parte 7: Caractere curinga - Ponto .
Parte 8: Substituindo strings com o método sub()
Parte 9: Como fazer regexes longas e complexas

Orientação a Objetos em Python

GUI - Interface Gráfica do Usuário

Tutoriais de Python

Par ou Ímpar
Ano bissexto
Validando datas
Como arredondar números em Python com a função round()
Progressão Aritmética (usando laço FOR)
Calcular fatorial
Todos os palpites da Mega Sena

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:

pack - vai adicionando os widgets na ordem que forem sendo empacotados
grid - adiciona através de posições de linhas e coluna, como uma tabela ou grade (grid)
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.

Saber quando uma tecla foi pressionada ou não em Python

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.

Event Handler com mouse em programação gráfica em Python

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:

<Button-1> - Botão 1 do mouse (mais a esquerda) é pressionado
<ButtonRelease-1> - Botão 1 é liberado (released)
<Enter> - Mouse entrou no frame (janela)
<Leave> - Mouse deixou o frame da janela
<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:

Com o evento <Enter>, que chama o método passou_por_cima
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()