I have a list of unknown number of items, let's say 26. let's say
list=['a','b','c','d','e','f','g','h',
'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
How to print like this:
abcde
fghij
klmno
pqrst
uvwxy
z
? Thank you very much. Attempt:
start = 0
for item in list:
if start < 5:
thefile.write("%s" % item)
start = start + 5
else:
thefile.write("%s" % item)
start = 0
for i, a in enumerate(A):
print a,
if i % 5 == 4:
print "\n"
Another alternative, the comma after the print means there is no newline character
You can simple do this by list comprehension: "\n".join(["".join(lst[i:i+5]) for i in xrange(0,len(lst),5)]) the xrange(start, end, interval) here would give a list of integers which are equally spaced at a distance of 5, then we slice the given list in to small chunks each with length of 5 by using list slicing.
Then the .join() method does what the name suggests, it joins the elements of the list by placing the given character and returns a string.
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
print "\n".join(["".join(lst[i:i+5]) for i in xrange(0,len(lst),5)])
>>> abcde
fghij
klmno
pqrst
uvwxy
z
It needs to invoke for-loop and join functions can solve it.
l=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
for i in range(len(l)/5+1):
print "".join(l[i*5:(i+1)*5]) + "\n"
Demo:
abcde
fghij
klmno
pqrst
uvwxy
z
Lots of answers here saying you how to do it, but none explaining how to figure it out. The trick I like to use to figure out a loop is to write the first few iterations by hand, and then look for a pattern. Also, ignore edge cases at first. Here, the obvious edge case is: what if the size of the list is not a multiple of 5? Don't worry about it! I'm going to try to avoid using any fancy language features that would make things easier for us in this answer, and instead do everything manually, the hard way. That way we can focus on the basic idea instead of cool Python features. (Python has lots of cool features. I'm honestly not sure if I can resist them, but I'll try.) I'm going to use print statements instead of thefile.write, because I think it's easier to read. You can even use print statements to write to files:
print >> thefile, l[0], and no need for all those %s strings :) Here's version 0:
print l[0], l[1], l[2], l[3], l[4]
print l[5], l[6], l[7], l[8], l[9]
This loop is simple enough that two iterations is probably enough, but sometimes you may need more. Here's version 1 (note that we still assume the size of the list is a multiple of 5):
idx=0
while idx < len(l):
print l[idx], l[idx+1], l[idx+2], l[idx+3], l[idx+4]
a += 5
Finally, we're ready to take care of the annoying fact that most numbers are not a multiple of 5. The above code will basically crash in that case. Let's try to fix it without thinking too hard. There are several ways to do this; this is the one I came up with; you're encouraged to try to come up with your own before peeking at what I did. (Or after peeking if you prefer.) Version 2:
idx=0
while idx < len(l):
print l[index],
if idx+1 < len(l): print l[idx+1],
if idx+2 < len(l): print l[idx+2],
if idx+3 < len(l): print l[idx+3],
if idx+4 < len(l): print l[idx+4]
idx += 5
We finally have code that does what we want, but it's not pretty. It's so repetitive that I resorted to copy/paste to write it, and it's not very symmetric either. But we know what to do about repetitive code: use a loop! Version 3:
idx=0
while idx < len(l):
b = 0
while b < 5:
if idx+b < len(l): print l[idx+b],
b += 1
print
idx += 5
It's no longer repetitive, but it didn't get any shorter. This might be a good time to look at our code and see if it reflects the best solution, or merely reflects the path we took to get here. Maybe there is a simpler way. Indeed, why are we processing things in blocks of five? How about we go one at a time, but treat every fifth item specially. Let's start over. Version 4:
idx=0
while idx < len(l):
print l[idx],
if idx % 5 == 4: print
idx += 1
Now that's much prettier! At this point, we've worked hard, and reward ourselves by looking at what cool features Python has to make this code even nicer. And we find that dabhand's answer is almost exactly what we have, except that it uses enumerate so Python does the work of keeping track of what number we're on. It only saves us two lines, but with such a short loop, it almost cuts our line count in half :) Version 5:
for idx, item in enumerate(l):
print item,
if idx % 5 == 4: print
And that's my final version. Many people here suggest using join. It's a good idea for this problem, and you might as well use it. The trouble is it would not help if you had a different problem. The DIY approach works even when Python does not have a pre-cooked solution :)
This will work:
n = m = 0
while m < len(l):
m = m+5
print("".join(l[n:m]))
n = m
But I believe there is a more pythonic way to accomplish the task.
You can something easier like below , break your list into sub-list , also this seems more Pythonic . Then print it how ever u want . Also don't use list as it's a keyword(not recommended)
sub_list1=[list1[x:x+5] for x in xrange(0, len(list1), 5)]
for each in sub_list1:
print( ''.join(each))
start = 0
for item in list:
if start < 4:
thefile.write("%s" % item)
start = start + 1
else: #once the program wrote 4 items, write the 5th item and two linebreaks
thefile.write("%s\n\n" % item)
start = 0
for x in range(0, len(list), 5):
print(*list[x:x+5])
The idea here is to count by 5 (starting at 0), and then slice out the item that's indexed at that count and the next 4 items.
| Count | Slice |
|---|---|
| 0 | 0 - 4 |
| 5 | 5 - 9 |
| 10 | 10 - 14 |
Just to prove I am really an unreformed JAPH regular expressions are the way to go!
import re
q="".join(lst)
for x in re.finditer('.{,5}',q)
print x.group()
Python 3+ simple way
lst=['a','b','c','d','e','f','g','h','i','j','k','l','m',
'n','o','p','q','r','s','t','u','v','w','x','y','z']
for ind, smb in enumerate(lst):
print(smb, end='')
if ind%5 == 4:
print('\n')
I think the most cleaner way to write this would be
list=['a','b','c','d','e','f','g','h', 'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
for i in range(0, len(list), 5):
print(*list[i:i+5], sep='')
If you're working on an iterable (like a file) which is potentially too big to fit in RAM you can use something like this:
from itertools import izip_longest
def chunker(iterable, n, fillvalue=None):
"""Like an itertools.grouper but None values are excluded.
>>> list(chunker([1, 2, 3, 4, 5], 3))
[[1, 2, 3], [4, 5]]
"""
if n < 1:
raise ValueError("can't chunk by n=%d" % n)
args = [iter(iterable)] * n
return (
[e for e in t if e is not None]
for t in izip_longest(*args, fillvalue=fillvalue)
)
with open('some_file') as f:
for row in chunker(f, 5):
print "".join(row)
If RAM is not a consideration the answer by ZdaR is preferable as it is considerably faster.
