Alles über das Schneiden von Operationen in Python

Für jeden Python -Programmierer, sei es im Bereich von Datenwissenschaft und maschinellem Lernen oder Softwareentwicklung, sind Python -Schnittvorgänge eines der effizientesten, vielseitigsten und leistungsstärksten Vorgänge. Python Slicing Syntax ermöglicht die Extraktion und Änderung von Datenstrukturen wie Hear, Zeichenfolgen, Tupeln, Arrays, Pandas DataFramesund sogar Bytesequenzen. Unabhängig davon, ob wir einen Abschnitt mit Listenschneide in Python extrahieren müssen, Zeichen mithilfe von String -Slicing manipulieren oder nur den Workflow optimieren möchten, bietet Slicing eine präzise Möglichkeit, mit Daten ohne Verwendung komplexer Schleifen oder manueller Indizierung zu arbeiten. In diesem Python Wenn wir das Tutorial schneiden, werden wir tiefer in die Funktionsweise der Python -Schnittvorgänge eintauchen und lernen, wie sie in Programmen und Workflows effektiv eingesetzt werden können.

Was sind in Python in Scheibenoperationen?

Schneiden bedeutet Schneiden. In ähnlicher Weise bedeutet es in Python, auf eine Sequenz (wie SaitenAnwesend HearAnwesend Tupeloder Arrays) durch Angabe eines Indizesbereichs. Durch die Schneiden von Operationen in Python wird die Verwendung von Dickdarmbetreibern (:) Innerhalb der Quadratklammern verwendet. Die grundlegende Syntax beinhaltet:

(Begin: Ende: Schritt)
START: Begin ist der Index, von dem das Schneiden beginnt.
ENDE: Ende ist der Indexpunkt, zu dem der Vorgang durchgeführt wird, dh es ist nicht in der enthalten
Betrieb.
SCHRITT: Schritt ist der Inkrementindex. Sein Standardwert ist 1, was bedeutet, dass die gesamte Sequenz die Ausgabe ist. Wenn Schritt = 2, wird jeder different Wert gedruckt.

Warum Slicing verwenden?

Das Schneiden ist eine wichtige Methode, da wir auf die Daten zugreifen und die Daten präzise manipulieren können, wodurch der Code über Datenstrukturen hinweg lesbar und vielseitiger wird. Zum Beispiel:

Iterieren ohne Schneiden

lst = (1, 2, 3, 4, 5)
sublist = ()
for i in vary(1, 4):
   sublist.append(lst(i))
print(sublist)

Iterieren mit Schneiden

lst = (1, 2, 3, 4, 5)
sublist = lst(1:4)
print(sublist)

Ausgabe: (2, 3, 4)

Schneidenmethoden in Python

Grundsätzlich bietet Python 2 verschiedene Slstellmethoden. Einer ist (Begin: Ende: Schritt) und der andere ist das .Slice (Begin, Stopp, Schritt) Funktion. In diesem Abschnitt werden wir zunächst die Syntax dieser Schnittvorgänge durchlaufen. Danach werden wir die wichtigsten Arten von Schneiden untersuchen, die wir in Python durchführen können.

1. Verwenden (Begin: Ende: Schritt)

Dies ist die häufigste Möglichkeit, den Schnittvorgang an verschiedenen Teilen der Eingangssequenz auszuführen.

Mit Index (:) Beispiele schneiden

mixed_data = (10, "apple", 3.14, "banana", 42, "cherry")


# Slice from index 1 to 4
print(mixed_data(1:4)) 
print(20*"--")
# Slice the record from the begin to index 3
print(mixed_data(:3)) 
print(20*"--")
# Slice each 2nd aspect
print(mixed_data(::2))

1. Verwenden von Python Slice () -Funktion

Mit der Slice -Funktion können Sie ein Slice -Objekt erstellen, das auf die Sequenz angewendet wird. Dies hilft, wenn Sie die Slice -Spezifikationen speichern und auf mehrere Sequenzen anwenden möchten.

Syntax von .slice ()

Schnitt (Begin, Stopp, Schritt)

Begin: Der Startindex des Slice (inklusive).
stoppen: Der Stoppindex des Slice (exklusiv).
Schritt: Der Schritt oder der Schritt (wie viel, um den Index nach jedem Schritt elective zu erhöhen).

Mit Slice () schneiden. Beispiele

textual content = "Hiya, world!"
# Create a slice object to get the primary 5 characters
s = slice(0, 5)
# Apply the slice object to the string
print(textual content(s)) 
# Output: "Hiya"

Jedes dritte Ingredient schneiden

mixed_data = (10, "apple", 3.14, "banana", 42, "cherry")
s = slice(None, None, 3)
# Apply the slice object to the record
print(mixed_data(s)) 
# Output: (10, 'banana')

Slice von Index 2 bis zum Ende

s = slice(2, None)
# Apply the slice object to the record
print(mixed_data(s)) 
# Output: (3.14, 'banana', 42, 'cherry')

In umgekehrter Reihenfolge schneiden

s = slice(None, None, -1)
# Apply the slice object to the record
print(mixed_data(s)) 
# Output: ('cherry', 42, 'banana', 3.14, 'apple', 10)

Jetzt werden wir uns mit den wichtigsten Arten von Schnittoperationen in Python befassen

1. Basisschnitte

Primary Slicing bezieht sich auf das Extrahieren einer Subsequenz für Datentypen wie String, Listing oder Tuple mit Syntax (Begin: Ende: Schritt). Es ist ein grundlegendes Werkzeug in Python, mit dem wir die Untersequenzen leicht abrufen können. Es funktioniert auch mit einer Vielzahl von Datentypen und macht es zu einer vielseitigen Technik.

numbers = (10, 20, 30, 40, 50, 60)
# Slice from index 1 to index 4 (unique)
print(numbers(1:4)) 
# Output: (20, 30, 40)

textual content = "Hiya, world!"
# Slice from index 7 to index 12 (unique)
print(textual content(7:12)) 
# Output: "world"

numbers_tuple = (1, 2, 3, 4, 5, 6)
# Slice from index 2 to index 5 (unique)
print(numbers_tuple(2:5)) 
# Output: (3, 4, 5)

2. Ausführen von ‚Begin‘, ‚Cease‘ oder ‚Schritt‘

Durch Auslassen von Begin, Stopp und Schritt beim Schneiden können Benutzer Standardwerte verwenden.

• Auslösen starten standardmäßig zum Beginn der Sequenz.
• Der Weglassen von Stopp bedeutet, dass die Scheibe bis zum Ende geht.
• Durch die Auslassung von Schritt standardmäßig einen Schritt von 1.

Durch das Entfernen dieser Teile wird der Code prägnanter und flexibler. Es ermöglicht es Ihnen, dynamisches und verallgemeinertes Schneiden zu erstellen, ohne alle Parameter explizit zu definieren.

Ändern Sie Hear mit Schneiden

numbers = (10, 20, 30, 40, 50, 60)
# Omitting begin, slice from the start to index 4 (unique)
print(numbers(:4)) 
# Output: (10, 20, 30, 40)


# Omitting cease, slice from index 2 to the top
print(numbers(2:)) 
# Output: (30, 40, 50, 60)

Leeres Schneiden

numbers_tuple = (1, 2, 3, 4, 5, 6)
# Omitting begin and step, slice the entire tuple
print(numbers_tuple(:)) 
# Output: (1, 2, 3, 4, 5, 6)

Elemente löschen

numbers = (2,4,5,12,64,45)
numbers(1:4) = ()


print(numbers)
# Output: (2,64,45)

3. Negatives Schneiden

Die damaging Indexierung ermöglicht das Zählen vom Ende einer Sequenz. Bei der negativen Indexierung bezieht sich -1 auf das letzte Ingredient, und -2 bezieht sich auf das zweite letzte. Es hilft, wenn Sie vom Ende einer Sequenz auf Elemente zugreifen müssen.

Zugriff auf die letzten Elemente

numbers = (10, 20, 30, 40, 50, 60)
# Slice on the final index
print(numbers(-1)) 
# Output: (60)

Eine Zeichenfolge umkehren

original_string = "howdy"
reversed_string = original_string(::-1)
print(reversed_string) 
# Output: "olleh"

4. Mit Schritt schneiden

Der Schrittparameter ermöglicht die Angabe des Intervalls zwischen den Elementen, wodurch es bei der Verarbeitung oder Abtastdaten nützlich ist. Ein negativer Schritt kann die Sequenz leicht rückgängig machen, wie oben gezeigt, wodurch es sehr einfach und bequem ist, die gesamten Daten umzukehren.

Jedes 2. Ingredient schneiden

numbers = (10, 20, 30, 40, 50, 60)
# Slice with step 2, selecting each second aspect
print(numbers(::2)) 
# Output: (10, 30, 50)

Verwirrender Schrittverhalten

numbers = (10, 20, 30, 40, 50, 60)
# Slice finally index
print(numbers(::-3)) 
# Output: (60,30)

5. ohne keine schneiden

Beim Schneiden kann keiner verwendet werden, um den Standardwert für Begin, Stopp und Ende darzustellen. Die Verwendung von None ermöglicht mehr Flexibilität und Klarheit in der Programmierung. Dies ist eine Möglichkeit, ein Standardschneideverhalten anzuwenden, ohne es manuell zu definieren.

Mit keinem auslassen

numbers = (10, 20, 30, 40, 50, 60)
# Slice each 2nd aspect utilizing slice(None, None, 2)
s = slice(None, None, 2)
print(numbers(s)) 
# Output: (10, 30, 50)

6. Out-of-of-Certain Slicing

Wenn Sie versuchen, eine Sequenz über ihre Grenzen hinaus zu schneiden (entweder mit großen Indizes oder mit -VE -Indizes außerhalb des Bereichs), erhöht sie keinen Fehler in Python und gibt einfach die größte gültige Scheibe zurück, ohne sich um die Ausnahmen zu sorgen.

numbers = (10, 20, 30, 40, 50, 60)
# Slice past the size of the record
print(numbers(4:15)) 
# Output: (50, 50)

Über Länge hinaus schneiden

textual content = "Hiya, world!"
# Slice past the size
print(textual content(15:55))
# Output: no output

7. Numpy Array Slicing

In Numpy funktioniert das Schneiden auch ähnlich wie das Python Primary Slicing. Außerdem ist Numpy speziell für wissenschaftliches Computing entwickelt und ermöglicht auch eine schnellere Datenmanipulation. Dies hilft bei der weiteren Unterstützung weiterer und effizienterer Vorgänge für große Datensätze. Durch das Schneiden können Numpy auf Sub-Arrays zugreifen und sie effizient ändern (dh wir können die Subtarrays ändern).

Durchschneiden von 1-D-Arrays

import numpy as np
# Create a 1-D NumPy array
arr = np.array((10, 20, 30, 40, 50, 60))
# Slice from index 1 to index 4 (unique)
print(arr(1:4)) 
# Output: (20 30 40)

Wie das grundlegende Schnitt können wir das Array von Index 1 bis 4 (exklusiv) durchschneiden, genau wie das reguläre Python -Schnitt. Es ermöglicht auch, alle anderen oben diskutierten Operationen in Arrays auszuführen.

# Slice each second aspect from the array
print(arr(::2)) 
# Output: (10 30 50)

Durchschnitt mehrdimensionale Arrays

# Create a 2-D NumPy array (matrix)
arr_2d = np.array(((10, 20, 30), (40, 50, 60), (70, 80, 90)))
# Slice from row 1 to row 2 (unique), and columns 1 to 2 (unique)
print(arr_2d(1:2, 1:3)) 
# Output: ((50 60))

8. Pandas DataFrame Slicing

PANDAS-Datenrahmen sind zweidimensionale markierte Datenstrukturen, die auch Schnittvorgänge unterstützen. Es ermöglicht das Durchschneiden der Datenpunkte durch .loc () und .iloc (). Zusammen mit diesem unterstützt Pandas auch die Boolesche Indexierung.

Durch das Schneiden des Datenframees selbst filtern und manipuliert große Datensätze effizient. Es ermöglicht die Auswahl von Daten unter Verwendung von Daten mit Bedingungen, sodass es zu einem wertvollen Instrument für die Datenanalyse und zum maschinellen Lernen wird.

Schneiden mit dem Zeilenindex (.ILOC)

import pandas as pd

# Create a DataFrame
df = pd.DataFrame({
   'A': (1, 2, 3, 4, 5),
   'B': (10, 20, 30, 40, 50)
})
print(df)
# Output
#    A   B
# 0  1  10
# 1  2  20
# 2  3  30
# 3  4  40
# 4  5  50


# Slice the primary three rows (unique of the fourth row)
print(df.iloc(:3))
#    A   B
# 0  1  10
# 1  2  20
# 2  3  30

Hier schneidet der .iloc (3) die ersten 3 Zeilen (Index 0 bis 2) des Datenrahmens.

Schneiden mit dem Spaltennamen (.loc)

# Create a DataFrame
df = pd.DataFrame({
   'A': (1, 2, 3, 4, 5),
   'B': (10, 20, 30, 40, 50)
})
print(df)
# Output
#    A   B
# 0  1  10
# 1  2  20
# 2  3  30
# 3  4  40
# 4  5  50
print(df.loc(df('A') > 2)) 
# Output:
#    A   B
# 2  3  30
# 3  4  40
# 4  5  50

Das .loc ermöglicht es, die Beschriftungen mit Spaltennamen oder als Index als Falsch zu schneiden. Hier schneiden wir auf der Grundlage der Bedingung, dass der Spalte „A“ Wert größer als 2 sein muss.

9. Byte -Sequenzschneide

Python bietet Byte -Sequenzen wie Bytes und Bytearray an, die wie Hear, Strings oder Arrays in Einschnitten unterstützen. Die Byte -Sequenz kommt in das Bild, wenn wir die Binärdatentypen verwenden, und Sie können relevante Teile von Binärdaten mit Leichtigkeit und Effizienz extrahieren.

Ein Byteobjekt schneiden

byte_seq = b'Hiya, world!'
# Slice from index 0 to index 5 (unique)
print(sort(byte_seq))
print(byte_seq(:5)) 
# Output: <class 'bytes'>, b'Hiya'

Ein Bytearray (veränderliche Bytes) schneiden

byte_arr = bytearray((10, 20, 30, 40, 50, 60))

# Slice from index 2 to index 5 (unique)
print(byte_arr(2:5)) 
# Output: bytearray(b'2x1e<')

Hier entspricht die Ausgabe in Werten, die ASCII -Zeichen entsprechen. Dies geschieht, wenn sich die Ausgabe nicht im druckbaren Bereich befindet. Bytearray (B’2 x1e <') ist additionally die Ausgabe, da es diese Byte-Werte in einer eher menschlich lesbaren Kind darstellt.

print(record(byte_arr(2:5)))  # Output: (30, 40, 50)
# Ouput: (30,40,50)

Vorteile der Verwendung des Schneidens in Python

Es gibt viele Vorteile bei der Verwendung von Schnittvorgängen in Python, einschließlich:

• Effizienz: Das Schneiden ermöglicht den schnellen Zugriff auf die gewünschte Untersequenz aus größeren Datensätzen, ohne dass die Schleife gelobt werden muss.
• Prägnanz: Es ermöglicht einen prägnanteren und lesbaren Code für die Datenmanipulation.
• Flexibilität: Mit Hilfe von Bibliotheken wie Numpy und Pandas fügt das Durchschneiden mehrdimensionaler Daten eine effiziente Möglichkeit für die Vorbereitung der Daten hinzu.
• Speichereffizient: Das Schneiden ist für die Leistung optimiert. Außerdem stellt der interne Mechanismus von Python sicher, dass die Schnittvorgänge im Gegensatz zur manuellen Indexierung schnell und speicher sind, was eine Menge manueller Codierung erfordert und die Speicherverwendung erhöht.

Dinge, die Sie beim Einsatz von Schnittvorgängen vermeiden sollten

Hier sind einige Dinge, die Sie vermeiden sollten, wenn Sie die Schnittvorgänge in Python verwenden.

• Überschreitende Indexgrenzen: Das Schneiden über die Sequenzlänge hinaus verursacht keinen Fehler in der Python. Dies kann jedoch zu unerwünschten Ergebnissen führen, insbesondere bei der Arbeit mit größeren Datensätzen.
• Verwirrende Indexierung und Schneidensyntax: Die Schnittsyntax beinhaltet Sequenz (Begin: Stopp: Ende), aber die Auswahl des Index/der Place des gewünschten Parts ergibt auch das gewünschte Ingredient.
• Schneiden ohne Berücksichtigung von Veränderlichkeit: Slicing kann verwendet werden, um die Sequenz zu ändern. Um dies zu verwenden, muss man prüfen, ob der Datentyp, mit dem sie sich befassen, mit Unterstützung von Mutability oder nicht. Beispielsweise sind Hear und Byte -Arrays veränderlich; Auf der anderen Seite sind Saiten, Tupel und Bytes unveränderlich. Sie können additionally nicht direkt durch Schneiden geändert werden.
• Schneiden mit ungültigen Schrittwerten: Während der Verwendung von Schneiden muss man auch den Schritt berücksichtigen, da er entscheidet, wie viele Punkte dazwischen übersprungen werden. Die Verwendung eines ungültigen Werts kann jedoch zu unerwarteten Ergebnissen führen, was zu ineffizienten Vorgängen führt.

Abschluss

Das Schneiden in Python ist eine effiziente und leistungsstarke Artwork und Weise, mit der Sie die Python -Datentypen wie Hear, Zeichenfolgen, Tupel, Numpy -Arrays und Pandas -Datenframes effizient zugreifen und manipulieren können. Egal, ob Sie eine Liste in Scheiben schneiden, mit mehrdimensionalen Arrays in Numpy arbeiten oder mit großen Datensätzen mit Pandas zu tun haben. Slicing bietet immer eine klare und präzise Möglichkeit, mit Sequenzen zu arbeiten. Durch das Beherrschen von Schneiden kann man saubereren und effizienteren Code schreiben, was für jeden Python -Programmierer unerlässlich ist.




Hallo, ich bin Vipin. Ich bin begeistert von Datenwissenschaft und maschinellem Lernen. Ich habe Erfahrung mit der Analyse von Daten, dem Aufbau von Modellen und der Lösung realer Probleme. Ich möchte Daten verwenden, um praktische Lösungen zu erstellen und in den Bereichen Datenwissenschaft, maschinelles Lernen und NLP zu lernen.