Das deutsche Python-Forum

Hallo zusammen

Ich übergebe an die Funktion die Grösse der Liste, die ich erstellen möchte und die Liste wird daraufhin mit der entsprechenden Anzahl an Zufallszahlen gefüllt.

Code: Alles auswählen

def info(size):
    numList = []
    for num in range(size):
        numList.append(random.randint(1, 10))
    return numList

Ginge das auch kompakter oder ist das ungefähr die Art, wie man so etwas in Python machen würde?

Danke für Hinweise.

Wenn's kompakter sein soll:

Code: Alles auswählen

def randoms(size):
    return [random.randint(1, 10) for i in size * [None]]

Moin,

Stichwort "List Comprehension":

Code: Alles auswählen

numlist = [random.randint(1, 10) for i in range(size)]

Gruß,
Manuel

Was ist eigentlich schneller? range(10) oder 10 * [None]?

Und wie finde ich das heraus? Wenn ich Timer benutze, nimmt er das nicht.

Besser:

Code: Alles auswählen

numlist = [random.randint(1, 10) for i in xrange(size)]

Da man ja die Liste von ``range`` gar nicht braucht.

bremer hat geschrieben:Und wie finde ich das heraus? Wenn ich Timer benutze, nimmt er das nicht.

``timeit``

bremer hat geschrieben:Was ist eigentlich schneller? range(10) oder 10 * [None]?

Ist das nicht für 10 Elemente total egal, da der Unterschied im Sub-Millisekundenbereich wäre? Sollte die Frage nicht lauten, was liest sich besser? Und da wäre meine Antwort: Die erste Variante.

Stefan

sma hat geschrieben:Sollte die Frage nicht lauten, was liest sich besser?

Nein, die Frage sollte lauten: "Was brauche ich eigentlich?". In diesem Fall wird kein Counter gebraucht. Es wird eine Funktion aufgerufen, die immer wieder die gleichen Parameter bekommt und das ganze wird in einer Liste gespeichert.

Code: Alles auswählen

from itertools import islice
from functional import partial
from random import randint

def repeat_call(func):
    while True: yield func()

print list(islice(repeat_call(partial(randint, 1,10)), 10))

Ich mach jetzt ne Runde Haskell. da wäre das nur:

Code: Alles auswählen

  gen <- newMTGen Nothing
  rand <- randoms gen
  print $ take 100000 rand

Ok, und wenn ich jetzt eine Liste von zweier-Tupeln haben will, wobei die Elemente der Tupel selber Zufallszahlen sind?

Code: Alles auswählen

def tupleListNoStringReturner(size):
    for i in range(size):
        k = random.randint(1, 10)
        v = random.randint(1, 10)
    return [(k, v) for i in range(size)]

Wie kann man das mit list comprehension machen?

Code: Alles auswählen

In [112]: [tuple(random.sample(xrange(1, 11), 2)) for _ in [None] * 10]
Out[112]: 
[(1, 2),
 (9, 7),
 (2, 9),
 (6, 10),
 (8, 4),
 (3, 5),
 (4, 2),
 (1, 9),
 (1, 5),
 (1, 7)]

Hier eine Lösung mit zwei Generator Expressions:

Code: Alles auswählen

from random import randint
from itertools import izip

def generate_random_tuples(size):
    a = (randint(1, 10) for i in xrange(size))
    b = (randint(1, 10) for i in xrange(size))
    return izip(a, b)

print list(generate_random_tuples(10))

Danke beide.
Ich versuche noch etwas:

Code: Alles auswählen

import types

for i in dir(types):
    print(i)

gibt alle types als String aus.
Wie kann ich nun den type als 'type' ausgeben, damit ich zu jedem type den doc-String aufrufen kann?

Mit timeit kann ich Statements "timen". Und wie mache ich das mit meinen Funktionen?

Genauso:

Code: Alles auswählen

timeit.Timer('[(lambda x:x*x)(i) for i in xrange(10)]').timeit()

Oder mit nicht-anonymen Funktionen:

Code: Alles auswählen

def foo(i):
    return i*i
timeit.Timer('[foo(i) for i in xrange(10)]', 'from __main__ import foo').timeit()

ich habs:

Code: Alles auswählen

for i in dir(types):
    print(getattr(types, i).__doc__)

kaum zu glauben, wie einfach (im Sinne von wenig Aufwand, wenn man weiss wies geht) das ist.

Code: Alles auswählen

In [82]: def mmap(func, times, seq):
    return ([func(item) for _ in xrange(times)] for item in seq)
   ....:

In [84]: list(mmap(unfold_args(randint), 2, (((1, 10), ) * 10)))
Out[84]:
[[9, 4],
 [8, 1],
 [8, 7],
 [6, 5],
 [2, 6],
 [5, 10],
 [10, 9],
 [7, 2],
 [1, 4],
 [2, 5]]

Was unfold_args macht sollte klar sein.

Nicht ganz, weil du dann ja auch noch das Ganze __*__-Zeugs bekommst. So wäre es besser:

Code: Alles auswählen

[getattr(types, type) for type in dir(types) if '__' not in type]

@ 10 * [None] vs xrange(10): xrange ist eigentlich der am meisten genutze Weg. Im Grunde ist es egal, aber grundsätzlich würde ich keine beliebigen Elemente zum "xmal" iterieren benutzen, sonderen immer {x,}range Objekte, selbst wenn ich die Zahl eigentlich nicht brauche. (und "i" als Variable).

bremer hat geschrieben:Was ist eigentlich schneller? range(10) oder 10 * [None]?

Sollte es hier wirklich auf Performance ankommen - bei n=10 sicher nicht - , dann ist die Erzeugung der Zufallszahlen der Flaschenhals: randint() ist die langsamste Methode, randrange() ist etwas schneller und random() ist erheblich schneller als die beiden anderen Varianten, und zwar selbst dann noch, wenn man ganzzahlige Werte eines bestimmten Intervalls damit erzeugt.

str1442 hat geschrieben:(und "i" als Variable).

Was spricht gegen `dummy`? Gut, das ist jetzt etwas kleinkariert, aber wenn ich die Namen nach ihrer Verwendung vergebe und weiß, dass ich `i` quasi nur als Mittel zum Zweck benötige, macht das ja eigentlich Sinn, find ich.

Das deutsche Python-Forum

Liste mit Zufallszahlen füllen

Liste mit Zufallszahlen füllen