Corte Python primer y último elemento en la lista

¿Hay alguna forma de dividir solo el primer y el ú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 syntax 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]: [] ... 

De una sola mano:

 some_list[::len(some_list)-1] 

Una mejor manera (no utiliza el corte, pero es más fácil de leer):

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

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, para las cuales el método [::len(some_list)-1] no funcionaría para:

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

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

 >>> import operator >>> operator.itemgetter(0, 2, -1)(some_list) ('1', '3', 'F') 
 first, last = some_list[0], some_list[-1] 

Puedes hacerlo así:

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

Algunas personas están respondiendo la pregunta incorrecta, parece. Usted dijo que quiere hacer:

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

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

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

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

Pero luego declara una complicación: “Lo estoy dividiendo en la misma línea, y eso tendría que pasar el tiempo dividiéndolo dos veces:”

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

Entonces, para evitar dos llamadas split (), solo debe operar en la lista que resulte de la división una vez.

En este caso, intentar hacer demasiado en una línea es un detrimento para la claridad y la simplicidad. Use una variable para mantener el resultado de la división:

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

Otras respuestas respondieron a la pregunta de “cómo obtener una nueva lista, que consiste en el primer y último elemento de una lista?” Probablemente se inspiraron en tu título, que menciona el corte en rodajas, que en realidad no quieres, de acuerdo con una lectura cuidadosa de tu pregunta.

AFAIK son 3 formas de obtener una nueva lista con los elementos 0 y últimos de una lista:

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

La ventaja del enfoque de comprensión de lista, es que el conjunto de índices en la tupla puede ser arbitrario y generado mediante progtwigción.

Que hay de esto

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

La única respuesta de Python 3 (que no usa cortar o tirar el rest de la list , pero podría ser lo suficientemente bueno de todos modos) es usar las generalizaciones de desempaquetado para obtener la first y la last separación del medio:

 first, *_, last = some_list 

La elección de _ como el conjunto para el “rest” de los argumentos es arbitraria; se almacenarán en el nombre _ que a menudo se usa como soporte para “cosas que no me importan”.

A diferencia de muchas otras soluciones, esta asegurará que haya al menos dos elementos en la secuencia; si solo hay uno (de modo que la first y la last sean idénticas), generará una excepción ( ValueError ).

En realidad, simplemente lo descubrí:

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

Caso más general: Devuelva N puntos de cada final de la lista

Las respuestas funcionan para la primera y la última, pero algunas, como yo, pueden estar buscando una solución que se pueda aplicar a un caso más general en el que pueda devolver los mejores N puntos desde cualquier lado de la lista (suponga que tiene una lista ordenada y solo quiero las 5 más altas o más bajas), 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 los 3 primeros y primeros 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] 

Puedes usar algo como

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

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

Esto no es un “sector”, 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 (por lo que puede crear y “dividir” 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) 

Puede simplemente from operator import itemgetter como (después from operator import itemgetter por brevedad en el momento del uso):

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

pero si va a reutilizar mucho al captador, puede guardar el trabajo de recrearlo (y darle un nombre útil y autodocumentado) al crearlo una vez antes.

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 comprobación de len o doble indexación o similares.

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

Otra solución de python3 usa el desempaquetado de tuplas con el carácter “*”:

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

Todos estos son interesantes, pero ¿qué sucede si tiene un número de versión y no sabe el tamaño de ningún segmento en una cadena y desea eliminar el último segmento? Algo así como 20.0.1.300 y quiero terminar con 20.0.1 sin el 300 en el final. Tengo esto hasta ahora:

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

que devuelve en forma de lista como:

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

¿Cómo puedo volver a convertirlo en una sola cadena separada por puntos?

 20.0.1 

Encontré que esto podría hacer esto:

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

Ahora solo haga una variable fuera de la función y recupere la función: así:

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