जवाबों:
some_list[-1] सबसे छोटा और सबसे पाइथोनिक है।
वास्तव में, आप इस सिंटैक्स के साथ बहुत कुछ कर सकते हैं। some_list[-n]वाक्य रचना वें करने वाली अंतिम तत्व हो जाता है। तो some_list[-1]अंतिम तत्व प्राप्त करता है, some_list[-2]दूसरे से अंतिम तक जाता है, आदि, नीचे सभी तरह से some_list[-len(some_list)], जो आपको पहला तत्व देता है।
आप इस तरह से सूची तत्व भी सेट कर सकते हैं। उदाहरण के लिए:
>>> some_list = [1, 2, 3]
>>> some_list[-1] = 5 # Set the last element
>>> some_list[-2] = 3 # Set the second to last element
>>> some_list
[1, 3, 5]ध्यान दें कि IndexErrorयदि कोई अपेक्षित आइटम मौजूद नहीं है, तो इंडेक्स द्वारा एक सूची आइटम प्राप्त करना । इसका मतलब है कि खाली होने पर some_list[-1]कोई अपवाद नहीं उठाया जाएगा some_list, क्योंकि खाली सूची में अंतिम तत्व नहीं हो सकता है।
यदि आपकी str()या list()वस्तुएं समाप्त हो सकती हैं, तो खाली होना चाहिए: astr = ''या alist = []फिर, आप वस्तु "साम्य" के alist[-1:]बजाय उपयोग करना चाह सकते हैं alist[-1]।
इसका महत्व यह है:
alist = []
alist[-1] # will generate an IndexError exception whereas
alist[-1:] # will return an empty list
astr = ''
astr[-1] # will generate an IndexError exception whereas
astr[-1:] # will return an empty strजहाँ यह भेद किया जा रहा है कि खाली सूची ऑब्जेक्ट या खाली str ऑब्जेक्ट को वापस करना अधिक "अंतिम तत्व" है-फिर एक अपवाद वस्तु।
if len(my_vector) == 0 or my_vector[-1] != update_valएक व्यावहारिक पैटर्न है। लेकिन यह निश्चित रूप से एक वैश्विक समाधान नहीं है - यह एक वाक्यविन्यास रूप होना अच्छा होगा जहां कोई भी परिणाम नहीं था
xs[-1] if xs else None
आप भी कर सकते हैं:
alist.pop()यह इस बात पर निर्भर करता है कि आप अपनी सूची के साथ क्या करना चाहते हैं क्योंकि pop()विधि अंतिम तत्व को हटा देगी।
अजगर में अंतिम तत्व प्रदर्शित करने का सबसे सरल तरीका है
>>> list[-1:] # returns indexed value
[3]
>>> list[-1] # returns value
3इस तरह के लक्ष्य को प्राप्त करने के लिए कई अन्य तरीके हैं लेकिन ये उपयोग करने के लिए कम और मीठे हैं।
list[-1]करेगा जबकि त्रुटि होगी।
a[-1:][0] सब पर ? वह a[-1]वैसे भी प्रदान करता है। कृपया स्पष्टीकरण दें?
पायथन में, आपको किसी सूची का अंतिम तत्व कैसे मिलता है?
केवल अंतिम तत्व प्राप्त करने के लिए,
-1सबस्क्रिप्ट नोटेशन पास करें:
>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'सूचकांक और स्लाइस नकारात्मक पूर्णांक को तर्क के रूप में ले सकते हैं।
मैंने दस्तावेज़ीकरण से एक उदाहरण को संशोधित करने के लिए संकेत दिया है कि प्रत्येक अनुक्रम में कौन सा आइटम है, इस मामले में, स्ट्रिंग में "Python", -1अंतिम तत्व, चरित्र को संदर्भित करता है 'n':
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
>>> p = 'Python'
>>> p[-1]
'n'यह विधि अनावश्यक रूप से सिर्फ अंतिम तत्व प्राप्त करने के उद्देश्य से दूसरी सूची तैयार कर सकती है, लेकिन पूर्णता के लिए (और क्योंकि यह किसी भी चलने योग्य का समर्थन करता है - न केवल सूचियों के लिए)
>>> *head, last = a_list
>>> last
'three'चर नाम, सिर अनावश्यक नव निर्मित सूची के लिए बाध्य है:
>>> head
['zero', 'one', 'two']यदि आप उस सूची के साथ कुछ भी नहीं करने का इरादा रखते हैं, तो यह अधिक एप्रोपोस होगा:
*_, last = a_listया, वास्तव में, यदि आप जानते हैं कि यह एक सूची है (या कम से कम सबस्क्रिप्ट नोटेशन स्वीकार करता है):
last = a_list[-1]एक टिप्पणीकार ने कहा:
काश पायथन के पास पहले () और आखिरी () के लिए एक फ़ंक्शन होता, जैसे लिस्प करता है ... यह बहुत सारे अनावश्यक लंबोदर कार्यों से छुटकारा दिलाता है।
ये परिभाषित करने के लिए काफी सरल होगा:
def last(a_list):
return a_list[-1]
def first(a_list):
return a_list[0]या उपयोग करें operator.itemgetter:
>>> import operator
>>> last = operator.itemgetter(-1)
>>> first = operator.itemgetter(0)किसी भी स्थिति में:
>>> last(a_list)
'three'
>>> first(a_list)
'zero'यदि आप कुछ अधिक जटिल कर रहे हैं, तो आपको अंतिम तत्व को थोड़े अलग तरीकों से प्राप्त करने के लिए अधिक प्रदर्शनकारी लग सकता है।
यदि आप प्रोग्रामिंग में नए हैं, तो आपको इस अनुभाग से बचना चाहिए, क्योंकि यह जोड़े अन्यथा शब्दार्थ के अलग-अलग हिस्सों को एक साथ जोड़ते हैं। यदि आप अपने एल्गोरिथ्म को एक स्थान पर बदलते हैं, तो कोड की एक अन्य पंक्ति पर इसका अनपेक्षित प्रभाव पड़ सकता है।
मैं पूरी तरह से मैं कर सकता हूँ के रूप में caveats और शर्तों को प्रदान करने की कोशिश, लेकिन मैं कुछ याद किया हो सकता है। कृपया टिप्पणी करें यदि आपको लगता है कि मैं एक चेतावनी छोड़ रहा हूं।
सूची का एक टुकड़ा एक नई सूची देता है - इसलिए हम -1 से अंत तक टुकड़ा कर सकते हैं यदि हम एक नई सूची में तत्व चाहते हैं:
>>> a_slice = a_list[-1:]
>>> a_slice
['three']यदि सूची खाली है तो यह विफल होने का उल्टा है:
>>> empty_list = []
>>> tail = empty_list[-1:]
>>> if tail:
... do_something(tail)जबकि अनुक्रमणिका द्वारा उपयोग करने का प्रयास उठता है IndexErrorजिसे संभालने की आवश्यकता होगी:
>>> empty_list[-1]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of rangeलेकिन फिर, इस उद्देश्य के लिए स्लाइसिंग केवल तभी की जानी चाहिए जब आपको आवश्यकता हो:
for छोरोंपायथन की एक विशेषता के रूप में, forलूप में कोई आंतरिक स्कूपिंग नहीं है ।
यदि आप पहले से ही सूची पर पूर्ण पुनरावृत्ति कर रहे हैं, तो अंतिम तत्व को अभी भी लूप में निर्दिष्ट चर नाम से संदर्भित किया जाएगा:
>>> def do_something(arg): pass
>>> for item in a_list:
... do_something(item)
...
>>> item
'three'यह सूची में अंतिम रूप से शब्द नहीं है। यह शब्दार्थ है कि आखिरी चीज, जिसका नाम itemथा, के लिए बाध्य था।
>>> def do_something(arg): raise Exception
>>> for item in a_list:
... do_something(item)
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
File "<stdin>", line 1, in do_something
Exception
>>> item
'zero'इस प्रकार इसका उपयोग केवल अंतिम तत्व प्राप्त करने के लिए किया जाना चाहिए
हम अंतिम तत्व को हटाकर और वापस करके हमारी मूल सूची को भी बदल सकते हैं:
>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']लेकिन अब मूल सूची को संशोधित किया गया है।
( -1वास्तव में डिफ़ॉल्ट तर्क है, इसलिए list.popइसका उपयोग सूचकांक तर्क के बिना किया जा सकता है):
>>> a_list.pop()
'two'केवल अगर यह
ये मान्य उपयोग के मामले हैं, लेकिन बहुत आम नहीं हैं।
मुझे नहीं पता कि आप ऐसा क्यों करेंगे, लेकिन पूर्णता के लिए, चूंकि reversedएक पुनरावृत्तिकर्ता (जो पुनरावृत्त प्रोटोकॉल का समर्थन करता है) आप इसके परिणाम को पास कर सकते हैं next:
>>> next(reversed([1,2,3]))
3तो यह इसके विपरीत करने जैसा है:
>>> next(iter([1,2,3]))
1लेकिन मैं ऐसा करने के लिए एक अच्छे कारण के बारे में नहीं सोच सकता, जब तक कि आपको बाद में रिवर्स इटरेटर के बाकी हिस्सों की आवश्यकता नहीं होगी, जो संभवतः इस तरह दिखाई देगा:
reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)
use_later = list(reverse_iterator)और अब:
>>> use_later
[2, 1]
>>> last_element
3इसे रोकने के लिए IndexError: list index out of range, इस सिंटैक्स का उपयोग करें:
mylist = [1, 2, 3, 4]
# With None as default value:
value = mylist and mylist[-1]
# With specified default value (option 1):
value = mylist and mylist[-1] or 'default'
# With specified default value (option 2):
value = mylist[-1] if mylist else 'default'एक अन्य विधि:
some_list.reverse()
some_list[0]lst[-1]सबसे अच्छा तरीका है, लेकिन सामान्य पुनरावृत्तियों के साथ, विचार करें more_itertools.last:
कोड
import more_itertools as mit
mit.last([0, 1, 2, 3])
# 3
mit.last(iter([1, 2, 3]))
# 3
mit.last([], "some default")
# 'some default'list[-1]सूची को बदले बिना सूची के अंतिम तत्व को पुनः प्राप्त करेगा।
list.pop()सूची के अंतिम तत्व को पुनः प्राप्त करेगा, लेकिन यह मूल सूची को बदल / बदल देगा। आमतौर पर, मूल सूची को बदलने की अनुशंसा नहीं की जाती है।
वैकल्पिक रूप से, यदि, किसी कारण से, आप कुछ कम पायथोनिक की तलाश कर रहे हैं, तो आप उपयोग कर सकते हैं list[len(list)-1], यह मानते हुए कि सूची खाली नहीं है।
सूची खाली होने पर आप IndexError प्राप्त नहीं करना चाहते हैं, तो आप नीचे दिए गए कोड का भी उपयोग कर सकते हैं।
next(reversed(some_list), None)ठीक है, लेकिन लगभग हर भाषा में क्या आम है items[len(items) - 1]? यह IMO अंतिम तत्व प्राप्त करने का सबसे आसान तरीका है, क्योंकि इसमें किसी भी तरह के पाइथोनिक ज्ञान की आवश्यकता नहीं होती है ।
some_list[-1]दृष्टिकोण से बेहतर है क्योंकि यह अधिक तार्किक है, और दिखाता है कि यह वास्तव some_list[-1]में मेरे विचार से बेहतर क्या है ।
some_list.last- यह कोड की खूबसूरत लाइन होगी