小编Chr*_*nds的帖子

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

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 …

我在Python脚本中使用Mysql Connection.

如何从名称中获取表格的结果？

cursor = conn.cursor()
cursor.execute("SELECT * FROM local")

现在我通过索引来做到这一点:

results = cursor.fetchall()
for row in results:
   print row[0] //

相反,我想通过名称得到字段,如:print row["name"]

我目前开始使用python 2中的python 3.在Python 2中,字符串类型转换可以使用int()函数轻松完成,但我在Py3.5.3中遇到问题

current = input("Enter the Current price: ")
int(current)
print (type(current))
c = current - 24

Class str即使在类型转换功能之后,电流仍然显示为.

错误是 TypeError: unsupported operand type(s) for -: 'str' and 'int'

我知道这只是一个小错误,但我在网上查看的例子都使用了我使用的int函数.这可能是什么问题

假设我有一个数字列表,我想将这个列表分成两个子列表:一个用于奇数,另一个用于平均.

evens, odds = [], []
for e in numbers:
    if e % 2 == 0:
        evens.append(e)
    else:
        odds.append(e)

我想知道在保持相同的复杂程度的同时,是否存在针对此问题的单线程.

我尝试使用itertools.groupby但是列表需要先订购,所以我要实现一个O(2n)而不是O(n):

def is_even(n):
    return n % 2 == 0

lst = sorted(lst, key=is_even)
grouper = itertools.groupby(lst, key=is_even)
lst1, lst2 = [list(v) for k, v in grouper]

我是 Biopython 的新手（以及一般编码），我正在尝试编写一种方法，将一系列 DNA 序列（超过 80 个）翻译成蛋白质序列，在一个单独的 FASTA 文件中。我还想在正确的阅读框中找到序列。

这是我到目前为止所拥有的：

from Bio import SeqIO
from Bio.SeqRecord import SeqRecord

for record in SeqIO.parse("dnaseq.fasta", "fasta"):
    protein_id = record.id
    protein1 = record.seq.translate(to_stop=True)
    protein2 = record.seq[1:].translate(to_stop=True)
    protein3 = record.seq[2:].translate(to_stop=True)

if len(protein1) > len(protein2) and len(protein1) > len(protein3):
    protein = protein1
elif len(protein2) > len(protein1) and len(protein2) > len(protein3):
    protein = protein2
else:
    protein = protein3

def prot_record(record):
    return SeqRecord(seq = protein, \
             id = ">" + protein_id, \
             description = "translated sequence")

records = …

最近我在Python中学习了更多关于哈希的知识,我在这个博客中说到:

假设一个Python程序有2个列表.如果我们需要考虑比较这两个列表,你会怎么做？比较每个元素？嗯,这听起来很简单,但也很慢!

Python有一个更聪明的方法来做到这一点.当在程序中构造元组时,Python解释器会在其内存中计算其哈希值.如果在2个元组之间进行比较,它只是比较哈希值,它知道它们是否相等!

所以我对这些陈述感到很困惑.

首先,当我们这样做时: [1, 2, 3] == [1, 2, 3]那么这种平等如何运作？它是否计算哈希值然后进行比较？

第二,当我们做的时候有什么不同:

[1, 2, 3] == [1, 2, 3]和(1, 2, 3) == (1, 2, 3)？

因为当我试图用timeit找到执行时间时,我得到了这个结果:

$ python3.5 -m timeit '[1, 2, 3] == [1, 2, 3]'
10000000 loops, best of 3: 0.14 usec per loop
$ python3.5 -m timeit '(1, 2, 3) == (1, 2, 3)'
10000000 loops, best of 3: 0.0301 usec per loop

那么为什么从0.14列表到0.03元组的时间差异比列表更快.

这是一个元编程问题：我想了解为什么python开发人员在new中引入了另一个运算符:=。我知道这是干什么的 但是，我想知道为什么开发人员选择一个新的符号而不是重复使用例如as运算符。

即为什么认为最好写

while (command := input("> ")) != "quit":
    print("You entered:", command)

而不是

while input("> ") as command != "quit":
    print("You entered:", command)

https://github.com/asottile/pyupgrade/blob/fecacc91e57c224a0bd2564579ef01238650126c/pyupgrade.py#L53

if False:  # pragma: no cover (mypy)
    from typing import Type
    if sys.version_info >= (3,):
        AsyncFunctionDef = ast.AsyncFunctionDef
    else:
        AsyncFunctionDef = ast.stmt

提交没有透露：https : //github.com/asottile/pyupgrade/commit/fecacc91e57c224a0bd2564579ef01238650126c#diff-8213eba6a28bcc759225cd8cf49b2fd1

False 在 Python 2（可以重新定义）中是真实的，但在 Python 3 中不是。这可能是一个笑话，或者正在进行中，或者注释掉代码的方式，但这是一个非常成熟的工具 - 我是遗漏了什么？

任务:
编写一个程序,检查作为参数提供的单词是否是等值线.Isogram是一个不会出现多次字母的单词.

创建一个名为is_isogram的方法,它接受一个参数,一个单词来测试它是否是等值线图.此方法应返回单词的元组和布尔值,指示它是否是等值线图.

如果提供的参数是空字符串,则返回参数和False :(参数,False).如果提供的参数不是字符串,则引发TypeError,并显示消息'Argument should a a string'.

例:

is_isogram("abolishment")

预期结果:

("abolishment", True)

可见测试

from unittest import TestCase

class IsogramTestCases(TestCase):
  def test_checks_for_isograms(self):
    word = 'abolishment'
    self.assertEqual(
      is_isogram(word),
      (word, True),
      msg="Isogram word, '{}' not detected correctly".format(word)
    )

  def test_returns_false_for_nonisograms(self):
    word = 'alphabet'
    self.assertEqual(
      is_isogram(word),
      (word, False),
      msg="Non isogram word, '{}' falsely detected".format(word)
    )

  def test_it_only_accepts_strings(self):
    with self.assertRaises(TypeError) as context:
      is_isogram(2)
      self.assertEqual(
        'Argument should be a string',
        context.exception.message,
        'String inputs allowed only'
      )

我的解决方案

def is_isogram(word):
    if type(word) != str: …

我有一个文本文件,其中每个ID行开头,>下一行是一系列字符.字符序列之后的下一行将是另一个以ID开头的ID行>.但在其中一些,而不是我有序列“Sequence unavailable”.ID行之后的序列可以是一行或多行.像这样的例子:

>ENSG00000173153|ENST00000000442|64073050;64074640|64073208;64074651
AAGCAGCCGGCGGCGCCGCCGAGTGAGGGGACGCGGCGCGGTGGGGCGGCGCGGCCCGAGGAGGCGGCGGAGGAGGGGCCGCCCGCGGCCCCCGGCTCACTCCGGCACTCCGGGCCGCTC
>ENSG00000004139|ENST00000003834
Sequence unavailable

我想过滤掉那些ID “Sequence unavailable”.输出应如下所示:

输出:

>ENSG00000173153|ENST00000000442|64073050;64074640|64073208;64074651
AAGCAGCCGGCGGCGCCGCCGAGTGAGGGGACGCGGCGCGGTGGGGCGGCGCGGCCCGAGGAGGCGGCGGAGGAGGGGCCGCCCGCGGCCCCCGGCTCACTCCGGCACTCCGGGCCGCTC

你知道如何在python中做到这一点吗？