Aprenda python do zero comigo (4) programação de banco de dados: banco de dados MySQL

prefácio

Olhando para trás, eu falei sobre programação de sintaxe python, fundamentos introdutórios obrigatórios e programação de rede, multi-threading/multi-processo/co-rotina, etc. não precisa avançar. A série de artigos foi resolvida. :

1. Aprenda python do zero comigo (1) Gramática de programação obrigatória
2. Aprenda python do zero comigo (2) Programação de rede
3. Aprenda python do zero comigo (3) Multi-thread/multi-processo/ co-rotina

Este artigo fala sobre: ​​Programação de banco de dados Python: banco de dados MySQL

Esta série de artigos é baseada nas seguintes rotas de aprendizagem. Devido ao grande conteúdo:

Aprenda python do zero ao roteiro avançado avançado

Preste atenção na conta oficial: campo de treinamento de tecnologia python , aprenda passo a passo avançado

Recursos do Python adequados para aprendizado baseado em zero e pessoas avançadas:

① Projeto completo de python certificado pela Tencent, notas práticas do tutorial em PDF
② Mais de uma dúzia de tópicos de entrevistas em python dos principais fabricantes PDF
③ Conjunto completo de tutoriais em vídeo Python (reverso JS avançado avançado zero)
④ Centenas de combate real do projeto + código-fonte + notas
⑤ Programação gramática - aprendizado de máquina -desenvolvimento de pilha completa-análise de dados-crawler-APP engenharia reversa e outro conjunto completo de projetos + documentos
⑥ Troca e estudo
⑦ Quer receber pedidos de meio período

O próximo capítulo: banco de dados Redis

1. Banco de dados MySQL

banco de dados MySQL

1. Noções básicas do MySQL

MySQL é um sistema de gerenciamento de banco de dados relacional e um dos bancos de dados de código aberto mais populares. O Python pode se conectar e operar bancos de dados MySQL por meio de módulos como MySQLdb e PyMySQL.

A seguir estão as etapas básicas para o Python se conectar ao banco de dados MySQL:

Instale o módulo MySQLdb ou PyMySQL

    pip install MySQLdb

ou

    pip install PyMySQL

módulo de importação

    import MySQLdb

ou

    import pymysql

Conecte-se ao banco de dados

    # MySQLdb模块
    conn = MySQLdb.connect(host='localhost', user='root', password='password', database='test', port=3306)
    
    # PyMySQL模块
    conn = pymysql.connect(host='localhost', user='root', password='password', database='test', port=3306)

Criar um objeto de cursor

    cursor = conn.cursor()

Executar instrução SQL

    cursor.execute('SELECT * FROM table_name')

Obter resultados da consulta

    result = cursor.fetchall()

fechar cursor e conexão

    cursor.close()
    conn.close()

As etapas acima são básicas para o Python se conectar ao banco de dados MySQL, e as operações específicas podem ser ajustadas de acordo com as necessidades reais.

2. No banco de dados MySQL, os tipos de dados comuns incluem :

• Tipos numéricos : incluindo número inteiro, ponto flutuante, precisão dupla, etc.

• Tipo de string : incluindo string de comprimento fixo, string de comprimento variável, tipo de texto, etc.

• Tipos de data e hora : incluindo data, hora, datahora, etc.

• Tipo booleano : inclui valores verdadeiros e falsos.

• Tipo binário : incluindo dados binários, imagem, áudio, etc.

• Tipo enumerado : inclui um conjunto de valores predefinidos.

• Tipo de Coleção : Inclui um conjunto predefinido de valores, mas mais de um pode ser selecionado.

Em Python, você pode usar bibliotecas como MySQLdb ou pymysql para se conectar ao banco de dados MySQL e usar instruções SQL para criar, modificar, consultar e excluir tabelas de dados. Ao criar uma tabela de dados, você precisa especificar o tipo de dados de cada campo para garantir a exatidão e integridade dos dados.

3. Em um banco de dados MySQL, uma restrição é uma regra usada para limitar os dados em uma tabela. A seguir estão as restrições comumente usadas no MySQL :

• Restrição NOT NULL : Essa restrição é usada para garantir que os valores na coluna não sejam nulos.

• Restrição UNIQUE : Essa restrição é usada para garantir que os valores na coluna sejam únicos.

• Restrição PRIMARY KEY : Esta restrição é usada para definir a coluna como a chave primária para garantir que cada linha de dados tenha um identificador exclusivo.

• Restrição FOREIGN KEY : Essa restrição é usada para garantir que os valores em uma coluna coincidam com os valores em outra tabela, e geralmente é usada para estabelecer relacionamentos entre tabelas.

• Restrição CHECK : Essa restrição é usada para garantir que os valores na coluna atendam às condições especificadas.

• Restrição DEFAULT : Esta restrição é usada para fornecer um valor padrão para uma coluna quando uma nova linha é inserida.

Por exemplo, o seguinte é um exemplo de uma tabela MySQL com restrições:

    CREATE TABLE students (
      id INT PRIMARY KEY,
      name VARCHAR(50) NOT NULL,
      age INT CHECK (age >= 18),
      email VARCHAR(50) UNIQUE,
      major_id INT,
      FOREIGN KEY (major_id) REFERENCES majors(id)
    );

No exemplo acima, a coluna id é definida como a chave primária, garantindo que cada linha de dados tenha um identificador único. A coluna de nome é definida como NOT NULL para garantir que o valor nessa coluna não seja nulo. A coluna de idade é definida como uma restrição CHECK para garantir que os valores nesta coluna sejam maiores ou iguais a 18. A coluna de e-mail é definida como uma restrição UNIQUE, garantindo que os valores dessa coluna sejam únicos. major\_idA coluna é definida como uma restrição FOREIGN KEY, garantindo que os valores nesta coluna coincidam com a coluna id na tabela majors.

4. Para operar o banco de dados MySQL em Python, você precisa usar bibliotecas de terceiros, como MySQLdb ou pymysql

Algumas operações básicas de banco de dados são descritas abaixo.

• Conectando ao banco de dados
  O código para conectar ao banco de dados usando a biblioteca MySQLdb é o seguinte:

    import MySQLdb
    
    # 打开数据库连接
    db = MySQLdb.connect(host="localhost", user="root", passwd="password", db="test")
    
    # 使用cursor()方法获取操作游标
    cursor = db.cursor()
    
    # 关闭数据库连接
    db.close()

O código para se conectar ao banco de dados usando a biblioteca pymysql é o seguinte:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", passwd="password", db="test")
    
    # 使用cursor()方法获取操作游标
    cursor = db.cursor()
    
    # 关闭数据库连接
    db.close()

• Criar tabelas
  Use execute()métodos para executar instruções SQL para criar tabelas, por exemplo:

    # 创建表
    sql = """CREATE TABLE EMPLOYEE (
             FIRST_NAME  CHAR(20) NOT NULL,
             LAST_NAME  CHAR(20),
             AGE INT,
             SEX CHAR(1),
             INCOME FLOAT )"""
    
    cursor.execute(sql)

• Inserir dados
  Use execute()métodos para executar instruções SQL para inserir dados, por exemplo:

    # 插入数据
    sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
             LAST_NAME, AGE, SEX, INCOME)
             VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
    
    cursor.execute(sql)

• Consultar dados
  Use execute()métodos para executar instruções SQL para consultar dados, por exemplo:

    # 查询数据
    sql = "SELECT * FROM EMPLOYEE WHERE INCOME > %s" % (1000)
    cursor.execute(sql)
    results = cursor.fetchall()
    for row in results:
        fname = row[0]
        lname = row[1]
        age = row[2]
        sex = row[3]
        income = row[4]
        print("fname=%s,lname=%s,age=%d,sex=%s,income=%d" % (fname, lname, age, sex, income))

• Atualizar dados
  Use execute()métodos para executar instruções SQL para atualizar dados, por exemplo:

    # 更新数据
    sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M')
    cursor.execute(sql)

• Excluir dados
  Use execute()métodos para executar instruções SQL para excluir dados, por exemplo:

    # 删除数据
    sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)
    cursor.execute(sql)

5. No MySQL, a tabela de dados é a unidade básica para armazenamento de dados.A
seguir apresentamos algumas operações de tabela de dados comumente usadas.

• Criar uma tabela de dados
  A sintaxe para criar uma tabela de dados é a seguinte:

    CREATE TABLE table_name (
       column1 datatype,
       column2 datatype,
       column3 datatype,
       .....
    );

Entre eles, table\_nameestá o nome da tabela de dados a ser criada, column1, column2, column3, etc. são os nomes das colunas na tabela de dados e datatype é o tipo de dados da coluna.

Por exemplo, para criar uma tabela de dados chamada alunos, que contém três colunas de id, nome e idade, e os tipos de dados são int, varchar(20) e int, a seguinte instrução pode ser usada:

    CREATE TABLE students (
       id int,
       name varchar(20),
       age int
    );

• Inserindo dados
  A sintaxe para inserir dados é a seguinte:

    INSERT INTO table_name (column1, column2, column3, ...) VALUES (value1, value2, value3, ...);

Entre eles, table\_nameestá o nome da tabela de dados para inserir dados, coluna1, coluna2, coluna3, etc. são os nomes das colunas na tabela de dados e valor1, valor2, valor3, etc. são os dados a serem inseridos.

Por exemplo, para inserir um dado na tabela de dados dos alunos, o id é 1, o nome é "Tom" e a idade é 18, você pode usar a seguinte declaração:

    INSERT INTO students (id, name, age) VALUES (1, 'Tom', 18);

• Consultando dados
  A sintaxe para consultar dados é a seguinte:

    SELECT column1, column2, column3, ... FROM table_name WHERE condition;

Entre eles, table\_nameestá o nome da tabela de dados cujos dados serão consultados, coluna1, coluna2, coluna3, etc. são os nomes das colunas a serem consultadas e condição é a condição da consulta.

Por exemplo, para consultar todos os dados na tabela de dados dos alunos, você pode usar a seguinte instrução:

    SELECT * FROM students;

• Atualização de dados
  A sintaxe para atualização de dados é a seguinte:

    UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE condition;

Entre eles, table\_name é o nome da tabela de dados cujos dados serão atualizados, column1, column2, etc. são os nomes das colunas a serem atualizadas, value1, value2, etc. a condição de atualização.

Por exemplo, para atualizar a idade do registro com id 1 na tabela de dados dos alunos para 20, você pode usar a seguinte instrução:

    UPDATE students SET age = 20 WHERE id = 1;

• Excluindo dados
  A sintaxe para excluir dados é a seguinte:

    DELETE FROM table_name WHERE condition;

Entre eles, table\_nameestá o nome da tabela de dados cujos dados serão deletados, e condition é a condição de deleção.

Por exemplo, para excluir o registro cujo id é 1 na tabela de dados dos alunos, você pode usar a seguinte instrução:

    DELETE FROM students WHERE id = 1;

• Excluindo uma tabela de dados
  A sintaxe para excluir uma tabela de dados é a seguinte:

    DROP TABLE table_name;

onde table\_nameé o nome da tabela de dados a ser excluída.

Por exemplo, para excluir a tabela de dados dos alunos, você pode usar a seguinte instrução:

    DROP TABLE students;

6. A operação básica de adição, exclusão, modificação e verificação do banco de dados MySQL com Python é a seguinte :

• Conecte-se ao banco de dados
  Use a biblioteca pymysql em Python para conectar-se ao banco de dados MySQL. O exemplo de código é o seguinte:

    import pymysql

    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="123456", database="test")
    
    # 使用 cursor() 方法创建一个游标对象 cursor
    cursor = db.cursor()
    
    # 关闭数据库连接
    db.close()

• Crie uma tabela de dados
  Use a biblioteca pymysql em Python para criar uma tabela de dados no banco de dados MySQL. O exemplo de código é o seguinte:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="123456", database="test")
    
    # 使用 cursor() 方法创建一个游标对象 cursor
    cursor = db.cursor()
    
    # 创建数据表SQL语句
    sql = """CREATE TABLE EMPLOYEE (
             FIRST_NAME  CHAR(20) NOT NULL,
             LAST_NAME  CHAR(20),
             AGE INT,  
             SEX CHAR(1),
             INCOME FLOAT )"""
    
    # 执行SQL语句
    cursor.execute(sql)
    
    # 关闭数据库连接
    db.close()

• Inserir dados
  Use a biblioteca pymysql em Python para inserir dados na tabela de dados no banco de dados MySQL. O exemplo de código é o seguinte:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="123456", database="test")
    
    # 使用 cursor() 方法创建一个游标对象 cursor
    cursor = db.cursor()
    
    # SQL 插入语句
    sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
             LAST_NAME, AGE, SEX, INCOME)
             VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
    
    # 执行SQL语句
    cursor.execute(sql)
    
    # 提交到数据库执行
    db.commit()
    
    # 关闭数据库连接
    db.close()

• Consultar dados
  Use a biblioteca pymysql em Python para consultar dados das tabelas de dados no banco de dados MySQL. O exemplo de código é o seguinte:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="123456", database="test")
    
    # 使用 cursor() 方法创建一个游标对象 cursor
    cursor = db.cursor()
    
    # SQL 查询语句
    sql = "SELECT * FROM EMPLOYEE \
           WHERE INCOME > %s" % (1000)
    
    # 执行SQL语句
    cursor.execute(sql)
    
    # 获取所有记录列表
    results = cursor.fetchall()
    for row in results:
        fname = row[0]
        lname = row[1]
        age = row[2]
        sex = row[3]
        income = row[4]
        # 打印结果
        print("fname=%s,lname=%s,age=%d,sex=%s,income=%d" % (fname, lname, age, sex, income))
    
    # 关闭数据库连接
    db.close()

• Atualizar dados
  Use a biblioteca pymysql em Python para atualizar os dados da tabela de dados no banco de dados MySQL. O código de amostra é o seguinte:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="123456", database="test")
    
    # 使用 cursor() 方法创建一个游标对象 cursor
    cursor = db.cursor()
    
    # SQL 更新语句
    sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M')
    
    # 执行SQL语句
    cursor.execute(sql)
    
    # 提交到数据库执行
    db.commit()
    
    # 关闭数据库连接
    db.close()

• Excluir dados
  Use a biblioteca pymysql em Python para excluir os dados da tabela de dados no banco de dados MySQL. O código de exemplo é o seguinte:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="123456", database="test")
    
    # 使用 cursor() 方法创建一个游标对象 cursor
    cursor = db.cursor()
    
    # SQL 删除语句
    sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)
    
    # 执行SQL语句
    cursor.execute(sql)
    
    # 提交到数据库执行
    db.commit()
    
    # 关闭数据库连接
    db.close()

2. Consulta avançada do MySQL

1. Criar banco de dados, tabela de dados

• Crie um banco de dados:

Use Python para se conectar ao banco de dados MySQL, você pode usar mysql.connectoro módulo, o código de exemplo é o seguinte:

    import mysql.connector
    
    # 连接MySQL数据库
    mydb = mysql.connector.connect(
      host="localhost",
      user="root",
      password="123456"
    )
    
    # 创建数据库
    mycursor = mydb.cursor()
    mycursor.execute("CREATE DATABASE mydatabase")

• Crie uma tabela de dados:

Use Python para se conectar ao banco de dados MySQL, você pode usar mysql.connectoro módulo, o código de exemplo é o seguinte:

    import mysql.connector
    
    # 连接MySQL数据库
    mydb = mysql.connector.connect(
      host="localhost",
      user="root",
      password="123456",
      database="mydatabase"
    )
    
    # 创建数据表
    mycursor = mydb.cursor()
    mycursor.execute("CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))")

O código acima cria uma customerstabela de dados chamada, que contém dois campos namee address, ambos do tipoVARCHAR(255)

2. Consulta de condição

A consulta condicional refere-se à filtragem dos dados que atendem aos requisitos de acordo com determinadas condições. As instruções de consulta condicional comumente usadas incluem WHERE, AND, OR, IN, BETWEEN etc.

• Instrução WHERE
  A instrução WHERE é usada para especificar condições de consulta, a sintaxe é a seguinte:

    SELECT column1, column2, ... FROM table_name WHERE condition;

Entre eles, condição é a condição da consulta, você pode usar operadores de comparação (=, <, >, <=, >=, <>), operadores lógicos (AND, OR, NOT) e curingas (%, _), etc.

Por exemplo, para consultar as informações de alunos com idade maior ou igual a 18 anos:

    SELECT * FROM students WHERE age >= 18;

• Instrução AND A
  instrução AND é usada para satisfazer várias condições ao mesmo tempo, a sintaxe é a seguinte:

    SELECT column1, column2, ... FROM table_name WHERE condition1 AND condition2 AND ...;

Por exemplo, para consultar as informações de alunos com idade maior ou igual a 18 anos e sexo feminino:

SELECT * FROM students WHERE age >= 18 AND gender = '女';

• Instrução OR
  A instrução OR é usada para satisfazer qualquer uma das várias condições. A sintaxe é a seguinte:

    SELECT column1, column2, ... FROM table_name WHERE condition1 OR condition2 OR ...;

Por exemplo, para consultar as informações de alunos com idade maior ou igual a 18 anos ou sexo feminino:

    SELECT * FROM students WHERE age >= 18 OR gender = '女';

• Instrução IN
  A instrução IN é usada para especificar vários valores, a sintaxe é a seguinte:

    SELECT column1, column2, ... FROM table_name WHERE column_name IN (value1, value2, ...);

Por exemplo, para consultar as informações do aluno dos números de aluno 1001, 1002 e 1003:

    SELECT * FROM students WHERE id IN (1001, 1002, 1003);

• Instrução BETWEEN A
  instrução BETWEEN é usada para especificar um intervalo, a sintaxe é a seguinte:

    SELECT column1, column2, ... FROM table_name WHERE column_name BETWEEN value1 AND value2;

Por exemplo, para consultar informações de alunos entre 18 e 20 anos:

    SELECT * FROM students WHERE age BETWEEN 18 AND 20;

A descrição acima é a sintaxe básica da consulta condicional, que pode ser usada de forma flexível de acordo com as necessidades reais.

3. No MySQL, você pode usar a cláusula ORDER BY para classificar os resultados da consulta

A cláusula ORDER BY pode ser seguida por um ou mais nomes de coluna, separados por vírgulas. Por padrão, a classificação é crescente e a palavra-chave DESC pode ser usada para classificação decrescente.

Por exemplo, a instrução a seguir classificará em ordem crescente pela coluna de idade:

    SELECT * FROM students ORDER BY age;

A instrução a seguir classificará em ordem decrescente pela coluna de idade:

    SELECT * FROM students ORDER BY age DESC;

Você pode especificar várias colunas para classificar ao mesmo tempo, por exemplo:

    SELECT * FROM students ORDER BY grade DESC, age;

A instrução acima classificará primeiro em ordem decrescente de acordo com a coluna de notas e, se houver os mesmos valores de notas, classificará em ordem crescente de acordo com a coluna de idade.

Observe que a cláusula ORDER BY deve ser colocada no final da instrução de consulta.

4. No MySQL, agrupamento é uma operação de classificação de dados de acordo com um determinado campo

O agrupamento pode ser usado para dados estatísticos, calculando o valor de funções agregadas, como média, máximo, mínimo, etc.

Aqui está um exemplo simples, assumindo que temos uma tabela de alunos com nomes, idades e notas dos alunos:

    CREATE TABLE students (
        id INT PRIMARY KEY AUTO_INCREMENT,
        name VARCHAR(50),
        age INT,
        score INT
    );
    
    INSERT INTO students (name, age, score) VALUES
        ('Tom', 18, 90),
        ('Jerry', 19, 80),
        ('Lucy', 18, 95),
        ('Lily', 20, 85),
        ('Bob', 19, 75);

Agora queremos agrupar por idade e contar a nota média e a nota mais alta de cada faixa etária, podemos usar a seguinte instrução SQL:

    SELECT age, AVG(score) AS avg_score, MAX(score) AS max_score
    FROM students
    GROUP BY age;

Os resultados da execução são os seguintes:

    +-----+-----------+----------+
    | age | avg_score | max_score |
    +-----+-----------+----------+
    |  18 | 92.5000   |       95 |
    |  19 | 77.5000   |       80 |
    |  20 | 85.0000   |       85 |
    +-----+-----------+----------+

Como você pode ver, agrupamos por idade e contamos a média e as pontuações mais altas para cada faixa etária.

Na consulta de grupo, também podemos usar a cláusula HAVING para filtrar os dados agrupados. Por exemplo, se quisermos descobrir a faixa etária cuja pontuação média é maior que 85, podemos usar a seguinte instrução SQL:

    SELECT age, AVG(score) AS avg_score
    FROM students
    GROUP BY age
    HAVING avg_score > 85;

Os resultados da execução são os seguintes:

    +-----+-----------+
    | age | avg_score |
    +-----+-----------+
    |  18 | 92.5000   |
    |  20 | 85.0000   |
    +-----+-----------+

Vê-se que mantemos apenas a faixa etária cuja pontuação média é superior a 85 pontos.

3. Aplicativo avançado MySQL

1. ver

No MySQL, uma visão é uma tabela virtual composta de resultados de consulta de uma ou mais tabelas básicas. As exibições não armazenam dados, mas geram conjuntos de resultados dinamicamente com base em instruções de consulta. As exibições podem simplificar operações de consulta complexas, melhorar a eficiência da consulta e proteger a segurança dos dados.

A sintaxe para criar uma visualização é a seguinte:

    CREATE VIEW view_name AS
    SELECT column1, column2, ...
    FROM table_name
    WHERE condition;

Entre eles, view_nameestá o nome da visão, column1, column2, ...é o nome da coluna a ser consultada, table_nameé o nome da tabela a ser consultada e conditioné a condição da consulta.

Por exemplo, podemos criar uma employee_viewview chamada , que consulta as colunas , e employeeda tabela :idnamesalary

    CREATE VIEW employee_view AS
    SELECT id, name, salary
    FROM employee;

A sintaxe para consultar uma visão é semelhante àquela para consultar uma tabela:

    SELECT * FROM view_name;

Por exemplo, podemos consultar employee_viewos resultados de uma exibição:

    SELECT * FROM employee_view;

As exibições também podem ser atualizadas, mas certas condições precisam ser atendidas. Especificamente, as exibições podem executar os seguintes tipos de operações de atualização:

• As atualizações são feitas em exibições de tabela única, ou seja, exibições que envolvem apenas uma tabela base.
• Atualize uma exibição de várias tabelas, mas a operação de atualização pode envolver apenas determinadas colunas de uma tabela básica e essas colunas devem ser exclusivas.
  A sintaxe para atualizar uma visão é a seguinte:

    UPDATE view_name
    SET column1 = value1, column2 = value2, ...
    WHERE condition;

Por exemplo, podemos atualizar employee_viewo salário do funcionário com id 1 na view:

    UPDATE employee_view
    SET salary = 5000
    WHERE id = 1;

Deve-se notar que quando uma visão é atualizada, os dados na tabela base são realmente atualizados, não a visão em si. Portanto, as restrições da tabela básica devem ser atendidas ao atualizar a exibição, caso contrário, a atualização falhará.

Além das operações de atualização, as exibições também podem executar operações de inserção e exclusão, e a sintaxe específica é semelhante às operações de tabela. No entanto, deve-se observar que as operações de inserção e exclusão podem envolver apenas uma tabela básica e as restrições da tabela básica devem ser atendidas.

2. Assuntos

Uma transação é um conjunto de operações que ou todas são executadas com sucesso ou nenhuma delas é executada. No MySQL, as transações usam propriedades ACID para garantir a consistência e confiabilidade dos dados.

ACID refere-se a:

• Atomicidade : Todas as operações em uma transação são executadas com sucesso ou não são executadas.
• Consistência : antes e depois da execução da transação, a integridade e as restrições dos dados permanecem inalteradas.
• Isolamento : as transações são isoladas umas das outras e a execução de uma transação não afetará a execução de outras transações.
• Durabilidade : Uma vez que uma transação é confirmada, a modificação dos dados é permanente e não será perdida mesmo se o sistema travar.

No MySQL, use as instruções BEGIN, COMMIT e ROLLBACK para controlar o commit e o rollback das transações.

• BEGIN : Inicia uma transação.
• COMMIT : Confirma uma transação e salva permanentemente todas as operações na transação no banco de dados.
• ROLLBACK : Reverter uma transação, desfazendo todas as operações na transação.
  Aqui está um exemplo usando transações:

    import mysql.connector
    
    # 连接数据库
    mydb = mysql.connector.connect(
      host="localhost",
      user="root",
      password="123456",
      database="mydatabase"
    )
    
    # 获取游标
    mycursor = mydb.cursor()
    
    # 开始事务
    mycursor.execute("START TRANSACTION")
    
    # 执行操作
    try:
      sql = "INSERT INTO customers (name, address) VALUES (%s, %s)"
      val = ("John", "Highway 21")
      mycursor.execute(sql, val)
    
      sql = "UPDATE customers SET address = 'Park Lane 38' WHERE address = 'Highway 21'"
      mycursor.execute(sql)
    
      # 提交事务
      mydb.commit()
    
    except:
      # 回滚事务
      mydb.rollback()
    
    # 关闭连接
    mydb.close()

No exemplo acima, usamos START TRANSACTION para iniciar uma transação e, em seguida, realizamos duas operações: inserir um dado e atualizar um dado. Se ambas as operações forem executadas com sucesso, COMMIT é usado para confirmar a transação, caso contrário, ROLLBACK é usado para reverter a transação.

3. Uso do pyMySQL

pyMySQL é uma biblioteca de terceiros em Python para conexão com bancos de dados MySQL. Ele fornece algumas APIs fáceis de usar para operações de banco de dados convenientes.

• Instale o pyMySQL:

Ele pode ser instalado usando o comando pip:

    pip install pymysql

• Conecte-se ao banco de dados MySQL:

Antes de usar o pyMySQL, você precisa se conectar ao banco de dados MySQL primeiro. Para se conectar ao banco de dados MySQL, você precisa especificar informações como nome do host, nome do usuário, senha e nome do banco de dados. O seguinte código pode ser usado para conectar:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="password", database="test")
    
    # 使用cursor()方法获取操作游标
    cursor = db.cursor()
    
    # 关闭数据库连接
    db.close()

Entre eles, host representa o nome do host, user representa o nome do usuário, password representa a senha e database representa o nome do banco de dados a ser conectado.

• Execute a instrução SQL:

Depois de se conectar ao banco de dados MySQL, você pode usar o objeto cursor para executar instruções SQL. O pyMySQL suporta a execução de todas as instruções SQL, incluindo consulta, inserção, atualização, exclusão e outras operações. Veja a seguir um exemplo de operação de consulta:

    import pymysql
    
    # 打开数据库连接
    db = pymysql.connect(host="localhost", user="root", password="password", database="test")
    
    # 使用cursor()方法获取操作游标
    cursor = db.cursor()
    
    # 执行SQL语句
    sql = "SELECT * FROM students"
    cursor.execute(sql)
    
    # 获取所有记录列表
    results = cursor.fetchall()
    for row in results:
        id = row[0]
        name = row[1]
        age = row[2]
        gender = row[3]
        print("id=%d,name=%s,age=%d,gender=%s" % (id, name, age, gender))
    
    # 关闭数据库连接
    db.close()

Antes de executar a instrução SQL, você precisa usar cursor()o método para obter o cursor da operação. A execução de instruções SQL pode usar execute()o método, que aceita uma instrução SQL como parâmetro. A operação de consulta pode usar fetchall()o método para obter uma lista de todos os registros e percorrer cada registro.

As operações de inserção, atualização e exclusão também podem usar execute()métodos, basta passar a instrução SQL correspondente como parâmetro.

O acima é o uso básico do pyMySQL. Para uma API mais detalhada, consulte a documentação oficial.

4. MySQL ORM framework-SQLAIchemy

SQLAlchemy é um kit de ferramentas Python SQL e uma estrutura ORM que fornece um amplo conjunto de ferramentas que tornam o trabalho com SQL em Python mais fácil e flexível. O principal objetivo do SQLAlchemy é fornecer acesso eficiente e de alto desempenho a bancos de dados SQL e suporta uma variedade de bancos de dados relacionais, como MySQL, PostgreSQL, Oracle, Microsoft SQL Server, etc.

A estrutura ORM do SQLAlchemy fornece uma maneira de mapear objetos Python para tabelas de banco de dados relacionais, permitindo que os desenvolvedores usem a linguagem Python para operar o banco de dados sem precisar usar a linguagem SQL diretamente. A estrutura ORM pode criar automaticamente tabelas de banco de dados, inserir dados, atualizar dados, excluir dados e outras operações e também oferece suporte a funções avançadas, como transações, pools de conexão e caches.

Aqui está um exemplo usando a estrutura SQLAlchemy ORM:

    from sqlalchemy import create_engine, Column, Integer, String
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.ext.declarative import declarative_base
    
    # 创建数据库连接
    engine = create_engine('mysql+pymysql://username:password@host:port/database')
    
    # 创建Session类
    Session = sessionmaker(bind=engine)
    
    # 创建Base类
    Base = declarative_base()
    
    # 定义User类
    class User(Base):
        __tablename__ = 'users'
        id = Column(Integer, primary_key=True)
        name = Column(String(50))
        age = Column(Integer)
    
    # 创建表
    Base.metadata.create_all(engine)
    
    # 创建Session实例
    session = Session()
    
    # 插入数据
    user = User(name='Tom', age=20)
    session.add(user)
    session.commit()
    
    # 查询数据
    users = session.query(User).all()
    for user in users:
        print(user.name, user.age)
    
    # 更新数据
    user = session.query(User).filter_by(name='Tom').first()
    user.age = 21
    session.commit()
    
    # 删除数据
    user = session.query(User).filter_by(name='Tom').first()
    session.delete(user)
    session.commit()
    
    # 关闭Session
    session.close()

No exemplo acima, primeiro criamos uma conexão de banco de dados e, em seguida, criamos uma classe Session e uma classe Base. A classe Session é usada para criar instâncias de Session e a classe Base é usada para definir o relacionamento de mapeamento ORM. Definimos uma classe User, que herda da classe Base, e define o nome da tabela e os campos. Então Base.metadata.create_all()criamos a tabela usando o método. Em seguida, criamos uma instância de Session e usamos session.add()o método para inserir um dado. Use session.query()métodos para consultar dados e session.commit()métodos para confirmar transações. Também demonstramos como atualizar e excluir dados e, finalmente, usar session.close()o método para fechar arquivos Session.

A estrutura SQLAlchemy ORM fornece recursos avançados e opções de configuração flexíveis para atender a várias necessidades. Ao mesmo tempo, também possui uma certa curva de aprendizado e leva algum tempo para aprender e dominar.

1. Um exemplo de uso do SQLAlchemy para consultar um banco de dados MySQL

Primeiro, a biblioteca SQLAlchemy precisa ser instalada:

    pip install sqlalchemy

Em seguida, conecte-se ao banco de dados MySQL:

    from sqlalchemy import create_engine

    # 连接MySQL数据库
    engine = create_engine('mysql+pymysql://username:password@host:port/database')

Entre eles, usernamee passwordé o nome de usuário e a senha do banco de dados MySQL, hosté o nome do host do banco de dados MySQL, porté o número da porta do banco de dados MySQL databasee é o nome do banco de dados a ser conectado.

Em seguida, defina um modelo ORM:

    from sqlalchemy.ext.declarative import declarative_base
    from sqlalchemy import Column, Integer, String
    
    # 定义ORM模型
    Base = declarative_base()
    
    class User(Base):
        __tablename__ = 'users'
    
        id = Column(Integer, primary_key=True)
        name = Column(String(50))
        age = Column(Integer)

Este modelo ORM corresponde à tabela de usuários no banco de dados MySQL, incluindo três campos id, namee age.

Em seguida, consulte os dados usando SQLAlchemy:

    from sqlalchemy.orm import sessionmaker
    
    # 创建Session
    Session = sessionmaker(bind=engine)
    session = Session()
    
    # 查询所有用户
    users = session.query(User).all()
    for user in users:
        print(user.id, user.name, user.age)
    
    # 查询年龄大于等于18岁的用户
    users = session.query(User).filter(User.age >= 18).all()
    for user in users:
        print(user.id, user.name, user.age)
    
    # 查询年龄大于等于18岁的用户，并按照年龄从小到大排序
    users = session.query(User).filter(User.age >= 18).order_by(User.age).all()
    for user in users:
        print(user.id, user.name, user.age)

O código acima consulta, respectivamente, todos os usuários, usuários cuja idade é maior ou igual a 18 anos e usuários cuja idade é maior ou igual a 18 anos, e classifica os resultados em ordem crescente de idade e os imprime.

Além dos exemplos acima, o SQLAlchemy também oferece suporte a mais métodos de consulta, como consulta de paginação, consulta de agregação, etc.

O texto acima é sobre a análise de conteúdo da programação de banco de dados python banco de dados MySQL

Esta série de artigos é baseada nas seguintes rotas de aprendizagem. Devido ao grande conteúdo:

Aprenda python do zero ao roteiro avançado avançado

Preste atenção na conta oficial: campo de treinamento de tecnologia python , aprenda passo a passo avançado

Recursos do Python adequados para aprendizado baseado em zero e pessoas avançadas:

① Projeto completo de python certificado pela Tencent, notas práticas do tutorial em PDF
② Mais de uma dúzia de tópicos de entrevistas em python dos principais fabricantes PDF
③ Conjunto completo de tutoriais em vídeo Python (reverso JS avançado avançado zero)
④ Centenas de combate real do projeto + código-fonte + notas
⑤ Programação gramática - aprendizado de máquina -desenvolvimento de pilha completa-análise de dados-crawler-APP engenharia reversa e outro conjunto completo de projetos + documentos
⑥ Troca e estudo
⑦ Quer receber pedidos de meio período

O próximo capítulo: banco de dados Redis