Esse projeto da playlist no Youtube, do canal SR de Python com MySQL.
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.
- python-dotevn
- os
- python-mysql-connector
- 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
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:
Juliana Mascarenhas
Data Scientist and Master in Computer Modeling by LNCC.
Computer Engineer
Tutorial: Instale seu Servidor DNS no Linux com Bind9 Passo a Passo
Nesse tutorial vamos dar todo o passo a passo para que você instale uma configuração…
SSH: Como criar chave pública
Nesse tutorial vamos ensinar a criar e configurar o acesso a um servidor SSH usando…
Socket em Python criando chat UDP
Tutorial para a criação de um chat simples utilizando sockets em UDP em Python 3….
Socket em Python, criando um Chat
Tutorial para a criação de um chat simples utilizando sockets TCP em Python 3. O…
Como usar apt get com proxy
Ao longo dos tempos sempre me deparo nos laboratórios de rede com a necessidade de…
Qual a melhor IDE para Python?
Encontrar a IDE perfeita é uma jornada pessoal que depende de vários fatores, como suas…