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




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

    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

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