Introduction

Concatenating text files in Python usually means reading multiple input files and writing their contents into one output file in order. The best approach depends on whether you care about memory usage, newline handling, encodings, and whether the files are plain text or structured data such as CSV.

The Straightforward Text Approach

For ordinary text files, a simple loop with open() is usually enough:

1from pathlib import Path
2
3inputs = [Path("part1.txt"), Path("part2.txt"), Path("part3.txt")]
4output = Path("combined.txt")
5
6with output.open("w", encoding="utf-8") as dest:
7    for path in inputs:
8        with path.open("r", encoding="utf-8") as src:
9            for line in src:
10                dest.write(line)

This is a good default because it:

• streams line by line instead of reading everything into memory
• makes the ordering explicit
• keeps encoding under your control

For most text-processing tasks, this is better than building one giant string with repeated + operations.

Concatenating Whole Files at Once

If the files are small and you value brevity over streaming, you can read each file completely:

1from pathlib import Path
2
3inputs = [Path("a.txt"), Path("b.txt")]
4
5with Path("merged.txt").open("w", encoding="utf-8") as dest:
6    for path in inputs:
7        dest.write(path.read_text(encoding="utf-8"))

This is readable, but it loads each entire file content into memory. That is usually fine for small config files or notes, but less appropriate for logs or large exports.

Copying More Efficiently

If you do not need to inspect lines and just want to copy text efficiently, shutil.copyfileobj() is a nice fit:

1from pathlib import Path
2import shutil
3
4inputs = [Path("one.txt"), Path("two.txt"), Path("three.txt")]
5
6with Path("all.txt").open("w", encoding="utf-8") as dest:
7    for path in inputs:
8        with path.open("r", encoding="utf-8") as src:
9            shutil.copyfileobj(src, dest)

This keeps the code focused on file-to-file transfer instead of manual line handling.

Be Careful with Newlines

The biggest real-world problem is not concatenation itself. It is boundary formatting.

Suppose part1.txt does not end with a newline, while part2.txt begins immediately with text. A naive concatenation produces:

last line of part1first line of part2

If you need a separator, add one deliberately:

1from pathlib import Path
2
3inputs = [Path("part1.txt"), Path("part2.txt")]
4
5with Path("combined.txt").open("w", encoding="utf-8") as dest:
6    for index, path in enumerate(inputs):
7        if index > 0:
8            dest.write("\n")
9        dest.write(path.read_text(encoding="utf-8"))

The right separator depends on the data. For log files, you may want exactly one newline. For prose documents, you might want two. For machine-readable formats, you should preserve the format rules rather than insert arbitrary blank lines.

Concatenating CSV Is a Different Problem

If the files are CSV, JSON Lines, or another structured format, simple text concatenation may be wrong. CSV files often repeat headers, and concatenating them verbatim usually leaves duplicate header rows in the middle of the result.

For CSV, use the csv module or a table library:

1import csv
2from pathlib import Path
3
4inputs = [Path("jan.csv"), Path("feb.csv")]
5
6with Path("all.csv").open("w", newline="", encoding="utf-8") as dest:
7    writer = None
8
9    for path in inputs:
10        with path.open("r", newline="", encoding="utf-8") as src:
11            reader = csv.DictReader(src)
12            if writer is None:
13                writer = csv.DictWriter(dest, fieldnames=reader.fieldnames)
14                writer.writeheader()
15            writer.writerows(reader)

That is not just concatenation. It is format-aware merging, which is usually what you really need for structured text.

Building a Reusable Function

If you do this often, wrap the logic in a small helper:

1from pathlib import Path
2
3def concatenate_text_files(inputs, output, separator=""):
4    with Path(output).open("w", encoding="utf-8") as dest:
5        for index, item in enumerate(inputs):
6            with Path(item).open("r", encoding="utf-8") as src:
7                if index > 0 and separator:
8                    dest.write(separator)
9                for line in src:
10                    dest.write(line)
11
12
13concatenate_text_files(
14    ["chapter1.txt", "chapter2.txt"],
15    "book.txt",
16    separator="\n",
17)

This keeps the call site short while still making separator behavior explicit.

Common Pitfalls

One common mistake is forgetting to specify encoding. If the input files are not all compatible with the default encoding on the current machine, you can get decoding errors or silently corrupted characters.

Another issue is reading every file into memory even when the files are large. Streaming line by line is safer and almost as simple.

Developers also often concatenate structured files as plain text. That may be acceptable for log chunks, but it is wrong for formats that contain headers or delimiters with semantic meaning.

Finally, be intentional about newlines. Concatenation bugs often show up at file boundaries, not inside the files themselves.

Summary

• For plain text, the simplest robust solution is to stream each input file into one output file.
• Use encoding="utf-8" or another explicit encoding instead of relying on platform defaults.
• Read whole files only when they are small and memory is not a concern.
• Add separators deliberately if file-boundary newlines matter.
• For CSV or other structured text formats, use format-aware parsing instead of raw concatenation.