danh sách với danh sách vô hạn

Question

Tôi cần phải hoạt động trên hai danh sách vô hạn vô hạn số, nhưng không thể tìm cách tạo, lưu trữ và vận hành trên đó bằng python.

Bất kỳ ai cũng có thể gợi ý cho tôi cách xử lý số học vô hạn hoặc bất kỳ chuỗi nào và cách vận hành chúng xem xét việc sử dụng bộ nhớ và thời gian tối thiểu.

Cảm ơn mọi người đã đề xuất trước.

Answer 1

Bạn đang tìm kiếm một python generator thay vì:

def infinitenumbers(): 
    count = 0 
    while True: 
     yield count 
     count += 1 

Gói itertools đi kèm với một pre-built count generator.

>>> import itertools 
>>> c = itertools.count() 
>>> next(c) 
0 
>>> next(c) 
1 
>>> for i in itertools.islice(c, 5): 
...  print i 
... 
2 
3 
4 
5 
6 

Answer 2

Đây là nơi số iterator xuất hiện. Bạn không thể có danh sách vô hạn các số, nhưng bạn có thể có trình lặp vô hạn.

import itertools 
arithmetic_progression = itertools.count(start,step) #from the python docs 

Các tài liệu cho python2 thể được tìm thấy here

Answer 3

Có lẽ cách tự nhiên để tạo ra một chuỗi vô hạn đang sử dụng một máy phát điện:

def arith(a, d): 
    while True: 
    yield a 
    a += d 

Điều này có thể được sử dụng như sau:

print list(itertools.islice(arith(10, 2), 100)) 

Answer 4

Giải pháp của tôi là:

from hofs import * 
def cons_stream(head,tail): 
    return [head,tail,False,False] 
def stream_cdr(strm): 
    if strm[2]: 
     return strm[3] 
    strm[3] = strm[1]() 
    strm[2] = True 
    return strm[3] 
def show_stream(stream, num = 10): 
    if empty(stream): 
     return [] 
    if num == 0: 
     return [] 
    return adjoin(stream[0], show_stream(stream_cdr(stream), num - 1)) 
def add_streams(a , b): 
    if empty(a): 
     return b 
    if empty(b): 
     return a 
    return cons_stream(a[0] + b[0] , lambda : add_streams(stream_cdr(a), stream_cdr(b))) 
def stream_filter(pred , stream): 
    if empty(stream): 
     return [] 
    if pred(stream[0]): 
     return cons_stream(stream[0], lambda : stream_filter(pred, stream_cdr(stream))) 
    else: 
     return stream_filter(pred , stream_cdr(stream)) 
def sieve(stream): 
    return cons_stream(stream[0] , lambda : sieve(stream_filter(lambda x : x % stream[0] > 0 , stream_cdr(stream)))) 
ones = cons_stream(1, lambda : ones) 
integers = cons_stream(1, lambda : add_streams(ones, integers)) 
primes = sieve(stream_cdr(integers)) 
print(show_stream(primes)) 

Sao chép mã Python ở trên. Khi tôi thử nó, tôi có [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] là 10 trong một danh sách vô hạn các số nguyên tố.

Answer 5

Bạn cần hofs.py là

def empty(data): 
    return data == [] 

def adjoin(value,data): 
    result = [value] 
    result.extend(data) 
    return result 

def map(func, data): 
    if empty(data): 
     return [] 
    else: 
     return adjoin(func(data[0]), map(func, data[1:])) 

def keep(pred, data): 
    if empty(data): 
     return [] 
    elif pred(data[0]): 
     return adjoin(data[0] , keep(pred, data[1:])) 
    else: 
     return keep(pred, data[1:]) 

Answer 6

tôi có một giải pháp python3 (đọc SICP chương 3,5)

class Stream: 
def __init__(self, head, tail): 
     self.head = head 
     self.tail = tail 
     self.memory = None 
     self.isDone = False 
def car(self): 
     return self.head 
def cdr(self): 
     if self.isDone: 
       return self.memory 
     self.memory = self.tail() 
     self.isDone = True 
     return self.memory 
def __getitem__(self, pullFrom): 
     if pullFrom < 1 or self.memory == []: 
       return [] 
     return [self.car()] + self.cdr()[pullFrom - 1] 
def __repr__(self): 
     return "[" + repr(self.car()) + " x " + repr(self.tail) + "]" 
def map(self, func): 
     if self.memory == []: 
       return [] 
     return Stream(func(self.car()), lambda: Stream.map(self.cdr(), func)) 
def from_list(lst): 
    if lst == []: 
     return [] 
    return Stream(lst[0], lambda: 
        Stream.from_list(lst[1:])) 
def filter(self, pred): 
    if self.memory == []: 
     return [] 
    elif pred(self.car()): 
     return Stream(self.car(), lambda: Stream.filter(self.cdr(), pred)) 
    else: 
     return self.cdr().filter(pred) 
def sieve(self): 
    return Stream(self.car(), lambda: self.cdr().filter(lambda n: n % self.car() > 0).sieve()) 
def foreach(self, action, pull = None): 
    if pull is None: 
     action(self.car()) 
     self.cdr().foreach(action, pull) 
    elif pull <= 0: 
     return 
    else: 
     action(self.car()) 
     self.cdr().foreach(action, pull-1)and run: 

a = Stream(0, lambda: a.map((lambda x: x + 1))) 
print(a[10]) 

trả về: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

Nhưng suối đang uể oải đánh giá, vì vậy:

>>> a = Stream(0, lambda: a.map((lambda x: x + 1))) 
>>> print(a) 

in:

[0 x [...]]