Mandar um café pro programador

Pode me ajudar a transformar cafeína em código?

Como Apoiar o Python Progressivo

Que tal apoiar e fazer crescer o ensino da programação no Brasil ?

Ajudar nosso país a crescer e se desenvolver cada vez mais, tecnologicamente?

Clica abaixo pra saber mais!

Apoiar o Projeto 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...

Fazer curso de Python online grátis


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.

Python Mercado de Trabalho
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:

Curso de Python com Certificado
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.



Curso de Python com certificado
Clique aqui e obtenha sua certificação para trabalhar como Programador Python

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

Curso de Python com Certificado

Básico da Linguagem Python

  1. Python - O que é? Para que serve? Onde é usado?
  2. Como começar a programar em Python
  3. Como fazer o primeiro programa em Python (hello, world - olá, mundo)
  4. Função print - Como imprimir dados na tela
    4.1 10 exercícios usando a função print
  5. Tipos de dados - Números, Strings e Booleanos
  6. Variáveis em Python
  7. Função input - Como ler dados do teclado do usuário
  8. Funções int() e float() - Transformar string em números
  9. Operações matemáticas em Python
    9.1 - Exercícios de porcentagens
    9.2 - Exercícios de juros compostos
  10. Comentar código - Calculadora Simples
  11. Precedência de operadores - Calculando média em Python
  12. Formatar números na função print
  13. Exercícios Básicos de Python


Testes Condicionais: IF ELIF ELSE

  1. Operadores de comparação: ==, !=, >, >=, < e <=
  2. IF - Teste Condicional em Python  
  3. IF e ELSE - Instruções de teste
  4. IF e ELSE aninhados 
  5. Exercícios de IF e ELSE  
  6. Instrução ELIF em Python
  7. Exercício de ELIF  
  8. Operadores Lógicos: AND, OR e NOT
Exercícios finais de Testes Condicionais

Laços e Loopings: WHILE e FOR

    1. Estruturas de repetição: Entendo a lógica dos laços e loopings
    2. WHILE - O que é, como funciona e como usar  
    3. FOR - Um loop controlado
    4. A função range() pro laço FOR 
    5. Progressão Aritmética (PA) com laços em Python
    6. Operadores de Atribuição: += -= *= /= e %=
    7. Fatorial com WHILE e FOR  
    8. Laços Aninhados (Loop dentro de loop)
    9. Instrução ELSE, BREAK e CONTINUE em Laços 
    Exercícios de laço FOR e WHILE

    Curso Python Progressivo

    Funções em Python

    1. Função: O que é? Para que serve? Onde são utilizadas?
    2. Como declarar, chamar e usar funções: def
      2.1 Calculadora em Python usando Funções   
    3. Função chamando função
    4. Variável local
    5. Parâmetro e Argumento em Funções Python  
    6. Passagem por valor
    7. Argumentos Posicional e Nomeado  
    8. Variável global
    9. Constante global  
    10. O comando return - Como retornar valores
    11. Recursividade: Somatório e Fatorial com função recursiva

      Módulos

      1. Módulo em Python - O que é? Para que serve? Onde se usa?
      2. Como Criar, Importar e Usar um módulo: import
      3. Como gerar números aleatórios em Python 
      4. Módulo math - Funções Matemáticas Prontas
      Exercícios de Função
      Criando um jogo em Python

      Listas

      1. Listas em Python - O que são ? Para que servem ? Por que usar ?
      2. Como criar uma lista e acessar seus itens
      3. Como Usar Listas: Adicionar, Mudar, Concatenar e Outras Operações
      4. Listas com Laço For
      5. Quebrando Listas (slice)
      6. Operadores in e not in
      7. Como copiar uma Lista
      8. Matriz: Lista dentro de lista
      9. Como criar o Jogo da velha

      Tuplas

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

      Dicionários

      1. O que é ? Para que serve? Como e quando se usa ?
      2. Como exibir items, valores e chaves de um dicionário
      3. Como usar os métodos get() e setdefault()
      4. Adicionar, Alterar e Remover items de um dicionário
      5. Exercício resolvido: Como usar Dicionários em Python
      6. Como alterar o nome de uma chave (key) de um Dicionário

      Arquivos (Files)

      1. Como Abrir e Ler um arquivo: open() e read()
      2. Como ler um arquivo linha por linha: readlines()
      3. Como escrever em Arquivos: write() - Modos de abertura
      4. Como retirar a quebra de linha (caractere '\n') de Arquivos
      5. Processando arquivos grandes com Laço FOR
      6. Módulo os: Caminhos, Endereços, Arquivos, Pastas e Diretórios
      7. Como ler e escrever ao mesmo tempo num mesmo arquivo
      Lista de exercícios de Arquivos

      Strings em Python

      1. O que é? Como funciona ? Para que serve ? Onde vamos usar ?
      2. Como usar, Acessar caracteres e Descobrir tamanho de string
      3. Strings maiúsculas e minúsculas
      4. String só de letra, número e/ou caractere especial
      5. Juntar e Separar strings: join() e split()
      6. Como Localizar e Substituir algo em uma string
      7. 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

      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

      Curso Python Progressivo


      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.

      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:

      Curso de Python

      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:

      Apostila de Python grátis para download

      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:

      Curso de Python online grátis


      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.

      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

      Eventos com Mouse: <ButtonRelease-1><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:
      Button event handler

      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.



      <Return> event - Pressionar tecla enter

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

      Evento de dar enter

      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()
      


      Bora fazer evoluir o ensino da Programação no Brasil ?

      Que tal apoiar e fazer crescer o ensino da programação no Brasil ?

      Ajudar nosso país a crescer e se desenvolver cada vez mais, tecnologicamente?

      Clica abaixo pra saber mais!

      Apoiar o Projeto Progressivo