UNIVERSIDAD ANDINA DEL CUSCO
FACULTAD DE INGENIERIA Y ARQUITECTURA
ESCUELAPROFESIONAL DE INGENIERIA DE SISTEMAS
Procesamiento básico de secuencias biológicas
Asignatura: Fundamentos de Bioinformática
Docente: Mgt. Ing. Harry Yeison Gonzales Condori
Integrantes:
• BACA ORCON, WILIANS ANTHONY (Participo)
• CASTRO ALENCASTRE, ADRIANA ( Participo)
• HERMOZA PFUYO, JULIO WILLIAMS (Participo)
• HUAMAN GUZMAN, GONZALO RODRIGO ( Participo)
• MONTALICO CASTRO, FRANK JOSUE (Participo)
• UBALDE JANCCO, CRISTIAN (Participo)
Cusco – Perú
2021
Desarrollo
1. """Escriba un programa que lea una secuencia de ADN, la convi
erta a letras mayúsculas y cuente cuántos nucleótidos son pur
inas y pirimidinas."""
def cont_puri_piri(sec_adn):
if validar_adn(sec_adn):
sec_adn= sec_adn.upper()
cantidad = {"Purinas":0, "Pirimidinas":0}
for cant in sec_adn:
if cant in ['A','G']:
cantidad['Purinas'] += 1
elif cant in ['C', 'T']:
cantidad['Pirimidinas'] +=1
else:
return None
return print(sec_adn,cantidad)
else: return print("Secuencia de ADN invalida")
cont_puri_piri("atagagagatatcg")
2. """Escribe un programa que lea una secuencia de ADN y verifiq
ue si es igual a su complemento inverso."""
def eje2(sec_adn):
if validar_adn(sec_adn):
sec = ""
comp = complemento_inverso(sec_adn)
for c in sec_adn.upper():
if c == "G":
sec = "C" + sec
elif c == "C":
sec = "G" + sec
elif c == "A":
sec = "T" + sec
elif c== "T":
sec = "A" + sec
if comp==sec:
return print("La secuencia es igual a su complemen
to", comp, " = ",sec)
else: return print("Secuencia de ADN invalida")
eje2("atagataactcgcatag")
3. """Escriba y pruebe una función que, dada una secuencia de AD
N, devuelva el número total de duplas "CG" que contiene."""
def eje3(sec_adn):
if validar_adn(sec_adn):
seqC = sec_adn.upper()
cg_count = 0
for s in seqC:
if s in "CG":
cg_count += 0.5
return print("La cantidad total de duplas es de: ",
cg_count)
else: return print("Secuencia de ADN invalida")
eje3("acgt")
4. """Escriba y pruebe una función de Python que, dada una secue
ncia de ADN,devuelva el tamaño de la primera proteína que pue
de ser codificada por esa secuenciaen cualquiera de los tres
marcos de lectura). La función deería devolver - si no se enc
uentra ninguna proteína."""
def proteina(secu_p):
sec_aa = secu_p
frec_aa = frecuencia(sec_aa)
list_f = sorted (frec_aa.items(), key=lambda x: x[1], reverse = T
rue)
for (k,v) in list_f:
print("Aminoacidos:", k, ":", v)
def eje4(sec_adn):
a=sec_adn
if validar_adn(a):
dic = {}
seqC = [Link]()
p = proteina(seqC)
errors = 0
for b in seqC:
if b in "CG":
if b in dic: dic[b] += 1
else : dic[b] = 1
else : errors += 1
return dic, errors
else: return print("-1")
eje4("ATGTACTCATCGTTTCGGAAGAGACAGGTACGTTAATAGTTAATAGCGTACTTCTTTTAAA
ACCTTCTTTTTACGTTTACTCTCGTGTTAAAAATCTGAATTCTTCTAGAGTTCCTGATCTTCTGGTC
TAA")
5. """Escriba y pruebe una función que, dada una
secuencia de aminoácidos, devuelva un valor lógico
que indique si la secuencia puede ser una proteína o
no"""
def validarAdn(seq_adn):
#se transforma la cadena a mayuscula y se almacena en la variable
seqm
seqm = seq_adn.upper()
#validacion es una variable de tipo int que acumula la suma de lo
s nucleotidos
validacion = [Link]("A") + [Link]("C") + [Link]("G")
+ [Link]("T")
# la suma de validacion se compara con el tamaño de la cadena ini
cial
if validacion == len(seqm):
return True
else:
return False
def translate_codon (cod):
tc = {"GCT":"A", "GCC":"A", "GCA":"A", "GCG":"A",
"TGT":"C", "TGC":"C",
"GAT":"D", "GAC":"D",
"GAA":"E", "GAG":"E",
"TTT":"F", "TTC":"F",
"GGT":"G", "GGC":"G", "GGA":"G", "GGG":"G",
"CAT":"H", "CAC":"H",
"ATA":"I", "ATT":"I", "ATC":"I",
"AAA":"K", "AAG":"K",
"TTA":"L", "TTG":"L", "CTT":"L", "CTC":"L", "CTA":"L", "CTG":"L",
"ATG":"M", "AAT":"N", "AAC":"N",
"CCT":"P", "CCC":"P", "CCA":"P", "CCG":"P",
"CAA":"Q", "CAG":"Q",
"CGT":"R", "CGC":"R", "CGA":"R", "CGG":"R", "AGA":"R", "AGG":"R",
"TCT":"S", "TCC":"S", "TCA":"S", "TCG":"S", "AGT":"S", "AGC":"S",
"ACT":"T", "ACC":"T", "ACA":"T", "ACG":"T",
"GTT":"V", "GTC":"V", "GTA":"V", "GTG":"V",
"TGG":"W",
"TAT":"Y", "TAC":"Y",
"TAA":"", "TAG":"", "TGA":"_"}
if cod in tc:
return tc[cod]
else :
return None
def translate_seq (dna_seq , ini_pos = 0):
assert validarAdn(dna_seq), "Invalid DNA sequence"
seqm = dna_seq.upper()
seq_aa = ""
for pos in range(ini_pos, len(seqm)-2,3):
cod = seqm[pos:pos+3]
seq_aa += translate_codon(cod)
return seq_aa
def primera_protina(seqAA):
validarAdn(seqAA)
adn = translate_seq(seqAA,0)
inProt = False
endProt = False
prot = ""
pos = 0
while not endProt and pos < len(adn):
if inProt:
if adn[pos]=="_": endProt = True
else: prot += adn[pos]
else:
if adn[pos]=="M":
inProt=True
prot = "M"
pos += 1
if endProt == "_":
return 0
else:
return -1
seq= input("Secuencia del aminoacido: ")
lprot = primera_protina("")
if lprot==0: print ("Si es proteina ")
else: print("No es proteina")
6. """Escriba y pruebe una función de Python que, dada una secue
ncia de ADN, crea un mapa (diccionario) con las frecuencias d
e los aminoácidos que codifica (suponiendo que la traducción
se inicie en la primera posición de la secuencia de ADN). Los
codones de parada deben ser ignorados."""
def crea_mapa(sec_adn):
if validar_adn(sec_adn):
frec_trad = {}
pos_i=0
for i in traductor_sec(sec_adn,pos_i):
if i== '_':
continue
if i in frec_trad:
frec_trad[i] +=1
else:
frec_trad[i] = 1
return frec_trad
else: return print("Secuencia de adn invalida")
secuencia = "ATGTACTCATCGTTTCGGAAGAGACAGGTACGTTAATAGTTAA
TAGCGTACTTCTTTTAAAACCTTCTTTTTACGTTTACTCTCGTGTTAAAAATCTGA
ATTCTTCTAGAGTTCCTGATCTTCTGGTCTAA"
crea_mapa(secuencia)
7. """Escriba un programa que lea una secuencia de aminoácidos y
una secuencia de ADN e imprima la lista de todas las subsecue
ncias de la secuencia de
ADN que codifican la secuencia de proteína dada. """
def subseqs(seqDNA, seqAA):
d = {"GCT":"A", "GCC":"A", "GCA":"A", "GCC":"A",
"TGT":"C", "TGC":"C",
"GAT":"D", "GAC":"D",
"GAA":"E", "GAG":"E",
"TTT":"F", "TTC":"F",
"GGT":"G", "GGC":"G", "GGA":"G", "GGG":"G",
"CAT":"H", "CAC":"H",
"ATA":"I", "ATT":"I", "ATC":"I",
"AAA":"K", "AAG":"K",
"TTA":"L", "TTG":"L", "CTT":"L", "CTC":"L", "CTA":"L", "C
TG":"L",
"ATG":"M", "AAT":"N", "AAC":"N",
"CCT":"P", "CCC":"P", "CCA":"P", "CCG":"P",
"CAA":"Q", "CAG":"Q",
"CGT":"R", "CGC":"R", "CGA":"R", "CGG":"R", "AGA":"R", "A
GG":"R",
"TCT":"S", "TCC":"S", "TCA":"S", "TCG":"S", "AGT":"S", "A
GC":"S",
"ACT":"T", "ACC":"T", "ACA":"T", "ACG":"T",
"GTT":"V", "GTC":"V", "GTA":"V", "GTG":"V",
"TGG":"W",
"TAT":"Y", "TAC":"Y",
"TAA":"", "TAG":"", "TGA":"_"
}
subseqs = []
lastpos = len(seqDNA) - len(seqAA)*3 + 1
for i in range(lastpos): # posicion inicial
prot = ""
for k in range(i, i + len(seqAA)*3, 3):
codao = seqDNA[k : k+3]
aa = d[codao]
prot += aa
if prot == seqAA:
[Link](i)
return subseqs
## main
seqAA = input("INGRESE UNA SECUENCIA DE AMINOACIDO:")
seqDNA = input("INGRESE UNA SECUENCIA DE ADN:")
subs = subseqs(seqDNA, seqAA)
if subs:
print("Subsecuencias que codifican la secuencia de aminoácidos
dianae")
for s in subs:
print(seqDNA[s:s+len(seqAA*3)])
else:
print("Ninguna subsecuencia codifica la secuencia de aminoácido
s diana")
8. """Escribe una función que, dada una secuencia como argumento
,permita detectar si hay subsecuencias repetidas de tamaño k(
el segundoargumento de la función)El resultado debe ser un di
ccionario donde las claves son subsecuencias y los valores so
n el número de veces que ocurren (al menos 2)Utilice la funci
ón en un programa que lea la
secuencia y k e imprima el resultado."""
9. """Escriba y pruebe una función que, dada una secuencia de AD
N, devuelva el número total de duplas "CG" que contiene."""
def eje9(sec_adn):
if validar_adn(sec_adn):
seqC = sec_adn.upper()
cg_count = 0
for s in seqC:
if s in "CG":
cg_count += 0.5
return print("La cantidad total de duplas es de: ",
cg_count)
else: return print("Secuencia de ADN invalida")
eje9("acgt")
Proyecto 1
Tomando como base la clase MySeq desarrollada en clase, implemente subclases para los tres
tipos distintos de secuencias biológicas: ADN, ARN y proteínas. En cada uno defina un
constructor apropiado. Redefina los métodos de la clase padre, en los casos en que crea que
esto es necesario o útil. Adapte los tipos de salidas en cada método en consecuencia.
class MySeq:
""" Class for biological sequences. """
def __init__ ( self , seq, seq_type = "DNA"):
[Link] = [Link]()
self.seq_type = seq_type
def __len__( self ):
return len ( [Link])
def __getitem__( self , n):
return [Link][n]
def __getslice__( self , i, j):
return [Link][i:j]
def __str__( self ):
return [Link]
def get_seq_biotype ( self ):
return self.seq_type
def show_info_seq ( self ):
print ("Sequence: " + [Link] + " biotype: " + self.seq_type)
def alphabet (self):
if ( self.seq_type=="DNA"):
return "ACGT"
elif ( self.seq_type=="RNA"):
return "ACGU"
elif ( self.seq_type=="PROTEIN"):
return "ACDEFGHIKLMNPQRSTVWY"
else : return None
def validate( self ):
alp = [Link]()
res = True
i=0
while i < len( [Link]) and res:
if self .seq[i] not in alp: res = False
else : i += 1
return res
def transcription( self ):
if ( self.seq_type == "DNA"):
return MySeq( [Link]("T","U"), "RNA")
else :
return None
def reverse_comp ( self ):
if ( self.seq_type != "DNA"): return None
comp = ""
for c in [Link]:
if (c == "A"): comp = "T" + comp
elif (c == "T"): comp = "A" + comp
elif (c == "G"): comp = "C" + comp
elif (c== "C"): comp = "G" + comp
return MySeq(comp, "DNA")
def translate( self , iniPos= 0):
if ( self.seq_type != "DNA"):return None
seq_aa = ""
for pos in range (iniPos, len( [Link])-2,3):
cod = [Link][pos:pos+3]
seq_aa += translate_codon(cod)
return MySeq(seq_aa, "PROTEIN")
class ADN(MySeq):
pass
class ARN(MySeq):
pass
class Proteina(MySeq):
pass
adn1 = ADN("ATGTGATAAGAATAGAATGCTGAATAAATAGAATGACAT")
print(transcription(adn1))
Proyecto 2
El paquete random incluye una serie de funciones que permiten generar números aleatorios.
Usando algunas de esas funciones, construya un módulo que implemente la generación de
secuencias de ADN aleatorias y el análisis de mutaciones sobre estas secuencias. Puede incluir
funciones para generar secuencias aleatorias de un tamaño determinado, para simular la
aparición de un número determinado de mutaciones en una secuencia de ADN en posiciones
aleatorias (incluidas inserciones, deleciones y sustituciones) y funciones para estudiar el impacto
de mutaciones en las proteínas codificadas de esas secuencias.
import random
def genADN():
DNA=['A','C','G','T']
tamaADN=len(DNA)
print(tamaADN)
for num in range(2):
ADN=[Link](DNA,k=10)
print("Primer ADN: ",ADN)
mutati=input("Desea Ingresar mutaciones?: ")
if mutati=="1":
mutaciones=int(input("Ingrese la cantidad de mutaciones:"))
for i in range(mutaciones):
nucleotidos=input("Ingrese el nucleotido: ")
[Link](nucleotidos)
print("El nuevo ADN es:",ADN)
elif mutati=="0":
boolremo=input("Desea remover un compuesto?: ")
if boolremo=="1":
remover=int(input("Ingrese la cantidad a remover: "))
for i in range(remover):
nucleoremove=input("Ingrese el nucleotido: ")
[Link](nucleoremove)
print("El nuevo ADN es:",ADN)
elif boolremo=="0":
replacesADN=input("Desea reemplazar algun compuesto: ")
if replacesADN=="1":
reemplace=int(input("Ingrese la cantidad a remover:
"))
for i in range(reemplace):
valorre=input("Ingrese que compuesto reemplaza:
")
nucleoreplace=input("Ingrese el nucleotido: ")
for n,i in enumerate(ADN):
if i==valorre:
ADN[n]= nucleoreplace
else:
print("Valor no encontrado")
print("El nuevo ADN es:",ADN)
elif replacesADN=="0":
print("El ADN es: ",ADN)
print(genADN())
