ලැයිස්තුවක අවසාන අංගය ලබා ගැනීම

පයිතන්හිදී, ලැයිස්තුවක අවසාන අංගය ලබා ගන්නේ කෙසේද?

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

වෙනස ඇති තැන නම් හිස් ලැයිස්තු වස්තුවක් හෝ හිස් නූල් වස්තුවක් ආපසු ලබා දීම වඩා “අන්තිම මූලද්‍රව්‍යය” වන අතර එය ව්‍යතිරේක වස්තුවකි.

ඔබට ද කළ හැකිය:

alist.pop()

එය ඔබගේ ලැයිස්තුව සමඟ කළ යුතු දේ මත රඳා පවතී, මන්ද එම pop()ක්‍රමය මඟින් අවසාන අංගය මකා දැමෙනු ඇත.

පයිතන් හි අවසාන අංගය පෙන්වීමට ඇති සරලම ක්‍රමය නම්

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

එවැනි ඉලක්කයක් සපුරා ගැනීම සඳහා තවත් බොහෝ ක්‍රම තිබේ, නමුත් මේවා කෙටි හා මිහිරි ය.

පයිතන්හිදී, ලැයිස්තුවක අවසාන අංගය ලබා ගන්නේ කෙසේද?

අවසාන අංගය ලබා ගැනීමට,

• ලැයිස්තුව වෙනස් නොකර, සහ
• ලැයිස්තුවේ අවසාන අංගයක් ඇති බව ඔබ උපකල්පනය කරයි (එනම් එය අක්‍රීයයි)

සමත් -1වූ යටකුරක් අංකනය:

>>> a_list = ['zero', 'one', 'two', 'three']
>>> a_list[-1]
'three'

පැහැදිලි කිරීම

දර්ශක සහ පෙති negative ණ පූර්ණ සංඛ්‍යා තර්ක ලෙස ගත හැකිය.

මම උදාහරණයක් වෙනස් කරන ලදි ලේඛගතකිරීම සිට මේ අවස්ථාවේ දී, වැල තුළ අනුපිළිවෙල වන අයිතමය එක් එක් දර්ශකය යොමු, සඳහන් කිරීම "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'

විශේෂ අවස්ථා

ඔබ වඩාත් සංකීර්ණ දෙයක් කරන්නේ නම්, අවසාන අංගය තරමක් වෙනස් ආකාරවලින් ලබා ගැනීම වඩා කාර්ය සාධනයක් ලෙස ඔබට පෙනෙනු ඇත.

ඔබ ක්‍රමලේඛයට අලුත් නම්, ඔබ මෙම කොටස මග හැරිය යුතුය, මන්ද එය වෙනත් ආකාරයකින් අර්ථකථන වශයෙන් ඇල්ගොරිතමවල විවිධ කොටස් එකට සම්බන්ධ කරයි. ඔබ ඔබේ ඇල්ගොරිතම එක තැනකින් වෙනස් කරන්නේ නම්, එය වෙනත් කේත පේළියකට අනපේක්ෂිත බලපෑමක් ඇති කළ හැකිය.

මට හැකි පමණින් අවවාද සහ කොන්දේසි සැපයීමට මම උත්සාහ කරමි, නමුත් මට යමක් මග හැරී ඇත. කරුණාකර අදහස් දක්වන්න, මම අවවාදයක් තබමි.

පෙති කැපීම

ලැයිස්තුවක පෙත්තක් නව ලැයිස්තුවක් ලබා දෙයි - එබැවින් අපට නව ලැයිස්තුවක මූලද්‍රව්‍යය අවශ්‍ය නම් අපට -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 ආපසු ලබා දෙන බැවින් (එය අනුකාරක ප්‍රොටෝකෝලය සඳහා සහය දක්වයි) ඔබට එහි ප්‍රති result ලය ලබා දිය හැකිය 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'

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'

තවත් ක්‍රමයක්:

some_list.reverse() 
some_list[0]

list[-1]ලැයිස්තුව වෙනස් නොකර ලැයිස්තුවේ අවසාන අංගය ලබා ගනී. list.pop()ලැයිස්තුවේ අවසාන අංගය ලබා ගනී, නමුත් එය මුල් ලැයිස්තුව විකෘති / වෙනස් කරයි. සාමාන්යයෙන්, මුල් ලැයිස්තුව විකෘති කිරීම නිර්දේශ නොකරයි.

විකල්පයක් ලෙස, කිසියම් හේතුවක් නිසා, ඔබ අඩු පයිතොනික් යමක් සොයන්නේ නම්, ඔබට list[len(list)-1]ලැයිස්තුව හිස් නොවන බව උපකල්පනය කළ හැකිය .

ලැයිස්තුව හිස් වූ විට ඔබට දර්ශක දෝෂය ලබා ගැනීමට අවශ්‍ය නැතිනම් ඔබට පහත කේතය භාවිතා කළ හැකිය.

next(reversed(some_list), None)

හරි, නමුත් සෑම භාෂා ආකාරයකින්ම පොදු දේ ගැන කුමක් කිව items[len(items) - 1]හැකිද? අන්තිම මූලද්‍රව්‍යය ලබා ගැනීමට ඇති පහසුම ක්‍රමය මෙයයි, එයට කිසිවක් පයිතොනික් දැනුම අවශ්‍ය නොවන නිසා .