Python Language
Indexering och skivning

Syntax

• obj [start: stopp: steg]
• slice (stopp)
• skiva (start, stopp [, steg])

parametrar

Anmärkningar

Grundläggande skivning

För alla iterabla (för t.ex. en sträng, lista osv.) Låter Python dig skiva och returnera en substring eller underlista över dess data.

Format för skivning:

iterable_name[start:stop:step]

var,

• start är skivans första index. Standardvärdet till 0 (indexet för det första elementet)
• stop en förbi skivets sista index. Standardvärde för len (iterable)
• step är stegstorleken (bättre förklaras av exemplen nedan)

Exempel:

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

Dessutom kan vilken som helst av ovanstående användas med stegstorleken definierad:

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

Index kan vara negativa, i vilket fall beräknas de från slutet av sekvensen

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

Stegstorlekar kan också vara negativa, i vilket fall skivan kommer att upprepas genom listan i omvänd ordning:

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

Denna konstruktion är användbar för att vända en iterable

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

Observera att för negativa steg är standard end_index None (se 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)

Gör en ytlig kopia av en matris

Ett snabbt sätt att göra en kopia av en matris (i motsats till att tilldela en variabel med en annan referens till den ursprungliga matrisen) är:

arr[:]

Låt oss undersöka syntaxen. [:] betyder att alla start , end och slice utelämnas. De har som standard 0 , len(arr) respektive 1 , vilket innebär att subarray som vi begär kommer att ha alla elementen i arr från början till slutet.

I praktiken ser det ut som:

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

Som ni kan arr.append('d') d till arr , men copy förblev oförändrad!

Observera att detta gör en ytlig kopia och är identisk med arr.copy() .

Omvända ett objekt

Du kan använda skivor för att mycket enkelt vända en str , list eller tuple (eller i princip alla samlingsobjekt som implementerar skivning med stegparametern). Här är ett exempel på att vända en sträng, även om detta gäller lika för de andra typerna ovan:

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

Låt oss snabbt titta på syntaxen. [::-1] betyder att skivan bör vara från början till slutet av strängen (eftersom start och end är utelämnad) och ett steg på -1 betyder att det bör röra sig genom strängen i omvänd riktning.

Indexera anpassade klasser: __getitem__, __setitem__ och __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]

Detta tillåter skärning och indexering för elementåtkomst:

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

Medan inställning och radering av element endast tillåts komma-separerad heltalindexering (ingen skivning):

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]

Skiva tilldelning

En annan snygg funktion med skivor är skivtilldelning. Python låter dig tilldela nya skivor för att ersätta gamla skivor i en lista i en enda operation.

Detta innebär att om du har en lista kan du ersätta flera medlemmar i en enda tilldelning:

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

Uppgiften ska inte matcha i storlek också, så om du ville ersätta en gammal skiva med en ny skiva som är annorlunda i storlek kan du:

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

Det är också möjligt att använda den kända skivsyntaxen för att göra saker som att ersätta hela listan:

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

Eller bara de två sista medlemmarna:

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

Skiva föremål

Skivor är föremål i sig själva och kan lagras i variabler med den inbyggda slice() . Skivvariabler kan användas för att göra din kod mer läsbar och för att främja återanvändning.

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

Grundläggande indexering

Python-listor är 0-baserade, dvs det första elementet i listan kan nås av index 0

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

Du kan komma åt det andra elementet i listan med index 1 , tredje elementet med index 2 och så vidare:

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

Du kan också använda negativa index för att komma åt element från slutet av listan. t.ex. index -1 ger dig det sista elementet i listan och index -2 ger dig det näst till sista elementet i listan:

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

Om du försöker komma åt ett index som inte finns i listan kommer en IndexError att höjas:

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