Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> Python

पायथन पांडस में लेक्सिकोग्राफिकल स्लाइसिंग का उपयोग करके डेटा के सबसेट का चयन कैसे करें?

परिचय

इंडेक्स स्थिति का उपयोग करके या इंडेक्स लेबल का उपयोग करके डेटा के सबसेट का चयन करने के लिए पांडा के पास दोहरी चयन क्षमता है। इस पोस्ट में, मैं आपको दिखाऊंगा कि "लेक्सिकोग्राफिकल स्लाइसिंग का उपयोग करके डेटा का एक सबसेट कैसे चुनें"।

Google डेटासेट से भरा है। kaggle.com में मूवी डेटासेट खोजें। यह पोस्ट kaggle से मूवी डेटा सेट का उपयोग करती है।

इसे कैसे करें

1. मूवी डेटासेट को केवल इस उदाहरण के लिए आवश्यक कॉलम के साथ आयात करें।

import pandas as pd
import numpy as np
movies = pd.read_csv("https://raw.githubusercontent.com/sasankac/TestDataSet/master/movies_data.csv",index_col="title",
usecols=["title","budget","vote_average","vote_count"])
movies.sample(n=5)


<थ>वोट_गिनती
शीर्षक <थ>बजट वोट_औसत
छोटी आवाज 0 6.6 61
ग्रोन अप 2 80000000 5.8 1155
हमारे जीवन के सर्वश्रेष्ठ वर्ष 2100000 7.6 143
टस्क 280000 5.1 366
ऑपरेशन क्रोमाइट 0 5.8 29

2. मैं हमेशा इंडेक्स को सॉर्ट करने की सलाह देता हूं, खासकर अगर इंडेक्स स्ट्रिंग्स से बना हो। यदि आप अपनी अनुक्रमणिका को क्रमबद्ध करते समय एक विशाल डेटासेट के साथ काम कर रहे हैं तो आपको अंतर दिखाई देगा।

यदि मैं अनुक्रमणिका को क्रमित न करूँ तो क्या होगा?

कोई बात नहीं आपका कोड हमेशा के लिए चलने वाला है। बस मजाक कर रहे हैं, ठीक है अगर इंडेक्स लेबल्स को छोड़ दिया गया है तो पांडा को आपकी क्वेरी से मेल खाने के लिए सभी लेबलों को एक-एक करके पार करना होगा। एक इंडेक्स पेज के बिना ऑक्सफोर्ड डिक्शनरी की कल्पना करें, आप क्या करने जा रहे हैं? अनुक्रमित अनुक्रमणिका के साथ आप उस लेबल पर तेज़ी से कूद सकते हैं जिसे आप निकालना चाहते हैं, ऐसा ही पांडास्तु के साथ भी है।

आइए पहले जांच लें कि हमारी अनुक्रमणिका क्रमबद्ध है या नहीं।

# check if the index is sorted or not ?
movies.index.is_monotonic

False

3. स्पष्ट रूप से, सूचकांक क्रमबद्ध नहीं है। हम A% से शुरू होने वाली फिल्मों का चयन करने का प्रयास करेंगे। यह लिखने जैसा है

select * from movies where title like'A%'


movies.loc["Aa":"Bb"]
---------------------------------------------------------------------------
ValueErrorTraceback (most recent call last)
~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in get_slice_bound(self, labe l, side, kind)
4844try:
-> 4845return self._searchsorted_monotonic(label, side) 4846except ValueError:

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in _searchsorted_monotonic(se lf, label, side)
4805
-> 4806raise ValueError("index must be monotonic increasing or decreasing")
4807

ValueError: index must be monotonic increasing or decreasing

During handling of the above exception, another exception occurred:

KeyErrorTraceback (most recent call last)
in
----> 1 movies.loc["Aa": "Bb"]

~\anaconda3\lib\site-packages\pandas\core\indexing.py in getitem (self, key)
1766
1767maybe_callable = com.apply_if_callable(key, self.obj)
-> 1768return self._getitem_axis(maybe_callable, axis=axis) 1769
1770def _is_scalar_access(self, key: Tuple):

~\anaconda3\lib\site-packages\pandas\core\indexing.py in _getitem_axis(self, key, axis)
1910if isinstance(key, slice):
1911self._validate_key(key, axis)
-> 1912return self._get_slice_axis(key, axis=axis) 1913elif com.is_bool_indexer(key):
1914return self._getbool_axis(key, axis=axis)

~\anaconda3\lib\site-packages\pandas\core\indexing.py in _get_slice_axis(self, slice_ob j, axis)
1794
1795labels = obj._get_axis(axis)
-> 1796indexer = labels.slice_indexer(
1797slice_obj.start, slice_obj.stop, slice_obj.step, kind=self.name 1798)

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in slice_indexer(self, start, end, step, kind)
4711slice(1, 3)
4712"""
-> 4713start_slice, end_slice = self.slice_locs(start, end, step=step, kind=ki nd)
4714
4715# return a slice

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in slice_locs(self, start, en d, step, kind)
4924start_slice = None
4925if start is not None:
-> 4926start_slice = self.get_slice_bound(start, "left", kind) 4927if start_slice is None:
4928start_slice = 0

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in get_slice_bound(self, labe l, side, kind)
4846except ValueError:
4847# raise the original KeyError
-> 4848raise err
4849
4850if isinstance(slc, np.ndarray):

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in get_slice_bound(self, labe l, side, kind)
4840# we need to look up the label
4841try:
-> 4842slc = self.get_loc(label) 4843except KeyError as err:
4844try:

~\anaconda3\lib\site-packages\pandas\core\indexes\base.py in get_loc(self, key, method,

tolerance)
2646return self._engine.get_loc(key)
2647except KeyError:
-> 2648return self._engine.get_loc(self._maybe_cast_indexer(key))
2649indexer = self.get_indexer([key], method=method, tolerance=tolerance) 2650if indexer.ndim > 1 or indexer.size > 1:

pandas\_libs\index.pyx in pandas._libs.index.IndexEngine.get_loc() pandas\_libs\index.pyx in pandas._libs.index.IndexEngine.get_loc()
pandas\_libs\index.pyx in pandas._libs.index.IndexEngine._get_loc_duplicates()

pandas\_libs\index.pyx in pandas._libs.index.IndexEngine._maybe_get_bool_indexer() KeyError: 'Aa'

4. इंडेक्स को आरोही क्रम में क्रमबद्ध करें और लेक्सिकोग्राफिकल स्लाइसिंग के लिए छँटाई का लाभ उठाने के लिए उसी कमांड को आज़माएँ।

True

5. अब हमारा डेटा सेट हो गया है और लेक्सिकोग्राफिकल स्लाइसिंग के लिए तैयार है। आइए अब अक्षर A से शुरू होकर अक्षर B तक सभी मूवी टाइटल चुनें।

<थेड> <थ>बजट <थ>वोट_गिनती
शीर्षक वोट_औसत
छोड़ें 25000000 4.6 45
छोड़ दिया गया 0 5.8 27
अपहरण 35000000 5.6 961
एबरडीन 0 7.0 6
पिछली रात के बारे में 12500000 6.0 210
... ... ... ...
वानरों के ग्रह के लिए लड़ाई 170000 5.5 215
वर्ष की लड़ाई 20000000 5.9 88
लड़ाई:लॉस एंजिल्स 70000000 5.5 1448
युद्धक्षेत्र पृथ्वी 44000000 3.0 255
युद्धपोत 209000000 5.5 2114


<थेड> <थ>बजट <थ>वोट_गिनती
शीर्षक वोट_औसत
फ्लक्स पर 62000000 5.4 703
xXx:संघ राज्य 60000000 4.7 549
xXx 70000000 5.8 1424
eXistenZ 15000000 6.7 475
[REC]² 5600000 6.4 489

बजट वोट_औसत वोट_गिनती शीर्षक

यह खाली डेटाफ़्रेम को देखने के लिए कोई दिमाग नहीं है क्योंकि डेटा को उल्टे क्रम में क्रमबद्ध किया जाता है। आइए अक्षरों को उलट दें और इसे फिर से चलाएं।

<थेड> <थ>बजट <थ>वोट_गिनती
शीर्षक वोट_औसत
बी-गर्ल 0 5.5 7
आयुर्वेद:होने की कला 300000 5.5 3
दूर हम चलते हैं 17000000 6.7 189
जागृत 86000000 6.3 395
एवेंजर्स:एज ऑफ अल्ट्रॉन 280000000 7.3 6767
... ... ... ...
पिछली रात के बारे में 12500000 6.0 210
एबरडीन 0 7.0 6
अपहरण 35000000 5.6 961
छोड़ दिया गया 0 5.8 27
छोड़ें 25000000 4.6 45



  1. पायथन - पंडों के सूचकांक में डेटा का प्रतिनिधित्व करने वाली एक सरणी लौटाएं

    पांडा इंडेक्स में डेटा का प्रतिनिधित्व करने वाली एक सरणी वापस करने के लिए, index.values . का उपयोग करें पंडों में संपत्ति। सबसे पहले, आवश्यक पुस्तकालयों को आयात करें - import pandas as pd अनुक्रमणिका बनाना - index = pd.Index(['Car','Bike','Truck','Ship','Airplan

  1. पायथन - जांचें कि क्या पंडों के सूचकांक में स्पष्ट डेटा है

    यह जांचने के लिए कि क्या पंडों के सूचकांक में स्पष्ट डेटा है, index.is_categorical() का उपयोग करें। पंडों में विधि। सबसे पहले, आवश्यक पुस्तकालयों को आयात करें - import pandas as pd श्रेणी . के रूप में सेट प्रकार के साथ पांडा अनुक्रमणिका बनाना astype() . का उपयोग करके विधि - index = pd.Index(["

  1. पायथन - पांडस डेटाफ्रेम के सबसेट का चयन कैसे करें

    मान लें कि Microsoft Excel में खोली गई हमारी CSV फ़ाइल की सामग्री निम्नलिखित हैं - सबसे पहले, CSV फ़ाइल से पंडों के डेटाफ़्रेम में डेटा लोड करें - dataFrame = pd.read_csv("C:\\Users\\amit_\\Desktop\\SalesData.csv") उपसमुच्चय का चयन करने के लिए वर्गाकार कोष्ठकों का प्रयोग करें। कोष्ठक म