Comment me connecter à une base de données MySQL à l'aide d'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 package le plus utilisé pour ce faire est MySQLdb mais il est difficile de l'installer en utilisant easy_install. Veuillez noter que MySQLdb ne prend en charge que Python 2.

Pour les utilisateurs de Windows, vous pouvez obtenir un exe de MySQLdb .

Pour Linux, il s'agit d'un package 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 rpm) ou dnf install python-mysql(pour la distribution Fedora moderne) en ligne de commande pour télécharger.)

Pour Mac, vous pouvez installer MySQLdb à l'aide de 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 dans ce post en cas de problème. Veuillez donc redémarrer.

Ensuite, c'est comme utiliser n'importe quel autre package:

#!/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; ceci est un exemple très basique. Vous devrez consulter la documentation. Un bon point de départ .

3 - Utilisation plus avancée

Une fois que vous savez comment cela fonctionne, vous souhaiterez peut-être utiliser un ORM pour éviter d'écrire SQL manuellement et manipuler vos tables car elles étaient des objets Python. L'ORM le plus célèbre de la communauté Python est SQLAlchemy .

Je vous conseille fortement de l'utiliser: votre vie va être beaucoup plus facile.

J'ai récemment découvert un autre joyau du monde Python: le peewee . C'est un ORM très léger, vraiment facile et rapide à configurer puis à utiliser. Cela rend ma journée pour les petits projets ou les applications autonomes, où l'utilisation de gros outils comme SQLAlchemy ou Django est exagérée:

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 peewee ( pip install peewee) n'est requis.

Voici une façon de le faire, en utilisant MySQLdb , qui ne prend en charge 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()

Référence ici

Oracle (MySQL) prend désormais en charge un connecteur Python pur. Cela signifie qu'aucun binaire à installer: c'est juste une bibliothèque Python. Cela s'appelle "Connector / Python".

http://dev.mysql.com/downloads/connector/python/

Si vous n'avez pas besoin de MySQLdb, mais accepteriez n'importe quelle bibliothèque, je recommanderais très, très fortement MySQL Connector / Python de MySQL: http://dev.mysql.com/downloads/connector/python/ .

C'est un paquet (environ 110k), pur Python, il est donc indépendant du système et simple à installer. Il vous suffit de télécharger, de double-cliquer, de confirmer l'accord de licence et de partir. Pas besoin de Xcode, MacPorts, de compilation, de 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 voulez éviter d'installer des en-têtes mysql juste pour accéder à mysql à partir de python.

Utilisez pymysql . Il fait tout ce que fait MySQLDb, mais il a été implémenté uniquement en Python sans AUCUNE Dépendance Externe . Cela rend le processus d'installation sur tous les systèmes d'exploitation cohérent et facile. pymysqlest une baisse en remplacement de MySQLDb et à mon humble avis, il n'y a aucune raison d'utiliser jamais MySQLDb pour rien ... JAMAIS! - PTSD from installing MySQLDb on Mac OSX and *Nix systems, mais c'est juste moi.

Installation

pip install pymysql

Ça y est ... vous êtes prêt à jouer.

Exemple d'utilisation du repo pymysql Github

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, ('webmaster@python.org', '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, ('webmaster@python.org',))
        result = cursor.fetchone()
        print(result)
finally:
    connection.close()

AUSSI - Remplacez MySQLdb dans le code existant rapidement et de manière transparente

Si vous avez du code existant qui 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 prend en charge que Python 2.

Il y a une page comment ici: http://www.kitebird.com/articles/pydbapi.html

Depuis 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 db, il existe également oursql . Certaines des raisons énumérées sur ce lien, qui expliquent pourquoi oursql est meilleur:

• oursql a un paramétrage réel, envoyant le SQL et les données à MySQL complètement séparément.
• oursql permet de diffuser du texte ou des données binaires dans la base de données et de les diffuser hors de la base de données, 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 récupérer des lignes paresseusement.
• oursql prend en charge Unicode par défaut.
• oursql prend en charge python 2.4 à 2.7 sans aucun avertissement de dépréciation sur 2.6+ (voir PEP 218) et sans échouer complètement sur 2.7 (voir PEP 328).
• oursql s'exécute 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 assez décent.

Et bien sûr pour ORM SQLAlchemy est un bon choix, comme déjà mentionné dans les autres réponses.

Exécutez cette commande dans votre terminal pour installer le connecteur mysql:

pip install mysql-connector-python

Et exécutez ceci dans votre éditeur python pour vous connecter à MySQL:

import mysql.connector

mydb = mysql.connector.connect(
      host="localhost",
      user="yusername",
      passwd="password",
      database="database_name"
)

Exemples pour exécuter les commandes MySQL (dans votre éditeur python):

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

SqlAlchemy

SQLAlchemy est la boîte à outils Python SQL et le mappeur relationnel objet qui offre aux développeurs d'applications toute la puissance et la flexibilité de SQL. SQLAlchemy fournit une suite complète de modèles de persistance au niveau de l'entreprise bien connus, conçus pour un accès à la base de données efficace et performant, adaptés dans un langage de domaine Pythonic simple.

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()

Manière 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):
    __tablename__ = '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()

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 la base de données (!), Vous pouvez utiliser connection.select_db(database), comme illustré ci-dessous.

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()

MySQLdb est le moyen simple. Vous obtenez d'exécuter des requêtes SQL sur une connexion. Période.

Ma façon préférée, qui est également pythonique, est d'utiliser à la place le puissant SQLAlchemy . Voici un didacticiel relatif aux requêtes , et voici un didacticiel sur les capacités ORM de SQLALchemy.

pour Python3.6, j'ai trouvé deux pilotes: pymysql et mysqlclient. J'ai testé les performances entre eux et j'ai obtenu le résultat: le mysqlclient est plus rapide.

ci-dessous est mon processus de test (besoin d'installer des crochets de profil de bibliothèque python pour analyser le temps écoulé:

sql brut: select * from FOO;

exécuter immédiatement dans le terminal mysql: 46410 rows in set (0.10 sec)

pymysql (2,4 s):

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 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:

Il semble donc que mysqlclient soit beaucoup plus rapide que pymysql

Même si certains d'entre vous peuvent marquer cela comme un doublon et s'énerver que je copie la réponse de quelqu'un d'autre, j'aimerais vraiment souligner un aspect de la réponse de M. Napik. Parce que j'ai raté cela, j'ai causé un temps d'arrêt du site Web national (9min). Si seulement quelqu'un avait partagé ces informations, j'aurais pu les empêcher!

Voici son code:

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()

L'important ici est le Essayez et enfin l' article. Cela permet de fermer TOUJOURS les connexions à , indépendamment de ce qui se passe dans la partie curseur / sqlstatement du code. De nombreuses connexions actives provoquent un pic de DBLoadNoCPU et pourraient bloquer un serveur db.

J'espère que cet avertissement permet d'économiser des serveurs et finalement des emplois! :RÉ

La meilleure façon de se connecter à MySQL depuis python est d'utiliser MySQL Connector / Python car il s'agit du pilote Oracle officiel pour MySQL pour travailler avec Python et il fonctionne avec Python 3 et Python 2.

suivez les étapes mentionnées ci-dessous pour connecter MySQL

1. installer le connecteur à l'aide de pip

   pip install mysql-connector-python

ou vous pouvez télécharger le programme d'installation à partir de https://dev.mysql.com/downloads/connector/python/

2. Utilisez la connect()méthode du connecteur mysql python pour vous connecter à MySQL.passez l'argument requis à connect()method. c'est-à-dire hôte, nom d'utilisateur, mot de passe et nom de la base de données.

3. Créer un cursorobjet à partir d'un objet de connexion renvoyé par la connect()méthode pour exécuter des requêtes SQL.

4. 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 ("You're 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/

API importante de MySQL Connector Python

• Pour les opérations DML - Utilisez cursor.execute()et cursor.executemany()pour exécuter la requête. et après cette utilisation, connection.commit()pour conserver vos modifications dans la base de données

• Pour récupérer les données - Utiliser cursor.execute()pour exécuter la requête et cursor.fetchall(), cursor.fetchone(), cursor.fetchmany(SIZE)pour extraire des données

Juste une modification dans la réponse ci-dessus. Exécutez simplement cette commande pour installer mysql pour python

sudo yum install MySQL-python
sudo apt-get install MySQL-python

rappelles toi! Il est sensible à la casse.

mysqlclient est le meilleur car les autres ne fournissent un support qu'à 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())

voir https://github.com/PyMySQL/mysqlclient-python

Jetez également un œil à Storm . Il s'agit d'un simple outil de mappage SQL qui vous permet de modifier et de créer facilement 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 rechercher et utiliser un objet:

michael = store.find(User, User.name == u"Michael").one()
print str(user.ID) # 10

Rechercher avec la clé primaire:

print store.get(User, 1).name #Mark

Pour plus d'informations, consultez le didacticiel .

Ceci est la connexion Mysql DB

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 __name__ == '__main__':
    app.run()

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 

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 install python-pip

• sudo pip install -U pip

• sudo apt-get install python-dev libmysqlclient-dev

• sudo apt-get install 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 mon windows 7, il suffit d'installer pip cymysql

(vous n'avez pas besoin de cython) rapide et indolore

Tout d'abord, installez le connecteur python-mysql à partir de https://dev.mysql.com/downloads/connector/python/

sur la console Python, entrez:

pip install mysql-connector-python-rf
import mysql.connector