Python Language
Indexation et découpage

Syntaxe

• obj [start: stop: step]
• tranche
• tranche (démarrer, arrêter [, étape])

Paramètres

Remarques

Tranchage de base

Pour toute itération (par exemple, une chaîne, une liste, etc.), Python vous permet de découper et de retourner une sous-chaîne ou une sous-liste de ses données.

Format de découpage:

iterable_name[start:stop:step]

où,

• start est le premier index de la tranche. La valeur par défaut est 0 (l'index du premier élément)
• stop vous au-delà du dernier index de la tranche. La valeur par défaut est len ​​(itérable)
• step est la taille de l'étape (mieux expliquée par les exemples ci-dessous)

Exemples:

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

En outre, l'un des éléments ci-dessus peut être utilisé avec la taille de pas définie:

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

Les indices peuvent être négatifs, auquel cas ils sont calculés à partir de la fin de la séquence

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()) 

Les tailles d'étape peuvent également être négatives, auquel cas la tranche parcourra la liste dans l'ordre inverse:

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

Cette construction est utile pour inverser une itération

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

Notez que pour les étapes négatives, end_index par défaut est None (voir 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)

Faire une copie superficielle d'un tableau

Un moyen rapide de faire une copie d'un tableau (par opposition à l'attribution d'une variable avec une autre référence au tableau d'origine) est la suivante:

arr[:]

Examinons la syntaxe. [:] signifie que start , end et slice sont tous omis. Ils sont par défaut à 0 , len(arr) et 1 , respectivement, ce qui signifie que le sous-tableau que nous demandons aura tous les éléments de arr du début à la fin.

En pratique, cela ressemble à quelque chose comme:

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

Comme vous pouvez le voir, arr.append('d') ajouté d à arr , mais la copy est restée inchangée!

Notez que cela fait une copie superficielle et est identique à arr.copy() .

Inverser un objet

Vous pouvez utiliser des tranches pour inverser très facilement un str , une list ou un tuple (ou, fondamentalement, tout objet de collection qui implémente le découpage en tranches avec le paramètre step). Voici un exemple d'inversion d'une chaîne, bien que cela s'applique également aux autres types répertoriés ci-dessus:

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

Regardons rapidement la syntaxe. [::-1] signifie que la tranche doit être du début jusqu'à la fin de la chaîne (parce que start et end sont omis) et une étape de -1 signifie qu'elle doit se déplacer dans la chaîne en sens inverse.

Indexation des classes personnalisées: __getitem__, __setitem__ et __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]

Cela permet de trancher et d'indexer pour l'accès aux éléments:

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

Lorsque la définition et la suppression d'éléments ne permettent que l'indexation d'entiers séparés par des virgules (sans découpage):

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]

Assignation de tranche

Une autre fonctionnalité intéressante utilisant des tranches est l’affectation des tranches. Python vous permet d'affecter de nouvelles tranches pour remplacer les anciennes tranches d'une liste en une seule opération.

Cela signifie que si vous avez une liste, vous pouvez remplacer plusieurs membres dans une seule tâche:

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

L'affectation ne doit pas non plus correspondre à la taille, donc si vous voulez remplacer une ancienne tranche par une nouvelle tranche de taille différente, vous pouvez:

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

Il est également possible d'utiliser la syntaxe de découpage connue pour faire des choses comme remplacer la liste entière:

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

Ou seulement les deux derniers membres:

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

Trancher des objets

Les tranches sont des objets en elles-mêmes et peuvent être stockées dans des variables avec la fonction slice() intégrée. Les variables Slice peuvent être utilisées pour rendre votre code plus lisible et pour promouvoir la réutilisation.

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

Indexation de base

Les listes Python sont basées sur 0, c'est-à- dire que le premier élément de la liste est accessible par l'index 0

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

Vous pouvez accéder au deuxième élément de la liste par index 1 , troisième élément par index 2 et ainsi de suite:

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

Vous pouvez également utiliser des index négatifs pour accéder aux éléments depuis la fin de la liste. par exemple. index -1 vous donnera le dernier élément de la liste et l'index -2 vous donnera l'avant-dernier élément de la liste:

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

Si vous essayez d'accéder à un index qui n'est pas présent dans la liste, une IndexError sera IndexError :

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