Python Language
Indexeren en segmenteren

Syntaxis

• obj [start: stop: stap]
• slice (stop)
• segment (start, stop [, stap])

parameters

Opmerkingen

Basis snijden

Voor elke iterabele (bijvoorbeeld een string, lijst, enz.), Kunt u met Python een substring of sublijst van zijn gegevens segmenteren en teruggeven.

Formaat voor het snijden:

iterable_name[start:stop:step]

waar,

• start is de eerste index van het segment. Standaard ingesteld op 0 (de index van het eerste element)
• stop een voorbij de laatste index van het segment. Standaard ingesteld op len (iterabel)
• step is de stapgrootte (beter uitgelegd door de onderstaande voorbeelden)

Voorbeelden:

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

Bovendien kan elk van de bovenstaande worden gebruikt met de gedefinieerde stapgrootte:

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

Indices kunnen negatief zijn, in welk geval ze worden berekend vanaf het einde van de reeks

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

Stapgroottes kunnen ook negatief zijn, in welk geval segment de lijst in omgekeerde volgorde doorloopt:

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

Deze constructie is handig voor het omkeren van een iterabel

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

Merk op dat voor negatieve stappen de standaard end_index None (zie 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)

Een ondiepe kopie van een array maken

Een snelle manier om een kopie van een array te maken (in tegenstelling tot het toewijzen van een variabele met een andere verwijzing naar de oorspronkelijke array) is:

arr[:]

Laten we de syntaxis onderzoeken. [:] betekent dat start , end en slice allemaal zijn weggelaten. Ze staan standaard op respectievelijk 0 , len(arr) en 1 , wat betekent dat de subarray waar we om vragen alle elementen van arr van het begin tot het einde zal hebben.

In de praktijk ziet dit er ongeveer zo uit:

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

Zoals je kunt zien, heeft arr.append('d') d toegevoegd aan arr , maar de copy is ongewijzigd gebleven!

Merk op dat dit een ondiepe kopie is en identiek is aan arr.copy() .

Een object omkeren

U kunt segmenten gebruiken om een str , list of tuple heel gemakkelijk om te keren (of in principe elk verzamelobject dat segmentering met de parameter step implementeert). Hier is een voorbeeld van het omkeren van een string, hoewel dit ook van toepassing is op de andere hierboven vermelde typen:

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

Laten we snel naar de syntaxis kijken. [::-1] betekent dat de plak van het begin tot het einde van de string moet zijn (omdat start en end worden weggelaten) en een stap van -1 betekent dat deze in omgekeerde volgorde door de string moet gaan.

Aangepaste klassen indexeren: __getitem__, __setitem__ en __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]

Dit maakt segmentering en indexering voor elementtoegang mogelijk:

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

Tijdens het instellen en verwijderen van elementen is alleen komma-gescheiden geheel getalindexering mogelijk (geen segmentering):

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]

Segment opdracht

Een andere handige functie met plakjes is plaktoewijzing. Met Python kunt u in één bewerking nieuwe segmenten toewijzen om oude segmenten van een lijst te vervangen.

Dit betekent dat als u een lijst hebt, u meerdere leden in één opdracht kunt vervangen:

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

De opdracht moet ook niet qua grootte overeenkomen, dus als je een oud segment wilt vervangen door een nieuw segment met een andere grootte, kun je:

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

Het is ook mogelijk om de bekende slicingsyntaxis te gebruiken om dingen te doen zoals het vervangen van de hele lijst:

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

Of alleen de laatste twee leden:

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

Plak objecten

Segmenten zijn objecten op zichzelf en kunnen in variabelen worden opgeslagen met de ingebouwde slice() -functie. Segmentvariabelen kunnen worden gebruikt om uw code leesbaarder te maken en hergebruik te bevorderen.

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

Basisindexering

Python-lijsten zijn gebaseerd op 0, dat wil zeggen dat het eerste element in de lijst toegankelijk is voor de index 0

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

U kunt het tweede element in de lijst openen via index 1 , het derde element via index 2 enzovoort:

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

U kunt ook negatieve indexen gebruiken om toegang te krijgen tot elementen aan het einde van de lijst. bv. index -1 geeft u het laatste element van de lijst en index -2 geeft u het voorlaatste element van de lijst:

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

Als u toegang probeert te krijgen tot een index die niet in de lijst IndexError , wordt een IndexError :

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