पांडा बनाम बनाम इलोक बनाम ix बनाम iat?

Question

हाल ही में पायथन में मेरी सुरक्षित जगह (आर) से बाहर शाखा शुरू हुई और सेल स्थानीयकरण / चयन में थोड़ा भ्रमित हूं Pandas। मैंने दस्तावेज़ीकरण पढ़ा है लेकिन मैं विभिन्न स्थानीयकरण / चयन विकल्पों के व्यावहारिक प्रभाव को समझने के लिए संघर्ष कर रहा हूं।

• वहाँ एक कारण है कि मैं कभी भी उपयोग करना चाहिए है .locया .ilocसबसे सामान्य विकल्प पर .ix?
• मैं समझता हूँ कि .loc, iloc, at, और iatकुछ की गारंटी शुद्धता कि प्रदान कर सकता है .ixप्रदान नहीं कर सकते, लेकिन मैं यह भी पढ़ा है, जहां .ixबोर्ड भर में सबसे तेजी से समाधान हो जाता है।
• कृपया वास्तविक दुनिया की व्याख्या करें, इसके अलावा किसी अन्य चीज़ का उपयोग करने के पीछे सबसे अच्छा अभ्यास है .ix?

Comments

बाहर की जाँच करें stackoverflow.com/questions/27667759/…

— cphlewis

locलेबल आधारित अनुक्रमण है, इसलिए मूल रूप से एक पंक्ति में एक मूल्य देख रहे हैं, ilocपूर्णांक पंक्ति आधारित अनुक्रमण है, ixएक सामान्य तरीका है जो पहले लेबल आधारित करता है, यदि वह विफल हो जाता है तो यह पूर्णांक आधारित पर गिरता है। atपदावनत किया जाता है और यह सलाह दी जाती है कि अब आप इसका उपयोग न करें। दूसरी बात पर विचार करें कि आप क्या करने की कोशिश कर रहे हैं क्योंकि इनमें से कुछ तरीके स्लाइसिंग और कॉलम असाइनमेंट की अनुमति देते हैं, ईमानदार होने के लिए डॉक्स बहुत स्पष्ट हैं: pandas.pydata.org/pandas-docs/stable/indexing.html

— EdChum

@EdChum - आप क्या कहते हैं कि atपदावनत किया जाता है? मैं में नहीं देखते हैं पर (या प.जा. ) डॉक्स।

— रस

यह एक त्रुटि है कि इसे पदावनत नहीं किया गया है, मुझे लगता है कि इसे पदावनत करने की कुछ बात हुई थी लेकिन यह विचार छोड़ दिया गया क्योंकि मुझे लगता है कि यह तेज़ है

— EdChum

और यहाँ loc, के बीच विस्तार से स्पष्टीकरण : stackoverflow.com/questions/31593201/…ixiloc

— एलेक्स रिले

Answer 1

loc: केवल इंडेक्स
iloc पर काम करें : पोजीशन
ix पर काम करें : आप डेटाफ्रेम से डेटा प्राप्त कर सकते हैं, इसके बिना इंडेक्स में
मौजूद नहीं है: स्केलर मान प्राप्त करें। यह एक बहुत तेज़ नियंत्रण रेखा है
: स्केलर मान प्राप्त करें। यह बहुत तेज इलोक है

http://pyciencia.blogspot.com/2015/05/obtener-y-filtrar-datos-de-un-dataframe.html

नोट: जैसा कि pandas 0.20.0, .ixअनुक्रमणिका अधिक सख्त और अनुक्रमणिका के पक्ष में पदावनत है ।.iloc.loc

Comments

तो atऔर iatका बहुत तेजी से संस्करण हैं locऔर ilocहै, तो क्यों उपयोग locऔर ilocसब पर?

— रे

atऔर iatएक, एक अदिश, यह है कि, dataframe में एक भी तत्व का उपयोग करने के लिए होती है, जबकि locऔर ilocसंभावित vectorized कार्रवाई करने, एक ही समय में पहुँच कई तत्वों को बयान कर रहे हैं।

— nasasas

@nasasas - अगर मैं दस्तावेज़ को सही पढ़ता हूँ .at केवल सूचकांक द्वारा पहुँच सकता है जबकि .loc कॉलम नाम से भी पहुँच सकता है। क्या तेज का उपयोग करने का एक तरीका है। लेकिन एक इंडेक्स के बजाय कॉलम नाम का उपयोग करें? जैसे x = df.loc [df.Id == source_Id, 'someValue']। मान [0] के साथ x = df.at [df.Id == source_Id, 'someValue']। .At के साथ संस्करण फेंकता "ValueError: एक पूर्णांक सूचकांक के आधार पर अनुक्रमण पर केवल indexers पूर्णांक हो सकता है"

— वेगा

Answer 2

pandas 0.20जो दिया गया है, उसके लिए अद्यतन किया ixगया है। यह न केवल उपयोग करने के तरीके को प्रदर्शित करता है loc,iloc , at, iat, set_value, लेकिन पूरा करने के लिए कैसे, मिश्रित स्थितीय / लेबल आधारित अनुक्रमण।

---

loc- लेबल आधारित
आपको इंडेक्सर्स के रूप में 1-डी सरणियों को पारित करने की अनुमति देता है। एरर्स इंडेक्स या कॉलम के स्लाइस (सबसेट) हो सकते हैं, या वे बूलियन एरे हो सकते हैं जो इंडेक्स या कॉलम की लंबाई के बराबर होते हैं।

विशेष नोट: जब एक स्केलर इंडेक्सर पास हो जाता है, तो locएक नया इंडेक्स या कॉलम मान दे सकता है जो पहले मौजूद नहीं था।

# label based, but we can use position values
# to get the labels from the index object
df.loc[df.index[2], 'ColName'] = 3

---

df.loc[df.index[1:3], 'ColName'] = 3

---

iloc- स्थिति के आधार पर
इसी तरह के पदों को locछोड़कर सूचकांक सूचकांक के समान । हालाँकि, आप नए कॉलम या सूचकांक निर्दिष्ट नहीं कर सकते ।

# position based, but we can get the position
# from the columns object via the `get_loc` method
df.iloc[2, df.columns.get_loc('ColName')] = 3

---

df.iloc[2, 4] = 3

---

df.iloc[:3, 2:4] = 3

---

at- लेबल आधारित
वर्क्स locस्केलर इंडेक्सर्स के लिए बहुत समान है । सरणी अनुक्रमणिका पर कार्य नहीं कर सकता । कर सकते हैं! नए सूचकांक और कॉलम असाइन करें।

इससे अधिक फायदाloc यह है कि यह तेज है।
नुकसान यह है कि आप इंडेक्सर्स के लिए सरणियों का उपयोग नहीं कर सकते हैं।

# label based, but we can use position values
# to get the labels from the index object
df.at[df.index[2], 'ColName'] = 3

---

df.at['C', 'ColName'] = 3

---

iat- स्थिति के आधार पर
इसी तरह काम करता हैiloc । एरे इंडेक्सर्स में काम नहीं कर सकता । नही सकता! नए सूचकांक और कॉलम असाइन करें।

इससे अधिक फायदाiloc यह है कि यह तेज है।
नुकसान यह है कि आप इंडेक्सर्स के लिए सरणियों का उपयोग नहीं कर सकते हैं।

# position based, but we can get the position
# from the columns object via the `get_loc` method
IBM.iat[2, IBM.columns.get_loc('PNL')] = 3

---

set_value- लेबल आधारित
वर्क्स बहुत समान हैloc स्केलर इंडेक्सर्स के लिए । सरणी अनुक्रमणिका पर कार्य नहीं कर सकता । कर सकते हैं! नए सूचकांक और कॉलम असाइन करें

सुपर फास्ट का लाभ उठाएं, क्योंकि बहुत कम ओवरहेड है!
नुकसान बहुत कम ओवरहेड है क्योंकि pandasसुरक्षा जांच का एक गुच्छा नहीं है। अपने जोखिम पार इस्तेमाल करें । इसके अलावा, यह सार्वजनिक उपयोग के लिए अभिप्रेत नहीं है।

# label based, but we can use position values
# to get the labels from the index object
df.set_value(df.index[2], 'ColName', 3)

---

set_valueसाथtakable=True - स्थिति आधारित
काम करता है इसी तरह करने के लिएiloc। एरे इंडेक्सर्स में काम नहीं कर सकता । नही सकता! नए सूचकांक और कॉलम असाइन करें।

सुपर फास्ट का लाभ उठाएं, क्योंकि बहुत कम ओवरहेड है!
नुकसान बहुत कम ओवरहेड है क्योंकि pandasसुरक्षा जांच का एक गुच्छा नहीं है। अपने जोखिम पर उपयोग करें । इसके अलावा, यह सार्वजनिक उपयोग के लिए अभिप्रेत नहीं है।

# position based, but we can get the position
# from the columns object via the `get_loc` method
df.set_value(2, df.columns.get_loc('ColName'), 3, takable=True)

Comments

तो, क्या स्थिति द्वारा कई कॉलम पढ़ने / सेट करने का एक सरल तरीका है? इसके अलावा, कहते हैं, मैं प्रत्येक कॉलम को नए कॉलम में जोड़ना चाहता था, क्या यह आसानी से हो गया है?

— शब्दों का

@ पासवर्ड डेटा के अंत में नए कॉलम को जोड़ने के लिए आसान ईश तरीके हैं। या शुरुआत भी। यदि पद शामिल हैं तो नहीं, कोई आसान तरीका नहीं है।

— पाईसर्कटेड

यह जवाब बस मुझे क्या चाहिए था! पांड निश्चित रूप से शक्तिशाली हैं, लेकिन यह सब कुछ समझने और एक साथ टुकड़े करने के लिए बेहद जटिल बनाने की कीमत पर आता है।

— slhck

ध्यान दें कि set_valueके पक्ष में पदावनत किया गया है .atऔर .iatके बाद से संस्करण 0.21

— nedned

Answer 3

दो प्राथमिक तरीके हैं जो पांडा डेटाफ़्रेम से चयन करते हैं।

• लेबल द्वारा
• इंटेगर लोकेशन द्वारा

दस्तावेज़ पूर्णांक स्थान का संदर्भ देने के लिए शब्द की स्थिति का उपयोग करता है । मुझे यह शब्दावली पसंद नहीं है क्योंकि मुझे लगता है कि यह भ्रामक है। पूर्णांक स्थान अधिक वर्णनात्मक है और वास्तव में यही है। यहाँ मुख्य शब्द INTEGER है - पूर्णांक स्थान का चयन करते समय आपको पूर्णांक का उपयोग करना चाहिए।.iloc

सारांश दिखाने से पहले हम सभी यह सुनिश्चित कर लें कि ...

.ix अनिच्छुक और अस्पष्ट है और इसका उपयोग कभी नहीं किया जाना चाहिए

पांडा के लिए तीन प्राथमिक सूचकांक हैं । हमारे पास स्वयं अनुक्रमणिका (कोष्ठक []) है .loc, और .iloc। आइए उनका सारांश प्रस्तुत करते हैं:

• []- मुख्य रूप से कॉलम के सबसेट का चयन करता है, लेकिन साथ ही पंक्तियों का चयन कर सकता है। एक साथ पंक्तियों और स्तंभों का चयन नहीं कर सकते।
• .loc - केवल लेबल द्वारा पंक्तियों और स्तंभों के सबसेट का चयन करता है
• .iloc - केवल पूर्णांक स्थान द्वारा पंक्तियों और स्तंभों के सबसेट का चयन करता है

मैं लगभग कभी भी उपयोग नहीं करता हूं .atया .iatजैसा कि वे कोई अतिरिक्त कार्यक्षमता नहीं जोड़ते हैं और बस एक छोटे से प्रदर्शन में वृद्धि होती है। जब तक आपके पास बहुत संवेदनशील एप्लिकेशन नहीं होगा, मैं उनके उपयोग को हतोत्साहित करूंगा। बावजूद, हमारे पास उनका सारांश है:

• .at केवल लेबल द्वारा DataFrame में एकल स्केलर मान का चयन करता है
• .iat केवल पूर्णांक स्थान द्वारा DataFrame में एकल स्केलर मान का चयन करता है

लेबल और पूर्णांक स्थान के चयन के अलावा , बूलियन चयन को बूलियन इंडेक्सिंग के रूप में भी जाना जाता है।

---

उदाहरण समझा .loc, .iloc, बूलियन चयन और .atऔर .iatनीचे दिखाए गए हैं

हम पहले .locऔर के बीच के अंतरों पर ध्यान केंद्रित करेंगे .iloc। इससे पहले कि हम मतभेदों के बारे में बात करें, यह समझना महत्वपूर्ण है कि DataFrames में ऐसे लेबल हैं जो प्रत्येक स्तंभ और प्रत्येक पंक्ति को पहचानने में मदद करते हैं। आइए एक नजर डालते हैं सैंपल डाटाफ्रेम पर:

df = pd.DataFrame({'age':[30, 2, 12, 4, 32, 33, 69],
                   'color':['blue', 'green', 'red', 'white', 'gray', 'black', 'red'],
                   'food':['Steak', 'Lamb', 'Mango', 'Apple', 'Cheese', 'Melon', 'Beans'],
                   'height':[165, 70, 120, 80, 180, 172, 150],
                   'score':[4.6, 8.3, 9.0, 3.3, 1.8, 9.5, 2.2],
                   'state':['NY', 'TX', 'FL', 'AL', 'AK', 'TX', 'TX']
                   },
                  index=['Jane', 'Nick', 'Aaron', 'Penelope', 'Dean', 'Christina', 'Cornelia'])

बोल्ड के सभी शब्द लेबल हैं। लेबल, age, color, food, height, scoreऔर stateके लिए उपयोग किया जाता है कॉलम । अन्य लेबल, Jane, Nick, Aaron, Penelope, Dean, Christina, Corneliaपंक्तियों के लिए लेबल के रूप में उपयोग किया जाता है। सामूहिक रूप से, इन पंक्ति लेबल को सूचकांक के रूप में जाना जाता है ।

---

एक DataFrame में विशेष पंक्तियों का चयन करने के लिए प्राथमिक तरीके के साथ कर रहे हैं .locऔर .ilocindexers। इनमें से प्रत्येक अनुक्रमणिका का उपयोग एक साथ स्तंभों का चयन करने के लिए भी किया जा सकता है लेकिन अभी के लिए पंक्तियों पर ध्यान केंद्रित करना अधिक आसान है। साथ ही, प्रत्येक अनुक्रमणिका ब्रैकेट के एक सेट का उपयोग करती है जो उनके चयन करने के लिए तुरंत उनके नाम का अनुसरण करते हैं।

.loc केवल लेबल द्वारा डेटा का चयन करता है

हम पहले बात करेंगे .loc इंडेक्सर के जो केवल इंडेक्स या कॉलम लेबल द्वारा डेटा का चयन करता है। हमारे नमूने DataFrame में, हमने इंडेक्स के मूल्यों के रूप में सार्थक नाम प्रदान किए हैं। कई DataFrames का कोई सार्थक नाम नहीं होगा और इसके बजाय, केवल 0 से n-1 तक पूर्णांकों के लिए डिफ़ॉल्ट होगा, जहां n, DataFrame की लंबाई (पंक्तियों की संख्या) है।

कर रहे हैं कई अलग अलग आदानों के लिए आप उपयोग कर सकते हैं .locतीन उनमें से बाहर हैं

• एक स्ट्रिंग
• तार की एक सूची
• स्टार्टिंग और स्टॉप वैल्यू के रूप में स्ट्रिंग्स का उपयोग करके स्लाइस नोटेशन

एक पंक्ति के साथ एक पंक्ति का चयन करना। एक स्ट्रिंग के साथ

डेटा की एक एकल पंक्ति का चयन करने के लिए, अनुक्रमणिका लेबल को कोष्ठक के अंदर रखें .loc।

df.loc['Penelope']

यह एक श्रृंखला के रूप में डेटा की पंक्ति देता है

age           4
color     white
food      Apple
height       80
score       3.3
state        AL
Name: Penelope, dtype: object

तार की सूची के साथ .loc के साथ कई पंक्तियों का चयन करना

df.loc[['Cornelia', 'Jane', 'Dean']]

यह सूची में निर्दिष्ट क्रम में पंक्तियों के साथ एक DataFrame लौटाता है:

स्लाइस अंकन के साथ .loc के साथ कई पंक्तियों का चयन करना

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

df.loc['Aaron':'Dean']

कॉम्प्लेक्स स्लाइस को उसी तरह से लिया जा सकता है जैसे पायथन सूची में।

.iloc केवल पूर्णांक स्थान द्वारा डेटा का चयन करता है

चलो अब बारी है .iloc। DataFrame में डेटा की हर पंक्ति और कॉलम में एक पूर्णांक स्थान होता है जो इसे परिभाषित करता है। यह उस लेबल के अतिरिक्त है जो नेत्रहीन रूप से आउटपुट में प्रदर्शित होता है। पूर्णांक स्थान केवल 0 पर शीर्ष / बाईं ओर से पंक्तियों / स्तंभों की संख्या है।

कर रहे हैं कई अलग अलग आदानों के लिए आप उपयोग कर सकते हैं .ilocतीन उनमें से बाहर हैं

• पूर्णांक
• पूर्णांकों की एक सूची
• प्रारंभ और रोक मूल्यों के रूप में पूर्णांकों का उपयोग करके स्लाइस अंकन

एक पूर्णांक के साथ .iloc के साथ एकल पंक्ति का चयन करना

df.iloc[4]

यह 5 वीं पंक्ति (पूर्णांक स्थान 4) को एक श्रृंखला के रूप में लौटाता है

age           32
color       gray
food      Cheese
height       180
score        1.8
state         AK
Name: Dean, dtype: object

पूर्णांक की सूची के साथ .iloc के साथ कई पंक्तियों का चयन करना

df.iloc[[2, -2]]

यह तीसरी और दूसरी से अंतिम पंक्तियों का डेटाफ़्रेम लौटाता है:

कई पंक्तियों का चयन करें। टुकड़ा संकेतन के साथ .ococ

df.iloc[:5:3]

---

.Loc और .iloc के साथ पंक्तियों और स्तंभों का एक साथ चयन

दोनों की एक उत्कृष्ट क्षमता .loc/.ilocदोनों पंक्तियों और स्तंभों को एक साथ चुनने की उनकी क्षमता है। उपरोक्त उदाहरणों में, प्रत्येक चयन से सभी कॉलम वापस कर दिए गए थे। हम उसी प्रकार के इनपुट के साथ कॉलम चुन सकते हैं जैसे हम पंक्तियों के लिए करते हैं। हमें केवल पंक्ति और स्तंभ चयन को अल्पविराम से अलग करने की आवश्यकता है ।

उदाहरण के लिए, हम पंक्तियों की ऊँचाई, स्कोर और राज्य के साथ जेन और डीन का चयन कर सकते हैं:

df.loc[['Jane', 'Dean'], 'height':]

यह पंक्तियों के लिए लेबल की एक सूची का उपयोग करता है और कॉलम के लिए टुकड़ा संकेतन करता है

हम .ilocकेवल पूर्णांक का उपयोग करके स्वाभाविक रूप से समान संचालन कर सकते हैं।

df.iloc[[1,4], 2]
Nick      Lamb
Dean    Cheese
Name: food, dtype: object

---

लेबल और पूर्णांक स्थान के साथ एक साथ चयन

.ixलेबल और पूर्णांक स्थान के साथ एक साथ चयन करने के लिए उपयोग किया गया था जो कि उपयोगी था लेकिन कई बार भ्रमित और अस्पष्ट था और शुक्र है कि इसे हटा दिया गया है। इस घटना में कि आपको लेबल और पूर्णांक स्थानों के मिश्रण के साथ चयन करने की आवश्यकता है, आपको अपने चयन लेबल या पूर्णांक दोनों स्थान बनाने होंगे।

उदाहरण के लिए, यदि हम पंक्तियों का चयन करना चाहते हैं Nickऔर Corneliaकॉलम 2 और 4 के साथ, हम .locपूर्णांकों को निम्नलिखित के साथ लेबल में परिवर्तित करके उपयोग कर सकते हैं :

col_names = df.columns[[2, 4]]
df.loc[['Nick', 'Cornelia'], col_names] 

या वैकल्पिक रूप से, इंडेक्स लेबल्स को get_locइंडेक्स विधि के साथ पूर्णांक में परिवर्तित करें ।

labels = ['Nick', 'Cornelia']
index_ints = [df.index.get_loc(label) for label in labels]
df.iloc[index_ints, [2, 4]]

बूलियन चयन

.Loc अनुक्रमणिका बूलियन चयन भी कर सकती है। उदाहरण के लिए, यदि हम उन सभी पंक्तियों को खोजने में रुचि रखते हैं, जहां उम्र 30 वर्ष से अधिक है foodऔर scoreहम केवल निम्नलिखित कॉलम और कॉलमों को वापस कर सकते हैं:

df.loc[df['age'] > 30, ['food', 'score']] 

आप इसे दोहरा सकते हैं, .ilocलेकिन आप इसे बूलियन श्रृंखला नहीं दे सकते। आपको बूलियन सीरीज़ को इस तरह एक शानदार सरणी में बदलना होगा:

df.iloc[(df['age'] > 30).values, [2, 4]] 

---

सभी पंक्तियों का चयन

.loc/.ilocकेवल कॉलम चयन के लिए उपयोग करना संभव है । आप इस तरह एक कोलन का उपयोग करके सभी पंक्तियों का चयन कर सकते हैं:

df.loc[:, 'color':'score':2]

---

इंडेक्सिंग ऑपरेटर, []स्लाइस पंक्तियों और स्तंभों का चयन कर सकता है, लेकिन एक साथ नहीं।

ज्यादातर लोग डेटाफ्रैम इंडेक्सिंग ऑपरेटर के प्राथमिक उद्देश्य से परिचित हैं, जो कॉलम का चयन करना है। एक स्ट्रिंग श्रृंखला के रूप में एक एकल कॉलम का चयन करता है और स्ट्रिंग्स की एक सूची एक DataFrame के रूप में कई कॉलम का चयन करती है।

df['food']

Jane          Steak
Nick           Lamb
Aaron         Mango
Penelope      Apple
Dean         Cheese
Christina     Melon
Cornelia      Beans
Name: food, dtype: object

एक सूची का उपयोग कई कॉलम का चयन करता है

df[['food', 'score']]

लोग किस चीज से कम परिचित हैं, वह यह है कि, जब स्लाइस नोटेशन का उपयोग किया जाता है, तो चयन पंक्ति लेबल या पूर्णांक स्थान द्वारा होता है। यह बहुत भ्रामक है और ऐसा कुछ है जिसका मैं लगभग कभी उपयोग नहीं करता लेकिन यह काम करता है।

df['Penelope':'Christina'] # slice rows by label

df[2:6:2] # slice rows by integer location

.loc/.ilocपंक्तियों के चयन के लिए खोजकर्ता को अत्यधिक पसंद किया जाता है। अनुक्रमणिका ऑपरेटर अकेले पंक्तियों और स्तंभों का एक साथ चयन करने में असमर्थ है।

df[3:5, 'color']
TypeError: unhashable type: 'slice'

---

द्वारा चयन .atऔर.iat

के साथ चयन .atलगभग समान है, .locलेकिन यह आपके डेटाफ़्रेम में केवल एक 'सेल' का चयन करता है। हम आमतौर पर इस सेल को स्केलर मान के रूप में संदर्भित करते हैं। उपयोग करने के लिए .at, इसे एक पंक्ति और स्तंभ लेबल दोनों को एक अल्पविराम द्वारा अलग कर दें।

df.at['Christina', 'color']
'black'

के साथ चयन .iatलगभग समान है, .ilocलेकिन यह केवल एकल स्केलर मान का चयन करता है। आपको इसे पंक्ति और स्तंभ दोनों स्थानों के लिए पूर्णांक देना होगा

df.iat[2, 5]
'FL'

Answer 4

df = pd.DataFrame({'A':['a', 'b', 'c'], 'B':[54, 67, 89]}, index=[100, 200, 300])

df

                        A   B
                100     a   54
                200     b   67
                300     c   89
In [19]:    
df.loc[100]

Out[19]:
A     a
B    54
Name: 100, dtype: object

In [20]:    
df.iloc[0]

Out[20]:
A     a
B    54
Name: 100, dtype: object

In [24]:    
df2 = df.set_index([df.index,'A'])
df2

Out[24]:
        B
    A   
100 a   54
200 b   67
300 c   89

In [25]:    
df2.ix[100, 'a']

Out[25]:    
B    54
Name: (100, a), dtype: int64

Answer 5

आइए इस छोटे df से शुरू करें:

import pandas as pd
import time as tm
import numpy as np
n=10
a=np.arange(0,n**2)
df=pd.DataFrame(a.reshape(n,n))

हम ऐसा करेंगे

df
Out[25]: 
        0   1   2   3   4   5   6   7   8   9
    0   0   1   2   3   4   5   6   7   8   9
    1  10  11  12  13  14  15  16  17  18  19
    2  20  21  22  23  24  25  26  27  28  29
    3  30  31  32  33  34  35  36  37  38  39
    4  40  41  42  43  44  45  46  47  48  49
    5  50  51  52  53  54  55  56  57  58  59
    6  60  61  62  63  64  65  66  67  68  69
    7  70  71  72  73  74  75  76  77  78  79
    8  80  81  82  83  84  85  86  87  88  89
    9  90  91  92  93  94  95  96  97  98  99

इसके साथ हमारे पास:

df.iloc[3,3]
Out[33]: 33

df.iat[3,3]
Out[34]: 33

df.iloc[:3,:3]
Out[35]: 
    0   1   2   3
0   0   1   2   3
1  10  11  12  13
2  20  21  22  23
3  30  31  32  33



df.iat[:3,:3]
Traceback (most recent call last):
   ... omissis ...
ValueError: At based indexing on an integer index can only have integer indexers

इस प्रकार हम थियोसिस का उपयोग नहीं कर सकते हैं। जहाँ हमें केवल .iloc का उपयोग करना चाहिए।

लेकिन चलो दोनों को एक बड़े df से चयन करने की कोशिश करते हैं और चलो गति की जांच करते हैं ...

# -*- coding: utf-8 -*-
"""
Created on Wed Feb  7 09:58:39 2018

@author: Fabio Pomi
"""

import pandas as pd
import time as tm
import numpy as np
n=1000
a=np.arange(0,n**2)
df=pd.DataFrame(a.reshape(n,n))
t1=tm.time()
for j in df.index:
    for i in df.columns:
        a=df.iloc[j,i]
t2=tm.time()
for j in df.index:
    for i in df.columns:
        a=df.iat[j,i]
t3=tm.time()
loc=t2-t1
at=t3-t2
prc = loc/at *100
print('\nloc:%f at:%f prc:%f' %(loc,at,prc))

loc:10.485600 at:7.395423 prc:141.784987

तो .loc के साथ हम सबसेट और .at को केवल एक स्केलर के साथ प्रबंधित कर सकते हैं, लेकिन .loc की तुलना में तेज है

:-)