En hızlı olup olmadığını bilmiyorum, ancak aşağıdakiler, işlevlerinize göre yaklaşık 10 kat hız sağlar:

  import stringtab = string .maketrans ("ACTG", "TGAC") def reverse_complement_table (seq): return seq.translate (tab) [:: - 1]  

Hashing içeren şey, bir Bu kadar küçük bir yedek set için çok fazla ek yük var.

Değeri ne olursa olsun, bunu kodunuza "çeviri tablosu ile" ekledim ve işte iş istasyonumda bulduğum şey:

  genel dikte uygulaması 1.37599sn toplam, 363374.8 string / saniyede 3.3% artış temel uygulamaya göre toplam 1.44126sn, 346919.4 string / saniyede -1.3% artış, çeviri tablosu ile toplam 0.16780s, 2979755.6 string / saniye 88.2% taban çizgisine göre artış  

Python 2 yerine python 3'e ihtiyacınız varsa, tab = str.maketrans ("ACTG", "TGAC") co de> tab = string.maketrans ("ACTG", "TGAC") için, maketrans artık str türünde statik bir yöntemdir .

Merak edenler için, biopython kullanmak bunun için daha yavaştır (saf uygulamadan ~% 50 daha yavaştır), muhtemelen dizeleri Seq nesnelere dönüştürmenin ek yükü nedeniyle. Biopython kullanarak dizileri zaten okuyan biri, performans çok farklı olsaydı şaşırmazdım.

İşte Python çalışmasını hızlandırmak için genel bir yaklaşım önerebilecek bir Cython yaklaşımı.

Karakter dizilerini (ASCII) manipüle ediyorsanız ve performans bir tasarım konusuysa, C veya Perl muhtemelen Python'a göre tercih edilen seçeneklerdir.

Her durumda, bu Cython testi Python 3.6.3 kullanır:

  $ python --versionPython 3.6.3 :: Anaconda custom (64-bit)  

Cython'u yüklemek için, örneğin:

  $ conda install -c anaconda cython  

Aşağıdaki Cython kodu, çeviri tablosuyla aynı hız artışı - belki de buna benzer bir kod çalıştırılır.

setup.py ile başlayan iki dosya gereklidir:

  distutils.core'dan Cython.Build import kurulumundan cythonizesetup (name = 'Ters tamamlayıcı C testi', ext_modules = cythonize ("revcomp_c.pyx"),)  

Ve daha sonra libc.stdlib'den revcomp_c.pyx:

  adlı ikinci bir dosya cimport malloccdef int seq_len = 17cdef char * seq_dest = <char * >malloc (seq_len + 1) seq_dest [ seq_len] = '\ 0'def reverse_complement_c_v1 (str seq): cdef bytes py_bytes = seq.encode (' ascii ') cdef char * seq_src = py_bytes cdef int i = 0 cdef int d = 0 için i aralıkta (seq_len): d = seq_len - i - 1 if seq_src [i] == 'A': seq_dest [d] = 'T' elif seq_src [i] == 'G': seq_dest [d] = ' C 'elif seq_src [i] ==' C ': seq_dest [d] =' G 'elif seq_src [i] ==' T ': seq_dest [d] =' A 'dönüş seq_dest [: seq_len] .decode (' ascii ')  

Bu, şu şekilde bir Python modülünde derlenebilir:

  $ python setup.py build_ext --inplace  

Ardından test tezgahını bu Cython modülünü ve ilgili test yöntemini içerecek şekilde değiştirebiliriz:

  #! / usr / bin / env pythonimport randomimport timeitfrom revcomp_c import reverse_complement_c_v1global completecomplement = { 'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} DNA uzunluğu = 17
#randomly 100k temel oluşturma_to_basemap = {1: 'A', 2: 'C', 3: 'G', 4: 'T'} num_strings = 500000random.seed (90210) DNAstrings = ["" .join ([int_to_basemap [ random.randint (1,4)] aralıktaki i için (DNA uzunluğu)]) aralıktaki j için (num_strings)] # DNAstringlerinin neye benzediğine dair bir fikir edinin (DNAstrings [0: 5]) def reverse_complement_naive (seq): this_complement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'} return "" .join (this_complement.get (taban, taban) için tersine baz (sıra)) def revers_complement (seq): dönüş "" .join (tamamlayıcı.get (taban, taban) ters çevrilmiş (seq)) tic = timeit.default_timer () rcs = [reverse_complement_naive (seq) için DNAstrings'de seq] toc = timeit.default_timer () baseline = toc - ticnamefunc = {"naif uygulama": reverse_complement_naive, "global dikte uygulaması": reverse_complement, "Cython uygulaması (v1)": isim işlevindeki fonksiyon_adı için reverse_complement_c_v1}: func = adefunc [işlev_adı] tic = timeit.default_timer () rcs = [DNA dizelerindeki sıra için func (sıra)] toc = timeit.default_timer () walltime = toc-tic baskı ("" "{} {: .5f} s toplam, {: .1f} saniye başına dizge {:. Referans değerine göre% 1f} artış "" ". Format (işlev_adı, duvar saati, sayı_dizesi / duvar saati, 100- ((duvar saati / taban çizgisi) * 100)))  

Örnek bir çalıştırma:

  $ python ./revcomp_test.py['ACTGCAATAGACCACGC ',' CAGCTTGAGCCATTAAC ',' GGCCCAAGAGTTCGAAC ',' CGACTGTCTCGAATTGT ',' ATCCGCTATGCGCCGTC başına 28.5'lik artış, toplam% 1,732,05,05 saf uygulama taban küresel dikte uygulamasına göre 1,70896sn toplam, saniyede 292575,5 dize baseline göre% -1,0 artış (v1) 0,21458sn toplam, 2330158,7 saniye baseline göre% 87,3 artış  

Bunu hızlandırmanın kolay bir yolu, statik const işaretsiz char dizisini ASCII arama tablosu olarak kullanmaktır. Bu, if ifadelerinin yerini alacak ve muhtemelen küçük bir destek sağlayacaktır ( ve öyle görünüyor ki, onu şimdiye kadarki en iyi performans gösterenlerden biri yapıyor!).

İşte benim C'deki ters tamamlayıcı işlevinin hızlı uygulamam:

https://gist.github.com/alexpreynolds/4f75cab4350e9d937f4a

Bunu, alt işlem kitaplığı aracılığıyla doğrudan Python'da kullanabilirsiniz. Ters tamamlama adımını C dilinde yazılmış bir yardımcı programa dış kaynak kullanmak, neredeyse her zaman Python'un yapabileceğinin en iyisini geçecektir ve sınır kontrolü gibi güzel ve önemli şeyleri çok fazla hız kaybetmeden yapabilirsiniz.

Nasıl olduğu belli değil. Yanıtın "saf" olması gerekir, ancak dizeleri işliyorsanız ve amacınız performanstırsa Python'dan bir sistem çağrısı yapmak adil görünür.

Alınacak bir başka yön de, eğer öyleyse, çoklu iş parçacığına bakmak olabilir. sıralı çıktıya gerek yoktur. Bellekte depolanan binlerce diziniz varsa, ofsetler veya dizi indeksleri kullanarak bir dizi dizisini daha küçük dizilere bölebilirsiniz. Her iş parçacığı, dizinin kendi parçasındaki "rc" -ing dizileri üzerinde çalışır.

En güvenilir ve en basit yol muhtemelen Biopython:

  kullanmaktır Bio.Seq import Seqdef my_reverse_complement (seq): return Seq (seq) .reverse_complement ( ) print (my_reverse_complement ('ATGCGTA')) # TACGCAT  

Devon'un burada söylediği gibi Biopython kullanmak o kadar hızlı değil saf Python çözümü olarak ve burada gösterilen ipython ile de test ettim. Ancak bunun nedeni, Biopython uygulamasının, naif yaklaşıma benzer olmasına rağmen, diğer özellikleri içermesidir; DNA'nın yanı sıra tamamlayıcı RNA'yı tersine çevirebilir ve size DNA ile RNA'yı karıştırıp karıştırmadığınızı söyler

Gerçekten hızlı bir yol istiyorsanız Cython 'a bakabileceğinizi unutmayın veya başka bir python uzantısı. Şimdi bunu düzenlerken, user172818 ve Alex Reynolds'tan bu yaklaşımı kullanan birkaç güzel cevap var.

Başka bir python uzantısı, ancak cython'suz. Kaynak kodu, bu cevabın altında veya bu ana başlıkta mevcuttur. Python3 yüklü Mac'te:

  toplamda 0,38166 dize, saniyede 1310067,4 dize, toplamda 0,20524sn'ye göre% 84,4 artış, saniyede 2436182,7 dizge başlangıca göre% 91,6 artış  

Python2 ile Linux'ta (sekans ilkidir):

  seqpy toplam 0.10960s, 4561842.5 dizge baseline göre% 93.3 artış, toplam 0.17811sn, saniyede 2807330.9 dizgiye göre% 89.1 artış baseline  

Bu setup.py dosyasıdır:

  şuradan setuptools içe aktarma kurulumu, Extensionseqpy_module = Uzantı ('seqpy', kaynaklar = ["seqpy.c"]) kurulumu (ad = "seqpy", açıklama = "seqpy", ext_modules = [seqpy_module])  

Bu seqpy.c dosyasıdır:

  #include <stdlib.h> # include <stdint.h> # include <PyPy .h>static işaretsiz karakter seq_comp_ta taş [256] = {0, 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, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 'T', 'V', 'G', 'H ',' E ',' F ',' C ',' D ',' I ',' J ',' M ',' L ',' K ',' N ',' O ',' P ', 'Q', 'Y', 'S', 'A', 'A', 'B', 'W', 'X', 'R', 'Z', 91, 92, 93, 94, 95, 64, 't', 'v', 'g', 'h', 'e', ​​'f', 'c', 'd', 'i', 'j', 'm', 'l', 'k', 'n', 'o', 'p', 'q', 'y', 's', 'a', 'a', 'b', 'w', 'x', 'r ',' z ', 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255}; statik PyObject * seqpy_revcomp (PyObject * self, PyObject * değiştirgeler) {PyObject * r; char * seq, * rev; int i, len; PyArg_ParseTuple (bağımsız değişkenler, "s #", &seq, &len); rev = (karakter *) malloc (len); için (i = 0; i < len; ++ i) rev [len - i - 1] = seq_comp_table [(uint8_t) seq [i]]; r = Py_BuildValue ("s #", rev, len); ücretsiz (rev); return r;} statik PyMethodDef seqpy_methods [] = {{"revcomp", seqpy_revcomp, METH_VARARGS, "Bir DNA dizisini ters tamamla"}, {NULL, NULL, 0, NULL}}; # if PY_MAJOR_VERSION > = 3statik yapı PyModu {PyModuleDef_HEAD_INIT, "seqpy", NULL, -1, seqpy_methods}; PyMODINIT_FUNC PyInit_seqpy (void) {return PyModule_Create (&seqpy_module); } #elsePyMODINIT_FUNC initseqpy (void) {Py_InitModule3 ("seqpy", seqpy_methods, NULL); } #endif  

Derlemek ve test etmek için:

  python setup.py build_ext -ipython -c 'import seqpy; print (seqpy.revcomp ("GGGTT")) ' 

dize yerine bir bytearray kullanın ve ardından çevirmek için maketrans kullanın

Bir dizi tabanı depolamak için dizenin daha gelişmiş dize kodlama yeteneklerine ihtiyacınız yoktur, ancak yine de performansta bunun bedelini ödüyorsunuz. Devon Ryan'ın maketrans önerisi, saf uygulamanızdan 10 kat daha hızlı olan büyük bir iyileştirmedir. Aynı yaklaşımı kullanmak, ancak her şeyi bayt 'lerle değiştirmek% 40 daha fazla hız iyileştirmesine olanak tanır, ancak:

  # DNA dizisi oluşturma işleminin de bytestab_b ile değiştirilmesi gerekir = bytes.maketrans (b "ACTG", b "TGAC") def reverse_complement_bytes (seq): return seq.translate (tab_b) [:: - 1]  

Karşılaştırmamda:

  Tablo uygulaması toplam 0,24339sn, 2054315,7 dize baselineBytes tablo uygulamasına göre% 82,5 artış toplam 0,144985s, saniyede 3336755,9 dize tabloya göre% 89,2 artış  

İşte bir char arama dizisi kullanma önerimi içeren orijinal Cython cevabımın bir revizyonu:

  libc'den. stdlib cimport malloccdef int seq_len = 17cdef char * seq_dest = <char * >malloc (seq_len + 1) seq_dest [seq_len] = '\ 0'cdef char * basemap = [' \ 0 ',' \ 0 ',' \ 0 ' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' \ 0 ',' T ',' \ 0 ',' G ',' \ 0 ',' \ 0 ',' \ 0 ',' C ',' \ 0 ',' \ 0 ' , '\ 0', '\ 0', '\ 0', '\ 0', 'N', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', 'A', 'A', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0 ',' \ 0 ',' \ 0 ',' t ',' \ 0 ',' g ',' \ 0 ',' \ 0 ',' \ 0 ',' c ',' \ 0 ', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0', '\ 0' , '\ 0', '\ 0', 'a', 'a'] def reverse_complement_c_v2 (str seq): cdef bayt py_bytes = seq.encode ('UTF-8') cdef char * seq_src = py_bytes cdef int i = 0 aralıktaki i için (seq_len): seq_dest [seq_len - i - 1] = temel harita [<int>seq_src [i]] return seq_dest [: seq_len] .decode ('UTF-8')  

OS X, Python 3.6.3 altında test edilirken:

  $ python ./revcomp.py['ACTGCAATAGACCACGC ',' CAGCTTGAGCCATTAAC ',' GGCCCAAGAGTTCGAAC ',' CGACTGTCTCTCGATCTCGATCTCGATCTCGATCTC ", 'ATCCGCTATGCGCC] ... Cython uygulaması (v1) 0.20664 toplam, saniyede 2419626,4 dize taban çizgisine göre% 88,3 artışCython uygulaması (v2) toplamda 0,14170s, saniyede 3528668,5 dize, taban çizgisine göre% 92,0 artış  

Kullanarak Benim arama dizisi yaklaşımım ("v2"), if bloklarını ("v1") kullanarak çok iyi bir performans artışı sağlıyor ve her şeyi bir Python dizesi olarak tutabilirsiniz.

Biopython'un en azından 1.71 sürümünden beri, doğal olarak düz dizelerde de çalışan (Seq nesnelerine dönüştürme olmadan) Bio.Seq.reverse_complement 'i kullanabilirsiniz. Mac'imde, karşılaştırmayı kullanırken bu uygulamayla ("biopython sadece rc") dönüştürülmüş 800 bin dizge alıyorum.

  Temel saniyelere göre 10000 dizge ve 250 tekrar yüzde artış saniye başına toplam dize alexreynolds Cython (v2) 94.0% 0.002491 4015188.7user172818 seqpy.c 93.2% 0.002833 3529944.4alexreynolds Cython (v1) 90.7% 0.003885 2573863.7devonryan string 86.0% 0.005804 1722983.5jackaidley byte 85.0% 0.005804 1722983.5jackaidley bayt rc 70.5% 0.012275 814638.6revcomp_translateSO 49.9% 0.020822 480254.6revcom SO'dan 41.7% 0.024253 412320.2string_replace 35.2% 0.026946 371107.3lambda SO'dan 10.7% 0.037111 269464.0global dikt 0.0% 0.041556 240641.7biopython sekansı sonra 2383 -30.9% 0.054430 183721.9naive (% 0.019.90) >