Python Language
Indizieren und Schneiden

Syntax

• obj [start: stop: step]
• Slice (Stop)
• Slice (Start, Stop [, Schritt])

Parameter

Bemerkungen

Grundschneiden

Bei jedem iterierbaren Element (z. B. einer Zeichenfolge, Liste usw.) können Sie in Python einen Teilstring oder eine Unterliste seiner Daten abschneiden und zurückgeben.

Format für das Schneiden:

iterable_name[start:stop:step]

woher,

• start ist der erste Index des Slice. Standardeinstellung ist 0 (der Index des ersten Elements)
• stop einen Punkt nach dem letzten Index des Slice. Standardeinstellung auf len (iterable)
• step ist die Schrittgröße (besser erklärt durch die Beispiele unten)

Beispiele:

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

Darüber hinaus kann eine der oben genannten Funktionen mit der definierten Schrittgröße verwendet werden:

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

Indizes können negativ sein. In diesem Fall werden sie vom Ende der Sequenz aus berechnet

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

Schrittgrößen können auch negativ sein. In diesem Fall durchläuft Slice die Liste in umgekehrter Reihenfolge:

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

Dieses Konstrukt ist nützlich, um eine Wiederholung rückgängig zu machen

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

Beachten Sie, dass für negative Schritte der Standardwert end_index None (siehe 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)

Erstellen einer flachen Kopie eines Arrays

Eine schnelle Methode zum Erstellen einer Kopie eines Arrays (im Gegensatz zum Zuweisen einer Variablen mit einem anderen Verweis auf das ursprüngliche Array) ist:

arr[:]

Untersuchen wir die Syntax. [:] bedeutet, dass start , end und slice alle weggelassen werden. Der Standardwert ist 0 , len(arr) und 1 , was bedeutet, dass das von uns angeforderte Unterfeld alle Elemente von arr vom Anfang bis zum Ende enthält.

In der Praxis sieht das so aus:

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

Wie Sie sehen, hat arr.append('d') d zu arr hinzugefügt, aber die copy blieb unverändert!

Beachten Sie, dass dies eine flache Kopie ist und mit arr.copy() identisch ist.

Objekt umkehren

Sie können Slices verwenden, um einen str , eine list oder ein tuple (oder im Grunde jedes Sammlungsobjekt, das das Slicing mit dem Parameter step implementiert) sehr einfach umzukehren. Hier ein Beispiel zum Umkehren eines Strings, obwohl dies auch für die anderen oben aufgeführten Typen gilt:

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

Sehen wir uns kurz die Syntax an. [::-1] bedeutet, dass das Slice vom Anfang bis zum Ende der Zeichenfolge sein sollte (da start und end sind) und ein Schritt von -1 bedeutet, dass es sich umgekehrt durch die Zeichenfolge bewegen soll.

Indizierung benutzerdefinierter Klassen: __getitem__, __setitem__ und __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]

Dies ermöglicht das Aufteilen und Indizieren für den Elementzugriff:

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

Während das Setzen und Löschen von Elementen nur die durch Kommas getrennte ganzzahlige Indizierung zulässt (keine Teilung):

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]

Slice-Zuordnung

Ein weiteres nettes Feature, das Slices verwendet, ist die Slice-Zuweisung. Mit Python können Sie neue Slices zuweisen, um alte Slices einer Liste in einem einzigen Vorgang zu ersetzen.

Das heißt, wenn Sie eine Liste haben, können Sie mehrere Mitglieder in einer einzigen Zuweisung ersetzen:

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

Die Zuweisung sollte auch in der Größe nicht übereinstimmen. Wenn Sie also ein altes Slice durch ein neues Slice ersetzen möchten, das sich in der Größe unterscheidet, können Sie Folgendes tun:

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

Es ist auch möglich, die bekannte Slicing-Syntax zu verwenden, um beispielsweise die gesamte Liste zu ersetzen:

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

Oder nur die letzten beiden Mitglieder:

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

Schneiden Sie Objekte

Slices sind Objekte in sich und können mit der eingebauten Funktion slice() in Variablen gespeichert werden. Slice-Variablen können verwendet werden, um den Code lesbarer zu machen und die Wiederverwendung zu fördern.

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

Grundlegende Indizierung

Python-Listen sind 0-basiert, dh das erste Element in der Liste kann über den Index 0 aufgerufen werden

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

Auf das zweite Element in der Liste können Sie über Index 1 zugreifen, das dritte Element auf Index 2 usw.

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

Sie können negative Indizes auch verwenden, um auf Elemente vom Ende der Liste aus zuzugreifen. z.B. Index -1 gibt Ihnen das letzte Element der Liste und Index -2 gibt Ihnen das vorletzte Element der Liste:

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

Wenn Sie versuchen, auf einen Index zuzugreifen, der nicht in der Liste enthalten ist, wird ein IndexError :

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