목록의 Python 슬라이스 첫 번째 및 마지막 요소

목록의 Python 슬라이스 첫 번째 및 마지막 요소

---

목록의 첫 번째 항목과 마지막 항목 만 분할하는 방법이 있습니까?

예를 들면 다음과 같습니다. 이것이 내 목록 인 경우 :

>>> some_list
['1', 'B', '3', 'D', '5', 'F']

나는 이것을 하고 싶다 (분명히 [0,-1]유효한 구문이 아님) :

>>> first_item, last_item = some_list[0,-1]
>>> print first_item
'1'
>>> print last_item
'F'

내가 시도한 몇 가지 :

In [3]: some_list[::-1]
Out[3]: ['F', '5', 'D', '3', 'B', '1']

In [4]: some_list[-1:1:-1]
Out[4]: ['F', '5', 'D', '3']

In [5]: some_list[0:-1:-1]
Out[5]: []
...

---

일방 통행:

some_list[::len(some_list)-1]

더 나은 방법 (슬라이싱을 사용하지 않지만 읽기가 더 쉽습니다) :

[some_list[0], some_list[-1]]

---

numpy의 멋진 인덱싱으로 이것을 수행하는 방법을 보여줄 것이라고 생각했습니다.

>>> import numpy
>>> some_list = ['1', 'B', '3', 'D', '5', 'F']
>>> numpy.array(some_list)[[0,-1]]
array(['1', 'F'], 
      dtype='|S1')

또한 [::len(some_list)-1]메서드가 작동하지 않는 임의의 인덱스 위치도 지원합니다 .

>>> numpy.array(some_list)[[0,2,-1]]
array(['1', '3', 'F'], 
      dtype='|S1')

DSM이 지적했듯이 itemgetter 와 비슷한 작업을 수행 할 수 있습니다 .

>>> import operator
>>> operator.itemgetter(0, 2, -1)(some_list)
('1', '3', 'F')

---

first, last = some_list[0], some_list[-1]

---

파이썬 3의 유일한 대답은 (슬라이싱을 사용하지 않거나 나머지를 버리지 list않지만 어쨌든 충분할 수 있음) 중간에서 가져 first오고 last분리 하기 위해 풀기 일반화를 사용 하는 것입니다.

first, *_, last = some_list

_인수의 "나머지"에 대한 캐치 올로 선택하는 것은 임의적입니다. 그들은 _"내가 신경 쓰지 않는 물건"의 대용으로 자주 사용되는 이름으로 저장 될 것 입니다.

다른 많은 솔루션과 달리이 솔루션은 시퀀스에 최소 두 개의 요소가 있는지 확인합니다. 이 단 하나 (그렇다면 first와 last동일한 것)는 예외를 발생시킬 것이다 ( ValueError).

---

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

some_list[0::len(some_list)-1]

---

어떤 사람들은 잘못된 질문에 답하고있는 것 같습니다. 당신이하고 싶다고 말했다 :

>>> first_item, last_item = some_list[0,-1]
>>> print first_item
'1'
>>> print last_item
'F'

즉, 첫 번째와 마지막 요소를 각각 별도의 변수로 추출하려고합니다.

이 경우 Matthew Adams, pemistahl 및 katrielalex의 답변이 유효합니다. 이것은 단지 복합 할당입니다.

first_item, last_item = some_list[0], some_list[-1]

그러나 나중에 당신은 합병증을 말합니다. "나는 그것을 같은 줄로 나누고 있으며, 두 번 나누는 데 시간을 소비해야합니다."

x, y = a.split("-")[0], a.split("-")[-1]

따라서 두 개의 split () 호출을 방지하려면 한 번 분할 된 목록에서만 작업해야합니다.

이 경우 한 줄에서 너무 많은 작업을 시도하면 명확성과 단순성이 손상됩니다. 분할 결과를 유지하려면 변수를 사용하십시오.

lst = a.split("-")
first_item, last_item = lst[0], lst[-1]

다른 응답자들은 "목록의 첫 번째 요소와 마지막 요소로 구성된 새 목록을 얻는 방법"이라는 질문에 답했습니다. 그들은 당신의 질문을주의 깊게 읽었을 때 당신이 실제로 원하지 않는 슬라이스를 언급하는 당신의 제목에서 영감을 받았을 것입니다.

AFAIK는 목록의 0 번째 요소와 마지막 요소가있는 새 목록을 가져 오는 세 가지 방법입니다.

>>> s = 'Python ver. 3.4'
>>> a = s.split()
>>> a
['Python', 'ver.', '3.4']

>>> [ a[0], a[-1] ]        # mentioned above
['Python', '3.4']

>>> a[::len(a)-1]          # also mentioned above
['Python', '3.4']

>>> [ a[e] for e in (0,-1) ] # list comprehension, nobody mentioned?
['Python', '3.4']

# Or, if you insist on doing it in one line:
>>> [ s.split()[e] for e in (0,-1) ]
['Python', '3.4']

The advantage of the list comprehension approach, is that the set of indices in the tuple can be arbitrary and programmatically generated.

---

What about this?

>>> first_element, last_element = some_list[0], some_list[-1]

---

Actually, I just figured it out:

In [20]: some_list[::len(some_list) - 1]
Out[20]: ['1', 'F']

---

This isn't a "slice", but it is a general solution that doesn't use explicit indexing, and works for the scenario where the sequence in question is anonymous (so you can create and "slice" on the same line, without creating twice and indexing twice): operator.itemgetter

import operator

# Done once and reused
first_and_last = operator.itemgetter(0, -1)

...

first, last = first_and_last(some_list)

You could just inline it as (after from operator import itemgetter for brevity at time of use):

first, last = itemgetter(0, -1)(some_list)

but if you'll be reusing the getter a lot, you can save the work of recreating it (and give it a useful, self-documenting name) by creating it once ahead of time.

Thus, for your specific use case, you can replace:

x, y = a.split("-")[0], a.split("-")[-1]

with:

x, y = itemgetter(0, -1)(a.split("-"))

and split only once without storing the complete list in a persistent name for len checking or double-indexing or the like.

Note that itemgetter for multiple items returns a tuple, not a list, so if you're not just unpacking it to specific names, and need a true list, you'd have to wrap the call in the list constructor.

---

More General Case: Return N points from each end of list

The answers work for the specific first and last, but some, like myself, may be looking for a solution that can be applied to a more general case in which you can return the top N points from either side of the list (say you have a sorted list and only want the 5 highest or lowest), i came up with the following solution:

In [1]
def GetWings(inlist,winglen):
    if len(inlist)<=winglen*2:
        outlist=inlist
    else:
        outlist=list(inlist[:winglen])
        outlist.extend(list(inlist[-winglen:]))
    return outlist

and an example to return bottom and top 3 numbers from list 1-10:

In [2]
GetWings([1,2,3,4,5,6,7,8,9,10],3)

#Out[2]
#[1, 2, 3, 8, 9, 10]

---

You can use something like

y[::max(1, len(y)-1)]

if you really want to use slicing. The advantage of this is that it cannot give index errors and works with length 1 or 0 lists as well.

---

Another python3 solution uses tuple unpacking with the "*" character:

first, *_, last = range(1, 10)

---

These are all interesting but what if you have a version number and you don't know the size of any one segment in string from and you want to drop the last segment. Something like 20.0.1.300 and I want to end up with 20.0.1 without the 300 on the end. I have this so far:

str('20.0.1.300'.split('.')[:3])

which returns in list form as:

['20', '0', '1']

How do I get it back to into a single string separated by periods

20.0.1

---

I found this might do this:

list[[0,-1]]

---

def recall(x): 
    num1 = x[-4:]
    num2 = x[::-1]
    num3 = num2[-4:]
    num4 = [num3, num1]
    return num4

Now just make an variable outside the function and recall the function : like this:

avg = recall("idreesjaneqand") 
print(avg)

참고URL : https://stackoverflow.com/questions/12218796/python-slice-first-and-last-element-in-list