Necesito los últimos 9 números de una lista y estoy seguro de que hay una manera de hacerlo con el corte, pero parece que no puedo obtenerlo. Puedo obtener los primeros 9 como este:

num_list[0:9]

Puede usar enteros negativos con el operador de corte para eso. Aquí hay un ejemplo con el intérprete de la CLI de Python:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> a[-9:]
[4, 5, 6, 7, 8, 9, 10, 11, 12]

la linea importante es a[-9:]

un índice negativo contará desde el final de la lista, entonces:

num_list[-9:]

Rebanar

El corte en Python es una operación increíblemente rápida, y es una forma práctica de acceder rápidamente a partes de sus datos.

La notación de corte para obtener los últimos nueve elementos de una lista (o cualquier otra secuencia que lo soporte, como una cadena) se vería así:

num_list[-9:]

Cuando veo esto, leo la parte entre paréntesis como "noveno desde el final hasta el final". (En realidad, lo abrevio mentalmente como "-9, en")

Explicación:

La notación completa es

sequence[start:stop:step]

Pero el colon es lo que le dice a Python que le está dando una porción y no un índice regular. Es por eso que la forma idiomática de copiar listas en Python 2 es

list_copy = sequence[:]

Y limpiarlos es con:

del my_list[:]

(Listas get list.copyy list.clearen Python 3.)

¡Dale a tus rebanadas un nombre descriptivo!

Puede resultarle útil separar la formación de la porción de pasarla al list.__getitem__método ( eso es lo que hacen los corchetes ). Incluso si no es nuevo en él, mantiene su código más legible para que otros que tengan que leer su código puedan comprender más fácilmente lo que está haciendo.

Sin embargo, no puede simplemente asignar algunos enteros separados por dos puntos a una variable. Necesita usar el objeto de corte:

last_nine_slice = slice(-9, None)

Se Nonerequiere el segundo argumento, de modo que el primer argumento se interprete como el startargumento; de lo contrario, sería el stopargumento .

Luego puede pasar el objeto de corte a su secuencia:

>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]

islice

islicedesde el módulo itertools es otra forma posiblemente performante de obtener esto. isliceno toma argumentos negativos, por lo que idealmente su iterable tiene un __reversed__método especial, que la lista sí tiene, por lo que primero debe pasar su lista (o iterable __reversed__) reversed.

>>> from itertools import islice
>>> islice(reversed(range(100)), 0, 9)
<itertools.islice object at 0xffeb87fc>

islice permite una evaluación diferida de la tubería de datos, por lo que para materializar los datos, páselos a un constructor (como list):

>>> list(islice(reversed(range(100)), 0, 9))
[99, 98, 97, 96, 95, 94, 93, 92, 91]

Los últimos 9 elementos se pueden leer de izquierda a derecha usando la lista numérica [-9:], o de derecha a izquierda usando la lista numérica [: - 10: -1], según lo desee.

>>> a=range(17)
>>> print a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
>>> print a[-9:]
[8, 9, 10, 11, 12, 13, 14, 15, 16]
>>> print a[:-10:-1]
[16, 15, 14, 13, 12, 11, 10, 9, 8]

Aquí hay varias opciones para obtener los elementos de "cola" de un iterable:

Dado

n = 9
iterable = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Salida deseada

[2, 3, 4, 5, 6, 7, 8, 9, 10]

Código

Obtenemos el último resultado utilizando cualquiera de las siguientes opciones:

from collections import deque
import itertools

import more_itertools


# A: Slicing
iterable[-n:]


# B: Implement an itertools recipe
def tail(n, iterable):
    """Return an iterator over the last *n* items of *iterable*.

        >>> t = tail(3, 'ABCDEFG')
        >>> list(t)
        ['E', 'F', 'G']

    """
    return iter(deque(iterable, maxlen=n))
list(tail(n, iterable))


# C: Use an implemented recipe, via more_itertools
list(more_itertools.tail(n, iterable))


# D: islice, via itertools
list(itertools.islice(iterable, len(iterable)-n, None))


# E: Negative islice, via more_itertools
list(more_itertools.islice_extended(iterable, -n, None))

Detalles

• A. El corte tradicional de Python es inherente al lenguaje. Esta opción funciona con secuencias como cadenas, listas y tuplas. Sin embargo, este tipo de corte no funciona en iteradores , por ejemplo iter(iterable).
• B. Una itertoolsreceta . Se generaliza para trabajar en cualquier iterable y resuelve el problema del iterador en la última solución. Esta receta debe implementarse manualmente ya que no está oficialmente incluida en el itertoolsmódulo.
• C. Muchas recetas, incluida la última herramienta (B), se han implementado convenientemente en paquetes de terceros. Instalar e importar estas bibliotecas evita la implementación manual. Una de estas bibliotecas se llama more_itertools(instalar mediante > pip install more-itertools); ver more_itertools.tail.
• D. Un miembro de la itertoolsbiblioteca. Tenga en cuenta itertools.islice que no admite cortes negativos .
• E. Se implementa otra herramienta more_itertoolsque se generaliza itertools.islicepara admitir el corte negativo; ver more_itertools.islice_extended.

¿Cuál uso?

Depende . En la mayoría de los casos, la división (opción A, como se menciona en otras respuestas) es la opción más simple, ya que está integrada en el lenguaje y admite la mayoría de los tipos iterables. Para iteradores más generales, use cualquiera de las opciones restantes. Tenga en cuenta que las opciones C y E requieren la instalación de una biblioteca de terceros, que algunos usuarios pueden encontrar útil.