Print list without brackets in a single row

python

list-manipulation

string-conversion

performance-optimization

For printing a list without brackets, use the join() function with a list comprehension or the map() function:

# Don't worry, "map" doesn't mean we're going hiking
print(' '.join(map(str, [1, 2, 3])))

The output will be: 1 2 3

If you're dealing with a list of strings, you can give map() a break:

# Finally, no translating numbers to strings!
print(' '.join(["apple", "banana", "cherry"]))

The output will be: apple banana cherry

Converting data types

Encountered your fair share of data types in a list? No problem! Convert all of them to string:

mixed_list = [1, 'apple', 3.14]
# Karate chop your worries away with map()!
print(' '.join(map(str, mixed_list)))

The output will be: 1 apple 3.14

Looking to separate your printed list items with a comma? Consider it done:

numbers = [1, 2, 3]
# Add more flavor to your soup with commas!
print(', '.join(map(str, numbers)))

Output: 1, 2, 3

They're not strings? Use list comprehension instead:

# No strings attached!
print(', '.join(str(num) for num in numbers))

Love the convenience of * operator and the sep parameter? They've got your back:

# Who needs a clone spell when you have *?
print(*numbers, sep=", ")

Output: 1, 2, 3

The great thing? No need for pretentious string conversions, print() can handle it all.

Use caution when:

Using a comma as a separator without a succeeding space
Converting non-string values to string without using map() or list comprehension
Dealing with nested lists — they want their own spotlight

Caught between sep versus join()? Keep these guiding lights handy:

Need to customize your output further that mirrors slicing the output of str(list) but without the brackets?

# Who knew slicing lists could be this much fun?
numbers_str = str(numbers)[1:-1]
print(numbers_str)

Output: 1, 2, 3

Check your list size though, large lists might make it less efficient.

The join() method is more elegant, but not always the most efficient. When dealing with large lists, the unpacking method could be your savior.

When coding, readability is king. Code with too many explanations may lose its essence. Strive for simplicity.

In performance-intensive applications:

Always test different methods
Make a trade-off between performance opportunity vs aesthetic code
For lists with uniform data types, direct methods like the unpacking operator (*) may be quicker