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.

Method 1: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

Here, "+" operator is used for addition in Python. It can be used to add numbers together or concatenate (join) strings. When used with numeric operands, it performs addition and returns the sum. 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. To achieve horizontal concatenation, we need to consider the line-wise concatenation of the strings.

string1 = "Hello"
string2 = "World"

concatenated_string = string1 + string2

print(concatenated_string)

Output

HelloWorld

Method 2:Using the 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. We can utilize this functionality to iterate over corresponding lines of the multiline strings.

Syntax

result = separator.join(iterable)

Here, the join() function is called on a string separator and takes an iterable (such as a list or tuple) as input. It concatenates the elements of the iterable, using the separator string between each element, and returns the resulting string.

Syntax

result = zip(iterable1, iterable2, ...)

Here, the zip() function is used to combine multiple iterables (such as lists or tuples) into a single iterable of tuples. Each tuple contains the corresponding elements from the input iterables, and the resulting iterable can be used, for example, in a loop to process the combined elements from multiple sequences simultaneously.

Example

In the below example, we first split the multiline strings string1 and string2 into individual lines using the split('\n') method. The split('\n') method splits the string at each newline character (\n) and returns a list of lines. Then we use the zip() function to iterate over the corresponding lines of string1 and string2. The zip() function pairs up the lines from each string and creates tuples with the corresponding lines. Then, we utilize a list comprehension to join each pair of lines with a space character using the join() method. This results in a list of horizontally concatenated lines. Finally, we join the lines back together using the '\n'.join() method, which adds a newline character (\n) between each line, creating the horizontally concatenated multiline string.

string1 = '''Hello
This is a multiline string
With multiple lines'''

string2 = '''World
In Python
Concatenation'''

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

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

print(horizontal_concatenation)

Output

Hello World
This is a multiline string In Python
With multiple lines Concatenation

Method 3:Using textwrap Module

The textwrap module provides various functions for formatting and manipulating multiline strings. To horizontally concatenate multiline strings using the textwrap module, we can make use of the wrap() function and then join the wrapped lines.

Syntax

textwrap.wrap(text, width, **kwargs)

Here,the textwrap.wrap() method takes a text string and width as input parameters, and returns a list of strings where each string represents a line of text wrapped to the specified width. Additional optional keyword arguments can be provided to control other aspects of the wrapping process.

Example

In the above example, we first import the textwrap module, which provides the necessary functions for wrapping and formatting multiline strings. Next, we use the textwrap.wrap() function to wrap the lines of string1 and string2 into a list of wrapped lines. The textwrap.wrap() function ensures that each line does not exceed a specified width. Then, we determine the maximum number of lines between the two wrapped lists using max(len(wrapped_lines1), len(wrapped_lines2)). Finally, we join the corresponding wrapped lines from wrapped_lines1 and wrapped_lines2, aligning each line using the ljust() method to ensure they have the same length. We add a space character between each pair of lines and join them with a newline character using the '\n'.join() method.

import textwrap

string1 = '''Hello
This is a multiline string
With multiple lines'''

string2 = '''World
In Python
Concatenation'''

wrapped_lines1 = textwrap.wrap(string1)
wrapped_lines2 = textwrap.wrap(string2)

max_lines = max(len(wrapped_lines1), len(wrapped_lines2))

horizontal_concatenation = '\n'.join(
    wrapped_lines1[i].ljust(len(max(wrapped_lines1, key=len)))
    + ' '
    + wrapped_lines2[i].ljust(len(max(wrapped_lines2, key=len)))
    for i in range(max_lines)
)

print(horizontal_concatenation)

Output

Hello This is a multiline string With multiple lines World In Python Concatenation                   

Conclusion

In this article, we discussed how we can concatenate multiline strings horizontally using different methods in Python. We explored two different approaches to perform horizontal concatenation: using the zip() function and the join() method, and utilizing the textwrap module. These techniques provide effective ways to concatenate multiline strings horizontally, allowing you to manipulate and format your string data in an effective manner.