列表中的Python片第一个和最后一个元素

Question

有没有办法只分割列表中的第一个和最后一个元素？

例如;如果这是我的名单：

>>> 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]: [] 
... 

Answer 1

方式一：

some_list[::len(some_list)-1] 

一种更好的方式（不使用切片，但是更易于阅读）：

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

Answer 2

你可以这样做：

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

Answer 3

其实，我只是想通了：

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

Answer 4

这个怎么样？

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

Answer 5

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

Answer 6

只是想我会展示如何在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') 

Answer 7

有些人正在回答错误的问题，看来。你说你想做：

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

列表理解方法的优点是，在元组中的一组指标，可任意并以编程方式生成。

Answer 8

您可以使用像`

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

，如果你真的想用切片。这样做的好处是它不能给出索引错误，并且可以使用长度为1或0的列表。

Answer 9

这不是一个“切片”，但它是一个通用的解决方案，它不使用显式索引，并且适用于所讨论的序列是匿名的场景（这样您就可以创建和“切片”同一条线路，而无需创建两次，两次索引）：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) 

，但如果你会重用吸气剂很多，你可以保存重新创建它的工作（一个d提供一个有用的自我记录名称），提前创建一次。

因此，对于您的具体使用情况，您可以取代：

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

有：

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

和split只有一次没有永久名称，存储完整的list为len检查或双-indexing等。

注意itemgetter多个项目返回一个tuple，不是list，所以如果你不只是它拆包特定的名称，需要一个真正的list，你必须包裹在list构造函数的调用。

Answer 10

的Python 3只回答（不使用切片或扔掉list的休息，但可能不够好反正）是使用拆包概括得到first和last从中间分开：

first, *_, last = some_list 

选择_作为参数“rest”的选项是任意的;他们将以_的名称存储，这个名字经常用作“我不关心的东西”的替身。

与许多其他解决方案不同，这一个将确保序列中至少有两个元素;如果只有一个（所以first和last将是相同的），它会引发异常（ValueError）。

Answer 11

更一般的情况：从列表的每一端返回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返回底部和顶部3个数字的示例：

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

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

Answer 12

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

现在只是使功能之外的变量和调用该函数：这样的：

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