Python Language
Indexación y corte

Sintaxis

• obj [inicio: detener: paso]
• cortar
• rebanada (inicio, parada [, paso])

Parámetros

Observaciones

Rebanado basico

Para cualquier iterable (por ejemplo, una cadena, lista, etc.), Python le permite dividir y devolver una subcadena o una lista secundaria de sus datos.

Formato para rebanar:

iterable_name[start:stop:step]

dónde,

• start es el primer índice de la rebanada. Por defecto es 0 (el índice del primer elemento)
• stop uno más allá del último índice de la rebanada. Por defecto a len (iterable)
• step es el tamaño del paso (mejor explicado por los ejemplos a continuación)

Ejemplos:

a = "abcdef"
a            # "abcdef" 
             # Same as a[:] or a[::] since it uses the defaults for all three indices
a[-1]        # "f"
a[:]         # "abcdef" 
a[::]        # "abcdef" 
a[3:]        # "def" (from index 3, to end(defaults to size of iterable)) 
a[:4]        # "abcd" (from beginning(default 0) to position 4 (excluded)) 
a[2:4]       # "cd" (from position 2, to position 4 (excluded)) 

Además, cualquiera de los anteriores se puede utilizar con el tamaño de paso definido:

a[::2]       # "ace" (every 2nd element)
a[1:4:2]     # "bd" (from index 1, to index 4 (excluded), every 2nd element)

Los índices pueden ser negativos, en cuyo caso se calculan desde el final de la secuencia.

a[:-1]     # "abcde" (from index 0 (default), to the second last element (last element - 1))
a[:-2]     # "abcd" (from index 0 (default), to the third last element (last element -2))
a[-1:]     # "f" (from the last element to the end (default len()) 

Los tamaños de los pasos también pueden ser negativos, en cuyo caso la división se repetirá en orden inverso:

a[3:1:-1]   # "dc" (from index 2 to None (default), in reverse order)

Este constructo es útil para revertir un iterable.

a[::-1]     # "fedcba" (from last element (default len()-1), to first, in reverse order(-1))

Tenga en cuenta que para los pasos negativos, el end_index predeterminado es None (consulte http://stackoverflow.com/a/12521981 )

a[5:None:-1] # "fedcba" (this is equivalent to a[::-1])
a[5:0:-1]    # "fedcb" (from the last element (index 5) to second element (index 1)

Hacer una copia superficial de una matriz

Una forma rápida de hacer una copia de una matriz (en lugar de asignar una variable con otra referencia a la matriz original) es:

arr[:]

Vamos a examinar la sintaxis. [:] Medios que start , end , y slice están omitidos. Los valores predeterminados son 0 , len(arr) y 1 , respectivamente, lo que significa que el subarreglo que solicitamos tendrá todos los elementos de arr desde el principio hasta el final.

En la práctica, esto se parece a algo como:

arr = ['a', 'b', 'c']
copy = arr[:]
arr.append('d')
print(arr)    # ['a', 'b', 'c', 'd']
print(copy)   # ['a', 'b', 'c']

Como puede ver, arr.append('d') agregó d a arr , ¡pero la copy mantuvo sin cambios!

Tenga en cuenta que esto hace una copia superficial y es idéntico a arr.copy() .

Invertir un objeto

Puede usar cortes para revertir muy fácilmente una str , list o tuple (o básicamente cualquier objeto de colección que implemente el corte con el parámetro de paso). Este es un ejemplo de inversión de una cadena, aunque esto se aplica igualmente a los otros tipos mencionados anteriormente:

s = 'reverse me!'
s[::-1]    # '!em esrever'

Veamos rápidamente la sintaxis. [::-1] significa que la división debe ser desde el principio hasta el final de la cadena (porque se omiten el start y el end ) y un paso de -1 significa que debe moverse a través de la cadena en sentido inverso.

Clases personalizadas de indexación: __getitem__, __setitem__ y __delitem__

class MultiIndexingList:
    def __init__(self, value):
        self.value = value
        
    def __repr__(self):
        return repr(self.value)
    
    def __getitem__(self, item):
        if isinstance(item, (int, slice)):
            return self.__class__(self.value[item])
        return [self.value[i] for i in item]
    
    def __setitem__(self, item, value):
        if isinstance(item, int):
            self.value[item] = value
        elif isinstance(item, slice):
            raise ValueError('Cannot interpret slice with multiindexing')
        else:
            for i in item:
                if isinstance(i, slice):
                    raise ValueError('Cannot interpret slice with multiindexing')
                self.value[i] = value
    
    def __delitem__(self, item):
        if isinstance(item, int):
            del self.value[item]
        elif isinstance(item, slice):
            del self.value[item]
        else:
            if any(isinstance(elem, slice) for elem in item):
                raise ValueError('Cannot interpret slice with multiindexing')
            item = sorted(item, reverse=True)
            for elem in item:
                del self.value[elem]

Esto permite el corte y la indexación para el acceso al elemento:

a = MultiIndexingList([1,2,3,4,5,6,7,8])
a
# Out: [1, 2, 3, 4, 5, 6, 7, 8]
a[1,5,2,6,1]
# Out: [2, 6, 3, 7, 2]
a[4, 1, 5:, 2, ::2]
# Out: [5, 2, [6, 7, 8], 3, [1, 3, 5, 7]]
#       4|1-|----50:---|2-|-----::2-----   <-- indicated which element came from which index

Al configurar y eliminar elementos solo se permite la indexación de enteros separados por comas (sin rebanar):

a[4] = 1000
a
# Out: [1, 2, 3, 4, 1000, 6, 7, 8]
a[2,6,1] = 100
a
# Out: [1, 100, 100, 4, 1000, 6, 100, 8]
del a[5]
a
# Out: [1, 100, 100, 4, 1000, 100, 8]
del a[4,2,5]
a
# Out: [1, 100, 4, 8]

Asignación de rebanada

Otra característica interesante que utiliza los segmentos es la asignación de sectores. Python le permite asignar nuevos segmentos para reemplazar los segmentos antiguos de una lista en una sola operación.

Esto significa que si tiene una lista, puede reemplazar varios miembros en una sola tarea:

lst = [1, 2, 3]
lst[1:3] = [4, 5]
print(lst) # Out: [1, 4, 5]

La asignación tampoco debe coincidir en tamaño, por lo que si desea reemplazar una porción antigua por una nueva que es de tamaño diferente, podría:

lst = [1, 2, 3, 4, 5]
lst[1:4] = [6]
print(lst) # Out: [1, 6, 5]

También es posible usar la sintaxis de corte conocida para hacer cosas como reemplazar toda la lista:

lst = [1, 2, 3]
lst[:] = [4, 5, 6]
print(lst) # Out: [4, 5, 6]

O solo los dos últimos miembros:

lst = [1, 2, 3]
lst[-2:] = [4, 5, 6]
print(lst) # Out: [1, 4, 5, 6]

Rebanar objetos

Los cortes son objetos en sí mismos y se pueden almacenar en variables con la función de slice() incorporada. Las variables de división se pueden usar para hacer que su código sea más legible y para promover la reutilización.

>>> programmer_1 = [ 1956, 'Guido', 'van Rossum', 'Python', 'Netherlands']
>>> programmer_2 = [ 1815, 'Ada', 'Lovelace', 'Analytical Engine', 'England']
>>> name_columns = slice(1, 3)
>>> programmer_1[name_columns]
['Guido', 'van Rossum']
>>> programmer_2[name_columns]
['Ada', 'Lovelace']

Indexación básica

Las listas de Python están basadas en 0, es decir, se puede acceder al primer elemento de la lista mediante el índice 0

arr = ['a', 'b', 'c', 'd']
print(arr[0])
>> 'a'

Puede acceder al segundo elemento de la lista por índice 1 , tercer elemento por índice 2 y así sucesivamente:

print(arr[1])
>> 'b'
print(arr[2])
>> 'c'

También puede usar índices negativos para acceder a los elementos del final de la lista. p.ej. El índice -1 le dará el último elemento de la lista y el índice -2 le dará el segundo elemento de la lista:

print(arr[-1])
>> 'd'
print(arr[-2])
>> 'c'

Si intenta acceder a un índice que no está presente en la lista, se IndexError un IndexError :

print arr[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range