मुझे डेटा की एक तालिका को कैसे ढूढ़ना और एक्सेस करना चाहिए ताकि मैं पाइथन 3.5 में आसानी से सबसेट की तुलना कर सकूं?

Question

1. क्या ऐसा करने का एक तेज़, अधिक पाइथोनिक तरीका है?
2. क्या है यह चेतावनी UserWarning: Boolean Series key will be reindexed to match DataFrame index. "DataFrame index.", UserWarning और क्या मुझे इससे चिंतित होना चाहिए?

मेरे पास 3 कॉलम के साथ एक सीएसवी फ़ाइल है: संगठन, महीने, व्यक्ति।

| org | month | person | 
| --- | ---------- | ------ | 
| 1 | 2014-01-01 | 100 | 
| 1 | 2014-01-01 | 200 | 
| 1 | 2014-01-02 | 200 | 
| 2 | 2014-01-01 | 300 | 

कौन सा मैं के साथ एक pandas.core.frame.DataFrame में पढ़ा है: अंतिम लक्ष्य

data = pd.read_csv('data_base.csv', names=['month', 'org', 'person'], skiprows=1) 

पहले की अवधि में व्यक्तियों की सेट के साथ 2 में लगातार अंतराल के बीच व्यक्तियों के चौराहे तुलना करने के लिए है।

org: 1, month: 2014-01-01, count(intersection((100, 200), 200))/len(set(100, 200)) == 0.5 

संपादित करें: मैं इसके साथ काम करने के लिए मिल गया:

import pandas as pd 
import sys 

data = pd.read_csv('data_base.csv', names=['month', 'org', 'person'], skiprows=1) 
data.sort_values(by=['org', 'month', 'person']) 

results = {} 
for _org in set(data.org): 
    results[_org] = {} 
    months = sorted(list(set(data[data.org == _org].month))) 
    for _m1, _m2 in zip(months, months[1:]): 
     _s1 = set(data[data.org == _org][data.month == _m1].person) 
     _s2 = set(data[data.org == _org][data.month == _m2].person) 
     results[_org][_m1] = float(len(_s1 & _s2)/len(_s1)) 
     print(str(_org) + '\t' + str(_m1) + '\t' + str(_m2) + '\t' + str(round(results[_org][_m1], 2))) 
     sys.stdout.flush() 

कौन इस तरह उत्पादन का उत्पादन:

UserWarning: Boolean Series key will be reindexed to match DataFrame index. "DataFrame index.", UserWarning 
5640 2014-01-01 2014-02-01 0.75 
5640 2014-02-01 2014-03-01 0.36 
5640 2014-03-01 2014-04-01 0.6 
... 

लेकिन यह वास्तव में धीमी गति से और तरह बदसूरत की है ... पर वर्तमान दर मेरी पिछली-लिफाफा-गणना डेटा के 2-वर्षीय बैच के लिए लगभग 22 घंटे अनुमानित करती है।

Answer 1

मान्य है, मैंने कभी पांडों का उपयोग नहीं किया है, इसलिए यह मूर्खतापूर्ण नहीं हो सकता है। यह सिर्फ मूल पायथन संरचनाओं का उपयोग करता है।

import collections 
org_month_dict = collections.defaultdict(set) 

# put the data into a simple, indexed data structure 
for index, row in data.iterrows(): 
    org_month_dict[row['org'], row['month']].add(row['person']) 

orgs = set(data.org) 
months = sorted(set(data.months)) 
for org in orgs: 
    for mindex in range(len(months)-1): 
     m1 = months[mindex] 
     m2 = months[mindex+1] 
     print org_month_dict[org, m2] & org_month_dict[org, m1] # persons in common between month 1 and 2 

यह org_month_dict जो संगठन और महीने के द्वारा अनुक्रमित में एक "कैश की गई" लुकअप तालिका बनाता है, अपने भीतर के पाश में महंगा data[data.org == _org][data.month == _m1] देखने कर से बचाने। यह आपके मूल कोड से काफी तेजी से चलना चाहिए।

Answer 2

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

यह आपके डेटा को स्टोर करने का एक और सुविधाजनक तरीका प्रदान करता है (तिथियों से निपटने के सुविधाजनक तरीके भी प्रदान करता है। और जब आप कर लेंगे, तो आप परिणामों को टैब्यूलर रूप में आउटपुट कर सकते हैं।

सबसे पहले, मैं मुद्दों को बेहतर ढंग से प्रदर्शित करने के लिए डेटा का विस्तार करने जा रहा हूं।

org  month person 
0  1 2014-01-01  100 
1  1 2014-01-01  200 
2  1 2014-01-02  200 
3  1 2014-01-03  300 
4  1 2014-01-03  100 
5  1 2014-01-04  200 
6  1 2014-01-04  100 
7  1 2014-01-04  300 
8  2 2014-01-01  100 
9  2 2014-01-01  200 
10 2 2014-01-02  300 
11 2 2014-01-02  400 
12 2 2014-01-03  100 
13 2 2014-01-04  200 
14 2 2014-01-04  100 

उसके बाद, आप कुछ इस तरह कर सकता है:

df['one'] = 1 
df = df.set_index(['org','month','person']).unstack('person') 
numer = ((df==df.shift(-1)) & (df.notnull())).sum(axis=1) 
denom = df.notnull().sum(axis=1) 

df['numer'] = numer 
df['denom'] = denom 
df['ratio'] = numer/denom 

       one    numer denom  ratio 
person   100 200 300 400      
org month           
1 2014-01-01 1 1 NaN NaN  1  2 0.500000 
    2014-01-02 NaN 1 NaN NaN  0  1 0.000000 
    2014-01-03 1 NaN 1 NaN  2  2 1.000000 
    2014-01-04 1 1 1 NaN  2  3 0.666667 
2 2014-01-01 1 1 NaN NaN  0  2 0.000000 
    2014-01-02 NaN NaN 1 1  0  2 0.000000 
    2014-01-03 1 NaN NaN NaN  1  1 1.000000 
    2014-01-04 1 1 NaN NaN  0  2 0.000000 

मैं, यहाँ कुछ विवरण अनदेखी कर रहा हूँ ऑर्ग 1 के बीच ब्रेकपाइंट की तरह और संगठन 2, लेकिन आप इस से निपटने के लिए एक GroupBy जोड़ सकता है । इसी प्रकार, आप किसी भी व्यक्ति के साथ दिन को संभालने के लिए कोड जोड़ना चाह सकते हैं और इसके साथ निपटने के तरीके भी हैं।