Aprenda como criar um conversor de moedas com Python que realiza a conversão de forma automática e em tempo real, em apenas 3 aulas!
Esta será uma série de 3 aulas em que você criará um projeto de conversor de Moedas com Python. Vou te mostrar como criar as telas e os elementos visuais do aplicativo, assim como toda a inteligência e o código por trás dele.
Partindo do zero, você desenvolverá um conversor de moeda que seleciona uma moeda e a converte para uma segunda moeda automaticamente e em tempo real.
Vamos dar início à nossa série do Projeto Conversor de Moedas com Python, onde você aprenderá a criar um sistema capaz de converter os valores das moedas de forma instantânea e automática.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na primeira aula da nossa série, vou te mostrar como criar telas com Python utilizando a biblioteca CustomTkinter.
Com essa biblioteca, vamos construir nossa tela e os elementos nela presentes, fazendo os ajustes e configurações necessárias em cada um para torná-los visualmente atrativos e intuitivos para o usuário final.
Vou te mostrar o passo a passo, desde a construção da janela até a personalização dos elementos. Então, faça o download do material disponível e venha comigo dar início ao seu Projeto Conversor de Moedas com Python.
A janela do nosso sistema de conversão de moedas terá as dimensões de 500×500 pixels e será intitulada Conversor de Moedas.
Dentro dela, teremos os campos para seleção das moedas, com rótulos indicando a moeda de origem e a moeda de destino. Esses campos são listas de valores que conterão os tipos de moedas disponíveis para conversão.
Por fim, teremos o botão para a conversão e um campo listando todas as moedas disponíveis com seus nomes.
Para construir essa tela, podemos utilizar diferentes ferramentas de interface visual do Python. Ao longo deste projeto, eu optei por utilizar o CustomTkinter.
O CustomTkinter é uma versão mais completa e estilizada do Tkinter, que já vem instalado por padrão no Python. Essa biblioteca oferece janelas e opções de estilização visualmente mais atrativas.
Ele possui a mesma estrutura e funcionamento que o Tkinter padrão do Python. Ou seja, criamos uma janela, definimos os elementos e vinculamos os elementos à janela.
Se você já teve alguma experiência ou programou com o Tkinter, verá que as duas bibliotecas são bastante semelhantes.
O primeiro passo é instalarmos o CustomTkinter. Então, dentro do terminal do editor de códigos que você estiver utilizando, execute o comando:
pip install customtkinter
Feito isso, vamos importá-lo para o nosso código.
import customtkinterCom o CustomTkinter instalado e importado, podemos criar nossa janela utilizando o seguinte comando:
import customtkinter
# criar e configurar a janela
janela = customtkinter.CTk()Em seguida, podemos definir o tamanho da janela utilizando o método geometry, onde passamos uma string contendo a largura e a altura dela.
import customtkinter
# criar e configurar a janela
janela = customtkinter.CTk()
janela.geometry("500x500")Para executar a nossa janela, utilizaremos o método mainloop, que garante que a janela do aplicativo permaneça aberta e funcional até que o usuário a feche manualmente, interrompendo a execução do código.
import customtkinter
# criar e configurar a janela
janela = customtkinter.CTk()
janela.geometry("500x500")
# rodar a janela
janela.mainloop()Antes de criar a janela, podemos definir sua aparência, escolhendo o tema e as cores que queremos utilizar, através das funções set_appearance_mode() e set_default_color_theme().
import customtkinter
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
# rodar a janela
janela.mainloop()Você pode conferir outros temas e cores na documentação do CustomTkinter.
A vantagem de utilizar essas funções para alterar a aparência e o tema da nossa janela é que os elementos adicionados a ela seguirão esse padrão de cores.
Você pode optar por definir individualmente a cor e o tema de cada um dos elementos, ou escolher essa abordagem que já padroniza as cores para você seguindo um tema específico.
Ao executar esse código, já conseguimos visualizar nossa janela, que por enquanto está sem nenhum elemento dentro dela.
Portanto, nossos próximos passos serão criar os elementos da nossa janela.
O CustomTkinter nos permite criar diversos elementos, como botões, canvas, checkbox, combobox, labels e muito mais.
Cada elemento criado dentro do CustomTkinter precisa ser associado a uma janela específica. Essa associação é fundamental quando trabalhamos com sistemas de múltiplas janelas, garantindo o posicionamento dos elementos.
Vincular um elemento a uma janela não o exibe visualmente, mas faz com que, ao editarmos a janela, esse elemento também seja impactado pelas mudanças.
Para posicionar e exibir o elemento na tela, utilizaremos o método pack().
Os primeiros elementos que adicionaremos à nossa janela serão os rótulos de texto, CtkLabel(). Vamos utilizar esses rótulos para definir o título da janela, o rótulo da moeda de origem e o rótulo da moeda de destino.
Ao criar um rótulo no CustomTkinter, sempre precisaremos passar dois parâmetros: a janela onde ele estará e o texto que ele deve exibir. Além disso, podemos definir parâmetros opcionais, como o font, que nos permite definir a família e o tamanho da fonte.
import customtkinter
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
# rodar a janela
janela.mainloop()Para exibir esses elementos na tela, vamos utilizar o método pack(), passando os parâmetros padx e pady para definir o espaçamento horizontal (x) e vertical (y) entre eles.
import customtkinter
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
texto_moeda_destino.pack(padx=10, pady=10)
# rodar a janela
janela.mainloop()
Perceba que o método pack() dispõe os elementos na tela na ordem em que os declaramos dentro do código, então primeiro ele adiciona o título, abaixo dele o rótulo da moeda de origem, e em sequência o da moeda de destino.
Com os rótulos adicionados, podemos inserir os campos para selecionar as moedas. Esses campos são o CTkOptionMenu(), e criaremos um para a moeda de origem e outro para a moeda de destino.
Para eles, precisamos definir a janela em que estão vinculados e o parâmetro values, em que passamos uma lista de valores que podem ser selecionados pelo usuário.
Nessa aula, definiremos esses valores manualmente, mas nas próximas aulas extrairemos esses valores a partir de uma API.
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])Com os campos definidos, vamos posicioná-los dentro da nossa janela utilizando o método pack(). Lembre-se de respeitar a ordem que você quer que os elementos sejam exibidos na tela.
import customtkinter
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
# rodar a janela
janela.mainloop()A tela do nosso aplicativo já está começando a tomar forma e a se assemelhar ao resultado final do projeto.
Agora falta adicionarmos o botão de conversão dentro da nossa janela e a lista com as moedas disponíveis e os nomes delas.
Vamos começar pelo botão, que será um CTkButton(). Ele receberá como parâmetros a janela em que está vinculado, o texto (text) que será exibido nele e qual função (command) será executada ao ser clicado.
A função chamada precisa ser definida antes do botão, então iremos criar uma função chamada converter_moeda, que por enquanto só executará um print na tela escrito “Converter moeda”.
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
def converter_moeda():
print("Converter moeda")
botao_converter = customtkinter.CTkButton(janela, text="Converter", command=converter_moeda)Com o botão criado, podemos adicioná-lo na tela.
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)Podemos executar nosso aplicativo e testar o botão criado.
Perceba que ao clicar no botão Converter, o texto “Converter moeda” é exibido no terminal.
Por fim, vamos criar a lista com os nomes completos das moedas. Esse elemento será um CTkScrollableFrame(), uma janela em que, dentro dela, teremos rótulos com os nomes das moedas.
O CTkScrollableFrame() só precisa receber como parâmetro a janela que ele será vinculado. Feito isso, podemos adicioná-lo à janela.
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
def converter_moeda():
print("Converter moeda")
botao_converter = customtkinter.CTkButton(janela, text="Converter", command=converter_moeda)
lista_moedas = customtkinter.CTkScrollableFrame(janela)
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)
lista_moedas.pack(padx=10, pady=10)Para adicionar elementos dentro da janela do ScrollableFrame, o procedimento é semelhante ao adicionar elementos dentro da janela principal. Criamos o elemento e, ao invés de vincularmos à janela principal, vinculamos à janela do ScrollableFrame.
Como queremos adicionar os nomes das moedas disponíveis, podemos criar uma lista com os nomes delas e executar um loop for percorrendo cada uma. Para cada moeda, adicionaremos o rótulo correspondente ao ScrollableFrame.
Além de criar o rótulo para cada moeda presente na lista, precisamos também adicioná-las ao ScrollableFrame utilizando o método pack().
import customtkinter
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
def converter_moeda():
print("Converter moeda")
botao_converter = customtkinter.CTkButton(janela, text="Converter", command=converter_moeda)
lista_moedas = customtkinter.CTkScrollableFrame(janela)
moedas_disponiveis = ["USD: Dólar americano", "BRL: Real brasileiro", "EUR: Euro", "BTC: Bitcoin"]
for moeda in moedas_disponiveis:
texto_moeda = customtkinter.CTkLabel(lista_moedas, text=moeda)
texto_moeda.pack()
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)
lista_moedas.pack(padx=10, pady=10)
# rodar a janela
janela.mainloop()Como o foco dessa aula é a criação da tela, os nomes das moedas foram definidos manualmente. Nas próximas aulas, iremos obtê-los automaticamente.
Com isso, temos a tela do nosso conversor de moedas com Python criada. Nas próximas aulas, veremos como implementar o código responsável pela conversão dos valores.
Vamos para a segunda aula da nossa série do Projeto Conversor de Moedas com Python! Nessa aula, eu vou te mostrar como ler arquivos XML com Python para complementar nosso projeto e alimentar as informações que o usuário pode consultar.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na segunda aula da nossa série do Projeto Conversor de Moedas com Python, eu vou te mostrar como carregar e ler arquivos XML usando Python!
Isso será muito importante para alimentar e complementar o projeto com mais informações e mais moedas, permitindo que o usuário escolha e consulte as moedas de interesse.
Para isso, vamos utilizar a biblioteca xmltodict, que transformará o arquivo XML em um dicionário Python, facilitando muito o trabalho e a manipulação dessas informações.
Depois disso, vou te mostrar como tratar esses arquivos para extrair apenas as informações necessárias e, por fim, atualizaremos os botões do nosso projeto para que o usuário possa selecionar a moeda de origem e receber a conversão na moeda destino.
Então, faça o download do material disponível e vem comigo continuar o nosso Projeto em Python!
Para começar essa aula, criaremos um novo arquivo Python chamado pegar_moedas.py. Será dentro desse arquivo que desenvolveremos nosso sistema, e é nele que faremos o tratamento e a leitura dos arquivos XML.
Existem diversos pacotes e bibliotecas Python capazes de trabalhar com arquivos XML, mas uma que eu gosto e recomendo muito é a xmltodict. Essa biblioteca transforma arquivos XML em um dicionário Python.
Os arquivos XML possuem uma estrutura semelhante à dos arquivos HTML, com segmentações definidas por tags. Isso porque o XML é também uma linguagem de marcação.
As tags desse arquivo XML representam as siglas das moedas, e dentro delas temos os nomes correspondentes escritos por extenso.
No caso desse exemplo, esse arquivo possui apenas um nível, o nível <xml>, e as moedas estão dentro dele. Mas é possível encontrarmos arquivos XML com múltiplos níveis, com uma estrutura semelhante a dicionários Python aninhados.
E é assim que a biblioteca xmltodict funciona: ela pega essa estrutura dos arquivos XML e a converte para a estrutura de um dicionário aninhado em Python. Então, se você já trabalhou com dicionários Python, você conseguirá trabalhar com arquivos XML.
Nosso primeiro passo será instalar essa biblioteca. Então, abra o terminal do seu editor e digite o comando pip install xmltodict.
Não se esqueça de baixar o material disponível nessa aula, onde se encontram os arquivos XML com os quais iremos trabalhar.
Esses arquivos foram obtidos através do site do Awesome API, a API que utilizaremos no nosso conversor de moedas. Dentro da documentação dessa API, temos um arquivo XML com as combinações possíveis de conversão e outro com a lista total de moedas.
Com os arquivos salvos em seu computador, vamos começar a trabalhar com eles e entender como tratá-los.
Primeiro vamos impotar a biblioteca xmltodict e utilizar a função open do Python dentro da estrutura with para abrir o arquivo moedas.xml.
Feito isso, vamos usar a função parse da biblioteca xmltodict para decodificar esse arquivo em um dicionário Python, que será armazenado na variável dic_moedas.
import xmltodict
with open("moedas.xml", "rb") as arquivo_moedas:
dic_moedas = xmltodict.parse(arquivo_moedas)Vamos printar esse dicionário para ver como podemos tratá-lo.
import xmltodict
with open("moedas.xml", "rb") as arquivo_moedas:
dic_moedas = xmltodict.parse(arquivo_moedas)
print(dic_moedas)
Nosso dic_moedas é um dicionário em que a primeira chave é xml e o valor é um segundo dicionário, em que cada chave é a sigla da moeda e o valor é o nome por extenso dela.
Ou seja, se quisermos pegar apenas o dicionário com as informações das moedas, podemos acessá-lo através da chave xml. Então, podemos armazenar o dic_moedas[“xml”] em uma nova variável e printar o resultado.
![dic_moedas["xml"]](https://www.hashtagtreinamentos.com/wp-content/uploads/2024/05/Conversor-de-Moedas-com-Python-4-1.png "🪙 Projeto Conversor de Moedas com Python 11")
Agora teremos apenas um dicionário em que cada chave é a sigla das moedas e o valor é o nome delas.
Podemos fazer o mesmo procedimento para o segundo arquivo XML, conversoes.xml.
import xmltodict
with open("conversoes.xml", "rb") as arquivo_conversoes:
dic_conversoes = xmltodict.parse(arquivo_conversoes)
print(dic_conversoes)
Perceba que temos um dicionário semelhante ao do exemplo anterior, em que a primeira chave é xml e o valor é um dicionário que contém as siglas das moedas de origem e destino da conversão e o nome delas por extenso.
Para pegarmos apenas o segundo dicionário, podemos acessá-lo pela chave xml, assim como fizemos para as moedas.
import xmltodict
with open("conversoes.xml", "rb") as arquivo_conversoes:
dic_conversoes = xmltodict.parse(arquivo_conversoes)
conversoes = dic_conversoes["xml"]
print(conversoes)
Vale ressaltar que as estruturas desses dois arquivos são similares porque os obtivemos da mesma fonte. A estrutura do arquivo XML pode variar de acordo com a fonte e a quantidade de informações contidas nele.
Agora faremos as adaptações necessárias para o nosso projeto. Na aula passada, construímos a parte visual, a janela do nosso conversor de moedas.
Nessa janela, temos uma lista com as moedas de origem e de destino, e uma lista com os nomes das moedas por extenso. Na aula anterior, definimos todas essas informações manualmente, mas agora utilizaremos nossos arquivos XML.
Com eles, conseguiremos inserir muito mais informações para o usuário utilizar de forma rápida e automática.
Vamos encapsular nosso primeiro código em uma função chamada nomes_moedas, que irá retornar o dicionário moedas, com as siglas e os nomes por extenso de todas as moedas disponíveis.
import xmltodict
def nomes_moedas():
with open("moedas.xml", "rb") as arquivo_moedas:
dic_moedas = xmltodict.parse(arquivo_moedas)
moedas = dic_moedas["xml"]
return moedasCom essa função pronta, podemos importá-la dentro do nosso arquivo principal, onde criamos a tela do nosso conversor.
import customtkinter
from pegar_moedas import nomes_moedasEntão, na hora de gerar a lista de moedas disponíveis, ao invés de declararmos os nomes das moedas manualmente, vamos pegar o resultado da função nomes_moedas.
moedas_disponiveis = nomes_moedas()Além disso, vamos modificar a estrutura do nosso for, pois agora estamos percorrendo um dicionário Python, e queremos que nossa lista exiba tanto o código da moeda (chave do dicionário) quanto o nome por extenso (valor do dicionário).
Para isso, passaremos para o parâmetro text,do CTkLabel uma f-string contendo as variáveis codigo_moeda e nome_moeda.
import customtkinter
from pegar_moedas import nomes_moedas
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["USD", "BRL", "EUR", "BTC"])
def converter_moeda():
print("Converter moeda")
botao_converter = customtkinter.CTkButton(janela, text="Converter", command=converter_moeda)
lista_moedas = customtkinter.CTkScrollableFrame(janela)
moedas_disponiveis = nomes_moedas()
for codigo_moeda in moedas_disponiveis:
nome_moeda = moedas_disponiveis[codigo_moeda]
texto_moeda = customtkinter.CTkLabel(lista_moedas, text=f"{codigo_moeda}: {nome_moeda}")
texto_moeda.pack()
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)
lista_moedas.pack(padx=10, pady=10)
# rodar a janela
janela.mainloop()Executando nosso código, veremos que nossa lista de moedas estará completa agora, com todos os códigos e nomes das moedas disponíveis na API.
Agora só falta ajustarmos as listas de moeda de origem e moeda de destino. Para isso, vamos encapsular a segunda parte do nosso código em uma função chamada conversoes_disponiveis().
Dentro dessa função, teremos o dicionário de conversões disponíveis que, como vimos, é composto pelos códigos das moedas de origem e destino como chave do dicionário, e os nomes delas por extenso como valor.
Na seleção de moeda de origem e moeda de destino do nosso Conversor de Moedas com Python, estamos utilizando apenas o código de cada moeda.
Então, ao invés dessa função retornar todo o dicionário, vamos pegar apenas a chave dele e separar o código da moeda de origem do código da moeda de destino.
Ou seja, de um par chave e valor como esse ‘USD-BRL’: ‘Dólar Americano/Real Brasileiro’, vamos pegar apenas o ‘USD-BRL’ e dividir esse código em ‘USD’ e ‘BRL’. Faremos isso através do método split no Python, passando o hífen como delimitador.
def conversoes_disponiveis():
with open("conversoes.xml", "rb") as arquivo_conversoes:
dic_conversoes = xmltodict.parse(arquivo_conversoes)
conversoes = dic_conversoes["xml"]
for par_conversao in conversoes:
moeda_origem, moeda_destino = par_conversao.split("-")A partir disso, podemos criar um dicionário chamado dic_conversoes_disponiveis, em que cada chave representa a moeda_origem e o valor será uma lista com todas as variáveis moeda_destino possíveis para aquela moeda_origem.
Para fazer isso, vamos inicializar esse dicionário fora do nosso for. Dentro do for, vamos verificar se a moeda_origem já foi cadastrada dentro do dicionário dic_conversoes_disponiveis.
Em caso positivo, vamos apenas adicionar (append) um item a essa lista de moedas destino. Caso contrário, criaremos uma lista com a primeira moeda_destino que aparecer para aquela moeda_origem.
Ao final, nossa função retornará o dic_conversoes_disponiveis.
def conversoes_disponiveis():
with open("conversoes.xml", "rb") as arquivo_conversoes:
dic_conversoes = xmltodict.parse(arquivo_conversoes)
conversoes = dic_conversoes["xml"]
dic_conversoes_disponiveis = {}
for par_conversao in conversoes:
moeda_origem, moeda_destino = par_conversao.split("-")
if moeda_origem in dic_conversoes_disponiveis:
dic_conversoes_disponiveis[moeda_origem].append(moeda_destino)
else:
dic_conversoes_disponiveis[moeda_origem] = [moeda_destino]
return dic_conversoes_disponiveisAgora podemos importar essa função para dentro do código do nosso conversor.
import customtkinter
from pegar_moedas import nomes_moedas, conversoes_disponiveisDentro do nosso código vamos gerar esse dicionário de conversões disponíveis chamando a função conversoes_disponiveis,
dic_conversoes_disponiveis = conversoes_disponiveis()Feito isso, passaremos como parâmetro values da classe CTkOptionMenu do campo_moeda_origem uma lista com todas as chaves do nosso dicionário dic_conversoes_disponiveis.
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=list(dic_conversoes_disponiveis.keys()))Se executarmos todo o nosso código, veremos que já temos os códigos das moedas de origem sendo exibidos uma única vez dentro do campo de seleção.
Para o campo da moeda de destino, faremos uma abordagem diferente. O nosso campo_moeda_origem é um botão OptionMenu. Para esse botão, podemos definir o parâmetro command.
Esse parâmetro permite definirmos uma função que será executada de acordo com o que o usuário selecionar dentro do campo de moeda de origem.
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=list(dic_conversoes_disponiveis.keys()), command=carregar_moedas_destino)Então, antes do campo_moeda_origem, vamos definir a função carregar_moedas_destino. Essa função recebe como parâmetro a moeda_selecionada, que será a moeda que o usuário marcou no campo de origem.
Dentro dela, criaremos a lista_moedas_destino a partir do dicionário dic_conversoes_disponiveis, passando como chave a moeda_selecionada.
Além disso, todo elemento do Custom Tkinter pode ser personalizado através do método configure. Dessa forma, podemos alterar o parâmetro values do campo_moeda_destino através dessa função.
Por fim, para substituir o valor inicial do campo_moeda_destino para o primeiro item da lista_moedas_destino, podemos utilizar o método set.
def carregar_moedas_destino(moeda_selecionada):
lista_moedas_destino = dic_conversoes_disponiveis[moeda_selecionada]
campo_moeda_destino.configure(values=lista_moedas_destino)
campo_moeda_destino.set(lista_moedas_destino[0])Para finalizar, vamos alterar o campo values presente no OptionMenu do campo_moeda_destino para inicializar com a frase “Selecione uma moeda de origem”.
Assim, as moedas destino só serão carregadas e exibidas depois que uma moeda de origem for escolhida.
import customtkinter
from pegar_moedas import nomes_moedas, conversoes_disponiveis
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
dic_conversoes_disponiveis = conversoes_disponiveis()
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
def carregar_moedas_destino(moeda_selecionada):
lista_moedas_destino = dic_conversoes_disponiveis[moeda_selecionada]
campo_moeda_destino.configure(values=lista_moedas_destino)
campo_moeda_destino.set(lista_moedas_destino[0])
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=list(dic_conversoes_disponiveis.keys()), command=carregar_moedas_destino)
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["Selecione uma moeda de origem"])
def converter_moeda():
print("Converter moeda")
botao_converter = customtkinter.CTkButton(janela, text="Converter", command=converter_moeda)
lista_moedas = customtkinter.CTkScrollableFrame(janela)
moedas_disponiveis = nomes_moedas()
for codigo_moeda in moedas_disponiveis:
nome_moeda = moedas_disponiveis[codigo_moeda]
texto_moeda = customtkinter.CTkLabel(lista_moedas, text=f"{codigo_moeda}: {nome_moeda}")
texto_moeda.pack()
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)
lista_moedas.pack(padx=10, pady=10)
# rodar a janela
janela.mainloop()Executando nosso conversor, teremos todas as moedas de origem e, de acordo com a moeda de origem escolhida, teremos as moedas destino disponíveis.
Chegamos à nossa última aula da série do Projeto Conversor de Moedas com Python! Nesta aula, eu vou te mostrar como consumir APIs com Python e pegar a cotação de moedas para fazermos a conversão necessária.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na terceira e última aula da nossa série do Projeto Conversor de Moedas com Python, eu vou te ensinar como consumir APIs com Python para que possamos finalizar o nosso projeto!
Você aprenderá como utilizar a biblioteca Requests para fazer requisições para a API do Awesome API, verá como tratar as informações recebidas e como retorná-las para o usuário final.
Assim, concluiremos o nosso projeto com o usuário conseguindo selecionar a moeda de origem e destino e obtendo o valor da cotação de acordo com a seleção feita. Tudo isso de forma automática e com informações atualizadas em tempo real!
Então, vem comigo e vamos finalizar nosso conversor de moedas com Python!
Como vimos na aula anterior, a API que utilizaremos para este projeto será a Awesome API. Ela fornece a cotação atualizada a cada 30 segundos, é gratuita e não exige nem mesmo a criação de conta para utilizá-la.
Quando trabalhamos com APIs, é comum enviarmos e recebermos informações que serão utilizadas no projeto que estamos desenvolvendo. Para isso, precisamos fazer o que chamamos de requisições.
Para fazer uma requisição em Python, usamos a biblioteca Requests. Essa biblioteca é responsável por comunicar nosso programa com a API que iremos consumir para obter as informações sobre a cotação das moedas.
Vamos começar criando um arquivo Python chamado pegar_cotacao.py. Será dentro desse arquivo que desenvolveremos o código que fará a requisição para a API.
Com o arquivo criado, o próximo passo será instalar a biblioteca Requests. Abra o terminal do seu editor de código e digite o comando: pip install requests.
Feito isso, a biblioteca estará pronta para ser utilizada.
Como nosso objetivo é obter informações sobre a cotação de moedas a partir de uma API, precisaremos fazer uma requisição do tipo GET.
Então, dentro do arquivo pegar_cotacao.py, importaremos a biblioteca Requests.
import requestsEm seguida, criaremos a nossa requisição utilizando a função get. Essa função recebe como argumento uma URL (link) com o caminho que desejamos acessar da API para puxar as informações que iremos utilizar.
Vamos usar como exemplo o link que traz a cotação do dólar em relação ao real brasileiro, obtido na documentação da Awesome API.
O resultado dessa requisição ficará armazenado na variável requisicao, que printaremos para poder visualizar e compreender melhor o que estamos obtendo como resposta do nosso pedido.
import requests
link = "https://economia.awesomeapi.com.br/last/USD-BRL"
requisicao = requests.get(link)
print(requisicao)Executando nosso código, teremos como resposta o código abaixo:
Esse é um código de Status HTTP, e o código 200 indica uma resposta bem-sucedida. Ou seja, nossa requisição foi feita para o servidor e funcionou corretamente.
Além disso, se verificarmos a documentação da Awesome API, veremos que, além do código de resposta, nossa variável requisicao também armazena um dicionário JSON com as informações a respeito das moedas.
Podemos visualizar esse dicionário printando a nossa requisição junto do método .json().
A estrutura do JSON é a mesma de um dicionário Python aninhado, em que a chave é composta pela sigla da moeda de origem concatenada com a sigla da moeda destino, e o valor é um segundo dicionário com as informações da conversão.
Para pegarmos apenas o valor da cotação, precisaremos acessar a chave bid do segundo dicionário.
import requests
link = "https://economia.awesomeapi.com.br/last/USD-BRL"
requisicao = requests.get(link)
print(requisicao.json()["USDBRL"]["bid"])
Agora que compreendemos como funciona a requisição e como acessamos a cotação da moeda dentro do dicionário JSON que recebemos como resposta, podemos adaptar o nosso código para pegarmos a cotação de qualquer moeda.
Para isso, será necessário utilizarmos variáveis que armazenarão as moedas de origem e de destino, e substituir o nosso link e a chave do dicionário por f-strings.
import requests
moeda_origem = "USD"
moeda_destino = "BRL"
link = f"https://economia.awesomeapi.com.br/last/{moeda_origem}-{moeda_destino}"
requisicao = requests.get(link)
print(requisicao.json()[f"{moeda_origem}{moeda_destino}"]["bid"])Com isso, é possível acessarmos a cotação de qualquer moeda, pois tanto o link de acesso quanto a chave do dicionário serão alteradas dinamicamente de acordo com as variáveis moeda_origem e moeda_destino.
Nosso próximo passo será pegar todo esse código que acabamos de criar e transformá-lo em uma função que poderá ser integrada ao nosso projeto.
Essa função será chamada de pegar_cotacao_moeda e receberá como parâmetros a moeda de origem e a moeda de destino. A partir disso, ela fará a requisição para o link correspondente e retornará o valor contido na chave bid do dicionário resposta.
import requests
def pegar_cotacao_moeda(moeda_origem, moeda_destino):
link = f"https://economia.awesomeapi.com.br/last/{moeda_origem}-{moeda_destino}"
requisicao = requests.get(link)
cotacao = requisicao.json()[f"{moeda_origem}{moeda_destino}"]["bid"]
return cotacaoom a função pronta, vamos retornar para o nosso arquivo main.py e definir um novo rótulo de texto (CTkLabel), que exibirá a informação sobre a cotação obtida. Por padrão, ele começará vazio.
texto_cotacao_moeda = customtkinter.CTkLabel(janela, text="")Em seguida, para que ele seja exibido na tela, vamos utilizar o método pack(). Lembrando que esse método dispõe os elementos na tela na ordem em que os declaramos dentro do código.
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)
texto_cotacao_moeda.pack(padx=10, pady=10)
lista_moedas.pack(padx=10, pady=10)Com o campo texto_cotacao_moeda criado e posicionado na janela do aplicativo, podemos partir para a etapa final do nosso projeto, que é integrar a função pegar_cotacao_moeda ao projeto e modificar a função converter_moeda.
O primeiro passo será importar a função pegar_cotacao_moeda para o arquivo main.py.
from pegar_cotacao import pegar_cotacao_moedaFeito isso, vamos modificar a função converter_moeda, que é chamada quando o usuário clica no botão Converter e que, até o momento, apenas printava o texto “Converter Moeda”.
Dentro dessa função, primeiro vamos utilizar o método get para pegar as informações das moedas que estão preenchidas no campo_moeda_origem e campo_moeda_destino.
def converter_moeda():
moeda_origem = campo_moeda_origem.get()
moeda_destino = campo_moeda_destino.get()Em seguida, verificaremos se ambos os campos foram preenchidos e salvos nas variáveis moeda_origem e moeda_destino.
Caso os campos tenham sido preenchidos corretamente, podemos chamar a função pegar_cotacao_moeda e armazenar o resultado dela na variável cotacao.
def converter_moeda():
moeda_origem = campo_moeda_origem.get()
moeda_destino = campo_moeda_destino.get()
if moeda_origem and moeda_destino:
cotacao = pegar_cotacao_moeda(moeda_origem, moeda_destino)Por fim, após obter o valor da cotação, vamos utilizar o método configure para editar o texto_cotacao_moeda informando a moeda de origem, o valor da cotação e a moeda de destino.
def converter_moeda():
moeda_origem = campo_moeda_origem.get()
moeda_destino = campo_moeda_destino.get()
if moeda_origem and moeda_destino:
cotacao = pegar_cotacao_moeda(moeda_origem, moeda_destino)
texto_cotacao_moeda.configure(text=f"1 {moeda_origem} = {cotacao} {moeda_destino}")Dessa forma, nossa função converter_moeda irá obter as moedas de origem e destino fornecidas pelo usuário, obterá o valor da conversão entre elas através da função pegar_cotacao_moeda e atualizará o campo de texto com o resultado para o usuário.
Código main.py completo:
import customtkinter
from pegar_moedas import nomes_moedas, conversoes_disponiveis
from pegar_cotacao import pegar_cotacao_moeda
# criar e configurar a janela
customtkinter.set_appearance_mode("dark")
customtkinter.set_default_color_theme("dark-blue")
janela = customtkinter.CTk()
janela.geometry("500x500")
dic_conversoes_disponiveis = conversoes_disponiveis()
# criar os botões, textos e outros elementos
titulo = customtkinter.CTkLabel(janela, text="Conversor de Moedas", font=("",20))
texto_moeda_origem = customtkinter.CTkLabel(janela, text="Selecione a moeda de origem")
texto_moeda_destino = customtkinter.CTkLabel(janela, text="Selecione a moeda de destino")
def carregar_moedas_destino(moeda_selecionada):
lista_moedas_destino = dic_conversoes_disponiveis[moeda_selecionada]
campo_moeda_destino.configure(values=lista_moedas_destino)
campo_moeda_destino.set(lista_moedas_destino[0])
campo_moeda_origem = customtkinter.CTkOptionMenu(janela, values=list(dic_conversoes_disponiveis.keys()),
command=carregar_moedas_destino)
campo_moeda_destino = customtkinter.CTkOptionMenu(janela, values=["Selecione uma moeda de origem"])
def converter_moeda():
moeda_origem = campo_moeda_origem.get()
moeda_destino = campo_moeda_destino.get()
if moeda_origem and moeda_destino:
cotacao = pegar_cotacao_moeda(moeda_origem, moeda_destino)
texto_cotacao_moeda.configure(text=f"1 {moeda_origem} = {cotacao} {moeda_destino}")
botao_converter = customtkinter.CTkButton(janela, text="Converter", command=converter_moeda)
lista_moedas = customtkinter.CTkScrollableFrame(janela)
texto_cotacao_moeda = customtkinter.CTkLabel(janela, text="")
moedas_disponiveis = nomes_moedas()
for codigo_moeda in moedas_disponiveis:
nome_moeda = moedas_disponiveis[codigo_moeda]
texto_moeda = customtkinter.CTkLabel(lista_moedas, text=f"{codigo_moeda}: {nome_moeda}")
texto_moeda.pack()
# colocar todos os elementos na tela
titulo.pack(padx=10, pady=10)
texto_moeda_origem.pack(padx=10, pady=10)
campo_moeda_origem.pack(padx=10)
texto_moeda_destino.pack(padx=10, pady=10)
campo_moeda_destino.pack(padx=10)
botao_converter.pack(padx=10, pady=10)
texto_cotacao_moeda.pack(padx=10, pady=10)
lista_moedas.pack(padx=10, pady=10)
# rodar a janela
janela.mainloop()Executando nosso aplicativo, podemos ver todo esse processo e o que construímos nas aulas anteriores funcionando, obtendo a cotação das moedas em tempo real e informando o valor para o usuário.
Ao longo dessas 3 aulas, explorei como construir o projeto Conversor de Moedas com Python a partir do zero! Esse conversor é capaz de realizar a conversão de forma automática e em tempo real de diversas moedas disponíveis!
Partindo do zero, você aprendeu a desenvolver um conversor de moeda passo a passo, desde a criação da tela com os elementos visuais até toda a lógica e o código por trás dele.
Dessa forma, você pode utilizá-lo tanto como um projeto individual quanto personalizá-lo e ajustá-lo para integrar com outras aplicações e sistemas que estiver desenvolvendo.
Para acessar outras publicações de Python, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.