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

要创建一个充当“可变”无限列表的对象，可以在类中重载__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"

类似地，可以创建一个“ infinite dictionary”，为每个丢失的键提供默认值。

Answer 4

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

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

这可以这样使用：

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

Answer 5

我的解决方案是：

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

我有另一个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 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)

列表中包含无限元素

8 个答案: