MySQL com Python

Autora: Isabelle Coimbra

Atualizado por: Melk de Sousa


Está curioso para saber como fazer uma integração com o Python e MySQL? Então seja bem-vindo!


Como o título já entrega, irei demonstrar como introduzir MySQL na linguagem de programação Python ou vice-versa. Nesta postagem, irei abordar dois “conectores” do MySQL nas bibliotecas Python. A primeira é a mysql.connector e a segunda é pymysql. Com o mysql.connector, irei mostrar como estabelecer a conexão com o servidor, e com o pymysql irei fazer um exemplo de inserção na tabela.

Primeiramente, precisamos já ter instalado o MySQL, caso não possua, instale.

Em minhas experiências, eu gosto de trabalhar com a interface do MySQL Workbench e com a IDE Pycharm Community.

🧑🏻‍💻 Mão na massa

No ambiente MySQL…

Com as ferramentas postas à mesa, seguiremos para a criação de um database e uma tabela para servir de exemplo.

CREATE DATABASE codenglish;
USE codenglish;

CREATE TABLE people (
	name VARCHAR(50),
	age INT
);
  • Criamos o banco;
  • Acessamos o banco;
  • Criamos uma tabela no banco;

Com esse ambiente pronto, podemos prosseguir para o desenvolvimento do código Python.

No ambiente Python…

Antes de seguir para o código, é importante termos em mente alguns métodos que são usados em ambas bibliotecas.

  • .cursor – O cursor é a obtenção de uma transação. Então para realizar uma transação, use o cursor.
  • .commit – Este método envia uma instrução COMMIT para o servidor MySQL, confirmando a transação atual, ou seja, é usado para salvar as alterações.
  • .connect() – Este método estabelece uma conexão, estabelecendo uma sessão com o servidor MySQL. Se nenhum argumento for fornecido, ele usa os valores já configurados ou padrão.
  • .close() – Fecha a conexão com o servidor e as transações.
  • .execute() – Este método executa a operação

📌Conexão usando o mysql.connector:

import mysql.connector

Importamos a biblioteca do mysql.connector

import mysql.connector

connection = mysql.connector.connect(
	host="localhost",
	user="root",
	passwd="root",
	database="codenglish"
)

Em seguida, temos que estabelecer a conexão. Para isso, você deve fornecer as informações de host, usuário, senha e o database que se quer trabalhar.

if connection.is_connected():
	cursor = connection.cursor()
	cursor.execute('select database();')
	db = cursor.fetchone()
	print(f'Connection at database {db} successfully!')

Para obtermos informações sobre a conexão estabelecida, usaremos o método .is_connected(), que relata se a conexão com o servidor MySQL está disponível. O método .fetchone() retorna uma linha de um conjunto de resultados de consulta ou None caso não haja essa linha.

if connection.is_connected():
	cursor.close()
	connection.close()
	print('Connection closed!')

Caso esteja tudo certo com a conexão, podemos encerrar a comunicação com o servidor.


📌Conectando com PyMySQL

Com ela, vou preencher a tabela através do código e as alterações serão salvas no banco de dados.

import pymysql

connection = pymysql.connect(
	host="localhost",
	db="codenglish",
	password="root"
	user="root"
)

Começamos pela importação da biblioteca e inserimos as informações do servidor MySQL.


cursor = connection.cursor()

name = str(input('Seu nome: '))
age = int(input('Sua idade: '))

cursor.execute(f'INSERT INTO people VALUES (`{name}`, {age})')

Utilizamos o método cursor e criamos um input para receber os dados no terminal da IDE, e em seguida usamos a sintaxe do MySQL para os dados serem armazenados no banco.


if connection.cursor():
	print(f'{name} registered!')

connection.commit()
connection.close()

Se ocorreu tudo bem, sinalizei que a pessoa foi cadastrada e fechei a conexão.


SELECT * FROM peoples;

Para saber se está armazenado no banco de dados, faça um select na tabela.

Sucesso! A conexão com o servidor foi estabelecida.

✅Conclusão

Existem muitos métodos em que você pode brincar com seu banco de dados através do Python. Para se aventurar mais, acesse este site consultando o documentação oficial MySQL.

PyMySQL: a biblioteca para MySQL com Python

Introdução

Toda aplicação tem como a principal funcionalidade a persistência dos dados inseridos informados nela. Estes dados devem ser salvos de alguma forma, o responsável por isso é um sistema de banco de dados. Este programa se utiliza de uma linguagem específica para estruturar, organizar e consultar estes dados, essa linguagem é chamada de SQL, do inglês, Structured Query Language, ou Linguagem de Consulta Estruturada. Há diversas ferramentas no mercado: MySQL, PostgreSQL, SQL Server, e tantas outras, mas nos ateremos à primeira.

Para este tutorial é necessário você possuir o MySQL instalado em sua máquina, caso não tenha, acesse aqui. Para facilitar sua vida, você também pode utilizar o MySQL Workbench, para ter uma interface mais fácil de acesso a ele.

Utilizaremos da biblioteca PyMySQL para comunicação entre nosso programa feito em Python com o banco de dados MySQL.

Mão na massa

Tendo nosso ambiente de desenvolvimento pronto, vamos criar um banco de dados em nosso MySQL, para podermos salvar nossos dados nele.

CREATE DATABASE codenglish;

USE codenglish;

CREATE TABLE participant (
  registration VARCHAR(20) PRIMARY KEY,
  name VARCHAR(50),
  course VARCHAR(20),
  birthdate DATE
);

Criamos o banco de dados codenglish, acessamos ele e criamos uma tabela participant para registrarmos a matrícula, nome, curso e data de nascimento dos participante do projeto CodEnglish. Agora vamos para o Python, que será o responsável por capturar os dados.

Primeiramente, devemos instalar a biblioteca PyMySQL via pip:

$ python3 -m pip install PyMySQL

A partir disso, em qualquer arquivo .py (vou chamar de app.py) podemos fazemos a conexão com o banco de dados por meio dela através da biblioteca PyMySQL:

from pymysql import connect

database = connect(host="localhost",
                   user="root",
                   password="root",
                   database="codenglish")

Vamos capturar alguns dados do usuário para inserir em nossa base:

registration = str(input('Seu número de matricula: '))
name = str(input('Seu nome: '))
course = str(input('Seu curso: '))
birthdate = str(input('Nascimento (yyyy-mm-dd): '))

Agora inserimos estes dados no banco:

with database:
    with database.cursor() as cursor:
				# Comando para inserir os dados na tabela 'participant'
        insert_participant_query = "INSERT INTO participant (registration,name,course,birthdate) VALUES (%s, %s, %s, %s)"

				# Executamos a consulta
        cursor.execute(insert_participant_query,
                       (registration, name, course, birthdate))
        print(f'Participante "{name}" cadastrado!')

		# Confirmamos que a operação deve ser realizada
    database.commit()

Para deixar mais interessante, colocamos a escolha para o usuário listar todos os participantes já cadastrados:

with database:
	...
	list_participants = str(
	  input('Você quer listar todos os participantes? [y/N] ')).lower()[0]
	
    if list_participants == 'y':
      with database.cursor() as cursor:
				# Query para selecionar todos os dados na tabela 'participant'
        list_all_participants_query = "SELECT name, course FROM participant"
        cursor.execute(list_all_participants_query)
				# Pegamos todos os dados
        list_all_participants = cursor.fetchall()

        print('Nome\\tCurso')
				# Percorremos todos as tuplas na lista de registros da tabela e mostramos
        [print(f'{participant[0]}\\t{participant[1]}')
         for participant in list_all_participants]

Ao final, temos o seguinte código:

from pymysql import connect

database = connect(host="localhost",
                   user="root",
                   password="root",
                   database="codenglish")

registration = str(input('Seu número de matricula: '))
name = str(input('Seu nome: '))
course = str(input('Seu curso: '))
birthdate = str(input('Nascimento (yyyy-mm-dd): '))

with database:
    with database.cursor() as cursor:
        insert_participant_query = "INSERT INTO participant (registration,name,course,birthdate) VALUES (%s, %s, %s, %s)"

        cursor.execute(insert_participant_query,
                       (registration, name, course, birthdate))
        print('Você foi cadastrado!')

    database.commit()

    list_participants = str(
        input('Você quer listar todos os participantes? [y/N] ')).lower()[0]

    if list_participants == 'y':
        with database.cursor() as cursor:
            list_all_participants_query = "SELECT name, course FROM participant"
            cursor.execute(list_all_participants_query)
            list_all_participants = cursor.fetchall()

            print('Nome\\tCurso')
            [print(f'{participant[0]}\\t{participant[1]}')
             for participant in list_all_participants]

Conclusão

Fizemos uma rápida brincadeira para trabalhar com banco de dados MySQL com Python. Mas não precisamos nos limitar a isso, tem conceitos muito mais avançados no estudo de bancos. Em uma futura postagem, pretendo apresentar a você uma maneira mais sofisticada de comunicação com banco de dados, independente de qual seja o famoso ORM.

Agradeço aqui sua atenção, continue aprendendo mais em nossa plataforma, acessando outras postagens. Até a próxima.

Orientação a Objetos em Python

Quando começamos a programar em qualquer linguagem de programação, temos que seguir um padrão de escrita de código, essa forma de construir nosso algoritmo é chamado de paradigma.

Existem diversos paradigmas de programação: Estrutural, Procedural, Imperativo, Declarativo, Funcional e Orientado a Objetos. Este último é o que abordaremos neste artigo.

O que é?

A Programação Orientada a Objetos foi conceituada por Alan Kay, que se baseou em conceitos de biologia e matemática, pois fazia parte da formação do Alan. Além de idealizar esta a POO, ele criou a primeira linguagem que implementava a Orientação a Objetos, a linguagem Smalltalk.

A ideia de Kay é trazer para a computação o mundo real, físico, partindo do pressuposto de que tudo no mundo real é um objeto, que interage com outros objetos, e estes podem ser classificados.

Definição

Como tudo em nosso mundo, os objetos precisam ser criados a partir de algo, uma fôrma, uma classe.

Os objetos em nosso mundo possuem características individuais, uma pessoa é identificada por um CPF, RG e nome, estes são seus atributos. Mas estes podem também ter comportamentos, ações, como um controle de TV, que liga, desliga a TV, muda de canal, altera o volume, uma forma, um método deste objeto interagir.

Com isto em mente, já temos os alicerces da OO: Classes, Objetos, Atributos e Métodos. Mas estes conceitos são para construir formar a ideia de POO, mas para considerar que uma linguagem é OO devem ser levados em consideração os pilares deste paradigma: Abstração, Herança, Encapsulamento e Polimorfismo.

Implementação

Uma classe Pessoa em Python:

class Person:
	def __init__(self, first_name, last_name, document):
		self.first_name = first_name
		self.last_name = last_name
		self.document = document

	def full_name(self):
		return f'{self.first_name} {self.last_name}'

Uma vantagem no Python é sua sintaxe muito parecida com a humana, logo, usamos a palavra-chave class e o nome que queremos dar a nossa classe. Em seguida, definimos o método inicializador (também chamado de construtor, em outras linguagens) que é executado assim que criamos um objeto da classe Pessoa, que recebe os atributos que são atribuídos à instância de Pessoa, por meio do parâmetro self. Também definimos um método full_name para retorna o nome completo de uma Pessoa.

class Worker(Person):
	def __init__(self, work):
		Person().__init__(self)
		self.work = work

robert = Person('Robert', 'Perteson', '65778901934')
bill = Worker('Bill', 'Gates', '23490856721', 'Ex Microsoft CEO')

people = (robert, bill)

for person in people:
	print(person.full_name())

Temos agora uma classe Trabalhador que herda os mesmos atributos e método de Pessoa, apenas com um novo atributo que é seu ‘trabalho’. Instanciamos ao final dois objetos de cada classe em uma tupla, e iteramos sobre a mesma. Note que acessamos cada valor da tupla e executamos um método que é comum as estes objetos, independente da forma da classe, tendo este método, será executado, isto é polimofismo.

O encapsulamento é basicamente se um dado, seja atributo ou método, deve ser escondido de quem utilizará tal classe. Um dado pode ter um de três modos de acesso: público, privado e protegido. Voltemos a nossa classe Pessoa e Work.

class Person:
	def __init__(self, first_name, last_name, document):
		self.first_name = first_name
		self.last_name = last_name
		self._document = document

	def full_name(self):
		return f'{self.first_name} {self.last_name}'

class Worker(Person):
	def __init__(self, work, salary):
		Person().__init__(self)
		self.work = work
		self.__salary = salary

Em Python, usamos uma convenção (um padrão na comunidade e linguagem) que todo método ou atributo com um ‘_’ (underscore) é protegido, com 2 ‘_’ é privado, quando não possui, então é público. Em Pessoa, o ‘documento’ é protegido, acessado apenas pela classe e quem herda ela. Mas o ‘salário’ é acessível apenas pela classe/objeto Trabalhador, logo, privado.

Conclusão

A essência do Python é a Orientação a Objetos, e de longe, é uma das linguagem que implementa de forma mais fácil e compreensível, outra muito legal que também é OO é Ruby, que recomendo dar uma pesquisada. Por fim, espero ter esclarecido este assunto de POO com Python. Até a próxima.

Referências

POO: tudo sobre Programação Orientada a Objetos!

Encapsulation in Python – GeeksforGeeks

Polymorphism in Python – GeeksforGeeks

Inheritance in Python – GeeksforGeeks

Fique Zen com Python

📍Introdução

Com certeza, se você conhece o Python hoje foi por que algo te chamou a atenção. Deixa eu adivinhar… A runtime dele! Acertei? Claro que não, foi a escrita de código. A forma simples e objetiva dessa linguagem é um dos fatores que sem dúvida leva ela ser uma das mais queridas e em ascensão no mundo de programação, como mostram algumas pesquisas.

Mas uma das melhores coisas dentro dessa língua das serpentes é um easteregg conhecido com Zen of Python, onde temos um conjunto de princípios (ou filosofia) para escrever código a la Python. Mas estas práticas propostas por Tim Peters (conhecida também por PEP 20) não é algo exclusivo desta linguagem, mas é aplicável a qualquer uma, respeitando suas especificidades, evidentemente, a fim de se ter um bom design de código.

Mas vamos logo ao nosso prato principal.

🐣Easter Egg

Como uma filosofia, você deve trazer o Zen do Python para sua vida, importar para sua prática de codificação, simples assim:

>>> import this
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one—and preferably only one—obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea—let's do more of those!

E aqui estão nossos princípios baseados nos mantras para um código Pythonico: Legível, Explícito e Simples. Boa parte destes pontos são auto explicativos, mas vamos abordar cada um.


Beautiful is better than ugly.

Logicamente, bonito é melhor que feio. Dentre os diversos caminhos que podemos ter para chegar a uma solução, escolha sempre o algoritmo mais bonito visualmente.

👿

if major(person) && not isNegative(person) || rich(person): return 'borrow money'

Explicit is better than implicit.

Por ser bastante flexível, você poderá ter diversas formas de chegar no seu objetivo, mas é bom que fique tudo bem claro, melhor dizendo, explícito, para quem ver aquele código entenda o que está sendo feito, sem deduções ou hipótese, seja parente aos olhos. Então não esconda partes do seu código.


Simple is better than complex.

Aqui está o ponto central, que liga os dois primeiros mantras, a simplicidade deve imperar. Não adianta ter um código bonito e explícito, se fica algo muito complexo, para isso um boa prática seria dividir em pequenos pedaços.


Complex is better than complicated.

Mas se a complexidade é inerente à sua solução, não deixe ela complicada, pois isto poupará dores de cabeça futuras. Siga design patterns e princípios como SOLID, DRY e KISS para ter algo complexo para execução, mas não complicado para manutenção.


Flat is better than nested.

As únicas pessoas que podem usar o hadouken é o Ryu e o Ken de Street Fighter, programadores NÃO! Como Python se utiliza de indentação para delimitar blocos de código, não aninhe muitas estruturas em outras estruturas, deixe o plano possível, próximo à esquerda.


Sparse is better than dense.

Não amontoe muito código em uma linha de código, porque bonito é melhor que feio.

👿

...
print('Reprovado') if nota < 5 else print('Recuperação') if nota <= 5 and nota < 7 else print('Aprovado')

😇

if nota < 5:
	print('Reprovado')
elif nota <= 5 and nota < 7:
	print('Recuperação')
elif nota >= 7:
	print('Aprovado')

Readability counts.

Sempre tenha em mente que ninguém é oniciente para adivinhar o que você quer dizer com seu código, então justifique a razão da existência de cada variável, função e classe pela sua declaração, para melhor legibilidade.

👿

x = ['Maçã', 'Banana', 'Uva']

for z in x:
	print(f'Comprar: {z}')

😇

lista_de_compras = ['Maçã', 'Banana', 'Uva']

for item in lista_de_compras:
	print(f'Comprar: {item}')

Special cases aren’t special enough to break the rules. Although practicality beats purity.


Errors should never pass silently. Unless explicitly silenced.

Todas as falhas devem ser vistas, jamais ignoradas, por isso é importante tratá-las.

👿

try:
	data_from_api = request_to_my_service(...)
	...
except:
	pass

😇

try:
	data_from_api = request_to_my_service(...)
	...
except RequestException as execption:
	fail_handler(exception)
	print(exception)
	raise exception

In the face of ambiguity, refuse the temptation to guess.

Quando seu código expõe possibilidades de ocorrer erros antecedidos de certas condições, essas condições irão ser atendidas, e seu código irá se comportar de forma inesperada.


There should be one—and preferably only one—obvious way to do it. Although that way may not be obvious at first unless you’re Dutch.

Uma boa prática em Python é que você utilize apenas uma única solução bonita, simples e legível para seu problema. Isso é o que possibilita a facilidade em desenvolver softwares com essa linguagem. Se fosse mais difícil, ainda assim seria fácil, somente para Guido van Rossum, criador do Python (que é um Holandês).


Now is better than never. Although never is often better than right now.

Pensou em algo, execute agora. Conforme vai se aprimorando a ideia, ela ficará pythonicamente bonita.


If the implementation is hard to explain, it’s a bad idea.

Se a implementação da sua aplicação gerou dúvidas e não lhe agradou, pythonicamente, você deve revisá-la, a fim de alinhá-la com o Zen.


If the implementation is easy to explain, it may be a good idea.

O fato de ser uma ideia fácil de explicar, não resultará necessariamente em boa implementação.


Namespaces are one honking great idea—let’s do more of those!

Namespaces são uma forma de agregar componentes (objetos, classes, funções) relacionados a um mesmo contexto, permitindo a simplicidade e a legibilidade, por isso uma boa ideia.

😇

import entities.people as people
import entities.product as product

def buy(buyer: people.Person, item: product.Product):
	return buyer.buy(item)

fruit = product.Product('Apple', '0.5')
person = people.Person('Alex Anderson')

print(buy(person, fruit))

Referências

Zen of Python | Python Academy

O Zen do Phyton