Horizontal Concatenation of Multiline Strings in Python

In Python, the concatenation of strings is a common operation that allows you to combine two or more strings into a single string. While concatenating strings vertically (i.e., one below the other) is straightforward, concatenating strings horizontally (i.e., side by side) requires some additional handling, especially when dealing with multiline strings. In this article, we will explore different approaches for performing horizontal concatenation of multiline strings in Python.

Using the + Operator

The + operator can be used to combine two or more strings into a single string. However, when dealing with multiline strings, using the + operator may not produce the desired horizontal concatenation.

Syntax

result = operand1 + operand2

The "+" operator is used for addition in Python. When used with string operands, it concatenates the strings and returns the combined result.

Example

In the below example, the + operator concatenates the strings vertically, resulting in the strings being appended one after the other ?

string1 = "Hello"
string2 = "World"

concatenated_string = string1 + string2

print(concatenated_string)

HelloWorld

Using zip() Function and join()

We can horizontally concatenate multiline strings by using the zip() function along with the join() method. The zip() function takes two or more iterables and returns an iterator that generates tuples containing elements from each iterable.

Syntax

result = separator.join(iterable)
result = zip(iterable1, iterable2, ...)

Example

In the below example, we split the multiline strings into individual lines and use zip() to pair corresponding lines together ?

string1 = '''Hello
This is line 1
End of string1'''

string2 = '''World
This is line 2
End of string2'''

lines1 = string1.split('\n')
lines2 = string2.split('\n')

horizontal_concatenation = '\n'.join(' | '.join(line) for line in zip(lines1, lines2))

print(horizontal_concatenation)

Hello | World
This is line 1 | This is line 2
End of string1 | End of string2

Using List Comprehension with Padding

For better formatting, we can pad strings to equal widths before concatenation. This approach handles strings with different numbers of lines by padding shorter strings with empty lines.

Example

In this example, we ensure both strings have the same number of lines and use fixed-width formatting ?

string1 = '''Line 1
Line 2'''

string2 = '''Column A
Column B
Column C'''

lines1 = string1.split('\n')
lines2 = string2.split('\n')

# Pad shorter list with empty strings
max_lines = max(len(lines1), len(lines2))
lines1.extend([''] * (max_lines - len(lines1)))
lines2.extend([''] * (max_lines - len(lines2)))

# Calculate maximum width for alignment
max_width1 = max(len(line) for line in lines1) if lines1 else 0

horizontal_concatenation = '\n'.join(
    f"{line1.ljust(max_width1)} | {line2}" 
    for line1, line2 in zip(lines1, lines2)
)

print(horizontal_concatenation)

Line 1 | Column A
Line 2 | Column B
       | Column C

Using textwrap for Complex Formatting

The textwrap module provides functions for formatting multiline strings. However, for horizontal concatenation, a custom approach works better than the standard wrap function.

Example

Here we create a function to horizontally concatenate multiple multiline strings with custom separators ?

def horizontal_concat(*strings, separator=" | ", padding=True):
    """Horizontally concatenate multiple multiline strings"""
    # Split all strings into lines
    all_lines = [s.split('\n') for s in strings]
    
    # Find maximum number of lines
    max_lines = max(len(lines) for lines in all_lines)
    
    # Pad all line lists to same length
    for lines in all_lines:
        lines.extend([''] * (max_lines - len(lines)))
    
    # Calculate max width for each string if padding is enabled
    if padding:
        max_widths = [max(len(line) for line in lines) if lines else 0 
                     for lines in all_lines]
    
    result_lines = []
    for i in range(max_lines):
        if padding:
            line_parts = [lines[i].ljust(max_widths[j]) 
                         for j, lines in enumerate(all_lines)]
        else:
            line_parts = [lines[i] for lines in all_lines]
        
        result_lines.append(separator.join(line_parts))
    
    return '\n'.join(result_lines)

# Example usage
text1 = '''Header 1
Data A
Data B'''

text2 = '''Header 2
Value X
Value Y
Value Z'''

text3 = '''Header 3
Info 1
Info 2'''

result = horizontal_concat(text1, text2, text3, separator=" | ")
print(result)

Header 1 | Header 2 | Header 3
Data A   | Value X  | Info 1  
Data B   | Value Y  | Info 2  
         | Value Z  |         

Comparison

Conclusion

Horizontal concatenation of multiline strings in Python can be achieved using various methods. Use zip() with join() for simple cases, list comprehension with padding for different line counts, and custom functions for complex formatting requirements.