Come mi collego a un database MySQL usando un programma Python?

Connessione a MYSQL con Python 2 in tre passaggi

1 - Impostazione

È necessario installare un driver MySQL prima di fare qualsiasi cosa. A differenza di PHP, solo il driver SQLite è installato di default con Python. Il pacchetto più usato per farlo è MySQLdb ma è difficile installarlo usando easy_install. Nota: MySQLdb supporta solo Python 2.

Per gli utenti Windows, puoi ottenere un exe di MySQLdb .

Per Linux, questo è un pacchetto casuale (python-mysqldb). (È possibile utilizzare sudo apt-get install python-mysqldb(per distribuzioni basate su debian), yum install MySQL-python(per basato su rpm) o dnf install python-mysql(per la distribuzione fedora moderna) nella riga di comando per scaricare.)

Per Mac, puoi installare MySQLdb usando Macport .

2 - Utilizzo

Dopo l'installazione, riavviare. Questo non è obbligatorio, ma mi impedirà di rispondere a 3 o 4 altre domande in questo post se qualcosa va storto. Quindi per favore riavvia.

Quindi è come usare qualsiasi altro pacchetto:

#!/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()

Certo, ci sono migliaia di possibilità e opzioni; questo è un esempio molto semplice. Dovrai consultare la documentazione. Un buon punto di partenza .

3 - Utilizzo più avanzato

Una volta che sai come funziona, potresti voler usare un ORM per evitare di scrivere manualmente SQL e manipolare le tue tabelle come fossero oggetti Python. L'ORM più famoso nella comunità Python è SQLAlchemy .

Ti consiglio vivamente di usarlo: la tua vita sarà molto più semplice.

Di recente ho scoperto un altro gioiello nel mondo Python: peewee . È un ORM molto leggero, davvero facile e veloce da configurare e utilizzare. È la mia giornata per piccoli progetti o app stand alone, dove l'utilizzo di grandi strumenti come SQLAlchemy o Django è eccessivo:

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

Questo esempio funziona immediatamente. Nient'altro che avere peewee ( pip install peewee) è richiesto.

Ecco un modo per farlo, usando MySQLdb , che supporta solo 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()

Riferimento qui

Oracle (MySQL) ora supporta un connettore Python puro. Ciò significa che nessun binario da installare: è solo una libreria Python. Si chiama "Connettore / Python".

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

Se non hai bisogno di MySQLdb, ma accetti qualsiasi libreria, ti consiglio caldamente MySQL Connector / Python di MySQL: http://dev.mysql.com/downloads/connector/python/ .

È un pacchetto (circa 110k), Python puro, quindi è indipendente dal sistema e semplicissimo da installare. Basta scaricare, fare doppio clic, confermare il contratto di licenza e andare. Non è necessario Xcode, MacPorts, compilare, riavviare ...

Quindi ti connetti come:

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

Smetti di usare MySQLDb se vuoi evitare di installare le intestazioni mysql solo per accedere a mysql da python.

Usa pymysql . Fa tutto ciò che fa MySQLDb, ma è stato implementato esclusivamente in Python senza dipendenze esterne . Ciò rende il processo di installazione su tutti i sistemi operativi coerente e semplice. pymysqlè un calo in sostituzione di MySQLDb e IMHO non c'è motivo di usare MySQLDb per nulla ... MAI! - PTSD from installing MySQLDb on Mac OSX and *Nix systems, ma sono solo io.

Installazione

pip install pymysql

Ecco fatto ... sei pronto per giocare.

Esempio di utilizzo dal repository Github di pymysql

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

ANCHE - Sostituisci MySQLdb nel codice esistente in modo rapido e trasparente

Se hai un codice esistente che utilizza MySQLdb, puoi facilmente sostituirlo con pymysql usando questo semplice processo:

# import MySQLdb << Remove this line and replace with:
import pymysql
pymysql.install_as_MySQLdb()

Tutti i riferimenti successivi a MySQLdb useranno pymysql in modo trasparente.

Prova a usare MySQLdb . MySQLdb supporta solo Python 2.

C'è un modo per pagina qui: http://www.kitebird.com/articles/pydbapi.html

Dalla pagina:

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

Come driver db, c'è anche il nostro qq . Alcuni dei motivi elencati su quel link, che dicono perché il nostroqq è migliore:

• oursql ha una vera parametrizzazione, inviando SQL e dati a MySQL completamente separatamente.
• oursql consente lo streaming di dati di testo o binari nel database e lo streaming fuori dal database, invece di richiedere che tutto sia bufferizzato nel client.
• oursql può sia inserire le righe pigramente sia recuperare le file pigramente.
• oursql ha il supporto Unicode attivo per impostazione predefinita.
• oursql supporta python da 2.4 a 2.7 senza alcun avviso di deprecazione su 2.6+ (vedi PEP 218) e senza fallire completamente su 2.7 (vedi PEP 328).
• oursql funziona nativamente su Python 3.x.

Quindi, come connettersi a mysql con Ourql?

Molto simile a 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]

Il tutorial nella documentazione è abbastanza decente.

E ovviamente per ORM SQLAlchemy è una buona scelta, come già menzionato nelle altre risposte.

Esegui questo comando nel tuo terminale per installare il connettore mysql:

pip install mysql-connector-python

Ed eseguilo nel tuo editor Python per connetterti a MySQL:

import mysql.connector

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

Esempi per eseguire i comandi MySQL (nel tuo 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

Per ulteriori comandi: https://www.w3schools.com/python/python_mysql_getstarted.asp

SQLAlchemy

SQLAlchemy è il toolkit SQL Python e Object Relational Mapper che offre agli sviluppatori di applicazioni tutta la potenza e la flessibilità di SQL. SQLAlchemy offre una suite completa di ben noti modelli di persistenza a livello aziendale, progettati per un accesso al database efficiente e ad alte prestazioni, adattati in un linguaggio di dominio semplice e Pythonic.

Installazione

pip install sqlalchemy

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

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

Nonostante tutte le risposte di cui sopra, nel caso in cui non si desideri connettersi a un database specifico in anticipo, ad esempio, se si desidera creare ancora il database (!), È possibile utilizzare connection.select_db(database), come dimostrato di seguito.

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 è il modo più semplice. È possibile eseguire query SQL su una connessione. Periodo.

Il mio modo preferito, che è anche pitonico, è usare invece il potente SQLAlchemy . Ecco un tutorial relativo alle query ed ecco un tutorial sulle funzionalità ORM di SQLALchemy.

per Python3.6 ho trovato due driver: pymysql e mysqlclient. Ho testato le prestazioni tra loro e ho ottenuto il risultato: il mysqlclient è più veloce.

di seguito è riportato il mio processo di test (è necessario installare i profili di python lib per analizzare il tempo trascorso time

sql grezzo: select * from FOO;

eseguire immediatamente nel terminale 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()

ecco il profilo 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()

ecco il profilo mysqlclient:

Quindi, sembra che mysqlclient sia molto più veloce di pymysql

Anche se alcuni di voi potrebbero contrassegnarlo come un duplicato e arrabbiarsi del fatto che sto copiando la risposta di qualcun altro, Vorrei VERAMENTE mettere in evidenza un aspetto della risposta del signor Napik. Perché ho perso questo, ho causato tempi di inattività del sito Web a livello nazionale (9 minuti). Se solo qualcuno avesse condiviso queste informazioni, avrei potuto impedirle!

Ecco il suo codice:

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

La cosa importante qui è la clausola Try and Infine . Ciò consente di chiudere SEMPRE le connessioni , indipendentemente da ciò che accade nella parte cursore / sqlstatement del codice. Molte connessioni attive causano il picco di DBLoadNoCPU e potrebbero causare l'arresto anomalo di un server db.

Spero che questo avviso aiuti a salvare i server e alla fine i lavori! : D

Il modo migliore per connettersi a MySQL da Python è utilizzare MySQL Connector / Python perché è un driver Oracle ufficiale per MySQL per lavorare con Python e funziona sia con Python 3 che con Python 2.

seguire i passaggi indicati di seguito per connettere MySQL

1. installare il connettore usando pip

   pip install mysql-connector-python

oppure puoi scaricare il programma di installazione da https://dev.mysql.com/downloads/connector/python/

2. Utilizzare il connect()metodo python del connettore mysql per connettersi a MySQL. Passare l'argomento richiesto al connect()metodo. cioè host, nome utente, password e nome del database.

3. Crea cursoroggetto dall'oggetto connessione restituito dal connect()metodo per eseguire query SQL.

4. chiudere la connessione al termine del lavoro.

Esempio :

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

Riferimento - https://pynative.com/python-mysql-database-connection/

API importante di MySQL Connector Python

• Per operazioni DML: utilizzare cursor.execute()e cursor.executemany()per eseguire la query. e dopo questo uso connection.commit()per mantenere le modifiche al DB

• Per recuperare i dati - Utilizzare cursor.execute()per eseguire query e cursor.fetchall(), cursor.fetchone(), cursor.fetchmany(SIZE)per recuperare i dati

Solo una modifica nella risposta sopra. Basta eseguire questo comando per installare mysql per Python

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

ricorda! Fa distinzione tra maiuscole e minuscole.

mysqlclient è il migliore in quanto altri forniscono supporto solo a versioni specifiche di Python

 pip install mysqlclient

codice di esempio

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

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

Dai anche un'occhiata a Storm . È un semplice strumento di mappatura SQL che consente di modificare e creare facilmente voci SQL senza scrivere le query.

Qui c'è un semplice esempio:

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

Per trovare e usare l'oggetto:

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

Trova con chiave primaria:

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

Per ulteriori informazioni consultare il tutorial .

Questa è la connessione 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()

installare prima il driver

pip install MySQL-python   

Quindi un codice di base è il seguente:

#!/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 

puoi connettere il tuo codice Python a mysql in questo modo.

import MySQLdb
db = MySQLdb.connect(host="localhost",
                 user="appuser",
                 passwd="",
                 db="onco")

cursor = db.cursor()

Prima installa il driver (Ubuntu)

• sudo apt-get install python-pip

• sudo pip install -U pip

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

• sudo apt-get installa MySQL-python

Codici di connessione al database 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 ()

Per python 3.3

CyMySQL https://github.com/nakagami/CyMySQL

Ho pip installato su Windows 7, solo pip installa cymysql

(non hai bisogno di cython) veloce e indolore

Innanzitutto, installa il connettore python-mysql da https://dev.mysql.com/downloads/connector/python/

sulla console Python inserire:

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