如何每行打印一个元组的元素答案

【问题标题】：How to print out elements of tuple one per line如何每行打印一个元组的元素
【发布时间】：2016-02-04 21:07:13
【问题描述】：

以下是我的 DNA 字符串相邻问题的代码：

chars = "ACGT"

def neighbors(pattern, d):
    assert(d <= len(pattern))

    if d == 0:
        return [pattern]

    r2 = neighbors(pattern[1:], d-1)
    r = [c + r3 for r3 in r2 for c in chars if c != pattern[0]]

    if (d < len(pattern)):
        r2 = neighbors(pattern[1:], d)
        r += [pattern[0] + r3 for r3 in r2]

    return r
def neighbors2(pattern, d):
    return ([neighbors(pattern, d2) for d2 in range(d + 1)], [])

print (neighbors2("ACG", 1))

输出如下：

([['ACG'], ['CCG', 'GCG', 'TCG', 'AAG', 'AGG', 'ATG', 'ACA', 'ACC', 'ACT']], [])

我怎样才能添加一些代码并改变输出看起来像这种模式：

CCG
TCG
GCG
AAG
ATG
AGG
ACA
ACC
ACT
ACG

【问题讨论】：

您的输出顺序与打印顺序不同。（最后打印的 ACG，有一个额外的 AGG、TCG 和 GCG 交换）是否有任何变化或只是拼写错误？

标签： python output tuples

【解决方案1】：

您可以使用 compiler.ast 模块中的 flatten 函数

from compiler.ast import flatten
print flatten(neighbors2("ACG", 1))

会产生

['ACG', 'CCG', 'GCG', 'TCG', 'AAG', 'AGG', 'ATG', 'ACA', 'ACC', 'ACT']

或

print("\n".join(flatten(neighbors2("ACG", 1))))

有这样的输出：

ACG
CCG
GCG
TCG
AAG
AGG
ATG
ACA
ACC
ACT

【讨论】：

编译器模块自 2.6 版起已弃用并在 python 3 中删除
@Copperfield 太糟糕了:(

【解决方案2】：

有几种方法可以做到这一点，你可以打印每一个，制作一个大字符串并打印它，使用 print 函数的sep 参数，定义一个代表你的东西的类 __str__ 方法以你想要的方式返回一个字符串。

例如

>>> test=['CCG', 'GCG', 'TCG', 'AAG', 'AGG', 'ATG', 'ACA', 'ACC', 'ACT']

打印一个

>>> for x in test:
        print(x)


CCG
GCG
TCG
AAG
AGG
ATG
ACA
ACC
ACT

制作一个大字符串

>>> print( "\n".join(test) )
CCG
GCG
TCG
AAG
AGG
ATG
ACA
ACC
ACT

使用 sep 和解包

>>> print( *test, sep="\n" )
CCG
GCG
TCG
AAG
AGG
ATG
ACA
ACC
ACT

使用类

>>> class Foo:
    def __init__(self,data):
        self.data=data
    def __str__(self):
        return "\n".join(self.data)


>>> x=Foo(test)
>>> print(x)
CCG
GCG
TCG
AAG
AGG
ATG
ACA
ACC
ACT

要从([['ACG'], ['CCG', 'GCG', 'TCG', 'AAG', 'AGG', 'ATG', 'ACA', 'ACC', 'ACT']], []) 到['ACG', 'CCG', 'GCG', 'TCG', 'AAG', 'AGG', 'ATG', 'ACA', 'ACC', 'ACT'] 你可以使用这个Flatten (an irregular) list of lists in Python 的答案，例如unutbu 的答案是我最喜欢的一个

from itertools import chain
from collections import Iterable

try: #python 2
    _basestring = basestring
except NameError:
    #python 3
    _basestring = (str,bytes)

def flatten_total(iterable, flattype=Iterable, ignoretype=_basestring):
    """Flatten all level of nesting of a arbitrary iterable"""
    #https://stackoverflow.com/questions/2158395/flatten-an-irregular-list-of-lists-in-python
    #unutbu version
    remanente = iter(iterable)
    while True:
        elem = next(remanente)
        if isinstance(elem,flattype) and not isinstance(elem,ignoretype):
            remanente = chain( elem, remanente )
        else:
            yield elem

然后做

print( "\n".join(flatten_total( neighbors2("ACG", 1))) )

【讨论】：

有很多不同方式的好答案。应该是公认的答案。

【解决方案3】：

我只是想打印而且嵌套层级总是一样的，你可以这样做：

for entry in neighbors2("ACG", 1)[0]:
    print(*entry, sep='\n')

输出：

ACG
CCG
GCG
TCG
AAG
AGG
ATG
ACA
ACC
ACT

【讨论】：