Sobre os Autores

Python é uma das linguagens de programação mais populares e versáteis

idiomas na indústria de tecnologia. No entanto, apesar de seu
popularidade e versatilidade, dominá-las pode ser desafiador,
especialmente para iniciantes. Desafios técnicos como
debugging and tight deadlines can cause stress and anxiety,
e avanço na carreira e ficar atualizado com o mais recente
Desenvolvimentos na área podem ser assustadores.

Table of Contents
Conteúdo
Sobre os Autores
Table of Contents
Projetos de GUI Tkinter com Python
PART 1: Introdução ao Módulo Tkinter do Python
Pré-requisitos para Tkinter
Programação GUI em Python
O que é Tkinter?
O que são Tcl, Tk e Tkinter?
Instalar Tkinter
Adicionando Tk às suas Aplicações
Primeiro Exemplo Tkinter
Métodos Tkinter usados acima:
Resumo:
PART 2: Janelas, Widgets e Frames do Tkinter
Introdução às Janelas e Widgets do Tkinter
Processamento Orientado a Eventos do Tkinter

Janelas Tkinter
Janela de Top-Level do Tkinter

Widgets Tkinter
Frames Tkinter
Exemplo Básico do Tkinter
Summary:
PART 3: Janelas Tkinter
Janelas Tkinter
Exemplo de Janela Tkinter:
Janela Personalizada do Tkinter

Resumo:
PART 4: Widgets Tkinter do Python
Widgets Tkinter
Summary:
PART 5: Gerenciador de Geometria do Tkinter em Python
Controlando o Layout da Aplicação Tkinter
1. Gerenciador de Geometria Tkinter pack()
Algoritmo de Empacotamento:

Exemplo de Gerenciador de Geometria Tkinter pack():

Tkinter pack() com Parâmetros

2. Gerenciador de Geometria grid() do Tkinter

Exemplo de Gerenciador de Geometria Tkinter grid() :

3. Lugar de Trinket() Gerenciador de Geometria

Exemplo de Gerenciador de Geometria place() do Tkinter:

Summary:
PART 6: Widget Label do Tkinter em Python
Widget Label do Tkinter
Exemplo de Widget Label do Tkinter

Widget Label do Tkinter - Outro Exemplo

Summary:
PART 7: Widget Botão Tkinter do Python
Widget de Botão Tkinter
Exemplo de Widget de Botão Tkinter
Tkinter Button Widget - Add style and Event handler
Summary:
PART 8: Widget Checkbutton do Python Tkinter
Widget Checkbutton do Tkinter
Métodos do Widget Checkbutton do Tkinter:
Exemplo de Widget Checkbutton do Tkinter

Resumo
PART 9: Widget Radiobutton do Python Tkinter
Widget Radiobutton do Tkinter
 Métodos do Widget Radiobutton do Tkinter:
Exemplo de Widget Radiobutton do Tkinter
Tkinter Radiobutton Widget Outro Exemplo
Summary:
PART 10: Widget Entry do Python Tkinter
Widget de Entrada Tkinter
Exemplo de Widget Entry do Tkinter

Resumo
PART 11: Widget de Mensagem Tkinter do Python
Widget de Mensagem do Tkinter

Exemplo de Widget de Mensagem Tkinter

Summary:
PART 12: Widget de Menu do Python Tkinter
Widget de Menu Tkinter
Exemplo de Widget de Menu Tkinter

Summary:
PART 13: Widget Menubutton do Python Tkinter
Widget Menubutton do Tkinter
Opções do Widget Menubutton do Tkinter:
Exemplo de Widget Menubutton do Tkinter
PART 14: Widget Frame do Python Tkinter
Widget Frame do Tkinter
Exemplo de Widget Frame do Tkinter

Summary
PART 15: Widget Canvas do Python Tkinter
Widget Canvas do Tkinter
Exemplo Básico do Widget Canvas do Tkinter
Widget Canvas Tkinter - Gráfico de Pizza usando Arcos

Summary:
PART 16: Widget Listbox do Python Tkinter
Widget Listbox do Tkinter
Opções do Widget Listbox do Tkinter:
Exemplo de Widget ListBox do Tkinter

Summary:
PART 17: Widget de Scrollbar do Python Tkinter
Widget de Barra de Rolagem Tkinter
 Opções do Widget Scrollbar do Tkinter:
Métodos do Widget Scrollbar do Tkinter:
Exemplo de Widget de Scrollbar do Tkinter

Resumo:
PART 18: Widget Scale do Tkinter em Python
Widget Scale do Tkinter
Métodos do Widget Scale do Tkinter

Widget Scale Tkinter - Exemplo Horizontal

Widget Scale do Tkinter -VeExemplo Vertical
Summary:
PART 19: Widget Toplevel do Python Tkinter
Widget Toplevel do Python Tkinter
Exemplo de Widget Toplevel do Tkinter

Summary:
PART 20: Widget Spinbox do Python Tkinter
Widget Spinbox do Tkinter
Exemplo de Widget Spinbox do Tkinter

Summary:
PART 21: Widget LabelFrame do Python Tkinter
Widget LabelFrame do Tkinter
Exemplo de Widget LabelFrame do Tkinter

Summary:
PUmRT 22: Python Tkinter PanedWindow Widget
Widget PanedWindow do Tkinter
Métodos do Widget PanedWindow do Tkinter:
Exemplo de Widget PanedWindow do Tkinter
Widget PanedWindow do Tkinter - Exemplo de Vários Painéis
Summary:
PART 23: Widget Text do Python Tkinter
Widget de Texto Tkinter
Métodos do Widget de Texto Tkinter:
Métodos para Manipulação de Tags

Métodos para Manuseio de Marcadores

Exemplo de Widget de Texto Tkinter

Summary:
PART 24: Caixa de Mensagem Tkinter do Python
 Caixa de Mensagem Tkinter

Caixa de Mensagem Tkinter - mostrar aviso()

Tkinter MessageBox - askquestion()

Tkinter MessageBox - askretrycancel()
Tkinter MessageBox - mostrarErro()
Summary:
PART 25: Aplicativo de Calculadora usando Tkinter (Projeto em Python)
O que é uma calculadora?
Código do Aplicativo Calculadora

Summary:
PART 26: Aplicativo de Editor de Texto Usando Tkinter (Projeto em Python)
1. Criando todos os widgets necessários
Explicação do código acima:
[Link]ção do Layout do Aplicativo
1. Função para Abrir o Arquivo
Explicação:
2. Função para Salvar o Arquivo
Explicação:
PART 27: Aplicativo de Reprodutor de Música usando Tkinter (Projeto em Python)
Bibliotecas usadas para Aplicativo de Reprodutor de Música:

1. Tkinter
2. Módulo Pygame

3. Módulo OS
Classe MusicPlayer
1. Construtor _init_
2. A Função playsong()
3. A Função stopsong()
4. A Função pausesong()
5. A Função unpausesong()
6. Looping da Janela Raiz
PART 28: Jogo Brick Breaker usando Tkinter (Projeto em Python)
Pré-requisitos:
Código para o jogo Brick Breaker

GameObject class
Classe Bola
 Classe de Paddle
Classe de Tijolo

Classe de Jogo

Código Completo para o Jogo Brick Breaker:

Brick Breaker Game UI:
PART 29: Aplicativo de Calculadora Usando a Linguagem Python
O que é uma Calculadora?
Código Fonte para Aplicativo de Calculadora
Summary:
PART 30: Despertador Usando a Linguagem Python
Passos sobre como fazer um despertador usando Python.
Despertador Usando Python Com Código Fonte
Código para Importar Módulos
Código Para O Módulo Horário Atual
Código Para O Módulo De Configuração Do Alarme
Código para a GUI
Código Fonte Completo do Despertador Usando Python
Conclusão
PUmRT 31: Jogo de Adivinhação de Números em Python
Regras do Jogo de Adivinhação de Números

Implementação do Jogo de Adivinhação de Números em Linguagem Python

PART 32: Jogo em Python: Pedra, Papel, Tesoura

Código-fonte de Pedra, Papel e Tesoura
1. Atribua uma escolha ao computador
2. Receber entrada do jogador
3. Usando um loop while para jogar várias rodadas
4. Exibir Pontuação
5. Opção para jogar novamente ou sair
Saída-
PART 33: Aplicativo de Notificação para Desktop - Projeto em Python
O queYoVocê descobrirá neste artigo
Step 1: Importing Libraries
Etapa 2: Recuperando os Dados da Web
Passo 3: Criando Notificação Personalizada
Código Fonte para Aplicativo de Notificador de Desktop

Output:
Como posso desativar as notificações?
Conclusão

Projetos de GUI Tkinter com

Python
PARTE 1: Introdução a
Módulo Tkinter do Python
Neste tutorial, abordaremos uma introdução ao Tkinter, sua
prerequisites, different ways for GUI Programming, how to
instale o Tkinter, e está funcionando.
Tkinter é uma biblioteca padrão em python usada para
creatingGraphical User Interface (GUI)for Desktop
Aplicações. Com a ajuda do Tkinter desenvolvendo desktop
aplicações não é uma tarefa difícil.
A principal biblioteca de interface gráfica que usaremos é o Tk, que é
A biblioteca GUI padrão do Python. Acessaremos Tk a partir do seu Python
interface chamada Tkinter (abreviação de Tk interface).

Pré-requisitos para Tkinter

Antes de aprender Tkinter, você deve ter conhecimento básico de
Python. Você pode aprender Python usando nossoPython Completo
Tutorial.

Programação de GUI em Python

Existem muitas maneiras de desenvolver programas baseados em GUI em
Python. Essas diferentes maneiras são apresentadas abaixo:

[Link]:
Em Python, Tkinter é uma GUI (interface gráfica do usuário) padrão
pacote de interface). Tkinter é a GUI padrão do Python
módulo e também a maneira mais comum que é usada
para programação GUI em Python. Note que Tkinter é um
um conjunto de wrappers que implementam os widgets Tk como Python
aulas.

wxPython:
Isso é basicamente uma GUI de código aberto e multiplataforma
um kit de ferramentas que é escrito em C++. Também uma alternativa a
Tkinter.
 [Link]:
JPython é uma plataforma Python para Java que está fornecendo
Acesso contínuo de scripts Python à classe Java
Bibliotecas para a máquina local.
Abordaremos Programação GUI com Tkinter.

O que é Tkinter?
Tkinter em Python ajuda a criar aplicações GUI com uma
mínimo incômodo. Entre várias estruturas de GUI, Tkinter é
a única estrutura que está embutida na Biblioteca Padrão do Python
Biblioteca.

Uma característica importante a favor do Tkinter é que ele

é multiplataforma, então o mesmo código pode funcionar facilmente
no Windows, macOS e Linux.
Tkinter é um módulo leve.
É simples de usar.

O que são Tcl, Tk e Tkinter?

Vamos tentar entender mais sobre o módulo Tkinter por
discutindo mais sobre sua origem.
Como mencionado, Tkinter é a interface gráfica padrão do Python
biblioteca, que nada mais é do que um módulo de wrapper em
top do kit Tk.
Tkinter é baseado na biblioteca Tk, e que foi
originalmente projetado para o Comando de Ferramentas
Linguagem (Tcl). Como o Tk é muito popular, assim ele tem
foi adaptado para uma variedade de outros scripts
linguagens, incluindo Perl (Perl/Tk), Ruby
(Ruby/Tk) e Python (Tkinter).
portabilidade e flexibilidade no desenvolvimento de GUI
Tkmakes é a ferramenta certa que pode ser usada para
desenhar e implementar uma ampla variedade de
aplicações GUI de qualidade comercial.
 Python com Tkinter nos fornece uma forma mais rápida e
forma eficiente para construir aplicações úteis
isso teria levado muito tempo se você tivesse que
programar diretamente em C/C++ com a ajuda de nativo
Bibliotecas do sistema OS.
Uma vez que tenhamos o Tkinter em funcionamento, usaremos
blocos de construção básicos conhecidos como widgets para criar um
variedade de aplicativos de desktop.

Instalar Tkinter
É provável que o Tkinter já esteja instalado no seu
sistema junto com Python. Mas nem sempre é verdade. Então vamos
primeiro verifique se está disponível.

Se você não tiver o Python instalado no seu sistema - Instale

Python 3.8 primeiro, e depois verifique o Tkinter.
Você pode determinar se o Tkinter está disponível para o seu
Interpretador Python ao tentar importar o Tkinter
módulo - Se o Tkinter estiver disponível, então não haverá erros,
como demonstrado no código a seguir:
importar tkinter
Nada explodiu, então sabemos que temos Tkinter disponível. Se
se você ver algum erro como módulo não encontrado, etc, então
seu interpretador Python não foi compilado com Tkinter
ativado, a importação do módulo falha e você pode precisar de
recompile seu interpretador Python para ter acesso ao Tkinter.

AddingTkto your Applications

Etapas básicas para configurar uma aplicação GUI usando Tkinter
Python são os seguintes:

Primeiramente, importe o módulo Tkinter.

2. O segundo passo é criar uma janela de nível superior.
objectthat contains your entire GUI application.
3. Então, no terceiro passo, você precisa configurar tudo o que você
Componentes de GUI e sua funcionalidade.
 4. Então você precisa conectar esses componentes da GUI a
o código de aplicação subjacente.
5. Em seguida, basta entrar no loop principal usando mainloop()
The above steps may sound gibberish right now. But just read
todos eles, e nós iremos explicar tudo à medida que avançamos com
este tutorial.

Primeiro Exemplo de Tkinter

Conforme mencionado anteriormente, na programação de GUI, todos os principais
os widgets são construídos apenas no objeto da janela de nível superior.

O objeto de janela de nível superior é criado pela classe Tk.

emTkinter.
Vamos criar uma janela de nível superior:
importar tkinter como tk

win = [Link]()
###você pode adicionar widgets aqui

[Link]()

Métodos Tkinter usados acima:

Os principais dois métodos são usados ao criar o Python
aplicação com GUI. Você precisa lembrar deles e
estes estão dados abaixo:
[Link](screenName=None, baseName=None,
className='Tk', useTk=1)
Este método é utilizado principalmente para criar a janela principal.
também pode mudar o nome da janela se quiser, apenas por
mudando o className para o desejado.
O código usado para criar a janela principal do aplicativo é
e nós também o utilizamos em nosso exemplo acima:
win = [Link]() ## onde win indica o nome do principal
objeto de janela
2. A Função mainloop()
Este método é usado para iniciar o aplicativo.
A função mainloop() é um loop infinito que é usado para executar
o aplicativo, ele aguardará um evento ocorrer e processar
o evento enquanto a janela não estiver fechada.

Summary:
Com isso, completamos a introdução ao Tkinter, nós
instalou o módulo Tkinter e até sabe o que são
Janelas e Widgets no Tkinter. Também criamos nosso primeiro
Aplicativo GUI Tkinter e executá-lo. No próximo tutorial, aprenderemos
mais sobre widgets Tkinter do Python.
PARTE 2: Janelas Tkinter
Widgets e Quadros
Neste tutorial, vamos cobrir o básico do módulo Tkinter,
para explicar o que é uma TkinterWindow, Widgets, e
Frames que são os blocos de construção de aplicações GUI em
Tkinter.

Introdução às Janelas Tkinter e

Widgets
Vamos mergulhar um pouco mais fundo, para entender alguns fundamentos sobre
o módulo Tkinter e como funciona.

O objeto da janela de nível superior na Programação GUI

contém todos os pequenos objetos da janela que estarão
Parte da sua interface gráfica completa.

Os pequenos objetos da janela podem ser texto

rótulos, botões, caixas de lista, etc., e estes individuais
pequenos componentes de GUI são conhecidos como Widgets.
 Assim, ter um objeto de janela de nível superior atuará como um
container onde você colocará todos os seus widgets. Em
Python, você normalmente faria isso assim usando o
seguinte código: win = [Link]()
O objeto que é retornado ao fazer uma chamada
[Link]() é geralmente referido como o Root
Janela.
Janelas de alto nível são principalmente independentes como Parte
do seu aplicativo, você também pode ter mais do que
uma janela de nível superior para sua GUI, mas apenas uma de
eles devem ser sua janela raiz.
Primeiro de tudo, você precisa projetar todos os seus widgets
completamente, e então adicione a funcionalidade real.
Os widgets podem ser autônomos ou podem
sercontainers. Se um widget contiver outros widgets,
é considerado o pai daqueles widgets.
Da mesma forma, se um widget estiver contido dentro de outro
widget, é conhecido como um filho do
pai, o pai é o próximo que está imediatamente ao redor
widget de contêiner.
Os widgets também têm alguns comportamentos associados,
como quando um botão é pressionado, ou o texto é preenchido
em um campo de texto, para que tenhamos eventos associados a estes
ações.
O comportamento dos widgets gera eventos, e
a resposta doGUI a eventos é conhecida
asCallbacks - porque eles 'chamam' uma função apenas para
lidar com o evento que ocorreu.

Processamento Baseado em Eventos do Tkinter

No Tkinter, temos janelas e widgets se unindo para
formar uma aplicação GUI. Mas a aplicação GUI é apenas a
frontend do aplicativo. Você gostaria de executar alguns
lógica de código quando o usuário final usa esses widgets.

Sempre que uma ação é realizada em qualquer widget, um evento é

gerado, que podemos manusear para realizar qualquer operação.
 Eventos (comportamento dos widgets) podem incluir pressionar um
button,movement of the mouse,hitting the return
ou tecla Enter, ganhando ou perdendo 'foco', etc.
Todo o sistema de eventos que ocorre a partir de
o início até o fim de qualquer GUI
a aplicação é o que a impulsiona e, portanto, também é
conhecido como Processamento Orientado a Eventos.

Vamos pegar um exemplo simples de movimento do mouse:

Suponha que o ponteiro do mouse esteja apenas parado.
em algum lugar no topo da sua aplicação GUI. Se você
move o mouse para outra parte do seu
aplicação, algo tem que causar o movimento de
o mouse a ser replicado pelo cursor no seu
tela (em cima da sua aplicação GUI). Esses
são eventos de 'movimento do cursor' que o sistema deve
processo para retratar seu cursor se movendo pelo
janela. No momento em que você parar de se mover o
mouse, não há mais eventos que precisam ser processados, então
tudo permanece parado na tela novamente.
Aqui estão algumas definições básicas através das quais você será
capaz de compreender o conceito de Janelas, widgets, e
quadros no Tkinter.

Janelas Tkinter
The term “Window” has different meanings in the different
contextos, mas geralmente "Janela" refere-se a uma área retangular
em algum lugar na tela do usuário através da qual você
pode interagir.
Então vem o conceito de Janela de Nível Superior em
Tkinter.

Janela Top-Level do Tkinter

A Janela de Nível Superior é uma janela que existe
independentemente na tela. Você pode decorar o nível superior
janela com o quadro padrão e controles para a área de trabalho
gerente. Normalmente, pode ser movido pela área de trabalho, e
você também pode redimensioná-lo se quiser.
Então vem o conceito de Widgets. Vamos tentar
entender isso.

Widgets Tkinter
O termo "Widgets" é um termo genérico que se refere a
os blocos de construção que compõem uma aplicação em um
interface gráfica do usuário.
Vamos listar os widgets principais com suas categorias:

Container
Sob esta categoria, os widgets que se encontram são quadro,
labelframe, toplevel e janela dividida.

Botões
Sob a categoria de Botões, há botões,
botões de rádio, botões de verificação (checkbox) e botões de menu.

Widgets de Texto
Sob a categoria de widgets de texto, existem rótulos,
texto

Widgets de Entrada

Sob esta categoria, os widgets são escala, barra de rolagem,

Lista, controle deslizante, caixa de rolagem, entrada (linha única), menu de opções,
text (multiline), and canvas (vector and pixel graphics).
Agora vamos passar para Frames no Tkinter.

Frames do Tkinter
Uma moldura é basicamente uma área retangular que pode conter outros
widgets. No Tkinter, existe um widget Frame que é o básico
unidade de organização para layouts complexos. É um widget que
não possui estilo especial ou componente de interface gráfica próprio. É apenas
usado para conter outros widgets Tkinter em caso de GUI complexa
layouts.
Nota: É importante notar aqui que sempre que qualquer widget é
criado, também há uma relação pai-filho que é criada.
Apenas tome um exemplo, se você colocar um botão dentro de um quadro, o
o widget frame é chamado de pai do widget Button.

Exemplo Básico de Tkinter

Vamos pegar um exemplo onde criaremos um Tkinter
aplicativo com um widget simpleText:
de tkinter import *
win = Tk()# Crie a janela raiz (base)
[Link]("200x200")
w = Label(win, text=“Hello, Welcome to Studytonight!”)#
Crie um rótulo com palavras
[Link]()# Coloque o rótulo na janela
[Link]()# Iniciar o loop de eventos

O código acima criará uma janela com o widget de rótulo

e a saída será como mostrado acima. Nós criamos um
Janela Tkinter e então adicionei um widget Label básico a ela.

Summary:
Neste tutorial, aprendemos sobre os blocos de construção básicos de
Aplicativo GUI usando Tkinter que são Janelas, Widgets,
e Frames, que são usados para desenvolver diferentes GUI
aplicações. No próximo tutorial, aprenderemos como criar um
Janela Tkinter que é o ponto de partida para qualquer
aplicativo, porque em uma janela Tkinter adicionamos tudo
widgets.
PARTE 3: Janelas Tkinter
Neste tutorial, aprenderemos sobre janelas Tkinter em Python
qual é a principal Janela da aplicação GUI dentro
cada outro componente funciona. Cobriu-se o básico
Componentes de aplicativo GUI Tkinter nos quais temos
explicou como as Janelas, Widgets e Frames do Tkinter são
blocos de construção de um aplicativo Tkinter.

Janelas Tkinter
A janela Tkinter é o elemento fundamental do
GUI Tkinter. A janela Tkinter é um contêiner no qual todos
outros elementos de GUI (widgets) ao vivo.

Aqui está a sintaxe para criar uma janela Tkinter básica:

win = Tk()
Sim, usamos a função Tk() para criar nosso aplicativo Tkinter
janela na qual todos os outros componentes são adicionados.

Exemplo de Janelas Tkinter:

Here is a simple example,
de tkinter importar *
win = Tk()
execute a janela do aplicativo

[Link]()
No exemplo acima, a função themainloop() é usada para executar o
Aplicação GUI.

Janela Personalizada Tkinter

Vamos agora cobrir um exemplo básico onde criaremos um
Aplicativo GUI básico usando propriedades
gostar título e geometria.
Aqui está o código para demonstrar os passos utilizados na
criação de uma janela Tkinter personalizada:
fromtkinterimport*
window = Tk()
Você pode adicionar seus widgets aqui

[Link]('Olá StudyTonight')
[Link]("300x200+10+20")
[Link]()

Aqui está o que fizemos no código:

O primeiro passo é importar o módulo Tkinter no

código.
Após a importação, o segundo passo é configurar o
objeto de aplicativo chamando a função theTk(). Isso
criará uma janela de nível superior (raiz) com um quadro
com uma barra de título e caixa de controle com o minimizar
e botões de fechar, e uma área de cliente para segurar outros
widgets.
Depois disso, você pode adicionar os widgets que desejar.
adicionar no seu código como botões, caixa de texto, barra de rolagem,
 rótulos, e muitos mais.
A função [Link]() é usada para fornecer o título a
a interface do usuário como você pode ver na saída.
Na linha [Link]("300x200+10+20");
o método thegeometry() define
a largura, a altura e as coordenadas do canto superior esquerdo
canto da moldura conforme segue (todos os valores são
geralmente em pixels) da mesma forma. Aqui está o
sintaxe:

[Link]("larguraxaltura+XPOS+YPOS")
Depois disso, o objeto da aplicação entra em um evento
loop de escuta chamando ométodo mainloop(). Neste
de maneira que o aplicativo está agora constantemente aguardando por
qualquer evento gerado nos elementos nele.
pode ser um evento como texto inserido em um campo de texto,
uma seleção feita a partir do menu suspenso ou rádio
botão, ações de clique simples/duplo do mouse, etc.
A funcionalidade do aplicativo envolve executar
funções de retorno apropriadas em resposta a um Particular
tipo de evento.
O loop de eventos será encerrado assim que houver um clique feito
no botão fechar na barra de título.

Summary:
Neste tutorial, aprendemos como criar uma janela Tkinter para
crie um aplicativo GUI. A janela Tkinter contém tudo o
widgets que tornam a aplicação.
PARTE 4: Python Tkinter
Widgets
Neste tutorial, abordaremos uma visão geral dos widgets do Tkinter
em Python. Esses widgets são as unidades funcionais em qualquer
Aplicação GUI Tkinter.

Widgets Tkinter
Existem vários controles, como botões, rótulos,
barras de rolagem, botões de rádio e caixas de texto usados em uma GUI
aplicação. Esses pequenos componentes ou controles de Gráficos
A Interface Gráfica do Usuário (GUI) é conhecida como widgets no Tkinter.

Summary:
Então, neste tutorial, tivemos uma introdução básica ao Trinket
Widgets. Nas nossas próximas páginas de tutoriais, abordaremos cada
widget em detalhes com seus respectivos exemplos de código.
O método Thepack() utiliza principalmente um algoritmo de empacotamento para
coloque os widgets em um quadro ou janela em uma ordem especificada.
Este método é principalmente utilizado para organizar os widgets em um
bloquear.

Packing Algorithm:
Os passos do algoritmo de empacotamento são os seguintes:

Primeiramente, este algoritmo calculará um retângulo.

área conhecida como um Pacote que é alto (ou largo)
suficiente para segurar o widget e então preencherá o
largura (ou altura) restante na janela
com espaço em branco.
Ele centralizará o widget até qualquer localização diferente
está especificado.

Este método é poderoso, mas é difícil de visualizar.

Aqui está a sintaxe para usar a função pack():
[Link](opções)
As opções possíveis como parâmetro para este método são dadas
abaixo:
encher
O valor padrão desta opção é definido como NENHUM. Além disso, nós
pode configurá-lo para X ou Yin a fim de determinar se
o widget contém algum espaço extra.
lado
Esta opção especifica de que lado empacotar o widget
contra. Se você quiser empacotar widgets verticalmente,
useTOPque é o valor padrão. Se você quiser
empacotar widgets horizontalmente, usar ESQUERDA.

expandir
Esta opção é usada para especificar se os widgets
deve ser expandido para preencher qualquer espaço extra na
mestre de geometria ou não. O valor padrão é falso. Se ele
se falso, então o widget não está expandido, caso contrário, widget
expands to fill extra space.
Exemplo de Gerenciador de Geometria Tkinterpack()
Vamos discutir um exemplo onde veremos o que acontece
quando você empacota() três widgets de Frame coloridos (aqui está o Tkinter
Widget de quadro) em uma janela:
importar tkinter como tk

win = [Link]()
adicione uma moldura laranja

frame1 = [Link](master=win, width=100, height=100,

bg=“orange”)
[Link]()
adicionar moldura azul

frame2 = [Link](mestre=win, largura=50, altura=50,

bg=“blue”)
[Link]()
# adicionar moldura verde

frame3 = [Link](master=win, width=25, height=25,

bg=“green”)
[Link]()
[Link]()

De acordo com a saída do código acima, o método thepack()

apenas coloca cada quadro abaixo do anterior por padrão, em
the sameorder in which they’re assigned to the window.
Tkinterpack()com Parâmetros
Vamos usar mais alguns exemplos de código utilizando os parâmetros de
essa função como preencher, lado e expandir.
Você pode definir opreencherargumento para especificar em
em qual direção você quer que as molduras sejam preenchidas. Se você quiser
para preencher a direção horizontal, então a opção é tk.X,
enquanto, tk.Y é usado para preencher verticalmente e preencher em ambos
[Link] é usado.
Vamos pegar outro exemplo onde empilharemos os três
quadros de forma que cada um preencha toda a janela horizontalmente:
importtkinterastk
win= [Link]()
frame1 = [Link](master=win, height=80, bg=“red”)
# adicionando o argumento de preenchimento com

valor de preenchimento horizontal

[Link](fill=tk.X)
frame2 = [Link](master=win, height=50, bg=“yellow”)
[Link](fill=tk.X)
frame3 = [Link](master=win, height=40, bg=“blue”)
[Link](fill=tk.X)
[Link]()

Na saída acima, você pode ver que as molduras preenchem todo o

largura da janela do aplicativo porque usamos
[Link] para o parâmetro de preenchimento.

Agora vamos pegar outro exemplo de código, onde estaremos usando

todas as opções, nomeadamente, preencher, lado e expandir opções de
o método thepack()
importar tkinter como tk

win = [Link]()
frame1 = [Link](mestre=win, largura=200, altura=100,
bg=“Yellow”)
# definindo preenchimento, lado e expandir

[Link](preencher=[Link], lado=[Link], expandir=True)

frame2 = [Link](master=win, width=100, bg=“blue”)
[Link](fill=[Link], side=[Link], expand=True)
frame3 = [Link](master=win, width=50, bg=“green”)
[Link](fill=[Link], side=[Link], expand=True)
[Link]()

Se você executar este código acima em seu sistema, então você pode
veja que esta saída é capaz de se expandir em ambas as direções.

2. Gerenciador de Geometria Tkintergrid()

O gerenciador de geometria mais utilizado é o grid() porque ele fornece
todo o poder da função pack() mas de uma forma mais fácil e
de forma sustentável.
O gerenciador de geometria grid() é principalmente usado para dividir uma
janela ou quadro em linhas e colunas.

Você pode facilmente especificar a localização de um widget apenas

chamando a função grid() e passando a linha e
coluna indica para opalavrachaveemlinhaecoluna
argumentos, respectivamente.
O índice tanto da linha quanto da coluna começa em 0, então um
o índice da linha de 2 e o índice da coluna de 2 dizem
a função thegrid() para colocar um widget no terceiro
 coluna da terceira linha (0 é a primeira, 1 é a segunda e 2
significa terceiro).

Aqui está a sintaxe da função grid():

[Link](opções)
As opções possíveis como parâmetro para este método são dadas
abaixo:

Coluna
Esta opção especifica o número da coluna na qual o
o widget deve ser colocado. O índice da coluna mais à esquerda é 0.

Linha
Esta opção especifica o número da linha na qual o widget
deve ser colocado. A linha mais alta é representada por 0.

Colunar
Esta opção especifica a largura do widget. Principalmente
representa o número de colunas até o qual, o
a coluna está expandida.

Rowspan
Esta opção especifica a altura do widget. Ela principalmente
representa o número de linhas até as quais, a linha é
expandido.

padx, pady
Esta opção representa principalmente o número de pixels de
padding a ser adicionado ao widget logo fora do
borda do widget.

ipadx, ipady
Esta opção é principalmente usada para representar o número de
pixels de preenchimento a serem adicionados ao widget dentro do
borda do widget.

Pegajoso
 Se alguma célula for maior que um widget, então sticky é
principalmente usado para especificar a posição do widget dentro
a célula. É basicamente a concatenação das letras adesivas
que representa a posição do widget. Pode ser N,
{"E":"L","W":"O","S":"S","NE":"NE","NW":"NO","NS":"NS","EW":"LE","ES":"ES"}

Exemplo do Gerenciador de Geometria Tkintergrid()

O seguinte script de código ajudará você a criar um 5 × 3
grade de quadros comWidgets de rótulo empacotados neles:
importar tkinter como tk

win = [Link]()
foriinrange(5):
forjinrange(3):
quadro = [Link](
master = win,
relief = [Link],
borderwidth =1
)
[Link](linha=i, coluna=j)
label = [Link](master=frame, text=f”Row{i}\nColumn
{j}”)
[Link]()
[Link]()

Se você quiser adicionar um pouco de preenchimento, pode fazê-lo usando

o seguinte trecho de código:
importar tkinter como tk

win = [Link]()
para i em range(5):
forjinarange(3):
quadro = [Link](
master=win,
relief=[Link],
borderwidth=1
)
[Link](linha=i, coluna=j, padx=5, pady=5)
label = [Link](master=frame, text=f”Row{i}\nColumn
{j}”)
[Link]()
[Link]()

Como você pode ver no exemplo de código acima, usamos

os parâmetros padx e pady devido aos quais o preenchimento é
aplicado fora do widget. Para adicionar preenchimento dentro do Frame
widget, use os parâmetros ipadx e ipady em seu código.
Da mesma forma, tente usar outros parâmetros também para
gerenciador de geometria thegrid()

3. Trinketplace() Gerenciador de Geometria

O Geômetro Theplace() organiza os widgets para colocar
eles em uma posição específica conforme orientado pelo programador.

Este método basicamente organiza o widget em

de acordo com suas coordenadas x e y. Tanto x quanto
as coordenadas y estão em pixels.
Assim, a origem (onde x e y são ambos 0) é o topo-
canto esquerdo doMoldure a janela.
Assim, o argumento especifica o número de pixels
do espaço do topo da janela, para colocar o
widget, e o argumento especifica o número de
pixels a partir da esquerda da janela.
Aqui está a sintaxe do método place():
[Link](opções)
As opções possíveis como parâmetro para este método são dadas
abaixo:

x, y
Esta opção indica o deslocamento horizontal e vertical
nos pixels.

height, width
Esta opção indica a altura e o peso do widget
nos pixels.

Âncora
Esta opção representa principalmente a posição exata do
widget dentro do contêiner. O valor padrão (direção)
éNWque é (o canto superior esquerdo).

modo de borda
Esta opção indica o valor padrão da borda
tipo que éDENTROe também se refere a ignorar o
o pai está dentro da fronteira. A outra opção é FORA.

relx, rely
 Esta opção é usada para representar o número decimal entre 0,0 e
1.0 e é o deslocamento na horizontal e vertical
direção.

relheight, relwidth
Esta opção é usada para representar o valor flutuante entre
0,0 e 1,0 indicando a fração da altura do pai
e largura.
Exemplo de Gerenciador de Geometria Tkinterplace()
O trecho de código para isso é dado abaixo:
from tkinter import *
top = Tk()
[Link]("400x250")
Nome de usuário = Label(top, text =“Nome de usuário”).place(x =30,y =
50)
email = Label(top, text =“Email”).place(x =30, y =90)
password = Label(top, text =“Password”).place(x =30, y =
130)
e1 = Entry(top).place(x =80, y =50)
e2 = Entry(top).place(x =80, y =90)
e3 = Entrada(cima).colocar(x = 95, y = 130)
[Link]()

No exemplo de código acima, usamos Tkinter

Label e widget Entry Tkinter, vamos cobri-los em detalhes
nos próximos tutoriais.

Summary:
Neste tutorial, aprendemos como podemos posicionar nossos widgets
dentro da moldura ou janela da nossa aplicação GUI. Nós
aprendi sobre os três gerenciadores de geometria do Tkinter, nomeadamente,
pack(), grid() e place().
A partir do próximo tutorial, começaremos a cobrir diferentes Tkinter
widgets.
PARTE 6: Python Tkinter
Widget de Rótulo
Neste tutorial, cobriremos o widget TkinterLabel
Python, que é usado para criar um Rótulo na aplicação GUI
no qual podemos mostrar qualquer texto ou imagem.

O widget label no Tkinter é usado para exibir

caixas onde você pode colocar suas imagens e texto.

O widget label é principalmente usado para fornecer um

mensagem sobre os outros widgets usados no Python
Aplicação para o usuário.
Você pode mudar ou atualizar o texto dentro do rótulo
widget sempre que você quiser.
Este widget usa apenas uma fonte por vez.
displaying some text.
Você pode realizar outras tarefas como sublinhar alguns
Parte do texto e você também pode abranger texto para
várias linhas.
Existem várias opções disponíveis para configurar o
texto ou parte do texto mostrado no rótulo.

Widget Label do Tkinter

A sintaxe do widget de rótulo é dada abaixo,
W = Label(mestre, opções)
Na sintaxe acima, o parâmetro master denota o pai
Você pode usar muitosopções para configurar o texto e
these options are written ascomma-separated key-value
pares.
Exemplo de Widget Label do Tkinter
Agora vamos ver um exemplo básico do widget de rótulo e o
o trecho de código é dado abaixo:
importar tkinter
de tkinter import *
win = Tk()
var = StringVar()
label = Label( win, textvariable=var, relief=RAISED )
# definir valor do rótulo

Oi!? Bem-vindo ao StudyTonight

[Link]()
[Link]()

No código acima, criamos uma variável simples variableStringVar() e

então atribuiu um valor a ele, e esta variável é atribuída como
valor para a opção textvariable do widget Label.

Widget Label Tkinter - Outro

Exemplo
Abaixo temos outro trecho de código para mais clareza
understanding. Let us see the code snippet given below:
fromtkinterimport*
win = Tk()
[Link]("400x250")
#criando um rótulo
username = Label(win, text =“Username”).place(x =30,y =
50)
criando o segundo rótulo
password = Label(win, text =“Password”).place(x =30, y =
90)
submitbutton = Button(win, text =“Submit”,activebackground
="vermelho", activeforeground ="azul".place(x =30, y =120)
e1 = Entrada(win, largura=20).lugar(x=100, y=50)
e2 = Entry(win, width =20).place(x =100, y =90)
[Link]()
Sempre que você executar o código acima, após inserir os valores
em nome de usuário e etiqueta de senha, quando você clicar em
o botão de envio então sua cor muda para vermelho.

Não se preocupe com o Widget de Botão e o Widget de Entrada utilizados

no código acima, iremos abordá-los brevemente no próximo
tutoriais. Este exemplo é para te dar uma ideia sobre como
Os widgets Tkinter são usados para criar interfaces de usuário para seu
Aplicação Tkinter.

Summary:
Neste tutorial, abordamos o Widget Label do Tkinter que é
usado para mostrar texto e imagens em aplicativos GUI Tkinter ou para
adicione textos com campos de entrada de formulário como fizemos no
exemplo acima.
PARTE 7: Python Tkinter
Widget de Botão
Neste tutorial, cobriremos o widget Button do Tkinter
módulo em Python.
O widget Button no Tkinter é principalmente utilizado para adicionar um botão
em qualquer aplicativo GUI. Em Python, ao usar o Tkinter
button widget, we can easily modify the style of the button
como adicionar cores de fundo a ele, ajustando a altura e
width of button, or the placement of the button, etc. very
facilmente.

You can add various types of buttons(as per your

interfaces de usuário) para seu aplicativo com a ajuda de
o Widget de Botão.
Você também pode associar qualquer método ou função com
um botão se você quiser e então esse método irá obter
chamado sempre que você pressiona o botão.
Existem muitas opções de widget de botão que
você pode redefinir ou configurar de acordo com seu
requisitos.

Widget de Botão Tkinter

A sintaxe do widget de botão é dada abaixo,
W = Botão(mestre, opções)
Na sintaxe acima, o parâmetro master denota o pai
[Link]ê pode usar muitas opções para mudar a aparência do
os botões e essas opções estão escritos como separados por vírgula.
Exemplo de Widget Botão Tkinter
Agora vamos criar um botão de envio simples com a ajuda de código
trecho dado abaixo:
fromtkinterimport*
win = Tk() ## win é uma janela principal ou pai
[Link]("200x100")
b = Button(win, text =“Submit”)
[Link]()#usando a geometria pack()
[Link]()

No exemplo de código acima, criamos uma janela simples de

dada a largura e a altura. Então, adicionamos um widget de botão a ele
com fornecendo a janela criada como a mestra disso
botão e adicionando um texto para o botão.

Widget Botão Tkinter - Adicione estilo e

Manipulador de eventos

Below we have another code snippet where we will change the

aparência dos botões adicionando mais estilo a eles. Vamos ver como nós
faça isso:

importar tkinter
de tkinter importar *
fromtkinterimportmessagebox
top = Tk()
[Link](“300x150”)
defclick():
[Link](“Hello”,“Green Button clicked”)
amarelo
activebackground=“orange”, pady=10)
b = Botão(top, texto="Azul", primeira cor ativa="azul",
activebackground=“orange”, pady=10)
# adicionando função de clique ao botão abaixo
c = Botão(top, texto= "Verde0", comando=clique,
activeforeground =“green”, activebackground=“orange”,
pady=10)
d = Botão(top, texto=“vermelho”, ativofrente=“amarelo”,
activebackground=“orange”, pady=10)
[Link](side = ESQUERDA)
[Link](side = DIREITA)
[Link](side = TOP)
[Link](side = BOTTOM)
[Link]()

No código acima, adicionamos alguns estilos usando diferentes

opções e adicionamos um manipulador de eventos para lidar com o
evento de clique do 3º botão. Então, sempre que você clicar em um
clique no botão com o texto Verde, você verá um Tkinter
caixa de mensagem com uma mensagem.

Summary:
Neste tutorial, aprendemos como criar um botão Tkinter
widget com várias opções, como mudar o estilo do
botão, adicionar texto ao botão ou posicionar o botão. Nós
também vi um exemplo de código para adicionar uma função de manipulador de eventos
para qualquer botão para realizar alguma ação quando o botão for
clicado.
PARTE 8: Checkbutton Tkinter do Python
Widget
Neste tutorial, cobriremos o widget Checkbutton do Tkinter em Python, que é usado para
criar caixas de seleção na interface gráfica ao desenvolver aplicativos de desktop usando Tkinter.

Se você quiser exibir um número de opções em um formulário, onde os usuários podem marcar para selecionar
qualquer opção, podemos usar o widget TkinterCheckbutton. Ele permite que você selecione
várias opções ou uma única opção por vez, apenas clicando no botão correspondente
a cada opção.
Por exemplo, em um formulário, você vê a opção de preencher seu Gênero, tem opções, Masculino,
Feminino, Outros, etc., e você pode marcar qualquer uma das opções, que é uma caixa de seleção. Usamos
o<input>tagem HTML, para criar uma caixa de seleção
Pode conter texto ou imagem. Existem várias opções disponíveis para
configure o widget Checkbutton de acordo com sua necessidade.

Widget Checkbutton do Tkinter

A sintaxe do widget checkbutton é dada abaixo:
w = CheckButton(mestre, opção=valor)
Na sintaxe acima, o parâmetro master denota a janela pai. Você pode usar
muitas opções para configurar seu widget de botão de verificação e essas opções estão escritas
como um par chave-valor separado por vírgulas.

Métodos do Widget Checkbutton do Tkinter:

A seguir estão os métodos usados com os widgets checkbutton:

Método
Description
Name

invocar()
Este método no widget checkbutton é usado para invocar o método
associado ao botão de verificação.

selecionar()
Este método no widget checkbutton é chamado para ativar o
botão de verificação.

deselecionar()
Este método no widget checkbutton é chamado para desligar o
caixa de seleção

alternar()
Este método no widget checkbutton é usado para alternar entre o
checkbuttons diferentes.

flash()
Este método no widget checkbutton é usado para alternar entre ativo
e cores normais.

Exemplo de Widget Checkbutton do Tkinter

Abaixo temos um exemplo básico desse widget para entender o básico disso.
method:
fromtkinterimport*
root = Tk()
[Link]("300x300")
w = Label(root, text =‘StudyTonight’, fg=“Blue”,font =“100”)
[Link]()
Checkbutton1 = IntVar()
Checkbutton2 = IntVar()
Checkbutton3 = IntVar()
Button1 = Checkbutton(root, text =“Homepage”,
variável = Checkbutton1,
onvalue =1,
offvalue =0,
height =2,
largura =10)
Button2 = Checkbutton(root, text =“Tutorials”,
variável = Checkbutton2,
onvalue =1,
offvalue =0,
height =2,
largura =10)
Button3 = Checkbutton(root, text =“Contactus”,
variable = Checkbutton3,
onvalue =1,
offvalue =0,
height =2,
largura =10)
[Link]()
[Link]()
[Link]()
loopprincipale()
Como você pode ver no código acima, três variáveis threeIntVar() são criadas e então temos
criou três botões de verificação com textos diferentes, como Página Inicial, Tutoriais,
eContate-nos.
Então, criamos aqui botões de verificação usando algumas opções como texto, variável, valor ativo,
valor desligado, altura e largura. Você pode tentar usar mais opções.

Resumo
Então, neste tutorial, aprendemos como criar caixas de seleção em uma aplicação GUI usando
Widget checkbutton do Tkinter.
PARTE 9: Radiobutton do Python Tkinter
Widget
Neste tutorial, abordaremos o widget Tkinter Radiobutton em Python, que é
usado quando queremos adicionar um botão de opção à interface gráfica do usuário da nossa aplicação.

O widget radiobutton do Tkinter é usado para implementar opções de múltipla escolha que são
principalmente criado em formulários de entrada do usuário.

Este widget oferece múltiplas seleções ao usuário e permite que o usuário

selecionar apenas uma opção entre as fornecidas. Assim, também é conhecido como
implementando uma seleção de um entre muitos em uma aplicação Python.
Além disso, métodos diferentes também podem ser associados ao botão de rádio.
Você também pode exibir texto de várias linhas e imagens no botão de opção.
Cada botão de opção exibe um único valor para uma variável particular.
Você também pode acompanhar a seleção do usuário do
radiobutton porque está associado a uma única variável

Widget Radiobutton do Tkinter

A sintaxe do widget Radiobutton é dada abaixo:
W = Botão de opção(mestre, opções)
Na sintaxe acima, o parâmetro master denota a janela pai. Você pode usar
muitas opções para mudar a aparência do botão de rádio e essas opções estão escritas
como pares de chave-valor separados por vírgula.

Métodos do Widget Radiobutton do Tkinter:

A seguir estão os vários métodos utilizados com os widgets Radiobutton do Tkinter:

Método
Description
Name
deselecionar() Este método é usado para desmarcar ou desligar o botão de opção.
selecionar() Este método é usado para selecionar o botão de rádio

Este método é geralmente usado para chamar uma função quando o estado do rádio
invocar()
o botão é alterado.
Este método é geralmente usado para alternar o botão de rádio entre seus
flash()
cores normais e ativas muitas vezes.

Exemplo de Widget Radiobutton do Tkinter

Abaixo temos um exemplo básico para o widget de botão de opção. Vamos ver o código
trecho para o widget Radiobutton:
#primeiro importe o módulo Tkinter
fromtkinterimport*
[Link]*
# Criando a janela pai Tkinter
win = Tk()
[Link]("200x200")
vamos criar uma variável de string Tkinter
que é capaz de armazenar qualquer valor de string

v = StringVar(win, "1")
Aqui está um dicionário para criar múltiplos botões
options = {” Option A”:“1”,
“Option B”:“2”,
“Option C”:“3”,
“Option D”:“4”
}
Usaremos um loop apenas para criar múltiplos
Botões de rádio em vez de criar cada botão separadamente
para(txt, val) em opçõ[Link]():
Radiobutton(win, text=txt, variable=v, value=val).pack(side = TOP, ipady =
4)
mainloop()
O código acima irá gerar a seguinte saída:

Nota: Se você tentar o código acima por conta própria, verá que no
você pode selecionar apenas um botão por vez.

Exemplo de Widget Radiobutton do Tkinter

Abaixo temos outro exemplo deste widget onde adicionaremos estilização.
botão de opção usando classe de estilo:

fromtkinterimport*
from [Link] import *
win= Tk()
[Link]('200x200')
v = StringVar(win, "1")
Nós adicionaremos a classe Style para adicionar estilo ao botão de opção

style = Style(win)
[Link]("TRadiobutton", background ="azul claro",
foreground =“orange”, font = (“arial”,14,“bold”))
Dicionário para criar vários botões
values = {“RadioButton 1”:“1”,
“RadioButton 2”:“2”,
“RadioButton 3”:“3”
}
para(texto, valor) em [Link]():
Radiobutton(win, texto = texto, variável = v,
valor = valor).empacotar(lado = CIMA,ipady =3)
mainloop()

O código acima mudará o estilo da fonte, bem como o fundo e a cor do texto.
cores. No acimaTRadiobuttoné usado na classe de estilo, que aplica automaticamente
estilizando todos os Botões de Opção disponíveis.

Summary:
Neste tutorial, aprendemos sobre o widget Radiobutton que é usado para criar
múltiplas opções das quais uma única pode ser selecionada. Isso é usado principalmente quando nós
crie um formulário de usuário, como um formulário de registro.
PARTE 10: Python Tkinter
Widget de Entrada
Neste tutorial, cobriremos o widget de entrada do Tkinter.
Python com suas várias opções, e com a ajuda de Few
Exemplos, iremos entender o conceito em detalhes.
Se você precisar obter um pouco de texto de um usuário, como um nome ou
um endereço de e-mail ou um número de contato então use
umEntradawidget.

O widget Entry é principalmente usado para exibir um pequeno

caixa de texto onde o usuário pode digitar algum texto.
Há o número de opções disponíveis para mudar
a estilização do Widget de Entrada.
É importante notar que o widget Entry é apenas
costumava obter uma única linha de texto do usuário porque
no caso de texto multilinha, o widget de texto será
usado.
Este widget é usado principalmente para aceitar texto.
strings do usuário.

Widget de Entrada Tkinter

A sintaxe do widget de entrada é dada abaixo:
w = Entry(master, option=valor)
Na sintaxe acima, o parâmetro master denota o pai.
Você pode usar várias opções para mudar o estilo de
o widget entry e essas opções são escritas como vírgula-
separated.

Exemplo de Widget Entry do Tkinter

Abaixo temos um exemplo básico do widget Entry do Tkinter.
Vamos ver o trecho de código:
fromtkinterimport*
win = Tk()
[Link]("400x250")
Nome
email = Label(win, text =“Email”).place(x =30, y =90)
password = Label(win, text =“Password”).place(x =30, y =
130)
submitbtn = Button(win, text =“Submit”,activebackground =
vermelho, ativoForeground = azul
.place(x=30, y=170)
entrada1 = Entrada(win).localizar(x =80, y =50)

entry2 = Entry(win).place(x =80, y =90)

entry3 = Entry(win).place(x =95, y =130)
[Link]()

No exemplo de código acima, fizemos o seguinte:

1. Crie etiquetas Tkinter para nomear os campos de entrada de texto.

Para todos os 3 campos de entrada (widget de entrada), temos
criou três rótulos.
 2. Utilizamos o gerenciador de geometria theplace() para posicionar
os rótulos na janela do aplicativo.
3. Então, criamos um botão que é o enviar
botão. E usou o gerenciador de geometria place() para
posicione-o na interface gráfica do aplicativo.

4. And finally, we have the threeEntrywidgets which

criará os três campos de entrada de texto. E usou
o gerenciador de geometria place() para posicioná-lo no
interface gráfica do aplicativo.

Resumo
Neste tutorial, aprendemos como usar o widget Entry do Tkinter
criar um campo de entrada de texto ao criar um aplicativo GUI.
PARTE 11: Python Tkinter
Widget de Mensagem
Neste tutorial, aprenderemos sobre o TkinterMessage
widget em Python que é usado para mostrar uma mensagem de texto em
a aplicação GUI que você cria usando Tkinter.
O Widget TkinterMessage em Python é principalmente utilizado
mostrar alguma mensagem para o usuário que está usando o
application.
A mensagem exibida pelo TkinterMessage
Widgets de tipo não editável e podem estar em
multiline.
A mensagem exibida pelo TkinterMessage
widgetcontainssingle texto da fonte.
A funcionalidade deste widget é muito semelhante
até oWidget Label do Tkintermas há um
diferença e essa é a mensagem do widget
pode envolver automaticamente o texto.

Widget de Mensagem Tkinter

A sintaxe do widget Message do Tkinter é dada abaixo:
W = Message(master,options)
Na sintaxe acima, o parâmetro master denota o pai
[Link]ê pode usar muitosopções para mudar oaparência do
mensagem e estas opções estão escritas como separadas por vírgulas
key-value pair.
Exemplo de Widget de Mensagem Tkinter
Abaixo temos um exemplo básico para a Mensagem Tkinter
widget:
de tkinter import *
win = Tk()
[Link]("300x200")
w = Label(win, text ='StudyTonight', font =
90
[Link]()
msg = Message(win, text =“Best place to learn coding
online
[Link]()
[Link]()

No exemplo de código acima, criamos um rótulo simples

widget e um widget de mensagem com alguma mensagem de texto nele.

Summary:
Assim, com isso, cobrimos o Widget de Mensagens Tkineter
que é usado para mostrar mensagens em uma aplicação GUI Tkinter. Nós
também pode criar widget de mensagem dinamicamente para mostrar erro ou
mensagem de sucesso na aplicação Tkinter.
PARTE 12: Python Tkinter
Menu Widget
Neste tutorial, abordaremos o widget TkinterMenu.
Python que é usado para criar menus com opções para os usuários para
escolher entre.
O widget TkinterMenu é usado para criar diferentes tipos de
menusin Aplicação Python.

Os seguintes tipos de menus podem ser criados usando

o widget Menu do Tkinter: pop-up, pull-down, e
nível superior.

Top-level menus are thosemenus that are

exibido logo abaixo da barra de título da raiz ou de qualquer
outros janelas de nível superior. Por exemplo, todas as
os sites têm um menu de navegação superior logo abaixo do
Barra de URL no navegador.
Os menus são comumente usados para fornecer conveniência
acesso a opções como abrir qualquer arquivo, sair de qualquer
tarefa, e manipulando dados em uma aplicação.

Widget de Menu do Tkinter

A sintaxe do widget Menu é dada abaixo:
W = Menu(mestre, opções)
Na sintaxe acima, o parâmetro master denota o pai
[Link]ê pode usar muitosopções para mudar oaparência do
menu e essas opções estão escritas como separadas por vírgula
pares de valor.

Exemplo de Widget de Menu Tkinter

Abaixo temos um exemplo básico usando este widget:
fromtkinterimport*
root = Tk()
defhello():
imprimir("olá!")
menubar = Menu(root)
menubar.add_command(label="Olá StudyTonight!"
command=hello)
menubar.add_command(label="Sair!", command=[Link])
[Link](menu=menubar)
[Link]()

Após executar o código acima, você verá a saída acima.

Sempre que você clicar no item de menu Olá StudyTonight!
então irá imprimir ahello! no seu console. Enquanto ao clicar
o item de menu Quit!, o aplicativo será fechado.

Resumo:
Neste tutorial, aprendemos como criar um menu para o nosso
Aplicação Tkinter e como adicionar itens de menu a ela e
realizar alguma operação quando o usuário selecionar qualquer item do menu.
PARTE 13: Python Tkinter
Widget de Botão de Menu
Neste tutorial, vamos abordar o TkinterMenubutton
widget em Python que é usado para criar um dropdown
menu que pode ser clicado pelo usuário para ver o

Este widget é usado para fornecer vários tipos de

menusin no aplicativo Python.
É importante notar que cada Menubutton em um
a aplicação está associada a um widget de Menu e
que em retorno pode exibir as opções para isso
botãomenuclicando sempre que o usuário clicar nele.
O widget Menubutton do Tkinter fornece ao usuário
com uma opção para selecionar a escolha apropriada
que existe dentro da aplicação.

Widget Menubutton do Tkinter

A sintaxe do widget Menubutton do Tkinter é a seguinte:
W = BotãoMenu(mestre, opções)
In the above syntax, themasterparameter denotesthe parent
janela. Você pode usar muitosopções para mudar oaparência do
botões de menu e estas opções estão escritas como vírgula-
pares chave-valor separados.
Opções do Widget Menubutton do Tkinter:
A seguir estão as várias opções usadas com Tkinter
Widgets de botão de menu:
 Opção
Description
name
Esta opção indica a cor de fundo de
fundoativo
d o botão de menu no momento em que o mouse
paira sobre o botão do menu.

Esta opção é usada para representar a largura de

bd a borda em pixels. O valor padrão é 2
pixels.
Esta opção será definida para o gráfico
bitmap conteúdo que deve ser exibido para o
widget

bg
Esta opção é usada para representar o
cor de fundo do widget.

cursor
Esta opção indica o cursor quando o
o mouse paira sobre o botão do menu.

This option mainlyrepresents the font

activeforeground cor do widget no momento em que o
o widget está sob o foco

fg
Esta opção representa a cor do primeiro plano
do widget.
Com a ajuda desta opção, você pode especificar
a direção para que o menu possa ser exibido para
direção a direção especificada do botão. Você
pode usar ESQUERDA, DIREITA ou ACIMA para colocar
o widget de acordo.
disabledforegrou Esta opção indica a cor do texto do
nd widget quando o widget está desativado

Esta opção indica a altura do

botão do menu. Esta altura indica
altura então o número de linhas de texto no caso de texto
linhas e indica o número de pixels em
o caso das imagens.
 Opção
Description
nome

imagem
Esta opção indica a imagem exibida em
o botão de menu.

higlightcolor
Esta opção indica a cor de destaque quando
há um foco no botão
Esta opção é utilizada para indicar o caminho
quais são as múltiplas linhas de texto
justificar
justificada à esquerda, é definido como
ESQUERDA e está definido como DIREITA para a direita
justificação, e CENTRO para o centro
justificação.

padx
Esta opção indica o preenchimento adicional
do widget na direção horizontal.

pady
Esta opção indica o acolchoamento adicional
do widget na direção vertical.

menu
Esta opção é usada para indicar o menu
associado ao botão de menu
Esta opção especifica a largura do widget.
largura
Para botões de texto, existe como um número de
letras ou para botões de imagem indica o
pixels
Neste caso, se o valor desta opção estiver definido como um
número
Comprimento do embrulho positivo, as linhas de texto serão
enrolado para caber dentro deste comprimento.
O estado normal do menubutton é
estado ativado. Pode ser configurado para desativar para fazer o
botão de menu não responde.

texto
Esta opção é usada para indicar o texto no(a)
widget.
 Option
Description
name
Uma variável de controle da classe StringVar pode ser

textvariable
associado a este botão de menu. Se você
definirá que controla a variável, então ele irá
mude o texto exibido.
Esta opção é usada principalmente para representar o
índice do caractere no texto do
sublinhar widget que deve ser sublinhado.
A indexação geralmente começa com zero em
o texto.

alívio
Esta opção é usada para especificar a borda
tipo. Seu valor padrão é EMBUTIDO

Exemplo de Widget Menubutton do Tkinter

Agora vamos ver um trecho de código para o Menubutton do Tkinter
widget:
fromtkinterimport*
importar tkinter
win = Tk()
mbtn = Menubutton(win, text=“Courses”, relief=RAISED)
[Link]()
[Link] = Menu(mbtn, tearoff =0)
mbtn[“menu”] = [Link]
pythonVar = IntVar()
javaVar = IntVar()
phpVar = IntVar()
[Link].add_checkbutton(label="Python")
variable=pythonVar)
[Link].add_checkbutton(label=“Java”, variable=javaVar)
[Link].add_checkbutton(label="PHP", variable=phpVar)
[Link]()
[Link]()
A saída do código acima é a seguinte:

Você pode tentar o exemplo acima por conta própria. Sempre que você
executará o código acima, você verá que há um
Botão de menu Tkinter chamado Cursos em uma janela sempre que
você clicará nele e então aparecerá um menu suspenso
menu assim:

Summary:
Neste tutorial, cobrimos o widget Menubutton do Tkinter.
que é usado para criar menus suspensos em um Tkinter
aplicativo.
PARTE 14: Python Tkinter
Widget de Quadro
O widget TkinterFrame é usado para agrupar e organizar o
widgets de uma forma melhor e amigável. O widget TheFrame é
basicamente um contêiner (um contêiner invisível) cuja tarefa é
segure outros widgets e organize-os com respeito a cada um
outro. O widget de quadro Tkinter forma um retângulo
região na tela.
Basicamente, atua como uma classe base que então implementa
widgets complexos. É como oTag div HTML, que é apenas para
defina divisões em uma página da web nas quais temos outros HTML
elementos.

Widget Frame do Tkinter

A sintaxe do widget de quadro é dada abaixo:
W = Quadro(mestre, opções)
Na sintaxe acima, o parâmetro mestre denota o pai
Janela. Você pode usar muitosopções para mudar oolhar do
frame e estas opções estão escritas como separadas por vírgula
pares chave-valor.

Exemplo de Widget Frame do Tkinter

Abaixo temos um exemplo básico onde organizaremos
diferentes widgets de botão em um widget Frame. Vamos ver o código
trecho dado abaixo:
fromtkinterimport*
root = Tk()
[Link]("300x150")
w = Label(root, text =‘StudyTonight’, font =“80”)
[Link]()
quadro = Quadro(raiz)
[Link]()
bottomframe = Frame(root)
[Link](lado = INFERIOR)
button1 = Button(frame, text =“Block1”, fg =“red”)
[Link](side = ESQUERDA)
button2 = Button(frame, text =“Block2”, fg =“brown”)
[Link](side = ESQUERDA)
button3 = Button(frame, text =“Block3”, fg =“blue”)
[Link](side = ESQUERDA)
button4 = Button(bottomframe, text =“Block4”, fg =“orange”)
[Link](side = BOTTOM)
button5 = Button(bottomframe, text =“Block5”, fg =“orange”)
[Link](side = BOTTOM)
button6 = Button(bottomframe, text =“Block6”, fg =“orange”)
[Link](side = BOTTOM)
[Link]()

No exemplo de código acima, criamos dois quadros

widgets e então adicionamos 3 botões em cada um desses quadros
e usei o gerenciador de geometria Tkinter para dispor os botões
dentro da janela do aplicativo,
Resumo
Neste tutorial, aprendemos sobre o widget Frame do Tkinter e
como podemos usá-lo para gerenciar outros widgets Tkinter e
posicione-os corretamente.
PARTE 15: Python Tkinter
Widget de Lona
O widget Canvas do Tkinter é principalmente usado como um geral-
widget de propósito que é usado para desenhar qualquer coisa no
janela de aplicação no Tkinter.
Este widget é usado principalmente para desenhar gráficos
e gráficos, desenhos, tabelas e exibição de imagens.
Você pode desenhar vários layouts complexos com a ajuda
de tela, por exemplo, polígono, retângulo, oval
texto, bitmap de arco, gráficos, etc.
O widget Canvas também é usado para criar gráficos
editores.
Existem várias opções disponíveis para configurar
e controlar o Widget Canvas.

Widget Canvas do Tkinter

A sintaxe do widget canvas é dada abaixo:
w = Canvas(master, opcao=valor)
Na sintaxe acima, o parâmetro mestre denota o pai.
janela. Você pode usar muitas opções para mudar o layout do
canvas e essas opções estão escritas como separados por vírgula
key-values.

Widget Canvas Básico do Tkinter

Exemplo
Vamos criar uma tela simples com a ajuda da tela
widget:
fromtkinterimport*
janela chamada topo
top = Tk()
# set height and width of window
[Link]("300x300")
#criando uma tela simples com o widget de tela
cv = Canvas(top, bg =“yellow”, height =“300”)
[Link]()
[Link]()

O código acima criará uma tela simples com fundo

amarelo e você pode desenhar qualquer coisa acima dele.

Tkinter Widget Canvas - Gráfico de Pizza

usando Arcos
Vamos criar uma tela e depois anarquizá-la com a ajuda de
trecho de código dado abaixo:
importar tkinter
# iniciar tk
root = [Link]()
# creating canvas
mCanvas = [Link](root, bg="branco", altura=300,
largura=300)
desenhando dois arcos
coord =10,10,300,300
arc1 = mCanvas.create_arc(coord, start=0, extent=150,
preencher="rosa")
arc2 = mCanvas.create_arc(coord, start=150, extent=215,
preencher="azul")
adicionando canvas à janela e exibindo-o
[Link]()
[Link]()

O código acima abrirá uma janela, adicionará uma tela e

em seguida desenha dois arcos nele. Os dois arcos desenhados
de rosa e azul juntos formam um círculo como mostrado em
a saída acima.

Summary:
Neste tutorial, aprendemos sobre o widget canvas do Tkinter
que pode ser usado para desenhar qualquer coisa na tela, talvez um
gráfico, e imagem, ou alguma forma dinâmica.
PARTE 16: Listbox do Python Tkinter
Widget
Neste tutorial, cobriremos o widget TkinterListbox em Python, que é usado para
exibir diferentes tipos de itens para o usuário na forma de uma lista dentro de uma caixa e o usuário
pode selecionar os itens.

Os itens contêm o mesmo tipo de fonte e a mesma cor de fonte.

É importante notar aqui que apenas itens de texto podem ser colocados dentro
um widget Listbox.
A partir desta lista de itens, o usuário pode selecionar um ou mais itens de acordo com
os requisitos.

Widget Listbox do Tkinter

A sintaxe do widget Listbox do Tkinter é dada abaixo:
W = ListaCaixa(mestre, opcoes)
Na sintaxe acima, o parâmetro master denota a janela pai. Você pode usar
muitas opções para mudar a aparência do ListBox e essas opções estão escritas como
pares chave-valor separados por vírgula.

Opções do Widget Listbox do Tkinter:

Seguem várias opções usadas com widgets Listbox:

Nome da Opção Description

bg Esta opção indica a cor de fundo do widget.

bd
Esta opção é usada para representar o tamanho da borda.
o valor padrão é 2 pixels.

cursor
Com a ajuda desta opção, o ponteiro do mouse ficará assim
o tipo de cursor como ponto, seta, etc.
fonte Esta opção indica o tipo de fonte dos itens da Listbox.
fg Esta opção indica a cor do texto.
Esta opção é usada para representar a contagem das linhas mostradas
height
na Listbox. O valor padrão desta opção é 10.

highlightcolor
Esta opção é usada para indicar a cor da Listbox
itens quando o widget está sob foco.
highlightthickness Esta opção é usada para indicar a espessura do destaque.

alívio
Esta opção indica o tipo de borda. O valor padrão
isSUNKEN.
 Nome da Opção Description

selecionar fundo
Esta opção é usada para indicar a cor de fundo que é
usado para exibir o texto selecionado.

Esta opção é usada para determinar o número de itens que podem

modo de seleção ser selecionado da lista. Ele pode definir
toBROWSE,SINGLE,MULTIPLE,EXTENDED.

largura
Esta opção é usada para representar a largura do widget em
personagens.
Esta opção é usada para permitir que o usuário role a Listbox
xscrollcommand
horizontalmente.
Esta opção é usada para permitir que o usuário role a Listbox
comando de rolagem vertical
verticalmente.

Exemplo de Widget ListBox do Tkinter

Abaixo temos um exemplo básico usando este widget:
de tkinter importar *
top = Tk()
[Link]("200x250")
lbl = Label(top, text=“List of Programming Languages”)
listbox = Listbox(top)
[Link](1, "Python")
[Link](2, "Java")
[Link](3, "C")
[Link](4, "C++")
[Link]()
[Link]()
[Link]()

No exemplo de código acima, criamos um simples widget Listbox com alguns itens
junto com a especificação do item superior da lista que é o cabeçalho no widget Listbox.
Summary:
Neste tutorial, aprendemos sobre o Widget Listbox do Tkinter, sua sintaxe básica, o
métodos comumente usados para o Widget ListBox, e um exemplo de código.
PARTE 17: Python Tkinter
Scrollbar Widget
Neste tutorial, abordaremos o widget TkinterScrollbar.
Python, usando o qual podemos adicionar uma barra de rolagem ao usuário
interface da nossa aplicação Tkinter.
Para rolar para cima, para baixo, para a direita ou para a esquerda o conteúdo em Python

aplicativo de desktop, o widget TkinterScrollbar é usado.

Deslocar o conteúdo de outros widgets

como Listbox, canvas, etc, usamos este widget.
As barras de rolagem horizontal e vertical podem ser
criado no widget de entrada do Trinket.
Abaixo temos uma imagem mostrando o widget de barra de rolagem utilizado com um
Listbox:

Nome do
Description
Opção
Esta opção representa o fundo
fundoativo cor do widget quando está embaixo
foco.

bg
Esta opção representa o fundo
cor do widget

bd
Esta opção representa o tamanho da borda de
o widget. O valor padrão é 2 pixels.
Com a ajuda desta opção, o mouse
o ponteiro será alterado para um específico
cursor
tipo de cursor e pode ser uma seta, ponto,
etc.
Esta opção será definida para o procedimento
comando associado que é chamado sempre que o
a barra de rolagem foi movida.
 Nome do
Descrição
Opção
Esta opção representa principalmente a fronteira
elementborderwidt largura ao redor das pontas das setas e do controle deslizante.
h
O valor padrão desta opção é -1.

highlightthickness
Esta opção representa a espessura de
os destaques do foco
Esta opção indica o destaque
destacar fundo
nd cor quando o widget não está sob o
foco

highlightcolor
Thisoption indicates the highlight
cor quando o widget está em foco
Esta opção é usada para controlar o
behavior of the scroll jump. If this option
pular está definido como 1, então o callback é chamado na
tempo quando o usuário solta o mouse
botão.
Esta opção pode ser definida como horizontal
orientar ou vertical, dependendo da orientação
da barra de rolagem.

Esta opção representa a largura do

largura
barra de rolagem.

cor do tubo
Esta opção é usada para definir a cor para o
canal
Por padrão, você pode usar a tecla Tab para alternar o foco através de
focar este widget. Se você não quiser isso
comportamento você pode definir esta opção como 0.

Esta opção é usada principalmente para contar o

duração até a qual o botão deve ser
atrasoderepetição pressionado antes que o controle deslizante comece a mover-se

essa direção repetidamente. seu valor padrão

is300 ms
 Nome do(a)
Description
Opção
intervalode RepetiçãoO valor padrão desta opção é 100

Widget de Barra de Rolagem Tkinter

A sintaxe do widget Scrollbar é dada abaixo:
W = BarraDeRolagem(mestre, opções)
Na sintaxe acima, o parâmetro master denota o pai
Você pode usar muitas opções para configurar seu
widget de barra de rolagem e essas opções estão escritas como vírgula-
separated key-value pairs.
Opções do Widget Scrollbar do Tkinter:
A seguir estão as várias opções usadas com a barra de rolagem Tkinter
widgets:
Métodos do Widget Scrollbar do Tkinter:
Alguns métodos usados com widgets Scrollbar do Tkinter são:

get():

Este método retorna os dois números

suponha a e b que representam a posição atual de
 a barra de rolagem.

set(first, last):

Este método é usado para conectar a barra de rolagem a qualquer outro

widget. Isso é o comando de rolagem isyscrollcommandorxscrollcommand do outro
widget para este método.

Exemplo de Widget Scrollbar do Tkinter

Abaixo temos um exemplo básico de um widget de barra de rolagem.

fromtkinterimport*
win = Tk()
sbb = Scrollbar(win)
[Link](side = DIREITA, fill = Y)
mylist = Listbox(win, yscrollcommand = [Link])
forlineinrange(45):
[Link](END, "Valor " + str(line))
[Link](side = ESQUERDA)
[Link](command = [Link])
loopprincipal()

Como você pode ver no código acima, criamos um Listbox

widget com números como itens de lista nele. Então nós criamos um
Widget de barra de rolagem e usei a opção theyscrollcommand
Widget Listbox para definir o widget Scrollbar com ele. Nós temos
usei a função set do widget Scrollbar aqui.

Summary:
Então cobrimos o widget Scrollbar do Tkinter. É muito
útil onde temos uma aplicação Tkinter com listas longas ou
algum widget que é longo demais para caber na aplicação
janela. Então podemos usar o widget Scrollbar para isso
aplicações.
PARTE 18: Python Tkinter
Widget de Escala
Neste tutorial, abordaremos o widget TkinterScale
Python que é usado para adicionar um objeto deslizante gráfico que
o usuário pode deslizar e escolher um número, como um valor numérico é
anexado a esta barra deslizante e conforme você move o deslizante
cima/baixo ou direita/esquerda, o valor numérico associado a ele aumenta
ou diminui e você pode ajustar o controle deslizante para o valor que deseja
selecionar.

A barra deslizante fornecida pelo widget de escala é

útil na seleção dos valores apenas deslizando a partir de
esquerda para direita ou de cima para baixo dependendo do
orientação da barra deslizante em nossa aplicação.
O widget de escala é usado como uma alternativa ao
O widget de entrada tem como propósito o
receber entrada numérica do usuário dentro de um intervalo dado de
valores.
Você também pode controlar o mínimo e o máximo.
valores juntamente com a resolução da escala.

Widget de Escala Tkinter

A sintaxe do widget TkinterScale é dada abaixo:
W = Escala(mestre, opções)
Na sintaxe acima, o parâmetro master denota o pai
[Link]ê pode usar muitosopções para mudar o layout do
escala widget e estas opções estão escritas como vírgula-
separated key-values.
Métodos do Widget Scale do Tkinter
A seguir estão alguns métodos usados com widgets Scale:
 get():

Este método é usado para obter o valor atual da escala.

set(value):

Este método é utilizado para definir o valor da escala.

Widget de Escala Tkinter - Horizontal

Exemplo
Abaixo temos um exemplo básico onde iremos criar um
barra deslizante horizontal.

fromtkinterimport*
win = Tk()
[Link]("200x100")
v = DoubleVar()
scale = Scale( win, variable=v, from_=1, to=50,
orient=HORIZONTAL
[Link](anchor=CENTER)
btn = Button(win, text=“Value”)
[Link](anchor=CENTER)
label = Label(win)
[Link]()
[Link]()

Neste tutorial, criamos um widget de Escala horizontal. Se

você vê no código, especificamos
theorientasHORIZONTALfor this. We have also specified
o intervalo de valores numéricos para a escala do slider.
Widget Scale Tkinter - Vertical
Exemplo
Abaixo temos outro exemplo onde vamos criar
avertical slider:
de tkinter importar*
win = Tk()
[Link]("400x300")
v = DoubleVar()
defshow():
sel =“TheVertical ScaleValue is = “+str([Link]())
adicionando valor de escala ao rótulo para mostrar

scale_val.config(text=sel, font=(“Courier”,16))
scl = Scale(win, variable=v, from_=60, to=1,
orient=VERTICAL)
mainlabel = Label(win, text=“TheVertical Slider”)
btn = Button(win, text =“Show SliderValue”,
command = show,
bg =“darkblue”,
fg =“white”)
criando outro rótulo para mostrar o valor da escala
scale_val = Label(win)
[Link](anchor = CENTRO)
[Link]()
[Link]()
scale_val.pack()
[Link]()
Você pode mover o controle deslizante de baixo para cima, pois é vertical.
slider. No exemplo dado, também adicionamos um botão para
nossa aplicação, e definimos uma funçãomostrar() que é
anexado ao widget de botão como um manipulador de eventos. Então, após o
o usuário usa o controle deslizante para selecionar qualquer valor e, em seguida, clica em
botão, o valor será exibido em um widget Label abaixo do
botão.

Summary:
Neste tutorial, aprendemos sobre o widget Scale do Tkinter
qual é um bom componente de IU para receber entrada numérica
valor dentro de um intervalo específico do usuário final.
PARTE 19: Python Tkinter
Widget de Nível Superior
Neste tutorial, cobriremos o widget TkinterToplevel
Python que é usado para criar e exibir janelas de nível superior
exceto pela janela do aplicativo.

Com a ajuda do widget TkinterToplevel, você

pode fornecer informações adicionais ao usuário em um
janela separada acima da janela pai.
Esta janela de nível superior foi criada usando o Toplevel
os widgets são diretamente organizados e gerenciados pelo
window manager.
Não é necessário que as janelas de nível superior tenham
pais no topo.
Você pode criar várias janelas de nível superior uma sobre
o outro.
Janelas de nível superior criadas usando widgets de nível superior
título de conteúdo barras, bordas e alguma janela
decorações também.
Com a ajuda deste widget, você pode fornecer
ups, algumas informações extras, ou alguns widgets
a nova janela se você quiser.

Widget Toplevel do Python Tkinter

A sintaxe do widget Toplevel do Tkinter é dada abaixo:
W = Toplevel(mestre, opções)
Na sintaxe acima, o parâmetro master denota o pai.
Você pode usar muitas opções para configurar seu
O widget de nível superior e essas opções estão escritas como vírgula-
separated key-value pairs.
Exemplo de Widget Toplevel do Tkinter
Abaixo temos um exemplo básico onde criaremos um simples
janela de nível superior.

fromtkinterimport*
win = Tk()
[Link]("200x200")
defabrir():
top = Toplevel(win)
[Link]()
btn = Button(win, text=“open”, command=open)
[Link](x=75, y=50)
[Link]()

No código acima, criamos um widget Toplevel que é

created and started when the Button is clicked.

Summary:
Agora sabemos o que é um widget Toplevel do Tkinter e como
para criá-lo. O widget Toplevel do Tkinter é bom para mostrar alguns
seção do seu aplicativo em uma janela diferente que é
exibido no topo da janela principal do aplicativo.
PARTE 20: Python Tkinter
Widget Spinbox
Neste tutorial, cobriremos o widget TkinterSpinbox
Python com sua sintaxe e alguns exemplos. O widget Spinbox
em Tkinter no Python é usado para selecionar um valor do
intervalo de valores especificado.
É diferente doWidget Scale do Tkinter(Widget de escala
ser mais estiloso) em termos de estilo, mas mais ou menos, cumpre
o mesmo propósito.
Por exemplo, quando você quer ter um menu suspenso de números
valores como ano de nascimento (de 1950 a 2020) ou um menu suspenso
para o usuário escolher sua idade, podemos usar o Spinbox do Tkinter
widget.

Este widget é uma alternativa ao widget de Entrada,

quando queremos que o usuário insira um valor numérico dentro de um
faixa específica.
Este widget é usado apenas no caso em que os usuários
precisa escolher entre uma gama de opções fornecidas.

Widget Spinbox do Tkinter

A sintaxe do widget Spinbox é dada abaixo:
w = Spinbox(mestre, opção=valor)
Na sintaxe acima, o parâmetro master denota o pai
Você pode usar muitas opções para configurar sua caixa de rodagem
widget e essas opções estão escritas como separados por vírgula
key-value pairs.

Exemplo de Widget Spinbox Tkinter

importar tkinter
# iniciar tk
root = [Link]()
# creating canvas
mCanvas = [Link](root, bg="branco", altura=300,
largura=300)
desenhando dois arcos
coord =10,10,300,300
arc1 = mCanvas.create_arc(coord, start=0, extent=150,
preencher="rosa")
arc2 = mCanvas.create_arc(coord, start=150, extent=215,
preencher="azul")
adicionando canvas à janela e exibindo-o
[Link]()
[Link]()

O código acima abrirá uma janela, adicionará uma tela e

de rosa e azul juntos formam um círculo como mostrado em

a saída acima.

Summary:
PARTE 21: Python Tkinter
Widget Frame de Rótulo
Neste tutorial, vamos abordar o TkinterLabelFrame
widget em Python com sua sintaxe e alguns exemplos.
O widget LabelFrame é principalmente usado para desenhar bordas ao redor de
os widgets filhos.

Este widget é um widget de contêiner bordado e

é usado para agrupar os widgets relacionados em um Tkinter
aplicativo para proporcionar uma melhor experiência ao usuário
usuário.
Por exemplo, podemos agrupar o radiobutton
widgets usados em uma aplicação usando o labelframe
miniaplicativo.
Também é possível adicionar um título para o LabelFrame
widget(nós veremos isso no exemplo de código).
O widget LabelFrame é simplesmente uma variante de
o widget Frame e tem todas as características de um
moldura.
Nota: Se você usouHTML para desenvolvimento web, então o
labelframe é apenas como a tag fieldset do HTML.

Widget LabelFrame do Tkinter

A sintaxe do widget LabelFrame é dada abaixo. Vamos
ver:
w = LabelFrame(mestre, opção=valor)
Na sintaxe acima, o parâmetro mestre denota o pai
[Link]ê pode usar muitosopções para configurar o labelframe
e essas opções estão escritas como pares chave-valor separados por vírgula
pares.
Exemplo de Widget LabelFrame do Tkinter
Abaixo temos um exemplo básico do widget LabelFrame. Deixe
veja o trecho de código dado abaixo:
fromtkinterimport*
win = Tk()
[Link]("300x200")
labelframe1 = LabelFrame(win, text=“Happy Thoughts!!!”)
[Link](fill="ambos", expand="sim")
toplabel = Label(labelframe1, text=“You can put your happy
pensamentos aqui
[Link]()
labelframe2 = LabelFrame(win, text =“ChangesYou want!!”)
[Link](fill="both", expand ="yes")
bottomlabel = Label(labelframe2, text =“You can put here the
mudanças que você quer, se houver!)

[Link]()
[Link]()
Como você pode ver na saída acima, criamos dois
widgets labelframe, nos quais adicionamos texto para o
widgets de labelframe, e dentro do widget labelframe temos
widget onelabel. Podemos ter quantos widgets quisermos dentro do
widget labelframe, como queremos.

Summary:
Assim, com isso, completamos o widget labelframe do Tkinter
que é exatamente como a tag fieldset do HTML, se você conhece HTML. O
o widget labelframe é usado para criar uma borda ao redor de outros
widgets para agrupar outros widgets presentes em sua aplicação.
PARTE 22: Python Tkinter
Widget PanedWindow
Neste tutorial, cobriremos o widget TkinterPanedWindow, que é principalmente
acontainer widget containing one or more than one child widgetswhich are also
conhecido como Panes.

Este widget organiza widgets filhos de forma vertical ou horizontal

maneira.
É também conhecido como oGeometry Manager widget.
Este widget é usado para implementar diferentes layouts em um desktop Python
aplicativo criado usando o módulo Tkinter.
Os widgets filhos dentro do widget PanedWindow podem ser redimensionados pelo
movendo linhas de separação usando o mouse.
Você pode implementar várias janelas usando o widget PanedWindow.
Aqui está uma janela de aplicativo Tkinter simples com três widgets empilhados verticalmente
dentro de um widget PanedWindow.

Widget PanedWindow do Tkinter

A sintaxe do widget PanedWindow é dada abaixo:
W = JanelaDividida(mestre, opções)
Na sintaxe acima, o parâmetro master denota a janela pai. Você pode usar
muitas opções para mudar a aparência do PanedWindow e essas opções são
escrito como separado por vírgulas.

Métodos do Widget PanedWindow do Tkinter:

A seguir estão alguns métodos usados com o widget PanedWindow:

Nome do Método Description

Este método é principalmente utilizado para configurar qualquer widget com algum
configurar(opções)
opções especificadas.
 Method Name Description

obter(início, fim) Este método é usado para obter o texto no intervalo especificado.

adicionar(filho, opções) This method is used to add a window to a parent window.

Exemplo de Widget PanedWindow do Tkinter

Abaixo temos um exemplo básico para a compreensão do widget PanedWindow.
Vamos ver o trecho de código abaixo:
fromtkinterimport*
# event handler for button
defadicao():
x = int([Link]())
y = int([Link]())
leftdata = str(x+y)
[Link](1, leftdata)
primeira janela em painel
w1 = JanelaPainel()
[Link](fill=BOTH, expand=1)
leftinput = Entry(w1, bd=5)
[Link](leftinput)
# segunda janela dividida
w2 = PanedWindow(w1, orient=VERTICAL)
[Link](w2)
e1 = Entrada(w2)
e2 = Entry(w2)
[Link](e1)
[Link](e2)
bottomBtn = Button(w2, text=“Addition”, command=addition)
[Link](bottomBtn)
loopprincipal()

Como você pode ver acima, na saída, temos uma janela de aplicativo, na qual nós
tenho 3 widgets Entry do tkinter e 1 widget botão do tkinter, empilhados usando 2
Widgets PanedWindow empilhados verticalmente um ao lado do outro.
Se você fornecer dois números nos widgets de entrada do lado direito e, em seguida, clicar no
Botão de adição, o resultado da adição dos números à direita será mostrado em
widget de entrada no lado esquerdo.

Widget PanedWindow do Tkinter - Vários Painéis

Exemplo
Vamos ver outro trecho de código deste widget abaixo:
fromtkinterimport*
do tkinter importar tk
win = Tk()
pw = JanelaDividida(orient = 'vertical')
#criando widget de Botão
top = [Link](pw, text =“Just Click Me!!!\nI am a Button”)
[Link](side=TOP)
#Adicionando widget de botão à janela dividida
[Link](top)
#Criando Widget Checkbutton
bot = Checkbutton(pw, text=“I am Checkbutton Choose Me!”)
[Link](side=TOP)
[Link](bot)
label = Label(pw, text=“I am a Label”)
[Link](side=TOP)
[Link](rótulo)
string = StringVar()
entry = Entry(pw, textvariable=string, font=(‘arial’,15,‘bold’))
[Link]()
Isto é usado para forçar o foco em um widget específico
isso significa que o widget já está selecionado para algumas operações

entry.focus_force()
[Link](entrada)
[Link](fill = BOTH, expand = True)
Para mostrar a faixa

[Link](sashrelief = RAISED)
loopprincipal()
No exemplo de código acima, criamos múltiplos widgets dentro de uma panedwindow.
widget. Também usamos a variável StringVar() e usamos a função focus_force()
ter o widget de entrada em foco quando o aplicativo é carregado.

Summary:
Neste tutorial, aprendemos sobre o widget PanedWindow, que é um ótimo widget se você
quero criar uma disposição de widgets em formato de grade com várias colunas em seu aplicativo.
PARTE 23: Texto Python Tkinter
Widget
Neste tutorial, cobriremos o widget TkinterText em Python. Se você quiser
um editor de texto em sua aplicação de desktop, então você pode usar o TkinterText
widget.
O widget de texto é usado para fornecer uma caixa de texto de várias linhas (caixa de entrada)

porque no Tkinter é fornecido uma caixa de texto de uma linha usandoWidget de entrada.
Você pode usar vários estilos e atributos com o widget de Texto.
Você também pode usar marcas e guias no widget de Texto para localizar o
seções específicas do texto.
Arquivos de mídia como imagens e links também podem ser inseridos no Texto
Widget.
Existem várias aplicações onde você precisa de texto em múltiplas linhas
gostar de enviar mensagens ou levar entradaslongas dos usuários, ou mostrar
texto longo editável no conteúdo do aplicativo, etc. casos de uso são
cumprido por este widget.
Assim, para mostrar informações textuais, usaremos o Texto
widget.

Widget Text do Tkinter

The syntax of the Text widget is given below:
W = Texto(mestre, opções)
Na sintaxe acima, o parâmetro master denota a janela pai. Você pode usar
muitas opções para configurar o editor de texto e essas opções estão escritas como vírgula-
separated key-value pairs.
Métodos do Widget de Texto do Tkinter:
Alguns métodos usados com o widget de texto são apresentados abaixo:

Método Description

índice(índice) Esse método é usado para obter o índice especificado.

Este método retorna verdadeiro ou falso com base no fato de que se o

ver(índice)
a string está visível ou não no índice especificado.

inserir(índice,string)
Este método é usado para inserir uma string na especificada
índice.

obter(infindex, supindex)
Este método retorna os caracteres no especificado
faixa
 Método Description

excluir(início, fim)
Este método exclui os caracteres no especificado
faixa

Métodos para Manipulação de Tags

Principalmente, as tags são usadas para configurar diferentes áreas do widget de texto separadamente.
Tag é basicamente o nome dado a áreas separadas do texto. Alguns Métodos para
As etiquetas de manuseio estão listadas abaixo:

configuração_tag()

Para configurar as propriedades da tag, este método será utilizado.

tag_adicionar(nomeTag, indiceInicio, indiceFim)

Este método é utilizado principalmente para marcar a string que está presente em
índice especificado.

tag_excluir(nome_tag)
Este método é usado principalmente para deletar a tag especificada.

remover_tag(nome_da_tag, índice_inicial, índice_final)

Para remover a tag do intervalo especificado, este método é usado.

Métodos para Manipulação de Marcas

Em um determinado widget de texto, a fim de marcar posições específicas entre o
personagens usados por Markis. Alguns métodos para o mesmo são dados abaixo:

índice(marca)

This method is mainly used to get the index of the mark specified.
marcar_nomes()

Este método é usado para obter todos os nomes da marca no intervalo no texto
widget.
marcar_gravidade(marca, gravidade)

Para obter a gravidade da marca dada, este método será utilizado.

marcar_conjunto(marca, índice)

Este método é usado para informar a nova posição da marca dada.

marcar_desmarcado(marca)

Para remover a marca dada do texto, este método será utilizado.

Exemplo de Widget de Texto Tkinter

Vamos discutir um exemplo básico para o widget de texto. O trecho de código para o
um exemplo do widget de texto é dado abaixo:
importar tkinter como tk
fromtkinterimport*
win = Tk()
para especificar o tamanho da janela.

[Link]("250x170")
Para criar um widget de texto e especificar o tamanho.

T = Texto(janela, altura=6, largura=53)

Para criar etiqueta
l = Label(win, text =“Quote for the Day”)
[Link](font =(“Courier”,14))
Quote =“““Success usually comes to those who are too busy to be looking for
ele"""
Crie um botão para o próximo texto.
b1 = Button(win, text =“Next”, )
Crie um botão de Sair.
b2 = Botão(win, texto = "Sair",
comando = [Link])
[Link]()
[Link]()
[Link]()
[Link]()
# Insert the Quote
[Link]([Link], Citação)
[Link]()
A saída para o trecho de código mencionado acima é a seguinte:

Se você quiser destruir esta janela, basta clicar no botão Sair.

Summary:
Neste tutorial, aprendemos sobre o widget Text do Tkinter, que é usado quando queremos adicionar
uma área de texto em nossa aplicação para receber grandes entradas de usuário.
PARTE 24: Python Tkinter
Caixa de Mensagem
Neste tutorial, abordaremos como criar e usar o Tkinter
MessageBox enquanto desenvolve aplicações de desktop.
Para exibir caixas de mensagem em um aplicativo de desktop,
usamos o módulo MessageBox no Tkinter.

Existem várias funções presentes neste módulo

o que ajuda a fornecer um tipo apropriado de
mensagem de acordo com a exigência.
Com a ajuda deste módulo, podemos criar um pop-up
caixas de mensagem para receber entrada do usuário.

As funções do módulo MessageBox são as

segue: mostrarErro(), perguntarRepetirCancelar(), mostrarAviso(), etc., todos
dos quais são usados para criar uma caixa de mensagem.

Caixa de Mensagem Tkinter

Para usar o módulo messagebox, primeiro precisamos importá-lo em
nosso script em python:

de tkinter import messagebox

Então, a seguir está a sintaxe básica para usar a caixa de mensagem:

messagebox.nome_da_função(título, mensagem [, opções])

Na sintaxe acima, usamos o seguinte:

function_name
Isto é usado para indicar o nome do apropriado
Função MessageBox.

title
 Isto é usado para indicar o texto a ser exibido no título
barra da caixa de mensagem apropriada.

message
Isto é utilizado para indicar o texto a ser exibido como um
mensagem na caixa de mensagem.

opções
É utilizado para indicar várias opções a fim de configurar
a MessageBox. Existem dois valores para isso e estes
são padrão e pai.

default:It is used to specify a default button

como ABORTAR, TENTAR NOVAMENTE, IGNORAR.

parent:It is used to specify a window on the top

do qual exibiremos a MessageBox.
As funções presentes no módulo MessageBox usam o
mesma sintaxe, mas as funcionalidades de cada função são
diferente.
Vamos ver algumas funções do módulo MessageBox do Tkinter.

Tkinter MessageBox -showwarning()

Este método é usado para exibir qualquer aviso ao usuário em um
Aplicação Python.
Aqui está um código para o mesmo:
fromtkinterimport*
fromtkinterimportmessagebox
win = Tk()
[Link]("200x200")
[Link](“warning”,“This is a Warning”)
[Link]()
Tkinter MessageBox -askquestion()
Este método em MessageBox é principalmente usado para fazer algumas
pergunta ao usuário que pode ser respondida de forma ou
sim ou não.
O código para este método é o seguinte:
fromtkinterimport*
fromtkinterimportmessagebox
win = Tk()
[Link]("100x100")
[Link](“Confirm”,“Are you sure about it?”)
[Link]()

Tkinter MessageBox -askretrycancel()

Se você deseja perguntar a um usuário se ele quer realizar alguma tarefa específica ou não
então este método será utilizado.
Vamos ver o código para o mesmo:
da tkinter import *
fromtkinterimportmessagebox
win= Tk()
[Link]("100x100")
[Link](“Application”,” wanna try
de novo?
[Link]()

Tkinter MessageBox -showerror()

Para exibir uma mensagem de erro, este método será utilizado.

Vamos ver o trecho de código abaixo:

fromtkinterimport*
fromtkinterimportcaixade mensagem

top = Tk()
[Link]("100x100")
[Link](“errorWindow”,“oops!!!Error”)
[Link]()

Resumo:
Neste tutorial, aprendemos sobre os diferentes tipos de mensagem
caixas que podemos criar para mostrar informações ao usuário ou para coletar
entrada dos usuários, como confirmar qualquer ação, etc. A mensagem
as caixas são como pop-ups nos quais podemos mostrar erros, avisos,
etc. para o usuário.
PARTE 25: Calculadora
Aplicativo utilizando Tkinter
(Projeto Python)
Neste tutorial, abordaremos como criar um simples
aplicativo de calculadora usando PythonTkinter.

Como em nossos tutoriais anteriores, cobrimos como

botões tkinter, rótulos tkinter, entrada tkinter, tkinter
framesandtkinter checkbuttons, e muitos mais. Agora com
a ajuda de todos os widgets discutidos nas seções anteriores, nós
vamos criar um aplicativo de calculadora usando Tkinter.
Aqui está como nossa calculadora ficará, que é feita usando
o campo de entrada, botões e para fins de cálculo nós vamos
use lógica em nosso código definido em funções, como se você quiser
adicione dois números e, em seguida, deve haver uma lógica para
propósito de adição, da mesma forma para subtração, multiplicação
etc, criamos funções cuja tarefa é realizar essas
operações.
Temos um campo de entrada onde a entrada do usuário será exibida
e o resultado final do cálculo será exibido.
And the buttons are like 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, -, *, /, =,
, e C(botão limpar)
O que é uma Calculadora?
Para aqueles que não sabem, uma calculadora é basicamente um
programa em um computador que simula o comportamento de
qualquer calculadora portátil útil para realizar
Cálculos Matemáticos. É um dispositivo muito básico usado em
nossas vidas cotidianas. Agora todos os smartphones também têm um
Aplicativo de calculadora neles.
Ao criar qualquer Aplicativo GUI, existem principalmente duas
steps:

O primeiro passo é criar uma Interface de Usuário.

O segundo passo é o mais importante e em
isso, adicionar funcionalidades à GUI
Now let’s begin withcreating a simple calculator appusing
Tkinter em Python que é usado para aritmética básica
cálculos.
Código do Aplicativo de Calculadora
Agora é hora de dar uma olhada no código para criar uma Calculadora
App usando Tkinter:
de tkinter importar *
win = Tk()# Isso é para criar uma janela básica
[Link]("312x324")# isso é para o tamanho da janela
[Link](0,0) # isso é para impedir o redimensionamento do
janela
[Link](“Calculator”)
###################Starting with functions
####################
# Função 'btn_click' :
Esta função atualiza continuamente o
campo de entrada sempre que você digitar um número

defbtn_click(item):
expressão global
expressão = expressão + str(item)
input_text.set(expressão)
# Função 'bt_clear': Esta é usada para limpar
o campo de entrada
defbt_clear():
expressão global
expression =””
input_text.set(””)
# ‘bt_equal’:This method calculates the expression
presente no campo de entrada
defbt_igualar():
expressão global
result =str(eval(expression))# ‘eval’:This function is used
para avaliar a expressão de string diretamente
input_text.set(resultado)
expression =””
expression =””
'StringVar()': É usado para obter a instância do campo de entrada
input_text = StringVar()
Vamos criar uma moldura para o campo de entrada
input_frame = Frame(win, largura=312, altura=50, bd=0,
highlightbackground=“black”, highlightcolor=“black”,
highlightthickness=2)
input_frame.pack(lado=SUPERIOR)
Vamos criar um campo de entrada dentro do 'Frame'
input_field = Entry(input_frame, font=(‘arial’,18,‘bold’),
textvariable=input_text, width=50, bg=“#eee”, bd=0,
justificar=DIRTO)
input_field.grid(linha=0, coluna=0)
input_field.pack(ipady=10)# 'ipady' é o preenchimento interno para
aumentar a altura do campo de entrada
Vamos criar outro 'Quadro' para o botão abaixo do
quadro_de_entrada
btns_frame = Frame(win, largura=312, altura=272.5,
bg=“grey”)
btns_frame.pack()
primeira linha
texto
32, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: bt_clear()).grid(linha = 0, coluna = 0,
columnspan =3, padx =1, pady =1)
divide = Button(btns_frame, text =“/”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
command =lambda: btn_click(“/”)).grid(row =0, column =3,
padx =1, pady =1)
segunda fila
seven = Button(btns_frame, text =“7”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando =lambda: btn_click(7)).grid(linha =1, coluna =0,
padx =1, pady =1)
oito = Botão(btns_frame, texto ="8", fg ="preto", largura =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando = lambda: btn_click(8)).grid(linha = 1, coluna = 1,
padx =1, pady =1)
nine = Button(btns_frame, text =“9”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando =lambda: btn_click(9)).grid(linha =1, coluna =2,
padx =1, pady =1)
multiplicar = Botão(btns_frame, texto ="*", fg ="preto", largura
=10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
command =lambda: btn_click(“*”)).grid(row =1, column =3,
padx =1, pady =1)
terceira linha
quatro = Botão(btns_frame, texto="4", fg="preto", largura =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando =lambda: btn_click(4)).grid(linha =2, coluna =0,
padx =1, pady =1)
five = Button(btns_frame, text =“5”, fg =“black”, width =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(5)).grid(linha=2, coluna=1, padx=1,
pady =1)
six = Button(btns_frame, text =“6”, fg =“black”, width =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(6)).grid(linha=2, coluna=2, padx=1,
pady =1)
minus = Button(btns_frame, text =“-”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: btn_click("-")).grid(linha = 2, coluna = 3,
padx =1, pady =1)
quarta linha
one = Button(btns_frame, text =“1”, fg =“black”, width =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(1)).grid(linha=3, coluna=0, padx=1,
pady =1)
dois = Botão(btns_frame, texto ="2", fg ="preto", largura =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(2)).grid(linha=3, coluna=1, padx=1,
pady =1)
three = Button(btns_frame, text =“3”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
command =lambda: btn_click(3)).grid(row =3, column =2,
padx =1, pady =1)
plus = Botão(btns_frame, texto = “+”, fg = “preto”, largura =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: btn_click("+")).grid(linha=3, coluna=
3, padx =1, pady =1)
quarta linha
zero = Button(btns_frame, text =“0”, fg =“black”, width =
21, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
command =lambda: btn_click(0)).grid(row =4, column =0,
columnspan =2, padx =1, pady =1)
ponto = Botão(btns_frame, texto =".", fg ="preto", largura =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
command =lambda: btn_click(“.”)).grid(row =4, column =2,
padx =1, pady =1)
equals = Button(btns_frame, text =“=”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
command =lambda: bt_equal()).grid(row =4, column =3,
padx =1, pady =1)
[Link]()
Existem uma variedade de funções no Tkinter com a ajuda de
torna-se fácil e conveniente fazer um simples
calculadora apenas com este pequeno código.
Além dos widgets Tkinter, definimos o seguinte
funções em nosso código:
btn_click()Função:Esta
função lida com o clique do botão em
vários botões numéricos para adicioná-los à operação.
bt_clear()Function:Esta
função é usada para lidar com o limpar
operação para limpar a entrada anterior na Calculadora
aplicação.
bt_equal()Function:Esta função é usada para lidar com a igualdade
botão para executar a operação e mostrar o resultado.
Agora vamos mostrar-lhe uma instantânea como resultado do acima
código. E sim, você pode implementá-lo em seu sistema para mais
compreensão clara do Aplicativo Calculadora Usando Tkinter:
Summary:
Neste tutorial, desenvolvemos um aplicativo de Calculadora básico
usando Tkinter e vários widgets do Tkinter sobre os quais nós
cobrimos em nosso Tutorial de Tkinter. Clique em Próximo para ver
mais aplicativos desenvolvidos usando Tkinter, pois isso ajudará você Parte
o que você aprendeu.
PARTE 26: Editor de Texto
Aplicativo Usando Tkinter
(Projeto em Python)
Neste tutorial, ajudaremos você a construir um editor de texto simples
Aplicativo usando Tkinter que é muito bom para iniciantes
projeto para Tkinter.
O Aplicativo de Editor de Texto é um aplicativo onde você pode escrever
seu texto, abra qualquer arquivo de texto, você pode editar qualquer arquivo de texto e você
também pode salvar um arquivo se quiser. Neste tutorial, nós iremos construir um
Aplicativo de Editor de Texto do zero.
Elementos essenciais para o aplicativo de editor de texto são como
segue:

Há umButton widget chamadobtn_open que é usado

para abrir um arquivo para edição
O segundo é um widget de botão chamadobtn_save por
salvando um arquivo

Terceiro, há umWidget de textochamadotxt_editarpara

criando e editando qualquer arquivo de texto.

A disposição de três widgets é feita de uma maneira tal que

os dois botões estão no lado esquerdo da janela, e
a caixa de texto está do lado direito. A altura mínima de
a janela inteira deve ter 900 pixels e o txt_edit deve ter
uma largura mínima de 900 pixels. E todo o layout deve
seja responsivo se a janela for redimensionada, então o txt_edit é redimensionado como
bem. A largura da estrutura que segura os botões não deve
mudar.
Deixe-nos mostrar a você com um esboço aproximado de como este editor de texto
vai parecer com:
O layout desejado do Aplicativo de Editor de Texto pode ser
conseguido usando o gerenciador de geometria .grid(). E este layout
contém uma única linha e duas colunas:

1. Do lado esquerdo, há uma coluna estreita para o

botões
2. Do lado direito, há uma coluna mais larga para o
caixa de texto

Para definir os tamanhos mínimos para a janela e txt_edit,

você só precisa definir os parâmetros de tamanho mínimo da janela
[Link]() e .columnconfigure() para 900. Para que
lidar com o redimensionamento, os parâmetros de peso desses métodos irão
definir como 1.
Se você quiser que os dois botões fiquem na mesma coluna, então você...
preciso criar um widget Frame chamado fr_buttons. De acordo com o
no esboço mostrado acima, os dois botões devem estar empilhados
verticalmente dentro deste quadro, tendo btn_open na parte superior. Isso pode
ser feito tanto por .grid() quanto por .pack() gerenciador de geometria. Por enquanto,
você só precisa ficar com .grid() pois é mais fácil de trabalhar
isso.
Vamos começar com o código para construir a Aplicação:

1. Criando todos os widgets necessários

O trecho de código que é utilizado é o seguinte:
importar tkinter como tk

janela = [Link]()
[Link]("Aplicativo de Editor de Texto")
[Link](0, minsize=900, weight=1)
[Link](1, minsize=900, peso=1)
txt_edit = [Link](janela)
fr_buttons = [Link](window)
btn_open = [Link](fr_buttons, text=“Open”)
btn_save = [Link](fr_buttons, text=“Save As…”)

Explicação do código acima:

O primeiro comando é usado para importar otkinter.
Então as próximas duas linhas são usadas para criar um novo
janela com o título "Aplicativo de Editor de Texto".
As próximas duas linhas de código são usadas para definir a linha
e configurações de coluna.
Então as linhas de 9 a 12 criarão os quatro
widgets que você precisará para a caixa de texto, a moldura, e
os botões abrir e salvar.

[Link](0, minsize=900, weight=1)

A linha acima dada no código indica
O parâmetro theminsize de .rowconfigure() está definido como 900 e o peso é
definir to1. O primeiro argumento é 0, que é usado para definir a altura
da primeira linha para 900 pixels e garante que a altura de
a linha cresce proporcionalmente à altura da janela.
Há apenas uma linha no layout do aplicativo, então esses
as configurações são aplicadas a toda a janela.
Então olhe para esta linha no código:
[Link](1, minsize=900, peso=1)
In the above code [Link]()to set
os atributos de largura e peso da coluna com
índice1a900e1, respectivamente. Tenha em mente que, linha e
os índices de coluna são baseados em zero, então essas configurações se aplicam apenas a
a segunda coluna. Ao configurar a segunda coluna, o
a caixa de texto irá expandir e contrair naturalmente quando a janela
é redimensionado, enquanto a coluna contendo os botões sempre estará
permanecer em uma largura fixa.

[Link]ção do Layout da Aplicação

btn_open.grid(row=0, column=0, sticky="ew", padx=5,
pady=5)
btn_save.grid(linha=1, coluna=0, sticky="ew", padx=5)
As duas linhas de código acima criarão uma grade com duas linhas
e uma coluna no quadro de botões "thefr_buttonsframe" já que ambos btn_open e
btn_save tem seu atributo mestre definido para fr_buttons.btn_open colocado em

a primeira linha e btn_save estarão na segunda linha para que

btn_aberto aparece acima btn_salvar no layout, conforme planejado no

esboço acima.

Obtn_open e obtn_save ambos têm

seus atributos pegajosos definidos como "ew", o que força o
botões para expandir horizontalmente em ambas as direções
e para preencher todo o quadro. Isso garante
ambos os botões têm o mesmo tamanho.
Você coloca 5 pixels de preenchimento ao redor de cada botão
bastando definir os parâmetros padx e pady para 5.
O btn_open tem preenchimento vertical. Porque está em cima,
o preenchimento vertical desloca o botão para baixo do
parte superior da janela um pouco e garante que há um
pequena lacuna entre isso e btn_save.
Agora que os botões estão organizados e prontos para funcionar, você pode apenas configurar
ajuste o layout da grade para o restante da janela agora:
fr_buttons.grid(row=0, column=0, sticky=“ns”)
txt_edit.grid(linha=0, coluna=1, sticky="nsew")
Essas duas linhas de código acima são usadas para criar uma grade com
uma linha e duas colunas para a janela. Você coloca os botões na
primeira coluna e txt_editar na segunda coluna assim
os botões thatfr aparecem à esquerda de txt_edit na disposição da janela.
O parâmetro sticky para os botões fr será definido como "ns", o que força
todo o quadro para expandir verticalmente e preencher toda a altura
de sua coluna.txt_edit é usado para preencher toda a célula da grade porque
você definiu seu parâmetro sticky como "nsew", o que o força a se expandir
em todas as direções.
Agora nós acabamos de criar os botões, mas eles não funcionam.
até adicionarmos funcionalidades a eles. Então vamos começar a adicionar o
Funcionamento dos Botões:

1. Função para Abrir o Arquivo

O trecho de código para open_file é o seguinte:
defabrir_arquivo():
Abra um arquivo para editar.
filepath = askopenfilename(
filetypes=[(“Text Files”,“*.txt”), (“All Files”,“*.*”)]
)
se não houver caminho do arquivo:

retornar
txt_edit.delete(1.0, [Link])
com open(filepath, "r") as arquivo_de_entrada:

texto = input_file.leitura()
txt_edit.insert([Link], texto)
[Link](f"Aplicativo de Editor de Texto -{filepath}")

Explicação:
As linhas de 3 a 5 usam ocaixadialogoabrirarquivo
do módulo filedialog do tkinter para exibir um abrir arquivo
dialogar e armazenar o caminho do arquivo selecionado em tofilepath.

As linhas 6 e 7 verificam se o usuário fecha o

caixa de diálogo ou clica no botão Cancelar. Se sim,
 então o caminho do arquivo será Nenhum, e a função
retornará sem executar nenhum do código para ler
o arquivo e definir o texto de txt_edit.
A linha 8 limpa o conteúdo atual detxt_editarusando
.deletar().

As linhas 9 e 10 são usadas para abrir o arquivo selecionado

[Link]() seu conteúdo antes de armazenar o texto como um
string.
A linha número 11 atribui a string text para txt_edit usando
.inserir().

A linha 12 define o título da janela para que ela

contém o caminho do arquivo aberto.

2. Função para Salvar o Arquivo

O trecho de código para save_file é o seguinte:
defsalvar_arquivo():

Salve o arquivo atual como um novo arquivo.

filepath = asksaveasfilename(
defaultextension=“txt”,
filetypes=[(“Text Files”,“*.txt”), (“All Files”,“*.*”)],
)
se não houver arquivo

retornar
comopen(caminho_do_arquivo, "w")comoarquivo_saida:

texto = txt_edit.get(1.0, [Link])

output_file.write(text)
[Link](f"Aplicativo de Editor de Texto -{filepath}")

Explanation:
As linhas 3 a 6 usam oasksaveasfilenamedialog box to get
o local de salvamento desejado pelo usuário. O selecionado
o caminho do arquivo está armazenado na variável thefilepath.
 As linhas 7 e 8 verificam se o usuário fecha o
caixa de diálogo ou clica no botão Cancelar. Se sim,
entãopathfileseráNenhum, e a função retornará
sem executar nenhum dos códigos para salvar o texto em
um arquivo.
A linha 9 cria um novo arquivo no caminho de arquivo selecionado.

A linha 10 extrai o texto detxt_editwith.get()

método e atribui à variável texto.
Linha 11 escrevetexto para o arquivo de saída.

A linha 12 atualiza o título da janela para que o

o novo caminho do arquivo é exibido no título da janela.

O código-fonte completo é:
importar tkinter como tk

[Link],
salvarcomonome
defabrir_arquivo():
Abra um arquivo para edição.
caminho_do_arquivo = pedir_nome_arquivo(

filetypes=[(“Text Files”,“*.txt”), (“All Files”,“*.*”)]

)
se não houver caminho do arquivo:

retornar
txt_edit.delete(1.0, [Link])
withopen(caminho_do_arquivo, "r")asinput_file:

texto = input_file.read()
txt_edit.insert([Link], texto)
[Link](f"Aplicativo de Editor de Texto -{filepath}")
defsalvar_arquivo():

Salve o arquivo atual como um novo arquivo.

filepath = asksaveasfilename(
 defaultextension=“txt”,
filetypes=[(“Text Files”,“*.txt”), (“All Files”,“*.*”)],
)
se não houver arquivo

retornar
with open(filepath, "w") as output_file:
texto = txt_edit.get(1.0, [Link])
output_file.write(text)
[Link](f"Aplicativo de Editor de Texto -{filepath}")
janela = [Link]()
[Link](“Text Editor Application”)
[Link](0, minsize=800, peso=1)
[Link](1, minsize=800, weight=1)
txt_edit = [Link](janela)
fr_buttons = [Link](window, relief=[Link], bd=2)
btn_open = [Link](fr_buttons, text=“Open”,
command=open_file)
btn_save = [Link](fr_buttons, text=“Save As…”,
command=save_file)
btn_open.grid(row=0, column=0, sticky="ew", padx=5,
pady=5)
btn_save.grid(row=1, column=0, sticky=“ew”, padx=5)
fr_buttons.grid(linha=0, coluna=0, pegajoso="ns")
txt_edit.grid(linha=0, coluna=1, fixo="nsew")
[Link]()
Como você pode ver na saída, temos um editor de texto básico
aplicativo no qual podemos escrever algo e depois salvar
o texto em um novo arquivo ou use o botão Abrir para abrir um arquivo em
o editor e então editá-lo.
PARTE 27: Tocador de Música
Application using Tkinter
(Projeto Python)
Neste tutorial, criaremos um Aplicativo de Reprodutor de Música em
Python usando o módulo Tkinter e Pygame.
Na nossa vida diária, vemos que cada pessoa tem um hobby e isso é
ouvindo música. Então, para ouvir música, todos eles precisam
um Reprodutor de Música (hardware ou software) onde eles podem tocar
suas músicas favoritas. E temos que instalar este reprodutor de música
no nosso computador, com base no sistema operacional, ou seja, Windows,
Macintosh, Android, Linux, etc. Então nós podemos ouvir nosso
canções favoritas.
Agora vamos ajudá-lo a codificar e criar um Reprodutor de Música a partir de
riscado.
Bibliotecas usadas para reprodutor de música
Aplicativo:
Agora vamos falar sobre as bibliotecas que usaremos em nossa
code :

1. Tkinter
Já dissemos a você no título desta página que somos
vou usar a biblioteca Tkinter, que é uma biblioteca padrão para
Criação de GUI. A biblioteca Tkinter é a mais popular e muito
fácil de usar e vem com muitos widgets (esses widgets
ajuda na criação de Aplicações GUI com aparência agradável).
Além disso, o Tkinter é um módulo muito leve e é útil em
criando aplicações multiplataforma (para que o mesmo código possa
easily work onWindows,macOS, andLinux)
Para usar todas as funções do Tkinter, você precisa importá-lo em
seu código e o comando para o mesmo é:
from tkinter import *

Módulo Pygame
Pygame é um módulo Python que funciona com computadores
bibliotecas gráficas e sonoras e é projetado com o poder de
brincando com diferentes formatos multimídia como áudio, vídeo,
etc. Ao criar nosso aplicativo de Reprodutor de Música, estaremos
usando o módulo [Link] do Pygame para fornecer diferentes
funcionalidade para nosso aplicativo de reprodutor de música que é normalmente
relacionado à manipulação das faixas musicais.
O comando usado para instalar o módulo thepygame é:
pip install pygame

Para usar este módulo no seu código você precisa escrever

isto:
importar pygame

3. Módulo OS
Não há necessidade de instalar este módulo explicitamente, pois ele vem
com a biblioteca padrão do Python. Este módulo fornece
diferentes funções para interação com o Sistema Operacional.
Neste tutorial, vamos usar o módulo OS
para buscar a playlist de músicas do especificado
diretório e torná-lo disponível para o tocador de música
aplicativo.
Para usar este módulo em seu código, você precisa importar suas e
o comando para o mesmo é o seguinte:
importarSO

Após importar bibliotecas e módulos, agora é hora de

crie uma janela básica onde vamos adicionar nossos elementos de interface
ou widgets do Tkinter. Você pode adicionar este código depois
importando bibliotecas ou também no final, logo antes do loop de
a janela raiz e o código é o seguinte:
root = Tk()# Para criar uma janela vazia
# Passando Root para a Classe MusicPlayer
ReprodutorDeMúsica(root)

Classe MusicPlayer
Aqui temos o construtor e as outras funções definidas
na classe MusicPlayer.

1._init_Construtor
Com a ajuda deste construtor, vamos definir o título para o
janelaegeometria para a janela. Vamos iniciar
pygame e pygame mixer e então declare a faixa
variável e variável de status.

Em seguida, criaremos os quadros de faixa para a música

rótulo&status rótulo e depois Insira a Música
Track Label and Status Label.
Depois disso, criaremos o botão
Quadro e inserir tocar, pausar, retomar e parar
botões nele.
Então, criaremos a estrutura da playlist e adicionaremos o
barra de rolagem para isso e nós iremos adicionar músicas no
playlist.
O trecho de código é o seguinte:
def __init__(self, raiz):
[Link] = root
 Título da janela
[Link]("MusicPlayer")
Geometria da Janela
[Link]("1000x200+200+200")
# Iniciando Pygame
[Link]()
Iniciando o Mixer do Pygame
[Link]()
# Declarando trackVariable
[Link] = StringVar()
Declarando StatusVariable
[Link] = StringVar()
Criando os Quadros de Faixa para o rótulo da Música e o rótulo de Status

trackframe = LabelFrame([Link],text=“Song
Rastrear", fonte=("times new
romano",15,"negrito"),bg="AzulMarinho",fg="branco",bd=5,relief=G
ROOVE)
[Link](x=0,y=0,width=600,height=100)
Inserindo o rótulo da faixa da música

songtrack =
Label(trackframe,textvariable=[Link],width=20,font=
times novo
romano",24,"negrito"),bg="Laranja",fg="dourado").grid(linha=0,coluna
mn=0,padx=10,pady=5)
Inserindo Etiqueta de Status
trackstatus =
Etiqueta(trilho,texto_variável=[Link],font=("times novo
romano",24,"negrito"),bg="laranja",fg="ouro").grid(linha=0,coluna
n=1,padx=10,pady=5)
# Criando o Quadro do Botão
 buttonframe = LabelFrame([Link],text=“Control
Painel
romano",15,"negrito"),bg="cinza",fg="branco",bd=5,alívio=GROO
VE)
[Link](x=0,y=100,largura=600,altura=100)
Inserindo Botão de Play
playbtn =
Botão(botãoquadro,texto="Tocarmúsica",comando=[Link]
ong,width=10,height=1,font=(“times new
romano",16,"negrito"),fg="azulmarinho",bg="rosa").grid(linha=0,col
umn=0,padx=10,pady=5
Inserindo Botão de Pausa
playbtn =
Button(buttonframe,text=“PAUSE”,command=[Link],
largura=8, altura=1, fonte=("times new
romano",16,"negrito"),fg="azul-marinho",bg="rosa").grid(linha=0,col
umn=1,padx=10,pady=5)
Inserindo Botão de Retomar
playbtn =
Button(buttonframe,text=“UNPAUSE”,command=[Link]
esong, largura=10, altura=1, fonte=(“times novo
romano",16,"negrito"),fg="azul-marinho",bg="rosa").grid(linha=0,col
umn=2,padx=10,pady=5)
Inserindo Botão de Parada
playbtn =
Button(buttonframe,text=“STOPSONG”,command=[Link]
ong,largura=10,altura=1,fonte=(“times nova
romano",16,"negrito"),fg="azul-marinho",bg="rosa").grid(linha=0,col
umn=3,padx=10,pady=5)
# Criando Quadro de Playlist
songsframe = LabelFrame([Link],text=“Song
Playlist
romano",15,"negrito"),bg="cinza",fg="branco",bd=5,relief=GROO
VE)
[Link](x=600,y=0,largura=400,altura=200)
 Inserindo barra de rolagem
scrol_y = Scrollbar(songsframe, orient=VERTICAL)
Inserindo caixa de lista de Playlist

[Link] =
Caixa de Lista(cantosframe,yscrollcommand=scrol_y.set,selectbackgr
ound="ouro", selectmode=SINGLE, font=("times new
romano",12,"negrito"),bg="prata",fg="azulmarinho",bd=5,relief=GR
OOVE
Aplicando barra de rolagem ao listbox
scrol_y.pack(side=DIREITA, fill=Y)
scrol_y.config(command=[Link])
[Link](fill=BOTH)
Mudando o diretório para buscar músicas
[Link]("Caminho/Do/Diretório")
Buscando Canções
songtracks = [Link]()
Inserindo Músicas na Playlist
fortrackinsongtracks:
[Link](END, track)
In the code above, change thePATH/OF/DIRECTORYwith
um caminho apropriado onde os arquivos de música estão armazenados.

2. A função playsong()
Agora vamos definir a Função Tocar Música e o código é:
defreproduzirmusica(self):

Exibindo o título da música selecionada

[Link]([Link](ATIVO))
Exibindo Status
[Link]("-Jogando")
Carregando a Música Selecionada
 [Link]([Link](ACTIVE))
# Tocando Canção Selecionada
[Link]()

3. A função thestopsong()
O trecho de código para parar a música:
defstopsong(self):
# Displaying Status
[Link]("-Parado")
Canção Parada
[Link]()

4. A função thepausesong()
O trecho de código para pausar a música:
defpausesong(self):
Exibindo Status
[Link](“-Pausado”)
Música Pausada
[Link]()

5. A função Theunpausesong()
O trecho de código para retomar a música:
defunpausesong(self):
Ele exibirá o status
[Link]("-Jogando")
Reproduzindo Música
[Link]()
6. Looping da Janela Raiz
O comando será:
[Link]()
Agora aqui estão algumas capturas de tela do nosso aplicativo:
A pasta chamada studytonight onde o arquivo de código e a pasta
para as músicas é colocado assim:

Forneceremos o caminho da pasta de músicas em nosso código onde

todas as músicas estão organizadas para serem acessadas.

Agora a seguinte captura de tela é para mostrar como o

o aplicativo parecerá com:

whenever you made aclick on the songit will look like this:

Ao clicar no botão PLAYSONG:

Ao clicar no botão PAUSAR:

On clicking theSTOP Button:

Então, tudo isso era sobre construir o Aplicativo de Reproduzidor de Música

usando Tkinter. Espero que todos gostem deste aplicativo. Por favor, compartilhem.
mais ideias conosco para aplicativos de desktop baseados em Tkinter e
definitivamente adicionaremos mais projetos de Tkinter ao nosso Tkinter
tutorial.
PARTE 28: Quebra-tijolos
Jogo usando Tkinter (Python)
Projeto
É hora de codificar um jogo em Python. Começaremos com um simples
Brick breaker game in which there is a ball that bounces of a
plataforma para quebrar uma parede de tijolos e o jogador tem que manter o
a bola passando, garantindo que a raquete esteja sempre lá para rebater
fora da bola de volta.
O jogo terá três camadas de tijolos, e cada camada de
o tijolo terá uma capacidade de impacto diferente, o que significa que alguns
tijolos quebrarão com um único golpe, alguns precisarão de um duplo
acertar e alguns precisarão de três acertos.

Para simplificar a lógica e a interface do usuário do jogo, o

os tipos de tijolos são:
Tijolo verde: Requer três golpes para quebrar
Tijolos rosa: Requer dois golpes para quebrar
Blocos roxos: Requer três golpes para quebrar

Requisitos:
Para entender o código para construir o jogo de quebra-blocos em
Python, você deve conhecer os seguintes conceitos:

Criar Classe em Python

Construtor para Classe em Python
Herança em Python
Modificadores de acesso em Python
__name__ como o método principal em Python

Além disso, a compreensão geral do Python é

necessário, que você também pode obter em nossa série de tutoriais GRATUITA
paraAprenda Python.

Código para o Jogo Quebra-Blocos

Nós criaremos 5 classes no código, o nome do
as aulas são:

1. GameObject
2. Ball
3. Remo
4. Tijolo
5. Jogo
Todas essas classes terão métodos para realizar várias
manipulação e operações no respectivo elemento do jogo.
Vamos ver o código para cada classe.

Classe GameObject
Esta classe é a classe pai de todas as outras classes, que
significa que todas as outras classes herdarão esta classe.
O código para esta classe é o seguinte:
classObjetoDeJogo(object):
def __init__(self, canvas, item):
[Link] = canvas
[Link] = item
def obter_posicao(self):
[Link]([Link])
defmovimentar(self, x, y):

[Link]([Link], x, y)
defdelete(self):
[Link]([Link])
Esta classe tem funções para lidar com o ciclo de vida básico de
different objects that form the game.
Classe de Bola
Aqui está o código para a classe Bola:
classBall(JogoObjeto):
def __init__(self, canvas, x, y):
[Link] =10
[Link] = [1, -1]
aumente o valor abaixo para aumentar a velocidade da bola
[Link] =5
item = canvas.create_oval([Link], [Link],
x+[Link], y+[Link],
fill='branco')
super(Ball, self).__init__(canvas, item)
definire atualizar(self):

coords = self.get_position()
largura = [Link].winfo_width()
se coords[0] <= 0 ou coords[2] >= largura:
 [Link][0] *= -1
se coords[1] <= 0:
[Link][1] *= -1
x = [Link][0] * [Link]
y = [Link][1] * [Link]
[Link](x, y)
defcollidir(self, objetos_de_jogo):
coords = self.get_position()
x = (coords[0] + coords[2]) * 0.5
se len(game_objects) > 1:
[Link][1] *= -1
se len(game_objects) == 1:
game_object = game_objects[0]
coords = game_object.get_position()
se x > coords[2]:
[Link][0] =1
elifx < coords[0]:
[Link][0] = -1
senão:
[Link][1] *= -1
forgame_objectingame_objects:
if isinstance(game_object, Brick):
game_object.acertar()
Na classe Ball, o método collide() é usado para lidar com o
colisão e é usado na função check_collisions() do
Classe de Jogo. Enquanto a função update() é para redefinir a Bola
objeto após uma vida ser perdida e o jogo começa novamente.

Aula de Remo
Aqui está o código para a classe Paddle:
class Paddle(GameObject):
def __init__(self, canvas, x, y):
# defina a forma e a posição da raquete
[Link] =80
[Link] =10
[Link] =None
item = canvas.create_rectangle(x - [Link] / 2,
y - [Link] /2,
x + [Link] / 2,
y + [Link] /2,
fill=‘#FFB643’)
super(Paddle, self).__init__(canvas, item)
definir_bola(self, bola):
[Link] = ball
defmova(self, deslocamento):

coords = self.get_position()
largura = [Link].winfo_width()
se coords[0] + deslocamento >= 0 e coords[2] + deslocamento <=
width:
super(Paddle, self).mover(offset,0)
se [Link] não None:
[Link](deslocamento, 0)

Além do construtor, o método themove() nesta classe é

importante, pois possibilita o movimento para a palheta.
Classe de Tijolo
Aqui está o código para a classe Brick:
class Tijolo(GameObject):
COLORS = {1:‘#4535AA’,2:‘#ED639E’,3:‘#8FE1A2’}
 def__init__(self, canvas, x, y, hits):
[Link] =75
[Link] =20
[Link] = hits
color = [Link][hits]
item = canvas.create_rectangle(x - [Link] /2,
y - [Link] /2,
x + [Link] /2,
y + [Link] / 2,
preencher=cor, tags='tijolo'
super(Brick, self).__init__(canvas, item)
defhit(self):
[Link] -=1
se [Link] == 0:
[Link]()
caso contrário:
[Link]([Link],
fill=[Link][[Link]]
Começamos a definição da classe definindo as cores para o
diferentes tipos de tijolos. Então, no construtor, o tamanho e
a posição dos tijolos está definida. E então há
a função thehit() que lida com a possibilidade de o tijolo desaparecer
ou ele irá absorver o golpe e mudar de cor para receber o próximo golpe.

Classe de Jogo
This is the main class that controls everything. Here is the
code:
classJogo([Link]):
def __init__(self, mestre):
super(Game, self).__init__(master)
 [Link] =3
[Link] =610
[Link] =400
[Link] = [Link](self, bg='#D6D1F5',
largura=[Link],
altura=[Link],
[Link]()
[Link]()
[Link] = {}
[Link] =None
[Link] = Paddle([Link], [Link]/2, 326)
[Link][[Link]] = [Link]
# adicionando tijolo com diferentes capacidades de impacto - 3, 2 e 1

para x em range(5, [Link] - 5, 75):

self.add_brick(x +37.5,50,3)
self.add_brick(x +37.5,70,2)
self.add_brick(x + 37.5, 90, 1)
[Link] =None
self.setup_jogo()
[Link].focus_set()
[Link]('<Esquerda>',
lambda_: [Link](-10))
[Link]('Direita',
lambda_: [Link](10))
definira_jogo(self):
self.adicionar_bola()
self.atualiza_texto_vidas()
[Link] = self.draw_text(300,200,
 Pressione Espaço para começar

[Link]('<espaço>', lambda_:
self.start_game())
def adicionar_bola(self):

se [Link] não for None:

[Link]()
paddle_coords = [Link].get_position()
x = (paddle_coords[0] + paddle_coords[2]) * 0.5
[Link] = Ball([Link], x, 310)
[Link].set_ball([Link])
def adicionar_tijolo(self, x, y, acertos):

brick = Brick([Link], x, y, hits)

[Link][[Link]] = brick
def desenhar_texto(self, x, y, texto, tamanho='40'):

font = (‘Forte’, size)

[Link].create_text(x, y, text=text,
font=font)
def atualizar_texto_vidas(self):
Vidas: %s
se [Link]:
[Link] = self.draw_text(50,20, text,15)
caso contrário:
[Link]([Link], text=text)
definiciar_jogo(self):
[Link]('<space>')
[Link]([Link])
[Link] =None
self.game_loop()
 defloop_do_jogo(self):
self.verificar_colisões()
num_bricks =len([Link].find_withtag(‘brick’))
se_num_blocos == 0:
[Link] =None
Você ganhou! Você é o Quebrador
Tijolos.')
elif [Link].get_position()[3] >= [Link]:
[Link] =None
[Link] -= 1
se [Link] < 0:
self.draw_text(300,200,'Você Perdeu! Jogo Terminado!')
senão:
[Link](1000, self.setup_game)
senão:
[Link]()
[Link](50, self.game_loop)
def verificar_colisões(self):
ball_coords = [Link].get_position()
items = [Link].find_overlapping(*ball_coords)
objetos = [[Link][x] for x in itens se x em [Link]]
[Link](objetos)
Nesta aula, temos o seguinte:

1. Definimos o número de vidas, as cores de fundo

do jogo, e outros estilos da janela do jogo.
2. A configuração do jogo é feita por esta classe.

3. Adicionando os tijolos, adicionando a pá, a bola e o texto é

feito por esta classe.
O gerenciamento de vidas é feito por esta classe.
 5. Iniciar o jogo e executar o loop do jogo, também é
feito nesta aula.

Código Completo para o Quebra-Blocos

Game:
Aqui está o código completo para o jogo.
import tkinter as tk
classGameObject(ato):
def __init__(self, canvas, item):
[Link] = canvas
[Link] = item
def obter_posição(self):
return [Link]([Link])
defmover(self, x, y):
[Link]([Link], x, y)
defdelete(self):
[Link]([Link])
classeBola(JogoObjeto):
def __init__(self, canvas, x, y):
[Link] =10
[Link] = [1, -1]
# aumente o valor abaixo para aumentar a velocidade da bola
[Link] =5
item = canvas.create_oval([Link], [Link],
x+[Link], y+[Link],
preencher='branco')
super(Ball, self).__init__(canvas, item)
defatualizar(self):
 coords = self.get_position()
largura = [Link].winfo_width()
se coords[0] <= 0 ou coords[2] >= largura:
[Link][0] *= -1
se coords[1] <= 0:
[Link][1] *= -1
x = [Link][0] * [Link]
y = [Link][1] * [Link]
[Link](x, y)
defcolidir(self, objetos_do_jogo):
coords = self.get_position()
x = (coords[0] + coords[2]) * 0.5
se len(game_objects) > 1:
[Link][1] *= -1
eliflen(game_objects) == 1:
game_object = game_objects[0]
coords = game_object.get_position()
se x > coords[2]:
[Link][0] =1
elifx < coords[0]:
[Link][0] = -1
senão:
[Link][1] *= -1
forgame_objectingame_objects:
se isinstance(game_object, Brick):
game_object.acertar()
classePaddle(GameObject):
def __init__(self, canvas, x, y):
 [Link] =80
[Link] =10
[Link] =None
item = canvas.create_rectangle(x - [Link] / 2,
y - [Link] / 2,
x + [Link] / 2,
y + [Link] /2,
fill='#FFB643')
super(Paddle, self).__init__(canvas, item)
def definir_bola(self, bola):
[Link] = bola
defmover(self, deslocamento):

coords = self.get_position()
largura = [Link].winfo_width()
secoords[0] + deslocamento >=0ecoords[2] + deslocamento <=
width:
super(Paddle, self).move(offset,0)
se o pró[Link] não é Nenhum:

[Link](offset,0)
classeBrick(GameObject):
COLORS = {1:‘#4535AA’,2:‘#ED639E’,3:‘#8FE1A2’}
def __init__(self, canvas, x, y, hits):
[Link] =75
[Link] =20
[Link] = hits
color = [Link][hits]
item = canvas.create_rectangle(x - [Link] / 2,
y - [Link] / 2,
 x + [Link] / 2,
y + [Link] /2,
preencher=cor, tags='tijolo')
super(Brick, self).__init__(canvas, item)
definir(self):
[Link] -=1
[Link] ==0:
[Link]()
senão:
[Link]([Link],
preencher=[Link][[Link]]
classeJogo([Link]):
def __init__(self, mestre):
super(Game, self).__init__(master)
[Link] =3
[Link] =610
[Link] =400
[Link] = [Link](self, bg=‘#D6D1F5’,
largura=[Link],
altura=[Link],
[Link]()
[Link]()
[Link] = {}
[Link] =None
[Link] = Paddle([Link], [Link]/2, 326)
[Link][[Link]] = [Link]
# adicionando tijolo com diferentes capacidades de dano - 3, 2 e 1
para x na faixa(5, [Link] -5,75):
 self.add_brick(x + 37.5, 50, 3)
self.add_brick(x +37.5,70,2)
self.add_brick(x +37.5,90,1)
[Link] =None
self.setup_game()
[Link].focus_set()
[Link]('<Esquerda>',
lambda_: [Link](-10))
[Link]('<Right>',
lambda_: [Link](10))
definiriniciar_jogo(self):

self.adicionar_bola()
self.atualiza_texto_vidas()
[Link] = self.draw_text(300,200,
Pressione Espaço para começar

[Link]('<space>',lambda_:
self.start_game())
defadd_ball(self):
se [Link] não é None:
[Link]()
paddle_coords = [Link].get_position()
x = (paddle_coords[0] + paddle_coords[2]) * 0.5
[Link] = Ball([Link], x,310)
[Link].set_ball([Link])
defadd_brick(self, x, y, hits):
brick = Brick([Link], x, y, hits)
[Link][[Link]] = brick
def desenhar_texto(self, x, y, texto, tamanho=‘40’):
 font = (‘Forte’, size)
[Link].create_text(x, y, text=text,
fonte=fonte)
defatualizar_texto_vidas(self):
Vidas: %s
se [Link]:
[Link] = self.draw_text(50,20, text,15)
caso contrário:
[Link]([Link], text=text)
definiriniciar_jogo(self):

[Link]('<espaço>')
[Link]([Link])
[Link] =None
self.game_loop()
defloop_do_jogo(self):
self.verifica_colisões()
num_bricks =len([Link].find_withtag(‘brick’))
se_num_blocos == 0:
[Link] =None
Você ganhou! Você é o Quebrador de
Tijolos.
elif [Link].get_position()[3] >= [Link]:
[Link] =None
[Link] -=1
se [Link] < 0:
self.draw_text(300,200,‘Você Perdeu! Fim de Jogo!’)
senão:
[Link](1000, self.setup_game)
 senão:
[Link]()
[Link](50, self.game_loop)
def verificar_colisoes(self):
ball_coords = [Link].get_position()
items = [Link].find_overlapping(*ball_coords)
objetos = [[Link][x] for x in itens se x em [Link]]
[Link](objetos)
se__nome__ == '__principal__':

root = [Link]()
[Link](‘Break those Bricks!’)
game = Game(root)
[Link]()
Para rodar o jogo, você deve ter o módulo Tkinter instalado.
Salve o código dado acima em um arquivo com algum nome, vamos
[Link]. Então, para executar o código, execute o
comando seguinte:
python [Link]
Interface do Usuário do Jogo Quebra-Tijolos
Aqui estão algumas imagens de como o jogo se parece.
Quando o jogador ganha o jogo:
Quando o jogador perde o jogo:

E com isso, este tutorial termina. Espero que o jogo funcione bem para
você. Recomendamos que você edite e personalize o código para
melhore o jogo. Tente adicionar mais recursos ao jogo.
PARTE 29: Calculadora
Aplicativo Usando Python
Língua
A Calculadora é um aplicativo que todos nós utilizamos em nosso dia-a-dia.
vidas do dia-a-dia. Se você está tentando sujar as mãos com
programação em python, A Calculadora é uma tarefa simples e
projeto útil ao mesmo tempo. Hoje, vamos desenvolver
Um Calculador aPython usando Tkinter com passos simples de seguir
instruções.
Aqui está como nossa calculadora aparecerá, que foi criada usando
o campo de entrada, botões e lógica definidos em funções para
fins de cálculo. Por exemplo, se você quiser adicionar dois
números, deve haver lógica para adição, da mesma forma para
subtração, multiplicação e assim por diante, criamos
funções cuja tarefa é realizar essas operações.
Temos um Campo de Entrada onde a entrada do usuário será exibida
junto com o resultado final do cálculo.
Os botões são numerados de 0 a 9, +, -, *, /, =,
e C. (botão de limpar)

O que é uma Calculadora?

Para aqueles que não estão familiarizados, uma calculadora é um aplicativo de computador
que imita o comportamento de qualquer calculadora de mão utilizada para
completando cálculos matemáticos. É realmente simples
um item que usamos diariamente. Um aplicativo de calculadora é
agora disponível em todos os celulares.
Existem principalmente dois processos envolvidos no desenvolvimento de qualquer
Aplicativo GUI:
Criar uma Interface de Usuário é a etapa inicial.
A segunda e mais crucial etapa é fornecer o
funcionalidade à interface gráfica do usuário.
Vamos começar fazendo um aplicativo de calculadora simples em Python
utilizando Tkinter para cálculos aritméticos básicos.

Código Fonte para Calculadora

Aplicativo
Agora é hora de olhar o código para fazer um Tkinter
Calculator App:
de tkinter import *
win = Tk()# Isso é para criar uma janela básica
[Link](“312x324”)# isso é para o tamanho da janela
[Link](0,0) # isso é para impedir o redimensionamento do
janela
[Link](“Calculator”)
###################Começando com funções
####################
# Função 'btn_click' :
Esta Função atualiza continuamente o
campo de entrada sempre que você inserir um número

defbtn_click(item):
expressão global
expression = expression +str(item)
input_text.set(expressão)
Função 'bt_clear': Isso é usado para limpar
# o campo de entrada
defbt_clear():
expressão global
expression =””
""
# ‘bt_equal’:This method calculates the expression
# presente no campo de entrada

defbt_equal():
expressão global
result =str(eval(expression))# ‘eval’:This function is used
para avaliar a expressão de string diretamente
input_text.set(result)
expression =””
expression =””
'StringVar()': É utilizado para obter a instância do campo de entrada
input_text = StringVar()
Vamos criar uma moldura para o campo de entrada
input_frame = Frame(win, largura=312, altura=50, bd=0,
highlightbackground=“black”, highlightcolor=“black”,
thicknessdestaque=2)
input_frame.pack(side=TOP)
#Let us create a input field inside the ‘Frame’
input_field = Entrada(input_frame, fonte=('arial',18,'negrito'),
textvariable=input_text, width=50, bg=“#eee”, bd=0,
justificar=À DIREITA)
input_field.grid(linha=0, coluna=0)
input_field.pack(ipady=10)# 'ipady' é o preenchimento interno para
aumentar a altura do campo de entrada
Vamos criar outro 'Quadro' para o botão abaixo do
quadro_de_entrada
btns_frame = Frame(win, width=312, height=272.5,
bg=“grey”)
btns_frame.pack()
# primeira linha

clear = Button(btns_frame, text =“C”, fg =“black”, width =

32, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando =lambda: bt_clear()).grid(linha =0, coluna =0,
columnspan =3, padx =1, pady =1)
divide = Button(btns_frame, text =“/”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: btn_click("/")).grid(linha=0, coluna=3,
padx =1, pady =1)
segunda linha
seven = Button(btns_frame, text =“7”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
command =lambda: btn_click(7)).grid(row =1, column =0,
padx =1, pady =1)
eight = Button(btns_frame, text =“8”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando = lambda: btn_click(8)).grid(linha = 1, coluna = 1,
padx =1, pady =1)
nine = Button(btns_frame, text =“9”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando =lambda: btn_click(9)).grid(linha =1, coluna =2,
padx =1, pady =1)
multiply = Button(btns_frame, text ="*", fg ="preto", width
=10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
command =lambda: btn_click(“*”)).grid(row =1, column =3,
padx =1, pady =1)
terceira linha
quatro = Botão(btns_frame, texto = "4", fg = "preto", largura =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando =lambda: btn_click(4)).grid(linha =2, coluna =0,
padx =1, pady =1)
five = Button(btns_frame, text =“5”, fg =“black”, width =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(5)).grid(linha = 2, coluna = 1, padx = 1,
pady =1)
six = Button(btns_frame, text =“6”, fg =“black”, width =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(6)).grid(row =2, column =2, padx =1,
pady =1)
minus = Button(btns_frame, text =“-”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: btn_click("-")).grid(linha = 2, coluna = 3,
padx =1, pady =1)
quarta linha
um = Botão(btns_frame, texto = "1", fg = "preto", largura = 10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(1)).grid(linha=3, coluna=0, padx=1,
pady =1)
dois = Botão(btns_frame, texto ="2", fg ="preto", largura =10,
height =3, bd =0, bg =“#fff”, cursor =“hand2”, command =
lambda: btn_click(2)).grid(linha=3, coluna=1, padx=1,
pady =1)
three = Button(btns_frame, text =“3”, fg =“black”, width =
10, height =3, bd =0, bg =“#fff”, cursor =“hand2”,
comando = lambda: btn_click(3)).grid(linha = 3, coluna = 2,
padx =1, pady =1)
plus = Botão(btns_frame, texto = " + ", fg = "preto", largura =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: btn_click("+")).grid(linha = 3, coluna =
3, padx =1, pady =1)
quarta linha
zero = Button(btns_frame, text =“0”, fg =“black”, width =
21, altura =3, bd =0, bg ="#fff", cursor ="hand2"
command =lambda: btn_click(0)).grid(row =4, column =0,
colspan=2, padx=1, pady=1
point = Button(btns_frame, text =“.”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
command =lambda: btn_click(“.”)).grid(row =4, column =2,
padx =1, pady =1)
equals = Button(btns_frame, text =“=”, fg =“black”, width =
10, height =3, bd =0, bg =“#eee”, cursor =“hand2”,
comando = lambda: bt_equal()).grid(linha = 4, coluna = 3,
padx =1, pady =1)
[Link]()
Tkinter possui uma série de métodos que facilitam e
rápido para criar uma calculadora básica com apenas algumas linhas de código.

We’ve defined the following functions in our code, in addition

aos widgets Tkinter:
Função btn click(): Esta função adiciona vários
botões numéricos para a operação manuseando o botão
cliques.
O método bt clear() é usado para lidar com a limpeza.
ação no aplicativo Calculadora, que limpa o
entrada anterior.
O botão igual é tratado pela função bt equal(), que
faz a ação e exibe o resultado.
Agora vamos mostrar uma captura de tela do mencionado anteriormente.
resultado do código. Sim, você pode usá-lo na sua máquina para ter um
melhor conhecimento do Aplicativo de Calculadora Usando Tkinter:

Output:
Summary:
Neste artigo, usamos Tkinter e vários widgets Tkinter para
crie um aplicativo de calculadora simples, que cobrimos em
nosso Tutorial Tkinter.
PARTE 30: Despertador
Usando a linguagem Python
O Despertador Usando Python é um projeto construído em python
linguagem de programação, O propósito deste PythonAlarm
O ClockTutorial é para criar uma GUI de Despertador em Python.

A Python Alarm Clock Script includes essential libraries such

asDateTime e Tkinter, que nos ajudam a construir
projetos utilizando a data e hora atuais. Eles também oferecem um
interface do usuário para definir o alarme de acordo com a demanda em um 24-
hour format. To start developing this primary project, Alarm
Relógio Usando Python, certifique-se de que você tenha o Pycharm
IDE instalado no seu computador.

Passos para Como Fazer um Alarme

Relógio Usando Python.
Despertador Usando Python Com Código Fonte
Código
Passo 1: Crie um nome para o projeto.

Primeiro, abra o IDE Pycharm e depois crie um "nome do projeto".

após gerar um nome de projeto, clique no botão “criar”.
Passo 2: Crie um arquivo Python.
Em segundo lugar, após estabelecer um nome para o projeto, "clique com o botão direito"
nome do projeto e depois escolha "novo" após isso, clique no
arquivo python
Passo 3: Nomeie seu arquivo python.
Em terceiro lugar, após gerar um arquivo python, nomeie seu arquivo python;
clique em "enter".
Passo 4: O código real.
Você pode usar o código fornecido abaixo e baixar o inteiro
código fonte abaixo.
Código para Importar Módulos
fromtkinterimport*
importar datetime
importar tempo

importwinsound
Enquanto o código a seguir importa todos os módulos que estão sendo
chamado ao executar o aplicativo.

Código Para O Módulo Hora Atual

defeituoso_tempo():
set_alarm_timer =f”{[Link]()}:{[Link]()}:{[Link]()}”
alarme(set_alarm_timer)
Este módulo é o tempo real ou o tempo atual que está sendo chamado
enquanto ajusta o alarme.

Código para o Módulo de Configuração do

Alarme
defalarme():
Laço Infinito
enquantoVerdadeiro:

# Set Alarm
set_alarm =f”{[Link]()}:{[Link]()}:
{[Link]()}”
Aguarde um segundo
[Link](1)
Obter a hora atual
current_time =
[Link]().strftime("%H:%M:%S")
Verifique se o alarme definido é igual à hora atual ou não
sehorário_atual == definir_alarme:
 Hora de Acordar
# Playing sound
[Link]("[Link]",winsound.SND_A
SINCRONIZAR)
Neste módulo, que é a configuração do alarme que é realizada.

Código Para A GUI

clock = Tk()
[Link](“DataFlair Alarm Clock”)
[Link]("400x200")
time_format=Label(clock, text=“Enter time in 24 hour
formato!
fg=“red”,bg=“black”,font=“Arial”).place(x=60,y=120)
addTime = Label(clock,text =“Hour Min
Sec
setYourAlarm = Label(clock,text =“When to wake you
para cima",fg="azul",alívio ="sólido",fonte=
(“Helevetica”,7,“bold”)).place(x=0, y=29)
# TheVariables we require to set the alarm(initialization):
hour = StringVar()
min= StringVar()
sec = StringVar()
Tempo necessário para configurar o despertador:

hourTime= Entry(clock,textvariable = hour,bg =“pink”,width

=15).lugar(x=110,y=30)
minTime= Entry(clock,textvariable =min,bg =“pink”,width =
15).colocar(x=150,y=30)
secTime = Entry(clock,textvariable = sec,bg =“pink”,width =
15).colocar(x=200,y=30)
Para receber a entrada de tempo pelo usuário:

submit = Button(clock,text =“Set Alarm”,fg=“red”,width =

10,comando = tempo_atual).colocar(x =110,y=70)
[Link]()
Execução da janela.
Este módulo é o design ou a interface gráfica do usuário ou
(GUI) deste projeto.

Código Fonte Completo do Alarme

Relógio Usando Python
# Importar Biblioteca Necessária

de tkinter import *
importar datetime
importar tempo

importwinsound
fromthreadingimport*
# Criar Objeto
root = Tk()
# Definir geometria

[Link]("400x200")
Use Threading
defThreading():
t1=Thread(target=alarm)
[Link]()
defalarm():
Laço Infinito
enquantoVerdadeiro:

Definir Alarme
set_alarm_time =f”{[Link]()}:{[Link]()}:
{[Link]()}
Espere um segundo
[Link](1)
 # Obter hora atual
current_time =
[Link]().strftime("%H:%M:%S")
imprimir(tempo_atual, definir_tempo_do_alarm)
Verifique se o alarme definido é igual ao horário atual ou não
se o_horário_atual == definir_hora_do_alarme:

Hora de acordar
Reproduzindo som
[Link]("[Link]", winsound.SND_A
SINCRONIZAR)
Adicionar Rótulos, Quadro, Botão, Menus de Opção

Label(root,text="Despertador",font=("Helvetica 20
bold"),fg="red").pack(pady=10)
Label(root,text="Definir Hora",font=("Helvetica 15 negrito")).pack()
frame = Frame(root)
[Link]()
hour = StringVar(root)
hours = (‘00’,‘01’,‘02’,‘03’,‘04’,‘05’,‘06’,‘07’,
‘08’,‘09’,‘10’,‘11’,‘12’,‘13’,‘14’,‘15’
‘16’,‘17’,‘18’,‘19’,‘20’,‘21’,‘22’,‘23’,‘24’
)
[Link](horas[0])
hrs = MenuDeOpções(frame, hora, *horas)
[Link](side=ESQUERDO)
minute = StringVar(root)
minutes = (‘00’,‘01’,‘02’,‘03’,‘04’,‘05’,‘06’,‘07’,
["08","09","10","11","12","13","14","15"]
‘16’,‘17’,‘18’,‘19’,‘20’,‘21’,‘22’,‘23’,
‘24’,‘25’,‘26’,‘27’,‘28’,‘29’,‘30’,‘31’,
 ‘32’,‘33’,‘34’,‘35’,‘36’,‘37’,‘38’,‘39’,
‘40’,‘41’,‘42’,‘43’,‘44’,‘45’,‘46’,‘47’,
‘48’,‘49’,‘50’,‘51’,‘52’,‘53’,‘54’,‘55’,
‘56’,‘57’,‘58’,‘59’,‘60’)
[Link](minutes[0])
mins = OptionMenu(frame, minute, *minutes)
[Link](side=ESQUERDA)
second = StringVar(root)
seconds = (‘00’,‘01’,‘02’,‘03’,‘04’,‘05’,‘06’,‘07’,
["08","09","10","11","12","13","14","15"]
‘16’,‘17’,‘18’,‘19’,‘20’,‘21’,‘22’,‘23’,
‘24’,‘25’,‘26’,‘27’,‘28’,‘29’,‘30’,‘31’,
‘32’,‘33’,‘34’,‘35’,‘36’,‘37’,‘38’,‘39’,
‘40’,‘41’,‘42’,‘43’,‘44’,‘45’,‘46’,‘47’,
‘48’,‘49’,‘50’,‘51’,‘52’,‘53’,‘54’,‘55’,
‘56’,‘57’,‘58’,‘59’,‘60’)
[Link](segundos[0])
secs = OptionMenu(frame, second, *seconds)
[Link](side=ESQUERDO)
Botão(root,text="Definir Alarme",fonte=("Helvetica
15"),comando=Threading).pack(pady=20)
# Executar Tkinter
[Link]()
Output:
Conclusão
O objetivo deste projeto, Despertador Usando Python, é
crie um despertador usando Python. Python contém algumas
bibliotecas essenciais como DateTime e Tkinter, que assistem
nós na construção de um projeto utilizando a data e hora atuais.
Eles também fornecem uma interface de usuário para configurar o alarme de acordo com
a demanda em um formato de 24 horas.
PARTE 31: Número
Jogo de Adivinhação em Python
Um jogo de adivinhação de números é um mini-projeto frequente para
programadores iniciantes que dominam a geração de números aleatórios
e declarações condicionais com iteração.
O jogo de adivinhação de números é baseado na noção do jogador de
estime um número entre o intervalo fornecido. Se o jogador
prevê o número desejado, o jogador ganha; caso contrário,
o jogador perde o jogo. Uma vez que este jogo tem esforços limitados, assim,
o jogador precisa indicar o número com
as tentativas limitadas. Caso contrário, o jogador perderá o jogo.
Neste tutorial, construiremos um jogo de adivinhação de números em
Python.

Number Guessing Game Rules

Você deve inserir apenas inteiros válidos dentro do
faixa fornecida.
[Link]ê terá tentativas limitadas para estimar o
número.
[Link]ê não pode sair do jogo uma vez iniciado.

Se o número de entrada for menor ou maior que

o número necessário, o jogador recebe a mensagem (dica) para
mova-se mais para cima ou para baixo.
Primeiro, produzimos um número aleatório dentro de um intervalo definido em
tal jogo. Pedimos ao usuário para estimar esse número. Se o
se o palpite estiver correto, informamos que o palpite está correto e quebramos
fora do loop. Caso contrário, especificamos se o número é menor ou
mais significativo do que o número real. Também pedimos ao usuário
para o total de palpites que eles estão autorizados a fazer. Quando o
o número de palpites supera isso, nós quebramos o loop.
O usuário pode fazer uso disso para saber o número real.
exemplo, se o usuário adivinhar que o número é 45 e o
o resultado é que o númerosexato é menor que 45, o usuário
pode inferir que o número não estará entre 45 e 100
(provided that the range is up to 100). (given that the content is
até 100). Dessa forma, o usuário pode continuar adivinhando e
interpretando o resultado. Publicamos o número de palpites
leva o usuário a obter a resposta corretamente.

Jogo de Adivinhação de Números

Implementação na Linguagem Python
importar aleatório

t =0
g = int(input("Total de Palpites: "))
baixo = int(input("Digite o limite inferior: "))
alto = int(input("Digite o limite superior: "))
x = [Link](inferior, superior)

n = int(input(“Digite um inteiro dentro do intervalo informado: “))

enquanto(x != 'n'):
se(t<(g-1)):
se n < x:
O número chutado é baixo
t=t+1
n = int(input("Digite um número inteiro entre os dados
range: “))
senão se(n > x):

O número adivinhado é alto

t=t+1
n = int(input("Digite um número inteiro entre o dado
range: “))
senão:
 O número adivinhado está certo
print("Total de tentativas feitas: ", t+1)
quebrar
senão:
Acabou as tentativas!
quebrar
Output:
Total Guesses: 5

Insira o limite inferior: 0

Insira o limite superior: 7

Insira um número inteiro dentro do intervalo dado: 5

O número adivinhado é baixo

Insira um inteiro dentro do intervalo dado: 6

O número adivinhado está certo

Total guesses taken: 2

Geramos o programa em Python 3. Aqui estão os

instructions for making a number guessing game inPython:
1. Inicialmente, pedimos ao usuário para escolher a faixa para
o número a ser criado. Um número inteiro aleatório é
criado usando a função randint() do
pacote inesperado.
2. Iniciamos uma variável com 0 para acompanhar o total
previsões feitas.
3. Executamos o loop while até que o número
o estimado não foi igual ao número real.
4. Usamos uma escada if-else para verificar se o
o número estimado é menor ou maior do que o real
number and increase the total guesses in each
iteração.
5. Nós saímos do loop quando a estimativa coincidiu
o número.
 6. Exibimos o total de palpites feitos quando o palpite
foi preciso.
Da mesma forma, replicando a lógica, podemos fazer este jogo em
Python 2 ou qualquer outra linguagem de computador.
PARTE 32: Jogo em Python :
Pedra, Papel, Tesoura
Programação de jogos é uma maneira divertida de aprender qualquer programação.

idioma. Neste tutorial, aprenderemos como codificar um simples

Jogo de Pedra, Papel e Tesoura.
Regras de vitória em Pedra, Papel e Tesoura são as seguintes:
Rock vs paper-> paper wins
Rock vs scissor-> Rock wins
paper vs scissor-> scissor wins.

Pedra, Papel e Tesoura Fonte

Código
Aqui está o código completo do projeto, que você pode executar e
veja como funciona.
Para fazer o código acima rodar repetidamente em um loop, adicione o
seguindo o código no final do loop while acima
código. O código abaixo perguntará ao usuário, após 1 jogo, se eles
quero jogar novamente, e se o usuário digitar 'y', então o jogo irá
reiniciar.
Você pode tentar este código no seu laptop localmente e jogar o jogo
de novo e de novo.
ch =input(“do you wish to continue(y/n)”)#choice for
loop contínuo
ifch==“y”:
player_choice=1
senão:
 quebrar
Para entender o fluxo, o código foi dividido em
seguindo conteúdos-

1. Atribua uma escolha ao computador

t = [“Rock”,“Paper”,“Scissors”]
#escolha aleatória para o computador

comp_choice = t[randint(0,2)]
Importe o módulo random para usar a função randint(). Nós atribuímos
uma opção de jogo para o computador. é uma lista de possíveis jogos
opções. randomint(0,2) gerará aleatoriamente um número de
o intervalo dado toda vez que é chamado. Pode dar 0, 1 ou 2
de acordo com nosso código.
comp_choice armazenará o valor como
t[0] = “Rock”
t[1]=“Paper”
t[2]=“Scissor”

2. Pegue a entrada do jogador

player_choice =input(“Chose Rock, Paper, Scissors?”)
Os jogadores deverão dar uma entrada de sua escolha

3. Usando o loop while para jogar múltiplos

rodadas
Dê uma olhada no corpo do enquanto
?
enquanto player_choice == 1:
#jogador escolhe sua opção
player_choice =input(“Chose Rock, Paper, Scissors?”)
comp_choice = t[randint(0,2)]
 se escolha_jogador == escolha_comp:
imprimir("Empate!")
imprimir(“Pontuação”)
imprimir("computador ganha:", computador_win)
print("jogador ganhou:", jogador_ganho)
elifplayer_choice == "Pedra":
secomp_escolha == “Papel”:
Você perdeu! O computador escolheu
“player chose”, player_choice)
computer_win+=1
imprimir(“Pontuação”)
print("computador ganha:", computador_win)
print("jogador ganhou:", jogador_ganhou)
senão:
Você ganhou! o jogador escolheu
“computer chose”, comp_choice)
player_win+=1
imprimir("Pontuação")
print("computador vence:", computador_win)
print("jogador ganhou:", jogador_ganhou)
elifplayer_choice == "Papel":
ifcomp_choice == "Tesouras":
você perdeu! o computador escolheu
"jogador escolheu", escolha_do_jogador)

computer_win+=1
imprimir(“Pontuação”)
print("computador ganha:", computador_win)
imprimir("jogador ganha:", jogador_ganha)
senão:
 Você ganhou! o jogador escolheu
“computer chose”, comp_choice)
player_win+=1
imprimir("Pontuação")
imprimir("computador venceu:", computador_vencedor)
imprimir("jogador vence:", jogador_vence)
elifplayer_choice == "Tesoura":
secompescolha == "Pedra":
você perde, o computador escolheu
“player chose”, player_choice)
computer_win+=1
print(“Pontuação”)
print("computador ganhou:", computador_win)
imprimir("jogador vence:", jogador_vence)
senão:
Você ganhou! O jogador escolheu
“computer chose”, comp_choice)
player_win+=1
print("Pontuação")
imprimir("computador ganhou:", computador_ganhou)
print(“jogador vence:”, jogador_victoria)
senão:
Isso não é uma jogada válida. Verifique sua ortografia!
print(””)
ch=input(“você deseja continuar(y/n)”)#escolha para
laço contínuo
ifch==“y”:
player_choice=1
senão:
 quebrar
Quando o loop começa, a escolha do jogador e a do computador
as escolhas são comparadas e quem vencer recebe um ponto.

4. Exibir Pontuação
computer_win=0
player_win=0
player_win e computer_win são inicializados em 0. Estes
as variáveis vão armazenar as pontuações.

5. Opção para jogar novamente ou sair

ch=input(“do you wish to continue(y/n)”)#choice for
loop contínuo
ifch=="y":
player_choice=1
comp_choice = t[randint(0,2)]
senão:
quebrar
Player is given the choice to continue or leave. Player’s choice
está armazenado em uma variável ch. Se for 'y', então player_choice é definido como
1 para continuar o loop, caso contrário, o controle executa break
e sai do loop.

Output-
Aqui jogamos quatro rodadas com o computador. Depois
Em cada rodada, as pontuações são impressas para o jogador e o computador.

Escolheu Pedra, Papel, Tesoura? Pedra

Empate!

Score

computer win: 0

player win: 0
você deseja continuar (s/n) s

Escolheu Pedra, Papel, Tesoura? Papel

Você perde! O computador escolheu Tesoura, o jogador escolheu Papel

Score

computer win: 1

player win: 0

deseja continuar (s/n) s

Escolheu Pedra, Papel ou Tesoura? Papel

Empate!

Pontuação

computer win: 1

player win: 0

você deseja continuar (s/n) s

Escolheu Pedra, Papel, Tesoura? Tesoura

Você ganhou! O jogador escolheu Tesoura, o computador escolheu Papel.

Score

computer win: 1

player win: 1

você deseja continuar (s/n) n

PARTE 33: Notificador de Desktop
Projeto de Aplicação Python
Você já tentou projetar uma notificação de desktop?
programa que atende às suas necessidades específicas? Você consegue
Saiba que você pode fazer isso usando Python em apenas alguns passos?
Não se preocupe, vamos começar do começo; neste post, nós vamos
crie um aplicativo de notificação para desktop para rastrear o
estatísticas diárias do coronavírus.

O Que Você Descobrirá Neste Artigo

Instalando os pacotes Python que são necessários.
Obtendo informações sobre coronavírus pela internet.
Criando um programa de notificação de desktop.
Fazer seu software rodar em segundo plano é uma
uma ótima maneira de economizar tempo.

Vamos em frente.
Precisamos obter dois pacotes vitais de python para isso
aplicação ao instalar pacotes python necessários.
Nota: Se você estiver usando o Windows, execute essas duas instruções
no prompt de comando; se você estiver usando Linux, digite-os
o terminal (para buscar dados da web)
pip install requests

pip install plyer

Podemos obter dados sobre coronavírus da web utilizando a URL
fornecido abaixo; você é livre para substituir o nome da nação por
o seu próprio, mas estaremos utilizando os dados sobre coronavírus da Índia para
este aplicativo.
[Link]

Agora que temos todas as ferramentas necessárias para construir isso

aplicativo, vamos começar a codificá-lo.
Nota: Será mais fácil se você codificar isso em um compilador offline
em vez de compilador online porque estaremos fazendo isso
aplicativo executado como um processo em segundo plano no seu PC mais tarde
etapas deste artigo; se você codificar em um compilador online, você irá
preciso baixar o arquivo, que não é necessário offline
compilador. Eu recomendo que você use o Visual Studio.

Passo 1: Importando Bibliotecas

import datetime #para ler a data atual
importar tempo
import requests #para recuperar dados sobre coronavírus da web
do plyer import notification #para receber notificações no seu
PC

Passo 2: Recuperando os Dados De

Web
deixe que não haja dados inicialmente
covidData = None
tente:
covidData = [Link](“[Link]
[Link]/Api/índia
exceto:
se os dados não forem buscados devido à falta de internet
Por favor! Verifique sua conexão com a internet

Passo 3: Criando Notificação Personalizada

se nós buscássemos dados

se (covidData != Nenhum):
#converting data into JSON format
data = [Link]()[‘Success’]
#repeating the loop for multiple times
enquanto(True):
notificaçã[Link](
#title of the notification,
title = “COVID19 Stats on
{}”.format([Link]()),
#the body of the notification
message = “Total cases : {totalcases}\nToday cases :
{todaycases}\nToday deaths :{todaydeaths}\nTotal active :
{ativo}
totalcases = data[‘cases’],
todaycases = data[‘todayCases’],
todaydeaths = data[‘todayDeaths’],
active = data[“active”]),
#creating icon for the notification
#we need to download a icon of ico file format
app_icon = “[Link]”,
a notificação permanece por 50 segundos
timeout = 50
)
# dormir por 4 hrs => 60*60*4 seg
#notificação se repete a cada 4 horas
[Link](60*60*4)
É isso; estamos prontos para lançar nosso programa. Antes de fazermos,
no entanto, você deve estar ciente de vários ajustes que pode
ajuste seu aplicativo às suas necessidades específicas.
timeout— specifies how long a notice should appear on the
[Link] ()— especifica o período de tempo após o qual o
um aviso deve aparecer.
Depois de executar seu aplicativo, é assim que você receberá seu
aviso.
Fazer seu aplicativo operar em segundo plano é ótimo
maneira de economizar tempo.

Código Fonte para Notificador de Área de Trabalho

Aplicativo
importar data #para ler a data atual
importar tempo
importar solicitações # para recuperar dados sobre coronavírus da web

from plyer import notification # para receber notificações no seu

PC
Deixe que não haja dados inicialmente
covidData =None
tente:
covidData = [Link](“[Link]
[Link]/Api/índia
exceto:
#if the data is not fetched due to lack of internet
Por favor! Verifique sua conexão com a internet
se nós buscássemos dados

se(covidData !=Nenhum):
#converting data into JSON format
data = [Link]()[‘Success’]
repetindo o loop várias vezes
enquanto(True):
[Link](
 #title of the notification,
title =“COVID19 Stats on
{}”.format([Link]()),
#the body of the notification
message =“Total cases : {totalcases}\nToday cases :
Casos hoje: {todaycases} Mortes hoje: {todaydeaths} Total ativo:
{active}”.format(
totalcases = data[‘cases’],
todaycases = data[‘todayCases’],
todaydeaths = data[‘todayDeaths’],
active = data[“active”]),
criando ícone para a notificação
nós precisamos baixar um ícone no formato de arquivo ico

app_icon =“[Link]”,
a notificação permanece por 50 segundos
timeout = 50
)
#dormir por 4 hrs => 60*60*4 seg
A notificação se repete a cada 4 horas
[Link](60*60*4)

Output:

Qual é a melhor maneira de fazer um programa Python rodar em um

fundo?
Basta executar este comando no prompt de comando em
Windows ou terminal no Linux para fazer seu programa operar em
o fundo. Note que você deve digitar este comando em
prompt de comando no Windows e terminal no Linux.
Nota: <seu-nome-de-arquivo-aqui> deve ser substituído por
[Link]-nome-de-arquivo-aqui>
[Link] .\<seu-nome-de-arquivo-aqui>
exemplo
[Link] .\[Link]
É só isso; seu programa agora funcionará em
fundo.

Como posso desativar as notificações?

É tão fácil quanto matar o processo python no Gerenciador de Tarefas. Se
você tem algum problema em parar o aviso, por favor compartilhe seu
experiência na área de comentários desta página. Há um
variedade de outras situações em que você pode usar esta estratégia.
Todos os dias, você será lembrado de tomar seu
medicação.
A necessidade de beber água é lembrada a cada hora.
e muitos outros; como você utiliza este programa depende totalmente de você
você.

Conclusão
Este programa é compatível com qualquer sistema operacional,
incluindo Windows, Linux e Mac. Sinta-se à vontade para perguntar em
a área de comentários deste post se você deseja uma área de trabalho mais simples
programa de notificação.