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

有没有办法只对列表中的第一项和最后一项进行切片

比如,；如果这是我的清单：

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

我想这样做（显然

[0，-1]

的语法无效）：

我尝试过的一些事情：

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[0::len(some_list)-1]

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

单向：

some_list[::len(some_list)-1]

更好的方法（不使用切片，但更易于阅读）：

---

事实上，我刚想出来：

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

这个怎么样

>>> first_element, last_element = 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所指出的，您可以通过以下方式执行类似操作：

---

似乎有些人回答了错误的问题。你说过你想做：

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

例如，您希望将第一个和最后一个元素分别提取到单独的变量中

在这种情况下，Matthew Adams、Pemisthal和Katrielex的答案是有效的。这只是一个复合赋值：

first_item, last_item = some_list[0], some_list[-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']

---

列表理解方法的优点是元组中的索引集可以是任意的，并且可以通过编程方式生成

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

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

这不是一个“切片”，但它是一个不使用显式索引的通用解决方案，适用于所讨论的序列是匿名的场景（因此您可以创建和“切片”）在同一行上，无需创建两次和索引两次）：

您可以将其内联为（在使用时为简洁起见，在操作员导入itemgetter的

之后）：

但是，如果要大量重用getter，可以通过提前创建一次getter来节省重新创建getter的工作（并给它一个有用的、自文档化的名称）

因此，对于您的特定用例，您可以替换：

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

与：

和
split
仅一次，而不将完整的
列表
存储在持久名称中，用于
len
检查或双重索引等

请注意，对于多个项，
itemgetter
返回的是一个
元组，而不是
列表
，因此，如果您不只是将其解压缩为特定名称，并且需要一个真正的
列表
，则必须将调用包装在
列表
构造函数中。
列表的其余部分，但无论如何可能已经足够好了）是使用解包泛化将
第一个
和
最后一个
从中间分开：

first, *_, last = some_list

>>> l = ['1', 'B', '3', 'D', '5', 'F']
>>> first, *_, last = l
>>> first
'1'
>>> last
'F'
>>> 

选择
\u
作为“其余”参数的catchall是任意的；它们将存储在名称
\u
中，该名称通常用作“我不在乎的东西”的替代

与许多其他解决方案不同，此解决方案将确保序列中至少有两个元素；如果只有一个（因此
first
和
last
是相同的），它将引发异常（
ValueError
）。
更一般的情况：从列表的每一端返回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

现在只需在函数外创建一个变量并调用函数：如下所示：

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

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

我发现这可能会这样：

list[[0,-1]]

另一个python3解决方案使用带有“*”字符的元组解包：

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

这些都很有趣，但是如果你有一个版本号，但你不知道字符串中任何一个段的大小，你想删除最后一个段。比如20.0.1.300，我想以20.0.1结束，但最后没有300。我有这个：

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

以列表形式返回，如下所示：

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

如何将其返回到由句点分隔的单个字符串中

20.0.1

利用打包/解包操作符将列表中间部分打包为单个变量：

>>> l = ['1', 'B', '3', 'D', '5', 'F']
>>> first, *middle, last = l
>>> first
'1'
>>> middle
['B', '3', 'D', '5']
>>> last
'F'
>>> 

或者，如果要放弃中间部分：

first, *_, last = some_list

>>> l = ['1', 'B', '3', 'D', '5', 'F']
>>> first, *_, last = l
>>> first
'1'
>>> last
'F'
>>> 

有趣的“一行”新方法匿名拆分的情况下，您不会将其拆分两次，而是使用一行中的所有工作，允许两种情况：

first, last = (split_str := a.split("-"))[0], split_str[-1]

以及：

请注意，在这两种情况下，它本质上完全等同于在一条线上执行：

split_str = a.split("-")

然后跟进以下其中一项：

first, last = split_str[0], split_str[-1]
first, last = split_str[::len(split_str)-1]

包括
split\u str
在其使用和访问的行之外仍然存在的事实。它只是在技术上满足了一个衬里的要求，但相当难看。我从不推荐它或解决方案，即使一个衬里是强制性的（排除明确索引或切片命名变量的非海象版本，并且必须引用该命名变量两次）。
哈哈3个答案，相同，在2秒钟内，一个是你的。经典。
first，last=一些列表[0]，一些列表[-1]有什么不好
？@matthewaddams，因为我在同一行中拆分它，而这将需要花费时间拆分它
20.0.1

>>> l = ['1', 'B', '3', 'D', '5', 'F']
>>> first, *middle, last = l
>>> first
'1'
>>> middle
['B', '3', 'D', '5']
>>> last
'F'
>>> 

>>> l = ['1', 'B', '3', 'D', '5', 'F']
>>> first, *_, last = l
>>> first
'1'
>>> last
'F'
>>> 

first, last = (split_str := a.split("-"))[0], split_str[-1]

first, last = (split_str := a.split("-"))[::len(split_str)-1]

split_str = a.split("-")

first, last = split_str[0], split_str[-1]
first, last = split_str[::len(split_str)-1]