Cara Lebih Pythonic untuk Menjalankan Proses X Kali

Mana yang lebih pythonic?

While loop:

count = 0
while count < 50:
    print "Some thing"
    count = count + 1

Untuk loop:

for i in range(50):
    print "Some thing"

Sunting: bukan duplikat karena ini memiliki jawaban untuk menentukan mana yang lebih jelas, vs. bagaimana menjalankan rentang tanpa 'i' - meskipun itu akhirnya menjadi yang paling elegan

Sendiri:

for _ in range(50):
    print "Some thing"

jika Anda tidak membutuhkannya i. Jika Anda menggunakan Python <3 dan Anda ingin mengulang loop berkali-kali, gunakan xrangekarena tidak perlu membuat seluruh daftar sebelumnya.

Perulangan for jelas lebih pythonic, karena menggunakan fungsionalitas bawaan tingkat tinggi Python untuk menyampaikan apa yang Anda lakukan dengan lebih jelas dan ringkas. Overhead range vs xrange, dan menugaskan yang tidak digunakani variabel yang , berasal dari tidak adanya pernyataan seperti pernyataan Verilog repeat. Alasan utama untuk tetap menggunakan solusi for adalah cara lain yang lebih kompleks. Contohnya:

from itertools import repeat

for unused in repeat(None, 10):
    del unused   # redundant and inefficient, the name is clear enough
    print "This is run 10 times"

Menggunakan repeat daripada range di sini kurang jelas karena ini bukan fungsi yang begitu terkenal, dan lebih kompleks karena Anda perlu mengimpornya. Panduan gaya utama jika Anda memerlukan referensi adalah PEP 20 - Zen of Python dan PEP 8 - Panduan Gaya untuk Kode Python .

Kami juga mencatat bahwa versi for range adalah contoh eksplisit yang digunakan baik dalam referensi bahasa dan tutorial , meskipun dalam hal ini nilainya digunakan. Ini berarti bentuknya pasti lebih familiar daripada perluasan while gaya-C for loop.

Jika Anda mencari efek samping yang terjadi dalam loop, saya pribadi akan memilih range() pendekatan.

Jika Anda peduli tentang hasil dari fungsi apa pun yang Anda panggil dalam loop, saya akan mencari pemahaman atau mappendekatan daftar. Sesuatu seperti ini:

def f(n):
    return n * n

results = [f(i) for i in range(50)]
# or using map:
results = map(f, range(50))

Bagaimana tentang?

while BoolIter(N, default=True, falseIndex=N-1):
    print 'some thing'

atau dengan cara yang lebih jelek:

for _ in BoolIter(N):
    print 'doing somthing'

atau jika Anda ingin mengetahui waktu terakhir melalui:

for lastIteration in BoolIter(N, default=False, trueIndex=N-1):
    if not lastIteration:
        print 'still going'
    else:
        print 'last time'

dimana:

class BoolIter(object):

    def __init__(self, n, default=False, falseIndex=None, trueIndex=None, falseIndexes=[], trueIndexes=[], emitObject=False):
        self.n = n
        self.i = None
        self._default = default
        self._falseIndexes=set(falseIndexes)
        self._trueIndexes=set(trueIndexes)
        if falseIndex is not None:
            self._falseIndexes.add(falseIndex)
        if trueIndex is not None:
            self._trueIndexes.add(trueIndex)
        self._emitObject = emitObject


    def __iter__(self):
        return self

    def next(self):
        if self.i is None:
            self.i = 0
        else:
            self.i += 1
        if self.i == self.n:
            raise StopIteration
        if self._emitObject:
            return self
        else:
            return self.__nonzero__()

    def __nonzero__(self):
        i = self.i
        if i in self._trueIndexes:
            return True
        if i in self._falseIndexes:
            return False
        return self._default

    def __bool__(self):
        return self.__nonzero__()

Tidak ada cara yang benar-benar pythonic untuk mengulangi sesuatu. Namun, ini cara yang lebih baik:

map(lambda index:do_something(), xrange(10))

Jika Anda perlu meneruskan indeks, maka:

map(lambda index:do_something(index), xrange(10))

Pertimbangkan bahwa ia mengembalikan hasil sebagai koleksi. Jadi, jika Anda perlu mengumpulkan hasilnya, itu bisa membantu.