हल: पांडा टाइमडेल्टा टू पोस्टग्रेज

डेटा विश्लेषण की दुनिया में, समय श्रृंखला डेटा को संभालना एक महत्वपूर्ण पहलू है। इस उद्देश्य के लिए सबसे अधिक उपयोग की जाने वाली पुस्तकालयों में से एक ** पांडा ** पायथन प्रोग्रामिंग भाषा में है। समय श्रृंखला डेटा के साथ काम करते समय एक सामान्य कार्य विभिन्न घटनाओं के बीच समय के अंतर को एक मानक प्रारूप में बदलना है। यहीं पर पांडा टाइमडेल्टा काम आता है। हालाँकि, PostgreSQL जैसे डेटाबेस के साथ काम करते समय, इन टाइमडेल्टा को स्टोर करना थोड़ा मुश्किल हो सकता है। इस लेख में, हम चर्चा करेंगे कि कैसे पांडा टाइमडेल्टा को एक प्रारूप में परिवर्तित किया जाए जिसे पोस्टग्रेएसक्यूएल में संग्रहीत किया जा सकता है, और इसके सही प्रतिनिधित्व को बनाए रखते हुए इसे पुनः प्राप्त किया जा सकता है।

समस्या का समाधान

इस समस्या के समाधान में पांडा और psycopg2 पुस्तकालयों का उपयोग करना शामिल है, जो क्रमशः डेटा हेरफेर और PostgreSQL डेटाबेस प्रबंधन के लिए व्यापक रूप से उपयोग किए जाते हैं। Psycopg2 लाइब्रेरी में PostgreSQL में `अंतराल` डेटा प्रकार का उपयोग करके टाइमडेल्टास को संभालने के लिए समर्थन है। हम अपने पांडा टाइमडेल्टा को पोस्टग्रेएसक्यूएल में स्टोर करने के लिए इस सुविधा का लाभ उठाएंगे और इसे अपने उचित प्रारूप में वापस प्राप्त करेंगे।

सबसे पहले, आइए आवश्यक पुस्तकालयों को आयात करें और हमारे PostgreSQL डेटाबेस से संबंध स्थापित करें।

import pandas as pd
import psycopg2

conn = psycopg2.connect(database="your_database",
                        user="your_user",
                        password="your_password",
                        host="your_host",
                        port="your_port")

पांडा टाइमडेल्टा और पोस्टग्रेएसक्यूएल इंटरवल

पांडा टाइमडेल्टा एक सुसंगत और पठनीय तरीके से समय के अंतर को व्यक्त करने के लिए एक शक्तिशाली उपकरण है। पांडा में टाइमडेल्टा ऑब्जेक्ट्स बनाना और हेरफेर करना आसान है, लेकिन जब उन्हें PostgreSQL डेटाबेस में स्टोर करने की बात आती है, तो हमें उन्हें उपयुक्त प्रारूप में बदलने की आवश्यकता होती है।

PostgreSQL समय अंतरालों को संग्रहीत करने के लिए `अंतराल` डेटा प्रकार प्रदान करता है। यह डेटा प्रकार विभिन्न ग्रैन्युलैरिटी में समय अवधि का प्रतिनिधित्व कर सकता है, जैसे दिन, घंटे, मिनट और सेकंड। एक PostgreSQL डेटाबेस में पांडा Timedelta को संग्रहीत करने के लिए, हमें इसे PostgreSQL अंतराल में बदलने की आवश्यकता है।

चलिए Timedelta कॉलम के साथ एक नमूना pandas DataFrame बनाते हैं:

data = {'event_name': ['start', 'end'],
        'time': [pd.Timestamp('2021-01-01'), pd.Timestamp('2021-01-03')]}
df = pd.DataFrame(data)
df['difference'] = df['time'].diff()
print(df)

अब इस डेटा को हमारे PostgreSQL डेटाबेस में सम्मिलित करने के लिए एक फ़ंक्शन बनाते हैं और Timedelta डेटा को PostgreSQL-संगत अंतराल में परिवर्तित करते हैं।

def insert_data(event_name, time, difference, conn):
    query = """
    INSERT INTO timedeltas (event_name, time, difference)
    VALUES (%s, %s, %s)
    """
    with conn.cursor() as cur:
        cur.execute(query, (event_name, time, difference))
    conn.commit()

इस फ़ंक्शन का उपयोग करके, हम अपने पांडा डेटाफ़्रेम डेटा को PostgreSQL डेटाबेस में सम्मिलित कर सकते हैं:

for _, row in df.iterrows():
    event_name, time, difference = row['event_name'], row['time'], row['difference']
    insert_data(event_name, time, difference, conn)

PostgreSQL से Timedeltas को पुनः प्राप्त करना

एक बार पांडा टाइमडेल्टा डेटा को पोस्टग्रेएसक्यूएल में अंतराल के रूप में संग्रहीत किया जाता है, हम डेटा को पढ़ते समय उन्हें आसानी से पुनर्प्राप्त कर सकते हैं और उन्हें वापस पांडा टाइमडेल्टास में परिवर्तित कर सकते हैं।

आइए अपने PostgreSQL टेबल से डेटा लाने के लिए एक फंक्शन बनाएं:

def fetch_data(conn):
    query = "SELECT event_name, time, difference FROM timedeltas"
    data = pd.read_sql(query, conn)
    data['difference'] = pd.to_timedelta(data['difference'])
    return data

इस फ़ंक्शन के साथ, हम अपने PostgreSQL डेटाबेस से डेटा प्राप्त और प्रिंट कर सकते हैं:

result = fetch_data(conn)
print(result)

PostgreSQL से प्राप्त डेटा में अब अपना Timedeltas ठीक से पांडा Timedeltas के रूप में दर्शाया गया है।

अंत में, पांडा टाइमडेल्टा को पोस्टग्रेएसक्यूएल स्टोरेज के लिए उपयुक्त प्रारूप में परिवर्तित करना और इसे अपने मूल रूप में पुनः प्राप्त करना एक सीधी प्रक्रिया है। शक्तिशाली पांडा और psycopg2 पुस्तकालयों का लाभ उठाकर, हम समय श्रृंखला डेटा को आसानी से संभाल सकते हैं और हमारे डेटा विश्लेषण और हमारे डेटाबेस स्टोरेज दोनों में इसका उचित प्रतिनिधित्व बनाए रख सकते हैं।