bir dizin değişkeni olmadan N kez bir şey yapmak için pythonic yolu?

Her gün python'u daha çok seviyorum.

Bugün, gibi bir kod yazıyordum:

for i in xrange(N):
    do_something()

N kere bir şeyler yapmak zorunda kaldım. Ancak her seferinde i(index değişkeni) değerine bağlı değildi . Hiç kullanmadığım bir değişken yarattığımı fark ettim ( i) ve "Bu işe yaramaz indeks değişkenine ihtiyaç duymadan bunu yapmanın daha pitonik bir yolu var." Diye düşündüm.

Yani ... soru şu: bu basit görevi daha güzel (pitonik) nasıl yapacağınızı biliyor musunuz?

Döngüden biraz daha hızlı bir yaklaşım xrange(N):

import itertools

for _ in itertools.repeat(None, N):
    do_something()

Bu soruyu sorduğumda öğrendiğim gibi _ değişkenini kullanın, örneğin:

# A long way to do integer exponentiation
num = 2
power = 3
product = 1
for _ in xrange(power):
    product *= num
print product

Sadece kullanıyorum for _ in range(n), doğrudan konuya değindim. Python 2'de büyük sayılar için tüm listeyi oluşturacak, ancak Python 3 kullanıyorsanız sorun değil.

işlev birinci sınıf vatandaş olduğundan, küçük bir paket yazabilirsiniz (Alex cevaplarından)

def repeat(f, N):
    for _ in itertools.repeat(None, N): f()

işlevi bağımsız değişken olarak iletebilirsiniz.

_, X ile aynı şeydir. Ancak, kullanmak istemediğiniz bir tanımlayıcıyı belirtmek için kullanılan bir python deyimi. Python'da bu tanımlayıcılar, diğer dillerdeki değişkenler gibi bellek almaz veya yer ayırmaz. Bunu unutmak kolay. Bunlar sadece nesnelere işaret eden isimler, bu durumda her yinelemede bir tamsayı.

Çeşitli cevapları gerçekten zarif buldum (özellikle Alex Martelli'nin) ama performansı ilk elden ölçmek istedim, bu yüzden aşağıdaki senaryoyu pişirdim:

from itertools import repeat
N = 10000000

def payload(a):
    pass

def standard(N):
    for x in range(N):
        payload(None)

def underscore(N):
    for _ in range(N):
        payload(None)

def loopiter(N):
    for _ in repeat(None, N):
        payload(None)

def loopiter2(N):
    for _ in map(payload, repeat(None, N)):
        pass

if __name__ == '__main__':
    import timeit
    print("standard: ",timeit.timeit("standard({})".format(N),
        setup="from __main__ import standard", number=1))
    print("underscore: ",timeit.timeit("underscore({})".format(N),
        setup="from __main__ import underscore", number=1))
    print("loopiter: ",timeit.timeit("loopiter({})".format(N),
        setup="from __main__ import loopiter", number=1))
    print("loopiter2: ",timeit.timeit("loopiter2({})".format(N),
        setup="from __main__ import loopiter2", number=1))

Ayrıca Martelli'nin çözümüne dayanan map()ve faydalı yük fonksiyonunu çağırmak için kullanılan alternatif bir çözüm buldum . Tamam, yükü atılan bir parametreyi kabul etme özgürlüğünü aldığım için biraz hile yaptım: Bunun bir yolu olup olmadığını bilmiyorum. Bununla birlikte, sonuçlar şunlardır:

standard:  0.8398549720004667
underscore:  0.8413165839992871
loopiter:  0.7110594899968419
loopiter2:  0.5891903560004721

bu nedenle harita kullanmak döngü standardı üzerinde yaklaşık% 30 ve Martelli'lere göre% 19 daha fazla iyileşme sağlar.

Do_something öğesini bir işlev olarak tanımladığınızı ve bunu N kez gerçekleştirmek istediğinizi varsayın . Belki aşağıdakileri deneyebilirsiniz:

todos = [do_something] * N  
for doit in todos:  
    doit()

Basit bir while döngüsü ne olacak?

while times > 0:
    do_something()
    times -= 1

Değişken zaten var; neden kullanmıyorsun?