Python 3 Indexer und Sequenz entpacken (Substitution entpacken)

In Python 3 werden Indexer und Sequenzentpacken (Entpackungszuweisung) verwendet, um "Tupel" und "Liste" zu teilen. ) Kann verwendet werden. Letzteres ist der übliche Unterstrich "" zum Verwerfen von Variablen ("" Wiederverwendung) und Sternchen "*" zum Zuweisen zur Liste der verbleibenden iterierbaren Elemente. /ja/3/reference/simple_stmts.html#assignment-statements) ist möglich.

Neben dem Entpacken in Tupel in der Python 3-Dokumentation gilt das Konvertieren in Listen auch als Entpacken, wenn einige der Elemente auf der linken Seite als Variablen im Code verwendet werden können.

[a, b] = 0, 1
#Die obige Formel ist eine Konvertierung von Taple in Liste, aber das Listenelement b kann als Variable verwendet werden.
print(b)  # 1
b = 2
print(b)  # 2
print((a, b))  # (0, 2)

Voraussetzungen

Typen, die Indexer verwenden können und nicht

Typen, die vom Indexer verwendet werden können, sind Klassen mit abstrakten Methoden "index", und Typen, die nicht verwendet werden können, sind Typen ohne "index". Ersteres hat Typen, bei denen Indizes von Bedeutung sind, wie z. B. "Tupel" und "Liste", und letzteres sind Typen, bei denen Indizes bedeutungslos sind, wie "set" und "frozenset". Die Verwendung eines Indexers für letzteres führt zu einem "TypeError" -Fehler.

tuple1 = (0, 1, 2)
t0 = tuple1[0]
print(0)  # 0
t0, t1, t2 = tuple1
print((t0, t1, t2))  # (0, 1, 2)

set1 = {0, 1, 2}
# s0 = set1[0]  # TypeError 'set' object is not subscriptable
# print(s0)
s0, s1, s2 = set1
print((s0, s1, s2))  # (0, 1, 2)

Typen mit __index__ sind definiert als typing.SupportsIndex.

Typen, die das Entpacken von Sequenzen verwenden können und nicht (Substitution beim Entpacken)

Der Typ, der zum Entpacken der Sequenz verwendet werden kann, entspricht der Sequenz.. Dies ist ein Typ mit einer speziellen Methode "getitem" und einer speziellen Methode "len", und viele Typen wie "tuple", "list" und "set" sind anwendbar.

Typen, die Indexer und Sequenzentpackungen verwenden können und nicht

Typen, die sowohl für Indexer als auch für das Entpacken von Sequenzen verwendet werden können, sind die Typen "index", "getitem" und "len". "Tupel" und "Liste" fallen in diese Kategorie, "Set" und "Frozen Set" jedoch nicht.

Tupel teilen

Da das vorhergehende und folgende "(", ")" weggelassen werden kann, kann es im Fall der linken Seite (Entpackungsziel) der gleichen Anzahl so geschrieben werden, dass es geteilt und ersetzt wird.

Indexer

t = ("a", "b", "c")
a = t[0]
b = t[1]
c = t[2]
print((a, b, c))  # ('a', 'b', 'c')

Tupel → Tupel auspacken

# tuple→tuple
a, b, c = "a", "b", "c"
print((a, b, c))  # ('a', 'b', 'c')

# tuple→tuple
a, b, c = ("a", "b", "c")
print((a, b, c))  # ('a', 'b', 'c')

# tuple→tuple
(a, b, c) = ("a", "b", "c")
print((a, b, c))  # ('a', 'b', 'c')

#Weglassen unnötiger Variablen
(_, b, _) = ("a", "b", "c")
print((_, b, _))  # ('c', 'b', 'c')

#Setzen Sie den Rest in eine Liste
(a, *bc, _, e) = ("a", "b", "c", "d", "e")
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

Tupel → Liste entpacken

# tuple→list
[a, b, c] = ("a", "b", "c")
print((a, b, c))  # ('a', 'b', 'c')

#Weglassen unnötiger Variablen
[_, b, _] = ("a", "b", "c")
print((_, b, _))  # ('c', 'b', 'c')

#Setzen Sie den Rest in eine Liste
[a, *bc, _, e] = ("a", "b", "c", "d", "e")
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

Liste teilen

Es kann grundsätzlich genauso behandelt werden wie "Tupel". Das vorhergehende und folgende "[", "]" kann jedoch nicht weggelassen werden.

Indexer

t = ["a", "b", "c"]
a = t[0]
b = t[1]
c = t[2]
print((a, b, c))  # ('a', 'b', 'c')

Liste → Tupel auspacken

# list→tuple
a, b, c = ["a", "b", "c"]
print((a, b, c))  # ('a', 'b', 'c')

# list→tuple
(a, b, c) = ["a", "b", "c"]
print((a, b, c))  # ('a', 'b', 'c')

#Weglassen unnötiger Variablen
(_, b, _) = ["a", "b", "c"]
print((_, b, _))  # ('c', 'b', 'c')

#Setzen Sie den Rest in eine Liste
(a, *bc, _, e) = ["a", "b", "c", "d", "e"]
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

Liste → Liste entpacken

# list→list
[a, b, c] = ["a", "b", "c"]
print((a, b, c))  # ('a', 'b', 'c')

#Weglassen unnötiger Variablen
[_, b, _] = ["a", "b", "c"]
print((_, b, _))  # ('c', 'b', 'c')

#Setzen Sie den Rest in eine Liste
[a, *bc, _, e] = ["a", "b", "c", "d", "e"]
print((a, bc, _, e))  # ('a', ['b', 'c'], 'd', 'e')

Set teilen

Indexer wird nicht unterstützt. Beim Auspacken in einen Tipp oder eine Liste kann die Bestellung nicht garantiert werden.

Set auspacken

# set→tuple
#Die Bestellung ist nicht garantiert.
a, b, c = {"a", "b", "c"}
print((a, b, c))  # ('a', 'b', 'c')Jede Art von

# set→list
#Die Bestellung ist nicht garantiert.
[a, b, c] = {"a", "b", "c"}
print((a, b, c))  # ('a', 'b', 'c')Jede Art von

#set → set (kann nicht)
# {a, b, c} = {"a", "b", "c"}
# print((a, b, c))  # ('a', 'c', 'b')

Beispiel

• Anwendung von Python 3-Variablen