5 Best Ways to Print a List of Tuples in Python Without Brackets

Printing a list of tuples in Python typically results in output enclosed in brackets. However, there are scenarios where a cleaner output without brackets is desired. For instance, when the input is [(1, 'apple'), (2, 'banana'), (3, 'cherry')], the desired output is 1, apple - 2, banana - 3, cherry. In this article, we address this requirement by discussing five effective methods.

Method 1: Using the str.join() and str() Methods

By leveraging the str.join() method together with str(), you can convert each tuple into a string and then concatenate them without brackets. It’s an elegant solution that utilizes built-in Python functionalities to achieve the desired result.

Here’s an example:

tuple_list = [(1, 'apple'), (2, 'banana'), (3, 'cherry')]
print(' - '.join([', '.join(map(str, t)) for t in tuple_list]))

Output: 1, apple - 2, banana - 3, cherry

This code snippet iterates over each tuple in the list, mapping each element to a string and then joining them with a comma. Afterwards, it joins the resulting strings with a delimiter (‘ – ‘). This way, the tuples are printed as if they are a continuous stream of text, without any brackets.

Method 2: Using the format() Function in a Loop

The format() function can be used within a loop to format each tuple accordingly and print them without brackets. This method offers flexibility with formatting, making it a go-to for custom output designs.

Here’s an example:

tuple_list = [(1, 'apple'), (2, 'banana'), (3, 'cherry')]
for t in tuple_list:
    print("{}, {} -".format(*t), end=' ')
print('\b\b')

Output: 1, apple - 2, banana - 3, cherry

In this snippet, each tuple is unpacked in the format() function, which formats the output according to the specified placeholders. The end=' ' parameter ensures that the next print statement continues on the same line, and \b\b removes the last unwanted hyphen and space.

Method 3: Using List Comprehension and the print() Function with *operator

A pythonic way to print the list of tuples without brackets is by using list comprehension inside the print() function along with the unpacking operator (*). This renders the code concise and readable.

Here’s an example:

tuple_list = [(1, 'apple'), (2, 'banana'), (3, 'cherry')]
print(*(f"{a}, {b}" for a, b in tuple_list), sep=" - ")

Output: 1, apple - 2, banana - 3, cherry

Using the unpacking operator, the list comprehension generates a generator expression that formats each tuple as a string, and then uses the sep argument in the print() function to separate them with the specified delimiter.

Method 4: Using a Loop with Manual String Concatenation

This method might not be as elegant as others but it’s straightforward, involving a loop and string concatenation to manually craft the output string without brackets.

Here’s an example:

tuple_list = [(1, 'apple'), (2, 'banana'), (3, 'cherry')]
output = ''
for t in tuple_list:
    output += f"{t[0]}, {t[1]} - "
print(output.rstrip(' - '))

Output: 1, apple - 2, banana - 3, cherry

The loop concatenates each tuple’s elements with the desired format to the output variable. The rstrip() method is then used to trim the trailing hyphen and space from the final string.

Bonus One-Liner Method 5: Using the print() Function with Tuple Expansion

By expanding the tuple inside the print() function, a one-liner code can be written to achieve the same result. It’s a quick method and best for one-off scripts where brevity is appreciated over readability.

Here’s an example:

tuple_list = [(1, 'apple'), (2, 'banana'), (3, 'cherry')]
print(' - '.join('%s, %s' % t for t in tuple_list))

Output: 1, apple - 2, banana - 3, cherry

The tuple elements are formatted and joined as strings in one line of code. This technique uses string formatting with percentages (%) which is an older format method, but still commonly used.

Summary/Discussion

• Method 1: Using str.join() and str(). Strengths: Concise and pythonic. Weaknesses: Might be less clear for beginners.
• Method 2: Using the format() function. Strengths: Flexible output formatting. Weaknesses: Verbosity with more complex data structures.
• Method 3: List comprehension with unpacking. Strengths: Compact and readable. Weaknesses: Unpacking may be confusing for some users.
• Method 4: Loop with manual string concatenation. Strengths: Easy to understand. Weaknesses: Can lead to inefficient string manipulation.
• Method 5: One-liner with tuple expansion. Strengths: Brevity. Weaknesses: Can decrease readability and is less flexible.