Kodeclik Blog
Printing a list in Python with semicolons between entries
Sometimes you would like to pretty print a list rather than accept the default way lists are printed in Python. Consider for instance:
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
print(mylist)The output will be:
['Jan', 'Feb', 'Mar', 'Apr']Note that the delimiters between entries are commas, just like how you set up the list in the first place.
Sometimes you might wish to use a different delimiter, e.g., a semicolon. How do we go about it? Here are six ways!
Method 1: Traverse the list carefully
Here is a very poor, inelegant way:
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
for x in mylist[0:-1]:
print(x, end=";")
print(mylist[-1])Here we are using a for loop with the slice mylist[0:-1] that selects all elements except the last one, and these are printed with a semicolon using the end=";" parameter to override Python's default newline behavior. Then, the final element mylist[-1] is printed separately on the same line without a semicolon.
The output will be:
Jan;Feb;Mar;AprAs mentioned this approach works but is not elegant.
Method 2: Use print() with unpacking
This is arguably the better and simplest method. It uses the asterisk (*) operator to unpack the list elements and the sep parameter (instead of the end parameter) to specify the semicolon separator. It's a concise and readable approach that leverages Python's print function capabilities:
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
print(*mylist, sep=';')The output will be:
Jan;Feb;Mar;AprNote that the Python deconstruction or unpacking operator is needed. Without it, if your code was:
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
print(mylist, sep=';')The output will instead be:
['Jan', 'Feb', 'Mar', 'Apr']In other words, the entire list is viewed as one entity, which is printed and the separator (“;”) is used between entries. But there is only one entry, so you don’t see the semicolon at all! This is why the unpacking operator is very much needed.
Method 3: Use join()
The join() method concatenates all elements in the list using the specified separator (semicolon). This approach is clean and efficient, working directly with the list elements:
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
print(';'.join(mylist))The output is again:
Jan;Feb;Mar;AprMethod 4: Use enumerate
This is likely a very traditional approach. It iterates through the list using enumerate to track position, printing each element with a semicolon except for the last item.
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
for i, item in enumerate(mylist):
print(item, end=';' if i < len(mylist)-1 else '')Note that it uses python enumerate, which returns both the item and its index as we run through the list. The output will be:
Jan;Feb;Mar;AprWhile more verbose, this approach offers the most control over formatting and can be useful when additional processing is needed.
Method 5: Use lambda functions and reduce()
This approach might seem like an overkill.
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
from functools import reduce
print(reduce(lambda x, y: str(x) + ';' + str(y), mylist))The reduce() function applies the lambda function cumulatively to the list elements from left to right. The lambda function takes two arguments (x and y) and concatenates them with a semicolon between them4. This process continues until all elements are combined into a single string.
The output is again:
Jan;Feb;Mar;AprThis lambda-based approach using reduce() offers a functional programming style solution that can be particularly elegant when working with other functional programming constructs.
Why do we view it as an overkill? It is generally less readable and less efficient than the join() or print(*list, sep=';') methods. Further, note that the reduce() operation has to create new string objects at each step of the reduction, making it less memory-efficient for large lists. Additionally, this method requires importing from functools, adding an extra dependency that the other methods don't need.
Method 6: Use map() and join()
Since we have used reduce() it is only natural to explore if there is a way to use map() as well to achieve our desired objective. Turns out the answer is yes!
mylist = ['Jan', 'Feb', 'Mar', 'Apr']
print(';'.join(map(str, mylist)))The output will be the same as above. You can view this as an amalgamation of the above approaches. This approach combines map() to convert all elements to strings with join() to concatenate them. It's particularly useful when dealing with lists containing mixed data types, as it ensures all elements are strings before joining. For instance, if one element is a string and another is an integer, this approach will serve you nicely.
Now, when would you need to print a Python list as a string with semicolons? Here are some situations!
Complex Items with Internal Commas
For instance, if your list items themselves contain commas, you need to look for a different character (in our case, semicolon) to string together the entries. Consider:
"I've lived in New York, New York; San Francisco, California; and Knoxville, Tennessee".
The semicolons here prevent confusion that would arise from using multiple commas.
Lists Within Lists
Semicolons are needed when you have a list embedded within another list. For example:
"I need to buy a textbook, a workbook, and a dictionary for Spanish; a calculator for math; and a map for geography".
The semicolons help distinguish the main list items from the sub-items.
We hope you enjoyed learning how to print a Python list with semicolons as delimiters. Which one of the above ways is your favorite? Or do you have a new one?
Want to learn Python with us? Sign up for 1:1 or small group classes.
