Neste artigo, vamos aprender como criar uma API RESTful usando o framework Flask em Python, incluindo exemplos de três rotas diferentes. Flask é uma biblioteca de código aberto que permite criar aplicativos web rapidamente e facilmente, tornando-o uma das melhores escolhas para a criação de APIs RESTful.

Passo 1: Instalação do Flask Para começar, você precisa instalar o Flask. Isso pode ser feito usando o gerenciador de pacotes Python pip. Abra o terminal e execute o seguinte comando:

pip install flask

Passo 2: Criando um projeto Em seguida, crie um novo diretório para o projeto e inicialize o arquivo Python. Você pode chamá-lo de “app.py”.

mkdir myapi
cd myapi
touch app.py

Passo 3: Configurando o Flask Agora, precisamos importar o Flask e criar uma instância da aplicação. Adicione o seguinte código ao arquivo “app.py”:

from flask import Flask

app = Flask(__name__)

Passo 4: Criando rotas Rotas são as URLs que são acessadas pelos usuários da API. Vamos criar três rotas diferentes para exemplificar:

@app.route("/")
def index():
    return "Bem-vindo à minha API!"

@app.route("/users", methods=["GET"])
def list_users():
    return "Lista de usuários"

@app.route("/users/<int:user_id>", methods=["GET"])
def get_user(user_id):
    return "Detalhes do usuário {user_id}"

Passo 5: Inicializando a aplicação Por fim, precisamos inicializar a aplicação. Adicione o seguinte código ao arquivo “app.py”:

if __name__ == "__main__":
    app.run(debug=True)

Passo 6: Executando a aplicação Para executar a aplicação, abra o terminal e navegue até o diretório do projeto. Em seguida, execute o seguinte comando:

python app.py

Com estes passos, você criou uma API RESTful simples usando o Flask. Agora, você pode adicionar mais recursos, como autenticação, validação de dados e persistência de dados, para torná-lo mais completo. Espero que este guia tenha sido útil para você e que você esteja animado para explorar mais sobre o Flask.

Neste tutorial, vamos construir uma API, ou um serviço web, para um aplicativo de lista de tarefas escrito em React. O serviço da API será implementado usando uma arquitetura baseada em REST.

Nosso aplicativo terá as seguintes características principais:

• Criar um item na lista
• Consultar todos os itens de uma lista
• Atualizar os itens com status “Não Iniciado”, “Em andamento”, ou “Completo”.
• Excluir os itens da lista

Nesse tutorial nós vamos focar apenas na parte do Back-end, então se você quiser criar o front-end do seu aplicativo, eu recomendo fortemente você visitar esse artigo, onde eu ensino passo a passo como criar uma ToDo list usando React. É com esse front-end que vamos trabalhar nesse tutorial.

Vamos conhecer a nossa principal ferramenta para esse projeto.

Programação em Python: O que é Flask

Flask é um framework para o desenvolvimento de aplicações web Python. Flask é do tipo “faça você mesmo”, ele não restringe a estrutura da sua aplicação de nenhuma forma particular. Ele fornece maior flexibilidade e controle aos desenvolvedores. Flask fornece as ferramentas básicas para criar um aplicativo web.

Flask faz parte das categorias da micro-frameworks. Micro-framework são normalmente framework com pouca ou nenhuma dependência de bibliotecas externas.

Isto tem prós e contras. Prós seria que o framework é leve, há pouca dependência para atualização o que pode garantir extra pontos em segurança e estabilidade, contras é que algum tempo você terá que fazer mais trabalho sozinho ou aumentar a lista de dependências adicionando plugins. No caso do Flask, suas dependências são:

• Werkzeug uma biblioteca de utilidades do WSGI
• jinja2 que é o seu mecanismo de templates.

Instalando Flask

Antes de instalar o framework eu recomendo, fortemente, que você crie uma ambiente virtual para a sua aplicação. Se você tem intenção de trabalhar com Python, essa deve ser sempre uma das primeiras coisas a fazer, se você não sabe como fazer isso, também tenho aqui um outro post que ensina o passo a passo, tudo o que você precisa saber sobre ambientes virtuais em Python

Feito isso, podemos então instalar o framework dentro do nosso ambiente virtual, executando o comando:

pip install Flask

Vamos configurar rapidamente o Flask e rodar um servidor web em nossa máquina local. Crie um arquivo com o nome main.py na pasta todo_service e insira esse código.

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello World!'

Após a importação do Flask, nós criamos uma rota. Uma rota, utilizando Flask, é especificada por:

• Um padrão URL (ex. example.com/api)
• Um método HTTP (ex. GET, POST)
• Uma função que recebe e lida com a requisição HTTP.

We link this route with a Python function that will be invoked every time this URL is requested via HTTP. In this case, we configure the root route (/) so that it can be accessed via the default URL http://localhost:5000/.

Iniciando a Aplicação

Com isso já podemos rodar o nosso servidor. Flask é bem simples com isso também, basta rodar o comando abaixo no seu terminal:

FLASK_APP=main.py flask run

essa mensagem deve aparecer no seu console:

Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Certo, o primeiro passo foi dado, já temos um servidor rodando e a nossa primeira rota definida. Se quiser, você pode usar o Postman para testar.

Criando a estrutura de rotas com Flask

Como você vai perceber ao longo desse post, programação em Python é bem simples, e Flaks não torna as coisas complicadas.

O que precisamos fazer agora, é definir as nossas rotas, as rotas serão:

• GET: /todo/getall- Consulta todas as tarefas
• POST: /todo/create – Cria uma nova tarefa
• UPDATE: /todo/update – Atualiza uma tarefa existente
• DELETE: /todo/delete – Deleta uma tarefa da lista

Para manter as coisas simples, vamos escrever todas as nossas rotas em um único arquivo, embora isso nem sempre seja uma boa prática, especialmente para aplicações muito grandes.

from flask import Flask
app = Flask(__name__)
app.run(debug=True)
@app.route('/todo/getall',methods=['GET'])
def getTasks():
    return 'Get all taks!'
@app.route('/todo/create',methods=['POST'])
def createTask():
    return 'Create new task'
@app.route('/todo/update',methods=['UPDATE'])
def updateTask():
    return 'Update Task'
@app.route('/todo/delete',methods=['DELETE'])
def deleteTask():
    return 'Delete task'

Vamos também criar um arquivo estático para representar nossa lista de tarefas, mas temos um outro post aqui que mostra como conectar o seu projeto em Python ao banco de dados MySQL.

Nossa lista de tarefas inicial vai ser essa:

[
   { "complete": false, "task": "Read about MongoDb" },
   { "complete": false, "task": "Create a React ToDo App" },
   { "complete": false, "task": "Find my key" }
 ]

Uma vez que você esteja confortável com esta estrutura inicial do Flask, você pode reestruturar seu aplicativo da maneira que quiser.

Consultando todas as tarefas

Vamos começar enviando a nossa lista de tarefas para o usuário quando ele consultar a rota todo/getall. Para fazer isso precisamos importa duas bibliotecas que vai nos permitir trabalhar com JSON, jsonfy e json

from flask import Flask
from flask import jsonify
import json
app = Flask(__name__)
app.run(debug=True)
# read file
with open('tasks.json', 'r') as myfile:
    data=myfile.read()
# parse file
obj = json.loads(data)
@app.route('/todo/getall',methods=['GET'])
def getTasks():
    return jsonify(obj)

Se você acessar a rota http://127.0.0.1:5000/todo/getall você vai ver um resultado igual a esse:

Agora vamos fazer o nosso front-end em React receber essas tarefas, vamos fazer algumas mudanças no seu arquivo App.js, Vamos usar mais um Hook, useEffect() para fazer o request da nossa lista.

import React, { useState, useEffect } from 'react';
import './App.css';
import TodoList from './components/TodoList';
import TodoForm from './components/TodoForm';
function App() {
   const [todos, setTodos] = useState([]);
   useEffect(() => {
      const fetchTasks = async () => {
         let response = await fetch('http://localhost:5000/todo/getall'
         );
         if (response.ok) { // if HTTP-status is 200-299
            // get the task lists
            let json = await response.json();
            setTodos(json);
         } else {
            alert("HTTP-Error: " + response.status);
         }
      }
      fetchTasks();
   }, [])
   return (
      <div className="App">
         <TodoForm addTodo={(todo) => {
            if (todo.task.trim().length > 0) {
               setTodos([...todos, todo]);
            }
         }} />
         <TodoList todos={todos} updateTodos={(list) => { setTodos(list) }}></TodoList>
      </div>
   );
}
export default App;

Se você não faz idéia de onde esse código veio, eu sugiro que você de uma conferida nesse post, onde tem todo o código front end que estamos usando.

É bem provável que você terá algum problema com CORS, que é facilmente resolvido em Flask instalando uma pequena biblioteca que resolve esse problema. Instale a biblioteca com o comando:

$pip install -U flask-cors

Depois disso, inclua essas duas linhas no seu arquivo main.py.

from flask import Flask
from flask import jsonify
import json
from flask_cors import CORS #include this line
app = Flask(__name__)
app.run(debug=True)
CORS(app) # include this line

Agora vamos rodar nossa aplicação React para ver o resultado, utilize o comando npm start na pasta do projeto para iniciar.

O nosso aplicativo continua funcionando como antes. e se olharmos no Chrome Developer Tools vamos ver que as tarefas já estão vindo do servidor Flask. Sucesso!

Criando um novo item

Para criar um nova tarefa na nossa lista vamos usar o método POST. Precisamos incluir o novo item na lista e retornar para o usuário.

No nosso arquivo main.py vamos alterar a rota todo/create. Vamos definir uma função que vai receber o valor do usuário, adicionar ao array e retornar o item para o usuário, indicando que a operação foi bem sucedida.

@app.route('/todo/create', methods=['POST'])
def createTask():
    # Get item from the POST body
    req_data = request.get_json()
    obj.append(req_data)
    return jsonify(req_data)

No lado do Front end o que precisamos fazer é modificar o nosso arquivo TodoForm.js. Vamos incluir uma função que vai submeter, de forma assíncrona, o item que o usuário digitar no formulário. A função de para submissão é essa:

   async function postData(url = '', data = {}) {
      const response = await fetch(url, {
         method: 'POST',
         headers: {
            'Content-Type': 'application/json'
         },
         body: JSON.stringify(data)
      });
      return response.json();
   }

E vamos chamar a função no nosso método handleSubmit, dessa forma:

   const handleSubmit = async e => {
      e.preventDefault();
      if (!userInput) return;
      await postData('http://localhost:5000/todo/create',
        { complete: false, task: userInput })
        .then(data => {
            addTodo(data);
            setUserInput("");
         })
   };

Nossa aplicação vais estar funcionando assim no momento:

Removendo itens da lista

Para deletar um item da lista, vamos enviar um objeto contendo o item, vamos fazer a busca dentro da lista, no servidor, se o item for encontrado, nós removemos usando o método pop().

@app.route('/todo/delete', methods=['DELETE'])
def deleteTask():
    req_data = request.get_json()
    for idx, task in enumerate(obj):
        if task.get('task') == req_data["task"]:
            obj.pop(idx)
            return jsonify(req_data)
    return "Item Not Found"

No front-end precisamos alterar o nosso TodoList.js. Que antes de atualizar a lista no front-end, a função removeTask() vai enviar os objeto com o item para o servidor, se o o retorno for OK nós atualizamos a lista no front-end. A função que vai submeter os valores para o servidor é essa:

async function deleteData(url = '', data = {}) {
   const response = await fetch(url, {
      method: 'DELETE',
      headers: {
         'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
   });
   return response.json();
}

E vamos altera a função removeTask() para incluir a chamada dessa função.

const removeTask = async (index, todo) => {
   await deleteData('http://localhost:5000/todo/delete',
      todo)
      .then(data => {
         const updatedList = todos.filter((task, taskIndex) => {
            return taskIndex !== index;
         });
         updateTodos(updatedList);
      })
}

Um ultimo detalhe, precisamos também atualizar o botão de deletar, antes estávamos passando apenas o index, agora precisamos passar também o objeto todo.

<button className="button" onClick={() => removeTask(index, todo)}>Delete</button>

Atualizando itens da lista

Estamos chegando ao final do projeto. Ultima etapa agora, precisamos atualizar a nossa lista, que no nosso caso é marcar o item como completo ou incompleto. Vamos começar com a nossa rota no nosso servidor Flask.

@app.route('/todo/update', methods=['PUT'])
def updateTask():
    req_data = request.get_json()
    for idx, task in enumerate(obj):
        if task.get('task') == req_data["task"]:
            obj.pop(idx)
            obj.insert(idx,req_data)
            break
    return jsonify(req_data)

Pra não super complicar as coisas, o que estou fazendo é bem simples, eu busco o item na lista, assim que eu encontro, eu removo ele da lista e insiro uma o mesmo elemento, com o valor que estou recebendo do usuário, que para essa função a única coisa que vai mudar é o valor complete:false/true.

Agora o nosso front-end, também segue a mesma idea das outras funções. Vamos primeiro criar uma função para enviar os dados para o servidor, e assim que recebermos a resposta, atualizamos o front-end.

async function updateData(url = '', data = {}) {
   const response = await fetch(url, {
      method: 'PUT',
      headers: {
         'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
   });
   return response.json();
}

Precisamos atualizar nossa função markComplete() para enviar o item que queremos atualizar no servidor. Já faço a mudança para complete:false/true no front-end.

const markComplete = async (index, todo) => {
   const updated = { ...todo, complete: !todo.complete }
   await updateData('http://localhost:5000/todo/update',
      updated)
      .then(data => {
         const updatedList = todos.map((item, id) => {
            if (index !== id) return item;
            return updated;
         });
         updateTodos(updatedList);
      })
}

E por fim, precisamos atualizar a função de click, para então enviar o index e o objeto todo.

...
onClick={() => markComplete(index, todo)}>  
...

Chegou a hora, vamos testar. Seu aplicativo vai estar funcionando como esse que você está vendo no video abaixo.

Conclusão

Como você pode perceber, a programação em Python é bem simples. A combinação entre Python Flask nos permite cria aplicações simples, porém poderosas.

Neste tutorial, nós construimos uma API, para um aplicativo em React. O serviço da API foi implementado usando uma arquitetura baseada em REST.

Espero que tenha gostado, se ficou tiver alguma dúvida, deixe nos comentários, eu respondo 100% dos comentários.

Até a próxima!

Nesse artigo eu vou mostrar como instalar e criar e utilizar seus ambientes virtuais, e você vai descobrir porque você já deveria estar usando ambientes virtuais.

Chega de erros de conflito…

Por que a Necessidade de Ambientes Virtuais em Python?

Python, como a maioria das outras linguagens de programação modernas, tem sua própria forma única de baixar, armazenar e resolver pacotes (ou módulos).

Embora isso tenha suas vantagens, também traz junto alguns ‘problemas’, especialmente como e onde esses pacotes são armazenados.

Considere o seguinte cenário onde você tem dois projetos: Projeto A e Projeto B, ambos com dependência do mesmo pacote, e que conecta o Python a um banco de dados, por exemplo.

Se quiser saber mais como conectar ao banco de dados MySQL usando Python, voce pode ir nesse post.

Para o Projeto A você precisa da versão v1.0.0 desse pacote, mas para a o Projeto B você precisa da versão v2.0.0.

Em Python, você não consegue diferenciar as versões no diretório padrão site-packages. Então tanto a v1.0.0 quanto a v2.0.0 do pacote vão estar no mesmo diretório com o mesmo nome.

Como os pacotes são armazenados apenas de acordo com seu nome, e não há diferenciação entre as versões. Assim, ambos os projetos, Projeto A e B, seriam obrigados a utilizar a mesma versão, o que é inaceitável em muitos casos.

É aqui que entram em jogo os ambientes virtuais e as ferramentas virtualenv/venv…

O que são ambientes virtuais em Python

Um ambiente virtual é uma árvore de diretórios que contém arquivos executáveis Python e outros arquivos que indicam que se trata de um ambiente virtual.

É um ambiente tal que o interpretador Python, bibliotecas e scripts instalados nele são isolados daqueles instalados em outros ambientes virtuais, e também das bibliotecas e pacotes instaladas por padrão pelo seu sistema operacional.

O principal objetivo dos ambientes virtuais é criar um ambiente isolado para os projetos Python. Isto significa que cada projeto pode ter suas próprias dependências, independente das dependências que cada outro projeto tenha.

O que é o Python virtualenv

Python virtualenv é uma ferramenta utilizada para criar um ambiente virtual isolado em Python. Este ambiente tem seus próprios diretórios de instalação que não compartilha bibliotecas com outros ambientes virtualenv (e opcionalmente também não acessa as bibliotecas instaladas globalmente).

Python virtualenv é a forma mais fácil (e recomendada) de configurar um ambiente Python personalizado.

O Python 3 já vem, por padrão com o pacote venv, que inclui essa funcionalidade, (Python2 não). Mas o Python virtualenv é uma biblioteca que oferece mais funcionalidades do que venv.

Veja o link abaixo para uma lista de funcionalidades que o venv não oferece em comparação com o virtualenv.

• https://virtualenv.pypa.io/en/stable/

Instalando o Python virtualenv

Para a instalação do virtualenv vamos precisar do pip.

Caso você ainda não tenha o gerenciador de pacotes pip, instale-o clicando aqui e executando o script baixado com python get-pip.py.

Agora com o pip, precisamos executar apenas um comando para instalar o virtualenv:

No macOS ou Linux:

python3 -m pip install --user virtualenv

Windows:

py -m pip install --user virtualenv

Criando um ambiente virtual com virtualenv

O Python virtualenv é bem, minimalista, tem apenas um comando.

virtualenv

Você pode criar um novo ambiente virtual indo diretamente na pasta do seu projeto e digitando o comando:

virtualenv <DIR>

Fazendo isso você vai criar um ambiente virtual sobre a versão do Python no qual o virtualenv foi instalado.

Se você quiser criar um ambiente virtual com uma versão diferente do Python, basta usar a opção --python (ou short -p) ao criar sua instância virtualenv e especificar a versão do Python que você quer usar, por exemplo:

virtualenv --python=/usr/bin/python3.8 <DIR>

Você precisa especificar o caminho da pasta da versão que você quer usar. Você pode descobrir a rota usando o comando:

which python
//ou
which python3

Como ativar seu Ambiente Virtual

Ao trabalhar neste projeto, você deve ativar o ambiente virtual para ter certeza de estar trabalhando com as versões certas de suas ferramentas e pacotes. Você pode fazer isso rodando o comando:

source DIR/bin/activate

O nome do ambiente virtual atual aparece à esquerda do prompt.
Por exemplo:

(DIR) [server]$ 

Como Desativar seu Ambiente Virtual

Para desativar um ambiente virtual, se caso você quiser utilizar outro ambiente virtual ou trabalhar em outro projeto. Basta executar esse comando:

(DIR) [server]$  deactivate

Isto te coloca de volta nas configurações padrão do seu usuário Shell.

Conclusão

Usar Python virtualenv e criar ambientes virtuais ajuda a eliminar, ou pelos reduzir os problemas de conflitos entre as versões de pacotes e bibliotecas.

Se você acabou de iniciar um novo projeto, aproveite para isolar ele dos seus antigos projetos ou de novos, o quanto antes melhor. Você só tem a ganhar fazendo isso.

Espero que tenham gostado! E se curtiu este post, e acredita que vai dar um up no seus projetos Python, não se esqueça de se inscrever, clicando aqui, ou no formulário logo abaixo, para receber todas as nossas novidades!

Tem muito conteúdo exclusivo lá também!

Até a próxima!

Neste artigo eu vou falar como conectar Python ao banco de dados MySQL

Bom, você já tem seu projeto rodando e funcionando. Porque você precisa conectar com um banco de dados?

A não ser que você queira que o seu projeto não salve nenhuma informação, você não precisa. Um banco de dados serve para guardar informações que poderemos usar mais tarde, e não precisarmos recomeçar tudo do zero.

Vamos explicar passo a passo, como conectar e criar um banco de dados MySQL usando Python, da maneira mais curta e eficiente possível.

O que é um Banco de Dados, e por que ele é importante?

Um banco de dados armazena os dados de forma organizada para que você possa pesquisar e recuperar esses dados mais tarde.

Um banco de dados, deve conter uma ou mais tabelas. A tabela é muito parecida com uma planilha, ele é basicamente um conjunto de linhas e colunas.

Todas as linhas têm as mesmas colunas, e cada coluna contém os dados em si. Se isso ajudar, pense em suas tabelas da mesma forma que você pensaria em uma tabela no Excel.

Os dados podem ser inseridos, recuperados, atualizados e excluídos de uma tabela. A palavra, criada, é geralmente usada ao invés de inserida, essas quatro funções são carinhosamente abreviadas como CRUD (Create, Read, Update and Delete)

Uma base de dados relacional organiza os dados em tabelas, e os vincula, com base em relações definidas. Estes relacionamentos permitem recuperar e combinar dados de uma ou mais tabelas com uma única consulta.

Um banco de dados vai ser extremamente útil se você seguiu o tutorial onde eu mostrei como criar uma página de login do zero.

Mas isso foi apenas um monte de palavras. Para entender verdadeiramente um banco de dados relacional, você precisa criar o seu. Então, vamos lá.

Instalando o MySQL

A primeira coisa que você precisa fazer, se você quer conectar Python ao banco de dados MySQL é baixar e instalar a ultima versão do MySQL. Basta ir no site do MySQL, e fazer o download da versão correta do sistema operacional do seu computador, se ainda não tiver feito isso. A versão que estou utilizando aqui é a MySQL Community Server 8.0.19.

Eu também recomendo fortemente você instalar uma ferramenta para gerenciar graficamente seus bancos de dados como o MySQL Workbench ou phpMyAdmin.

Feito isso basta checar se seu banco de dados esta funcionando com qualquer uma das ferramentas que sugeri, ou qualquer uma outra que você preferir, usando o usuário e senha que você criou durante a instalação.

Conector Python ao banco de dados MySQL

Segundo passo, precisamos conectar Python ao banco de dados MySQL, através de um conector.

Python não vem nativamente com um conector. Você precisa fazer o download. Um Conector nada mais é do que um modulo que auxilia a comunicação entre Python ao banco de dados MySQL. Temos pelo menos 5 módulos disponÍveis, mas nesse tutorial, vamos utilizar o que é disponibilizado pela própria MySQL.

Para instalar o Conector, a maneira mais simples (e recomendável) é utilizando pip, que é o instalador de pacotes para Python. Eu citei o pip nesse outro artigo. Se você já tem o pip instalado, basta executar esse comando abaixo para instalar o Conector Python/MySQL.

pip install mysql-connector-python

Conectando Python ao banco de dados MySQL

Para conectar Python ao banco de dados MySQL usando o conector que acabamos de instalar é bem simples.

A primeira coisa que precisamos fazer é importar o conector. Em seguida utilizar a função connect() com as credenciais que você gerou durante a instalação do MySQL. O nome do host pode ser tanto localhost ou 127.0.0.1 que são sinônimos.
Nesse teste apenas vamos abrir uma conexão e fechar logo em seguida, com a função close().

import mysql.connector

cnx = mysql.connector.connect(user='root', password='********', host='127.0.0.1')

cnx.close()

Copie e cole esse código, salve o arquivo como connection.py ou como preferir. Abra uma janela no seu terminal na pasta onde contém o arquivo e rode o comando python connection.py.

Se esse código rodar sem problemas quer dizer que funcionou e você já pode usar o MySQL.

Criando um Banco de Dados MySQL usando Python

Chegou a hora de criar o nosso primeiro banco de dados. Vamos modificar um pouco o código acima e criar o código que vai conectar Python ao banco de dados MySQL.

Vamos criar uma instância de um objeto da classe MySQLCursor ao invés de apenas fechar a conexão. O objeto interage com com o MySQL server usando um objeto MySQLConnection.

Para criar o cursor basta usar o método cursor() em uma conexão existente. Agora é escrever nossa SQL Query e executar utilizando o método execute() do objeto mycursor da conexão que acabamos de criar.

O comando SQL para criar um banco de dados é:

CREATE DATABASE mydatabase

Juntando tudo, temos esse código abaixo.

import mysql.connector

cnx = mysql.connector.connect(user='root', password='********', host='127.0.0.1')

mycursor = cnx.cursor()
mycursor.execute("CREATE DATABASE mydatabase")

Basta executar esse arquivo com o mesmo comando que mostrei lá em cima, python connection.py. Se esse código também executar sem problemas, parabéns, você acaba de criar o seu primeiro banco de dados usando Python.

Conclusão

Para conferir seu banco de dados recém criado você pode utilizar uma das ferramentas que citei anteriormente. Utilizando o MySQLWorkbench eu obtive esse resultado.

Recapitulando tudo que vimos até aqui.
Primeiro passo, precisamos baixar o MySQL, depois instalar o conector Python/MySQL para conseguirmos conectar Python ao banco de dados MySQL e por fim, criar seu primeiro banco de dados usando o classe MySQLCursor.

Conectar seu projeto a um banco de dados é um passo importante e essencial. Na medida que o seu projeto cresce é de se esperar que você acumule mais dados. Por isso aqui estou citando como conectar Python ao banco de dados MySQL.

MySQL é um banco de dados extremamente confiável e amplamente utilizado, seu projeto vai estará muito bem servido com ele.

Bom espero que tenha ficado claro porque você deve ter um banco de dados no seu projeto e como é simples criar uma conexão.

Até a próxima.