Wie betreibe ich MySQL in Python?

1. Einführung in den Python-Datenbankbetrieb

Pythons Standard-Datenbankschnittstelle ist die Python DB-API, die Entwicklern eine Programmierschnittstelle für Datenbankanwendungen bietet. Die Python-Datenbankschnittstelle unterstützt viele Datenbanken. Sie können die Datenbank auswählen, die zu Ihrem Projekt passt:

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server. 2000
• Informix
• Interbase
• Oracle
• S ybase. ..

Sie können die Python-Datenbankschnittstelle und -API besuchen, um eine detaillierte Liste der unterstützten Datenbanken anzuzeigen.

Sie müssen verschiedene DB-API-Module für verschiedene Datenbanken herunterladen. Wenn Sie beispielsweise auf Oracle-Datenbank- und MySQL-Daten zugreifen müssen, müssen Sie Oracle- und MySQL-Datenbankmodule herunterladen.

DB-API ist eine Spezifikation. Sie definiert eine Reihe notwendiger Objekte und Datenbankzugriffsmethoden, um konsistente Zugriffsschnittstellen für verschiedene zugrunde liegende Datenbanksysteme und verschiedene Datenbankschnittstellenprogramme bereitzustellen.

Die DB-API von Python implementiert Schnittstellen für die meisten Datenbanken. Nachdem Sie sie zum Herstellen einer Verbindung zu jeder Datenbank verwendet haben, können Sie jede Datenbank auf die gleiche Weise bedienen.

Python DB-API-Nutzungsprozess:

Einführung des API-Moduls.

Stellen Sie die Verbindung zur Datenbank her.

SQL-Anweisungen und gespeicherte Prozeduren ausführen

Datenbankverbindung schließen.

2. Python betreibt das MySQL-Modul

Python verwendet hauptsächlich zwei Methoden, um MySQL zu betreiben:

DB-Modul (natives SQL)

• PyMySQL (unterstützt Python2.x/3.x)
• MySQLdb (unterstützt derzeit nur Python2. x)

ORM-Framework

• SQLAchemy

2.1 PyMySQL-Modul

Dieser Artikel stellt hauptsächlich das PyMySQL-Modul vor. Die Verwendung von MySQLdb ist ähnlich

2.1.1 PyMySQL installieren

PyMySQL ist ein MySQL-Modul in Python-Treiber. Lassen Sie uns die Python-Sprache verwenden, um die MySQL-Datenbank zu betreiben. 2.2 Grundlegende Verwendung die Cursorposition, wie zum Beispiel:

cursor.scroll(1,mode='relative') #Bewegen Sie sich relativ zur aktuellen Position.

cursor.scroll(2,mode='absolute') #Bewegen Sie sich relativ zur absoluten Position

2.5 SQL-Injection verhindern

pip install PyMySQL

Auf diese Weise werden SQL-Operationen sicherer. Wenn Sie eine detailliertere Dokumentation benötigen, lesen Sie bitte die PyMySQL-Dokumentation. Es scheint jedoch, dass die Implementierung dieser SQL-Datenbanken nicht dieselbe ist. Der Parameterplatzhalter von PyMySQL verwendet den C-Formatierer wie %s, während der Platzhalter des mit Python gelieferten sqlite3-Moduls ein Fragezeichen (?) zu sein scheint. . Daher ist es besser, die Dokumentation sorgfältig zu lesen, wenn Sie andere Datenbanken verwenden. Willkommen bei der Dokumentation von PyMySQL
3. Bei der oben genannten Methode gibt es ein Problem, das in einem Single-Thread-Fall behoben werden kann. Das Programm muss häufig Verbindungen erstellen und freigeben, um den Betrieb der Datenbank abzuschließen. Dann ist unser Programm/Skript in Welche Probleme werden unter Multithreading auftreten? Zu diesem Zeitpunkt müssen wir einen Datenbankverbindungspool verwenden, um dieses Problem zu lösen.
3.1 DBUtils-Modul

DBUtils ist ein Modul, das zur Implementierung verwendet wird Datenbankverbindungspools.

Dieser Verbindungspool verfügt über zwei Verbindungsmodi:

Erstellen Sie eine Verbindung für jeden Thread. Auch wenn der Thread die Close-Methode aufruft, wird er nicht geschlossen. Die Verbindung wird einfach wieder in den Verbindungspool für seinen eigenen Thread eingefügt wieder zu verwenden. Wenn der Thread beendet wird, wird die Verbindung automatisch geschlossen

Erstellen Sie einen Stapel von Verbindungen zum Verbindungspool, damit alle Threads sie teilen können (empfohlen)

3.2 Modus eins

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "shuke"
# Date: 2018/5/13
import pymysql
# 创建连接
conn = pymysql.connect(host="127.0.0.1", port=3306, user='zff', passwd='zff123', db='zff', charset='utf8mb4')
# 创建游标(查询数据返回为元组格式)
# cursor = conn.cursor()
# 创建游标(查询数据返回为字典格式)
cursor = conn.cursor(pymysql.cursors.DictCursor)
# 1. 执行SQL,返回受影响的行数
effect_row1 = cursor.execute("select * from USER")
# 2. 执行SQL,返回受影响的行数,一次插入多行数据
effect_row2 = cursor.executemany("insert into USER (NAME) values(%s)", [("jack"), ("boom"), ("lucy")])# 3
# 查询所有数据,返回数据为元组格式
result = cursor.fetchall()
# 增/删/改均需要进行commit提交,进行保存
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
conn.close()
print(result)
"""
[{'id': 6, 'name': 'boom'}, {'id': 5, 'name': 'jack'}, {'id': 7, 'name': 'lucy'}, {'id': 4, 'name': 'tome'}, {'id': 3, 'name': 'zff'}, {'id': 1, 'name': 'zhaofengfeng'}, {'id': 2, 'name': 'zhaofengfeng02'}]
"""

3.3 Modus zwei

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "shuke"
# Date: 2018/5/13
import pymysql
# 创建连接
conn = pymysql.connect(host="127.0.0.1", port=3306, user='zff', passwd='zff123', db='zff', charset='utf8mb4')
# 创建游标(查询数据返回为元组格式)
cursor = conn.cursor()
# 获取新创建数据自增ID
effect_row = cursor.executemany("insert into USER (NAME)values(%s)", [("eric")])
# 增删改均需要进行commit提交
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
conn.close()
new_id = cursor.lastrowid
print(new_id)
"""
8
"""

⚠️ Aufgrund von PyMySQL MySQLdb usw. Der Threadsicherheitswert ist 1, sodass die Threads im Verbindungspool in diesem Modus von allen Threads gemeinsam genutzt werden und somit Thread-sicher sind. Wenn kein Verbindungspool vorhanden ist und pymysql zum Herstellen einer Verbindung mit der Datenbank verwendet wird, gibt es bei Single-Thread-Anwendungen kein Problem. Wenn jedoch Multi-Thread-Anwendungen beteiligt sind, ist eine Sperre erforderlich . Bei vielen Anfragen nimmt die Leistung ab.
3.4 Gesperrt

• #! /usr/bin/env python
  # -*- coding: utf-8 -*-
  # __author__ = "shuke"
  # Date: 2018/5/13
  import pymysql
  # 创建连接
  conn = pymysql.connect(host="127.0.0.1", port=3306, user='zff', passwd='zff123', db='zff', charset='utf8mb4')
  # 创建游标
  cursor = conn.cursor()
  cursor.execute("select * from USER")
  # 获取第一行数据
  row_1 = cursor.fetchone()
  # 获取前n行数据
  row_2 = cursor.fetchmany(3)
  #
  # # 获取所有数据
  row_3 = cursor.fetchall()
  # 关闭游标
  cursor.close()
  # 关闭连接
  conn.close()
  print(row_1)
  print(row_2)
  print(row_3)

3.5 Keine Sperre (Fehlerbericht)

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "shuke"
# Date: 2018/5/13
import pymysql
# 创建连接
conn = pymysql.connect(host="127.0.0.1", port=3306, user='zff', passwd='zff123', db='zff', charset='utf8mb4')
# 创建游标
cursor = conn.cursor()
# 存在sql注入情况(不要用格式化字符串的方式拼接SQL)
sql = "insert into USER (NAME) values('%s')" % ('zhangsan',)
effect_row = cursor.execute(sql)
# 正确方式一
# execute函数接受一个元组/列表作为SQL参数,元素个数只能有1个
sql = "insert into USER (NAME) values(%s)"
effect_row1 = cursor.execute(sql, ['wang6'])
effect_row2 = cursor.execute(sql, ('wang7',))
# 正确方式二
sql = "insert into USER (NAME) values(%(name)s)"
effect_row1 = cursor.execute(sql, {'name': 'wudalang'})
# 写入插入多行数据
effect_row2 = cursor.executemany("insert into USER (NAME) values(%s)", [('ermazi'), ('dianxiaoer')])
# 提交
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
conn.close()

Sie können den Verbindungsstatus in der Datenbank zu diesem Zeitpunkt überprüfen: Status wie „Threads%“ anzeigen;

4. Der Datenbankverbindungspool wird in Verbindung mit verwendet pymsql

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "shuke"
# Date: 2018/5/13
from DBUtils.PersistentDB import PersistentDB
import pymysql
POOL = PersistentDB(
 creator=pymysql,# 使用链接数据库的模块
 maxusage=None,# 一个链接最多被重复使用的次数，None表示无限制
 setsession=[],# 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
 ping=0,
 # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
 closeable=False,
 # 如果为False时， conn.close() 实际上被忽略，供下次使用，在线程关闭时，才会自动关闭链接。如果为True时， conn.close()则关闭链接，那么再次调用pool.connection时就会报错，因为已经真的关闭了连接（pool.steady_connection()可以获取一个新的链接）
 threadlocal=None,# 本线程独享值得对象，用于保存链接对象，如果链接对象被重置
 host='127.0.0.1',
 port=3306,
 user='zff',
 password='zff123',
 database='zff',
 charset='utf8',
)
def func():
 conn = POOL.connection(shareable=False)
 cursor = conn.cursor()
 cursor.execute('select * from USER')
 result = cursor.fetchall()
 cursor.close()
 conn.close()
 return result
result = func()
print(result)

PS: Sie können statische Methoden verwenden, um sie zur einfacheren Verwendung in einer Klasse zu kapseln.

Das obige ist der detaillierte Inhalt vonWie betreibe ich MySQL in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!