python - 無限の要素を持つリスト

Question

2つの別々の無限の数のリストを操作する必要がありますが、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

次に、ラムダ式を使用して「無限リスト」を初期化し、リスト内のアイテムを変更できます。

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

私の解決策は次のとおりです。

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コードをコピーします。試してみると、素数の無限リストの10である[2、3、5、7、11、13、17、19、23、29]が得られました。

Answer 7

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