python实现基因双序列

❶ 已知蛋白序列号，怎么运用python得到完整序列

一个就是你直接blast 蛋白序列，找到与你的所需要的那个基因的序列 另外就是直接search那个肽链的名字如胸腺肽Thymosin，就会出来结果，找到Homo sapiens，打开就会有一条肽链，看看是不是你需要的，那上面有一个CDS

❷ python A, C, T, 和 G构成的字符串来构建一个基因组，，在 TAG, TAA, 或者 TGA之前结束

#-*-coding:utf-8-*-
sstr=raw_input('PleaseinputtheGeneString:
')
endsplit=['TAG','TAA','TGA']
if'ATG'insstr:
foriinsstr.split('ATG'):
forjinendsplit:
ifjini:
printi.split(j)[0]
else:
print'error'

>>>

Please input the Gene String:
TTATGTTTTAAGGATGGGGCGTTAGTT
TTT
GGGCGT

Please input the Gene String:
TGTGTGTATAT
error

❸ python 怎么实现基因向氨基酸的转变

建立一个字典然后读取文件，循环每行的操作是按空格分为两个部分。然后按后面的作为字典的key来储存第一个。最后就是循环需哦入到文件里

❹ 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脚本实现查询CDS序列中的SSR序列（简单重复序列），并输出SSR序列

RULE={'A':'T','T':'A','C':'G','G':'C'}
DNA_LIST='CATGCATCGT'
print "".join(map(lambda x:RULE[x],DNA_LIST))[::-1]

s = ""
for i in DNA_LIST:
if i == "A":
s = s+"T"
if i == "T":
s = s+"A"
if i == "C":
s = s+"C"
if i == "G":
s = s+"G"
print s

❻ 如何用python编写一个程序，计算并输出基因组测序出来的一个FASTA文件中所有蛋白质分子的分子量

你该问中科院

❼ 有一串dna序列存储为一个文件，名为dna.txt。写一个python程序，打印出所

破译的过程其实挺简单 现在我们知道,DNA的信息储存是由3连密码子储存的,总共四种核苷酸,在DNA里是A T C G 在RNA里是A U C G 在转录的时候T和U是对等的,所以我们可以把它也看成是一种核苷酸.它们每三个一组,通过不同的排列组合方式,表达一种氨基酸,所以基因链可以通过读取三连密码子,来进行破译.在最初破译三连密码子的时候,有一个确定的方向,就是肯定一定数量的核苷酸的排列组合,对应的一个氨基酸信息,方向确定之后,接下来的工作就是确定密码子的数量,也就是说,几个碱基对应一个氨基酸,现已知道构成蛋白质的氨基酸共20种,那么四种碱基不可能一一对应,如果是2种碱基排列,则有16种组合,也不够,那么接下来就是3种碱基的排列,总共有64种组合,可以完全覆盖20种氨基酸,如果是4种碱基,则有256种组合,虽然也完全覆盖了20种氨基酸,但是数量太过悬殊,从一切节约的生命原则来看,未免信息量过大,会造成信息储存的传递的负担.所以当初的科学家暂定是3种碱基的组合为一个密码子.说实话,这有些运气的成分.当然,这种运气是被后来的事实验证了的.接下来就是确定各种碱基组合分别对应的是哪种氨基酸,这是个繁琐的工作,其实原理很简单,就是人工合成一段DNA,然后用来表达,看这段DNA序列最后合成的是哪种氨基酸.比如 首先要确定的是密码子“AAA”的信息 那么我们就合成一段序列“AAA AAA AAA AAA AAA AAA AAA”将其翻译成蛋白之后,发现这一段序列由7个赖氨酸组成,那么就可以相信,赖氨酸是由三个A编码的.当然,用64个密码子表示20种氨基酸,肯定会有重复,这就是密码子的简并性,就是会有多个密码子表示一个氨基酸,具体就不细说了.

❽ 如何用PYTHON提取基因序列里的小写字符串（内含子）

楼上的代码正确
内含子是不会小写的，小写了说明大家已经知道那是内含子了。……你这个程序还有啥意义。

❾ ...主要是基因组,转录组分析,请问该如何去有效的去学习python呢 ...

从入门教程看起，同时试着使用它完成一些日常事务，逐渐你就掌握了。
Python有生物信息模块，也有不错的绘图模块，应当比Perl好用。

❿ Python问题，谢谢啦！

def one_year_change(num_old,parm):
num_new = num_old *2 *parm
return num_new

if __name__=="__main__":
fast = 1
slow = 1000

i = 1
while True:
if fast>slow:
print i
break
fast = one_year_change(fast,0.7)
slow = one_year_change(slow,0.6)
i = i+1

第46年