python पायथन में एक सूची का अंतिम तत्व प्राप्त करना




list indexing (11)

पायथन में, आप सूची का अंतिम तत्व कैसे प्राप्त करते हैं?


पायथन में, आप सूची का अंतिम तत्व कैसे प्राप्त करते हैं?

अंतिम तत्व प्राप्त करने के लिए,

  • सूची को संशोधित किए बिना, और
  • आपको लगता है कि सूची में एक अंतिम तत्व है (यानी यह अपर्याप्त है)

सबस्क्रिप्ट नोटेशन के लिए पास -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']

यदि आप उस सूची के साथ कुछ भी नहीं करना चाहते हैं, तो यह अधिक apropos होगा:

*_, last = a_list

या, वास्तव में, यदि आप जानते हैं कि यह एक सूची है (या कम से कम सबस्क्रिप्ट नोटेशन स्वीकार करता है):

last = a_list[-1]

एक समारोह में

एक टिप्पणीकार ने कहा:

मेरी इच्छा है कि पाइथन के पास पहले () और आखिरी () जैसे Lisp करता है ... यह बहुत अनावश्यक लैम्ब्डा कार्यों से छुटकारा पाता है।

यह परिभाषित करने के लिए काफी आसान होगा:

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'

विशेष स्थितियां

यदि आप कुछ और जटिल कर रहे हैं, तो आप अंतिम तत्व को थोड़ा अलग तरीके से प्राप्त करने के लिए इसे अधिक निष्पादित कर सकते हैं।

यदि आप प्रोग्रामिंग के लिए नए हैं, तो आपको इस सेक्शन से बचना चाहिए, क्योंकि यह अन्यथा एल्गोरिदम के अलग-अलग हिस्सों को जोड़ता है। यदि आप एक ही स्थान पर अपना एल्गोरिदम बदलते हैं, तो यह कोड की दूसरी पंक्ति पर एक अनपेक्षित प्रभाव हो सकता है।

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

टुकड़ा करने की क्रिया

एक सूची का एक टुकड़ा एक नई सूची देता है - इसलिए यदि हम एक नई सूची में तत्व चाहते हैं तो हम -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

लेकिन फिर, इस उद्देश्य के लिए टुकड़ा करना केवल तभी किया जाना चाहिए यदि आपको आवश्यकता हो:

  • एक नई सूची बनाई गई
  • और यदि पूर्व सूची खाली थी तो नई सूची खाली हो जाएगी।

loops के लिए

पायथन की एक विशेषता के रूप में 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

यदि आप केवल सूची का अंतिम मूल्य प्राप्त करना चाहते हैं, तो आपको इसका उपयोग करना चाहिए:

your_list[-1]

लेकिन अगर आप मूल्य प्राप्त करना चाहते हैं और इसे सूची से भी हटा देना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

your_list.pop()

या: आप इंडेक्स के साथ भी पॉप कर सकते हैं ...

your_list.pop(-1)

यदि आपकी str () या list () ऑब्जेक्ट्स खाली होने के कारण समाप्त हो सकती हैं: astr = '' या 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

जहां भेदभाव किया जा रहा है कि एक रिक्त सूची वस्तु या खाली स्ट्र ऑब्जेक्ट लौटना अधिक "अंतिम तत्व" है-जैसे अपवाद ऑब्जेक्ट।


तिथि: 2017-12-06

alist.pop()

मैं आपके संदर्भ के लिए सभी सूची के 11 तरीकों का एक विस्तृत चीटशीट बनाता हूं।

{'list_methods': {'Add': {'extend', 'append', 'insert'},
                  'Entire': {'clear', 'copy'},
                  'Search': {'count', 'index'},
                  'Sort': {'reverse', 'sort'},
                  'Subtract': {'remove', 'pop'}}}

पायथन में अंतिम तत्व प्रदर्शित करने का सबसे आसान तरीका है

>>> list[-1:] # returns indexed value
    [3]
>>> list[-1]  # returns value
    3

इस तरह के एक लक्ष्य को प्राप्त करने के लिए कई अन्य तरीके हैं लेकिन इनका उपयोग करने के लिए छोटे और मीठे हैं।


आप यह भी कर सकते हैं:

alist.pop()

यह इस बात पर निर्भर करता है कि आप अपनी सूची के साथ क्या करना चाहते हैं क्योंकि pop() विधि अंतिम तत्व को हटा देगी।


ठीक है, लेकिन लगभग हर भाषा के तरीके में items[len(items) - 1] बारे में क्या बात है items[len(items) - 1] ? यह आईएमओ अंतिम तत्व प्राप्त करने का सबसे आसान तरीका है, क्योंकि इसे किसी भी प्रकार के पाइथोनिक ज्ञान की आवश्यकता नहीं है।


mylist = [ 1 , 2 , 3 , 4 , 5]

#------------------------------------
# Method-1 : Last index
#------------------------------------

print(mylist[-1])


#------------------------------------
# Method-2 : Using len 
#------------------------------------

print(mylist[len(mylist) - 1])


#------------------------------------
# Method-3 : Using pop, pop will remove the last 
#            element from the list.
#------------------------------------

print(mylist.pop())

popes = ['john paul II', 'benedict XIV', 'francis I']
current_pope = []
for pope in popes:
     current_pope = pope

लूप के बाद आपको current_pope चर में अंतिम आइटम मिल जाएगा।


some_list[-1] सबसे छोटा और सबसे पायथनिक है।

वास्तव में, आप इस वाक्यविन्यास के साथ और अधिक कर सकते हैं। some_list[-n] वाक्यविन्यास nth-to-last तत्व प्राप्त करता है। तो 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]

यदि आप खाली हैं तो आप इंडेक्स एरर नहीं प्राप्त करना चाहते हैं, तो आप नीचे दिए गए कोड का भी उपयोग कर सकते हैं।

next(reversed(some_list), None)






indexing