小编Chr*_*nds的帖子

我有一个这样的input_file.fa文件（FASTA格式）：

> header1 description
data data
data
>header2 description
more data
data
data

我想一次在文件中读取一个块，以便每个块包含一个头和相应的数据，例如块1：

> header1 description
data data
data

当然，我可以像这样读取文件并拆分：

with open("1.fa") as f:
    for block in f.read().split(">"):
        pass

但是我要避免将整个文件读入内存，因为文件通常很大。

我当然可以逐行读取文件：

with open("input_file.fa") as f:
    for line in f:
        pass

但理想情况下，我想要的是这样的：

with open("input_file.fa", newline=">") as f:
    for block in f:
        pass

但是我得到一个错误：

ValueError：非法换行值：>

我也尝试过使用csv模块，但没有成功。

我确实在3年前就找到了这篇文章，它提供了基于发电机的解决方案，但是似乎并不紧凑，这真的是唯一/最佳的解决方案吗？如果可以用单行而不是单独的函数来创建生成器，就像这样的伪代码，那将是一件很整洁的事情：

with open("input_file.fa") as f:
    blocks = magic_generator_split_by_>
    for block in blocks:
        pass

如果这不可能，那么我想您可以考虑我的问题与其他帖子的重复，但是如果是这样，我希望人们可以向我解释为什么其他解决方案是唯一的解决方案。非常感谢。

import MySQLdb

db = MySQLdb.connect("localhost","root","password","database")
cursor = db.cursor()
cursor.execute("SELECT id FROM some_table")
u_data = cursor.fetchall()

>>> print u_data
((1320088L,),)

我在互联网上找到的东西让我直到这里:

string = ((1320088L,),)
string = ','.join(map(str, string))
>>> print string
(1320088L,)

我期望输出看起来像:

 #Single element expected result
 1320088L  
 #comma separated list if more than 2 elements, below is an example
 1320088L,1320089L

有可能知道是否使用了发电机？即

def code_reader(code):
   for c in code:
        yield c

code_rdr = code_reader(my_code)

a = code_rdr.next()

foo(code_rdr)

经过foo电话,我想知道,如果.next()是呼吁code_rdr通过foo与否.当然我可以通过一些带有next()调用计数器的类来包装它.有没有简单的方法呢？

我有一个生成元组元组的所有可能组合

( (base1 , position1) , (base2 , position2) )

的bases = ["U", "C", "A", "G"]和positions = [0,1,2,3,4,5,6,7,8].

要求

• 没有重复
• 基数可以相同但位置必须不同
• 必须保留订单.

例如:

( (A,1), (B,2) ) == ( (B,2) , (A,1) )并且 ( (A,1), (B,1) )应该被丢弃.

样本输出:

[ ( (U,0) , (U,1) ), ( (U,0) , (U,2) ), ( (U,0) , (U,3) ) ...]

应该有448的长度

例:

对于字符串长度2:

((U,0),(U,1))
((U,0),(C,1))
((U,0),(A,1))
((U,0),(G,1))

((C,0),(U,1))
((C,0),(C,1))
((C,0),(A,1))
((C,0),(G,1))

((A,0),(U,1))
((A,0),(C,1))
((A,0),(A,1))
((A,0),(G,1))

((G,0),(U,1))
((G,0),(C,1))
((G,0),(A,1))
((G,0),(G,1)) …

我一直在挖掘源代码,以弄清楚打印结果的哪一点.例如:

>>> x = 1
>>> x + 2
3

以上两个陈述编译为:

  1           0 LOAD_CONST               0 (1)
              3 STORE_NAME               0 (x)
              6 LOAD_CONST               1 (None)
              9 RETURN_VALUE

和

  1           0 LOAD_NAME                0 (x)
              3 LOAD_CONST               0 (2)
              6 BINARY_ADD
              7 RETURN_VALUE

第一个语句不打印任何内容,因为None它是返回的值.第二个返回添加的结果.

CPython的交互式循环调用PyRun_InteractiveOneObjectEx()每个输入.这将获取AST并调用run_mod()以将AST编译为字节代码,然后在虚拟机中评估结果.获取的返回Python对象PyRun_InteractiveOneObjectEx()只是VM堆栈的顶部.

到目前为止,所有这些都是我所期待的.但后来返回的值似乎被抛弃了!什么时候由REPL打印？

顺便说一句,我可以看到交互模式确实改变了标记器; 它invokes PyOS_Readline带有sys.ps1提示(">>> "默认情况下).我检查了类似的变化pythonrun.c,但没有运气.

我有一个值列表：[0,2,3,5,6,7,9]并且想要获取每个数字之间中间的数字列表：[1, 2.5, 4, 5.5, 6.5, 8]。python中有没有一种巧妙的方法来做到这一点？

是否有一种更有效/更智能的方法来随机化字符串中的字母大写？像这样:

input_string = "this is my input string"
for i in range(10):
    output_string = ""
    for letter in input_string.lower():
        if (random.randint(0,100))%2 == 0:
            output_string += letter
        else:
            output_string += letter.upper()
    print(output_string)

输出:

thiS iS MY iNPUt strInG
tHiS IS My iNPut STRInG
THiS IS mY Input sTRINg
This IS my INput STRING
ThIS is my INpUt strIng
tHIs is My INpuT STRInG
tHIs IS MY inPUt striNg
THis is my inPUT sTRiNg
thiS IS mY iNPUT strIng
THiS is MY …

如下代码：

from pathlib import Path
Desktop = Path('Desktop')
SubDeskTop = Desktop+"/subdir"

得到以下错误：

    ---------------------------------------------------------------------------
 TypeError                                 Traceback (most recent call last)
    <ipython-input-4-eb31bbeb869b> in <module>()
             1 from pathlib import Path
             2 Desktop = Path('Desktop')
       ----> 3 SubDeskTop = Desktop+"/subdir"

     TypeError: unsupported operand type(s) for +: 'PosixPath' and 'str'

我显然在这里做一些可疑的事情，但这引发了一个问题：如何访问Path对象的子目录？

我一直在研究一个程序,它需要在主字符串(~400,000个字符)内计算子字符串(最多4000个位于列表中的2-6个字符的子字符串).我理解这与字符串中的Counting子字符串中提出的问题类似,但是,此解决方案对我不起作用.由于我的子字符串是DNA序列,我的许多子字符串都是单个字符的重复实例(例如'AA'); 因此,如果我将字符串拆分为'AA','AAA'将被解释为'AA'的单个实例而不是两个实例.我目前的解决方案是使用嵌套循环,但我希望有一个更快的方法,因为这个代码需要5分钟以上的单个主字符串.提前致谢!

def getKmers(self, kmer):
    self.kmer_dict = {}
    kmer_tuples = list(product(['A', 'C', 'G', 'T'], repeat = kmer))
    kmer_list = []
    for x in range(len(kmer_tuples)):
        new_kmer = ''
        for y in range(kmer):
            new_kmer += kmer_tuples[x][y]
        kmer_list.append(new_kmer)
    for x in range(len(kmer_list)):
        self.kmer_dict[kmer_list[x]] = 0
    for x in range(len(self.sequence)-kmer):
        for substr in kmer_list:
            if self.sequence[x:x+kmer] == substr:
                self.kmer_dict[substr] += 1
                break
    return self.kmer_dict

我想从一堆 PDB 文件中提取特定链的单字母氨基酸序列。

我可以使用 SeqIO.parse() 来做到这一点，但在我看来，它感觉很不Pythonic：

PDB_file_path = '/full/path/to/some/pdb' 

# Is there a 1-liner for this ?
query_seqres = SeqIO.parse(PDB_file_path, 'pdb-seqres')

for chain in query_seqres:
    if chain.id == query_chain_id:
        query_chain = chain.seq
#

有没有更简洁、更清晰的方法来做到这一点？