Ein umfassendes Verständnis der Python-Slicing-Operationen in einem Artikel

Bei der Verwendung von Python zur Lösung verschiedener praktischer Probleme stoßen wir häufig auf die Situation, Teilwerte aus einem Objekt zu extrahieren. Der Slicing-Vorgang wird speziell dazu verwendet Operation. mächtige Waffe. Theoretisch kann jeder Zielwert durch einen oder mehrere Slicing-Vorgänge erhalten werden, solange der bedingte Ausdruck geeignet ist. Die grundlegende Syntax von Slicing-Operationen ist relativ einfach, aber wenn die interne Logik nicht vollständig verstanden wird, können leicht Fehler auftreten, und solche Fehler sind manchmal tief verborgen und schwer zu erkennen. Dieser Artikel fasst verschiedene Situationen von Slicing-Vorgängen anhand detaillierter Beispiele zusammen. Wenn es Fehler oder Mängel gibt, korrigieren Sie mich bitte!

1. Die Indizierungsmethode der schneidbaren Objekte von Python

Die Indizierungsmethode der schneidbaren Objekte von Python umfasst: positiven Index und negativen Index.

Wie in der folgenden Abbildung gezeigt, nehmen wir a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] als Beispiel:

2. Allgemeine Methode der Python-Slicing-Operation

Ein vollständiger Slicing-Ausdruck enthält zwei „:“, die zum Trennen von drei Parametern (Start_Index, End_Index, Schritt) verwendet werden Es gibt nur ein „:“, der standardmäßige dritte Parameter „step=1“.

Grundlegender Ausdruck für den Slicing-Vorgang: object[start_index : end_index : step]

step: Es können sowohl positive als auch negative Zahlen verwendet werden, die die „Schrittgröße“ beim Schneiden von Daten bestimmen. und Die positiven und negativen Vorzeichen bestimmen die „Schnittrichtung“, positiv bedeutet Wertannahme „von links nach rechts“, negativ bedeutet Wertannahme „von rechts nach links“. Wenn der Schritt weggelassen wird, ist der Standardwert 1, d. h. der Wert wird in Schritten von 1 von links nach rechts übernommen. „Die Schnittrichtung ist sehr wichtig!“ „Die Schnittrichtung ist sehr wichtig!“ Sagen Sie dreimal Wichtiges!

start_index: Gibt den Startindex an (einschließlich des Index selbst); wenn dieser Parameter weggelassen wird, bedeutet dies, dass vom „Endpunkt“ des Objekts aus gestartet wird „Endpunkt“, er wird durch Schritt bestimmt. Die positiven und negativen Parameter bestimmen den Schritt. Wenn der Schritt positiv ist, beginnt er am „Startpunkt“, und wenn er negativ ist, beginnt er am „Endpunkt“.

end_index: Gibt den Endindex an (mit Ausnahme des Index selbst); wenn dieser Parameter weggelassen wird, bedeutet dies, dass die Daten bis zum „Endpunkt“ oder bis zum Erreichen des „Startpunkts“ übernommen werden „Endpunkt“, es wird auch durch den Schrittparameter bestimmt. Bestimmt durch positiv oder negativ, wenn der Schritt positiv ist, geht er zum „Endpunkt“, und wenn er negativ ist, geht er zum „Startpunkt“.

3. Detaillierte Beispiele für Python-Slicing-Operationen

Die folgenden Beispiele basieren auf der Liste a = [0, 1, 2, 3, 4, 5, 6 , 7, 8 , 9] Zum Beispiel:

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

1. Schneiden Sie einen einzelnen Wert aus

>>> a[0]
0
>>> a[-4]
6

2. Schneiden Sie das gesamte Objekt aus

>>> a[:] # 从左往右
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[::] # 从左往右
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[::-1] # 从右往左
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

3 positive (+) Indizes Situation

>>> a[1:6] # step=1，从左往右取值，start_index=1到end_index=6同样表示从左往右取值。
[1, 2, 3, 4, 5]
>>>a[1:6:-1] # step=-1，决定了从右往左取值，而start_index=1到end_index=6决定了从左往右取值，两者矛盾。
>>> [] # 输出为空列表，说明没取到数据。
>>>a[6:1] # step=1，决定了从左往右取值，而start_index=6到end_index=1决定了从右往左取值，两者矛盾。
>>> [] # 同样输出为空列表。
>>>a[:6] # step=1，从左往右取值，从“起点”开始一直取到end_index=6。
>>> [0, 1, 2, 3, 4, 5]
>>>a[:6:-1] # step=-1，从右往左取值，从“终点”开始一直取到end_index=6。
>>> [9, 8, 7]
>>>a[6:] # step=1，从左往右取值，从start_index=6开始，一直取到“终点”。
>>> [6, 7, 8, 9]
>>>a[6::-1] # step=-1，从右往左取值，从start_index=6开始，一直取到“起点”。
>>> [6, 5, 4, 3, 2, 1, 0]

Verwandte Empfehlungen: „Python-Video-Tutorial“

Der Fall, in dem start_index und end_index beide negative (-) Indizes sind

>>>a[-1:-6] # step=1，从左往右取值，而start_index=-1到end_index=-6决定了从右往左取值，两者矛盾。
>>> []
>>>a[-1:-6:-1] # step=-1，从右往左取值，start_index=-1到end_index=-6同样是从右往左取值。
>>> [9, 8, 7, 6, 5]
>>>a[-6:-1] # step=1，从左往右取值，而start_index=-6到end_index=-1同样是从左往右取值。
>>> [4, 5, 6, 7, 8]
>>>a[:-6] # step=1，从左往右取值，从“起点”开始一直取到end_index=-6。
>>> [0, 1, 2, 3]
>>>a[:-6:-1] # step=-1，从右往左取值，从“终点”开始一直取到end_index=-6。
>>> [9, 8, 7, 6, 5]
>>>a[-6:] # step=1，从左往右取值，从start_index=-6开始，一直取到“终点”。
>>> [4, 5, 6, 7, 8, 9]
>>>a[-6::-1] # step=-1，从右往左取值，从start_index=-6开始，一直取到“起点”。
>>> [4, 3, 2, 1, 0]

5 .Start_index und end_index positiv (+) negativ (-) gemischter Index

>>>a[1:-6] # start_index=1在end_index=-6的左边，因此从左往右取值，而step=1同样决定了从左往右取值。
>>> [1, 2, 3]
>>>a[1:-6:-1] # start_index=1在end_index=-6的左边，因此从左往右取值，但step=-则决定了从右往左取值，两者矛盾。
>>> []
>>>a[-1:6] # start_index=-1在end_index=6的右边，因此从右往左取值，但step=1则决定了从左往右取值，两者矛盾。
>>> []
>>>a[-1:6:-1] # start_index=-1在end_index=6的右边，因此从右往左取值，而step=-1同样决定了从右往左取值。
>>> [9, 8, 7]

6. Kontinuierlicher Slicing-Vorgang

>>>a[:8][2:5][-1:]
>>> [4]

entspricht:

a[:8]=[0, 1, 2, 3, 4, 5, 6, 7]
a[:8][2:5]= [2, 3, 4]
a[:8][2:5][-1:] = 4

theoretisch unbegrenzte Zeiten Kontinuierlicher Slicing-Vorgang, solange das letzte zurückgegebene Objekt immer noch ein slicbares Objekt ungleich Null ist.

7. Die drei Parameter der Slicing-Operation können durch den Ausdruck

>>>a[2+1:3*2:7%3] # 即：a[2+1:3*2:7%3] = a[3:6:1]
>>> [3, 4, 5]

8 ausgedrückt werden. Slicing-Operationen anderer Objekte

Die vorherigen Slicing-Operationsanweisungen werden alle mit erklärt Liste als Beispiel, aber tatsächlich gibt es viele Datentypen, die in Scheiben geschnitten werden können, einschließlich Tupel, Zeichenfolgen usw.

>>> (0, 1, 2, 3, 4, 5)[:3] # 元组的切片操作
>>> (0, 1, 2)
>>>'ABCDEFG'[::2] # 字符串的切片操作
>>>'ACEG'
>>>for i in range(1,100)[2::3][-10:]: # 利用range函数生成1-99的整数，然后取3的倍数，再取最后十个。
       print(i, end=' ')
>>> 72 75 78 81 84 87 90 93 96 99

4. Häufig verwendete Slicing-Operationen in Python

Nehmen Sie eine Liste: a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ist das Beschreibungsobjekt

Nehmen Sie die gerade Position

>>>b = a[::2]
[0, 2, 4, 6, 8]

Nehmen Sie die ungerade Position

>>>b = a[1::2]
[1, 3, 5, 7, 9]

Kopieren Sie das gesamte Objekt

>>>b = a[:] # ★★★★★
>>>print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) # 41946376
>>>print(id(b)) # 41921864
>>>b = a.copy()
>>>print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) # 39783752
>>>print(id(b)) # 39759176
需要注意的是：[:]和.copy()都属于“浅拷贝”，只拷贝最外层元素，内层嵌套元素则通过引用，而不是独立分配内存。
>>>a = [1,2,['A','B']]
>>>print('a={}'.format(a))
a=[1, 2, ['A', 'B']] # 原始a
>>>b = a[:]
>>>b[0] = 9 # 修改b的最外层元素，将1变成9
>>>b[2][0] = 'D' # 修改b的内嵌层元素
>>>print('a={}'.format(a)) # b修改内部元素A为D后，a中的A也变成了D，说明共享内部嵌套元素，但外部元素1没变。
a=[1, 2, ['D', 'B']] 
>>>print('b={}'.format(b)) # 修改后的b
b=[9, 2, ['D', 'B']] 
>>>print('id(a)={}'.format(id(a)))
id(a)=38669128
>>>print('id(b)={}'.format(id(b)))
id(b)=38669192

4. Ein einzelnes Element ändern

>>>a[3] = ['A','B']
[0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9]

5. Element

>>>a[3:3] = ['A','B','C']
[0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]
>>>a[0:0] = ['A','B']
['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

an einer bestimmten Position einfügen 6. Einige Elemente ersetzen

>>>a[3:6] = ['A','B']
[0, 1, 2, 'A', 'B', 6, 7, 8, 9]

5. Zusammenfassung

(1) start_index, end_index und step können sowohl positiv als auch negativ sein, oder es kann eine Mischung aus positiv und negativ verwendet werden. Es muss jedoch ein Prinzip befolgt werden, das heißt, die Reihenfolge der Werte der beiden muss gleich sein, sonst können die Daten nicht korrekt abgerufen werden: Wenn sich die Position von start_index links von end_index befindet, bedeutet dies Folgendes Der Wert wird von links nach rechts genommen, und Schritt muss eine positive Zahl sein (es bedeutet auch von links nach rechts); wenn die Position von start_index rechts von end_index liegt, bedeutet dies, dass der Wert von rechts nach links genommen wird. Zu diesem Zeitpunkt muss der Schritt eine negative Zahl sein (es bedeutet auch von rechts nach links). In besonderen Fällen, wenn start_index oder end_index weggelassen werden, werden der Startindex und der Endindex durch das Positive oder Negative des Schritts bestimmt. Es gibt keinen Konflikt in der Richtung des Werts, aber die durch Positiv und Negativ erzielten Ergebnisse sind völlig unterschiedlich , weil eine Eins links und eine rechts.

(2) Beim Schneiden müssen die positiven und negativen Aspekte der Stufe berücksichtigt werden, insbesondere wenn die Stufe weggelassen wird. Beispielsweise kann a[-1:] leicht als vom „Endpunkt“ zum „Startpunkt“ beginnend verwechselt werden, d. h. a[-1:] = [0, 1, 2, 3, 4, 5 , 6, 7 , 8, 9], aber tatsächlich a[-1:]=a[-1]=9, der Grund dafür ist, dass Schritt = 1 bedeutet, dass der Wert von links nach rechts genommen wird und der Startindex start_index= ist -1 selbst ist der höchste Wert des Objekts. Es gibt kein Element auf der rechten Seite und es gibt keine Daten weiter rechts, also gibt es nur ein Element a[-1].

Das obige ist der detaillierte Inhalt vonEin umfassendes Verständnis der Python-Slicing-Operationen in einem Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!