Python: Konvertiere n-Tupel in x-Tupel wobei x <n - Python, Python-2.7, Tupel

Die Frage ist ziemlich einfach (anders als der Titel). Ich habe ein Tupel des Typs:

p = (1, 2, 3, 4, 5, 6)
# I refer to this as a 6-tuple but p could be an n-tuple

Ich muss dies in ein kleineres Tupel umwandeln:

(a, b) = p

so dass a <- 1 und b <- (2, 3, 4, 5, 6)

BEARBEITEN:

Ich brauche Code für Python v2.7. Ich hätte auch erwähnen müssen, dass es Möglichkeiten gibt, dies zu tun, aber ich suche nach etwas Natürlichem und etwas, wo ich mich nicht mit Indizes beschäftigen muss.

a, b, c, d, e = p[0], p[1], p[2], p[3], p[4], p[5:]

ist nicht erwünscht.

EDIT 2:

Im obigen Beispiel ist a eine ganze Zahl, während bist unser neues Tupel. Die Idee hinter n-Tupel zu x-Tupel ist, dass die Länge des neuen Tupels kleiner ist als die des ursprünglichen. Im folgenden Beispiel haben wir 0-Tupel (ints):

a, b, c = (1, 2, 3)

Wenn es jedoch Folgendes ist:

a, b, c, d = (1, 2, 3)

dann haben wir a <- 1, b <- 2, c <-3, d <- None/Nothing.

Antworten:

3 für die Antwort № 1

Für eine allgemeine Lösung:

def split_after(lst, n):
for i in range(n):
yield lst[i]
yield lst[n:]

Ergebnis:

>>> a,b,n = split_after(p,2)
>>> a
1
>>> b
2
>>> n
(3, 4, 5, 6)
>>> l = list(split_after(p,3))
>>> l
[1, 2, 3, (4, 5, 6)]

Sie müssen also wissen, wie viele Artikel Sie habenauf der linken Seite und sagen Sie dies der Funktion (weil sie das nicht von sich aus sagen kann, im Gegensatz zu der erweiterten Tupel-Entpackungssyntax in Python 3).

---

2 für die Antwort № 2

Du kannst das

a, b = p[0], p[1:]

Dies ist ein Beispiel

>>> p = (1,2,3,4,5)
>>> a, b = p[0], p[1:]
>>> a
1
>>> b
(2, 3, 4, 5)

---

2 für die Antwort № 3

Wenn Sie Python 3 verwenden, ist dies mit der erweitertes iteratives Entpacken Syntax:

>>> p = (1, 2, 3, 4, 5, 6)
>>> a, *b = p
>>> a
1
>>> b
[2, 3, 4, 5, 6]

b wird in eine Liste aufgenommen, da die RHS beliebig iterierbar sein kann, aber Sie können dies tun b = tuple(b) Wenn Sie es wirklich brauchen, um genau ein Tupel zu sein.

Dies unterscheidet sich geringfügig von Ihren späteren Beispielen:

a, b, c = (1, 2, 3)

Diese Syntax ist bereits in Python 2 zulässig und wird das Richtige tun, wenn LHS und RHS dieselbe Anzahl von Elementen haben. Dies ist das nur Dies funktioniert in Python 2, ohne mit der Indizierung zu spielen.

Verwendung einer * funktioniert auch hier in Python 3, aber die Variable, der Sie sie hinzufügen, wird dies tun immer eine Liste sein - auch wenn es nur einen Artikel hat:

>>> a,b,*c = (1, 2, 3)
>>> c
[3]

Aber in Ihrem letzten Beispiel wird es ungefähr das tun, was Sie wollen:

a, b, c, *d = (1, 2, 3)
>>> d
[]

dh, d ist eine leere Liste statt None.

---

1 für die Antwort № 4

In Python2 muss die RHS auf die korrekte Anzahl von Elementen entpackt werden, um der LHS zu entsprechen. Sie können Indizes mit solchen Hacks vermeiden. Sie müssen jedoch noch wissen, wie viele Elemente Sie dort auspacken müssen.

>>> p = (1, 2, 3, 4, 5, 6)
>>> a, b = (lambda a, *b:(a, b))(*p)
>>> a
1
>>> b
(2, 3, 4, 5, 6)

---

0 für die Antwort № 5

Dadurch wird eine Liste basierend auf einer Liste von aufgeteilten Indizes rekursiv aufgeteilt.

def split(lis, splits):
if not splits:
return [lis]
new_splits = [s - splits[0] for s in splits[1:]]
return [lis[:splits[0]]] + split(lis[splits[0]:], new_splits)

Verwendung

>>> split([1,2,3,4,5,6],[2])
[[1,2], [3,4,5,6]]

>>> split([1,2,3,4,5,6],[2,4])
[[1,2], [3,4], [5,6]]

>>> split([1,2,3,4,5,6],[2,4,8])
[[1,2], [3,4], [5,6], []]

Welches können Sie so verwenden:

>>> a,b,c,d = split([1,2,3,4,5,6],[2,4,8])

---