programming python

Trình tạo css python

là một đối tượng có thể lặp lại [được lặp lại]. Nó được sử dụng để phản ánh dữ liệu vùng chứa để làm cho nó hoạt động giống như một đối tượng có thể lặp lại. You could you used one vài đối tượng có thể lặp lại mỗi ngày. chuỗi, list and dictionary to set name for a number

Một iterator được định nghĩa bởi một lớp thực hiện các Giao thức Iterator . Giao thức này chỉ ra hai phương pháp trong lớp học.

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

5 và

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

Quay lại. Tại sao bạn thậm chí muốn tạo ra iterators?

Tiết kiệm thời gian không bộ nhớ

Iterator không tính toán giá trị của mỗi mục khi khởi tạo. Chúng chỉ tính toán cho nó khi bạn yêu cầu nó. Đây được gọi là đánh giá lười biếng.

Đánh giá lười biếng thực sự hữu ích khi bạn có một bộ dữ liệu cực lớn để tính toán. Nó cho phép bạn sử dụng dữ liệu ngay lập tức, trong khi cả bộ dữ liệu đang được tính toán

Giả sử chúng ta muốn nhận tất cả các nguyên tố số nhỏ hơn một số cực đại

Trước đó, chúng tôi xác định chức năng kiểm tra nếu một số là số nguyên tố

def check_prime[number]:
    for divisor in range[2, int[number ** 0.5] + 1]:
        if number % divisor == 0:
            return False
    return True

Sau đó, chúng ta định nghĩa lớp bao gồm phương thức

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

5 và

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

9 được khởi tạo với giá trị lớn nhất. If the integer integer to continue by large more than

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

0, iterator will boost a exception

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

1, end iterator

Khi chúng ta yêu cầu các phần tử tiếp theo trong Iterator, nó sẽ tăng

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

2 một đơn vị và kiểm tra xem đó có phải là một số nguyên tố hay không. Nếu không, nó sẽ gọi

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

6 một lần nữa cho đến khi

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

4đó là nguyên tố. Một khi đạt được, Iterator trả về số

Bằng cách sử dụng một Iterator, chúng ta không tạo ra một danh sách các nguyên tố trong bộ nhớ của chúng ta. Thay vào đó, chúng tôi sẽ tạo ra nguyên tố tiếp theo mỗi khi được yêu cầu

Please try it

primes = Primes[100000000000]
print[primes]
for x in primes:
    print[x]
---------

2
3
5
7
11
...

Mỗi lần lặp lại của đối tượng

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

5 gọi

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

6 để tạo nguyên tố tiếp theo

Iterator chỉ có thể được lặp lại qua một lần . Nếu bạn cố lặp lại

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

7 một lần nữa, sẽ không có bất kỳ giá trị nào được trả lại và điều này hoạt động giống như một danh sách trống rỗng.

Bây giờ chúng ta đã biết iterator là gì và làm thế nào để tạo ra chúng, tiếp theo là về máy phát điện

Máy phát điện

Nhớ lại rằng hàm tạo cho phép chúng ta tạo ra các iterator theo một cách đơn giản hơn

Trình tạo giới thiệu câu lệnh

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

8 cho Python. Nó hoạt động giống như

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

9 vì nó trả về một giá trị.

Do đó, chúng ta đã tiết kiệm được trạng thái của chức năng. Trong lần tiếp theo chức năng được gọi, vẫn tiếp tục từ nơi dừng lại, cùng với các giá trị biến mà nó đã có trước khi mang lại kết quả

Nếu chúng ta chuyển _____19 iterator thành generator, it will same as after

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

Bây giờ đó là Pythonic. Liệu ta có thể làm tốt hơn không?

Qua đó, chúng ta có thể sử dụng Generator Expressions, được giới thiệu với PEP 289.

Đây là danh sách hiểu tương đương của trình tạo. Nó hoạt động chính xác giống như hiểu, nhưng biểu thức được đặt trong_______61 và ngược lại với

primes = Primes[100000000000]
print[primes]
for x in primes:
    print[x]
---------

2
3
5
7
11
...

Các biểu thức sau đây có thể thay thế chức năng trình tạo ở trên

class Primes:
    def __init__[self, max]:
        self.max = max
        self.number = 1
    def __iter__[self]:
        return self
    def __next__[self]:
        self.number += 1
        if self.number >= self.max:
            raise StopIteration
        elif check_prime[self.number]:
            return self.number
        else:
            return self.__next__[]

Đây là khả năng của trình tạo bằng Python

Tóm tắt

Generator cho phép bạn tạo các iterator theo cách rất Pythonic
Iterator cho phép đánh giá lười biếng, chỉ tạo phần tử tiếp theo của một đối tượng có thể lặp lại khi được yêu cầu. Điều này hữu ích đối với bộ dữ liệu cực lớn

Máy phát điện

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề