Thêm cách Pythonic để chạy một quy trình X lần

Cái nào nhiều pythonic hơn?

Trong khi lặp lại:

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

Vòng lặp for:

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

Chỉnh sửa: không trùng lặp vì điều này có câu trả lời để xác định cái nào rõ ràng hơn, so với cách chạy một phạm vi mà không có 'i' - mặc dù điều đó cuối cùng là thanh lịch nhất

Cá nhân:

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

nếu bạn không cần i. Nếu bạn sử dụng Python <3 và bạn muốn lặp lại vòng lặp nhiều lần, hãy sử dụng xrangevì không cần tạo toàn bộ danh sách trước.

Vòng lặp for chắc chắn là khó hiểu hơn, vì nó sử dụng cấp độ cao hơn được tích hợp sẵn của Python để truyền đạt những gì bạn đang làm rõ ràng và ngắn gọn hơn. Chi phí của dải ô so với xrange và việc gán một ibiến không sử dụng , xuất phát từ việc không có câu lệnh như repeatcâu lệnh của Verilog . Lý do chính để gắn bó với giải pháp cho phạm vi là các cách khác phức tạp hơn. Ví dụ:

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"

Sử dụng lặp lại thay vì phạm vi ở đây ít rõ ràng hơn vì nó không được biết đến nhiều như một hàm và phức tạp hơn vì bạn cần nhập nó. Các hướng dẫn phong cách chính nếu bạn cần tham khảo là PEP 20 - The Zen of Python và PEP 8 - Style Guide for Python Code .

Chúng tôi cũng lưu ý rằng phiên bản cho phạm vi là một ví dụ rõ ràng được sử dụng trong cả tham chiếu và hướng dẫn ngôn ngữ , mặc dù trong trường hợp đó, giá trị được sử dụng. Nó có nghĩa là biểu mẫu này chắc chắn sẽ quen thuộc hơn sự mở rộng while của vòng lặp for kiểu C.

Nếu bạn đang theo đuổi các tác dụng phụ xảy ra trong vòng lặp, cá nhân tôi sẽ đi range()tiếp cận.

Nếu bạn quan tâm đến kết quả của bất kỳ hàm nào bạn gọi trong vòng lặp, tôi sẽ tìm hiểu danh sách hoặc mapcách tiếp cận. Một cái gì đó như thế này:

def f(n):
    return n * n

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

Làm thế nào về?

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

hoặc theo cách xấu xí hơn:

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

hoặc nếu bạn muốn xem lần cuối cùng thông qua:

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

Ở đâu:

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

Không có một cách thực sự nào để lặp lại điều gì đó. Tuy nhiên, đó là một cách tốt hơn:

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

Nếu bạn cần chuyển chỉ mục thì:

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

Hãy coi rằng nó trả về kết quả dưới dạng một tập hợp. Vì vậy, nếu bạn cần thu thập kết quả, nó có thể giúp ích.