Python Language
Datenbankzugriff

Django Flask HTML GNU/Linux matplotlib MySQL opencv pandas Regular Expressions tensorflow
Suche…


Bemerkungen

Python kann viele verschiedene Arten von Datenbanken verarbeiten. Für jeden dieser Typen gibt es eine andere API. Um die Ähnlichkeit zwischen diesen verschiedenen APIs zu fördern, wurde PEP 249 eingeführt.

Diese API wurde definiert, um die Ähnlichkeit zwischen den Python-Modulen zu fördern, die für den Zugriff auf Datenbanken verwendet werden. Auf diese Weise hoffen wir, eine Konsistenz zu erreichen, die zu leicht verständlicheren Modulen, zu generell mehr portablem Code für Datenbanken und zu einer größeren Reichweite der Datenbankkonnektivität von Python führt. PEP-249

Zugriff auf MySQL-Datenbank mit MySQLdb

Als Erstes müssen Sie mit der connect-Methode eine Verbindung zur Datenbank herstellen. Danach benötigen Sie einen Cursor, der mit dieser Verbindung arbeitet.

Verwenden Sie die Ausführungsmethode des Cursors, um mit der Datenbank zu interagieren, und machen Sie die Änderungen gelegentlich mit der Festschreibungsmethode des Verbindungsobjekts fest.

Vergessen Sie nicht, den Cursor und die Verbindung zu schließen.

Hier ist eine Dbconnect-Klasse mit allem, was Sie brauchen. 

import MySQLdb

class Dbconnect(object):

    def __init__(self):

        self.dbconection = MySQLdb.connect(host='host_example',
                                           port=int('port_example'),
                                           user='user_example',
                                           passwd='pass_example',
                                           db='schema_example')
        self.dbcursor = self.dbconection.cursor()

    def commit_db(self):
        self.dbconection.commit()

    def close_db(self):
        self.dbcursor.close()
        self.dbconection.close()

Die Interaktion mit der Datenbank ist einfach. Nachdem Sie das Objekt erstellt haben, verwenden Sie einfach die Ausführungsmethode. 

db = Dbconnect()
db.dbcursor.execute('SELECT * FROM %s' % 'table_example')

Wenn Sie eine gespeicherte Prozedur aufrufen möchten, verwenden Sie die folgende Syntax. Beachten Sie, dass die Parameterliste optional ist. 

db = Dbconnect()
db.callproc('stored_procedure_name', [parameters] )

Nachdem die Abfrage abgeschlossen ist, können Sie auf mehrere Arten auf die Ergebnisse zugreifen. Das Cursorobjekt ist ein Generator, der alle Ergebnisse abrufen oder als Schleife ausführen kann. 

results = db.dbcursor.fetchall()
for individual_row in results:
    first_field = individual_row[0]

Wenn Sie eine Schleife verwenden möchten, die direkt den Generator verwendet: 

for individual_row in db.dbcursor:
    first_field = individual_row[0]

Wenn Sie Änderungen an der Datenbank festschreiben möchten: 

db.commit_db()

Wenn Sie den Cursor und die Verbindung schließen wollen: 

db.close_db()

SQLite

SQLite ist eine leichtgewichtige, festplattenbasierte Datenbank. Da kein separater Datenbankserver erforderlich ist, wird er häufig zum Prototyping oder für kleine Anwendungen verwendet, die häufig von einem einzelnen Benutzer oder von einem Benutzer zu einem bestimmten Zeitpunkt verwendet werden. 

import sqlite3

conn = sqlite3.connect("users.db")
c = conn.cursor()

c.execute("CREATE TABLE user (name text, age integer)")

c.execute("INSERT INTO user VALUES ('User A', 42)")
c.execute("INSERT INTO user VALUES ('User B', 43)")

conn.commit()

c.execute("SELECT * FROM user")
print(c.fetchall())

conn.close()

Der obige Code stellt eine Verbindung zu der Datenbank her, die in der Datei mit dem Namen users.db gespeichert ist. Die Datei wird zuerst erstellt, wenn sie noch nicht vorhanden ist. Sie können über SQL-Anweisungen mit der Datenbank interagieren.

Das Ergebnis dieses Beispiels sollte sein: 

[(u'User A', 42), (u'User B', 43)]

Die SQLite-Syntax: Eine eingehende Analyse

Fertig machen

  1. Importieren Sie das sqlite-Modul mit 

    >>> import sqlite3

  2. Um das Modul verwenden zu können, müssen Sie zuerst ein Connection-Objekt erstellen, das die Datenbank darstellt. Hier werden die Daten in der Datei example.db gespeichert: 

    >>> conn = sqlite3.connect('users.db')

    Alternativ können Sie auch den speziellen Namen :memory: erstellen Sie eine temporäre Datenbank im RAM: 

    >>> conn = sqlite3.connect(':memory:')

  3. Sobald Sie eine Connection , können Sie ein Cursor Objekt erstellen und seine Methode execute() aufrufen, um SQL-Befehle auszuführen: 

    c = conn.cursor()

# Create table
c.execute('''CREATE TABLE stocks
            (date text, trans text, symbol text, qty real, price real)''')

# Insert a row of data
c.execute("INSERT INTO stocks VALUES ('2006-01-05','BUY','RHAT',100,35.14)")

# Save (commit) the changes
conn.commit()

# We can also close the connection if we are done with it.
# Just be sure any changes have been committed or they will be lost.
conn.close()

Wichtige Eigenschaften und Funktionen der Connection

  1. isolation_level

    Mit diesem Attribut wird die aktuelle Isolationsstufe abgerufen oder festgelegt. Keine für den Autocommit-Modus oder eine der DEFERRED , IMMEDIATE oder EXCLUSIVE .

  1. cursor

    Das Cursorobjekt wird verwendet, um SQL-Befehle und Abfragen auszuführen.

  1. commit()

    Übernimmt die aktuelle Transaktion.

  1. rollback()

    Macht alle Änderungen rückgängig, die seit dem letzten Aufruf von commit()

  1. close()

    Schließt die Datenbankverbindung. commit() automatisch aufgerufen. Wenn close() aufgerufen wird, ohne vorher commit() aufzurufen (vorausgesetzt, Sie befinden sich nicht im Autocommit-Modus), gehen alle vorgenommenen Änderungen verloren.

  1. total_changes

    Ein Attribut, das die Gesamtzahl der Zeilen protokolliert, die seit dem Öffnen der Datenbank geändert, gelöscht oder eingefügt wurden.

  2. execute , executemany und executescript

    Diese Funktionen funktionieren genauso wie die des Cursorobjekts. Dies ist eine Abkürzung, da der Aufruf dieser Funktionen über das Verbindungsobjekt zur Erstellung eines Cursor-Zwischenobjekts und zum Aufrufen der entsprechenden Methode des Cursorobjekts führt

  1. row_factory

    Sie können dieses Attribut in eine aufrufbare Eigenschaft ändern, die den Cursor und die ursprüngliche Zeile als Tupel akzeptiert und die tatsächliche Ergebniszeile zurückgibt. 

    def dict_factory(cursor, row):
    d = {}
    for i, col in enumerate(cursor.description):
        d[col[0]] = row[i]
    return d

conn = sqlite3.connect(":memory:")
conn.row_factory = dict_factory

Wichtige Funktionen des Cursor

  1. execute(sql[, parameters])

    Führt eine einzelne SQL-Anweisung aus. Die SQL-Anweisung kann parametrisiert werden (dh Platzhalter statt SQL-Literale). Das Modul sqlite3 unterstützt zwei Arten von Platzhaltern: Fragezeichen ? ("Qmark style") und benannte Platzhalter :name ("named style"). 

    import sqlite3
conn = sqlite3.connect(":memory:")
cur = conn.cursor()
cur.execute("create table people (name, age)")

who = "Sophia"
age = 37
# This is the qmark style:
cur.execute("insert into people values (?, ?)",
            (who, age))

# And this is the named style:
cur.execute("select * from people where name=:who and age=:age",
            {"who": who, "age": age})  # the keys correspond to the placeholders in SQL

print(cur.fetchone())

Achtung: Verwenden Sie %s zum Einfügen von Zeichenfolgen in SQL-Befehle, da Ihr Programm dadurch anfällig für einen SQL-Injection-Angriff werden kann (siehe SQL Injection ).

  1. executemany(sql, seq_of_parameters)

    Führt einen SQL-Befehl für alle in der Sequenz sql gefundenen Parametersequenzen oder -zuordnungen aus. Das Modul sqlite3 ermöglicht auch die Verwendung eines Iterators, der anstelle einer Sequenz Parameter liefert. 

    L = [(1, 'abcd', 'dfj', 300),    # A list of tuples to be inserted into the database
     (2, 'cfgd', 'dyfj', 400),
     (3, 'sdd', 'dfjh', 300.50)]                           

conn = sqlite3.connect("test1.db")
conn.execute("create table if not exists book (id int, name text, author text, price real)")
conn.executemany("insert into book values (?, ?, ?, ?)", L)

for row in conn.execute("select * from book"):
    print(row)

    Sie können auch Iterator-Objekte als Parameter an das ausführende Unternehmen übergeben, und die Funktion durchläuft jedes Tupel von Werten, das der Iterator zurückgibt. Der Iterator muss ein Tupel von Werten zurückgeben. 

    import sqlite3

class IterChars:
    def __init__(self):
        self.count = ord('a')

    def __iter__(self):
        return self

    def __next__(self):            # (use next(self) for Python 2)
        if self.count > ord('z'):
            raise StopIteration
        self.count += 1
        return (chr(self.count - 1),) 

conn = sqlite3.connect("abc.db")
cur = conn.cursor()
cur.execute("create table characters(c)")

theIter = IterChars()
cur.executemany("insert into characters(c) values (?)", theIter)

rows = cur.execute("select c from characters")
for row in rows:
    print(row[0]),

  2. executescript(sql_script)

    Dies ist eine nicht dem Standard entsprechende Methode zum gleichzeitigen Ausführen mehrerer SQL-Anweisungen. Es gibt zuerst eine COMMIT Anweisung aus und führt dann das SQL-Skript aus, das es als Parameter erhält.

    sql_script kann eine Instanz von str oder bytes . 

    import sqlite3
conn = sqlite3.connect(":memory:")
cur = conn.cursor()
cur.executescript("""
     create table person(
         firstname,
         lastname,
         age
     );

     create table book(
         title,
         author,
         published
     );

     insert into book(title, author, published)
     values (
         'Dirk Gently''s Holistic Detective Agency',
         'Douglas Adams',
         1987
     );
     """)

    Die nächsten Funktionen werden in Verbindung mit SELECT Anweisungen in SQL verwendet. Um Daten nach der Ausführung einer SELECT Anweisung abzurufen, können Sie den Cursor entweder als Iterator behandeln, die Methode fetchone() des Cursors fetchone() , um eine einzelne übereinstimmende Zeile fetchall() , oder fetchall() aufrufen, um eine Liste der übereinstimmenden Zeilen fetchall() .

    Beispiel für das Iterator-Formular: 

    import sqlite3
stocks = [('2006-01-05', 'BUY', 'RHAT', 100, 35.14),
          ('2006-03-28', 'BUY', 'IBM', 1000, 45.0),
          ('2006-04-06', 'SELL', 'IBM', 500, 53.0),
          ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)]
conn = sqlite3.connect(":memory:")
conn.execute("create table stocks (date text, buysell text, symb text, amount int, price real)")
conn.executemany("insert into stocks values (?, ?, ?, ?, ?)", stocks)    
cur = conn.cursor()

for row in cur.execute('SELECT * FROM stocks ORDER BY price'):
    print(row)

# Output:
# ('2006-01-05', 'BUY', 'RHAT', 100, 35.14)
# ('2006-03-28', 'BUY', 'IBM', 1000, 45.0)
# ('2006-04-06', 'SELL', 'IBM', 500, 53.0)
# ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)

  3. fetchone()

    Ruft die nächste Zeile eines Abfrageergebnissatzes ab und gibt eine einzelne Sequenz zurück oder Keine, wenn keine weiteren Daten verfügbar sind. 

    cur.execute('SELECT * FROM stocks ORDER BY price')
i = cur.fetchone()
while(i): 
    print(i)
    i = cur.fetchone()

# Output:
# ('2006-01-05', 'BUY', 'RHAT', 100, 35.14)
# ('2006-03-28', 'BUY', 'IBM', 1000, 45.0)
# ('2006-04-06', 'SELL', 'IBM', 500, 53.0)
# ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)

  4. fetchmany(size=cursor.arraysize)

    Ruft die nächsten Zeilen eines Abfrageergebnisses ab (durch Größe angegeben) und gibt eine Liste zurück. Wenn size nicht angegeben wird, gibt fetchmany eine einzelne Zeile zurück. Eine leere Liste wird zurückgegeben, wenn keine weiteren Zeilen verfügbar sind. 

    cur.execute('SELECT * FROM stocks ORDER BY price')
print(cur.fetchmany(2))

# Output:    
# [('2006-01-05', 'BUY', 'RHAT', 100, 35.14), ('2006-03-28', 'BUY', 'IBM', 1000, 45.0)]

  5. fetchall()

    Ruft alle (verbleibenden) Zeilen eines Abfrageergebnisses ab und gibt eine Liste zurück. 

    cur.execute('SELECT * FROM stocks ORDER BY price')
print(cur.fetchall())

# Output:
# [('2006-01-05', 'BUY', 'RHAT', 100, 35.14), ('2006-03-28', 'BUY', 'IBM', 1000, 45.0), ('2006-04-06', 'SELL', 'IBM', 500, 53.0), ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)]

SQLite- und Python-Datentypen

SQLite unterstützt nativ die folgenden Typen: NULL, INTEGER, REAL, TEXT, BLOB.

Auf diese Weise werden die Datentypen konvertiert, wenn von SQL zu Python oder umgekehrt gewechselt wird. 

                None     <->     NULL
                int      <->     INTEGER/INT
                float    <->     REAL/FLOAT
                str      <->     TEXT/VARCHAR(n)
                bytes    <->     BLOB

PostgreSQL-Datenbankzugriff mit psycopg2

psycopg2 ist der beliebteste PostgreSQL-Datenbankadapter, der leicht und effizient ist. Es ist die aktuelle Implementierung des PostgreSQL-Adapters.

Seine Hauptmerkmale sind die vollständige Implementierung der Python DB API 2.0-Spezifikation und die Threadsicherheit (mehrere Threads können dieselbe Verbindung gemeinsam nutzen).

Herstellen einer Verbindung zur Datenbank und Erstellen einer Tabelle 

import psycopg2

# Establish a connection to the database.
# Replace parameter values with database credentials.
conn = psycopg2.connect(database="testpython", 
                        user="postgres",
                        host="localhost",
                        password="abc123",
                        port="5432") 

# Create a cursor. The cursor allows you to execute database queries. 
cur = conn.cursor()

# Create a table. Initialise the table name, the column names and data type. 
cur.execute("""CREATE TABLE FRUITS (
                    id          INT ,
                    fruit_name  TEXT,
                    color       TEXT,
                    price       REAL
            )""")
conn.commit()
conn.close()

Daten in die Tabelle einfügen: 

# After creating the table as shown above, insert values into it.
cur.execute("""INSERT INTO FRUITS (id, fruit_name, color, price)
               VALUES (1, 'Apples', 'green', 1.00)""")

cur.execute("""INSERT INTO FRUITS (id, fruit_name, color, price)
               VALUES (1, 'Bananas', 'yellow', 0.80)""")

Tabellendaten abrufen: 

# Set up a query and execute it 
cur.execute("""SELECT id, fruit_name, color, price 
             FROM fruits""")

# Fetch the data 
rows = cur.fetchall()

# Do stuff with the data
for row in rows:
    print "ID = {} ".format(row[0])
    print "FRUIT NAME = {}".format(row[1])
    print("COLOR = {}".format(row[2]))
    print("PRICE = {}".format(row[3]))

Die Ausgabe des obigen wäre: 

ID = 1 
NAME = Apples
COLOR = green
PRICE = 1.0

ID = 2 
NAME = Bananas
COLOR = yellow
PRICE = 0.8

Und jetzt wissen Sie die Hälfte von allem, was Sie über psycopg2 wissen müssen ! :)

Oracle-Datenbank

Voraussetzungen:

Konfiguration:

  • Installieren Sie das cx_Oracle-Paket wie folgt:

    sudo rpm -i <YOUR_PACKAGE_FILENAME>

  • Extrahieren Sie den Oracle Instant Client und legen Sie die Umgebungsvariablen wie folgt fest: 

ORACLE_HOME=<PATH_TO_INSTANTCLIENT>
PATH=$ORACLE_HOME:$PATH
LD_LIBRARY_PATH=<PATH_TO_INSTANTCLIENT>:$LD_LIBRARY_PATH

Verbindung herstellen: 

import cx_Oracle

class OraExec(object):
    _db_connection = None
    _db_cur = None

    def __init__(self):
        self._db_connection = 
            cx_Oracle.connect('<USERNAME>/<PASSWORD>@<HOSTNAME>:<PORT>/<SERVICE_NAME>')
        self._db_cur = self._db_connection.cursor()

Datenbankversion abrufen: 

ver = con.version.split(".")
print ver

Sample-Ausgabe: ['12 ',' 1 ',' 0 ',' 2 ',' 0 ']

Abfrage ausführen: SELECT 

_db_cur.execute("select * from employees order by emp_id")
for result in _db_cur:
    print result

Die Ausgabe erfolgt in Python-Tupeln:

(10, 'SYSADMIN', 'IT-INFRA', 7)

(23, 'HR ASSOCIATE', 'MENSCHLICHE RESSOURCEN', 6)

Abfrage ausführen: INSERT 

_db_cur.execute("insert into employees(emp_id, title, dept, grade) 
                values (31, 'MTS', 'ENGINEERING', 7)
_db_connection.commit()

Wenn Sie Einfüge- / Aktualisierungs- / Löschvorgänge in einer Oracle-Datenbank durchführen, sind die Änderungen nur in Ihrer Sitzung verfügbar, bis Sie ein commit ausführen. Wenn die aktualisierten Daten für die Datenbank festgeschrieben sind, stehen sie anderen Benutzern und Sitzungen zur Verfügung.

Abfrage ausführen: INSERT mit Bind-Variablen

Referenz

Bindungsvariablen ermöglichen es Ihnen, Anweisungen mit neuen Werten erneut auszuführen, ohne dass die Anweisung erneut analysiert werden muss. Bindungsvariablen verbessern die Wiederverwendbarkeit von Code und können das Risiko von SQL Injection-Angriffen verringern. 

rows = [ (1, "First" ),
     (2, "Second" ),
     (3, "Third" ) ]
_db_cur.bindarraysize = 3
_db_cur.setinputsizes(int, 10)
_db_cur.executemany("insert into mytab(id, data) values (:1, :2)", rows)
_db_connection.commit()

Verbindung schließen: 

_db_connection.close()

Die close () -Methode schließt die Verbindung. Alle Verbindungen, die nicht explizit geschlossen wurden, werden automatisch freigegeben, wenn das Skript endet.

Verbindung

Verbindung herstellen

Gemäß PEP 249 sollte die Verbindung zu einer Datenbank mithilfe eines connect() Konstruktors hergestellt werden, der ein Connection Objekt zurückgibt. Die Argumente für diesen Konstruktor sind datenbankabhängig. In den datenbankspezifischen Themen finden Sie die relevanten Argumente. 

import MyDBAPI

con = MyDBAPI.connect(*database_dependent_args)

Dieses Verbindungsobjekt verfügt über vier Methoden:

1: schließen 

con.close()

Schließt die Verbindung sofort. Beachten Sie, dass die Verbindung automatisch geschlossen wird, wenn die Connection.__del___ Methode aufgerufen wird. Alle ausstehenden Transaktionen werden implizit zurückgesetzt.

2: begehen 

con.commit()

Überträgt jede ausstehende Transaktion in die Datenbank.

3: Rollback 

con.rollback()

Rollt zum Beginn einer ausstehenden Transaktion zurück. Mit anderen Worten: Dies bricht jede nicht festgeschriebene Transaktion in der Datenbank ab.

4: Cursor 

cur = con.cursor()

Gibt ein Cursor Objekt zurück. Damit werden Transaktionen in der Datenbank ausgeführt.

Sqlalchemy verwenden

So verwenden Sie sqlalchemy für die Datenbank: 

from sqlalchemy import create_engine
from sqlalchemy.engine.url import URL


url = URL(drivername='mysql',
          username='user',
          password='passwd',
          host='host',
          database='db')

engine = create_engine(url)  # sqlalchemy engine

Jetzt kann diese Engine verwendet werden: zB mit Pandas, um Dataframes direkt von MySQL abzurufen 

import pandas as pd

con = engine.connect()
dataframe = pd.read_sql(sql=query, con=con)


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow