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年