Python 三等分字符串

编写一个函数，该函数将字符串“s”作为参数，拆分为并返回一个元组（左、中、右）。如果字符串的长度不能被三整除，则函数应尝试尽可能均匀地分割字符串

我曾尝试使用for循环和string替换，strip函数，但显然不起作用。。。我不知所措。我现在的代码以3的形式输出所有内容

def trisect(s): 
    print(tuple([s[i:i+3] for i in range(0, len(s), 3)]))
s = input("what is your string: ")
trisect(s)

预期结果：输入：

“123456789012”

输出：

（'1234'，'5678'，'9012'）

实际结果：输入：

“123456789012”

---

输出：

（'123'、'456'、'789'、'012'）

您可以使用

len（s）

获取字符串的长度，然后使用

len（s）//3

（

/

执行整数除法）获取节的长度

然后，根据需要简单地切片：

长度=len（s）//3
三段=s[：长度]、s[长度：长度*2]、s[长度*2:]

编辑：

使用

length=round（len（s）/3）

代码：

for s in ["abcdef", "abcdefg", "abcdefgh"]:
    n, r = divmod(len(s), 3)
    trisections = s[:n], s[n:2*n+(r>1)], s[2*n+(r>1):]
    print(trisections)

('ab', 'cd', 'ef')
('ab', 'cd', 'efg')
('ab', 'cde', 'fgh')

输出：

for s in ["abcdef", "abcdefg", "abcdefgh"]:
    n, r = divmod(len(s), 3)
    trisections = s[:n], s[n:2*n+(r>1)], s[2*n+(r>1):]
    print(trisections)

('ab', 'cd', 'ef')
('ab', 'cd', 'efg')
('ab', 'cde', 'fgh')

---

编辑：一种广义的方法

# The method.
def n_sect(s, n):
    m, r = divmod(len(s), n)
    idx_a = 0
    result = []
    for i in range(n):
        idx_b = idx_a + m + (i < r)
        result.append(s[idx_a:idx_b])
        idx_a = idx_b
    return result

# Try it yourself!
import string
for n in range(3, 5):
    for i in range(1, 27):
        s = string.ascii_lowercase[:i]
        print(n_sect(s, n))
    print()

#方法。
定义n_节（s，n）：
m、 r=divmod（长（s），n）
idx_a=0
结果=[]
对于范围（n）中的i：
idx_b=idx_a+m+（i

起初，我认为这是重复的，但现有线程似乎没有考虑“尽可能均匀”的要求。使用

textwrap.wrap

，

zip

和大多数itertools解决方案，在最后会留下一块悬空的不均匀块。此解决方案从正面将

n

的任意值和焊盘分块

方法是取iterable长度的商和余数，并开始按所需的块大小进行迭代。对于每个区块，如果有余数，则向区块添加1。按块大小递增+1，剩余部分递减。如果没有余数，则正常生成块

下面是函数和测试代码：

def chunk(iterable, chunks):
    if chunks < 1: 
        raise ValueError("invalid chunk size")

    q, r = divmod(len(iterable), chunks)
    i = 0

    while i < len(iterable):
        if r > 0: 
            r -= 1
            yield iterable[i:i+q+1]
            i += 1
        else:
            yield iterable[i:i+q]

        i += q


if __name__ == "__main__":
    s = "".join(map(chr, range(97, 115)))

    for i in range(len(s) + 1):
        for j in range(1, len(s[:i]) + 1):
            print(repr(s[:i]), " chunk size", j, ":")
            print(list(chunk(s[:i], j)), "\n")

'abcdefgh'块大小1:
['abcdefgh']
“abcdefgh”块大小2：
['abcd'，'efgh']
“abcdefgh”块大小3：
['abc'，'def'，'gh']
“abcdefgh”块大小4:
['ab'、'cd'、'ef'、'gh']
“abcdefgh”块大小5：
['ab'，'cd'，'ef'，'g'，'h']
“abcdefgh”块大小6：
['ab'，'cd'，'e'，'f'，'g'，'h']
“abcdefgh”块大小7：
[ab'，c'，d'，e'，f'，g'，h']
“abcdefgh”块大小8:
['a'，'b'，'c'，'d'，'e'，'f'，'g'，'h']

'abcdefghijklm'块大小1:
['abcdefghijklm']
“abcdefghijklm”区块大小2：
['abcdefg'，'hijklm']
“abcdefghijklm”区块大小3：
['abcde'，'fghi'，'jklm']
“abcdefghijklm”块大小4：
['abcd'，'efg'，'hij'，'klm']
“abcdefghijklm”块大小5：
['abc'，'def'，'ghi'，'jk'，'lm']
“abcdefghijklm”区块大小6：
['abc'，'de'，'fg'，'hi'，'jk'，'lm']
“abcdefghijklm”区块大小7：
['ab'，'cd'，'ef'，'gh'，'ij'，'kl'，'m']
“abcdefghijklm”块大小8：
['ab'，'cd'，'ef'，'gh'，'ij'，'k'，'l'，'m']
“abcdefghijklm”区块大小9：
['ab'，'cd'，'ef'，'gh'，'i'，'j'，'k'，'l'，'m']
“abcdefghijklm”区块大小10：
[ab'，cd'，ef'，g'，h'，i'，j'，k'，l'，m']
“abcdefghijklm”区块大小11：
[ab'，cd'，e'，f'，g'，h'，i'，j'，k'，l'，m']
“abcdefghijklm”区块大小12：
[ab'，c'，d'，e'，f'，g'，h'，i'，j'，k'，l'，m']
“abcdefghijklm”区块大小13：
['a'，'b'，'c'，'d'，'e'，'f'，'g'，'h'，'i'，'j'，'k'，'l'，'m']

现在，编写

trisect

函数如下所示：

def trisect(s):
    return list(chunk(s, 3))

---

您当前只获得3个字符的字符串，因为您已固定了子字符串的大小

s[i:i+3]

将始终是一个长度为3的子字符串，因此，如果您得到的字符串大于或小于9个字符，它将失败。

范围（a，b，3）

表示“拆分为N个长度为3的独立子字符串”；它并不意味着“精确地分成3个子字符串”。

s=“abcdefgh”

->

trisections=（'ab'，'cd'，'efgh'）

我认为最好使用正则除法，然后将

长度

四舍五入到最接近的整数。这将解决@brentertainerRounding指出的问题，给出奇怪的结果，如

（'abc'，'de'，'fgh'）

，但至少它解决了差异问题。Brentertainer的回答给出了一致的结果。在3上效果很好，但我希望这可以推广到任何

n

（很好的奖励！）。另外，如果从前面而不是从后面填充，会更直观一些+1不管怎样。啊，就像我贴的一样。干得不错，我喜欢这个。