Jede Hilfe zu diesem Problem wird sehr geschätzt.

Grundsätzlich möchte ich eine Abfrage in meiner SQL-Datenbank ausführen und die zurückgegebenen Daten als Pandas-Datenstruktur speichern.

Ich habe Code für die Abfrage angehängt.

Ich lese die Dokumentation zu Pandas, habe jedoch Probleme, den Rückgabetyp meiner Abfrage zu ermitteln.

Ich habe versucht, das Abfrageergebnis zu drucken, aber es enthält keine nützlichen Informationen.

Vielen Dank!!!!

from sqlalchemy import create_engine

engine2 = create_engine('mysql://THE DATABASE I AM ACCESSING')
connection2 = engine2.connect()
dataid = 1022
resoverall = connection2.execute("
  SELECT 
      sum(BLABLA) AS BLA,
      sum(BLABLABLA2) AS BLABLABLA2,
      sum(SOME_INT) AS SOME_INT,
      sum(SOME_INT2) AS SOME_INT2,
      100*sum(SOME_INT2)/sum(SOME_INT) AS ctr,
      sum(SOME_INT2)/sum(SOME_INT) AS cpc
   FROM daily_report_cooked
   WHERE campaign_id = '%s'", %dataid)

Ich möchte also irgendwie verstehen, was das Format / der Datentyp meiner Variablen "resoverall" ist und wie ich sie in die PANDAS-Datenstruktur einfügen soll.

Hier ist der kürzeste Code, der die Arbeit erledigt:

from pandas import DataFrame
df = DataFrame(resoverall.fetchall())
df.columns = resoverall.keys()

Sie können schicker werden und die Typen wie in Pauls Antwort analysieren.

Bearbeiten: März 2015

Wie unten erwähnt, verwendet pandas jetzt SQLAlchemy, um sowohl aus ( read_sql ) zu lesen als auch in ( to_sql ) eine Datenbank einzufügen . Folgendes sollte funktionieren

import pandas as pd

df = pd.read_sql(sql, cnxn)

Vorherige Antwort: Über mikebmassey aus einer ähnlichen Frage

import pyodbc
import pandas.io.sql as psql

cnxn = pyodbc.connect(connection_info) 
cursor = cnxn.cursor()
sql = "SELECT * FROM TABLE"

df = psql.frame_query(sql, cnxn)
cnxn.close()

Wenn Sie ORM von SQLAlchemy anstelle der Ausdruckssprache verwenden, möchten Sie möglicherweise ein Objekt vom Typ sqlalchemy.orm.query.Queryin einen Pandas- Datenrahmen konvertieren .

Der sauberste Ansatz besteht darin, das generierte SQL aus dem Anweisungsattribut der Abfrage abzurufen und es dann mit der read_sql()Methode von pandas auszuführen . Beginnen Sie beispielsweise mit einem Abfrageobjekt mit dem Namen query:

df = pd.read_sql(query.statement, query.session.bind)

Bearbeiten 30.09.2014:

Pandas hat jetzt eine read_sqlFunktion. Sie möchten das definitiv stattdessen verwenden.

Ursprüngliche Antwort:

Ich kann Ihnen bei SQLAlchemy nicht helfen - ich verwende nach Bedarf immer pyodbc, MySQLdb oder psychopg2. Dabei entspricht eine so einfache Funktion wie die folgende meinen Anforderungen:

import decimal

import pydobc
import numpy as np
import pandas

cnn, cur = myConnectToDBfunction()
cmd = "SELECT * FROM myTable"
cur.execute(cmd)
dataframe = __processCursor(cur, dataframe=True)

def __processCursor(cur, dataframe=False, index=None):
    '''
    Processes a database cursor with data on it into either
    a structured numpy array or a pandas dataframe.

    input:
    cur - a pyodbc cursor that has just received data
    dataframe - bool. if false, a numpy record array is returned
                if true, return a pandas dataframe
    index - list of column(s) to use as index in a pandas dataframe
    '''
    datatypes = []
    colinfo = cur.description
    for col in colinfo:
        if col[1] == unicode:
            datatypes.append((col[0], 'U%d' % col[3]))
        elif col[1] == str:
            datatypes.append((col[0], 'S%d' % col[3]))
        elif col[1] in [float, decimal.Decimal]:
            datatypes.append((col[0], 'f4'))
        elif col[1] == datetime.datetime:
            datatypes.append((col[0], 'O4'))
        elif col[1] == int:
            datatypes.append((col[0], 'i4'))

    data = []
    for row in cur:
        data.append(tuple(row))

    array = np.array(data, dtype=datatypes)
    if dataframe:
        output = pandas.DataFrame.from_records(array)

        if index is not None:
            output = output.set_index(index)

    else:
        output = array

    return output

MySQL Connector

Für diejenigen, die mit dem MySQL-Connector arbeiten, können Sie diesen Code als Start verwenden. (Danke an @Daniel Velkov)

Gebrauchte Refs:

• Abfragen von Daten mit Connector / Python
• Herstellen einer Verbindung zu MYSQL mit Python in 3 Schritten

import pandas as pd
import mysql.connector

# Setup MySQL connection
db = mysql.connector.connect(
    host="<IP>",              # your host, usually localhost
    user="<USER>",            # your username
    password="<PASS>",        # your password
    database="<DATABASE>"     # 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 <TABLE>")

# Put it all to a data frame
sql_data = pd.DataFrame(cur.fetchall())
sql_data.columns = cur.column_names

# Close the session
db.close()

# Show the data
print(sql_data.head())

Hier ist der Code, den ich benutze. Hoffe das hilft.

import pandas as pd
from sqlalchemy import create_engine

def getData():
  # Parameters
  ServerName = "my_server"
  Database = "my_db"
  UserPwd = "user:pwd"
  Driver = "driver=SQL Server Native Client 11.0"

  # Create the connection
  engine = create_engine('mssql+pyodbc://' + UserPwd + '@' + ServerName + '/' + Database + "?" + Driver)

  sql = "select * from mytable"
  df = pd.read_sql(sql, engine)
  return df

df2 = getData()
print(df2)

Dies ist eine kurze und klare Antwort auf Ihr Problem:

from __future__ import print_function
import MySQLdb
import numpy as np
import pandas as pd
import xlrd

# Connecting to MySQL Database
connection = MySQLdb.connect(
             host="hostname",
             port=0000,
             user="userID",
             passwd="password",
             db="table_documents",
             charset='utf8'
           )
print(connection)
#getting data from database into a dataframe
sql_for_df = 'select * from tabledata'
df_from_database = pd.read_sql(sql_for_df , connection)

1. Verwenden von MySQL-connector-python

# pip install mysql-connector-python

import mysql.connector
import pandas as pd

mydb = mysql.connector.connect(
    host = 'host',
    user = 'username',
    passwd = 'pass',
    database = 'db_name'
)
query = 'select * from table_name'
df = pd.read_sql(query, con = mydb)
print(df)

2. Verwenden von SQLAlchemy

# pip install pymysql
# pip install sqlalchemy

import pandas as pd
import sqlalchemy

engine = sqlalchemy.create_engine('mysql+pymysql://username:password@localhost:3306/db_name')

query = '''
select * from table_name
'''
df = pd.read_sql_query(query, engine)
print(df)

Wie Nathan möchte ich häufig die Ergebnisse einer SQLalchemie- oder SQLSoup-Abfrage in einem Pandas-Datenrahmen speichern. Meine eigene Lösung dafür ist:

query = session.query(tbl.Field1, tbl.Field2)
DataFrame(query.all(), columns=[column['name'] for column in query.column_descriptions])

resoverallist ein sqlalchemy ResultProxy-Objekt. Weitere Informationen finden Sie in den sqlalchemy-Dokumenten . Letzteres erläutert die grundlegende Verwendung der Arbeit mit Engines und Connections. Wichtig ist hier, dass resoveralldiktiert wird.

Pandas diktieren gerne Objekte, um ihre Datenstrukturen zu erstellen. Weitere Informationen finden Sie in den Online-Dokumenten

Viel Glück mit sqlalchemy und Pandas.

Einfach benutzen pandasund pyodbczusammen. Sie müssen Ihre Verbindungszeichenfolge ( connstr) gemäß Ihren Datenbankspezifikationen ändern .

import pyodbc
import pandas as pd

# MSSQL Connection String Example
connstr = "Server=myServerAddress;Database=myDB;User Id=myUsername;Password=myPass;"

# Query Database and Create DataFrame Using Results
df = pd.read_sql("select * from myTable", pyodbc.connect(connstr))

Ich habe pyodbcmit mehreren Unternehmensdatenbanken (z. B. SQL Server, MySQL, MariaDB, IBM) verwendet.

Diese Frage ist alt, aber ich wollte meine zwei Cent hinzufügen. Ich las die Frage als "Ich möchte eine Abfrage an meine [meine] SQL-Datenbank ausführen und die zurückgegebenen Daten als Pandas-Datenstruktur [DataFrame] speichern."

Aus dem Code geht hervor, dass Sie MySQL-Datenbank meinen und davon ausgehen, dass Sie Pandas DataFrame meinen.

import MySQLdb as mdb
import pandas.io.sql as sql
from pandas import *

conn = mdb.connect('<server>','<user>','<pass>','<db>');
df = sql.read_frame('<query>', conn)

Beispielsweise,

conn = mdb.connect('localhost','myname','mypass','testdb');
df = sql.read_frame('select * from testTable', conn)

Dadurch werden alle Zeilen von testTable in einen DataFrame importiert.

Hier ist mein. Nur für den Fall, dass Sie "pymysql" verwenden:

import pymysql
from pandas import DataFrame

host   = 'localhost'
port   = 3306
user   = 'yourUserName'
passwd = 'yourPassword'
db     = 'yourDatabase'

cnx    = pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=db)
cur    = cnx.cursor()

query  = """ SELECT * FROM yourTable LIMIT 10"""
cur.execute(query)

field_names = [i[0] for i in cur.description]
get_data = [xx for xx in cur]

cur.close()
cnx.close()

df = DataFrame(get_data)
df.columns = field_names

pandas.io.sql.write_frame ist DEPRECATED. https://pandas.pydata.org/pandas-docs/version/0.15.2/generated/pandas.io.sql.write_frame.html

Sollte sich ändern, um pandas.DataFrame.to_sql zu verwenden https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html zu verwenden

Es gibt eine andere Lösung. PYODBC zu Pandas - DataFrame funktioniert nicht - Die Form der übergebenen Werte ist (x, y), Indizes implizieren (w, z)

Ab Pandas 0.12 (glaube ich) können Sie Folgendes tun:

import pandas
import pyodbc

sql = 'select * from table'
cnn = pyodbc.connect(...)

data = pandas.read_sql(sql, cnn)

Vor 0.12 konnten Sie Folgendes tun:

import pandas
from pandas.io.sql import read_frame
import pyodbc

sql = 'select * from table'
cnn = pyodbc.connect(...)

data = read_frame(sql, cnn)

Lange Zeit vom letzten Beitrag, aber vielleicht hilft es jemandem ...

Kurzweg als Paul H:

my_dic = session.query(query.all())
my_df = pandas.DataFrame.from_dict(my_dic)

am besten mache ich das

db.execute(query) where db=db_class() #database class
    mydata=[x for x in db.fetchall()]
    df=pd.DataFrame(data=mydata)

Wenn der Ergebnistyp ResultSet ist , sollten Sie ihn zuerst in ein Wörterbuch konvertieren. Dann werden die DataFrame-Spalten automatisch erfasst.

Das funktioniert in meinem Fall:

df = pd.DataFrame([dict(r) for r in resoverall])