遗传算法python实验报告

⑴ python 遗传算法问题

遗传算法（GA）是最早由美国Holland教授提出的一种基于自然界的“适者生存，优胜劣汰”基本法则的智能搜索算法。
遗传算法也是借鉴该基本法则，通过基于种群的思想，将问题的解通过编码的方式转化为种群中的个体，并让这些个体不断地通过选择、交叉和变异算子模拟生物的进化过程，然后利用“优胜劣汰”法则选择种群中适应性较强的个体构成子种群，然后让子种群重复类似的进化过程，直到找到问题的最优解或者到达一定的进化（运算）时间。

⑵ 关于遗传算法的Python，请问如何修改达到想要的目的

defrun(self):
foriinrange(self.generation_max):
self.generation=i
self.evolve()
printi
foriinrange(self.indivials):
(x,y)=self.decode(interval,chrom1)
self.decode(interval,chrom2))
print（x,y)

⑶ 老师要求用python做遗传算法，原理明白，可是不会代码，哪位老哥帮讲讲，价钱可以商量

还是蛮简单的，而且 python 中有现成的遗传算法工具箱可用。
实现的关键则是如何进行编码，这个码就是函数的参数，参数的个数就是染色体中基因的个数， 选择交叉变异，无非就是改变基因的值而不改变染色体的长度，然后产生新的染色体，将新的染色体重的值以参数的形式带入到函数中求得新的函数值

⑷ Python 遗传算法的数学应用

来自nnetinfo目前可以做的一般有:分类.函数拟合压缩.图象识别等等,其实说到底,所有的都能归于第2点--函数拟合.一般如果输入与输出是有强烈关系的,网络都能找得到这个关系.例如病人的特征作为输入,判断这个是否为病人,一般都是可以的.业务背景知识强,才能把神经网络运用到实际中.另外,还需要把实现问题转换为数学问题的能力.例如数字识别就是一个经典的应用.但直接把图片放进去训练是得不到识别效果的,因为维度太多了,而且信息冗余量很大.于是有人把图片的特征先自已提取出来:例如对角线与图片上的数字有几个交点等等,再把这些特征作为输入,数字类别向量作为输出,放到网络中训练.最后你再写一个数字,提取这个数字的特征,再把这特征放进网络中的时候,它就能识别到你是哪个数字了.另外,又有人用卷积神经网络去做数字识别.还有人用深度网络去做,即先把原来图片的信息用RBM网络进行压缩,然后再训练,效果就好了.等等,其实很多问题都可以做,但前提是你要想到好的方式去运用神经网络.

⑸ python有没有简单的遗传算法库

首先遗传算法是一种优化算法，通过模拟基因的优胜劣汰，进行计算（具体的算法思路什么的就不赘述了）。大致过程分为初始化编码、个体评价、选择，交叉，变异。

以目标式子 y = 10 * sin(5x) + 7 * cos(4x)为例，计算其最大值

首先是初始化，包括具体要计算的式子、种群数量、染色体长度、交配概率、变异概率等。并且要对基因序列进行初始化

[python]view plain

• pop_size=500#种群数量

• max_value=10#基因中允许出现的最大值

• chrom_length=10#染色体长度

• pc=0.6#交配概率

• pm=0.01#变异概率

• results=[[]]#存储每一代的最优解，N个二元组

• fit_value=[]#个体适应度

• fit_mean=[]#平均适应度

• pop=geneEncoding(pop_size,chrom_length)




其中genEncodeing是自定义的一个简单随机生成序列的函数，具体实现如下

[python]view plain

• defgeneEncoding(pop_size,chrom_length):

• pop=[[]]

• foriinrange(pop_size):

• temp=[]

• forjinrange(chrom_length):

• temp.append(random.randint(0,1))

• pop.append(temp)

• returnpop[1:]

编码完成之后就是要进行个体评价，个体评价主要是计算各个编码出来的list的值以及对应带入目标式子的值。其实编码出来的就是一堆2进制list。这些2进制list每个都代表了一个数。其值的计算方式为转换为10进制，然后除以2的序列长度次方减一，也就是全一list的十进制减一。根据这个规则就能计算出所有list的值和带入要计算式子中的值，代码如下

[python]view plain

• #0.0coding:utf-80.0

• #解码并计算值

• importmath

• defdecodechrom(pop,chrom_length):

• temp=[]

• foriinrange(len(pop)):

• t=0

• forjinrange(chrom_length):

• t+=pop[i][j]*(math.pow(2,j))

• temp.append(t)

• returntemp

• defcalobjValue(pop,chrom_length,max_value):

• temp1=[]

• obj_value=[]

• temp1=decodechrom(pop,chrom_length)

• foriinrange(len(temp1)):

• x=temp1[i]*max_value/(math.pow(2,chrom_length)-1)

• obj_value.append(10*math.sin(5*x)+7*math.cos(4*x))

• returnobj_value

有了具体的值和对应的基因序列，然后进行一次淘汰，目的是淘汰掉一些不可能的坏值。这里由于是计算最大值，于是就淘汰负值就好了

[python]view plain

• #0.0coding:utf-80.0

• #淘汰（去除负值）

• defcalfitValue(obj_value):

• fit_value=[]

• c_min=0

• foriinrange(len(obj_value)):

• if(obj_value[i]+c_min>0):

• temp=c_min+obj_value[i]

• else:

• temp=0.0

• fit_value.append(temp)

• returnfit_value




然后就是进行选择，这是整个遗传算法最核心的部分。选择实际上模拟生物遗传进化的优胜劣汰，让优秀的个体尽可能存活，让差的个体尽可能的淘汰。个体的好坏是取决于个体适应度。个体适应度越高，越容易被留下，个体适应度越低越容易被淘汰。具体的代码如下

[python]view plain

• #0.0coding:utf-80.0

• #选择

• importrandom

• defsum(fit_value):

• total=0

• foriinrange(len(fit_value)):

• total+=fit_value[i]

• returntotal

• defcumsum(fit_value):

• foriinrange(len(fit_value)-2,-1,-1):

• t=0

• j=0

• while(j<=i):

• t+=fit_value[j]

• j+=1

• fit_value[i]=t

• fit_value[len(fit_value)-1]=1

• defselection(pop,fit_value):

• newfit_value=[]

• #适应度总和

• total_fit=sum(fit_value)

• foriinrange(len(fit_value)):

• newfit_value.append(fit_value[i]/total_fit)

• #计算累计概率

• cumsum(newfit_value)

• ms=[]

• pop_len=len(pop)

• foriinrange(pop_len):

• ms.append(random.random())

• ms.sort()

• fitin=0

• newin=0

• newpop=pop

• #转轮盘选择法

• whilenewin<pop_len:

• if(ms[newin]<newfit_value[fitin]):

• newpop[newin]=pop[fitin]

• newin=newin+1

• else:

• fitin=fitin+1

• pop=newpop

• 以上代码主要进行了3个操作，首先是计算个体适应度总和，然后在计算各自的累积适应度。这两步都好理解，主要是第三步，转轮盘选择法。这一步首先是生成基因总数个0-1的小数，然后分别和各个基因的累积个体适应度进行比较。如果累积个体适应度大于随机数则进行保留，否则就淘汰。这一块的核心思想在于：一个基因的个体适应度越高，他所占据的累计适应度空隙就越大，也就是说他越容易被保留下来。

选择完后就是进行交配和变异，这个两个步骤很好理解。就是对基因序列进行改变，只不过改变的方式不一样

交配：

[python]view plain

• #0.0coding:utf-80.0

• #交配

• importrandom

• defcrossover(pop,pc):

• pop_len=len(pop)

• foriinrange(pop_len-1):

• if(random.random()<pc):

• cpoint=random.randint(0,len(pop[0]))

• temp1=[]

• temp2=[]

• temp1.extend(pop[i][0:cpoint])

• temp1.extend(pop[i+1][cpoint:len(pop[i])])

• temp2.extend(pop[i+1][0:cpoint])

• temp2.extend(pop[i][cpoint:len(pop[i])])

• pop[i]=temp1

• pop[i+1]=temp2



• 变异：

[python]view plain

• #0.0coding:utf-80.0

• #基因突变

• importrandom

• defmutation(pop,pm):

• px=len(pop)

• py=len(pop[0])

• foriinrange(px):

• if(random.random()<pm):

• mpoint=random.randint(0,py-1)

• if(pop[i][mpoint]==1):

• pop[i][mpoint]=0

• else:

• pop[i][mpoint]=1



• 整个遗传算法的实现完成了，总的调用入口代码如下

[python]view plain

• #0.0coding:utf-80.0

• importmatplotlib.pyplotasplt

• importmath

• fromselectionimportselection

• fromcrossoverimportcrossover

• frommutationimportmutation

• frombestimportbest

• print'y=10*math.sin(5*x)+7*math.cos(4*x)'

• #计算2进制序列代表的数值

• defb2d(b,max_value,chrom_length):

• t=0

• forjinrange(len(b)):

• t+=b[j]*(math.pow(2,j))

• t=t*max_value/(math.pow(2,chrom_length)-1)

• returnt

• pop_size=500#种群数量

• max_value=10#基因中允许出现的最大值

• chrom_length=10#染色体长度

• pc=0.6#交配概率

• pm=0.01#变异概率

• results=[[]]#存储每一代的最优解，N个二元组

• fit_value=[]#个体适应度

• fit_mean=[]#平均适应度

• #pop=[[0,1,0,1,0,1,0,1,0,1]foriinrange(pop_size)]

• pop=geneEncoding(pop_size,chrom_length)

• foriinrange(pop_size):

• obj_value=calobjValue(pop,chrom_length,max_value)#个体评价

• fit_value=calfitValue(obj_value)#淘汰

• best_indivial,best_fit=best(pop,fit_value)#第一个存储最优的解,第二个存储最优基因

• results.append([best_fit,b2d(best_indivial,max_value,chrom_length)])

• selection(pop,fit_value)#新种群复制

• crossover(pop,pc)#交配

• mutation(pop,pm)#变异

• results=results[1:]

• results.sort()

• X=[]

• Y=[]

• foriinrange(500):

• X.append(i)

• t=results[i][0]

• Y.append(t)

• plt.plot(X,Y)

• plt.show()

• 最后调用了一下matplotlib包，把500代最优解的变化趋势表现出来。



完整代码可以在github查看

欢迎访问我的个人博客

阅读全文

⑹ python遗传算法目标函数怎么编

一、遗传算法介绍
遗传算法是通过模拟大自然中生物进化的历程，来解决问题的。大自然中一个种群经历过若干代的自然选择后，剩下的种群必定是适应环境的。把一个问题所有的解看做一个种群，经历过若干次的自然选择以后，剩下的解中是有问题的最优解的。当然，只能说有最优解的概率很大。这里，我们用遗传算法求一个函数的最大值。
f(x) = 10 * sin( 5x ) + 7 * cos( 4x ), 0 <= x <= 10
1、将自变量x进行编码
取基因片段的长度为10, 则10位二进制位可以表示的范围是0到1023。基因与自变量转变的公式是x = b2d(indivial) * 10 / 1023。构造初始的种群pop。每个个体的基因初始值是[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
2、计算目标函数值
根据自变量与基因的转化关系式，求出每个个体的基因对应的自变量，然后将自变量代入函数f（x），求出每个个体的目标函数值。
3、适应度函数
适应度函数是用来评估个体适应环境的能力，是进行自然选择的依据。本题的适应度函数直接将目标函数值中的负值变成0. 因为我们求的是最大值，所以要使目标函数值是负数的个体不适应环境，使其繁殖后代的能力为0.适应度函数的作用将在自然选择中体现。
4、自然选择
自然选择的思想不再赘述，操作使用轮盘赌算法。其具体步骤：
假设种群中共5个个体，适应度函数计算出来的个体适应性列表是fitvalue = [1 ,3, 0, 2, 4] ，totalvalue = 10 ， 如果将fitvalue画到圆盘上，值的大小表示在圆盘上的面积。在转动轮盘的过程中，单个模块的面积越大则被选中的概率越大。选择的方法是将fitvalue转化为[1 ， 4 ，4 , 6 ，10], fitvalue / totalvalue = [0.1 , 0.4 , 0.4 , 0.6 , 1.0] . 然后产生5个0-1之间的随机数，将随机数从小到大排序，假如是[0.05 , 0.2 , 0.7 , 0.8 ,0.9]，则将0号个体、1号个体、4号个体、4号个体、4号个体拷贝到新种群中。自然选择的结果使种群更符合条件了。
5、繁殖
假设个体a、b的基因是
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]

b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]

这两个个体发生基因交换的概率pc = 0.6.如果要发生基因交换，则产生一个随机数point表示基因交换的位置，假设point = 4,则：

a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]

b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
交换后为：

a = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1]

b = [0, 0, 0, 1, 0, 1, 1, 1, 0, 0]
6、突变
遍历每一个个体，基因的每一位发生突变（0变为1,1变为0）的概率为0.001.突变可以增加解空间
二、代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def b2d(b): #将二进制转化为十进制 x∈[0,10] t = 0 for j in range(len(b)): t += b[j] * (math.pow(2, j)) t = t * 10 / 1023 return tpopsize = 50 #种群的大小#用遗传算法求函数最大值：#f(x)=10*sin(5x)+7*cos(4x) x∈[0,10]chromlength = 10 #基因片段的长度pc = 0.6 #两个个体交叉的概率pm = 0.001; #基因突变的概率results = [[]]bestindivial = []bestfit = 0fitvalue = []tempop = [[]]pop = [[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] for i in range(popsize)]for i in range(100): #繁殖100代 objvalue = calobjvalue(pop) #计算目标函数值 fitvalue = calfitvalue(objvalue); #计算个体的适应值 [bestindivial, bestfit] = best(pop, fitvalue) #选出最好的个体和最好的函数值 results.append([bestfit,b2d(bestindivial)]) #每次繁殖，将最好的结果记录下来 selection(pop, fitvalue) #自然选择，淘汰掉一部分适应性低的个体 crossover(pop, pc) #交叉繁殖 mutation(pop, pc) #基因突变 results.sort() print(results[-1]) #打印函数最大值和对应的

来自CODE的代码片
GA.py

1
2
3
4
5
6
7
8
9
def best(pop, fitvalue): #找出适应函数值中最大值，和对应的个体 px = len(pop) bestindivial = [] bestfit = fitvalue[0] for i in range(1,px): if(fitvalue[i] > bestfit): bestfit = fitvalue[i] bestindivial = pop[i] return [bestindivial, bestfit]

来自CODE的代码片
best.py

1
2
3
4
5
6
7
8
9
10
11
def calfitvalue(objvalue):#转化为适应值，目标函数值越大越好，负值淘汰。 fitvalue = [] temp = 0.0 Cmin = 0; for i in range(len(objvalue)): if(objvalue[i] + Cmin > 0): temp = Cmin + objvalue[i] else: temp = 0.0 fitvalue.append(temp) return fitvalue

来自CODE的代码片
calfitvalue.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import mathdef decodechrom(pop): #将种群的二进制基因转化为十进制（0,1023） temp = []; for i in range(len(pop)): t = 0; for j in range(10): t += pop[i][j] * (math.pow(2, j)) temp.append(t) return tempdef calobjvalue(pop): #计算目标函数值 temp1 = []; objvalue = []; temp1 = decodechrom(pop) for i in range(len(temp1)): x = temp1[i] * 10 / 1023 #（0,1023）转化为 （0,10） objvalue.append(10 * math.sin(5 * x) + 7 * math.cos(4 * x)) return objvalue #目标函数值objvalue[m] 与个体基因 pop[m] 对应

来自CODE的代码片
calobjvalue.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import randomdef crossover(pop, pc): #个体间交叉，实现基因交换 poplen = len(pop) for i in range(poplen - 1): if(random.random() < pc): cpoint = random.randint(0,len(pop[0])) temp1 = [] temp2 = [] temp1.extend(pop[i][0 : cpoint]) temp1.extend(pop[i+1][cpoint : len(pop[i])]) temp2.extend(pop[i+1][0 : cpoint]) temp2.extend(pop[i][cpoint : len(pop[i])]) pop[i] = temp1 pop[i+1] = temp2

来自CODE的代码片
crossover.py

1
2
3
4
5
6
7
8
9
10
11
12
13
import randomdef mutation(pop, pm): #基因突变 px = len(pop) py = len(pop[0]) for i in range(px): if(random.random() < pm): mpoint = random.randint(0,py-1) if(pop[i][mpoint] == 1): pop[i][mpoint] = 0 else: pop[i][mpoint] = 1

来自CODE的代码片
mutation.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import randomdef sum(fitvalue): total = 0 for i in range(len(fitvalue)): total += fitvalue[i] return totaldef cumsum(fitvalue): for i in range(len(fitvalue)): t = 0; j = 0; while(j <= i): t += fitvalue[j] j = j + 1 fitvalue[i] = t;def selection(pop, fitvalue): #自然选择（轮盘赌算法） newfitvalue = [] totalfit = sum(fitvalue) for i in range(len(fitvalue)): newfitvalue.append(fitvalue[i] / totalfit) cumsum(newfitvalue) ms = []; poplen = len(pop) for i in range(poplen): ms.append(random.random()) #random float list ms ms.sort() fitin = 0 newin = 0 newpop = pop while newin < poplen: if(ms[newin] < newfitvalue[fitin]): newpop[newin] = pop[fitin] newin = newin + 1 else: fitin = fitin + 1 pop = newpop

⑺ 遗传算法中几种不同选择算子及Python语言实现

在Python这种动态类型语言中貌似看起来有些鸡肋，但是为了能够更加规范使用者，利用Python的元类在实例化类对象的时候对接口的实现以及接口的参数类型加以限制。

⑻ 有没有用python实现的遗传算法优化BP神经网络的代码

下面是函数实现的代码部分：
clc
clear all
close all
%% 加载神经网络的训练样本 测试样本每列一个样本 输入P 输出T，T是标签
%样本数据就是前面问题描述中列出的数据
%epochs是计算时根据输出误差返回调整神经元权值和阀值的次数
load data
% 初始隐层神经元个数
hiddennum=31;
% 输入向量的最大值和最小值
threshold=[0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1;0 1];
inputnum=size(P,1); % 输入层神经元个数
outputnum=size(T,1); % 输出层神经元个数
w1num=inputnum*hiddennum; % 输入层到隐层的权值个数
w2num=outputnum*hiddennum;% 隐层到输出层的权值个数
N=w1num+hiddennum+w2num+outputnum; %待优化的变量的个数
%% 定义遗传算法参数
NIND=40; %个体数目
MAXGEN=50; %最大遗传代数
PRECI=10; %变量的二进制位数
GGAP=0.95; %代沟
px=0.7; %交叉概率
pm=0.01; %变异概率
trace=zeros(N+1,MAXGEN); %寻优结果的初始值
FieldD=[repmat(PRECI,1,N);repmat([-0.5;0.5],1,N);repmat([1;0;1;1],1,N)]; %区域描述器
Chrom=crtbp(NIND,PRECI*N); %初始种群
%% 优化
gen=0; %代计数器
X=bs2rv(Chrom,FieldD); %计算初始种群的十进制转换
ObjV=Objfun(X,P,T,hiddennum,P_test,T_test); %计算目标函数值
while gen

⑼ 遗传算法tsp 城市100个 种群个数应该是多少

个体基因数为100，建议种群数为100*（3~5）
遗传代数为100*（8~10）

⑽ Python算法中如何添加平均适应度图

今天整理之前写的代码，发现在做数模期间写的用python实现的遗传算法，感觉还是挺有意思的，就拿出来分享一下。
首先遗传算法是一种优化算法，通过模拟基因的优胜劣汰，进行计算（具体的算法思路什么的就不赘述了）。大致过程分为初始化编码、个体评价、选择，交叉，变异。
遗传算法介绍
遗传算法是通过模拟大自然中生物进化的历程，来解决问题的。大自然中一个种群经历过若干代的自然选择后，剩下的种群必定是适应环境的。把一个问题所有的解看做一个种群，经历过若干次的自然选择以后，剩下的解中是有问题的最优解的。当然，只能说有最优解的概率很大。这里，我们用遗传算法求一个函数的最大值。
f(x) = 10 * sin( 5x ) 7 * cos( 4x ), 0 <= x <= 10
1、将自变量x进行编码
取基因片段的长度为10, 则10位二进制位可以表示的范围是0到1023。基因与自变量转变的公式是x = b2d(indivial) * 10 / 1023。构造初始的种群pop。每个个体的基因初始值是[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
2、计算目标函数值
根据自变量与基因的转化关系式，求出每个个体的基因对应的自变量，然后将自变量代入函数f（x），求出每个个体的目标函数值。
3、适应度函数
适应度函数是用来评估个体适应环境的能力，是进行自然选择的依据。本题的适应度函数直接将目标函数值中的负值变成0. 因为我们求的是最大值，所以要使目标函数值是负数的个体不适应环境，使其繁殖后代的能力为0.适应度函数的作用将在自然选择中体现。
4、自然选择
自然选择的思想不再赘述，操作使用轮盘赌算法。其具体步骤：
假设种群中共5个个体，适应度函数计算出来的个体适应性列表是fitvalue = [1 ,3, 0, 2, 4] ，totalvalue = 10 ， 如果将fitvalue画到圆盘上，值的大小表示在圆盘上的面积。在转动轮盘的过程中，单个模块的面积越大则被选中的概率越大。选择的方法是将fitvalue转化为[1 ， 4 ，4 , 6 ，10], fitvalue / totalvalue = [0.1 , 0.4 , 0.4 , 0.6 , 1.0] . 然后产生5个0-1之间的随机数，将随机数从小到大排序，假如是[0.05 , 0.2 , 0.7 , 0.8 ,0.9]，则将0号个体、1号个体、4号个体、4号个体、4号个体拷贝到新种群中。自然选择的结果使种群更符合条件了。
5、繁殖
假设个体a、b的基因是
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]
b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
这两个个体发生基因交换的概率pc = 0.6.如果要发生基因交换，则产生一个随机数point表示基因交换的位置，假设point = 4,则：
a = [1, 0, 0, 0, 0, 1, 1, 1, 0, 0]
b = [0, 0, 0, 1, 1, 0, 1, 1, 1, 1]
交换后为：
a = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1]
b = [0, 0, 0, 1, 0, 1, 1, 1, 0, 0]
6、突变
遍历每一个个体，基因的每一位发生突变（0变为1,1变为0）的概率为0.001.突变可以增加解空间
以目标式子 y = 10 * sin(5x) 7 * cos(4x)为例，计算其最大值
首先是初始化，包括具体要计算的式子、种群数量、染色体长度、交配概率、变异概率等。并且要对基因序列进行初始化
pop_size = 500 # 种群数量
max_value = 10 # 基因中允许出现的最大值
chrom_length = 10 # 染色体长度
pc = 0.6 # 交配概率
pm = 0.01 # 变异概率
results = [[]] # 存储每一代的最优解，N个二元组
fit_value = [] # 个体适应度
fit_mean = [] # 平均适应度
pop = geneEncoding(pop_size, chrom_length)
其中genEncodeing是自定义的一个简单随机生成序列的函数，具体实现如下
def geneEncoding(pop_size, chrom_length):
pop = [[]]
for i in range(pop_size):
temp = []
for j in range(chrom_length):
temp.append(random.randint(0, 1))
pop.append(temp)
return pop[1:]

编码完成之后就是要进行个体评价，个体评价主要是计算各个编码出来的list的值以及对应带入目标式子的值。其实编码出来的就是一堆2进制list。这些2进制list每个都代表了一个数。其值的计算方式为转换为10进制，然后除以2的序列长度次方减一，也就是全一list的十进制减一。根据这个规则就能计算出所有list的值和带入要计算式子中的值，代码如下
# 0.0 coding:utf-8 0.0