Just to mention, the following bash code does the same and is likely also faster.

cat *.fasta | grep -ve '^>' | tr '[:lower:]' '[:upper:]'

This is good practice if you're learning to code, and fasta manipulations are more tricky than they first appear.

We would be remiss as a professional bioinformatics community if we didn't also suggest a more robust alternative to this however, so consider familiarising yourself with biopython.

It's dedicated sequence input and output methods will handle a lot of the common pitfalls.

An equivalent script would be:

import sys

from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord


def concatenate(paths, name="concatenated"):
    seq = "".join(
        str(record.seq).upper()
        for path in paths
        for record in SeqIO.parse(path, "fasta")
    )
    return SeqRecord(Seq(seq), id=name, description=f"{len(paths)} files, {len(seq)} bp")


SeqIO.write(concatenate(sys.argv[1:]), sys.stdout, "fasta")

Which you would run like so: python concat_fasta.py ./*.fasta > combined.fasta

You can put in all of the extension checking logic back in if you want, but this can be handled now by just giving the extension of the file on the command line (./*.fasta etc).

It's important also to note that file extensions are just conventions and don't actually control what the file _is_. An advantage of using BioPython is that it will make sure all of the files really are formatted as fasta, irrespective of what the extension claims it to be.

You caught five of the six. The one you missed: extensions = ('.fasta') is a string, not a tuple - without a trailing comma the parentheses are just grouping, so looping over it gives you '.', 'f', 'a' and so on. Either write ('.fasta',) or drop the whole thing, since glob does that job:

from pathlib import Path

def concat_fasta(directory):
    chunks = []
    for path in sorted(Path(directory).glob("*.fasta")):
        with open(path) as f:
            for line in f:
                line = line.strip()
                if line and not line.startswith(">"):
                    chunks.append(line)
    return "".join(chunks).upper()

print(concat_fasta(input("Enter the directory: ")))

Collecting into a list and joining at the end rather than sequence += line in the loop stops it going quadratic once the files get big. And if your data might use .fa or .fna, glob for those too - glob is also case sensitive, so .FASTA wouldn't match.

Another option, if you're interested in a higher-level interface for sequence handling, is Sugar, a Python package I'm developing.

For example, the task above could be expressed as:

from sugar import read

seqs = read("*.fasta")
seqs.str.upper()
seqs.merge(keys=None)
seqs.write("concat.fasta")

The goal of Sugar is to make common sequence and annotation operations concise and to handle the underlying bioinformatics file formats for you.

You can install it with:

pip install rnajena-sugar

I'd be interested to hear what you think.