Pertanyaan Mendapatkan elemen terakhir dari daftar dengan Python


Dalam Python, bagaimana Anda mendapatkan elemen terakhir dari daftar?


1385
2018-05-30 19:28


asal


Jawaban:


some_list[-1] adalah yang terpendek dan paling Pythonic.

Bahkan, Anda dapat melakukan lebih banyak dengan sintaks ini. Itu some_list[-n] syntax mendapatkan elemen nth-to-last. Begitu some_list[-1] mendapat elemen terakhir, some_list[-2] mendapat yang kedua untuk terakhir, dll, semua jalan ke bawah some_list[-len(some_list)], yang memberi Anda elemen pertama.

Anda juga dapat mengatur elemen daftar dengan cara ini. Contohnya:

>>> 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]

2207
2018-05-30 19:29



Jika Anda str() atau list() objek mungkin berakhir kosong seperti: astr = '' atau alist = [], maka Anda mungkin ingin menggunakannya alist[-1:] dari pada alist[-1] untuk objek "kesamaan".

Signifikansi ini adalah:

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

Di mana perbedaan yang dibuat adalah bahwa mengembalikan objek daftar kosong atau objek str kosong lebih "elemen terakhir" -seperti kemudian objek pengecualian.


182
2017-11-09 23:26



Anda juga bisa melakukan:

alist.pop()

Itu tergantung pada apa yang ingin Anda lakukan dengan daftar Anda karena pop() metode akan menghapus elemen terakhir.


67
2018-05-30 22:21



Cara termudah untuk menampilkan elemen terakhir dalam python adalah

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

ada banyak metode lain untuk mencapai tujuan tersebut tetapi ini pendek dan manis untuk digunakan.


54
2017-08-20 17:41



Dalam Python, bagaimana Anda mendapatkan elemen terakhir dari daftar?

Untuk mendapatkan elemen terakhir,

  • tanpa memodifikasi daftar, dan
  • dengan asumsi Anda tahu daftarnya punya elemen terakhir (yaitu tidak kosong)

lulus -1 ke notasi subscript:

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

Penjelasan

Indeks dan irisan dapat mengambil bilangan bulat negatif sebagai argumen.

Saya telah memodifikasi sebuah contoh dari dokumentasi untuk menunjukkan item mana dalam urutan setiap referensi indeks, dalam hal ini, dalam string "Python", -1 referensi elemen terakhir, karakter, 'n':

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

>>> p = 'Python'
>>> p[-1]
'n'

Penugasan melalui pembongkaran secara berulang

Metode ini mungkin tidak perlu memunculkan daftar kedua untuk tujuan hanya mendapatkan elemen terakhir, tetapi demi kelengkapan (dan karena mendukung setiap iterable - bukan hanya daftar):

>>> *head, last = a_list
>>> last
'three'

Nama variabel, kepala terikat ke daftar yang baru dibuat tidak perlu:

>>> head
['zero', 'one', 'two']

Jika Anda tidak melakukan apa-apa dengan daftar itu, ini akan menjadi lebih banyak:

*_, last = a_list

Atau, sungguh, jika Anda tahu itu adalah daftar (atau setidaknya menerima notasi subscript):

last = a_list[-1]

Dalam suatu fungsi

Seorang komentator berkata:

Saya berharap Python memiliki fungsi untuk first () dan last () seperti Lisp tidak ... itu akan menyingkirkan banyak fungsi lambda yang tidak perlu.

Ini akan sangat mudah untuk didefinisikan:

def last(a_list):
    return a_list[-1]

def first(a_list):
    return a_list[0]

Atau gunakan operator.itemgetter:

>>> import operator
>>> last = operator.itemgetter(-1)
>>> first = operator.itemgetter(0)

Dalam kedua kasus:

>>> last(a_list)
'three'
>>> first(a_list)
'zero'

Kasus-kasus khusus

Jika Anda melakukan sesuatu yang lebih rumit, Anda mungkin merasa lebih berkinerja untuk mendapatkan elemen terakhir dengan cara yang sedikit berbeda.

Jika Anda baru dalam pemrograman, Anda harus menghindari bagian ini, karena ia berpasangan jika bagian-bagian dari algoritma bersama-sama berbeda secara semantis. Jika Anda mengubah algoritme di satu tempat, itu mungkin memiliki dampak yang tidak diinginkan pada baris kode lain.

Saya mencoba memberikan peringatan dan ketentuan selengkap mungkin, tetapi saya mungkin melewatkan sesuatu. Silakan komentar jika Anda berpikir saya meninggalkan peringatan.

Mengiris

Sepotong daftar mengembalikan daftar baru - sehingga kita dapat mengiris dari -1 ke akhir jika kita ingin elemen dalam daftar baru:

>>> a_slice = a_list[-1:]
>>> a_slice
['three']

Ini memiliki keuntungan jika tidak gagal jika daftar kosong:

>>> empty_list = []
>>> tail = empty_list[-1:]
>>> if tail:
...     do_something(tail)

Sedangkan upaya untuk mengakses berdasarkan indeks menimbulkan suatu IndexError yang perlu ditangani:

>>> empty_list[-1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Tetapi sekali lagi, mengiris untuk tujuan ini seharusnya hanya dilakukan jika Anda membutuhkan:

  • daftar baru dibuat
  • dan daftar baru kosong jika daftar sebelumnya kosong.

for loop

Sebagai fitur Python, tidak ada pelingkupan batin dalam for lingkaran.

Jika Anda melakukan iterasi lengkap di atas daftar, elemen terakhir akan tetap direferensikan oleh nama variabel yang ditetapkan dalam loop:

>>> def do_something(arg): pass
>>> for item in a_list:
...     do_something(item)
...     
>>> item
'three'

Ini bukanlah hal yang semantis dalam daftar. Ini semantis hal terakhir yang namanya, item, pasti.

>>> 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'

Jadi ini hanya boleh digunakan untuk mendapatkan elemen terakhir jika Anda

  • sudah berputar, dan
  • Anda tahu loop akan selesai (tidak pecah atau keluar karena kesalahan), selain itu akan mengarah ke elemen terakhir yang direferensikan oleh loop.

Mengambil dan menghapusnya

Kami juga dapat mengubah daftar asli kami dengan menghapus dan mengembalikan elemen terakhir:

>>> a_list.pop(-1)
'three'
>>> a_list
['zero', 'one', 'two']

Tapi sekarang daftar aslinya sudah dimodifikasi.

(-1 sebenarnya adalah argumen default, jadi list.pop dapat digunakan tanpa argumen indeks):

>>> a_list.pop()
'two'

Lakukan ini hanya jika

  • Anda tahu daftar memiliki elemen di dalamnya, atau siap untuk menangani pengecualian jika kosong, dan
  • Anda berniat untuk menghapus elemen terakhir dari daftar, memperlakukannya seperti tumpukan.

Ini adalah use case yang valid, tetapi tidak terlalu umum.

Menyimpan sisa pembalikan untuk nanti:

Saya tidak tahu mengapa Anda melakukannya, tetapi untuk kelengkapan, sejak itu reversed mengembalikan sebuah iterator (yang mendukung protokol iterator) Anda dapat memberikan hasilnya next:

>>> next(reversed([1,2,3]))
3

Jadi seperti melakukan kebalikan dari ini:

>>> next(iter([1,2,3]))
1

Tapi saya tidak bisa memikirkan alasan yang baik untuk melakukan ini, kecuali Anda akan memerlukan sisa iterator terbalik nanti, yang mungkin akan terlihat lebih seperti ini:

reverse_iterator = reversed([1,2,3])
last_element = next(reverse_iterator)

use_later = list(reverse_iterator)

dan sekarang:

>>> use_later
[2, 1]
>>> last_element
3

20
2018-06-23 22:05



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())

6
2018-02-21 09:06



jika kamu mau saja mendapatkan nilai terakhir daftar, Anda harus menggunakan:

your_list[-1]

TAPI jika Anda menghendaki mendapatkan nilai dan juga menghapus dari daftar, Anda dapat menggunakan:

your_list.pop()

ATAU: Anda dapat melakukan pop dengan indeks juga ...

your_list.pop(-1)

5
2017-10-13 12:32



Ok, tapi bagaimana dengan umum di hampir setiap cara bahasa items[len(items) - 1]? Ini IMO cara termudah untuk mendapatkan elemen terakhir, karena tidak memerlukan apa-apa pythonic pengetahuan.


4
2017-10-07 17:22



some_list = [1, 2, 3]

Metode 1:

some_list[-1]

Metode 2:

**some_list.reverse()** 

**some_list[0]**

Metode 3:

some_list.pop() 

4
2018-01-10 12:32