अजगर-पांडा और डेटाबेस जैसे mysql

Question

पंडों के लिए प्रलेखन में विभिन्न स्वरूपों में संग्रहीत डेटा के साथ काम करने के लिए सर्वोत्तम प्रथाओं के कई उदाहरण हैं।

हालाँकि, उदाहरण के लिए MySQL जैसे डेटाबेस के साथ काम करने के लिए मुझे कोई अच्छा उदाहरण नहीं मिल पा रहा है।

क्या कोई मुझे लिंक या पॉइंट कोड दे सकता है कि कैसे पंडों में डेटा फ़्रेमों के लिए mysql-python का उपयोग करके कुशलतापूर्वक क्वेरी परिणामों को परिवर्तित करने के लिए कुछ कोड स्निपेट दें ?

Comments

प्रलेखन: pandas.pydata.org/pandas-docs/stable/io.html#sql-queries

— मैकेनिकल घोंघा

इन्हें भी देखें: stackoverflow.com/questions/15231646/…

— यांत्रिक घोंघा

ब्लेज़ पर भी एक नज़र डालें ।

— osa

यदि आप पैसे खर्च करने को तैयार हैं, तो मेरा मानना ​​है कि वेस मैककिनी की पुस्तक ("डेटा विश्लेषण के लिए पायथन") के कुछ उपयोगी उदाहरण हैं।

— MTrenfield

Answer 1

जैसा कि वेस कहते हैं, io / sql का read_sql यह करेगा, एक बार जब आप एक डेटाबेस कनेक्शन प्राप्त कर लेते हैं, तो D हम Oracle और MySQL से जुड़ने और उनके डेटा शब्दकोशों को क्वेरी करने के लिए MySQLdbऔर cx_Oracleलाइब्रेरीज़ का उपयोग करके दो छोटे उदाहरण देख सकते हैं । यहाँ के लिए उदाहरण है 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()

और यहाँ के लिए समान उदाहरण है 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()

Answer 2

इस प्रश्न के हाल के पाठकों के लिए : 14.0 संस्करण के लिए अपने डॉक्स में पांडा की निम्नलिखित चेतावनी है :

चेतावनी: कुछ मौजूदा फ़ंक्शन या फ़ंक्शन उपनामों को हटा दिया गया है और भविष्य के संस्करणों में हटा दिया जाएगा। इसमें शामिल हैं: टकीरी, यूकेरी, रीड_फ्रेम, फ्रेम_क्वेरी, राइट_फ्रेम।

तथा:

चेतावनी: DBAPI कनेक्शन ऑब्जेक्ट्स का उपयोग करते समय 'mysql' स्वाद के लिए समर्थन को हटा दिया गया है। MySQL को SQLAlchemy इंजन (GH6900) के साथ आगे सपोर्ट किया जाएगा।

इससे यहां के कई उत्तर पुराने हो जाते हैं। आपको उपयोग करना चाहिए 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')

Comments

133 पंक्तियों और 7 स्तंभों के साथ एक तालिका लोड करने में लगभग 30 सेकंड लगते हैं .. क्या आप कुछ अंतर्दृष्टि दे सकते हैं कि ऐसा क्यों है?

— इडोदा

@idoda [सामान्य तौर पर यह सवाल का विषय नहीं है और एक नया प्रश्न पूछना बेहतर है ताकि आप अधिक राय प्राप्त करें]। क्या आप सुनिश्चित हैं कि यह अनुरोध में देरी का मामला नहीं है? क्या केवल क्वेरी भेजना और परिणामों को तेज़ी से प्राप्त करना है?

— कुरान

@ कोरम मैंने एक नया खोलने के बारे में सोचा था, लेकिन मैं यह सुनिश्चित करना चाहता था कि यह पहले एक तुच्छ न हो। जब मैं एक mySql क्लाइंट (सीक्वल प्रो) का उपयोग करता हूं और डेटाबेस को क्वेरी करता हूं, तो पुन: प्रदर्शित होने में बहुत तेजी आती है। जब आप कहते हैं "बस भेजना और फिर पुनर्प्राप्त करना", तो क्या आपका मतलब है? (एक ग्राहक का उपयोग कर)

— idoda

@ सोडा का मतलब है कि अमल करने में लगने engine.execute("select * FROM mytable")वाले समय के साथ लगने वाले समय की तुलना करनाpd.read_sql_query('SELECT * FROM mytable', engine)

— कोरम

क्या कोई पंडालस विधि से सीधे एक sqlalchemy क्वेरी (सेशन। मेरे उत्तर के रूप में नीचे) कर सकता है? यह एक आरा होगा!

— dmvianna

Answer 3

रिकॉर्ड के लिए, यहां एक 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

Comments

आप निर्दिष्ट करने के द्वारा एक सूचकांक के रूप में उपयोग करने के लिए स्तंभ निर्दिष्ट कर सकते हैं index_col='timestamp'में frame_query।

— मैकेनिकल घोंघा

Answer 4

मैं SQLAlchemy के साथ क्वेरी बनाना पसंद करता हूं , और फिर इससे एक DataFrame बनाता हूं। यदि आप चीजों को मिक्स एंड मैच करने का इरादा रखते हैं, तो SQLAlchemy , SQL शर्तों को पाइथनिक रूप से संयोजित करना आसान बनाता है ।

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)

Comments

यदि आप SQLAlchemy के डिफ़ॉल्ट एक के समान नहीं हैं, तो भी आपको ड्राइवर को निर्दिष्ट करना होगा :dialect+driver://user:pwd@host:port/db

— नूनो एंड्रे

Answer 5

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)

Comments

frame_queryअब पदावनत हो गया है। अब pd.read_sql(query, db)इसके बजाय उपयोग करें ।

— राबर्ट स्मिथ

Answer 6

पॉडबेक का उपयोग करते हुए भी सुश्री एसक्यूएल सर्वर के लिए एक ही वाक्य रचना काम करती है।

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

Answer 7

और यह है कि आप Psycopg2 ड्राइवर का उपयोग करके PostgreSQL से कैसे कनेक्ट करें (यदि आप "डेबियन लिनक्स व्युत्पन्न OS पर हैं तो" apt-get install python-psycopg2 "स्थापित करें)।

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)

Answer 8

Sybase के लिए निम्नलिखित कार्य ( http://python-sybase.sourceforge.net के साथ )

import pandas.io.sql as psql
import Sybase

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

Answer 9

pandas.io.sql.frame_queryपदावनत किया गया है। pandas.read_sqlइसके बजाय उपयोग करें ।

Answer 10

मॉड्यूल आयात करें

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

यह ठीक काम करता है और pandas.io.sql फ्रेम_वर्क (डिप्रेशन चेतावनी के साथ) का उपयोग करता है। डेटाबेस का उपयोग mysql ट्यूटोरियल से नमूना डेटाबेस है।

Answer 11

यह ठीक काम करना चाहिए।

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

Answer 12

यह मेरे लिए अजगर 3.x आधारित lambda फ़ंक्शन से AWS MYSQL (RDS) को जोड़ने और एक पांडा में लोड करने में मदद करता है 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
    #}

Answer 13

उपयोगकर्ताओं को पोस्टग्रैज के लिए

import psycopg2
import pandas as pd

conn = psycopg2.connect("database='datawarehouse' user='user1' host='localhost' password='uberdba'")

customers = 'select * from customers'

customers_df = pd.read_sql(customers,conn)

customers_df

Comments

क्या आप @Will के जवाब के अंतर को इंगित कर सकते हैं और आपका समाधान क्यों चुना जाना चाहिए?

— सेबस्टियन