Python срезает первый и последний элемент в списке

Ответ 1

Один из способов:

some_list[::len(some_list)-1]

Лучший способ (не использует нарезку, но легче читать):

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

Ответ 2

Просто подумал, что я покажу, как это сделать с numpy fancy indexing:

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

Ответ 3

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

Ответ 4

Вы можете сделать это следующим образом:

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

Ответ 5

Некоторые люди отвечают на неправильный вопрос, кажется. Вы сказали, что хотите сделать:

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

Т.е. вы хотите извлечь первый и последний элементы в отдельные переменные.

В этом случае ответы Мэтью Адамса, 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 - это 3 способа получить новый список с 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']

Преимущество подхода к пониманию списка состоит в том, что набор индексов в кортеже может быть произвольным и программным образом сгенерирован.

Ответ 6

Как насчет этого?

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

Ответ 7

Ответ Python 3 (который не использует нарезку или выбрасывает остальную часть list, но может быть достаточно хорош в любом случае) использует распаковку обобщений, чтобы получить first и last отдельно от середины:

first, *_, last = some_list

Выбор _ как совокупности для "остатка" аргументов произволен; они будут сохранены в имени _, которое часто используется в качестве резервной копии для "вещей, которые мне не нужны".

В отличие от многих других решений, это гарантирует, что в последовательности будет по крайней мере два элемента; если есть только один (так что first и last были бы идентичны), он вызывает исключение (ValueError).

Ответ 8

Собственно, я только что понял:

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

Ответ 9

Вы можете использовать что-то вроде

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

если вы действительно хотите использовать нарезку. Преимущество этого в том, что он не может выдавать ошибки индекса и работает также со списками длиной 1 или 0.

Ответ 10

Больше общего случая: вернуть N точек из каждого конца списка

Ответы работают для конкретного первого и последнего, но некоторые, как и я, могут искать решение, которое можно применить к более общему случаю, в котором вы можете вернуть верхние N точек с обеих сторон списка ( скажем, у вас есть отсортированный список и вам нужно только 5 наивысших или самых низких), я придумал следующее решение:

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

и пример возврата нижнего и верхнего трех чисел из списка 1-10:

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

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

Ответ 11

Это не "срез", но это общее решение, которое не использует явное индексирование и работает для сценария, в котором данная последовательность анонимна (так что вы можете создавать и "срезать" на одном и том же line, не создавая дважды и дважды индексируя): operator.itemgetter

import operator

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

...

first, last = first_and_last(some_list)

Вы можете просто вставить его как (после from operator import itemgetter для краткости во время использования):

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

но если вы будете многократно использовать геттер, вы можете сохранить работу по ее воссозданию (и дать ему полезное самозаверяющее имя), создав его заблаговременно.

Таким образом, для вашего конкретного варианта использования вы можете заменить:

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

с:

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

и split только один раз, не сохраняя полное list в постоянном имени для len проверки или двойного индексирования или тому подобного.

Обратите внимание, что itemgetter для нескольких элементов возвращает tuple, а не list, поэтому, если вы не просто распаковываете его на определенные имена и нуждаетесь в истинном list, вам придется обернуть вызов в конструкторе list.

Ответ 12

Другое решение python3 использует распаковку кортежей с символом "*": first, * _, last = range (1, 10)

Ответ 13

Я обнаружил, что это может сделать это:

list[[0,-1]]

Ответ 14

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

Теперь просто внесите переменную вне функции и вызовите функцию: например:

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