python - 具有无限元素的列表

Question

我需要对两个单独的无限数字列表进行操作，但找不到在 python 中生成、存储和操作它的方法。

考虑到内存和时间的最小使用，任何人都可以建议我一种处理无限算术推进或任何系列的方法以及如何对它们进行操作。

提前感谢大家的建议。

Answer 1

您正在寻找一个python 生成器：

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

该itertools软件包带有一个预构建的count生成器。

>>> 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 的文档可以在这里找到

Answer 3

我有另一个 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 [...]]

Answer 4

要创建一个类似于“可变”无限列表的对象，您可以重载类中的__getitem__和__setitem__方法：

class infinite_list():
    def __init__(self, func):
        self.func = func
        self.assigned_items = {}
    def __getitem__(self, key):
        if key in self.assigned_items:
            return self.assigned_items[key]
        else:
            return self.func(key)
    def __setitem__(self, key , value):
        self.assigned_items[key] = value

然后，您可以使用 lambda 表达式初始化“无限列表”并修改列表中的项目：

infinite_thing = infinite_list(lambda a: a*2)

print(infinite_thing[1]) #prints "2"
infinite_thing[1] = infinite_thing[2]
print(infinite_thing[1]) #prints "4"

类似地，可以创建一个“无限字典”，为每个缺失的键提供一个默认值。

Answer 5

也许生成无限系列的自然方法是使用生成器：

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

这可以像这样使用：

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

Answer 6

你需要 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 7

我的解决方案是：

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 8

我假设您想要一个范围内的无限数列表。我有类似的问题，这是我的解决方案：

c = 0
step = 0.0001 # the difference between the numbers
limit = 100 # The upper limit 
myInfList = []
while c <= limit:
    myInfList.append(c)
    c = c + step
print(myInfList)