Python tranche le premier et le dernier élément de la liste

Question

Existe-t-il un moyen de couper uniquement le premier et le dernier élément d'une liste ?

Par exemple : si c'est ma liste :

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

I veulent pour ce faire (évidemment [0,-1] n'est pas une syntaxe valide) :

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

Certaines choses que j'ai essayées :

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

Un moyen :

some_list[::len(some_list)-1]

Une meilleure façon (n'utilise pas le découpage, mais est plus facile à lire) :

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

Answer 2

La seule réponse possible avec Python 3 (qui n'utilise pas le découpage en tranches ou qui ne jette pas le reste de l'information) est la suivante list mais qui pourrait être suffisant de toute façon) est d'utiliser le déballage des généralisations pour obtenir first y last séparé du milieu :

first, *_, last = some_list

Le choix de _ comme fourre-tout pour le "reste" des arguments est arbitraire ; ils seront stockés dans le nom _ qui est souvent utilisé comme un stand-in pour "les choses dont je me fiche".

Contrairement à beaucoup d'autres solutions, celle-ci garantit qu'il y a au moins deux éléments dans la séquence ; s'il n'y en a qu'un (donc first y last serait identique), il lèvera une exception ( ValueError ).

Answer 3

Je pensais juste montrer comment faire ça avec l'indexation fantaisiste de Numpy :

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

Notez qu'il prend également en charge des emplacements d'index arbitraires, ce que la fonction [::len(some_list)-1] ne fonctionnerait pas pour :

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

Comme le souligne DSM, vous pouvez faire quelque chose de similaire avec itemgetter :

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

Answer 4

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

Answer 5

Il semble que certaines personnes répondent à la mauvaise question. Tu as dit que tu voulais le faire :

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

Par exemple, vous voulez extraire le premier et le dernier élément dans des variables séparées.

Dans ce cas, les réponses de Matthew Adams, pemistahl, et katrielalex sont valables. Il s'agit simplement d'un devoir composé :

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

Mais plus tard vous déclarez une complication : "Je le divise dans la même ligne, et il faudrait passer du temps à le diviser deux fois :"

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

Ainsi, afin d'éviter deux appels split(), vous ne devez opérer qu'une seule fois sur la liste qui résulte du fractionnement.

Dans ce cas, tenter d'en faire trop en une seule ligne nuit à la clarté et à la simplicité. Utilisez une variable pour contenir le résultat de la division :

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

D'autres réponses ont répondu à la question "comment obtenir une nouvelle liste, constituée des premiers et derniers éléments d'une liste ?". Elles ont probablement été inspirées par votre titre, qui mentionne le slicing, ce que vous ne voulez en fait pas, selon une lecture attentive de votre question.

Il y a trois façons d'obtenir une nouvelle liste avec les 0ème et dernier éléments d'une liste :

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

L'avantage de l'approche de la compréhension de liste est que l'ensemble des indices dans le tuple peut être arbitraire et généré de manière programmatique.