SQL क्वेरी परिणाम PANDAS डेटा संरचना में कैसे परिवर्तित करें?

Question

इस समस्या पर किसी भी मदद की बहुत सराहना की जाएगी।

इसलिए मूल रूप से मैं अपने SQL डेटाबेस में एक क्वेरी चलाना चाहता हूं और पंडों के डेटा स्ट्रक्चर के रूप में लौटाए गए डेटा को स्टोर करना चाहता हूं।

मेरे पास क्वेरी के लिए कोड संलग्न है।

मैं पंडों पर प्रलेखन पढ़ रहा हूं, लेकिन मुझे अपनी क्वेरी के रिटर्न प्रकार की पहचान करने में समस्या है।

मैंने क्वेरी परिणाम को प्रिंट करने की कोशिश की, लेकिन यह कोई उपयोगी जानकारी नहीं देता है।

धन्यवाद!!!!

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)

इसलिए मैं यह समझना चाहता हूं कि मेरे चर "resoverall" का प्रारूप / प्रारूप क्या है और इसे पंडाल डेटा संरचना के साथ कैसे रखा जाए।

Comments

मूल रूप से, "resoverall" चर की संरचना / प्रकार क्या है और इसे पंडों की डेटा संरचना में कैसे परिवर्तित किया जाए।

— user1613017

पंडों को यह काफी दिलचस्प लगता है, मैंने इसके बारे में पहले नहीं सुना था, लेकिन यह सवाल मुश्किल से ही समझ में आता है। क्या आप कोशिश कर सकते हैं और स्पष्ट कर सकते हैं कि आपके द्वारा "किसी भी उपयोगी जानकारी नहीं देता है" का क्या मतलब है?

— tadman

क्योंकि जिस क्वेरी को मैंने निष्पादित किया है, वह रिटर्न देता है, बस सोच रहा हूं कि मुझे इस रिटर्न को कैसे हेरफेर करना चाहिए और इसे पंडों की डेटा संरचना में बनाना चाहिए। मैं अजगर के लिए बहुत नया हूं और इसलिए मुझे बहुत ज्ञान नहीं है, जैसे कि हम PHP में क्या करते हैं बस एक sql_fetch_array करना है और हमारे पास "उपयोगी" डेटा है। =)

— user1613017

Answer 1

यहाँ सबसे छोटा कोड है जो काम करेगा:

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

आप धर्मांध जा सकते हैं और पॉल के उत्तर के अनुसार प्रकारों को पार्स कर सकते हैं।

Comments

यह मेरे लिए एक Oracle डेटाबेस से 1.000.000 रिकॉर्ड के लिए काम किया।

— एरडेम काया

df = DataFrame(cursor.fetchall())रिटर्न ValueError: DataFrame constructor not properly called!, ऐसा प्रतीत होता है कि टुपल्स का टपल डाटाफ्रेम कंस्ट्रक्टर के लिए स्वीकार्य नहीं है। .keys()शब्दकोश या ट्यूपल मोड में कर्सर पर भी नहीं है।

— मोबिजिटल

बस ध्यान दें कि कुंजी विधि केवल sqlalchemy का उपयोग करके प्राप्त परिणामों के साथ काम करेगी। पाइलोडब कॉलम के लिए विवरण विशेषता का उपयोग करता है।

— फिलिप

क्या यह डेटाबेस के पोस्टग्रेज के लिए काम कर सकता है? मैं keys()फ़ंक्शन के साथ परिणाम डेटाफ़्रेम के लिए कॉलम नाम प्राप्त करने की कोशिश कर रहा हूं, लेकिन काम करने के लिए इसे प्राप्त नहीं कर सकता।

— बोवेन लियू

@BowenLiu हाँ, आप df.columns=[ x.name for x in recoverall.description ]

— psycopg2

Answer 2

संपादित करें: मार्च २०१५

जैसा कि नीचे उल्लेख किया गया है, पांडा अब ( read_sql ) से पढ़े और एक डेटाबेस में ( in_sql ) सम्मिलित करने के लिए SQLAlchemy का उपयोग करते हैं । निम्नलिखित काम करना चाहिए

import pandas as pd

df = pd.read_sql(sql, cnxn)

पिछला उत्तर: इसी तरह के सवाल से वाया माइकबस्मासी

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

Comments

ऐसा करने का यह सबसे अच्छा तरीका लगता है, क्योंकि आपको कॉलम इंडेक्स प्राप्त करने के लिए मैन्युअल रूप से .keys () का उपयोग करने की आवश्यकता नहीं है। संभवतः इस विधि के अस्तित्व में आने से पहले डेनियल का उत्तर लिखा गया था। आप pandas.io.sql.read_frame ()

— रोबिनल

@openwonk pd.read_sql()ऊपर कोड स्निपेट में कहां लागू होगा ?

— 3kstc

दरअसल, मेरी अंतिम प्रतिक्रिया के बाद से, मैंने उपयोग किया है pyodbcऔर pandasसाथ में काफी थोड़ा सा। उदाहरण के साथ नए उत्तर को जोड़ना, FYI करें।

— ओपनवॉक

Answer 3

यदि आप अभिव्यक्ति की भाषा के बजाय SQLAlchemy के ORM का उपयोग कर रहे हैं, तो आप अपने आप sqlalchemy.orm.query.Queryको पंडों के डेटा फ़्रेम में ऑब्जेक्ट के प्रकार को परिवर्तित करना चाहते हैं ।

सबसे साफ दृष्टिकोण क्वेरी के स्टेटमेंट विशेषता से उत्पन्न एसक्यूएल को प्राप्त करना है, और फिर इसे पांडा की read_sql()विधि के साथ निष्पादित करना है । उदाहरण के लिए, एक क्वेरी ऑब्जेक्ट के साथ शुरू होता है query:

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

Comments

एक अधिक कुशल दृष्टिकोण यह है कि sqlalchemy से स्टेटमेंट प्राप्त करें और पंडों को इसके साथ pandas.read_sql_queryगुजरते हुए स्वयं क्वेरी करें query.statement। इस उत्तर को देखें: stackoverflow.com/a/29528804/1273938

— LeoRochael

धन्यवाद @LeoRochael! मैंने अपना उत्तर संपादित किया। निश्चित रूप से क्लीनर!

— नाथन गोल्ड

Answer 4

2014-09-30 संपादित करें:

पांडा का अब एक read_sqlफंक्शन है। आप निश्चित रूप से इसके बजाय इसका उपयोग करना चाहते हैं।

मूल उत्तर:

मैं SQLAlchemy के साथ आपकी मदद नहीं कर सकता - मैं हमेशा जरूरत के हिसाब से pyodbc, MySQLdb, या psychopg2 का उपयोग करता हूं। लेकिन ऐसा करते समय, नीचे दिए गए एक फ़ंक्शन के रूप में सरल मेरी जरूरतों के अनुरूप है:

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

Comments

मुझे लगता है कि आपको ऊपर कहीं ऊपर दशमलव आयात करने की आवश्यकता है?

— जोफ्रोमक्ट

@joefromct शायद, लेकिन यह उत्तर इतना अप्रचलित है कि मुझे वास्तव में पूरी बात पर प्रहार करना चाहिए और पंडों के तरीकों को दिखाना चाहिए।

— H पर पॉल एच।

यह कुछ के लिए पुन: लागू हो सकता है ... जिस कारण से मैं यह पढ़ रहा था वह मेरे अन्य मुद्दे के कारण था, read_sql () का उपयोग करते हुए यहां stackoverflow.com/questions/32847246/…

— joefromct

यह उन लोगों के लिए प्रासंगिक है जो SQLAlchemy का उपयोग नहीं कर सकते हैं जो सभी डेटाबेस का समर्थन नहीं करते हैं।

— लैमिक्कल

@lamecicle कुछ असहमत। IIRC, read_sqlअभी भी गैर SQLAlchemy कनेक्शन स्वीकार कर सकता है जैसे, pyodbc, psychopg2, आदि

— पॉल एच।

Answer 5

MySQL कनेक्टर

उन लोगों के लिए जो mysql कनेक्टर के साथ काम करते हैं, आप इस कोड को एक शुरुआत के रूप में उपयोग कर सकते हैं। (@ डैनियल वेलकोव को धन्यवाद)

प्रयुक्त रेफरी:

• कनेक्टर / पायथन का उपयोग करके डेटा को छोड़ना
• 3 चरणों में MYSQL को पायथन के साथ जोड़ना

---

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

Answer 6

यहाँ मैं उपयोग कोड है। उम्मीद है की यह मदद करेगा।

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)

Answer 7

यह आपकी समस्या का एक छोटा और कुरकुरा जवाब है:

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)

Answer 8

1. MySQL-कनेक्टर-अजगर का उपयोग करना

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

Comments

सरल और महान जवाब!

— लुकास ऐमारेत्तो

Answer 9

नाथन की तरह, मैं अक्सर पंडों के डेटा फ्रेम में एक sqlalchemy या sqlsoup क्वेरी के परिणामों को डंप करना चाहता हूं। इसके लिए मेरा खुद का हल है:

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

Comments

यदि आपके पास कोई क्वेरी ऑब्जेक्ट है। Sqlalchemy से स्टेटमेंट प्राप्त करने और इसे pandas.read_sql_queryपास query.statementकरने के साथ पांडा को क्वेरी स्वयं करने दें , यह अधिक कुशल है। इस उत्तर को देखें: stackoverflow.com/a/29528804/1273938

— LeoRochael

Answer 10

resoverallएक sqlalchemy ResultProxy ऑब्जेक्ट है। आप sqlalchemy डॉक्स में इसके बारे में अधिक पढ़ सकते हैं , बाद वाले इंजन और कनेक्शंस के साथ काम करने के बुनियादी उपयोग के बारे में बताते हैं। यहां महत्वपूर्ण यह है कि resoverallजैसा तानाशाही है।

पंडों को अपनी डेटा संरचनाओं को बनाने के लिए वस्तुओं की तरह तानाशाही पसंद है, ऑनलाइन डॉक्स देखें

चक्कलकेमी और पंडों का सौभाग्य।

Answer 11

बस उपयोग pandasऔर pyodbcएक साथ। आपको connstrअपने डेटाबेस विनिर्देशों के अनुसार अपने कनेक्शन स्ट्रिंग ( ) को संशोधित करना होगा ।

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

मैंने pyodbcकई एंटरप्राइज़ डेटाबेस (जैसे SQL सर्वर, MySQL, MariaDB, IBM) का उपयोग किया है।

Comments

कैसे इस डेटाफ्रेम को फिर से वापस लिखकर MSSQL को Pyodbc का उपयोग करना है? Otherthan का उपयोग कर SQLAlchemy

— रैमसे

ऑब्जेक्ट to_sqlपर विधि का उपयोग करें DataFrame। यह तरीका SQLite के लिए डिफॉल्ट करता है, इसलिए आपको MSSQL डेटाबेस की ओर इशारा करते हुए इसे स्पष्ट रूप से पास करना होगा। डॉक्स देखें ।

— ओपनवॉन्क

मैंने नीचे की कोशिश की और मेरे पास 13 कॉलम के साथ लगभग 200K पंक्तियाँ हैं। यह 15 मिनट के बाद भी पूरा नहीं हुआ है। कोई विचार? df.to_sql ('tablename', इंजन, स्कीमा = 'schemaname', if_exists = 'append', index = False)

— रामसे

यह धीमा प्रतीत होता है ... मुझे संभवतः पूरे कोड को कार्रवाई में देखने की आवश्यकता होगी, क्षमा करें। मैं चाहता pandasथा कि प्रकाश ETL काम के लिए और अधिक अनुकूलित किया गया था, लेकिन अफसोस ...

— ओपनऑकॉन

Answer 12

यह प्रश्न पुराना है, लेकिन मैं अपना दो-सेंट जोड़ना चाहता था। मैंने प्रश्न को "मैं अपने [मेरे] SQL डेटाबेस के लिए एक क्वेरी चलाना और पंडों के डेटा संरचना [DataFrame] के रूप में लौटाए गए डेटा को संग्रहीत करना चाहता हूं।"

कोड से ऐसा लगता है कि आपका मतलब mysql डेटाबेस है और आप पंडों का मतलब डेटाफ़्रेम मानते हैं।

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)

उदाहरण के लिए,

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

यह TestFable की सभी पंक्तियों को एक DataFrame में आयात करेगा।

Answer 13

यह रहा मेरा। अगर आप "pymysql" का उपयोग कर रहे हैं तो बस:

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

Answer 14

pandas.io.sql.write_frame का मूल्यांकन किया गया है। https://pandas.pydata.org/pandas-docs/version/0.15.2/generated/pandas.io.sql.write_frame.html

Pandas.DataFrame.to_sql https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sll.html का उपयोग करने के लिए बदलना चाहिए

एक और उपाय है। पंडों को PYODBC - डेटाफ़्रेम काम नहीं कर रहा है - पारित मूल्यों का आकार है (x, y), सूचकांक का अर्थ है (w, z)

पंडों के रूप में 0.12 (मेरा मानना ​​है) आप कर सकते हैं:

import pandas
import pyodbc

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

data = pandas.read_sql(sql, cnn)

0.12 से पहले, आप कर सकते हैं:

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

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

data = read_frame(sql, cnn)

Comments

यह अब तक का सबसे आसान तरीका है

— Wilmer E. Henao

Answer 15

पिछले पोस्ट से लंबे समय तक लेकिन शायद यह किसी की मदद करता है ...

पॉल एच की तुलना में छोटा रास्ता:

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

Answer 16

सबसे अच्छा तरीका है कि मैं ऐसा करूं

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

Answer 17

यदि परिणाम प्रकार ResultSet है , तो आपको इसे पहले शब्दकोश में बदलना चाहिए। फिर DataFrame कॉलम अपने आप एकत्रित हो जाएगा।

यह मेरे मामले पर काम करता है:

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