Conectando ao MySQL com Python

Esse projeto da playlist no Youtube, do canal SR de Python com MySQL.

English version: Click Here

O objetivo desse projeto está na criação de uma classe de conexão e métodos CRUD para recuperação, manipulação e remoção de dados do banco de dados MySQL em uma instância local.

Para navegar em artigos de banco de dados acesse nossa categoria: Banco de Dados no Simplificando Redes

Para ver nossa seleação de livros técnicos clique aqui

Bibliotecas utilizadas no projeto

Você irá perceber que alguns métodos foram criados com fins didáticos. Para esses, assim como os demais, você poderá realizar suas próprias modificações.

1. python-dotevn
2. os
3. python-mysql-connector
4. Fastapi

Mas para começar, você só precisa do python-mysql-connector. Execute o comando abaixo no terminal:

$ pip install python-mysql-connector

OBS: para quem for usar esse código no python 3.10, use a lib mysql-connector-python. No meu caso, o outro pacote não foi encontrado utilizando a versão 3.10 do Python

First step – Conectando ao MySQL com Python

Este artigo segue a evolução do código criado na playlist. Sendo assim, iremos começar com um código mais simples para depois aumentar a complexidade.

Função de conexão

Você pode seguir usando funções, classes e métodos, ou ainda executar tudo dentro do main. Faça o mais simples de entender pra você.

Para sua conexão ser bem sucedida, após a instalação dos pacotes, crie o seguinte trecho de código na sua aplicação.

Eu uso pycharm, mas você pode fazer no VS code oiu ainda no Gedit. rs

def _connecting(user_var, passwd, host, database):
        return mysql_connector.connect(
            user=user_var
            password=passwd,
            host=host,
            database=database,
        )

Essa função retorna o recurso de conexão, por onde você vai alocar o cursor e consequentemente executar as queries.

Para quem for executar dentro do main o código fica assim:

import mysql.connector as mysql_connector

def connecting(user_var, passwd, host, database):
        return mysql_connector.connect(
            user=user_var
            password=passwd,
            host=host,
            database=database,
        )

if __name__ == '__main__':

   conn = connecting('seu_usuario', 'sua_senha', 'localhost', 'seu_banco_de_dados')
   if conn:
      print('Conexão realizada com sucesso!')
  else:
      print('Erro ao conectar! Verifique os parâmetros de conexão')

Tirando os dados de conexão do código principal – Variáveis de ambiente

Para isso você vai precisar usar o pacote python-dotenv. Sendo assim, use o comando abaixo para instalar via pip.

$ pip install python-dotenv

Você poder criar um arquivo contendo todos os dados de conexão ao banco de dados, basta nomea-lo como .env.

Para poder usar os dados dentro do arquivo, você precisa carrega-los.

from dotenv import load_dotenv
import os

load_dotenv()

host = os.getenv("HOST")
username = os.getenv("USERNAME")
passwd = os.getenv("PASSWD")
database = os.getenv("DATABASE")

conn = connecting(username, passwd, host, database)

Aqui você instanciou o load_dotenv(), carregou os dados através do método getenv pela li os, passando o nome da variável alvo como parâmetro.

E por que usar variável de ambiente com python?

Muito bem, agora seus dados estão desacoplados do código. Quando você for compartilhar seu projeto, não precisa passar o arquivo .env. Apenas explique como os dados foram definidos.

Criando a classe Database

OK, vamos pegar o que foi feito até agora e isolar dentro de uma classe. Para deixar a conexão ainda mais protegida, vamos usar operadores de privacidade.

Adicionando a função de conexão a classe MySQLDatabase, temos o seguinte código.

import os
import mysql.connector as mysql_connector
from dotenv import load_dotenv

load_dotenv()

class MySQLDatabase:

    def __init__(self):
        self._host = os.getenv("HOST")
        self._username = os.getenv("USERNAME")
        self._passwd = os.getenv("PASSWD")
        self._database = os.getenv("DATABASE")
        self.conn = self._connecting()

    def _connecting(self):
        return mysql_connector.connect(
            user=self._username,
            password=self._passwd,
            host=self._host,
            database=self._database,
        )

O operador _ antes dos atributos da classe definem que estes só podem ser acessados dentro da classe. O mesmo acontece para os métodos.

Sendo assim, nosso método _connecting() só pode ser acessado pela classe MySQLDatabase.

Retornando os parâmetros de conexão com o MySQL com Python

Caso você queira saber se realmente está no banco de dados escolhido, basta criar o método abaixo para retornar o nome do banco de dados, dentro da classe.

def get_database_name(self):
return self._database

O mesmo acontece para user e os demais parâmetros de conexão.

def get_database_user(self):
return self._username

Criando método de encerramento da conexão

Ok, quando você encerra a aplicação a conexão é encerrada. Mas vamos garantir que isso aconteça.

É bem simples, na verdade. Basta usar o método close() na conexão gerada lá no início do código. Como colocar isso no método?

def closing(self):
    if self.conn.is_connected():
        self.conn.close()

Consultando as tabelas de um BD no MySQL com Python

Antes de finalizar, vamos criar um método que retorne as tabelas do banco de dados que estamos acessando dentro do SGBD, o MySQL.

Para isso precisamos executar o comando SQL: SHOW TABLES;

Vamos para o código:

 def get_database_tables(self):
        dict_of_tables = self._querying('SHOW tables;')
        print(f'List of tables on {self._database} database!\n')
        for table in dict_of_tables:
            print(' '.join(['-', table['Tables_in_'+self._database]]))
        return dict_of_tables

O método querying() foi criado separado para que possamos aproveitar o código em outros métodos. Assim, só precisamos passar a string com a query desejada.

Vamos para o método….

Como executar uma query com Python no MySQL?

Precisamos alocar o cursos através da conexão criada, com MySQL usando Python. Assim, usando o cursos (conn.cursor) podemos executar a query SQL. Você pode ver no código do método.

def _querying(self, query: str):
    if (not self.conn.is_connected()) or self.conn is None:
        self.conn = self._connecting()

    cursor = self.conn.cursor(dictionary=True)
    cursor.execute(query)
    result = cursor.fetchall()
    cursor.close()

   return result

O método cursor recebe dictionary como True, poís será usado em queries que tenham parâmetros a serem passados. Tais como id, nome e outro atributo que seja um condicional para a query.

O fetchall() irá nos retornar uma lista de tuplas a partir da query SQL. O result recebe a lista de dados, para então encerrarmos a conexão.

Bom… é isso, no próximo artigo teremos o CRUD criado com Python e MySQL.

Até lá!

Veja mais:

Projeto para Portifólio: Sua primeira API com Python e MySQL

Instalar Python Windows

Python: minhas portas TCP e UDP abertas

Python: mostrar portas TCP abertas

Principais Bibliotecas Python para Data Science: Manipulação e Visualização

Link para a página desse projeto para portfólio – Vídeos:

Projeto para Portifólio: Sua primeira API com Python e MySQL