Comment se connecter à une base de données MySQL en Python?
Comment se connecter à une base de données MySQL en utilisant un programme python?
Connexion à MYSQL avec Python 2 en trois étapes
1 - Réglage
Vous devez installer un pilote MySQL avant de faire quoi que ce soit. Contrairement à PHP, seul le pilote SQLite est installé par défaut avec Python. Le paquet le plus utilisé est MySQLdb mais il est difficile de l’installer à l’aide de easy_install. Veuillez noter que MySQLdb ne supporte que Python 2.
Pour les utilisateurs Windows, vous pouvez obtenir un exe de MySQLdb .
Pour Linux, il s'agit d'un paquet occasionnel (python-mysqldb). (Vous pouvez utiliser Sudo apt-get install python-mysqldb (pour les distributions basées sur Debian), yum install MySQL-python (pour les systèmes rpm) ou dnf install python-mysql (pour la distribution Fedora moderne) en ligne de commande pour le téléchargement.)
Pour Mac, vous pouvez installer MySQLdb avec Macport .
2 - Utilisation
Après l'installation, redémarrez. Ce n'est pas obligatoire, mais cela m'empêchera de répondre à 3 ou 4 autres questions de ce message en cas de problème. Alors s'il vous plaît redémarrez.
Ensuite, c'est comme si vous utilisiez n'importe quel autre paquet:
#!/usr/bin/python
import MySQLdb
db = MySQLdb.connect(Host="localhost", # your Host, usually localhost
user="john", # your username
passwd="megajonhy", # your password
db="jonhydb") # name of the data base
# you must create a Cursor object. It will let
# you execute all the queries you need
cur = db.cursor()
# Use all the SQL you like
cur.execute("SELECT * FROM YOUR_TABLE_NAME")
# print all the first cell of all the rows
for row in cur.fetchall():
print row[0]
db.close()
Bien sûr, il existe des milliers de possibilités et d’options; C'est un exemple très basique. Vous devrez regarder la documentation. n bon point de départ .
3 - Utilisation plus avancée
Une fois que vous savez comment cela fonctionne, vous pouvez utiliser un ORM pour éviter d'écrire SQL manuellement et manipuler vos tables comme s'il s'agissait d'objets Python. L'ORM le plus célèbre de la communauté Python est SQLAlchemy .
Je vous conseille vivement de l'utiliser: votre vie sera beaucoup plus facile.
J'ai récemment découvert un autre joyau dans le monde Python: peewee . C'est un ORM très léger, très facile et rapide à installer puis à utiliser. Cela fait ma journée pour de petits projets ou des applications autonomes, Où utiliser de gros outils comme SQLAlchemy ou Django est excessif:
import peewee
from peewee import *
db = MySQLDatabase('jonhydb', user='john', passwd='megajonhy')
class Book(peewee.Model):
author = peewee.CharField()
title = peewee.TextField()
class Meta:
database = db
Book.create_table()
book = Book(author="me", title='Peewee is cool')
book.save()
for book in Book.filter(author="me"):
print book.title
Cet exemple fonctionne hors de la boîte. Rien d'autre que d'avoir un peewee (pip install peewee) n'est requis.
Voici une façon de le faire, en utilisant MySQLdb , qui ne supporte que Python 2:
#!/usr/bin/python
import MySQLdb
# Connect
db = MySQLdb.connect(Host="localhost",
user="appuser",
passwd="",
db="onco")
cursor = db.cursor()
# Execute SQL select statement
cursor.execute("SELECT * FROM location")
# Commit your changes if writing
# In this case, we are only reading data
# db.commit()
# Get the number of rows in the resultset
numrows = cursor.rowcount
# Get and display one row at a time
for x in range(0, numrows):
row = cursor.fetchone()
print row[0], "-->", row[1]
# Close the connection
db.close()
Oracle (MySQL) prend désormais en charge un connecteur pur Python. Cela signifie qu’il n’ya aucun fichier binaire à installer: c’est juste une bibliothèque Python. Cela s'appelle "Connector/Python".
Si vous n'avez pas besoin de MySQLdb, mais que vous acceptez n'importe quelle bibliothèque, je vous recommande vivement MySQL Connector/Python de MySQL: http://dev.mysql.com/downloads/connector/python/ .
C'est un paquet (environ 110k), en pur Python, donc indépendant du système, et simple à installer. Il vous suffit de télécharger, de double-cliquer sur le bouton, de confirmer le contrat de licence et de partir. Il n'y a pas besoin de Xcode, MacPorts, compilation, redémarrage…
Ensuite, vous vous connectez comme:
import mysql.connector
cnx = mysql.connector.connect(user='scott', password='tiger',
Host='127.0.0.1',
database='employees')
try:
cursor = cnx.cursor()
cursor.execute("""
select 3 from your_table
""")
result = cursor.fetchall()
print result
finally:
cnx.close()
Arrêtez d'utiliser MySQLDb si vous souhaitez éviter d'installer des en-têtes mysql uniquement pour accéder à mysql à partir de python.
Utilisez pymysql . Il fait tout ce que MySQLDb fait, mais il a été implémenté purement dans Python avec AUCUN dépendances externes . Cela rend le processus d'installation sur tous les systèmes d'exploitation cohérent et facile. pymysql est une solution de remplacement pour MySQLDb et IMHO, il n'y a aucune raison d'utiliser jamais MySQLDb pour quoi que ce soit ... JAMAIS! - PTSD from installing MySQLDb on Mac OSX and *Nix systems, mais c'est juste moi.
Installation
_pip install pymysql_
C'est ça ... vous êtes prêt à jouer.
Exemple d'utilisation de pymysql Github repo
_import pymysql.cursors
import pymysql
# Connect to the database
connection = pymysql.connect(Host='localhost',
user='user',
password='passwd',
db='db',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
try:
with connection.cursor() as cursor:
# Create a new record
sql = "INSERT INTO `users` (`email`, `password`) VALUES (%s, %s)"
cursor.execute(sql, ('[email protected]', 'very-secret'))
# connection is not autocommit by default. So you must commit to save
# your changes.
connection.commit()
with connection.cursor() as cursor:
# Read a single record
sql = "SELECT `id`, `password` FROM `users` WHERE `email`=%s"
cursor.execute(sql, ('[email protected]',))
result = cursor.fetchone()
print(result)
finally:
connection.close()
_AUSSI - Remplacer MySQLdb dans le code existant rapidement et de manière transparente
Si votre code existant utilise MySQLdb, vous pouvez facilement le remplacer par pymysql en utilisant ce processus simple:
_# import MySQLdb << Remove this line and replace with:
import pymysql
pymysql.install_as_MySQLdb()
_Toutes les références ultérieures à MySQLdb utiliseront pymysql de manière transparente.
Essayez d'utiliser MySQLdb . MySQLdb ne supporte que Python 2.
Il existe un moyen de rechercher une page ici: http://www.kitebird.com/articles/pydbapi.html
De la page:
# server_version.py - retrieve and display database server version
import MySQLdb
conn = MySQLdb.connect (Host = "localhost",
user = "testuser",
passwd = "testpass",
db = "test")
cursor = conn.cursor ()
cursor.execute ("SELECT VERSION()")
row = cursor.fetchone ()
print "server version:", row[0]
cursor.close ()
conn.close ()
En tant que pilote de base de données, il existe également oursql . Certaines des raisons énumérées sur ce lien, qui expliquent pourquoi notre système est meilleur:
- oursql a un paramétrage réel, envoyant le SQL et les données à MySQL de manière totalement séparée.
- oursql permet aux données textuelles ou binaires d'être diffusées dans la base de données et extraites de celle-ci au lieu d'exiger que tout soit mis en mémoire tampon dans le client.
- oursql peut à la fois insérer des lignes paresseusement et extraire des lignes paresseusement.
- oursql a le support unicode par défaut.
- oursql prend en charge python 2.4 à 2.7 sans aucun avertissement de dépréciation sous 2.6+ (voir PEP 218) et sans échec complet sur 2.7 (voir PEP 328).
- oursql fonctionne nativement sur python 3.x.
Alors, comment se connecter à mysql avec oursql?
Très similaire à mysqldb:
import oursql
db_connection = oursql.connect(Host='127.0.0.1',user='foo',passwd='foobar',db='db_name')
cur=db_connection.cursor()
cur.execute("SELECT * FROM `tbl_name`")
for row in cur.fetchall():
print row[0]
Le tutoriel dans la documentation est plutôt correct.
Et bien sûr, ORM SQLAlchemy est un bon choix, comme déjà mentionné dans les autres réponses.
Malgré toutes les réponses ci-dessus, si vous ne souhaitez pas vous connecter à une base de données spécifique à l'avance, par exemple, si vous souhaitez créer une base de données (!), Vous pouvez utiliser connection.select_db(database), comme illustré ci-après.
import pymysql.cursors
connection = pymysql.connect(Host='localhost',
user='mahdi',
password='mahdi',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
cursor = connection.cursor()
cursor.execute("CREATE DATABASE IF NOT EXISTS "+database)
connection.select_db(database)
sql_create = "CREATE TABLE IF NOT EXISTS "+tablename+(timestamp DATETIME NOT NULL PRIMARY KEY)"
cursor.execute(sql_create)
connection.commit()
cursor.close()
SqlAlchemy
SQLAlchemy est le Python toolkit SQL et le mappeur d'objets relationnel qui donne aux développeurs d'applications la pleine puissance et la flexibilité de SQL. SQLAlchemy fournit une suite complète de modèles de persistance bien connus au niveau de l'entreprise, conçus pour un accès efficace et hautement performant aux bases de données, adaptés à un langage de domaine simple et Pythonic.
Installation
pip install sqlalchemy
Requête RAW
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, scoped_session
engine = create_engine("mysql://<user_name>:<password>@<Host_name>/<db_name>")
session_obj = sessionmaker(bind=engine)
session = scoped_session(session_obj)
# insert into database
session.execute("insert into person values(2, 'random_name')")
session.flush()
session.commit()
Façon ORM
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, scoped_session
Base = declarative_base()
engine = create_engine("mysql://<user_name>:<password>@<Host_name>/<db_name>")
session_obj = sessionmaker(bind=engine)
session = scoped_session(session_obj)
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine
class Person(Base):
__table= 'person'
# Here we define columns for the table person
# Notice that each column is also a normal Python instance attribute.
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
# insert into database
person_obj = Person(id=12, name="name")
session.add(person_obj)
session.flush()
session.commit()
MySQLdb est le moyen le plus simple. Vous devez exécuter des requêtes SQL sur une connexion. Période.
Ma méthode préférée, qui est également Pythonic, consiste à utiliser le puissant SQLAlchemy . Voici un tutoriel lié à la requête , et voici un tutoriel sur capacités ORM de SQLALchemy.
Juste une modification dans la réponse ci-dessus. Il suffit d’exécuter cette commande pour installer mysql pour python
Sudo yum install MySQL-python
Sudo apt-get install MySQL-python
rappelles toi! C'est sensible à la casse.
pour Python3.6, j'ai trouvé deux pilotes: pymysql et mysqlclient. J'ai testé la performance entre eux et obtenu le résultat: le mysqlclient est plus rapide.
ci-dessous est mon processus de test (besoin d'installer python lib profilehooks pour analyser le temps écoulé:
raw sql: select * from FOO;
exécuter immédiatement dans le terminal mysql: 46410 rows in set (0.10 sec)
pymysql (2.4s):
from profilehooks import profile
import pymysql.cursors
import pymysql
connection = pymysql.connect(Host='localhost', user='root', db='foo')
c = connection.cursor()
@profile(immediate=True)
def read_by_pymysql():
c.execute("select * from FOO;")
res = c.fetchall()
read_by_pymysql()
voici le profil de pymysql: 
mysqlclient (0.4s)
from profilehooks import profile
import MySQLdb
connection = MySQLdb.connect(Host='localhost', user='root', db='foo')
c = connection.cursor()
@profile(immediate=True)
def read_by_mysqlclient():
c.execute("select * from FOO;")
res = c.fetchall()
read_by_mysqlclient()
voici le profil mysqlclient: 
Donc, il semble que mysqlclient soit beaucoup plus rapide que pymysql
Le meilleur moyen de se connecter à MySQL depuis python consiste à utiliser MySQL Connector/Python car il s'agit du pilote Oracle officiel de MySQL permettant de travailler avec Python et fonctionnant avec Python. _ 3 et Python 2.
suivez les étapes mentionnées ci-dessous pour connecter MySQL
installer le connecteur en utilisant pip
pip install mysql-connector-python
ou vous pouvez télécharger le programme d'installation depuis https://dev.mysql.com/downloads/connector/python/
Utilisez la méthode
connect()du connecteur mysql python pour vous connecter à MySQL.Passez l'argument requis à la méthodeconnect(). c'est-à-dire l'hôte, le nom d'utilisateur, le mot de passe et le nom de la base de données.Créer un objet
cursorà partir d'un objet de connexion renvoyé parconnect()méthode permettant d'exécuter des requêtes SQL.fermez la connexion une fois votre travail terminé.
Exemple :
import mysql.connector
from mysql.connector import Error
try:
conn = mysql.connector.connect(Host='hostname',
database='db',
user='root',
password='passcode')
if conn.is_connected():
cursor = conn.cursor()
cursor.execute("select database();")
record = cursor.fetchall()
print ("Your connected to - ", record)
except Error as e :
print ("Print your error msg", e)
finally:
#closing database connection.
if(conn.is_connected()):
cursor.close()
conn.close()
Référence - https://pynative.com/python-mysql-database-connection/
Important API de MySQL Connector Python
Pour les opérations DML - Utilisez
cursor.execute()etcursor.executemany()pour lancer la requête. et après cela, utilisezconnection.commit()pour conserver vos modifications dans la base de données.Pour récupérer des données - Utilisez
cursor.execute()pour exécuter la requête etcursor.fetchall(),cursor.fetchone(),cursor.fetchmany(SIZE)pour récupérer des données
Regardez aussi Storm . C'est un outil de mappage SQL simple qui vous permet de facilement éditer et créer des entrées SQL sans écrire les requêtes.
Voici un exemple simple:
from storm.locals import *
# User will be the mapped object; you have to create the table before mapping it
class User(object):
__storm_table__ = "user" # table name
ID = Int(primary=True) #field ID
name= Unicode() # field name
database = create_database("mysql://root:password@localhost:3306/databaseName")
store = Store(database)
user = User()
user.name = u"Mark"
print str(user.ID) # None
store.add(user)
store.flush() # ID is AUTO_INCREMENT
print str(user.ID) # 1 (ID)
store.commit() # commit all changes to the database
Pour trouver et utiliser un objet:
michael = store.find(User, User.name == u"Michael").one()
print str(user.ID) # 10
Rechercher avec clé primaire:
print store.get(User, 1).name #Mark
Pour plus d'informations, voir le tutorial .
mysqlclient est ce qu'il y a de mieux, car les autres n'offrent qu'un support pour des versions spécifiques de python
pip install mysqlclient
exemple de code
import mysql.connector
import _mysql
db=_mysql.connect("127.0.0.1","root","umer","sys")
#db=_mysql.connect(Host,user,password,db)
# Example of how to insert new values:
db.query("""INSERT INTO table1 VALUES ('01', 'myname')""")
db.store_result()
db.query("SELECT * FROM new1.table1 ;")
#new1 is scheme table1 is table mysql
res= db.store_result()
for i in range(res.num_rows()):
print(result.fetch_row())
Exécutez cette commande dans votre terminal pour installer le connecteur mysql:
pip install mysql-connector-python
Et lancez ceci dans votre éditeur python pour vous connecter à MySQL:
import mysql.connector
mydb = mysql.connector.connect(
Host="localhost",
user="yourusername",
passwd="yourpassword",
database="mydatabase"
)
Exemples pour exécuter les commandes MySQL (dans votre python edior):
mycursor = mydb.cursor()
mycursor.execute("CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))")
mycursor.execute("SHOW TABLES")
mycursor.execute("INSERT INTO customers (name, address) VALUES ('John', 'Highway 21')")
mydb.commit() # Use this command after insert or update
Pour plus de commandes: https://www.w3schools.com/python/python_mysql_getstarted.asp
installez d'abord le pilote
pip install MySQL-python
Ensuite, un code de base va comme ceci:
#!/usr/bin/python
import MySQLdb
try:
db = MySQLdb.connect(Host="localhost", # db server, can be a remote one
db="mydb" # database
user="mydb", # username
passwd="mydb123", # password for this username
)
# Create a Cursor object
cur = db.cursor()
# Create a query string. It can contain variables
query_string = "SELECT * FROM MY_TABLE"
# Execute the query
cur.execute(query_string)
# Get all the rows present the database
for each_row in cur.fetchall():
print each_row
# Close the connection
db.close()
except Exception, e:
print 'Error ', e
C'est la connexion à la base de données Mysql
from flask import Flask, render_template, request
from flask_mysqldb import MySQL
app = Flask(__name__)
app.config['MYSQL_Host'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_PASSWORD'] = 'root'
app.config['MYSQL_DB'] = 'MyDB'
mysql = MySQL(app)
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == "POST":
details = request.form
cur = mysql.connection.cursor()
cur.execute ("_Your query_")
mysql.connection.commit()
cur.close()
return 'success'
return render_template('index.html')
if __== '__main__':
app.run()
vous pouvez connecter votre code python à mysql de cette façon.
import MySQLdb
db = MySQLdb.connect(Host="localhost",
user="appuser",
passwd="",
db="onco")
cursor = db.cursor()
Installez d'abord le pilote (Ubuntu)
Sudo apt-get installez python-pip
Sudo pip installer -U pip
Sudo apt-get installez python-dev libmysqlclient-dev
Sudo apt-get installe MySQL-python
Codes de connexion à la base de données MySQL
import MySQLdb
conn = MySQLdb.connect (Host = "localhost",user = "root",passwd = "pass",db = "dbname")
cursor = conn.cursor ()
cursor.execute ("SELECT VERSION()")
row = cursor.fetchone ()
print "server version:", row[0]
cursor.close ()
conn.close ()
Pour python 3.3
CyMySQL https://github.com/nakagami/CyMySQL
J'ai installé pip sur mes fenêtres 7, il suffit d'installer pip cymysql
(vous n'avez pas besoin de cython) rapide et sans douleur