# How to Translate DNA to Protein in Python By the end of this guide you will be able to take a DNA sequence and produce its [protein sequence](/blog/guides/protein-sequence) two different ways: with a codon table you write yourself in pure Python, and with the `translate()` method from Biopython. You will also be able to translate all six reading frames, validate that a sequence is a proper coding sequence, batch-translate a FASTA file, and check that your output is correct instead of hoping it is. You need Python 3.8 or newer, a terminal, and about 20 megabytes of disk space for Biopython. Everything in this guide runs on a laptop. No cluster, no Docker, no conda environment required, although a virtual environment is good practice. Translation is one of the first real tasks most people attempt in Python for bioinformatics, and for good reason. It is short enough to finish in one sitting, but it touches almost every practical issue in sequence work: input cleaning, frame logic, biological standards, and validation. Tools built entirely in Python, from small desktop packages such as the Bioinformatics Mini Toolbox, which bundles a six-frame translation utility among its DNA and protein analysis modules [1], up through large research libraries, show how central this single operation is to the field [2]. ## The Biology You Need Before Writing Code Translation is the step of the central dogma in which the information stored in DNA becomes a protein. DNA is transcribed into RNA, and RNA is translated into protein, with each three-base codon specifying one amino acid [3]. Conceptually, you can translate DNA directly by reading the coding strand, because the codon table is usually written with DNA letters. The information flow from DNA through RNA to protein is the organizing principle behind most sequence-analysis software, including Python tools that classify the functions of DNA, RNA, and protein sequences [4]. Four facts determine whether your code is correct: 1. Codons are triplets. A sequence of 15 nucleotides contains 5 codons. 2. The standard genetic code has 64 codons. Three of them (TAA, TAG, TGA in DNA notation) signal translation to stop, leaving 61 sense codons that map to 20 amino acids. 3. Translation is frame-dependent. There are three possible frames on a strand, starting at offset 0, 1, or 2. Reading from offset 1 instead of 0 produces a completely different protein. 4. Each gene has an orientation. A gene on the minus strand must be reverse-complemented before translation. The 20 amino acids, their one-letter codes, and how many codons each receives in the standard code: | Amino acid | One-letter | Three-letter | Codons | |--|--|--|--| | Alanine | A | Ala | 4 | | Arginine | R | Arg | 6 | | Asparagine | N | Asn | 2 | | Aspartic acid | D | Asp | 2 | | Cysteine | C | Cys | 2 | | Glutamine | Q | Gln | 2 | | Glutamic acid | E | Glu | 2 | | Glycine | G | Gly | 4 | | Histidine | H | His | 2 | | Isoleucine | I | Ile | 3 | | Leucine | L | Leu | 6 | | Lysine | K | Lys | 2 | | Methionine | M | Met | 1 | | Phenylalanine | F | Phe | 2 | | Proline | P | Pro | 4 | | Serine | S | Ser | 6 | | Threonine | T | Thr | 4 | | Tryptophan | W | Trp | 1 | | Tyrosine | Y | Tyr | 2 | | Valine | V | Val | 4 | The methionine codon ATG doubles as the start codon in most contexts, and the three stop codons are usually written as the asterisk character `*` in protein output. ## Step-by-Step: Translate DNA to Protein in Python This walkthrough uses one small worked sequence throughout so you can verify every intermediate value by hand. Our example CDS is: ``` ATGAAAGGCTATTGA ``` It is 15 nucleotides, 5 codons, and translates to the peptide `MKGY` followed by a stop. ### Step 1: Set Up Your Environment Create a working directory and install Biopython: ```bash python3 --version python3 -m venv .venv source .venv/bin/activate # on Windows use .venv\Scripts\activate pip install biopython ``` Check the install: ```bash python3 -c "import Bio; print(Bio.__version__)" ``` You should see a version number of 1.80 or newer on a current install. If you get `ModuleNotFoundError: No module named 'Bio'`, the virtual environment is not active or the install failed. Rerun `pip install biopython` with the environment active. You do not strictly need Biopython for steps 2 through 4. The pure Python path is worth doing once because it forces you to understand the frame logic, and it gives you an independent implementation you can use to cross-check Biopython later. ### Step 2: Clean and Validate the Input Sequence Real sequences arrive dirty. FASTA files copied from web pages carry line breaks, spaces, occasionally line numbers, and lowercase letters. Genomic sequences can contain ambiguity codes such as `N` for an unknown base. Clean first, translate second: ```python def clean_dna(raw: str) -> str: """Uppercase, strip whitespace, and reject non-DNA characters.""" text = "".join(raw.split()).upper() allowed = set("ACGTUN") bad = sorted(set(text) - allowed) if bad: raise ValueError(f"Invalid characters in DNA sequence: {bad}") return text print(clean_dna("atg aaa\nggc tat tga ")) # ATGAAAGGCTATTGA ``` Decide deliberately what to do with ambiguity codes. `N` is legitimate input (it appears constantly in draft genomes), so it stays in the allowed set and will translate to `X`, the one-letter code for an unknown residue. Characters such as digits or `Z` almost always indicate a copy-paste error, so rejecting them with a `ValueError` is safer than silently translating. ### Step 3: Build a Codon Table in Pure Python The standard genetic code fits in one dictionary. Every entry is a three-base DNA codon mapping to a one-letter amino acid, with `*` for stop codons: ```python CODON_TABLE = { "TTT": "F", "TTC": "F", "TTA": "L", "TTG": "L", "CTT": "L", "CTC": "L", "CTA": "L", "CTG": "L", "ATT": "I", "ATC": "I", "ATA": "I", "ATG": "M", "GTT": "V", "GTC": "V", "GTA": "V", "GTG": "V", "TCT": "S", "TCC": "S", "TCA": "S", "TCG": "S", "CCT": "P", "CCC": "P", "CCA": "P", "CCG": "P", "ACT": "T", "ACC": "T", "ACA": "T", "ACG": "T", "GCT": "A", "GCC": "A", "GCA": "A", "GCG": "A", "TAT": "Y", "TAC": "Y", "TAA": "*", "TAG": "*", "CAT": "H", "CAC": "H", "CAA": "Q", "CAG": "Q", "AAT": "N", "AAC": "N", "AAA": "K", "AAG": "K", "GAT": "D", "GAC": "D", "GAA": "E", "GAG": "E", "TGT": "C", "TGC": "C", "TGA": "*", "TGG": "W", "CGT": "R", "CGC": "R", "CGA": "R", "CGG": "R", "AGT": "S", "AGC": "S", "AGA": "R", "AGG": "R", "GGT": "G", "GGC": "G", "GGA": "G", "GGG": "G", } assert len(CODON_TABLE) == 64 ``` The `assert` line is a cheap guarantee that you did not lose a codon while typing. The standard code is degenerate, meaning several codons map to the same amino acid. Leucine, serine, and arginine each get six codons, which is why synonymous mutations at those positions are so common. ### Step 4: Translate the Sequence With Your Own Function The function below walks the sequence in steps of three, looks each codon up, and handles the two decisions every translator must make: what to do with a stop codon, and what to do with trailing bases that do not form a full codon. ```python def translate_dna(dna: str, stop_at_stop: bool = True) -> str: dna = clean_dna(dna) usable_length = len(dna) - (len(dna) % 3) protein = [] for i in range(0, usable_length, 3): amino_acid = CODON_TABLE.get(dna[i:i + 3], "X") if amino_acid == "*" and stop_at_stop: break protein.append(amino_acid) return "".join(protein) seq = "ATGAAAGGCTATTGA" print(translate_dna(seq)) # MKGY print(translate_dna(seq, stop_at_stop=False)) # MKGY* print(translate_dna("ATGNNNGGCTAA")) # MXG* ``` Walk the first call by hand to confirm the logic. The sequence splits into `ATG AAA GGC TAT TGA`, which maps to M, K, G, Y, and a stop. Stopping at the stop codon gives `MKGY`. Keeping it gives `MKGY*`. Codons containing `N` have no entry in the table, and `.get(codon, "X")` returns `X` instead of raising a `KeyError`. If you use plain dictionary indexing (`CODON_TABLE[codon]`), an ambiguous codon crashes the run with `KeyError: 'NNN'`, which is one of the most common errors in homemade translators. ### Step 5: Do the Same Translation With Biopython For day-to-day work, use Biopython. Its `Seq` object wraps the sequence and its `translate()` method implements the full set of NCBI genetic code tables, ambiguous-base handling, and validation options: ```python from Bio.Seq import Seq coding_dna = Seq("ATGAAAGGCTATTGA") print(coding_dna.translate()) # MKGY* print(coding_dna.translate(to_stop=True)) # MKGY print(coding_dna.transcribe()) # AUGAAAGGCUAUUGA print(coding_dna.translate(table=1)) # MKGY* ``` You get identical protein output whether you pass DNA with `T` or RNA with `U`, because Biopython's codon tables accept both spellings. `transcribe()` produces the RNA string, which is useful when you want to show the intermediate molecule, but you do not need to transcribe before translating. The two parameters that change behavior most often: ```python # Stop at the first stop codon instead of translating through it print(coding_dna.translate(to_stop=True)) # Select a non-standard genetic code (vertebrate mitochondrial, table 2) mito = Seq("ATGTGATGA") print(mito.translate(table=1)) # M** print(mito.translate(table=2)) # MWW ``` That last example is the clearest demonstration of why genetic code choice matters. In the vertebrate mitochondrial code, TGA codes for tryptophan rather than stop, so the same 9 nucleotides yield two different proteins depending on the table. NCBI maintains a numbered collection of alternative genetic codes for mitochondria, chloroplasts, and various bacterial and ciliate systems, and Biopython exposes all of them through the `table` parameter. You can also inspect any table directly: ```python from Bio.Data import CodonTable standard = CodonTable.unambiguous_dna_by_id[1] print(standard.start_codons) # ['TTG', 'CTG', 'ATT', 'ATC', 'ATA', 'ATG', 'GTG'] print(standard.stop_codons) # ['TAA', 'TAG', 'TGA'] ``` ### Step 6: Enforce Coding-Sequence Rules With cds=True When your input is supposed to be a complete coding sequence (a CDS: start codon at position 0, stop codon at the end, no internal stops, length divisible by three), Biopython can enforce all of those rules in one call: ```python good = Seq("ATGAAAGGCTATTGA") print(good.translate(cds=True)) # MKGY bad = Seq("GGAAAAGGCTATTGA") bad.translate(cds=True) # TranslationError: First codon 'GGA' is not a start codon ``` The `cds=True` mode raises a `TranslationError` when any rule fails. The most common ones are a first codon that is not a start codon, a sequence length that is not a multiple of three, and an internal stop codon. This makes `cds=True` the cheapest validation you can add to a pipeline: it catches frame errors, truncated downloads, and wrong-strand inputs in a single call. ### Step 7: Translate All Six Reading Frames Because genes sit on both strands and in all three offsets, single-frame translation misses most coding regions in an unannotated sequence. Six-frame translation, running three offsets on the strand and three on its reverse complement, is the standard survey approach. Dedicated tools implement exactly this: the Bioinformatics Mini Toolbox translates a DNA sequence into all six open reading frames as one of its core modules [1]. ```python from Bio.Seq import Seq def six_frame_translation(dna: str, table: int = 1) -> dict: seq = Seq(dna.upper()) strands = {"+": seq, "-": seq.reverse_complement()} frames = {} for strand_name, s in strands.items(): for offset in range(3): end = len(s) - ((len(s) - offset) % 3) frames[f"{strand_name}{offset + 1}"] = s[offset:end].translate(table=table) return frames dna = "ATGAAAGGCTATTGATCA" for name, protein in six_frame_translation(dna).items(): print(name, protein) ``` Expected output: ``` +1 MKGY*S +2 *KAID +3 ERLLI -1 *SIAFH -2 DQ*PF -3 INSL-S ``` Notice what the output reveals. Frame +1 contains a start codon followed by sense codons and a stop, which is the signature of an open reading frame. The trimming expression `end = len(s) - ((len(s) - offset) % 3)` drops trailing partial codons so every frame receives a clean multiple of three. To go from raw six-frame output to candidate genes, scan each frame for segments that begin with a start codon, contain no internal stops, and end at a stop codon of reasonable length. ### Step 8: Read a FASTA File and Translate Every Record Production work almost never uses hardcoded strings. Biopython's `SeqIO` module parses FASTA files and hands you records whose `.seq` attribute translates directly: ```python from Bio import SeqIO with open("genes.fasta") as handle: for record in SeqIO.parse(handle, "fasta"): protein = record.seq.translate(to_stop=True) print(record.id, len(protein), str(protein)[:40]) ``` Typical output for a small file: ``` gene_001 148 MSTQNKSVLF... gene_002 371 MVHLSKEKGF... gene_003 0 ``` A length of zero means the first codon in the record was a stop codon, which usually means the record holds genomic sequence rather than a CDS, or the strand is flipped. Handle that case explicitly rather than writing an empty protein to your output file. ## Key Parameters and Genetic Codes at a Glance ![A short decision path leading from sequence origin to table 1, table 2 or table 11 in Biopython.](/article-images/illustrations/translate-dna-to-protein-python-genetic-code-choice.webp) | Parameter or tool | Applies to | What it does | Default | |--|--|--|--| | `table` | Biopython `translate()` | Selects the NCBI genetic code by ID. 1 is the standard code, 2 is vertebrate mitochondrial, 11 is the bacterial code | 1 | | `to_stop` | Biopython `translate()` | Truncates the protein at the first stop codon instead of writing `*` and continuing | False | | `cds` | Biopython `translate()` | Requires a valid start codon, a terminal stop codon, no internal stops, and a length divisible by three | False | | `gap` | Biopython `translate()` | Character used for codons that cannot be translated in a gapped sequence | `"-"` | | `stop_at_stop` | Custom pure Python function | Same behavior as `to_stop`, implemented manually | True | | Unknown codon fallback | Both approaches | Codons containing ambiguity codes such as `N` map to `X` | `X` | Two table IDs cover most day-to-day cases. Use table 1 for standard nuclear genes. Use table 11 for bacterial genes when you want alternative start codons such as GTG and TTG to be recognized as starts under `cds=True`. For mitochondrial sequences, pick the mitochondrial table that matches your organism. ## How to Check That Your Translation Is Correct A translation that runs without errors is not necessarily correct. Build verification into the workflow: 1. **Length check.** The protein length should equal the number of complete codons. A 15-nucleotide CDS gives 4 amino acids plus a stop. If your protein is longer or shorter, a frame or trimming bug is present. 2. **Boundary check.** A CDS should start with M (or, in bacteria with alternative start codons, an amino acid translated from a non-ATG start) and, when translated without `to_stop`, should end in `*`. 3. **Internal stop check.** Count stops with `protein.count("*")`. Any stop before the final position in a genuine CDS means the input was not a CDS or the wrong table was used. 4. **Cross-implementation check.** Compare your pure Python function against Biopython on the same input with an assertion. Two independent implementations agreeing is strong evidence both are right: ```python assert str(coding_dna.translate(to_stop=True)) == translate_dna(str(coding_dna)) ``` 5. **External check.** Paste the [nucleotide sequence](/knowledge/molecular-biology/nucleotide-sequence) into the NCBI ORFfinder web tool and compare its output against yours. Agreement with an independent reference implementation catches logic errors that two copies of your own mental model will not. 6. **Biological plausibility.** A real protein rarely contains runs of `X`, and a frame scan of a real gene typically yields one long ORF with many junk ORFs in the other five frames. At scale, translation accuracy has measurable biological consequences. The deTELpy package implements a high-throughput pipeline that detects amino acid substitutions in mass spectrometry data in order to calculate codon-specific and site-specific translation error rates across organisms and conditions [5]. Errors that are trivial in a 15-nucleotide tutorial become systematic bias when a pipeline processes hundreds of datasets, which is why the checks above belong in code rather than in your head. ## Common Mistakes and Limitations ![A path from a wrong-looking protein through stop codons, frame errors and strand orientation to a fix.](/article-images/illustrations/translate-dna-to-protein-python-translation-failure-triage.webp) These are the failures that show up again and again in real pipelines, with the exact symptom and the fix. **Translating genomic DNA when you meant a CDS.** Eukaryotic genomic sequence contains introns. Translating it produces a short fragment followed by an internal stop, which many beginners interpret as a bug in their code. The fix is input-level, not code-level: translate CDS or mRNA sequences, or extract the CDS feature from a GenBank record. When working from annotation files, extract gene features programmatically rather than by eye. Tools built for exactly this exist, such as GAD, a Python utility that splits GFF3 and GTF genome annotation files into feature-based outputs including CDS regions in formats like FASTA [6]. **Using the wrong genetic code.** The default table 1 is correct for standard nuclear genes only. Vertebrate mitochondrial sequences mis-translate under table 1 at multiple codons, including TGA, which is a stop in the standard code and tryptophan in the mitochondrial code. The symptom is a protein peppered with `*` or missing tryptophans. Always pass an explicit `table` argument in production code rather than relying on the default. **Off-by-one frame errors.** Translating from offset 1 instead of 0 yields a valid-looking protein that is biologically meaningless. There is no error message, because the translation technically succeeds. The habit that prevents this is explicit frame labeling (as in the six-frame function above, where every output is keyed to its strand and offset) and the `cds=True` validation, which fails loudly when the frame is wrong. **A naive dictionary lookup crashes on ambiguous bases.** `CODON_TABLE["NNN"]` raises `KeyError: 'NNN'`. Use `.get(codon, "X")` in your own code, or rely on Biopython, which handles ambiguity codes internally and emits `X` in the protein. **Calling `.translate()` on a plain string.** Python's built-in `str.translate()` is a character-mapping method with an unrelated purpose. Calling it with no arguments raises `TypeError: translate() takes exactly one argument (0 given)`, and calling it with a mapping table silently produces garbage rather than a protein. Convert to a `Seq` object first, or use your own function. **Keeping or dropping the stop codon inconsistently.** By default Biopython keeps `*` in the output. Downstream tools differ: some protein analysis modules reject sequences containing `*`, others expect it. Decide once, at the top of your pipeline, whether your canonical protein representation includes the terminal stop, and strip it explicitly with `.rstrip("*")` where needed. **Trailing partial codons.** A sequence whose length is not divisible by three has leftover bases. Biopython issues a warning about a partial codon and ignores the trailing bases, while a naive range-based loop may crash or silently skip the last codon. Trim explicitly, as the six-frame function does, and log the warning when it fires because a partial codon often means a truncated or mis-sliced input. **Confusing transcription with translation.** `transcribe()` changes T to U and returns RNA. It does not produce a protein. Beginning scripts sometimes chain the two calls incorrectly and then compare RNA output against an expected protein string. Translation alone is the operation that maps codons to amino acids. **Ignoring strand orientation.** For genes annotated on the minus strand, translating the stored forward sequence produces nonsense. Apply `.reverse_complement()` before translating whenever the feature location indicates the minus strand. **Expecting translation to find genes.** Translation is a deterministic codon-to-amino-acid mapping. It does not predict where genes are, which strand they occupy, or where they start. Six-frame translation shows you all possible readings [1], but separating real genes from chance ORFs requires gene prediction or annotation, which is a separate step. **Assuming protein output equals a functional protein.** A correct [amino acid sequence](/blog/guides/amino-acid-sequence) is the beginning of protein analysis, not the end. Subsequent questions such as solubility, domains, and function require additional analyses. The SubFeat ensemble classifier, for example, predicts functional classes of DNA, RNA, and protein sequences from feature subspaces, illustrating how far downstream of translation the analysis chain extends [4]. A final limitation applies to the biology rather than the code: a translated sequence is only as good as its input sequence, and individual research questions require domain expertise and, where relevant, experimental validation of any computational prediction. ## Practical Tips for Reliable Translation Workflows **Validate early with `cds=True`.** Run it as a gate at the entrance of your pipeline. A sequence that passes `cds=True` has a valid start, a terminal stop, a clean length, and no internal stops, which eliminates an entire class of silent failures downstream. **Work in objects, not strings.** Passing `Seq` objects through your pipeline keeps strand, alphabet, and ID metadata attached to the sequence. Mixing bare strings and `Seq` objects is a frequent source of the `str.translate()` trap described above. **Write the cleanup as a function with tests.** The `clean_dna` function from Step 2 is small enough to test exhaustively: lowercase input, embedded newlines, digits, ambiguity codes, empty strings. Five unit tests take ten minutes to write and permanently protect every script that imports the function. **Keep both implementations.** The pure Python translator is not throwaway code. It is your independent referee. When you upgrade Biopython, change a table, or modify frame logic, run both implementations on a test set and assert agreement. **Use the codon tables as data, not just for translation.** Biopython exposes table objects with properties like `forward_table`, `start_codons`, and `stop_codons`. Reverse lookups (which codons code for leucine?) support primer design, mutation analysis, and codon-usage calculations. For work on sequence variants and their protein-level consequences, the `hgvs` Python library parses, validates, and formats variants according to [Human Genome](/blog/guides/human-genome) Variation Society nomenclature, which keeps mutation descriptions consistent across reports and databases [7]. **Batch with care.** When translating thousands of records from a FASTA file, print a per-record summary (identifier, protein length, stop count) rather than full sequences. Anomalous lengths and unexpected stops surface immediately in a summary table and stay invisible in a wall of sequence text. **Where [synthetic biology](/blog/careers/synthetic-biology) fits.** If your translations feed construct design, note that codon-level manipulation is standard in that field. The basicsynbio package supports BASIC DNA assembly design in Python, including engineering applications such as fusion protein construction that depend on precise, in-frame translation of part sequences [8]. ## Where to Go Next With Your Protein Sequence Translation hands you a protein string. The productive next steps, all doable in the same Python environment: **Compute physicochemical properties.** Biopython's `ProteinAnalysis` class computes molecular weight, isoelectric point, aromaticity, and instability index from a protein string: ```python from Bio.SeqUtils.ProtParam import ProteinAnalysis analysis = ProteinAnalysis("MKGY") print(analysis.molecular_weight()) print(analysis.isoelectric_point()) ``` For a much broader descriptor set, PyBioMed calculates hundreds of chemical descriptors plus protein and DNA descriptors and their interactions, positioning itself as a bridge between biological sequences and data-mining pipelines [9]. Python tools aimed at practical lab use, such as ASAP, compute physicochemical and antigenic properties of protein sequences to support experiments like vaccine antigen selection [10]. **Move toward function and structure.** Once you trust your translated proteins, functional prediction tools such as SubFeat take DNA, RNA, and protein sequences as input and classify their likely functions with an ensemble of base classifiers [4]. **Connect to population-scale analysis.** If your translations feed polymorphism studies, EggLib provides a C++-accelerated Python library for sequence [data management](/blog/guides/data-management-basics-principles-processes-and-best-practices), file format conversion, and population genetic analyses on nucleotide data [11]. **Build phylogenetic context.** Translated proteins are the substrate for homology and phylogeny. The ETE framework handles the tree side of that workflow, with automated manipulation, annotation, and analysis of phylogenetic and clustering trees at survey scale [12]. **Model sequences with machine learning.** Recent work treats codon structure itself as a modeling asset. The Genomic Tokenizer embeds the codon-level logic of the central dogma, including start and stop codons, into a HuggingFace-compatible tokenizer for DNA transformer models [3]. If you move from translation scripts toward learned models of sequence, that codon-aware framing is a natural continuation of what you built here. ## Frequently Asked Questions ### Can I translate RNA instead of DNA in Python? Yes. Biopython's `translate()` accepts both DNA and RNA spellings, so `Seq("AUGAAAGGCUAUUGA").translate()` returns the same protein as the DNA version. In pure Python, either build a second table with U codons or replace U with T using `rna.replace("U", "T")` before lookup. ### How do I translate all six reading frames? Take three offsets (0, 1, 2) on the sequence and three on its reverse complement, translating each sliced segment. The `six_frame_translation` function in Step 7 does this in about ten lines and labels each result by strand and frame. ### Why does my translated protein contain asterisks? The asterisk is the standard one-letter symbol for a stop codon. Biopython keeps stop codons in the output by default. Use `translate(to_stop=True)` to truncate at the first stop, or strip terminal stops with `.rstrip("*")` if your downstream tool rejects them. ### Which genetic code table should I use? Use table 1, the standard code, for ordinary nuclear genes. Switch to a mitochondrial table for mitochondrial sequences and table 11 for bacterial genes with alternative start codons. If the origin of your sequence is uncertain, the presence of unexpected stop codons is a useful diagnostic that the wrong table is in play. ### Do I need Biopython, or is plain Python enough? Plain Python is enough for the core operation, and writing the codon table yourself is excellent for learning. For real work, use Biopython, because it implements every NCBI genetic code, validates CDS rules, parses FASTA and GenBank files, and is the de facto standard library that most Python bioinformatics packages build on. ### How do I handle ambiguous bases like N during translation? Codons containing ambiguity codes have no defined amino acid, so they translate to `X`, the one-letter code for an unknown residue. Your own dictionary should use `.get(codon, "X")` rather than direct indexing to avoid a `KeyError`. If `cds=True` is set, Biopython rejects sequences with ambiguous bases in critical positions instead of returning X. ### How do I translate a FASTA file with many sequences? Use `SeqIO.parse("genes.fasta", "fasta")` in a loop and call `record.seq.translate(to_stop=True)` on each record, as shown in Step 8. Print a per-record summary of identifier and protein length so records that fail silently, such as genomic sequence with immediate stops, stand out immediately. ### How long should the translated protein be? The protein has one residue per codon, so its length is the number of complete three-base codons in the input. A CDS of 900 nucleotides yields 299 amino acids plus the terminal stop codon. Any other length means a frame error, truncated input, or a trimming bug. ## Sources 1. [BMT: Bioinformatics mini toolbox for comprehensive DNA and protein analysis.](https://pubmed.ncbi.nlm.nih.gov/32791200/) 2. [PyElph - a software tool for gel images analysis and phylogenetics.](https://pubmed.ncbi.nlm.nih.gov/22244131/) 3. [Genomic Tokenizer: Toward a biology-driven tokenization in transformer models for DNA sequences](https://doi.org/10.1101/2025.04.02.646836) 4. [SubFeat: Feature Subspacing Ensemble Classifier for Function Prediction of DNA, RNA and Protein Sequences](https://pubmed.ncbi.nlm.nih.gov/33932779/) 5. [deTELpy: Python package for high-throughput detection of amino acid substitutions in mass spectrometry datasets](https://pubmed.ncbi.nlm.nih.gov/38941503/) 6. [GAD: A Python Script for Dividing Genome Annotation Files into Feature-Based Files.](https://pubmed.ncbi.nlm.nih.gov/32524530/) 7. [A Python package for parsing, validating, mapping and formatting sequence variants using HGVS nomenclature.](https://pubmed.ncbi.nlm.nih.gov/25273102/) 8. [basicsynbio and the BASIC SEVA collection: software and vectors for an established DNA assembly method.](https://pubmed.ncbi.nlm.nih.gov/36381610/) 9. [PyBioMed: a python library for various molecular representations of chemicals, proteins and DNAs and their interactions.](https://pubmed.ncbi.nlm.nih.gov/29556758/) 10. [Detection of Huntington’s Disease in Human DNA Sequence using Numerical Encoding Method and Machine Learning based Classifier](https://doi.org/10.35940/ijrte.d5312.118419) 11. [EggLib: processing, analysis and simulation tools for population genetics and genomics.](https://pubmed.ncbi.nlm.nih.gov/22494792/) 12. [ETE: a python Environment for Tree Exploration.](https://pubmed.ncbi.nlm.nih.gov/20070885/)