SQL Query 결과를 PANDA Data Structure로 변환하는 방법

SQL Query 결과를 PANDA Data Structure로 변환하는 방법

이 문제에 대해 어떤 도움이라도 주시면 대단히 감사하겠습니다.

기본적으로 SQL 데이터베이스에 쿼리를 실행하여 반환된 데이터를 Panda 데이터 구조로 저장합니다.

문의용 코드를 첨부했습니다.

팬더에 대한 문서를 읽고 있지만, 반품 유형을 확인하는 데 문제가 있습니다.

조회 결과를 인쇄하려고 했지만 유용한 정보를 얻을 수 없습니다.

감사합니다!!!!

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
)

따라서 변수 "리저벌"의 형식과 데이터 유형이 무엇인지, PANDA 데이터 구조와 함께 사용하는 방법을 알고 싶습니다.

이 작업을 수행할 수 있는 가장 짧은 코드는 다음과 같습니다.

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

폴의 답변에 있는 대로 멋대로 활자를 해석할 수 있습니다.

편집 : 2015년 3월

아래에 기술한 바와 같이, Panda는 SQL Chemy를 사용하여 데이터베이스의 읽기(read_sql)와 삽입(to_sql)을 모두 수행합니다.다음 사항이 유효합니다.

import pandas as pd

df = pd.read_sql(sql, cnxn)

이전 답변: 유사한 질문에서 mikebmassey 경유

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

표현 언어가 아닌 SQL Chemy의 ORM을 사용하는 경우 유형 객체를 변환하고 싶을 수 있습니다.sqlalchemy.orm.query.Query팬더 데이터 프레임으로 이동합니다.

가장 깔끔한 접근법은 쿼리의 스테이트먼트 속성에서 생성된SQL을 가져와 판다의 어트리뷰트로 실행하는 것입니다.read_sql()방법.예: Query 개체로 시작합니다.query:

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

2014-09-30 편집:

팬더들은 이제read_sql기능.당신은 반드시 그것을 대신 사용하고 싶어합니다.

원답:

SQL Chemy는 도와드릴 수 없습니다.필요에 따라 항상 pyodbc, MySQLdb 또는 psychopg2를 사용합니다.그러나 이 경우 다음과 같은 간단한 기능이 내 요구에 맞는 경향이 있습니다.

import decimal

import pyodbc #just corrected a typo here
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 커넥터

mysql 커넥터를 사용하는 사용자는 이 코드를 시작할 수 있습니다.(@Daniel Velkov 덕분에)

사용된 참조:

• 커넥터/Python을 사용한 데이터 쿼리
• Python을 사용하여 MYSQL에 3단계로 연결

---

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

1. 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. SQL Chemy 사용

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

이게 내가 사용하는 코드야.이게 도움이 됐으면 좋겠다.

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)

다음은 문제에 대한 간결하고 명쾌한 답변입니다.

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)

Nathan과 마찬가지로 sqalchemy 또는 sqlsoup Query의 결과를 Panda 데이터 프레임에 덤프하고 싶은 경우가 많습니다.이에 대한 저만의 솔루션은 다음과 같습니다.

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

resoverall는 sqlalchemy ResultProxy 객체입니다.자세한 내용은 sqlalchemy 문서에서 확인할 수 있습니다.후자는 엔진과 Connections의 기본적인 사용법에 대해 설명합니다.여기서 중요한 것은resoverall받아쓰기를 좋아합니다.

판다는 데이터 구조를 만들기 위해 객체처럼 dict를 좋아합니다. 온라인 문서를 참조하십시오.

스칼케미와 판다에게 행운을 빈다.

'만들기'를 사용하세요.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))

가 쓴 적이 있어요.pyodbcSQL Server, MySQL, MariaDB, IBM).

이 질문은 오래되었지만, 나는 나의 2센트를 추가하고 싶었다.질문을 "[my]에게 쿼리를 실행하고 싶다.SQL 데이터베이스와 반환된 데이터를 Panda 데이터 구조[DataFrame]로 저장합니다."

코드를 보면 mysql 데이터베이스를 의미하는 것 같고, 팬더 Data Frame을 의미하는 것으로 추정됩니다.

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)

그러면 testTable의 모든 행이 DataFrame으로 Import됩니다.

지난 게시물로부터 오랜 시간이 흘렀지만 누군가에게 도움이 될지도...

Paul H보다 쇼트웨이:

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

여기 제 거예요."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

pandas.io.sql.write_frame은 DEPRECATED 입니다.https://pandas.pydata.org/pandas-docs/version/0.15.2/generated/pandas.io.sql.write_frame.html

팬더를 쓰려면 바꿔야죠DataFrame.to_sql https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html

다른 해결책이 있습니다.PYODBC to Pandars - DataFrame이 작동하지 않음 - 전달된 값의 모양은 (x,y), 지수는 (w,z)를 의미한다.

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

내가 이걸 하는 가장 좋은 방법

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

결과 유형이 ResultSet인 경우 먼저 사전으로 변환해야 합니다.그러면 DataFrame 열이 자동으로 수집됩니다.

이 방법은 내 경우에 유효합니다.

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

다음은 제가 좋아하는 간단한 솔루션입니다.

DB 연결 정보를 안전한 위치에 YAML 파일에 저장합니다(코드 repo에서 버전화하지 마십시오).

---
host: 'hostname'
port: port_number_integer
database: 'databasename'
user: 'username'
password: 'password'

그런 다음 사전에 conf를 로드하고 db 연결을 열고 SQL 쿼리의 결과 세트를 데이터 프레임에 로드합니다.

import yaml
import pymysql
import pandas as pd

db_conf_path = '/path/to/db-conf.yaml'

# Load DB conf
with open(db_conf_path) as db_conf_file:
    db_conf = yaml.safe_load(db_conf_file)

# Connect to the DB
db_connection = pymysql.connect(**db_conf)

# Load the data into a DF
query = '''
SELECT *
FROM my_table
LIMIT 10
'''

df = pd.read_sql(query, con=db_connection)

언급URL : https://stackoverflow.com/questions/12047193/how-to-convert-sql-query-result-to-pandas-data-structure