ADN y ARN

El problema

El ADN está formado por cuatro bases nitrogenadas:

• 🧬 Adenina (A)
• 🧬 Timina (T)
• 🧬 Citosina (C)
• 🧬 Guanina (G)

Cada base se empareja siempre con su complementaria:

• A ↔ T
• C ↔ G

Escribe una función complemento_adn(secuencia) que reciba una cadena de ADN y devuelva su secuencia complementaria.

Restricción: resuelve el reto sin usar Biopython. Al final veremos cómo hacerlo en una línea con Bio.Seq.

Ejemplos

Código inicial

def complemento_adn(secuencia):
    # Tu código aquí
    pass


print(complemento_adn("ATGGCCATTGTAATGGGC"))  # TACCGGTAACATTACCCG
print(complemento_adn("ATCG"))                # TAGC
print(complemento_adn("AAAA"))                # TTTT

Concepto clave: pares de bases

El complemento de una secuencia de ADN se obtiene sustituyendo cada base por su pareja:

# A se empareja con T, y C con G
"ATCG" → "TAGC"

Una forma sencilla de modelar esto en Python es con un diccionario de traducción:

pares = {"A": "T", "T": "A", "C": "G", "G": "C"}
print(pares["A"])  # T

def complemento_adn(secuencia):
  pares = {"A": "T", "T": "A", "C": "G", "G": "C"}
  return "".join(pares[base] for base in secuencia)


print(complemento_adn("ATGGCCATTGTAATGGGC"))  # TACCGGTAACATTACCCG
print(complemento_adn("ATCG"))                # TAGC
print(complemento_adn("AAAA"))                # TTTT
print(complemento_adn("CGCG"))                # GCGC
print(complemento_adn(""))                    # ""

Versión con str.maketrans()

Si prefieres evitar el bucle explícito, Python ofrece una traducción de cadenas muy eficiente:

def complemento_adn(secuencia):
    tabla = str.maketrans({"A": "T", "T": "A", "C": "G", "G": "C"})
    return secuencia.translate(tabla)


print(complemento_adn("ATGGCCATTGTAATGGGC"))
# TACCGGTAACATTACCCG

str.maketrans() crea una tabla de traducción y translate() la aplica a toda la cadena en una sola pasada. Es rápida y legible.

Variante: transcribir ADN a ARN

Durante la transcripción, el ADN se copia a ARN. El proceso es casi igual que el complemento, pero la Timina (T) se sustituye por Uracilo (U) en lugar de por Adenina:

def adn_a_arn(secuencia):
    pares = {"A": "U", "T": "A", "C": "G", "G": "C"}
    return "".join(pares[base] for base in secuencia)


print(adn_a_arn("ATGGCCATTGTAATGGGC"))
# AUGGCCAUUGUAAUGGGC

La forma profesional con Biopython

En proyectos reales de bioinformática se usa el paquete Biopython, que ya trae todo esto resuelto:

from Bio.Seq import Seq

adn = Seq("ATGGCCATTGTAATGGGC")
print(f"ADN: {adn}")
# ADN: ATGGCCATTGTAATGGGC

print(f"Complementaria: {adn.complement()}")
# Complementaria: TACCGGTAACATTACCCG

arn = adn.transcribe()
print(f"ARN: {arn}")
# ARN: AUGGCCAUUGUAAUGGGC

proteina = arn.translate()
print(f"Proteína: {proteina}")
# Proteína: MAIVMG

Biopython no solo calcula complementos: también transcribe, traduce a proteínas, lee archivos de secuencias y trabaja con múltiples formates bioinformáticos.

Próximos pasos

• Añade validación: lanza un error si la secuencia contiene caracteres que no sean A, T, C o G.
• Implementa es_cadena_adn(secuencia) que devuelva True solo si todos los caracteres son bases válidas.
• Calcula el porcentaje de GC de una secuencia: (G + C) / longitud_total * 100.
• Investiga cómo Biopython traduce una secuencia de ARN a proteínas con translate().