web-dev-qa-db-fra.com

python-pandas et bases de données comme mysql

La documentation de Pandas contient de nombreux exemples de meilleures pratiques pour travailler avec des données stockées dans divers formats.

Cependant, je suis incapable de trouver de bons exemples d'utilisation de bases de données telles que MySQL, par exemple.

Quelqu'un peut-il m'indiquer des liens ou donner des extraits de code expliquant comment convertir les résultats d'une requête à l'aide de mysql-python en fichiers de données dans Pandas de manière efficace?

pythonpandas
94
user1320615

Comme le dit Wes, read_sql d'io/sql le fera une fois que vous aurez établi une connexion à une base de données en utilisant une bibliothèque compatible DBI. Nous pouvons examiner deux exemples utilisant les bibliothèques MySQLdb et cx_Oracle pour se connecter à Oracle et MySQL et interroger leurs dictionnaires de données. Voici l'exemple pour cx_Oracle:

import pandas as pd
import cx_Oracle

ora_conn = cx_Oracle.connect('your_connection_string')
df_ora = pd.read_sql('select * from user_objects', con=ora_conn)    
print 'loaded dataframe from Oracle. # Records: ', len(df_ora)
ora_conn.close()

Et voici l'exemple équivalent pour MySQLdb:

import MySQLdb
mysql_cn= MySQLdb.connect(Host='myhost', 
                port=3306,user='myusername', passwd='mypassword', 
                db='information_schema')
df_mysql = pd.read_sql('select * from VIEWS;', con=mysql_cn)    
print 'loaded dataframe from MySQL. records:', len(df_mysql)
mysql_cn.close()
96
Keith C Campbell

Pour les lecteurs récents de cette question: les pandas ont l’avertissement suivant dans leur docs pour la version 14.0 :

Avertissement: Certaines des fonctions existantes ou des alias de fonctions ont été obsolète et sera supprimé dans les versions futures. Ceci comprend: tquery, uquery, read_frame, frame_query, write_frame. 

Et:

Avertissement: Le support de la variante «mysql» lors de l’utilisation d’objets de connexion DBAPI est été déconseillé. MySQL sera encore supporté avec SQLAlchemy moteurs (GH6900).

Cela rend de nombreuses réponses obsolètes. Vous devriez utiliser sqlalchemy:

from sqlalchemy import create_engine
import pandas as pd
engine = create_engine('dialect://user:pass@Host:port/schema', echo=False)
f = pd.read_sql_query('SELECT * FROM mytable', engine, index_col = 'ID')
52
Korem

Pour mémoire, voici un exemple utilisant une base de données sqlite:

import pandas as pd
import sqlite3

with sqlite3.connect("whatever.sqlite") as con:
    sql = "SELECT * FROM table_name"
    df = pd.read_sql_query(sql, con)
    print df.shape
23
mbatchkarov

Je préfère créer des requêtes avec SQLAlchemy , puis créer un DataFrame à partir de celui-ci. SQLAlchemy facilite la combinaison des conditions SQL en python si vous souhaitez mélanger et faire correspondre des éléments à plusieurs reprises.

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Table
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from pandas import DataFrame
import datetime

# We are connecting to an existing service
engine = create_engine('dialect://user:pwd@Host:port/db', echo=False)
Session = sessionmaker(bind=engine)
session = Session()
Base = declarative_base()

# And we want to query an existing table
tablename = Table('tablename', 
    Base.metadata, 
    autoload=True, 
    autoload_with=engine, 
    schema='ownername')

# These are the "Where" parameters, but I could as easily 
# create joins and limit results
us = tablename.c.country_code.in_(['US','MX'])
dc = tablename.c.locn_name.like('%DC%')
dt = tablename.c.arr_date >= datetime.date.today() # Give me convenience or...

q = session.query(tablename).\
            filter(us & dc & dt) # That's where the magic happens!!!

def querydb(query):
    """
    Function to execute query and return DataFrame.
    """
    df = DataFrame(query.all());
    df.columns = [x['name'] for x in query.column_descriptions]
    return df

querydb(q)
19
dmvianna

Exemple MySQL:

import MySQLdb as db
from pandas import DataFrame
from pandas.io.sql import frame_query

database = db.connect('localhost','username','password','database')
data     = frame_query("SELECT * FROM data", database)
10
aerkenemesis

La même syntaxe fonctionne pour Ms SQL Server utilisant également podbc. 

import pyodbc
import pandas.io.sql as psql

cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=servername;DATABASE=mydb;UID=username;PWD=password') 
cursor = cnxn.cursor()
sql = ("""select * from mytable""")

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

Et voici comment vous vous connectez à PostgreSQL avec le pilote psycopg2 (installer avec "apt-get install python-psycopg2" si vous utilisez un système d'exploitation dérivé de Debian Linux).

import pandas.io.sql as psql
import psycopg2

conn = psycopg2.connect("dbname='datawarehouse' user='user1' Host='localhost' password='uberdba'")

q = """select month_idx, sum(payment) from bi_some_table"""

df3 = psql.frame_query(q, conn)
5
Will

Pour Sybase, les travaux suivants (avec http://python-sybase.sourceforge.net )

import pandas.io.sql as psql
import Sybase

df = psql.frame_query("<Query>", con=Sybase.connect("<dsn>", "<user>", "<pwd>"))
4
user1827356

pandas.io.sql.frame_query est obsolète. Utilisez pandas.read_sql à la place.

4
ajkl

importer le module

import pandas as pd
import oursql

relier

conn=oursql.connect(Host="localhost",user="me",passwd="mypassword",db="classicmodels")
sql="Select customerName, city,country from customers order by customerName,country,city"
df_mysql = pd.read_sql(sql,conn)
print df_mysql

Cela fonctionne très bien et avec pandas.io.sql frame_works (avec l'avertissement de dépréciation). La base de données utilisée est la base de données exemple du tutoriel mysql.

1
user5925400

Cela devrait bien fonctionner.

import MySQLdb as mdb
import pandas as pd
con = mdb.connect(‘127.0.0.1’, ‘root’, ‘password’, ‘database_name’);
with con:
 cur = con.cursor()
 cur.execute(“select random_number_one, random_number_two, random_number_three from randomness.a_random_table”)
 rows = cur.fetchall()
 df = pd.DataFrame( [[ij for ij in i] for i in rows] )
 df.rename(columns={0: ‘Random Number One’, 1: ‘Random Number Two’, 2: ‘Random Number Three’}, inplace=True);
 print(df.head(20))
0
MontyPython

Cela m’a aidé à me connecter à AWS MYSQL (RDS) à partir de python 3.x basé la fonction lambda et chargement dans un pandas DataFrame

import json
import boto3
import pymysql
import pandas as pd
user = 'username'
password = 'XXXXXXX'
client = boto3.client('rds')
def lambda_handler(event, context):
    conn = pymysql.connect(Host='xxx.xxxxus-west-2.rds.amazonaws.com', port=3306, user=user, passwd=password, db='database name', connect_timeout=5)
    df= pd.read_sql('select * from TableName limit 10',con=conn)
    print(df)
    # TODO implement
    #return {
    #    'statusCode': 200,
    #    'df': df
    #}
0
Dheeraj