Wie verbinde ich mich mit einem Python-Programm mit einer MySQL-Datenbank?

Herstellen einer Verbindung zu MYSQL mit Python 2 in drei Schritten

1 - Einstellung

Sie müssen einen MySQL-Treiber installieren, bevor Sie etwas tun können. Im Gegensatz zu PHP wird in Python standardmäßig nur der SQLite-Treiber installiert. Das am häufigsten verwendete Paket ist MySQLdb, aber es ist schwierig, es mit easy_install zu installieren. Bitte beachten Sie, dass MySQLdb nur Python 2 unterstützt.

Für Windows-Benutzer können Sie eine Exe von MySQLdb erhalten .

Für Linux ist dies ein Gelegenheitspaket (python-mysqldb). (Sie können sudo apt-get install python-mysqldb(für Debian-basierte Distributionen), yum install MySQL-python(für RPM -basierte dnf install python-mysqlDistributionen) oder (für moderne Fedora-Distributionen) in der Befehlszeile zum Herunterladen verwenden.)

Für Mac können Sie MySQLdb mit Macport installieren .

2 - Verwendung

Starten Sie nach der Installation neu. Dies ist nicht obligatorisch, verhindert jedoch, dass ich 3 oder 4 andere Fragen in diesem Beitrag beantworte, wenn etwas schief geht. Also bitte neu starten.

Dann ist es wie bei jedem anderen Paket:

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

Natürlich gibt es Tausende von Möglichkeiten und Optionen; Dies ist ein sehr einfaches Beispiel. Sie müssen sich die Dokumentation ansehen. Ein guter Ausgangspunkt .

3 - Erweiterte Verwendung

Sobald Sie wissen, wie es funktioniert, können Sie ein ORM verwenden , um das manuelle Schreiben von SQL zu vermeiden und Ihre Tabellen so zu bearbeiten, als wären sie Python-Objekte. Das bekannteste ORM in der Python-Community ist SQLAlchemy .

Ich rate Ihnen dringend, es zu verwenden: Ihr Leben wird viel einfacher.

Ich habe kürzlich ein weiteres Juwel in der Python-Welt entdeckt: Peewee . Es ist ein sehr leichtes ORM, sehr einfach und schnell einzurichten und dann zu verwenden. Es ist mein Tag für kleine Projekte oder eigenständige Apps, bei denen die Verwendung großer Tools wie SQLAlchemy oder Django übertrieben ist:

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

Dieses Beispiel funktioniert sofort. Es ist nichts anderes als peewee ( pip install peewee) erforderlich.

Hier ist eine Möglichkeit, MySQLdb zu verwenden , das nur Python 2 unterstützt:

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

Referenz hier

Oracle (MySQL) unterstützt jetzt einen reinen Python-Connector. Das bedeutet, dass keine Binärdateien installiert werden müssen: Es ist nur eine Python-Bibliothek. Es heißt "Connector / Python".

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

Wenn Sie MySQLdb nicht benötigen, aber eine Bibliothek akzeptieren würden, würde ich MySQL Connector / Python von MySQL sehr, sehr empfehlen: http://dev.mysql.com/downloads/connector/python/ .

Es ist ein Paket (ca. 110 KB), reines Python, daher systemunabhängig und kinderleicht zu installieren. Sie müssen nur herunterladen, doppelklicken, die Lizenzvereinbarung bestätigen und loslegen. Xcode, MacPorts, Kompilieren, Neustarten sind nicht erforderlich.

Dann verbinden Sie sich wie:

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

Beenden Sie die Verwendung von MySQLDb, wenn Sie die Installation von MySQL-Headern vermeiden möchten, nur um von Python aus auf MySQL zuzugreifen.

Verwenden Sie pymysql . Es macht alles, was MySQLDb macht, aber es wurde rein in Python ohne externe Abhängigkeiten implementiert . Dies macht den Installationsprozess auf allen Betriebssystemen konsistent und einfach. pymysqlist ein Rückgang des Ersatzes für MySQLDb und IMHO gibt es keinen Grund, MySQLDb jemals für irgendetwas zu verwenden ... NIE! - PTSD from installing MySQLDb on Mac OSX and *Nix systems, aber das bin nur ich.

Installation

pip install pymysql

Das war's ... du bist bereit zu spielen.

Beispiel für die Verwendung von 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, ('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()

AUCH - Ersetzen Sie MySQLdb in vorhandenem Code schnell und transparent

Wenn Sie bereits Code haben, der MySQLdb verwendet, können Sie ihn mit diesem einfachen Verfahren einfach durch pymysql ersetzen:

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

Alle nachfolgenden Verweise auf MySQLdb verwenden pymysql transparent.

Versuchen Sie es mit MySQLdb . MySQLdb unterstützt nur Python 2.

Hier finden Sie eine Anleitung: http://www.kitebird.com/articles/pydbapi.html

Von der Seite:

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

Als DB- Treiber gibt es auch unsere SQL . Einige der Gründe, die auf diesem Link aufgeführt sind, sagen aus, warum unsere SQL besser ist:

• Unsere SQL verfügt über eine echte Parametrisierung, bei der SQL und Daten vollständig separat an MySQL gesendet werden.
• Mit ourql können Text- oder Binärdaten in die Datenbank gestreamt und aus der Datenbank gestreamt werden, anstatt dass alles im Client gepuffert werden muss.
• Unser SQL kann sowohl Zeilen träge einfügen als auch Zeilen träge abrufen.
• Unsere SQL unterstützt standardmäßig Unicode.
• Unser SQL unterstützt Python 2.4 bis 2.7 ohne Verfallswarnungen auf 2.6+ (siehe PEP 218) und ohne auf 2.7 vollständig zu versagen (siehe PEP 328).
• ourql läuft nativ auf Python 3.x.

Wie kann man mit unserer SQL eine Verbindung zu MySQL herstellen?

Sehr ähnlich zu 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]

Das Tutorial in der Dokumentation ist ziemlich anständig.

Und natürlich ist SQLAlchemy für ORM eine gute Wahl, wie bereits in den anderen Antworten erwähnt.

Führen Sie diesen Befehl in Ihrem Terminal aus, um den MySQL-Connector zu installieren:

pip install mysql-connector-python

Führen Sie dies in Ihrem Python-Editor aus, um eine Verbindung zu MySQL herzustellen:

import mysql.connector

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

Beispiele zum Ausführen von MySQL-Befehlen (in Ihrem 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

Für weitere Befehle: https://www.w3schools.com/python/python_mysql_getstarted.asp

SqlAlchemy

SQLAlchemy ist das Python SQL-Toolkit und Object Relational Mapper, das Anwendungsentwicklern die volle Leistung und Flexibilität von SQL bietet. SQLAlchemy bietet eine vollständige Suite bekannter Persistenzmuster auf Unternehmensebene, die für einen effizienten und leistungsstarken Datenbankzugriff entwickelt wurden und in eine einfache und pythonische Domänensprache umgewandelt wurden.

Installation

pip install sqlalchemy

RAW-Abfrage

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

ORM Weg

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

Trotz aller oben genannten Antworten können Sie connection.select_db(database), wie Sie im Folgenden zeigen möchten, eine Verbindung zu einer bestimmten Datenbank herstellen, z. B. wenn Sie die Datenbank noch (!) Erstellen möchten .

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 ist der einfache Weg. Sie können SQL-Abfragen über eine Verbindung ausführen. Zeitraum.

Mein bevorzugter Weg, der auch pythonisch ist, ist die Verwendung der mächtigen SQLAlchemy . Hier finden Sie ein Tutorial zum Thema Abfrage und ein Tutorial zu den ORM-Funktionen von SQLALchemy.

Für Python3.6 habe ich zwei Treiber gefunden: pymysql und mysqlclient. Ich habe die Leistung zwischen ihnen getestet und das Ergebnis erhalten: Der mysqlclient ist schneller.

Unten ist mein Testprozess (ich muss Python Lib Profilehooks installieren, um den Zeitablauf zu analysieren:

rohes SQL: select * from FOO;

sofort im MySQL-Terminal ausführen: 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()

Hier ist das Pymysql-Profil:

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

Hier ist das mysqlclient-Profil:

Es scheint also, dass mysqlclient viel schneller ist als pymysql

Auch wenn einige von euch dies als Duplikat markieren kann und aufregen , dass ich die Antwort von kopiere jemand anderes, würde ich WIRKLICH wie ein Aspekt von Herrn Napik Antwort zu markieren. Da ich dies verpasst habe, habe ich eine landesweite Ausfallzeit der Website (9 Minuten) verursacht. Wenn nur jemand diese Informationen geteilt hätte, hätte ich sie verhindern können!

Hier ist sein 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()

Das Wichtigste hier ist die Try and finally- Klausel. Dadurch können Verbindungen zu IMMER geschlossen werden, unabhängig davon, was im Cursor- / SQL-Anweisungsteil des Codes geschieht. Viele aktive Verbindungen führen zu einem Anstieg der DBLoadNoCPU und können einen Datenbankserver zum Absturz bringen.

Ich hoffe, diese Warnung hilft, Server und letztendlich Jobs zu retten! : D.

Die beste Möglichkeit, von Python aus eine Verbindung zu MySQL herzustellen, ist die Verwendung von MySQL Connector / Python, da es der offizielle Oracle-Treiber für MySQL für die Arbeit mit Python ist und sowohl mit Python 3 als auch mit Python 2 funktioniert.

Befolgen Sie die unten genannten Schritte, um MySQL zu verbinden

1. Installieren Sie den Stecker mit pip

   pip install mysql-connector-python

oder Sie können das Installationsprogramm von https://dev.mysql.com/downloads/connector/python/ herunterladen.

2. Verwenden Sie die connect()Methode von MySQL Connector Python, um eine Verbindung zu MySQL herzustellen. Übergeben Sie das erforderliche Argument an die connect()Methode. dh Host, Benutzername, Passwort und Datenbankname.

3. Erstellen Sie ein cursorObjekt aus einem von der connect()Methode zurückgegebenen Verbindungsobjekt, um SQL-Abfragen auszuführen.

4. Schließen Sie die Verbindung, nachdem Ihre Arbeit abgeschlossen ist.

Beispiel :

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

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

Wichtige API von MySQL Connector Python

• Für DML-Operationen - Verwenden Sie cursor.execute()und cursor.executemany(), um eine Abfrage auszuführen. und danach verwenden Sie, connection.commit()um Ihre Änderungen an der Datenbank beizubehalten

• Zu holen Daten - Verwenden Sie cursor.execute()laufen Abfrage und cursor.fetchall(), cursor.fetchone(), cursor.fetchmany(SIZE)zu holen Daten

Nur eine Änderung in der obigen Antwort. Führen Sie einfach diesen Befehl aus, um MySQL für Python zu installieren

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

merken! Es wird zwischen Groß- und Kleinschreibung unterschieden.

mysqlclient ist das Beste, da andere nur bestimmte Versionen von Python unterstützen

 pip install mysqlclient

Beispielcode

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

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

Schauen Sie sich auch Storm an . Es ist ein einfaches SQL-Mapping-Tool, mit dem Sie SQL-Einträge einfach bearbeiten und erstellen können, ohne die Abfragen schreiben zu müssen.

Hier ist ein einfaches Beispiel:

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

So finden und verwenden Sie Objekte:

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

Mit Primärschlüssel suchen:

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

Weitere Informationen finden Sie im Tutorial .

Dies ist eine MySQL-DB-Verbindung

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

Installieren Sie zuerst den Treiber

pip install MySQL-python   

Dann lautet ein Basiscode wie folgt:

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

Auf diese Weise können Sie Ihren Python-Code mit MySQL verbinden.

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

cursor = db.cursor()

Installieren Sie zuerst den Treiber (Ubuntu)

• sudo apt-get installiere python-pip

• sudo pip install -U pip

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

• sudo apt-get installiere MySQL-Python

MySQL-Datenbankverbindungscodes

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

Für Python 3.3

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

Ich habe pip auf meinem Windows 7 installiert, nur pip install cymysql

(Sie brauchen kein Cython) schnell und schmerzlos

Installieren Sie zunächst den Python-MySQL-Connector unter https://dev.mysql.com/downloads/connector/python/.

Geben Sie auf der Python-Konsole Folgendes ein:

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