With a set of data from an arbitrary set of lists (or dicts or other iter), I want to create a new list or tuple that has all the first entries, then all the 2nd, and so on, like an hstack. If I have a known set of data, I can zip them together like this: data = {'2015': [2, 1, 4, 3, 2, 4], '2016': [5, 3, 3, 2, 4, 6], '2017': [3, 2, 4, 4, 5, 3]} hstack = sum(zip(data['2015'], data['2016'], data['2017']), ()) print(hstack) # hstack: (2, 5, 3, 1, 3, 2, 4, 3, 4, 3, 2, 4, 2, 4, 5, 4, 6, 3)  But what if I don't know how many entries (or the keys) of the dict? For processing an arbitrary set of iterators, I tried: combined_lists = sum(zip(data[val] for val in data.keys()), ()) # combined_lists: ([2, 1, 4, 3, 2, 4], [5, 3, 3, 2, 4, 6], [3, 2, 4, 4, 5, 3])  And also: nums = sum(zip(num for val in data.keys() for num in data[val]), ()) # nums: (2, 1, 4, 3, 2, 4, 5, 3, 3, 2, 4, 6, 3, 2, 4, 4, 5, 3)  But both of these just keep the same order I could get from adding the sequences together. I was able to get it to work with: counts = [] entry = list(data.keys())[0] for idx, count in enumerate(data[entry]): for val in list(data.keys()): counts.append(data[val][idx]) # counts: [2, 5, 3, 1, 3, 2, 4, 3, 4, 3, 2, 4, 2, 4, 5, 4, 6, 3]  Which is fine, but it's a bit bulky. Seems like there should be a better way. Is there a way with list comprehension or some feature of zip that I missed? No imports preferred.
While @Tinyfold's answer works, it should be pointed out that using sum to concatenate a series of iterables is rather inefficient as noted in the documentation:  For some use cases, there are good alternatives to sum(). The preferred, fast way to concatenate a sequence of strings is by calling ''.join(sequence). To add floating-point values with extended precision, see math.fsum(). To concatenate a series of iterables, consider using itertools.chain().  This is because sum() at its core performs a series of additions, each of which is a binary operation that "adds" two operands into one value. This is fine for numeric values, but for tuples as in your example, each addition creates a new tuple by copying all items in tuples of both operands, so a series of additions of tuples becomes quadratic in time complexity. To keep the time complexity linear you can use itertools.chain instead as suggested by the documentation: from itertools import chain hstack = tuple(chain.from_iterable(zip(*data.values())))  or if you absolutely don't want any import (which should not be a problem because itertools is part of the standard library), use a generator expression: hstack = tuple(i for t in zip(*data.values()) for i in t)  Note that itertools.chain is faster than a generator expression/comprehension because the former is written purely in C while the latter has to be interpreted.