cara pythonic untuk melakukan sesuatu N kali tanpa variabel indeks?

Setiap hari aku semakin mencintai python.

Hari ini, saya menulis beberapa kode seperti:

for i in xrange(N):
    do_something()

Saya harus melakukan sesuatu N kali. Tetapi setiap waktu tidak tergantung pada nilai i(variabel indeks). Saya menyadari bahwa saya sedang membuat variabel yang tidak pernah saya gunakan ( i), dan saya pikir "Pasti ada cara yang lebih pythonic untuk melakukan ini tanpa perlu untuk variabel indeks yang tidak berguna."

Jadi ... pertanyaannya adalah: apakah Anda tahu bagaimana melakukan tugas sederhana ini dengan cara yang lebih (pythonic) yang indah?

Pendekatan yang sedikit lebih cepat daripada melakukan looping xrange(N)adalah:

import itertools

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

Gunakan variabel _, seperti yang saya pelajari ketika saya mengajukan pertanyaan ini , misalnya:

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

Saya hanya menggunakan for _ in range(n), langsung ke intinya. Ini akan menghasilkan seluruh daftar untuk angka besar di Python 2, tetapi jika Anda menggunakan Python 3 itu tidak masalah.

karena fungsi adalah warga negara kelas satu, Anda dapat menulis pembungkus kecil (dari jawaban Alex)

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

maka Anda dapat melewati fungsi sebagai argumen.

_ Adalah hal yang sama dengan x. Namun itu adalah idiom python yang digunakan untuk menunjukkan pengidentifikasi yang tidak ingin Anda gunakan. Dalam python pengidentifikasi ini tidak membutuhkan memor atau mengalokasikan ruang seperti variabel lakukan dalam bahasa lain. Mudah untuk melupakannya. Mereka hanya nama yang menunjuk ke objek, dalam hal ini bilangan bulat pada setiap iterasi.

Saya menemukan berbagai jawaban yang sangat elegan (terutama jawaban Alex Martelli) tetapi saya ingin mengukur sendiri kinerjanya, jadi saya membuat skrip berikut:

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))

Saya juga datang dengan solusi alternatif yang dibangun di atas Martelli dan digunakan map()untuk memanggil fungsi payload. OK, saya sedikit curang karena saya mengambil kebebasan untuk membuat payload menerima parameter yang dibuang: Saya tidak tahu apakah ada cara untuk mengatasi ini. Namun demikian, berikut hasilnya:

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

jadi menggunakan peta menghasilkan peningkatan sekitar 30% di atas standar untuk loop dan tambahan 19% di atas Martelli.

Anggap Anda telah mendefinisikan do_something sebagai fungsi, dan Anda ingin melakukannya N kali. Mungkin Anda bisa mencoba yang berikut:

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

Bagaimana dengan loop sementara sederhana?

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

Anda sudah memiliki variabel; mengapa tidak menggunakannya?