随机游走码python

您如何加快以下代码的速度，使其能够执行100多个任务

""" Random Walker """
import numpy as np
import scipy as sp
import random as rd
import time

def procedure():
    time.sleep(2.5)
    t0C = time.clock()
    t0 = time.time()

    """Definitions"""

    def ifilterfalse(predicate, iterable):
        # ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
        if predicate is None:
            predicate = bool
        for x in iterable:
            if not predicate(x):
                yield x

    def unique_everseen(iterable, key=None):
        "List unique elements, preserving order. Remember all elements ever seen."
        # unique_everseen('AAAABBBCCDAABBB') --> A B C D
        # unique_everseen('ABBCcAD', str.lower) --> A B C D
        seen = set()
        seen_add = seen.add
        if key is None:
            for element in ifilterfalse(seen.__contains__, iterable):
                seen_add(element)
                yield element
        else:
            for element in iterable:
                k = key(element)
                if k not in seen:
                    seen_add(k)
                    yield element

    """Creating the Random Walk"""

    n=int(input('Number of Individuals at Table: '))
    iters=10000
    final=np.zeros(n)
    total=0
    for j in xrange(iters):
        d=np.array([0])
        i=0
        while i<1:
            new=d[len(d)-1]+rd.choice([-1,1])
            if new<0:
                new+=n
            elif new>=n:
                new-=n
            d=np.append(d,new)
            dshort=list(unique_everseen(d))
            if len(dshort)>=n:
                i=1
            last=dshort[len(dshort)-1]
            length=len(d)
        final[last]+=1
        total+=length

    final=np.round(final/iters,4)
    total=round(total/iters,3)

    """Writing To A File"""

    print (40 * '-')
    print (" ")
    print ("   Percentages: ")
    print (" ")
    print ("   S#:"+"      S#:".join(map(str,range(n))))
    print ("   "+"%   ".join(map(str,final))+"%")
    print (" ")
    print ("   Average Number of Passes of Plate: {}".format(total))
    print (" ")
    print (40 * '-')

    # measure process time
    print time.clock() - t0C, "seconds process time"

     # measure wall time
    print time.time() - t0, "seconds wall time"


if __name__ == "__main__":
    procedure()

“随机漫游者”
将numpy作为np导入
将scipy作为sp导入
将随机导入为rd
导入时间
def过程（）：
时间。睡眠（2.5）
t0C=time.clock（）
t0=时间。时间（）
“定义”
def ifilterfalse（谓词，iterable）：
#ifilterfalse（λx:x%2，范围（10））-->0 2 4 6 8
如果谓词为无：
谓词=bool
对于iterable中的x：
如果不是谓词（x）：
产量x
def unique_everseen（iterable，key=None）：
列出唯一的元素，保持顺序。记住所有见过的元素
#独特的（“AAAABBBCCDAABBB”）->A B C D
#独特的埃弗森（'abbcad'，str.lower）->A B C D
seen=set（）
seen_add=seen.add
如果键为“无”：
对于ifilterfalse中的元素（请参见._包含_uu，iterable）：
见添加（元素）
屈服要素
其他：
对于iterable中的元素：
k=键（元素）
如果未看到k：
见附录（k）
屈服要素
“”“正在创建随机漫游”“”
n=int（输入（'表中的个体数量：'））
iters=10000
最终=np.零（n）
总数=0
对于X范围内的j（iters）：
d=np.array（[0]）
i=0
当i=n时：
i=1
last=dshort[len（dshort）-1]
长度=长度（d）
最终[最后]+=1
总长度+=长度
最终=np.轮（最终/iters，4）
总计=四舍五入（总计/iters，3）
“”“正在写入文件”“”
打印（40*'-'）
打印（“”）
打印（“百分比：”）
打印（“”）
打印（“S:”+“S:”。连接（映射（str，range（n）））
打印（“+”%.”连接（映射（str，final））+“%”）
打印（“”）
打印（“板的平均通过次数：{}”。格式（总数））
打印（“”）
打印（40*'-'）
#测量过程时间
打印时间.时钟（）-t0C，“秒处理时间”
#测壁时间
打印时间.time（）-t0，“秒墙时间”
如果名称=“\uuuuu main\uuuuuuuu”：
程序（）

目前，对于10个人的情况，时间是：

5.877529秒处理时间

12.9134569168秒壁时间

---

问题是当个体数（1001000）增加时，代码速度太慢，有什么建议吗

问题是，

unique\u everseen

在连续执行中几乎做相同的工作，消耗了太多的时间。下面是一个简化版本，它删除了

unique\u everseed

函数和

d

列表，并使用直接在主循环中设置的

seen

和

last

var来保留最后一项：

""" Random Walker """
import random as rd
import time

def procedure():
    n = int(input('Number of Individuals at Table: '))

    t0C = time.clock()
    t0 = time.time()

    iters = 10000
    final = [0] * n
    total = 0
    for j in xrange(iters):
        last = 0
        count = 1
        seen = set([0])
        while len(seen) < n:
            count += 1;
            new = last + rd.choice([-1, 1])
            if new < 0:
                new += n
            elif new >= n:
                new -= n
            seen.add(new)
            last = new
        final[last] += 1
        total += count

    final = [round(float(f) / iters, 4) for f in final]
    total = round(float(total) / iters, 3)

    """Writing To A File"""

    print(40 * '-')
    print(" ")
    print("   Percentages: ")
    print(" ")
    print("   S#:" + "      S#:".join(map(str, range(n))))
    print("   " + "%   ".join(map(str, final)) + "%")
    print(" ")
    print("   Average Number of Passes of Plate: {}".format(total))
    print(" ")
    print(40 * '-')

    # measure process time
    print time.clock() - t0C, "seconds process time"

    # measure wall time
    print time.time() - t0, "seconds wall time"


if __name__ == "__main__":
    procedure()

“随机漫游者”
将随机导入为rd
导入时间
def过程（）：
n=int（输入（'表中的个体数量：'））
t0C=time.clock（）
t0=时间。时间（）
iters=10000
最终=[0]*n
总数=0
对于X范围内的j（iters）：
最后一个=0
计数=1
seen=set（[0]）
而len（seen）=n：
新-=n
见。添加（新）
最后的=新的
最终[最后]+=1
总数+=计数
决赛=[决赛f轮（浮动（f）/iters，4）
总计=圆形（浮动（总计）/国际热核实验堆，3）
“”“正在写入文件”“”
打印（40*'-'）
打印（“”）
打印（“百分比：”）
打印（“”）
打印（“S:”+“S:”。连接（映射（str，range（n）））
打印（“+”%.”连接（映射（str，final））+“%”）
打印（“”）
打印（“板的平均通过次数：{}”。格式（总数））
打印（“”）
打印（40*'-'）
#测量过程时间
打印时间.时钟（）-t0C，“秒处理时间”
#测壁时间
打印时间.time（）-t0，“秒墙时间”
如果名称=“\uuuuu main\uuuuuuuu”：
程序（）

请注意，删除

numpy

依赖项允许脚本使用

pypy

某些结果（以秒为单位）

• 10个人
  • python:0.472
  • pypy:0.084
• 100个人
  • python:49.352
  • 派比：3.256
• 500人
  • 派比：80.460
• 1000人
  • 派比：318.392

---

如果你修正缩进，答案会更容易回答。很抱歉，缩进已经修正了。是的，虽然我注意到总数的精度/结果变化了超过1个单位，但速度更快。为什么会这样？造成差异的一个原因是我用

total=round（total/iters，3）

替换为

total=round（float（total）/iters，3）

使除法（和整轮）正确工作（

total/iters

是一个整数除法）。另外，a忘了用

[0]

初始化

seen

，现在我修复了它。