python - 합치기 - 파이썬 리스트 자르기




파이썬에서리스트의 마지막 요소를 얻는다. (10)

파이썬에서는리스트의 마지막 요소를 어떻게 얻습니까?


파이썬에서는리스트의 마지막 요소를 어떻게 얻습니까?

마지막 요소를 얻으려면,

  • 목록을 수정하지 않고
  • 목록에 마지막 요소 있다고 가정하면 (예 : 비어 있지 않음)

-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는 불필요하게 새로 생성 된리스트에 바인딩됩니다.

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

그 목록으로 아무 것도하지 않으려한다면, 이것은 더 apropos 일 것입니다 :

*_, last = a_list

또는 정말로, 목록이라는 것을 아는 경우 (또는 적어도 첨자 표기법을 허용하는 경우) :

last = a_list[-1]

함수에서

작성자는 다음과 같이 말했습니다.

나는 파이썬이 first ()와 last ()를위한 함수를 Lisp과 같이 가지고 있었으면 좋겠다 ... 그것은 불필요한 lambda 함수를 제거 할 것이다.

이것들은 매우 간단하게 정의 할 수 있습니다 :

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 (iterator 프로토콜을 지원하는) 반복자가 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

some_list = [1, 2, 3]

방법 1 :

some_list[-1]

방법 2 :

**some_list.reverse()** 

**some_list[0]**

방법 3 :

some_list.pop() 

날짜 : 2017-12-06

alist.pop()

나는 당신의 참고를 위해 모든리스트의 11 가지 방법에 대한 철저한 치트 시트를 만들었다.

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

다음과 같이 할 수도 있습니다.

alist.pop()

pop() 메서드는 마지막 요소를 삭제하기 때문에 목록에 무엇을 할 것인가에 달려 있습니다.


좋습니다.하지만 거의 모든 언어 방식에서 공통적으로 나타나는 items[len(items) - 1] 입니까? IMO는 파이썬 지식을 필요로하지 않기 때문에 마지막 요소를 가져 오는 가장 쉬운 방법입니다.


파이썬리스트는 음수 인덱스를 지원합니다.

a = [1, 2, 3]

a[-1] # gives the last elements with negative indexes

또는

a[len(a) - 1] # gives the last elements len function


list[-1] 는 목록을 변경하지 않고 목록의 마지막 요소를 검색합니다. list.pop() 는리스트의 마지막 요소를 검색하지만 원본 목록을 변경 / 변경합니다. 일반적으로 원본 목록을 변경하는 것은 좋지 않습니다.

또는, 어떤 이유에서, 무언가가 덜 무언가를 찾고 있다면리스트가 비어 있지 않다는 가정하에 list[len(list)-1] 사용할 수 있습니다.


lst[-1] 은 최선의 방법이지만 일반적인 iterables의 경우 more_itertools.last 고려 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'

str() 또는 list() 객체가 비어있는 상태로 끝나는 경우 : astr = '' 또는 alist = [] , 객체 alist[-1] 대신 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 객체를 반환하는 것이 예외 객체와 마찬가지로 "마지막 요소"입니다.


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




indexing