Python Language
Indeksowanie i krojenie

Składnia

• obj [start: stop: step]
• plasterek (stop)
• plasterek (start, stop [, krok])

Parametry

Uwagi

Podstawowe krojenie

W przypadku dowolnej iterowalnej (np. Ciąg, lista itp.) Python pozwala wycinać i zwracać podciąg lub podlistę swoich danych.

Format krojenia:

iterable_name[start:stop:step]

gdzie,

• start jest pierwszym indeksem wycinka. Domyślnie 0 (indeks pierwszego elementu)
• stop za ostatnim indeksem plastra. Domyślnie len (iterowalny)
• step to rozmiar kroku (lepiej wyjaśniony w poniższych przykładach)

Przykłady:

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

Ponadto można zastosować dowolną z powyższych opcji ze zdefiniowanym rozmiarem kroku:

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

Wskaźniki mogą być ujemne, w takim przypadku są obliczane od końca sekwencji

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

Rozmiary kroków mogą być również ujemne, w takim przypadku plasterek będzie iterował listę w odwrotnej kolejności:

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

Ta konstrukcja jest przydatna do odwracania iterowalnego

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

Zauważ, że dla kroków ujemnych domyślnym end_index jest None (patrz 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)

Wykonywanie płytkiej kopii tablicy

Szybki sposób na wykonanie kopii tablicy (w przeciwieństwie do przypisywania zmiennej z innym odwołaniem do oryginalnej tablicy) to:

arr[:]

Przeanalizujmy składnię. [:] oznacza, że pomija się start , end i slice . Domyślnie mają odpowiednio 0 , len(arr) i 1 , co oznacza, że żądana podtablica będzie zawierała wszystkie elementy arr od początku do samego końca.

W praktyce wygląda to tak:

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

Jak widać, arr.append('d') dodał d do arr , ale copy pozostała niezmieniona!

Zauważ, że tworzy to płytką kopię i jest identyczna z arr.copy() .

Odwracanie obiektu

Możesz użyć wycinków, aby bardzo łatwo odwrócić str , list lub tuple (lub w zasadzie dowolny obiekt kolekcji, który implementuje wycinanie z parametrem step). Oto przykład odwrócenia ciągu, chociaż dotyczy to również innych typów wymienionych powyżej:

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

Spójrzmy szybko na składnię. [::-1] oznacza, że plasterek powinien znajdować się od początku do końca łańcucha (ponieważ start i end są pominięte), a krok -1 oznacza, że powinien on przechodzić przez łańcuch w odwrotnej kolejności.

Indeksowanie klas niestandardowych: __getitem__, __setitem__ i __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]

Umożliwia to dzielenie i indeksowanie dostępu do elementu:

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

Chociaż ustawianie i usuwanie elementów pozwala tylko na indeksowanie liczb całkowitych oddzielonych przecinkami (bez krojenia):

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]

Przydział plasterków

Kolejną ciekawą funkcją używania plasterków jest przypisywanie plasterków. Python pozwala przypisywać nowe wycinki w celu zastąpienia starych wycinków listy w jednej operacji.

Oznacza to, że jeśli masz listę, możesz zastąpić wielu członków w jednym zadaniu:

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

Przypisanie również nie powinno pasować do rozmiaru, więc jeśli chcesz zastąpić stary wycinek nowym wycięciem o innym rozmiarze, możesz:

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

Można również użyć znanej składni krojenia, aby wykonać takie czynności, jak zamiana całej listy:

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

Lub tylko dwóch ostatnich członków:

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

Pokrój obiekty

Plasterki same w sobie są obiektami i mogą być przechowywane w zmiennych za pomocą wbudowanej funkcji slice() . Zmiennych plastra można użyć, aby uczynić kod bardziej czytelnym i promować ponowne użycie.

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

Podstawowe indeksowanie

Listy w języku Python są oparte na 0, tzn. Do pierwszego elementu na liście można uzyskać indeks 0

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

Możesz uzyskać dostęp do drugiego elementu na liście według indeksu 1 , trzeciego elementu według indeksu 2 i tak dalej:

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

Możesz także użyć indeksów ujemnych, aby uzyskać dostęp do elementów z końca listy. na przykład. indeks -1 da ci ostatni element listy, a indeks -2 da ci ostatni do ostatniego element listy:

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

Jeśli spróbujesz uzyskać dostęp do indeksu, którego nie ma na liście, pojawi się błąd IndexError :

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