ultimo - mover elementos de una lista python

Python slice primer y último elemento en la lista

Question

¿Hay alguna forma de dividir solo el primer y último elemento en una lista?

Por ejemplo; Si esta es mi lista:

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

Quiero hacer esto (obviamente [0,-1] no es una sintaxis válida):

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

Algunas cosas que he intentado:

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

¿Qué hay de esto?

>>> 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 2

Algunas personas están respondiendo la pregunta equivocada, parece. Dijiste que quieres hacer:

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

Es decir, desea extraer los elementos primero y último, cada uno en variables separadas.

En este caso, las respuestas de Matthew Adams, pemistahl y katrielalex son válidas. Esta es solo una tarea compuesta:

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

Pero más tarde declaras una complicación: "Lo estoy dividiendo en la misma línea, y eso tendría que perder tiempo dividiéndolo dos veces".

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

Por lo tanto, para evitar dos llamadas split (), solo debe operar en la lista que resulta de dividir una vez.

En este caso, intentar hacer demasiado en una línea es en detrimento de la claridad y la simplicidad. Usa una variable para mantener el resultado dividido:

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

Otras respuestas respondieron a la pregunta de "¿cómo obtener una nueva lista, que consta de los primeros y últimos elementos de una lista?" Probablemente fueron inspirados por su título, que menciona rebanar, que en realidad no desea, según una lectura cuidadosa de su pregunta.

AFAIK son 3 maneras de obtener una nueva lista con el 0º y último elemento de una lista:

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

La ventaja del enfoque de comprensión de listas es que el conjunto de índices en la tupla puede generarse arbitraria y programáticamente.

Answer 3

De una sola mano:

some_list[::len(some_list)-1]

Una mejor manera (No usa cortar, pero es más fácil de leer):

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

Answer 4

Descubrí que esto podría hacer esto:

list[[0,-1]]

Answer 5

En realidad, me acabo de dar cuenta:

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

Answer 6

Esto no es una "porción", pero es una solución general que no usa indexación explícita, y funciona para el escenario donde la secuencia en cuestión es anónima (para que pueda crear y "cortar" en la misma línea, sin creando dos veces e indexando dos veces): operator.itemgetter

import operator

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

...

first, last = first_and_last(some_list)

Podrías simplemente from operator import itemgetter como (después from operator import itemgetter para la brevedad en el momento del uso):

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

pero si va a reutilizar mucho el getter, puede guardar el trabajo de recrearlo (y darle un nombre útil y autodocumentado) creándolo una vez con anticipación.

Por lo tanto, para su caso de uso específico, puede reemplazar:

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

con:

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

y split solo una vez sin almacenar la list completa en un nombre persistente para la verificación de len o doble indexación o similar.

Tenga en cuenta que itemgetter para varios elementos devuelve una tuple , no una list , por lo que si no solo está desempacando en nombres específicos, y necesita una list verdadera, tendría que ajustar la llamada en el constructor de list .

Answer 7

Puedes hacerlo así:

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

Answer 8

Puedes usar algo como

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

si realmente quieres usar slicing. La ventaja de esto es que no puede dar errores de índice y funciona con listas de longitud 1 o 0 también.

Answer 9

Python 3 solo responde (que no usa cortar o tirar el resto de la list , pero de todas maneras podría ser lo suficientemente bueno) es usar generalizaciones de desempaquetado para obtener la first y la last separación del medio:

first, *_, last = some_list

La elección de _ como el complemento para el "resto" de los argumentos es arbitraria; se almacenarán en el nombre _ que a menudo se usa como sustituto de "cosas que no me importan".

A diferencia de muchas otras soluciones, esta se asegurará de que haya al menos dos elementos en la secuencia; si solo hay uno (por lo que el first y el last serían idénticos), generará una excepción ( ValueError ).

Answer 10

Solo pensé que mostraría cómo hacer esto con la elegante indexación de Numpy:

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

Tenga en cuenta que también admite ubicaciones de índice arbitrarias, que el método [::len(some_list)-1] no funcionaría:

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

Como DSM señala, puedes hacer algo similar con itemgetter :

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

Answer 11

Más casos generales: devuelve N puntos de cada extremo de la lista

Las respuestas funcionan para el primero y el último específicos, pero algunos, como yo, pueden estar buscando una solución que se pueda aplicar a un caso más general en el que puede devolver los N puntos superiores de cualquier lado de la lista (digamos que tiene una lista ordenada y solo desea el 5 más alto o más bajo), se me ocurrió la siguiente solución:

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

y un ejemplo para devolver 3 números de la lista 1-10:

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

Ahora solo crea una variable fuera de la función y recupera la función: así:

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

Answer 13

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