Problem mit 1000 mal Würfel

[mutetella]

Und hier noch eine total vergurkte Lösung, so wie man es von mir kennt:

Code: Alles auswählen

>>> dice = map([random.randint(1, 6) for _ in xrange(1000)].count, range(1,7))
>>> for count, dice in enumerate(dice):
...     print '{0}er: {1} mal'.format(count+1, dice)
1er: 178 mal
2er: 181 mal
3er: 151 mal
4er: 150 mal
5er: 158 mal
6er: 182 mal

mutetella

[jbs]

Ich finde es gar nicht so schlecht

Ich merke gerade zum ersten mal, dass du muTEtella heißt.

[cofi]

Na wenigstens wolltest du ihn nicht aufs Brot schmieren

Verkorkst wuerde ich sie nicht nennen, aber es geht schon in Richtung Obfuscated Python

Aus dem Performance-Blickwinkel ist sie auch suboptimal: Du gehst 6x ueber die ganze Liste (was auch heisst, dass du die ganze Liste brauchst und nicht mit einer GenExp davonkommst). Wenn man jetzt "genauere" Ergebnisse haben moechte koennte man das gut merken

[mutetella]

Ich merke gerade zum ersten mal, dass du muTEtella heißt.

... die ganze Liste brauchst und nicht mit einer GenExp davonkommst ...

Darüber hab' ich ein Weilchen nachgedacht, zumal ich hier auf der PyCon am Montag das Tutorial "Iteratoren, Generatoren und Decoratoren" besucht hatte und jetzt natürlich alles nur noch mit Generatoren machen möchte... *grins*

mutetella

[mutetella]

Hoffentlich liest lunar jetzt nicht mit...

Aus dem Performance-Blickwinkel ist sie auch suboptimal...

Das scheint mir manchmal schon ein Reflex zu sein: Dies oder das ist mit Listen gelöst, das muss lahm sein...
Aus meiner geringen Erfahrung heraus weiß ich aber, dass das so oft nicht stimmt. Und nachdem mich das Tutorial schließlich 'n Hunni gekostet hat, hab' ich da gleich mal eine decorator-Übung gemacht *grins*:

Code: Alles auswählen

from timeit import default_timer
import random, collections
def measure(func):
    def call_func(*args):
        start = default_timer()
        result = func(*args)
        return result, default_timer() - start
    return call_func
 
@measure
def with_collections(count):
    return collections.Counter(random.randint(1, 6) for _ in xrange(count))
 
@measure
def without_collections(count):
    return map([random.randint(1, 6) for _ in xrange(count)].count, xrange(1, 7))

Code: Alles auswählen

>>> with_collections(100000)
(Counter({6: 16785, 4: 16771, 2: 16731, 5: 16657, 3: 16576, 1: 16480}), 0.24344611167907715)
>>> without_collections(100000)
(<map object at 0x1754950>, 0.16588497161865234)

mutetella

[cofi]

Aus dem Performance-Blickwinkel ist sie auch suboptimal...

Das scheint mir manchmal schon ein Reflex zu sein: Dies oder das ist mit Listen gelöst, das muss lahm sein...

Nanana, schneid mal nicht den relevanten Teil weg

[mutetella]

Ja ok, ich wollte jetzt einfach mal die Gelegenheit nutzen: Ein bischen klugscheißen und mit 'nem Decorator um mich werfen!!!

Wenn wir schon dabei sind:
In diesem Fall fände ich es syntaktisch eigentlich schöner, die zu messende Funktion an die messende Funktion zu übergeben. Ok, ich verstehe schon, dass es den einen oder anderen Fall gibt, wo ein Decorator für mehr Klarheit sorgt. Aber sowas wie 'ne Messroutine... würdet ihr das mit Decorator oder via Übergabe (was ja letztlich dasselbe ist) machen?

mutetella

[cofi]

Ich finde es nicht nur syntaktisch schoener keine Dekoratoren zu nutzen, sondern auch in vielen anderen Aspekten. Will man keine dauerhafte Ueberwachung der Funktion haben, hat man mit dem Dekorator ein Problem

Wenn man die zu messende Funktion uebergibt hat man das Problem nicht. Man kann die Dekorator-Funktion aber auch nicht als Dekorator nutzen und umschifft es auch:

Code: Alles auswählen

measure(func)(10000)

[BlackJack]

@mutetella: Die konkrete Messung widerlegt aber nicht, dass die Vorgehensweise die Elemente verschieden oft betrachten muss. Der `Counter` geht einmal durch die Daten, die Lösung mit der `count()`-Methode geht sechsmal durch die gleiche Datenmenge. Dass das trotzdem schneller ist, kann man auch als Implementierungsdetail ansehen, weil die Schleife bei `count()` intern in C programmiert ist und bei `Counter` verhältnismässig viel Python-Code für den einen Durchgang abgearbeitet wird. Das kann bei anderen Implementierungen, beispielsweise PyPy oder einem in C implementierten `Counter`, schon wieder anders aussehen. Solange es nicht tatsächlich zu einem messbaren Problem führt, würde ich fast immer den Algorithmus mit weniger „atomaren” Schritten wählen.

[lunar]

Hoffentlich liest lunar jetzt nicht mit...

Ich lese mit… und ich frage mich, warum Dich das stört.

[mutetella]

@lunar
Nun ja... das Thema Performance war ja in der Vergangenheit hin und wieder schon... keine Ahnung, wie ich jetzt sagen soll... war jedenfalls immer für ein Schmunzeln gut... puh, gerade noch die Kurve bekommen... *grins*

[lunar]

@mutetella So war das nicht gemeint. Ich habe nicht verstanden, dass Du nur auf vergangene Diskussionen anspielst, und dachte, ich wäre Dir mit irgendeinem Beitrag auf die Füße getreten. Sorry

[mutetella]

@lunar
Nein nein, bist Du überhaupt nicht... mach' Dir keinen Kopf, alles im tiefgrünen Bereich...!