Tutorial de Python e MariaDB: Conexão, CRUD, Transações e Tratamento de Erros

1. Introdução

Para quem quer trabalhar com MariaDB em Python

Muitas pessoas desejam conectar ao MariaDB usando Python e manipular dados. Neste artigo, explicaremos tudo, desde o básico até tópicos mais avançados, para trabalhar com MariaDB usando Python.

Você tem algum destes problemas?

• Você não sabe como conectar ao MariaDB a partir do Python
• Você quer criar, ler, atualizar e excluir dados no MariaDB de forma simples usando Python
• Você quer aprender sobre erros comuns e como corrigi‑los

O que você aprenderá neste artigo

• Como conectar ao MariaDB a partir do Python de forma simples
• Como implementar CRUD (Create, Read, Update, Delete)
• Erros comuns e suas soluções
• Como proteger a integridade dos dados com transações

Depois de ler este artigo, você será capaz de trabalhar de forma fluida com MariaDB usando Python. Agora, vamos aos detalhes.

2. Configuração do Ambiente (Instalando MariaDB & Python)

O que é MariaDB?

MariaDB é um sistema de gerenciamento de banco de dados relacional (RDBMS) de código aberto, amplamente usado como sucessor do MySQL. Enquanto mantém alta compatibilidade com o MySQL, o MariaDB oferece desempenho aprimorado e novos recursos.

Ferramentas necessárias

Para trabalhar com MariaDB em Python, você precisa preparar as seguintes ferramentas:

• Python (versão 3.x ou superior recomendada)
• MariaDB (servidor)
• Conector Python para MariaDB (a biblioteca mariadb)

Como instalar o MariaDB (por SO)

Para Windows

1. Baixe o instalador do MariaDB no site oficial .
2. Execute o instalador e siga as instruções para concluir a instalação.
3. Após a instalação, verifique se o MariaDB está funcionando executando o comando a seguir:

   mysql -u root -p
   

4. Se conseguir fazer login com sucesso, a instalação está concluída.

Para Mac

No Mac, você pode instalar o MariaDB facilmente usando o Homebrew.

1. Se o Homebrew não estiver instalado, instale‑o com o comando a seguir:

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
   

2. Instale o MariaDB:

   brew install mariadb
   

3. Inicie o MariaDB:

   brew services start mariadb
   

4. Verifique a instalação:

   mysql -u root -p
   

Para Linux (Ubuntu)

1. Atualize a lista de pacotes e instale o MariaDB:

   sudo apt update
   sudo apt install mariadb-server mariadb-client
   

2. Inicie o MariaDB:

   sudo systemctl start mariadb
   

3. Habilite o MariaDB (início automático na inicialização):

   sudo systemctl enable mariadb
   

4. Execute o script de instalação segura:

   sudo mysql_secure_installation
   

Isso permite definir a senha do root e remover configurações padrão desnecessárias.

Instalando Python e a biblioteca necessária

Para integrar o MariaDB ao Python, você precisa instalar a biblioteca mariadb.

1. Instale a biblioteca mariadb usando o pip :

   pip install mariadb
   

2. Verifique a instalação:

   import mariadb
   print("The MariaDB library was installed successfully.")
   

Se nenhum erro ocorrer, a instalação foi bem‑sucedida.

Agora a configuração do seu ambiente para usar Python com MariaDB está completa. Em seguida, explicaremos como conectar ao MariaDB a partir do Python.

3. Conectando ao MariaDB

Como conectar ao MariaDB com Python

Importar a biblioteca necessária

Para conectar ao MariaDB, importe a biblioteca Python mariadb.

import mariadb

Código básico para conectar ao banco de dados

O código a seguir mostra a forma básica de conectar ao MariaDB usando Python.

import mariadb

# Database connection settings
config = {
    "host": "localhost",   # Hostname of the MariaDB server
    "user": "root",        # MariaDB username
    "password": "password", # MariaDB password
    "database": "sample_db" # Database name to connect to
}

try:
    # Connect to MariaDB
    conn = mariadb.connect(**config)
    print("Connected to MariaDB!")

    # Criar um cursor
    cursor = conn.cursor()

    # Se a conexão for bem-sucedida, feche-a
    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erro de conexão: {e}")

About the arguments of connect()

If the server is remote, specify an IP address or domain name in host.

A secure connection method using environment variables

Hardcoding sensitive information such as passwords directly in your code is a security risk. By using environment variables, you can manage them more safely.

Install python-dotenv

First, install a library to manage environment variables.

pip install python-dotenv

Create a .env file and write your connection settings

Create a .env file in your project folder and add your connection settings like this:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=password
DB_NAME=sample_db

Load environment variables in your Python script

To load the .env file in a Python script, write the following:

import mariadb
import os
from dotenv import load_dotenv

# Carregar o arquivo .env
load_dotenv()

config = {
    "host": os.getenv("DB_HOST"),
    "user": os.getenv("DB_USER"),
    "password": os.getenv("DB_PASSWORD"),
    "database": os.getenv("DB_NAME")
}

try:
    conn = mariadb.connect(**config)
    print("Conectado com segurança ao MariaDB!")
    conn.close()
except mariadb.Error as e:
    print(f"Erro de conexão: {e}")

Common connection errors and how to fix them

Below are some errors you may encounter when connecting Python to MariaDB, along with their solutions.

Access denied for user 'root'@'localhost'

Error message

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Causes

• The user’s credentials are incorrect
• MariaDB authentication settings are not configured properly

Solutions

1. Log in to MariaDB and check the user’s privileges.

   mysql -u root -p
   

2. Grant the required privileges to the user.

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Try connecting again.

Can't connect to MySQL server on 'localhost'

Error message

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Causes

• The MariaDB server is not running
• The host setting is incorrect

Solutions

1. Check whether the server is running.

   sudo systemctl status mariadb
   

2. If the server is stopped, start it.

   sudo systemctl start mariadb
   

3. Check that the host setting is correct.

Summary

In this section, we explained how to connect to MariaDB from Python.

• Basic connection method using mariadb.connect()
• A secure connection method using a .env file
• Common connection errors and how to fix them

4. Creating Databases and Tables

Creating a database

In MariaDB, you need to create a database to store data. Let’s look at how to create a database using Python.

Create a database using a MariaDB management tool

You can create a database using the MariaDB command line (or GUI tools such as MySQL Workbench).

CREATE DATABASE sample_db;

To view the list of databases you created, use the following command:

SHOW DATABASES;

Create a database using Python

To create a database using Python, run the following code:

import mariadb

# Conexão ao banco de dados (sem banco especificado)
config = {
    "host": "localhost",
    "user": "root",
    "password": "password"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Criar o banco de dados
    cursor.execute("CREATE DATABASE IF NOT EXISTS sample_db")

    print("Banco de dados 'sample_db' criado.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Ocorreu um erro: {e}")

By adding IF NOT EXISTS, you can prevent errors if a database with the same name already exists.

Creating a table

After creating the database, the next step is to create a table to store data.

Basic table structure

A table typically has a structure like the following:

Create a table with SQL

If you create a table using MariaDB SQL commands, write the following:

USE sample_db;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

To view the list of tables, run:

SHOW TABLES;

Create a table using Python

Here is how to create the same table using a Python script.

import mariadb

# Conexão com o banco de dados
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # SQL de criação da tabela
    table_creation_query = """
    CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(100) NOT NULL,
        email VARCHAR(100) UNIQUE NOT NULL,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )
    """

    cursor.execute(table_creation_query)
    print("Tabela 'users' criada.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Ocorreu um erro: {e}")

By adding IF NOT EXISTS, you can prevent errors if the table already exists.

How to choose data types

When designing tables, it is important to choose appropriate data types. Below is a summary of commonly used data types in MariaDB.

For example, it is common to use VARCHAR(100) for the name field, but if you need a longer string, TEXT can be a good option.

How to check and drop existing tables

Check existing tables

To check the tables in a database, use the following SQL:

SHOW TABLES;

To view a table’s detailed structure, run the DESCRIBE command:

DESCRIBE users;

Drop a table

To drop a table, use DROP TABLE:

DROP TABLE users;

To drop a table from Python, run the following code:

cursor.execute("DROP TABLE IF EXISTS users")

Summary

In this section, we explained how to create databases and tables in MariaDB to store data.

• How to create a database in MariaDB
• How to create a table using Python
• How to choose appropriate data types
• How to check and drop existing tables

Now the basic setup for MariaDB is complete. In the next section, we will explain CRUD operations (Create, Read, Update, Delete) in detail.

5. CRUD Operations (Create, Read, Update, Delete)

After creating the MariaDB database and tables, the next step is to perform CRUD operations. CRUD stands for Create, Read, Update, and Delete, which are the basic operations of a database.

In this section, we will explain how to manipulate MariaDB data using Python.

Inserting data (INSERT)

To add a new record to the database, use the INSERT statement.

Insert data using SQL

To insert data using MariaDB SQL, execute the following command:

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');

To verify the inserted data, use the SELECT statement:

SELECT * FROM users;

Insert data using Python

To insert data using Python, run the following code:

import mariadb

# Configurações de conexão com o banco de dados
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Inserir dados
    insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
    data = ("Alice", "alice@example.com")
    cursor.execute(insert_query, data)

    # Salvar alterações
    conn.commit()
    print("Dados inseridos com sucesso!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erro ocorrido: {e}")

Key points:

• Using ? placeholders helps prevent SQL injection.
• If you do not execute conn.commit() , the data will not be saved to the database.

Retrieving data (SELECT)

To retrieve registered data, use the SELECT statement.

Retrieve data using SQL

To retrieve data using MariaDB SQL:

SELECT * FROM users;

To retrieve data with conditions, use the WHERE clause:

SELECT * FROM users WHERE email = 'alice@example.com';

Retrieve data using Python

To retrieve data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Recuperar dados
    select_query = "SELECT id, name, email FROM users"
    cursor.execute(select_query)

    # Exibir dados recuperados
    for (id, name, email) in cursor:
        print(f"ID: {id}, Name: {name}, Email: {email}")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erro ocorrido: {e}")

Key points:

• Execute SQL with cursor.execute(select_query) and retrieve data from the cursor object.
• You can process records one by one using a for loop.

Updating data (UPDATE)

To modify registered data, use the UPDATE statement.

Update data using SQL

To update data using MariaDB SQL, execute:

UPDATE users SET name = 'Alice Smith' WHERE email = 'alice@example.com';

Update data using Python

To update data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Atualizar dados
    update_query = "UPDATE users SET name = ? WHERE email = ?"
    data = ("Alice Smith", "alice@example.com")
    cursor.execute(update_query, data)

    # Salvar alterações
    conn.commit()
    print("Dados atualizados com sucesso!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erro ocorrido: {e}")

Deleting data (DELETE)

To remove unnecessary data, use the DELETE statement.

Delete data using SQL

To delete data using MariaDB SQL, execute:

DELETE FROM users WHERE email = 'alice@example.com';

Delete data using Python

To delete data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Excluir dados
    delete_query = "DELETE FROM users WHERE email = ?"
    data = ("alice@example.com",)
    cursor.execute(delete_query, data)

    # Salvar alterações
    conn.commit()
    print("Dados excluídos com sucesso!")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erro ocorrido: {e}")

Summary

In this section, we explained how to manipulate MariaDB data using Python.

• Insert data (INSERT)
• Retrieve data (SELECT)
• Update data (UPDATE)
• Delete data (DELETE)

You can now perform basic data operations in MariaDB using Python.

6. Transactions and Rollback (Ensuring Data Integrity)

Quando se trabalha com um banco de dados, é importante usar transações para manter a integridade dos dados.
Em particular, a capacidade de restaurar os dados ao seu estado original (rollback) quando ocorre um erro durante o processamento é essencial para manter a consistência.

Nesta seção, explicaremos como gerenciar transações no MariaDB usando Python.

O que é uma transação?

Uma transação é um mecanismo que agrupa uma série de operações de banco de dados em uma única unidade, confirma todas as alterações se todo o processo for bem‑sucedido e desfaz todas as alterações se ocorrer um erro.

Características das transações

• Propriedades ACID
• Atomicidade: Todas as operações são concluídas com sucesso ou nenhuma é aplicada.
• Consistência: A integridade dos dados é mantida.
• Isolamento: Transações concorrentes não interferem umas nas outras.
• Durabilidade: Uma vez confirmadas, as alterações são salvas permanentemente.

Operações básicas de transação (COMMIT e ROLLBACK)

As transações no MariaDB podem ser controladas com os seguintes comandos:

Usando transações em Python

Abaixo está um exemplo básico de gerenciamento de transações no MariaDB usando Python.

Gerenciando múltiplas operações dentro de uma única transação

O código a seguir trata várias operações de inserção como uma única transação e confirma apenas se todas as operações forem bem‑sucedidas.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    # Insert data
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Bob", "bob@example.com"))
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Charlie", "charlie@example.com"))

    # Commit if all operations succeed
    conn.commit()
    print("Data added successfully.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Error occurred: {e}")
    conn.rollback()  # Roll back if an error occurs

Pontos principais

• Use conn.start_transaction() para iniciar uma transação.
• Use conn.commit() para finalizar as alterações (não podem ser desfeitas após o commit).
• Se ocorrer um erro, use conn.rollback() para cancelar as alterações e restaurar o estado original.

Tratamento de erros baseado em transação

Erros podem ocorrer durante as operações de banco de dados.
Por exemplo, um endereço de e‑mail duplicado (violação de restrição UNIQUE) ou um tempo limite do servidor podem acontecer.

Gerenciamento de transação com tratamento de erro

O código a seguir adiciona lógica para desfazer as alterações e restaurar o estado original se ocorrer um erro durante o processamento.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    try:
        # First insert succeeds
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Dave", "dave@example.com"))

        # Second insert causes an error (duplicate email)
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Eve", "dave@example.com"))

        # Commit if all operations succeed
        conn.commit()
        print("Data inserted successfully.")

    except mariadb.Error as e:
        print(f"Error occurred during data processing: {e}")
        conn.rollback()  # Roll back on error
        print("Transaction rolled back.")

    cursor.close()
    conn.close()

except mariadb.Error as e:
    print(f"Database connection error: {e}")

Resumo

Nesta seção, explicamos os fundamentos das transações e como implementá‑las em Python.

• A importância das transações e das propriedades ACID
• Como usar commit() e rollback() em Python
• Gerenciamento de transação combinado com tratamento de erro

7. Tratamento de Erros (Erros Comuns e Soluções)

Ao trabalhar com MariaDB em Python, podem ocorrer erros.
Em particular, erros de conexão ao banco de dados, erros de sintaxe SQL e erros de integridade de dados são comuns, portanto é importante entender suas causas e soluções.

Nesta seção, apresentamos as causas dos erros comuns e como corrigi-los.

Access denied for user (Erro de autenticação)

Error message

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Causa

• O nome de usuário ou a senha está incorreto(a)
• O usuário do MariaDB não possui os privilégios adequados

Solução

1. Faça login no MariaDB e verifique os privilégios do usuário

   mysql -u root -p
   

2. Conceda privilégios ao usuário

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Reinicie o MariaDB

   sudo systemctl restart mariadb
   

Can't connect to MySQL server on 'localhost' (Erro de conexão)

Error message

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Causa

• O servidor MariaDB não está em execução
• A configuração host está incorreta

Solução

1. Verifique se o servidor MariaDB está em execução

   sudo systemctl status mariadb
   

2. Se o servidor estiver parado, inicie-o

   sudo systemctl start mariadb
   

3. Configure o servidor para iniciar automaticamente

   sudo systemctl enable mariadb
   

Unknown database 'sample_db' (Banco de dados não existe)

Error message

mariadb.ProgrammingError: Unknown database 'sample_db'

Causa

• O banco de dados especificado não existe
• Há um erro de digitação no nome do banco de dados

Solução

1. Verifique a lista de bancos de dados

   SHOW DATABASES;
   

2. Crie o banco de dados se ele não existir

   CREATE DATABASE sample_db;
   

Table doesn't exist (Tabela não existe)

Error message

mariadb.ProgrammingError: Table 'sample_db.users' doesn't exist

Causa

• A tabela especificada não existe
• O banco de dados não foi selecionado usando USE sample_db;

Solução

1. Verifique a lista de tabelas

   SHOW TABLES;
   

2. Crie a tabela se ela não existir

   CREATE TABLE users (
       id INT AUTO_INCREMENT PRIMARY KEY,
       name VARCHAR(100) NOT NULL,
       email VARCHAR(100) UNIQUE NOT NULL,
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
   );
   

Duplicate entry (Erro de entrada duplicada)

Error message

mariadb.IntegrityError: Duplicate entry 'alice@example.com' for key 'users.email'

Causa

• A coluna email tem uma restrição UNIQUE, portanto valores duplicados não podem ser inseridos

Solução

• Verifique duplicatas antes de inserir dados
• Use ON DUPLICATE KEY UPDATE

Código Python para evitar duplicatas

try:
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
    conn.commit()
except mariadb.IntegrityError:
    print("Error: The email address already exists.")

Ou use ON DUPLICATE KEY UPDATE

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
ON DUPLICATE KEY UPDATE name = 'Alice Updated';

Incorrect number of bindings (Número incorreto de ligações)

Error message

mariadb.ProgrammingError: Incorrect number of bindings supplied. The current statement uses 2, and there are 1 supplied.

Causa

• O número de parâmetros exigidos pela instrução SQL não corresponde ao número de argumentos fornecidos

Solução

• Certifique-se de que o número de placeholders corresponde ao número de parâmetros

Código incorreto

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice"))

Código correto

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))

Resumo

Nesta seção, explicamos erros comuns que ocorrem ao trabalhar com MariaDB em Python e como resolvê‑los.

• Access denied for user (Erro de autenticação)
• Can't connect to MySQL server (Erro de conexão)
• Unknown database (Banco de dados não existe)
• Table doesn't exist (Tabela não existe)
• Duplicate entry (Erro de dados duplicados)
• Incorrect number of bindings (Incompatibilidade no número de parâmetros)

8. Conclusão

Neste artigo, explicamos como trabalhar com MariaDB usando Python, desde conceitos básicos até tópicos mais avançados. Ao compreender as operações fundamentais de banco de dados e implementar corretamente o tratamento de erros e o gerenciamento de transações, você pode realizar operações de dados mais seguras e eficientes.

Recapitulação do artigo

Configuração do ambiente

• Como instalar o MariaDB (Windows / Mac / Linux)
• Como instalar a biblioteca conector do MariaDB (mariadb) para Python

Conectando ao MariaDB

• Métodos básicos de conexão ao banco de dados
• Conexões seguras usando variáveis de ambiente
• Soluções para erros de conexão comuns

Criando bancos de dados e tabelas

• Criando bancos de dados (SQL / Python)
• Criando tabelas e escolhendo tipos de dados
• Verificando e removendo tabelas existentes

Operações CRUD (Create, Read, Update, Delete)

• Operações básicas de dados usando Python
• Usando placeholders para prevenir injeção de SQL
• Tratamento adequado de erros

Transações e rollback

• A importância das transações (propriedades ACID)
• Como restaurar dados em caso de erro (rollback)
• Gerenciando transações manualmente desativando o AutoCommit

Tratamento de erros (Erros comuns e soluções)

• Erros de autenticação (Access denied for user)
• Erros de conexão (Can't connect to MySQL server)
• Erros de banco de dados ou tabela não encontrada
• Erros de dados duplicados (Duplicate entry)
• Tratamento de deadlocks e implementação de lógica de repetição

Pontos‑chave ao combinar Python e MariaDB

1. Use placeholders

   cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
   

→ Vincule variáveis ao invés de incorporá‑las diretamente nas instruções SQL para prevenir injeção de SQL.

2. Gerencie transações adequadamente

• Use conn.commit() para confirmar explicitamente as alterações.
• Use conn.rollback() em caso de erro para manter a integridade dos dados.

3. Implemente tratamento de erros abrangente

• Use blocos try-except para capturar potenciais erros antecipadamente.
• Prepare estratégias específicas de tratamento para erros como OperationalError e IntegrityError.

4. Considere o desempenho

• Inserções em lote (inserir múltiplos registros de uma vez)
• Indexação adequada (melhorar o desempenho de buscas)

Recursos para aprendizado adicional

Se você deseja aprofundar seu entendimento sobre a integração de Python e MariaDB, considere os recursos a seguir:

Documentação oficial

• MariaDB Official Documentation

Conteúdo de aprendizado relacionado

• SQL Basics (W3Schools)
• Database Operations with Python (Real Python)

Livros recomendados

• SQL, 2ª Edição: Operações de Banco de Dados do Zero – Aprenda os fundamentos do SQL de forma completa
• Effective Python: 90 Maneiras Específicas de Melhorar Seus Programas Python – Aprenda as melhores práticas de Python

Resumo

Ao integrar MariaDB com Python, você pode habilitar gerenciamento de dados baseado em scripts e automação. Implementando não apenas as operações CRUD básicas, mas também o tratamento adequado de erros e o gerenciamento de transações, você pode construir um sistema mais seguro e eficiente.

Como próximo passo, considere aprender sobre gerenciamento de dados eficiente e integração de API para aplicar seu conhecimento a operações práticas de banco de dados.