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?
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()
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')
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
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)
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)
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()
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)
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>"))
pandas.io.sql.frame_query
est obsolète. Utilisez pandas.read_sql
à la place.
import pandas as pd
import oursql
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.
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))
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
#}