無限精彩列表

Question

我需要操作兩個單獨的無限列表的數字，但無法找到一種方式來產生，存儲和操作它在Python中。

任何人都可以請我建議一種方法來處理無限的算術運算或任何系列，以及如何對它們進行操作，考慮到最小的內存使用和時間。

感謝每一位提前提出的建議。

Answer 1

你正在尋找一個python generator代替：

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

的itertools包帶有預建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

這就是iterator進來。你不能數的無限名單，但你可以有無限的迭代器。

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

爲Python2該文檔可以發現here

Answer 3

也許自然的方式來生成一個無窮級數是利用發電機：

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

這可以用於像這樣：

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

Answer 4

我的解決方案是：

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

複製上面的Python代碼。 當我嘗試它時，我得到了[2,3,5,7,11,13,17,19,23,29]這是無限的素數列表中的10個。

Answer 5

你需要hofs.py是

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

我還有一個python3溶液（讀SICP 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]) 

返回： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]。

但流懶洋洋地評估，所以：

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

打印：

[0 x [...]]