blocks|key|1182723|text|def+repeat_to_length(string_to_expand,+length):
+++return+(string_to_expand+*+((length/len(string_to_expand))%2B1))[:length]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1182724|对于python3：|unstyled|1182725|def+repeat_to_length(string_to_expand,+length):
++++return+(string_to_expand+*+(int(length/len(string_to_expand))%2B1))[:length]|1182726|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>def repeat_to_length(string_to_expand, length):
 return (string_to_expand * ((length/len(string_to_expand))+1))[:length]
</code></pre>

For python3:

<pre><code>def repeat_to_length(string_to_expand, length):
 return (string_to_expand * (int(length/len(string_to_expand))+1))[:length]
</code></pre>

blocks|key|1182730|text|string+*+(length+/+len(string))+%2B+string[0:(length+%25+len(string))]怎么样？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1182731|entityMap^0|0|1U|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

How about <code>string * (length / len(string)) + string[0:(length % len(string))]</code>

blocks|key|968509|text|这是使用列表理解的一种方法，尽管随着rpt字符串长度的增加，这种方法会越来越浪费。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|968510|def+repeat(rpt,+length):
++++return+''.join([rpt+for+x+in+range(0,+(len(rpt)+%25+length))])[:length]|code-block|syntax|javascript|968511|entityMap^0|I|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This is one way to do it using a list comprehension, though it's increasingly wasteful as the length of the <code>rpt</code> string increases.

<pre><code>def repeat(rpt, length):
 return ''.join([rpt for x in range(0, (len(rpt) % length))])[:length]
</code></pre>

blocks|key|968522|text|from+itertools+import+cycle,+islice
def+srepeat(string,+n):
+++return+''.join(islice(cycle(string),+n))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|968523|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>from itertools import cycle, islice
def srepeat(string, n):
 return ''.join(islice(cycle(string), n))
</code></pre>

blocks|key|968541|text|def+rep(s,+m):
++++a,+b+=+divmod(m,+len(s))
++++return+s+*+a+%2B+s[:b]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|968542|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def rep(s, m):
 a, b = divmod(m, len(s))
 return s * a + s[:b]
</code></pre>

blocks|key|1182893|text|也许不是最有效的解决方案，但肯定是简短简单的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1182894|def+repstr(string,+length):
++++return+(string+*+length)[0:length]

repstr("foobar",+14)|code-block|syntax|javascript|1182895|给出"foobarfoobarfo“。关于这个版本的一件事是，如果length+<+len(+string+)，那么输出字符串将被截断。例如：|1182896|repstr("foobar",+3)|1182897|给出"foo“。|1182898|Edit:实际上，令我惊讶的是，这比目前接受的解决方案(+'repeat_to_length‘函数)更快，至少在短字符串上是这样：|1182899|from+timeit+import+Timer
t1+=+Timer("repstr('foofoo',+30)",+'from+__main__+import+repstr')
t2+=+Timer("repeat_to_length('foofoo',+30)",+'from+__main__+import+repeat_to_length')
t1.timeit()++#+gives+~0.35+secs
t2.timeit()++#+gives+~0.43+secs|1182900|假设如果字符串很长，或者长度非常高(即，如果string+*+length部分的浪费很高)，那么它的性能就会很差。事实上，我们可以修改上面的代码来验证这一点：|offset|length|style|CODE|1182901|from+timeit+import+Timer
t1+=+Timer("repstr('foofoo'+*+10,+3000)",+'from+__main__+import+repstr')
t2+=+Timer("repeat_to_length('foofoo'+*+10,+3000)",+'from+__main__+import+repeat_to_length')
t1.timeit()++#+gives+~18.85+secs
t2.timeit()++#+gives+~1.13+secs|1182902|entityMap^0|0|0|0|0|0|0|0|M|F|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@$S|18|T|19|U|V]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Perhaps not the most efficient solution, but certainly short &amp; simple:

<pre><code>def repstr(string, length):
 return (string * length)[0:length]

repstr("foobar", 14)
</code></pre>

Gives "foobarfoobarfo". One thing about this version is that if length &lt; len(string) then the output string will be truncated. For example:

<pre><code>repstr("foobar", 3)
</code></pre>

Gives "foo".

Edit: actually to my surprise, this is faster than the currently accepted solution (the 'repeat_to_length' function), at least on short strings:

<pre><code>from timeit import Timer
t1 = Timer("repstr('foofoo', 30)", 'from __main__ import repstr')
t2 = Timer("repeat_to_length('foofoo', 30)", 'from __main__ import repeat_to_length')
t1.timeit() # gives ~0.35 secs
t2.timeit() # gives ~0.43 secs
</code></pre>

Presumably if the string was long, or length was very high (that is, if the wastefulness of the <code>string * length</code> part was high) then it would perform poorly. And in fact we can modify the above to verify this:

<pre><code>from timeit import Timer
t1 = Timer("repstr('foofoo' * 10, 3000)", 'from __main__ import repstr')
t2 = Timer("repeat_to_length('foofoo' * 10, 3000)", 'from __main__ import repeat_to_length')
t1.timeit() # gives ~18.85 secs
t2.timeit() # gives ~1.13 secs
</code></pre>

blocks|key|968642|text|另一种FP方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|968643|def+repeat_string(string_to_repeat,+repetitions):
++++return+''.join([+string_to_repeat+for+n+in+range(repetitions)])|code-block|syntax|javascript|968644|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another FP aproach:

<pre><code>def repeat_string(string_to_repeat, repetitions):
 return ''.join([ string_to_repeat for n in range(repetitions)])
</code></pre>

blocks|key|1182999|text|并不是说这个问题没有足够的答案，而是有一个repeat函数；只需要列出一个列表，然后加入输出：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1183000|from+itertools+import+repeat

def+rep(s,n):
++''.join(list(repeat(s,n))|code-block|syntax|javascript|1183001|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Not that there haven't been enough answers to this question, but there is a repeat function; just need to make a list of and then join the output:

<pre><code>from itertools import repeat

def rep(s,n):
 ''.join(list(repeat(s,n))
</code></pre>

blocks|key|968707|text|我使用的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|968708|def+extend_string(s,+l):
++++return+(s*l)[:l]|code-block|syntax|javascript|968709|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

i use this: 

<pre><code>def extend_string(s, l):
 return (s*l)[:l]
</code></pre>

blocks|key|1183050|text|这是相当的pythonic式的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1183051|newstring+=+'abc'*5
print+newstring[0:6]|code-block|syntax|javascript|1183052|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is pretty pythonic:

<pre><code>newstring = 'abc'*5
print newstring[0:6]
</code></pre>

blocks|key|968726|text|def+extended_string+(word,+length)+:

++++extra_long_word+=+word+*+(length//len(word)+%2B+1)
++++required_string+=+extra_long_word[:length]
++++return+required_string

print(extended_string("abc",+7))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|968727|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def extended_string (word, length) :

 extra_long_word = word * (length//len(word) + 1)
 required_string = extra_long_word[:length]
 return required_string

print(extended_string("abc", 7))
</code></pre>

blocks|key|1183083|text|c+=+s.count('a')++++
div=n//len(s)++++
if+n%25len(s)==0:
++++c=+c*div
else:
++++m+=+n%25len(s)
++++c+=+c*div%2Bs[:m].count('a')
print(c)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1183084|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>c = s.count('a') 
div=n//len(s) 
if n%len(s)==0:
 c= c*div
else:
 m = n%len(s)
 c = c*div+s[:m].count('a')
print(c)
</code></pre>

What is an efficient way to repeat a string to a certain length? Eg: <code>repeat('abc', 7) -&gt; 'abcabca'</code>

Here is my current code:

<pre><code>def repeat(string, length):
 cur, old = 1, string
 while len(string) &lt; length:
 string += old[cur-1]
 cur = (cur+1)%len(old)
 return string
</code></pre>

Is there a better (more pythonic) way to do this? Maybe using list comprehension?

Repeat string to certain length

重复特定长度的字符串的有效方法是什么？例如：repeat('abc', 7) -> 'abcabca'下面是我当前的代码：def repeat(string, length): cur, old = 1, string while len(string) < length: string +=...

问将字符串重复到一定长度
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字符串重复到一定长度EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将字符串重复到一定长度
EN