[Python] Zuweisung von mehreren Variabeln in einer Zeile

Lichtweite

Ich habe keine Ahnung von Python, kann mir einer erklären wie ich diese Zeile zu verstehen habe?

q, r, t, k, m, x = 10*q, 10*(r-m*t), t, k, (10*(3*q+r))//t - 10*m, x

Shade Of Mine

http://docs.python.org/release/2.7.3/tutorial/datastructures.html#tuples-and-sequences

Oliver

Hier stand Mist.

Lichtweite

Hehe, sehr schön. Das Ergbnis habe ich auch rausbekommen, leider stimmt die Rechnung dann nicht mehr. Warum auch immer. Ich habe dann die
e richtige Reihenfolge raus bekommen, so dass wieder dasselbe Ergebnis raus kommt wie vorher.

r = 10*(r-m*t)
t = t
k = k
m = (10*(3*q+r))//t - 10*m
x = x
q = 10*q

t,k,x kann man sich sparen habe die aber trotzdem drinne.

Ja, dass was ich bis jetzt von Python gesehen habe ist alles sehr intuitiv und auch mit IDLE bin ich gleich klar gekommen. Eine feine Sprache die ich mir auch mal genauer ansehen werden.

Hier ist mal das gesammt Programm und ihr könnt mal selbst probieren, dass die einfache Ersetzung dieser Zuweisung, in der vermuteten Reihenfolge, nicht klappt.

def make_pi():
    q, r, t, k, m, x = 1, 0, 1, 1, 3, 3
    for j in range(1000):
        if 4 * q + r - t < m * t:
            yield m
            q, r, t, k, m, x = 10*q, 10*(r-m*t), t, k, (10*(3*q+r))//t - 10*m, x
        else:
            q, r, t, k, m, x = q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2

digits = make_pi()
pi_list = []
my_array = []

for i in make_pi():
    my_array.append(str(i))

my_array = my_array[:1] + ['.'] + my_array[1:]
big_string = "".join(my_array)
print "here is a big string:\n %s" % big_string

Nymer

Die Ausdrücke auf der rechten Seite werden alle ausgewertet, bevor sie zugewiesen werden.

Oliver

Nymer schrieb:

Die Ausdrücke auf der rechten Seite werden alle ausgewertet, bevor sie zugewiesen werden.

Das stimmt. Habe ich nicht bedacht. Ich Noob.

Lichtweite

Na das ist doch mal eine Erklärung, ich wäre fast vom Glauben abgekommen. Nun kann ich beruhigt an der Matratze horchen.

Shade Of Mine

q, r, t, k, m, x = q*k, (2*q+r)*x, t*x, k+1, (q*(7*k+2)+r*x)//(t*x), x+2

ist sowas eigentlich esotherisch?

PS:
was ich damit sagen will: so einen code wuerde ich bei uns wieder zurueck zum autor schicken...

SG1

Definitiv.

Mit einem Kommentar, dass man genau das von Nymer beschriebene Verhalten braucht (und ansonsten jede Menge zusätzliche Variablen bräuchte, die den Code auch nicht leserlicher machen würden), könnte man es eventuell durchgehen lassen.

Oliver

Ja so wuerde ich das auch nie benutzen. Wenn man mehr als einen Rueckgabewert hat, da finde ich das sehr praktisch.

def foo():
    return 2, 4, 8

a, b, c = foo()

Ich kenne sonst keine Programmiersprache wo das so schoen geht (will damit nicht sagen dass es keine gibt!).

pyhax

Damit lässt sich schön ein "swap" implementieren:

x,y = y,x

Ich glaube, das steht sogar irgendwo im Python Handbuch auf python.org. Also so verwunderlich finde ich das jetzt nicht.

Oliver schrieb:

Ich kenne sonst keine Programmiersprache wo das so schoen geht (will damit nicht sagen dass es keine gibt!).

Hmm, in Haskell geht das ziemlich genauso, aber das kennst du vermutlich nicht.

Kennst du dafür C++? Da geht das fast so schön

std::tie(x, y) = std::tuple(y, x);

schoen schrieb:

Kennst du dafür C++? Da geht das fast so schön
std::tie(x, y) = std::tuple(y, x);

da fehlt aber noch die Definition von x und y.

C++ ist immer "fast so schön", wenn man all den Boilerplate-Code ausblendet

ups, hatte den Thread ein bischen zu schnell überflogen und dann geantwortet, wieso boost::tie keinen Spaß macht.

Aber das swap über tie-tupelei ist auch kein Code den man jemals so verfassen würde...