最后
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
👉Python所有方向的学习路线👈
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
👉Python必备开发工具👈
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
👉Python全套学习视频👈
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
👉实战案例👈
学python就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。
因此在学习python的过程中一定要记得多动手写代码，教程只需要看一两遍即可。
👉大厂面试真题👈
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
chromosome_num(int):染色体数，对应需要寻优的参数个数
chromosome_length(int):染色体长度
max_value(float):染色体十进制数值最大值
min_value(float):染色体十进制数值最小值
iter_num(int):迭代次数
deta(float):量子旋转角度
‘’’
self.population_size = population_size
self.chromosome_num = chromosome_num
self.chromosome_length = chromosome_length
self.max_value = max_value
self.min_value = min_value
self.iter_num = iter_num
self.deta = deta
#2.2 种群的量子形式初始化===========
def species_origin_angle(self):
‘’'种群初始化
input:self(object):QGA类
output:population_Angle(list):种群的量子角度列表
population_Angle2(list):空的种群的量子角度列表，用于存储交叉后的量子角度列表
‘’’
population_Angle = []
for i in range(self.chromosome_num):
tmp1 = [] #存储每个染色体所有取值的量子角度
for j in range(self.population_size):
tmp2 = [] #存储量子角度
for m in range(self.chromosome_length):
a = np.pi * 2 * np.random.random()
tmp2.append(a)
tmp1.append(tmp2)
population_Angle.append(tmp1)
return population_Angle
#将初始化的量子角度序列转换为种群的量子系数列表
def population_Q(self,population_Angle):
‘’’
input:self(object):QGA类
population_Angle(list):种群的量子角度列表
output:population_Q(list):种群的量子系数列表
‘’’
population_Q = []
for i in range(len(population_Angle)):
tmp1 = [] #存储每个染色体所有取值的量子系数对
for j in range(len(population_Angle[i])):
tmp2 = [] #存储每个染色体的每个取值的量子对
tmp3 = [] #存储量子对的一半
tmp4 = [] #存储量子对的另一半
for m in range(len(population_Angle[i][j])):
a = population_Angle[i][j][m]
tmp3.append(np.sin(a))
tmp4.append(np.cos(a))
tmp2.append(tmp3)
tmp2.append(tmp4)
tmp1.append(tmp2)
population_Q.append(tmp1)
return population_Q
#2.3计算适应度函数值==========
def translation(self,population_Q):
‘’'将种群的量子列表转换为二进制列表
input:self(object):QGA类
population_Q(list):种群的量子列表
output:population_Binary:种群的二进制列表
‘’’
population_Binary = []
for i in range(len(population_Q)):
tmp1 = [] # 存储每个染色体所有取值的二进制形式
for j in range(len(population_Q[i])):
tmp2 = [] ##存储每个染色体每个取值的二进制形式
for l in range(len(population_Q[i][j][0])):
if np.square(population_Q[i][j][0][l]) > np.random.random():
tmp2.append(1)
else:
tmp2.append(0)
tmp1.append(tmp2)
population_Binary.append(tmp1)
return population_Binary
#=求适应度函数数值列表，本实验采用的适应度函数为RBF_SVM的3_fold交叉验证平均值=
def fitness(self,population_Binary):
‘’’
input:self(object):QGA类
population_Binary(list):种群的二进制列表
output:fitness_value(list):适应度函数值类表
parameters(list):对应寻优参数的列表
‘’’
#=(1)染色体的二进制表现形式转换为十进制并设置在[min_value,max_value]之间=
parameters = [] #存储所有参数的可能取值
for i in range(len(population_Binary)):
tmp1 = [] #存储一个参数的可能取值
for j in range(len(population_Binary[i])):
total = 0.0
for l in range(len(population_Binary[i][j])):
total += population_Binary[i][j][l] * math.pow(2,l) #计算二进制对应的十进制数值
value = (total * (self.max_value - self.min_value)) / math.pow(2,len(population_Binary[i][j])) + self.min_value ##将十进制数值坐落在[min_value,max_value]之间
tmp1.append(value)
parameters.append(tmp1)
#(2)适应度函数为RBF_SVM的3_fold交叉校验平均值=====
fitness_value = []
for l in range(len(parameters[0])):
rbf_svm = svm.SVC(kernel = ‘rbf’, C = parameters[0][l], gamma = parameters[1][l])
cv_scores = cross_validation.cross_val_score(rbf_svm,trainX,trainY,cv =3,scoring = ‘accuracy’)
fitness_value.append(cv_scores.mean())
#=(3)找到最优的适应度函数值和对应的参数二进制表现形式==
best_fitness = 0.0
best_parameter = []
best_parameter_Binary = []
for j in range(len(population_Binary)):
tmp2 = []
best_parameter_Binary.append(tmp2)
best_parameter.append(tmp2)
for i in range(len(population_Binary[0])):
if best_fitness < fitness_value[i]:
best_fitness = fitness_value[i]
for j in range(len(population_Binary)):
best_parameter_Binary[j] = population_Binary[j][i]
best_parameter[j] = parameters[j][i]
return parameters,fitness_value,best_parameter_Binary,best_fitness,best_parameter
#2.4 全干扰交叉===
def crossover(self,population_Angle):
‘’'对种群量子角度列表进行全干扰交叉
input:self(object):QGA类
population_Angle(list):种群的量子角度列表
‘’’
#=初始化一个空列表，全干扰交叉后的量子角度列表
population_Angle_crossover = []
for i in range(self.chromosome_num):
tmp11 = []
for j in range(self.population_size):
tmp21 = []
for m in range(self.chromosome_length):
tmp21.append(0.0)
tmp11.append(tmp21)
population_Angle_crossover.append(tmp11)
for i in range(len(population_Angle)):
for j in range(len(population_Angle[i])):
for m in range(len(population_Angle[i][j])):
ni = (j - m) % len(population_Angle[i])
population_Angle_crossover[i][j][m] = population_Angle[i][ni][m]
return population_Angle_crossover
#2.4 变异======
def mutation(self,population_Angle_crossover,population_Angle,best_parameter_Binary,best_fitness):
‘’'采用量子门变换矩阵进行量子变异
input:self(object):QGA类
population_Angle_crossover(list):全干扰交叉后的量子角度列表
output:population_Angle_mutation(list):变异后的量子角度列表
‘’’
#(1)求出交叉后的适应度函数值列表=====
population_Q_crossover = self.population_Q(population_Angle_crossover) ## 交叉后的种群量子系数列表
population_Binary_crossover = self.translation(population_Q_crossover) ## 交叉后的种群二进制数列表
parameters,fitness_crossover,best_parameter_Binary_crossover,best_fitness_crossover,best_parameter = self.fitness(population_Binary_crossover) ## 交叉后的适应度函数值列表
#(2)初始化每一个量子位的旋转角度==
Rotation_Angle = []
for i in range(len(population_Angle_crossover)):
tmp1 = []
for j in range(len(population_Angle_crossover[i])):
tmp2 = []
for m in range(len(population_Angle_crossover[i][j])):
tmp2.append(0.0)
tmp1.append(tmp2)
Rotation_Angle.append(tmp1)
deta = self.deta
#(3)求每个量子位的旋转角度====
for i in range(self.chromosome_num):
for j in range(self.population_size):
if fitness_crossover[j] <= best_fitness:
for m in range(self.chromosome_length):
s1 = 0
a1 = population_Q_crossover[i][j][0][m]
b1 = population_Q_crossover[i][j][1][m]
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 0 and a1 * b1 > 0:
s1 = -1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 0 and a1 * b1 < 0:
s1 = 1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 0 and a1 * b1 == 0:
s1 = 1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 1 and a1 * b1 < 0:
s1 = -1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 1 and a1 * b1 == 0:
s1 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 0 and a1 * b1 > 0:
s1 = -1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 0 and a1 * b1 < 0:
s1 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 0 and a1 * b1 == 0:
s1 = -1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 1 and a1 * b1 > 0:
s1 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 1 and a1 * b1 < 0:
s1 = -1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 1 and a1 * b1 == 0:
s1 = 1
Rotation_Angle[i][j][m] = deta * s1
else:
for m in range(self.chromosome_length):
s2 = 0
a2 = population_Q_crossover[i][j][0][m]
b2 = population_Q_crossover[i][j][1][m]
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 0 and a2 * b2 > 0:
s2 = -1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 0 and a2 * b2 < 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 0 and a2 * b2 == 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 1 and a2 * b2 > 0:
s2 = -1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 1 and a2 * b2 < 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 0 and best_parameter_Binary[i][m] == 1 and a2 * b2 == 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 0 and a2 * b2 > 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 0 and a2 * b2 < 0:
s2 = -1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 0 and a2 * b2 == 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 1 and a2 * b2 > 0:
s2 = 1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 1 and a2 * b2 < 0:
s2 = -1
if population_Binary_crossover[i][j][m] == 1 and best_parameter_Binary[i][m] == 1 and a2 * b2 == 0:
s2 = 1
Rotation_Angle[i][j][m] = deta * s2
#=(4)根据每个量子位的旋转角度，生成种群新的量子角度列表=========
for i in range(self.chromosome_num):
for j in range(self.population_size):
for m in range(self.chromosome_length):
population_Angle[i][j][m] = population_Angle[i][j][m] + Rotation_Angle[i][j][m]
return population_Angle
#2.5 画出适应度函数值变化图
def plot(self,results):
‘’’
画图
‘’’
X = []
Y = []
for i in range(self.iter_num):
X.append(i + 1)
Y.append(results[i])
plt.plot(X,Y)
plt.xlabel(‘Number of iteration’,size = 15)
plt.ylabel(‘Value of CV’,size = 15)
plt.title(‘QGA_RBF_SVM parameter optimization’)
plt.show()
#=2.6 主函数======
def main(self):
results = []
best_fitness = 0.0
best_parameter = []
#=种群初始化=
population_Angle= self.species_origin_angle()
#=迭代==
for i in range(self.iter_num):
population_Q = self.population_Q(population_Angle)
计算本次迭代的适应度函数值列表，最优适应度函数值及对应的参数
parameters,fitness_value,current_parameter_Binary,current_fitness,current_parameter = self.fitness(population_Binary)
找出到目前为止最优的适应度函数值和对应的参数
if current_fitness > best_fitness:
best_fitness = current_fitness
best_parameter = current_parameter
print(‘iteration is :’,i+1,‘;Best parameters:’,best_parameter,‘;Best fitness’,best_fitness)
results.append(best_fitness)
全干扰交叉
population_Angle_crossover = self.crossover(population_Angle)
量子旋转变异
population_Angle = self.mutation(population_Angle_crossover,population_Angle,current_parameter_Binary,current_fitness)
if name == ‘main’:
print(‘----------------1.Load Data-------------------’)
trainX,trainY = load_data(‘rbf_data’)
print(‘----------------2.Parameter Seting------------’)
population_size=200
chromosome_num=2
chromosome_length=20
max_value=15
min_value=0.01
iter_num=100
deta=0.1 * np.pi
print(‘----------------3.QGA_RBF_SVM-----------------’)
qga = QGA(population_size,chromosome_num,chromosome_length,max_value,min_value,iter_num,deta)
qga.main()
4.3 结果
5 量子遗传算法——Matlab实现
clear,clc
%% 1基本概念
%（1）量子遗传算法是量子计算与遗传算法相结合的智能优化算法，由K.H.Han等人提出，其将量子态、量子门、量子状态特性、概率幅等量子概念引入到遗传算法当中。
%量子遗传算法也是一种概率搜素算法，它采用量子位来表示基因。遗传算法的基因所表达的是某一确定的信息，而量子遗传算法中，由于量子信息的叠加性使量子位所表达的基因包含所有可能的信息。
%（2）在量子计算中，量子比特｜0〉和｜1〉表示微观粒子的两种基本状态，根据叠加原理，量子信息的叠加态可以表示为这两个基本态的线性组合，即｜ψ〉=α｜0〉+β｜1〉，式中α和β为复数，表示量子位状态的概率幅，其中和分别表示量子态｜ψ〉因测量导致坍缩到｜0〉态和｜1〉态的概率，且满足的归一化条件
%（3）在量子遗传算法中，染色体采用量子位的概率幅进行编码，编码方案如下：
%θ为量子比特的相位，n为染色体数目，k为量子位的位数即解空间的维数，rand是[0,1]范围内的随机数。每个量子位为分上下两行，分别对应两个量子基本态的概率幅，满足归一化条件，因此每个个体包含上下两条文化基因链，每条基因链是优化问题的一个候选解。由此可知，量子遗传算法在种群规模不变的情况下，候选解个数比遗传算法多一倍，增加了解空间的多样性，提高了寻优成功的概率。
%（4）在量子遗传算法中，采用量子旋转门改变量子比特相位，以更新量子位的概率幅，从而达到基因变异的效果。
%% 2、量子遗传算法的基本步骤：
%step1：初始化父代染色体
%step2：对每个染色体基因位即量子位进行测量，得到一个状态。对每个状态计算适应度，记录最佳个体及适应度。
%step3：遗传进化设定的代数，其中采用量子旋转门对每一代染色体进行遗传变异。
%step4：达到终止条件，输出最佳个体及适应度。
%% 3、量子遗传算法的MATLAB实现代码如下
%% 变量部分
popsize = 100; %种群规模
vartotal = 2; %变量个数即一条染色体的量子位数
shiftstep = 0.01*pi; %转角步长
Pm = ones(1,popsize)*0.05;%设置变异概率
maxgen = 200; %设置迭代次数
%% 数组部分–解空间的优化变量的取值范围
var_range(1,1) = -100;
var_range(1,2) = 100;
var_range(2,1) = -100;
var_range(2,2) = 100;
%% 个体初始化
%初始化了2*popsize个体，其中每个个体有两条基因链
for i=1:1:vartotal
fai(:,i)=2pirand(popsize,1);
chrom(:,1,i)=cos(fai(:,i));
chrom(:,2,i)=sin(fai(:,i));
oldfai(:,i)=2pirand(popsize,1);
oldchrom(:,1,i)=cos(oldfai(:,i));
oldchrom(:,2,i)=sin(oldfai(:,i));
end
%% 解空间变换
for i=1:1:2
for j=1:1:vartotal
chromx(:,i,j)=0.5*(var_range(j,2)(1+chrom(:,i,j))+var_range(j,1)(1-chrom(:,i,j)));
oldchromx(:,i,j)=0.5*(var_range(j,2)(1+oldchrom(:,i,j))+var_range(j,1)(1-oldchrom(:,i,j)));
end
end
%% 计算适应度—适应度函数：Shaffer’s F6函数
for i=1:1:popsize
for j=1:1:2
x1=chromx(i,j,1);
x2=chromx(i,j,2);
fitness(i,j)=0.5-((sin(sqrt(x12+x22)))2-0.5)/(1+0.001*(x12+x22))2;
x1=oldchromx(i,j,1);
x2=oldchromx(i,j,2);
oldfitness(i,j)=0.5-((sin(sqrt(x12+x22)))2-0.5)/(1+0.001*(x12+x22))2;
end
end
%% 获得最优解及相应自变量
[Bestf,Indexf]=sort(fitness,2);
[BestF,IndexF]=sort(Bestf,1);
gBestfit=BestF(popsize,2);
gBestpop=IndexF(popsize,2);
gBestg=Indexf(gBestpop,2);
gBestfai=fai(gBestpop,:);
gBestC=chrom(gBestpop,:😅;
gBest_x=chromx(gBestpop,:😅;
gBest_fit=fitness(gBestpop,:);
%% 主循环开始
for gen = 1:1:maxgen
for i = 1:1:vartotal
tmp=abs(chromx(1,gBestg,i)-oldchromx(1,gBestg,i));
if tmp<1.0e-2
tmp=1.0e-2;
end
max(i)=abs(fitness(1,gBestg)-oldfitness(1,gBestg))/tmp;
min(i)=abs(fitness(1,gBestg)-oldfitness(1,gBestg))/tmp;
for j = 1:1:popsize
tmp=abs(chromx(j,gBestg,i)-oldchromx(j,gBestg,i));
if tmp<1.0e-2
tmp=1.0e-2;
end
if max(i)<=abs(fitness(j,gBestg)-oldfitness(j,gBestg))/tmp
max(i)=abs(fitness(j,gBestg)-oldfitness(j,gBestg))/tmp;
end
if min(i)>abs(fitness(j,gBestg)-oldfitness(j,gBestg))/tmp
min(i)=abs(fitness(j,gBestg)-oldfitness(j,gBestg))/tmp;
end
一、Python所有方向的学习路线
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
二、Python必备开发工具
工具都帮大家整理好了，安装就可直接上手！
三、最新Python学习笔记
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
四、Python视频合集
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
五、实战案例
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
六、面试宝典
简历模板
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
3750
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
