Obter livro impresso |
Python Progressivo
Curso de Python completo, online e grátis
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.
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:
![]() |
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.
![]() |
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
- Python - O que é? Para que serve? Onde é usado?
- Como começar a programar em Python
- Como fazer o primeiro programa em Python (hello, world - olá, mundo)
- Função print - Como imprimir dados na tela
4.1 10 exercícios usando a função print - Tipos de dados - Números, Strings e Booleanos
- Variáveis em Python
- Função input - Como ler dados do teclado do usuário
- Funções int() e float() - Transformar string em números
- Operações matemáticas em Python
9.1 - Exercícios de porcentagens
9.2 - Exercícios de juros compostos - Comentar código - Calculadora Simples
- Precedência de operadores - Calculando média em Python
- Formatar números na função print
- Exercícios Básicos de Python
Testes Condicionais: IF ELIF ELSE
- Operadores de comparação: ==, !=, >, >=, < e <=
- IF - Teste Condicional em Python
- IF e ELSE - Instruções de teste
- IF e ELSE aninhados
- Exercícios de IF e ELSE
- Instrução ELIF em Python
- Exercício de ELIF
- Operadores Lógicos: AND, OR e NOT
Laços e Loopings: WHILE e FOR
- Estruturas de repetição: Entendo a lógica dos laços e loopings
- WHILE - O que é, como funciona e como usar
- FOR - Um loop controlado
- A função range() pro laço FOR
- Progressão Aritmética (PA) com laços em Python
- Operadores de Atribuição: += -= *= /= e %=
- Fatorial com WHILE e FOR
- Laços Aninhados (Loop dentro de loop)
- Instrução ELSE, BREAK e CONTINUE em Laços
Funções em Python
- Função: O que é? Para que serve? Onde são utilizadas?
- Como declarar, chamar e usar funções: def
2.1 Calculadora em Python usando Funções - Função chamando função
- Variável local
- Parâmetro e Argumento em Funções Python
- Passagem por valor
- Argumentos Posicional e Nomeado
- Variável global
- Constante global
- O comando return - Como retornar valores
- Recursividade: Somatório e Fatorial com função recursiva
Módulos
- Módulo em Python - O que é? Para que serve? Onde se usa?
- Como Criar, Importar e Usar um módulo: import
- Como gerar números aleatórios em Python
- Módulo math - Funções Matemáticas Prontas
Criando um jogo em Python
Listas
- Listas em Python - O que são ? Para que servem ? Por que usar ?
- Como criar uma lista e acessar seus itens
- Como Usar Listas: Adicionar, Mudar, Concatenar e Outras Operações
- Listas com Laço For
- Quebrando Listas (slice)
- Operadores in e not in
- Como copiar uma Lista
- Matriz: Lista dentro de lista
- Como criar o Jogo da velha
Tuplas
Dicionários
- O que é ? Para que serve? Como e quando se usa ?
- Como exibir items, valores e chaves de um dicionário
- Como usar os métodos get() e setdefault()
- Adicionar, Alterar e Remover items de um dicionário
- Exercício resolvido: Como usar Dicionários em Python
- Como alterar o nome de uma chave (key) de um Dicionário
Arquivos (Files)
- Como Abrir e Ler um arquivo: open() e read()
- Como ler um arquivo linha por linha: readlines()
- Como escrever em Arquivos: write() - Modos de abertura
- Como retirar a quebra de linha (caractere '\n') de Arquivos
- Processando arquivos grandes com Laço FOR
- Módulo os: Caminhos, Endereços, Arquivos, Pastas e Diretórios
- Como ler e escrever ao mesmo tempo num mesmo arquivo
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
- O que é Classe e Objeto
- Como criar uma Classe e um Objeto
- Métodos, __init__ e Atributos
- Parâmetros e Argumentos de métodos em classes
- Método Construtor __init__: Parâmetros e Argumentos
Jogos: Cara ou Coroa e Lançamento de dados - Atributos privados
- Atributos de classe
- Composição: Objeto dentro de Objeto
- Herança: O que é ? Para que serve?
- Como usar herança - Superclasse e Subclasse
- Polimorfismo em Python
GUI - Interface Gráfica do Usuário
- O módulo Tkinter
- Label - Exibindo rótulos (textos) numa janela
- Frame - Widget que armazena widgets
- Caixas de diálogo - info dialog boxes
- Botões - o widget Button
- Entry widget - Recebendo entradas do usuário
- StringVar - Saída dinâmica de dados com label
- Botão de rádio - Radiobutton e IntVar
- Botão de check - Checkbutton
- Tratamento de eventos: classe Event e método bind()
- Dando enter: o evento <Return>
- Eventos envolvendo botão: <Enter> e <Leave>
- Tratamento de eventos envolvendo Mouse
- Tratamento de eventos envolvendo Teclas do teclado
- Gerenciadores de Layout: pack, grid e place
Tutoriais de Python
Par ou ÍmparAno 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.
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.
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.
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:
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:

- Faça o download desse site: Apostila de Python
Eventos com Mouse: <ButtonRelease-1> e <B1-Motion>
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.
Agora que já aprendemos a trabalhar com o widget Button, vamos aprender a usar eventos com botões.
Vamos usar dois eventos:
Vamos fazer dois binds:
Veja como fica nosso código:
- 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
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
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
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()
Assinar:
Postagens (Atom)