Enviar um café pro programador

Mostrando postagens com marcador Tutorial de Python. Mostrar todas as postagens
Mostrando postagens com marcador Tutorial de Python. Mostrar todas as postagens

Curso de Python em vídeo - Aula 07: Operações Matemáticas

 Nesta vídeo aula de nosso curso, apresentamos as principais operações matemáticas em programação Python, bem como seus operadores:

  • Adição ou soma
  • Subtração ou menos
  • Multiplicação
  • Divisão
  • Divisão inteira
  • Resto da divisão
  • Exponenciação

Bem como os operadores usados em computação: + - * / // ** %

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


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

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

      Acessar conteúdo em PDF: Apostila de Python

      Tratamento de Eventos - Event Handling

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

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

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

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

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

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

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

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

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

      • widget.bind( evento , tratador_do_evento )

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

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

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

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

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



      Teste o código:

      from tkinter import *
      
      # É o event handler
      def tratador_evento(event):
          print("Você clicou na posição:", event.x, event.y)
      
      janela_principal = Tk()
      meuframe = Frame(janela_principal, width=100, height=100)
      meuframe.bind("<Button-1>", tratador_evento)
      meuframe.pack()
      
      janela_principal.mainloop()
      

      O resultado vai ser algo assim:

      Event handling em Python



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


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

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

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

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

      Botão de Rádio: RadioButton e IntVar

      Neste tutorial de GUI em Python, vamos aprender como criar os radio buttons, aqueles botões de rádio, onde escolhemos apenas uma opção dentre várias:
      Radio Button em Python


      Ler este conteúdo em PDF: Apostila Python Progressivo

      Botões de Rádio: Radio Button


      Botões de rádio são aquelas opções, que aparecem em grupo, para você poder marcar apenas uma alternativa. Quando você marca uma opção, automaticamente as outras estarão desmarcadas.

      Ou seja, dizemos que um botão de rádio é mutuamente exclusivo: só pode marcar uma opção e apenas uma, nada mais nem nada menos que uma.

      Eles são bem úteis quando o programa deseja saber o que o usuário quer fazer, deixando ele escolher apenas uma opção.

      RadioButton - Como usar em Python

      Para criarmos um grupo de radio buttons em Python, devemos fazer duas coisas:
      Criar os botões, onde cada um é objeto da classe Radiobutton
      Um objeto da classe IntVar, que vai armazenar o valor do botão selecionado

      Para criar um objeto da classe Radiobutton, passamos como argumento:


      1. O container onde o botão de rádio vai (geralmente um frame)
      2. text - variável que armazena a string que vai aparecer ao lado do botão de rádio
      3. variable - nome da variável, que é um objeto da classe tipo IntVar
      4. value - valor inteiro, onde cada opção deve corresponder a um número diferente
      Pegamos o valor selecionado através do método get() de objetos da classe IntVar.
      Vamos ver um exemplo real, funcionando e acontecendo, para entender melhor ?


      Exemplo de uso de um Radiobutton

      Vamos criar um programa que vai ter a seguinte 'cara':
      Como fazer um radio button em Python

      Primeiro, criamos nossa janela_principal, depois dois frames: frame_cima e o frame_baixo.
      No frame de cima, vamos colocar o label e os botões de rádio.
      No frame de baixo, vão os botões Exibe e Sair.

      Depois, criamos o objeto radio_valor, da classe IntVar, que vai armazenar o valor do botão de rádio selecionado. Inicialmente setamos ele como 1, para aparecer marcado a opção de valor 1.


      Em seguida criamos o label "Qual melhor curso?".
      Depois, os três Radiobutton. Vamos colocar todos no frame_cima, todos vão usar a variável radio_valor e cada um tem um número inteiro diferente, de 1 até 3, para sabermos qual valor foi marcado.

      Empacotamos o label e os botões no frame de cima.
      Depois criamos os botões Exibe e o Sair. O exibe pega o valor assinalado (que está no método get() do objeto radio_valor da classe VarInt) e exibe a opção que escolhemos.

      Veja como ficou nosso código Python:


      from tkinter import *
      from tkinter import messagebox
      
      class MinhaGUI:
       def __init__(self):
        # Cria janela principal
        self.janela_principal = Tk()
        
        # Cria dois frames
        self.frame_cima = Frame(self.janela_principal)
        self.frame_baixo = Frame(self.janela_principal)
        
        # Objeto IntVar dos botões
        self.radio_valor = IntVar()
        self.radio_valor.set(1)  # Para a primeira opção ficar marcada
        
        # Criando os radio buttons e o label
        self.label = Label(self.frame_cima, text='Qual o melhor curso?')
        self.python = Radiobutton(self.frame_cima, text='Python Progressivo', \
             variable = self.radio_valor, value=1)
        self.java = Radiobutton(self.frame_cima, text='Java Progressivo', \
             variable = self.radio_valor, value=2)
        self.c = Radiobutton(self.frame_cima, text='C Progressivo', \
             variable = self.radio_valor, value=3)
        
        # Empacotando o label e os radio buttons
        self.label.pack(anchor = 'w')
        self.python.pack(anchor = 'w')
        self.java.pack(anchor = 'w')
        self.c.pack(anchor = 'w')
        
        # Criando os botões
        self.botao = Button(self.frame_baixo, text='Exibe', command=self.exibe)
        self.botao_sair = Button(self.frame_baixo, text='Sair', command=self.janela_principal.quit)
        
        # Empacotando botões
        self.botao.pack(side='left')
        self.botao_sair.pack(side='left')
        
        # Empacotando os frames na janela principal
        self.frame_cima.pack()
        self.frame_baixo.pack()
        
        # Rodando
        mainloop()
        
       def exibe(self):
         nome = str(self.radio_valor.get())
         messagebox.showinfo('Resposta','Você escolheu a opçao ' + nome)
         
        
      gui = MinhaGUI()
      

      Chamando Métodos sem Botão

      Se você puxar pela memória, vai se lembrar que muitas vezes nem precisar clicar em um botão, para o programa tomar alguma ação, basta selecionar um dos botões de rádio e algo já acontece.

      Para fazer isso, basta adicionar o parâmetro command ao criar um objeto da classe Radiobutton com o nome do método que você deseja que seja executado.

      Veja como fica nosso programa sem o uso de botões:


      from tkinter import *
      from tkinter import messagebox
      
      class MinhaGUI:
       def __init__(self):
        # Cria janela principal
        self.janela_principal = Tk()
        
        # Criando o frame
        self.frame_cima = Frame(self.janela_principal)
        
        # Objeto IntVar dos botões
        self.radio_valor = IntVar()
        self.radio_valor.set(1)  # Para a primeira opção ficar marcada
        
        # Criando os radio buttons e o label
        self.label = Label(self.frame_cima, text='Qual o melhor curso?')
        self.python = Radiobutton(self.frame_cima, text='Python Progressivo', \
             variable = self.radio_valor, value=1, command=self.exibe)
        self.java = Radiobutton(self.frame_cima, text='Java Progressivo', \
             variable = self.radio_valor, value=2, command=self.exibe)
        self.c = Radiobutton(self.frame_cima, text='C Progressivo', \
             variable = self.radio_valor, value=3, command=self.exibe)
        
        # Empacotando o label e os radio buttons
        self.label.pack(anchor = 'w')
        self.python.pack(anchor = 'w')
        self.java.pack(anchor = 'w')
        self.c.pack(anchor = 'w')
        
        
        # Empacotando o frame na janela principal
        self.frame_cima.pack()
        
        # Rodando
        mainloop()
        
       def exibe(self):
         nome = str(self.radio_valor.get())
         messagebox.showinfo('Resposta','Você escolheu a opçao ' + nome)
         
        
      gui = MinhaGUI()
      

      Label como saída - StringVar

      Neste tutorial de nosso Curso de Python, vamos aprender a usar a classe StringVar, que nos permite criar labels dinâmicas, que usaremos como saída de dados.

      Python Progressivo em PDF: Apostila de Pyhon

      Label como saída de dados dinâmica

      Até o momento, em nossos estudos em programação gráfica, viemos usando as caixas de diálogo para exibir alguma informação, uma saída de dados, como uma simples string.

      Porém, não é isso que ocorre na prática, não fica sempre pipocando janelinhas, até porque isso é chato. É normal que, você insira um dado, aperte um botão ou não, e automaticamente já apareça uma informação na janela mesmo, sem nenhuma nova janela surgindo.

      É como se fosse uma espécie de label dinâmica. Inicialmente ela mostra:

      Seu IMC é:

      Então você informa seu peso e altura, e esse label se transforma;
      Seu IMC é: 26, você está com sobrepeso

      Essa mudança deve ocorrer simplesmente clicando em algum botão.

      Vamos aprender como fazer isso?

      Como usar StringVar

      Vamos criar o seguinte programa:

      Label como saída de dados dinâmica

      Digitamos nosso nome, clicamos em Exibe e aparece o label embaixo: "Seu nome é: ..."

      Esse programa é composto por três frames:

      1. Frame de cima: tem o label "Digite seu nome" e o campo de entrada
      2. Frame do meio: tem o label "Seu nome é:" e o label dinâmico (StringVar), que exibe o nome que o usuário digitou no campo de entrada
      3. Frame de baixo: dois botões, o Exibe e o Sair
      O primeiro e o último frame, bem como seus widgets internos, sabemos muito bem como criar e trabalhar com eles.

      Vamos focar no frame do meio, que tem a label dinâmica.

      O segredo aqui é criar um objeto do tipo StringVar(), vamos chamar de label_dinamica.
      Ela que vai ficar 'pegando' o que é digitado no campo de entrada. Mas ela pega e passa pra outra label, a label3.

      A label3 recebe um parâmetro chamado textvariable, que como o nome diz, vai receber um texto variável. Como argumento, passamos o nome do label dinâmica, que no nosso caso é label_dinamica.

      O código fica assim:
      self.label3 = Label(self.frame_meio, textvariable=self.label_dinamica)


      Ou seja, essa linha de código quer dizer: crie uma label de nome label3, que vai ficar no frame_meio e o valor que ela vai exibir é um texto variável, que a label_dinamica vai ficar pegando).

      Essa label dinâmica vai pegar o valor escrito na entrada, quando clicamos no botão Exibe.
      Quando isso ocorre, esse botão chama o método exibe()

      Dentro desse método, pegamos o valor que foi digitado e armazenamos na variável nome da seguinte maneira:
      nome = self.entrada.get()

      Agora, vamos passar essa variável para a label dinâmica, através do método set() que ela tem, que recebe uma string:
      self.label_dinamica.set(nome)

      Veja como fica nosso código Python:

      from tkinter import *
      
      class MinhaGUI:
       def __init__(self):
        # Cria janela principal
        self.janela_principal = Tk()
        
        # Cria três frames
        self.frame_cima = Frame(self.janela_principal)
        self.frame_meio = Frame(self.janela_principal)
        self.frame_baixo = Frame(self.janela_principal)
        
        # No frame de cima, um label e uma entry
        self.label1 = Label(self.frame_cima, text='Digite seu nome: ')
        self.entrada = Entry(self.frame_cima, width = 30)
        
        # Empacotando o label e entrada no primeiro frame
        self.label1.pack(side='left')
        self.entrada.pack(side='left')
        
        # Labels do frame do meio
        self.label2 = Label(self.frame_meio, text='Seu nome é:  ')
        self.label_dinamica = StringVar()
        self.label3 = Label(self.frame_meio, textvariable=self.label_dinamica)
        
        # Empacotando as labels do meio
        self.label2.pack(side='left')
        self.label3.pack(side='left')
        
        # Criando os botões
        self.botao = Button(self.frame_baixo, text='Exibe', command=self.exibe)
        self.botao_sair = Button(self.frame_baixo, text='Sair', command=self.janela_principal.quit)
        
        # Empacotando botões e label
        self.botao.pack(side='left')
        self.botao_sair.pack(side='left')
        
        # Empacotando os frames na janela principal
        self.frame_cima.pack()
        self.frame_meio.pack()
        self.frame_baixo.pack()
        
        # Rodando
        mainloop()
        
       def exibe(self):
         nome = self.entrada.get()
         self.label_dinamica.set(nome)
         
        
      gui = MinhaGUI()
      

      Rode ele! Leia linha por linha e tente entender tudo que está se passando aí.

      Recebendo dados do usuário: Entry widget

      Neste tutorial de programação gráfica GUI em Python, vamos aprender o que é e como usar o widget Entry.

      Recebendo informações do usuário

      Até o momento, nossa única interação código-usuário foi através do clique do usuário em botões, seja em nossos buttons como em caixas de diálogo.

      Porém, a forma mais comum de interação entre um programa e o usuário, é através daquelas áreas retangulares, onde escrevemos algum texto.

      Por exemplo, para preencher o campo de nome, telefone, CEP, data de nascimento etc.



      Geralmente, o normal é termos algo do tipo:

      • Um label com algum texto
      • Um campo de entrada, para escrevermos algo
      • Um botão, para fazer algo com o dado que escrevemos

      Vejamos um print de uma aplicação real:

      Como receber entrada do usuário

      Como usar entradas: Entry widget

      Vamos aprender como fazer o programinha do print anterior.

      Na primeira janela, temos dois frames:
      frame de cima: tem um label e um widget do tipo Entry
      frame de baixo: dois botões

      Após criar os objetos do tipo label e os frames, vamos criar nosso widget Entry.

      1. Ele recebe dois parâmetros:
      2. O container que ele vai estar (frame ou janela)
      3. width: número de caracteres que vai ser possível digitar no campo de texto

      Vamos usar width=30
      Em seguida, empacotamos o label e entry no frame de cima, lado a lado (side='left').
      Nosso entry vai se chamar entrada e ele tem um método especial, o get(), que retorna uma string com o que foi digitado na caixa.

      Em seguida, criamos dois botões.
      O primeiro chama o método exibe(), onde esse método exibe uma string.
      Por fim, um botão de quit.

      Agora vamos empacotar esse botões no frame de baixo.
      Depois empacotamos os dois frames na janela principal...e rodamos o programa!

      Veja como fica o código completo:

      from tkinter import *
      from tkinter import messagebox
      
      class MinhaGUI:
       def __init__(self):
        # Criamos a janela principal
        self.janela_principal = Tk()
        
        # Criando os frames
        self.frame_cima  = Frame(self.janela_principal) 
        self.frame_baixo = Frame(self.janela_principal) 
        
        # Criando label e botões do frame de cima
        self.label = Label(self.frame_cima, text='Digite seu nome:')
        
        # Criando o widget de entrada
        self.entrada = Entry(self.frame_cima, width=30)
        
        # Empacotando label e entrada no frame de cima
        self.label.pack(side='left')
        self.entrada.pack(side='left')
        
        # Criando os botões, no frame de baixo
        self.botao = Button(self.frame_baixo, text='Exibir', command=self.exibe)
        self.botao_sair = Button(self.frame_baixo, text='Sair', command=self.janela_principal.quit)
        
        # Empacotando os botões no frame de baixo
        self.botao.pack(side='left')
        self.botao_sair.pack(side='left')
        
        # Empacotando os botões janela principal
        self.botao.pack()
        self.botao_sair.pack()
        
        # Empacotando os frames na janela principal
        self.frame_cima.pack()
        self.frame_baixo.pack()
        
        # Rodando
        mainloop()
      
        
       def exibe(self):
        messagebox.showinfo('Python Progressivo','Seu nome é: '+ self.entrada.get())
      
      
      gui = MinhaGUI()
      

      Ou seja, o pulo do gato dos widgets Entry é o método get() que todo objeto desse tipo tem.
      Esse método retorna SEMPRE uma string, com o que foi digitado.

      Quer pegar um número? Ok, mas primeiro converte de string pra inteiro ou float, só depois usa o número. Mas é sempre uma string, ok?

      Botão em GUI: o widget Button

      Neste tutorial de GUI em Python, vamos aprender a criar e usar um dos widgets mais importantes, o button, ou seja, vamos criar botões em nossos programas.

      Leia nosso conteúdo sem precisar de internet: Apostila Python Progressivo

      Widget de Botão: Button

      O widget Button nada mais é que aquele velho e conhecido botão, nas janelas, que clicamos em cima e acontece alguma coisa.

      Em programação gráfica em Python, o que ocorre por trás dos panos quando criamos um botão é a chamada de um método.

      Ou seja, clicou em OK, então o código vai atrás de um determinado método ou função e executa ele. Já se clicar em Cancelar outro método ou função que será invocado.

      Para criarmos um botão, usamos a classe Button, que recebe três parâmetros:

      1. A janela mestre (objeto do tipo Tk() )
      2. text: string com o texto que vai aparecer no botão (Ok, Cancelar, Sair...)
      3. command: nome do método ou função que vai ser chamado quando clicarmos no botão, mas sem os parêntesis

      Exemplo de uso do Botão em Python

      Vamos criar um botão que com o texto "Clique aqui", que quando cli.cado, chama o método hello_world(), que dentro dele exibe uma caixa de diálogo.

      Veja como fica nosso código Python:

      from tkinter import *
      from tkinter import messagebox
      
      class MinhaGUI:
       def __init__(self):
        # Criamos a janela principal
        self.janela_principal = Tk()
        
        # Criando o botão
        self.botao = Button(self.janela_principal, text='Clique aqui', command=self.hello_world)
        
        # Empacotando o botão na janela principal
        self.botao.pack()
        
        # Rodando
        mainloop()
      
        
       def hello_world(self):
        messagebox.showinfo('Adoro a Apostila Python Progressivo!')
      
      
      gui = MinhaGUI()
      

      E o resultado:
      Button widget em Python

      Ao clicar, aparece essa caixa de diálogo:

      Apostila de Python grátis para download

      O Botão sair: quit button

      Se você clicar em "Clique aquI", aparece a caixa de diálogo.

      Se clicar no "Ok" da caixa de mensagem, volta pra janela principal, que tem o "Clique aqui" e fica nisso, eternamente. Só acaba se clicar no x de fechar.


      Mas o comum é ter um botão de fechar, cancelar, sair...que ao clicar nele, nossa aplicação se encerre.
      Pois bem, todo objeto da classe Tk() tem um método chamado quit(), mas chamar ele que as janelas fecham ao clicar no botão.

      Então, vamos criar mais um botão, o botao_sair, que ao ser clicado (command) chama o método quit() da janela principal, que fecha o programa.

      Veja como fica nosso código:

      from tkinter import *
      from tkinter import messagebox
      
      class MinhaGUI:
       def __init__(self):
        # Criamos a janela principal
        self.janela_principal = Tk()
        
        # Criando os botões
        self.botao = Button(self.janela_principal, text='Clique aqui', command=self.hello_world)
        self.botao_sair = Button(self.janela_principal, text='Sair', command=self.janela_principal.quit)
        
        # Empacotando os botões janela principal
        self.botao.pack()
        self.botao_sair.pack()
        
        # Rodando
        mainloop()
      
        
       def hello_world(self):
        messagebox.showinfo('Adoro a Apostila Python Progressivo!')
      
      
      gui = MinhaGUI()
      

      E o resultado:

      Como fazer um botão

      Experimente clicar em Sair e veja o que acontece!

      Caixa de diálogo em GUI Python: messagebox

      Neste tutorial de GUI, vamos aprender a usar as info dialog box (caixas de diálogo ou de mensagem), em programação gráfica Python.

      Baixe nossa apostila e estude onde quiser: Apostila de Python

      Caixa de Mensagem: info dialog box

      Caixa de diálogo ou simplesmente caixa de mensagem, nada mais é que uma simples janelinha que aparece, com algum texto e algum botão, geralmente o de OK, que fecha a box quando clicamos.

      Outras caixas de diálogo exibem botão Cancelar, Tente novamente etc.

      Para usarmos, primeiro importamos a messagebox do módulo tkinter.

      Depois, usamos a função showinfo, que recebe duas strings como argumento: a primeira vai no título da caixa de diálogo que vai abrir, a segunda string é a mensagem que vai aparecer.

      Veja um exemplo de código:

      from tkinter import messagebox
      
      messagebox.showinfo('Python Progressivo', \
            'Adoro o curso Python Progressivo')
      

      O resultado é:
      Dialog box em Python

      Agora, ao invés de usar a função showinfo, tente as seguintes:
      • showwarning()
      • showerror()
      • askquestion()
      • askokcancel()
      • askyesno ()
      • askretrycancel ()


      Tente todas mesmo!
      O que aconteceu? Bacana e simples, não é?

      Note que ao clicarmos nos botão de Ok, Cancelar, Tente novamente etc, nada acontece.
      Mas, calma, no próximo tutorial vamos aprender como fazer as coisas acontecerem ao clicarmos em algum botão.


      Frame em Python - Organizando os widgets

      Neste tutorial de Python, vamos aprender o que são os Frames, para que servem e como usar, em programação gráfica (GUI).

      Acesse esse conteúdo em PDF: Apostila Python Progresivo

      Frames em Python

      Um frame, em programação GUI, nada mais é que uma espécie de 'container', cujo propósito principal é armazenar e agrupar outros widgets.

      Na barra do seu navegador, por exemplo, lá em cima, tem um frame com as várias opções de menu (Editar, Exibir, Ajuda etc).

      Logo abaixo, deve ter outro frame, que agrupa vários botões: Página inicial, Parar, Atualizar, Voltar, Ir pra frente etc.

      Ou seja, frame é uma 'região' em sua aplicação gráfica, que você vai colocar uma porção de outras coisas. É um widget que serve pra armazenar outros widgets.

      O normal é colocar vários widgets num frame, e organizar eles ali dentro (cores, disposição, eventos etc). Depois, cria outro frame pra exibir na mesma janela, mas com outros widgets, com sua própria maneira de arranjo.

      Abaixo, dois frames, lado a lado:

      Programação gráfica (GUI) em Python


      Note que, internamente, cada um tem seu arranjo (botões, disposições, cores, alinhamentos etc)

      Como usar Frames em Python

      Vamos fazer uma aplicação que vai exibir dois frames.
      Em cada um dos frames, vais colocar um Label, com um texto simples em cada um.

      Primeiro, damos um import em tudo (*) do módulo tkinter.
      Nossa classe que vai criar o programinha, se chama MinhaGUI.

      Primeiro, instanciamos o objeto da Tk(), que é nossa janela principal.
      Depois, vamos criar dois frames: o frame_cima e o frame_baixo, através da classe Frame(), que tem que recebe como argumento um objeto do tipo Tk(), no nosso caso é o objeto janela_principal, que é onde os frames estarão localizados (janela mãe).

      A seguir, criamos dois labels, o label1 e o label2, e passamos os frames criados como argumento, um label para cada frame.

      Damos o pack() pra posicionar os labels nos respectivos frames.
      E por fim, damos o pack() para posicionar os frames (sim, frames também precisam ser posicionados nas janelas).

      Depois é só chamar a função mainloop() que vai fazer sua aplicação rodar bonitinha.
      Código Python:

      from tkinter import *
      
      class MinhaGUI:
       def __init__(self):
        # Criando a janela principal
        self.janela_principal = Tk()
        
        # Criando os frames
        self.frame_cima = Frame(self.janela_principal)
        self.frame_baixo = Frame(self.janela_principal)
        
        # Criando os labels
        self.label1 = Label(self.frame_cima, text='To no frame de cima!')
        self.label2 = Label(self.frame_baixo, text='To no frame de baixo!')
        
        # Posicionando os labels nos frames
        self.label1.pack(side='top')
        self.label2.pack(side='top')
        
        # Posicionando o frame
        self.frame_cima.pack()
        self.frame_baixo.pack()
      
        # Fazer o Tkinter exibir o looping da janela
        mainloop()
      
      minha_gui = MinhaGUI()
      
      

      Resultado:
      Como criar aplicativos em Python

      Parâmetros da Frame

      No exemplo anterior, passamos apenas uma informação ao criar um objeto do tipo Frame, que foi sua janela mestre. É o único parâmetro obrigatório, é o master.

      Existem alguns outros, como o bg, (pode usar background também, o tkinter entende ambos) que define a cor de fundo do frame.
      O parâmetro height define a altura e o width a largura, em pixels, de cada frame.


      Por exemplo, o código Python a seguir:

      from tkinter import *
      
      class MinhaGUI:
       def __init__(self):
        # Criando a janela principal
        self.janela_principal = Tk()
        
        # Criando os frames
        self.frame_cima = Frame(self.janela_principal, bg="white", height=70, width=400)
        self.frame_baixo = Frame(self.janela_principal, bg='red', height=70, width=400)
        
        # Posicionando o frame
        self.frame_cima.pack()
        self.frame_baixo.pack()
      
        # Fazer o Tkinter exibir o looping da janela
        mainloop()
      
      minha_gui = MinhaGUI()
      
      

      Cria a seguinte aplicação:

      Curso de Python online grátis para download


      Se passar o argumento side="left" nas chamadas da pack(), essas duas faixas vão aparecer lado a lado ao invés de uma em cima da outra.

      Exercício de Python

      Busque na internet a figura da bandeira da França e da Holanda.

      Código Python:

      from tkinter import *
      
      class MinhaGUI:
       def __init__(self):
        # Criando as janelas
        self.janela1 = Tk()
        self.janela2 = Tk()
        
        # Bandeira da França
        self.frame1 = Frame(self.janela1, bg="blue", height=200, width=80)
        self.frame2 = Frame(self.janela1, bg='white', height=200, width=80)
        self.frame3 = Frame(self.janela1, bg='red', height=200, width=80)
        self.frame1.pack(side="left")
        self.frame2.pack(side="left")
        self.frame3.pack(side="left")
        
        # Bandeira da Holanda
        self.fram1 = Frame(self.janela2, bg="red", height=80, width=200)
        self.fram2 = Frame(self.janela2, bg='white', height=80, width=200)
        self.fram3 = Frame(self.janela2, bg='blue', height=80, width=200)
        self.fram1.pack(side="top")
        self.fram2.pack(side="top")
        self.fram3.pack(side="top")
      
        # Fazer o Tkinter exibir o looping da janela
        mainloop()
      
      minha_gui = MinhaGUI()
      
      

      Resultado:
      Como desenhar em Python

      Note que dessa vez criamos duas janelas, então quando rodamos o script, aparecem duas janelas!