Python-Slice erste und letzte Element in der Liste

Gibt es eine Möglichkeit, nur das erste und letzte Element in einer Liste zu schneiden?

Beispielsweise; Wenn dies meine Liste ist:

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

Ich möchte das tun (offensichtlich [0,-1] ist keine gültige Syntax):

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

Einige Dinge habe ich versucht:

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

  • Python: Subskript ein Modul
  • Matplotlib tiefgestellt
  • Text in Matplotlib-Etiketten abzeichnen
  • 12 Solutions collect form web for “Python-Slice erste und letzte Element in der Liste”

    Einweg:

     some_list[::len(some_list)-1] 

    Ein besserer Weg (nutzt das Schneiden nicht, ist aber leichter zu lesen):

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

    Ich dachte nur, ich würde zeigen, wie das mit numpys fancy indexing zu tun:

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

    Beachten Sie, dass es auch beliebige Indexstandorte unterstützt, für die die Methode [::len(some_list)-1] nicht funktionieren würde:

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

    Wie DSM darauf hinweist, können Sie etwas ähnliches mit itemgetter machen :

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

    Du kannst es so machen:

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

    Was ist damit?

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

    Manche Leute beantworten die falsche Frage, so scheint es. Sie sagten, Sie wollen:

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

    Sie wollen das erste und das letzte Element in einzelne Variablen extrahieren.

    In diesem Fall sind die Antworten von Matthew Adams, pemistahl und katrielalex gültig. Das ist nur eine zusammengesetzte Aufgabe:

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

    Aber später sagen Sie eine Komplikation: "Ich spalte es in der gleichen Zeile, und das müsste Zeit damit verbringen, es zweimal zu teilen:"

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

    Um also zwei Split () Anrufe zu vermeiden, musst du nur auf der Liste operieren, die sich aus der Spaltung ergibt.

    In diesem Fall ist der Versuch, zu viel in einer Zeile zu tun, ein Nachteil der Klarheit und Einfachheit. Verwenden Sie eine Variable, um das Split-Ergebnis zu halten:

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

    Andere Antworten beantworteten die Frage nach "wie bekomme ich eine neue Liste, bestehend aus den ersten und letzten Elementen einer Liste?" Sie wurden wahrscheinlich von deinem Titel inspiriert, was das Aufschneiden nennt, was du eigentlich nicht willst, nach einer sorgfältigen Lektüre deiner Frage.

    AFAIK sind 3 Wege, um eine neue Liste mit dem 0. und letzten Elementen einer Liste zu erhalten:

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

    Der Vorteil des Listenverständnisses ist, dass der Satz von Indizes im Tupel beliebig und programmgesteuert erzeugt werden kann.

    Eigentlich habe ich es gerade herausgefunden:

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

    Du kannst so etwas wie `verwenden

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

    Wenn du wirklich schneiden willst. Der Vorteil davon ist, dass es keine Indexfehler geben kann und auch mit Längen 1 oder 0 Listen arbeitet.

    Dies ist kein "Slice", aber es ist eine allgemeine Lösung, die keine explizite Indizierung verwendet und arbeitet für das Szenario, wo die Sequenz in Frage ist anonym (so können Sie erstellen und "Slice" auf der gleichen Zeile, ohne Zweimal erstellen und zweimal indizierend): operator.itemgetter

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

    Du from operator import itemgetter es einfach als (nach from operator import itemgetter zur Kürze zum Zeitpunkt der Nutzung):

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

    Aber wenn du den Getter viel wiederverwenden wirst, kannst du die Arbeit der Wiederherstellung speichern (und ihm einen nützlichen, selbstdokumentierenden Namen geben), indem du ihn einmal vor der Zeit schaffst.

    So können Sie für Ihren speziellen Anwendungsfall ersetzen:

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

    mit:

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

    Und split nur einmal, ohne die vollständige list in einem persistenten Namen für len Überprüfung oder Doppel-Indizierung oder dergleichen zu speichern.

    Beachten Sie, dass itemgetter für mehrere Elemente ein tuple zurückgibt, nicht eine list , also wenn Sie es nicht nur auf bestimmte Namen auspacken und eine echte list benötigen, müssten Sie den Anruf im list Konstruktor itemgetter .

    Python 3 antwortet nur (das nutzt das Slicing nicht oder wirft den Rest der list weg, könnte aber trotzdem gut genug sein) ist das Auspacken von Verallgemeinerungen, um first und last getrennt von der Mitte zu bekommen:

     first, *_, last = some_list 

    Die Wahl von _ als der Fang für die "Ruhe" der Argumente ist willkürlich; Sie werden im Namen gespeichert, der oft als Stand-in für "Sachen, die mir egal" ist, nicht benutzt wird.

    Im Gegensatz zu vielen anderen Lösungen wird dafür sichergestellt, dass es mindestens zwei Elemente in der Sequenz gibt. Wenn es nur eine gibt (so dass first und last wäre identisch), wird es eine Ausnahme ( ValueError ) zu ValueError .

    More General Case: Rückkehr N Punkte von jedem Ende der Liste

    Die Antworten arbeiten für die spezifischen ersten und letzten, aber einige, wie ich selbst, können auf der Suche nach einer Lösung, die auf einen allgemeineren Fall angewendet werden kann, in dem Sie die Top-N-Punkte von beiden Seiten der Liste zurückgeben können (sagen, Sie haben Eine sortierte Liste und möchte nur die 5 höchsten oder niedrigsten), kam ich mit der folgenden Lösung:

     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 

    Und ein Beispiel, um die unteren und oberen 3 Zahlen aus der Liste 1-10 zurückzugeben:

     In [2] GetWings([1,2,3,4,5,6,7,8,9,10],3) #Out[2] #[1, 2, 3, 8, 9, 10] 
     def recall(x): num1 = x[-4:] num2 = x[::-1] num3 = num2[-4:] num4 = [num3, num1] return num4 

    Jetzt mach nur eine Variable außerhalb der Funktion und ruf die Funktion an: wie folgt:

     avg = recall("idreesjaneqand") print(avg) 
    Python ist die beste Programmiersprache der Welt.