Floor Division und Remainder gleichzeitig in 2 separaten Variablen erhalten

Question

Gibt es eine Python-eingebaute (oder einfach nur optimierte) Funktion, um die Floor Division und den Rest gleichzeitig in zwei separaten Variablen zu erhalten?

Beispiel:

a, b = 10 divided by 4 

Wunschergebnisse:

a = 2 
b = 2 

Ich brauche dies eine optimierte Lösung.

Ergebnisse Performance:

erstes Stück Code:

for i in range(10000000): 
    a, b = divmod(i, 5) 
took 3.99 seconds to run 

zweites Stück Code:

for i in range(10000000): 
    a = i // 5 
    b = i % 5 
took 2.56 seconds to run 

Bemerkungen:

Lesen Sie @casevh Antwort für eine detailliertere Erklärung.

tldr: divmod() funktioniert besser, wenn Zahlen groß sind.

Answer 1

Verwenden Sie dies. das wird dir helfen.

a,b = divmod(10,2) 

es wird sowohl Wert zurück

Answer 2

Ich glaube, Sie suchen divmod() Bibliotheksfunktion

Hier ist ein link to its docs

Beispiel

>>> a, b = divmod(10, 4) 
>>> print a, b 
>>> 2 2 

Answer 3

Es gibt einen signifikanten Unterschied in Leistung, wenn Sie verwenden größere Zahlen. Hier

ist ein Beispiel kleine und große Zahlen mit:

$ py27 -m timeit -s "a=123;b=7" "divmod(a,b)" 
10000000 loops, best of 3: 0.0913 usec per loop 
$ py27 -m timeit -s "a=123;b=7" "a//b;a%b" 
10000000 loops, best of 3: 0.047 usec per loop 
$ py27 -m timeit -s "a=123333333333333333333333333333333333333;b=7222222222222222222" "divmod(a,b)" 
10000000 loops, best of 3: 0.165 usec per loop 
$ py27 -m timeit -s "a=123333333333333333333333333333333333333;b=7222222222222222222" "a//b;a%b" 
1000000 loops, best of 3: 0.232 usec per loop 

Warum der Unterschied?

divmod() erfordert einen Funktionsaufruf, während // und% Operatoren sind. Es gibt einen zusätzlichen Overhead für einen Funktionsaufruf relativ zu Operatoren. Wenn also die Kosten der Berechnung minimal sind, ist der Overhead beim Aufruf einer Funktion viel größer als die tatsächlichen Kosten der Berechnung (en).

Für größere Zahlen ist divmod() schneller. divmod() berechnet sowohl den Quotienten als auch den Rest zur gleichen Zeit und gibt beide zurück. Die Operatoren // und% berechnen jeweils den Quotienten und den Rest, geben aber nur eines der Ergebnisse zurück.

divmod() hat mehr Overhead, führt aber nur eine Division durch. // und% haben weniger Overhead, aber zwei Divisionen. Solange der Overhead im Vergleich zur Zeit groß ist, um division durchzuführen, wird divmod() langsamer sein.Aber sobald die Kosten einer Division größer als der Overhead ist, wird Divmod() schneller sein.