UNIVERSIDAD AUTÓNOMA DE NUEVO LEÓN

FACULTAD DE CIENCIAS FÍSICO MATEMÁTICAS

BIOINFORMÁTICA

TAREA: PRESENTACIONES PPT

(STRINGS, CONDICIONAL IF & ARCHIVOS)

CÉSAR FERNANDO VALERO HERNÁNDEZ

MATRÍCULA: 1731820 GRUPO 001 AULA 404

28/Febrero/2018
Índice

Introducción. .......................................................................................................... 1
Objetivo. ................................................................................................................ 1
Ejercicios (Strings). ............................................................................................... 1
EJERCICIO 1. .................................................................................................... 1
EJERCICIO 2. .................................................................................................... 2
EJERCICIO 3. .................................................................................................... 2
EJERCICIO 4. .................................................................................................... 3
Ejercicios (If & Archivos) ...................................................................................... 4
EJERCICIO 1. .................................................................................................... 4
EJERCICIO 2. .................................................................................................... 5
EJERCICIO 3. .................................................................................................... 6
EJERCICIO 4. .................................................................................................... 6
EJERCICIO 5. .................................................................................................... 7
Preguntas (Reporte). .............................................................................................. 8
Conclusión. ...........................................................................................................10
Introducción.

En la siguiente tarea se elaborarán ejercicios relacionados al lenguaje Python, en los

primeros ejemplos se verá cómo hacer uso de las funciones para cadenas, tales como
leer un valor, imprimirlo, contar el número de caracteres, buscar un texto coincidente,
etcétera. También se observará como emplear las funciones de comprobación,
específicamente if y for. Finalmente se manejarán los comandos y acciones básicas de
los ficheros en Python, para abrir archivos de secuencias y utilizar los conceptos ya vistos
en programas más completos.

Objetivo.

El objetivo de esta práctica es aplicar los conocimientos ya adquiridos acerca de los

conceptos básicos del lenguaje Python, para implementarlos con el uso de archivos de
secuencias, haciendo búsquedas de cadenas dentro de estas, etcétera. También con
esto logramos familiarizarnos con el lenguaje Python en la interfaz de Linux, así
aprendiendo a desarrollarnos en ambos entornos a la vez.

Ejercicios (Strings).

EJERCICIO 1.
Pida al usuario una secuencia y luego imprima su longitud.
En este programa, lo único que tenemos que hacer, es solicitar una secuencia, y después
imprimir su longitud, esto lo logramos fácilmente con la función len().
CÓDIGO FUENTE SALIDA

str = raw_input("Enter a
sequence: ")
print(f"It is {len(str)} bases
long")

1
EJERCICIO 2.
Modificar el programa para que también imprima el número de caracteres A, T, C y G
que existen en la secuencia.
En este ejemplo, modificaremos el programa del ejemplo 1, y le agregaremos un ciclo
for, donde con la función for in, se leerá la secuencia base por base y cada vez que
encuentre un valor A, T, C o G, se incrementará un contador inicializado para cada base.
CÓDIGO FUENTE SALIDA

str = raw_input("Enter a sequence: ")

print(f"It is {len(str)} bases long")
ad=0
th=0
cy=0
gu=0
for seq in str:
if seq=='A':
ad=ad+1
if seq=='T':
th=th+1
if seq=='C':
cy=cy+1
if seq=='G':
gu=gu+1
print(f"adenine: ",ad)
print(f"thymine: ",th)
print(f"cytosine: ",cy)
print(f"guanine: ",gu)

EJERCICIO 3.
Modificar el programa para permitir caracteres minúsculas y mayúsculas en la secuencia.
La única modificación que se le hará al programa en esta ocasión es el de añadir la
condición de los caracteres a, c, t y g, al bloque de if. Con esto se aceptan minúsculas.
CÓDIGO FUENTE (FOR MODIFICADO) SALIDA

for seq in str:

if seq=='A' or seq=='a':
ad=ad+1
if seq=='T' or seq=='t':
th=th+1
if seq=='C' or seq=='c':
cy=cy+1

2
EJERCICIO 4.
Modificar el programa para imprimir el número de caracteres desconocidos en la
secuencia, o sea que no pertenece a ninguna base.
La última modificación al programa será añadir una opción para que al final en la
impresión, se nos diga cuando el usuario ingrese caracteres que no coincidan con
ninguna base A, C, T o G. Para esto añadiremos un else en los if’s que ya teníamos y
una variable unknow.
CÓDIGO FUENTE (FOR MODIFICADO) SALIDA

str = input("Enter a sequence: ")

print(f"It is {len(str)} bases long")

ad=0
th=0
cy=0
gu=0
uk=0

for seq in str:

if seq=='A' or seq=='a':
ad=ad+1
else:
if seq=='T' or seq=='t':
th=th+1
else:
if seq=='C' or
seq=='c':
cy=cy+1
else:
if seq=='G' or
seq=='g':
gu=gu+1
else:
uk=uk+1

print(f"adenine: ",ad)
print(f"thymine: ",th)
print(f"cytosine: ",cy)
print(f"guanine: ",gu)
print(f"unknow: ",uk)

3
Ejercicios (If & Archivos)

EJERCICIO 1.
Obtenga una secuencia del usuario. Si hay una A en la secuencia, imprima el número de
veces que aparece en la secuencia. Haga lo mismo para T, C y G. Si no existe una base,
no imprima nada.
Este programa es bastante parecido al de la sección anterior, sólo que, en este, mediante
el ciclo if elegiremos cuando es necesario imprimir una opción de base.

CÓDIGO FUENTE Y SALIDA.

seq=raw_input("Enter a sequence: ")

contA=0
contG=0
contC=0
contT=0

for x in seq:
if x=="A":
contA=contA+1
if x=="G":
contG=contG+1
if x=="C":
contC=contC+1
if x=="T":
contT=contT+1

if contA!=0:
print("A count: ",contA)
if contC!=0:
print("C count: ",contC)
if contG!=0:
print("G count: ",contG)
if contT!=0:
print("T count: ",contT)

4
EJERCICIO 2.
Obtenga una secuencia del usuario. Si hay una A en la secuencia, imprima el número
de veces que aparece en la secuencia. Si no existe, escriba "A not found". Haga lo
mismo para T, C y G.
Se hace lo mismo que en el ejercicio anterior, se pide que el usuario ingrese una
secuencia, y en un ciclo for se registrará con un contador cuando haya una base.
Finalmente, con ciclos if, si contador==0, entonces se imprime “A not found”.

CÓDIGO FUENTE Y SALIDA.

seq=raw_input("Enter a sequence: ")
contA=0
contG=0
contC=0
contT=0

for x in seq:
if x=="A":
contA=contA+1
if x=="G":
contG=contG+1
if x=="C":
contC=contC+1
if x=="T":
contT=contT+1

if contA!=0:
print("A count: ",contA)
else:
print("A not found")
if contC!=0:
print("C count: ",contC)
else:
print("C not found")
if contG!=0:
print("G count: ",contG)
else:
print("G not found")
if contT!=0:
print("T count: ",contT)
else:
print("T not found")

5
EJERCICIO 3.
Leer el fichero /usr/coursehome/dalke/10_sequences. seq
Imprima el número de línea (comenzando con 1) y luego la línea. Recuerde utilizar rstrip
() para eliminar la nueva línea extra.
En este ejercicio, lo único que necesitaremos hacer es abrir un archive, con la función
open en modo leer. Después, en un for iteraremos diez veces, imprimiendo cada vez una
línea del archivo e incrementando el contador para el numero de línea.

CODIGO FUENTE.
infile = open("/home/cvalero/Escritorio/10_sequences.seq")
for i in [1,2,3,4,5,6,7,8,9,10]:
file=infile.readline()
print(i," ",file)
i=i+1

SALIDA.

EJERCICIO 4.
Listar las secuencias en “10_sequences.seq” que tengan el patrón CTATA. Este
programa leerá un archivo, y si una línea tiene “CTATA” se incrementará un contador.
CODIGO FUENTE.
infile=open("/home/cvalero/Escritorio/
10_sequences.seq")
for i in [1,2,3,4,5,6,7,8,9,10]:
file=infile.readline()
if "CTATA" in file:
print(i," ",file)
i=i+1

6
SALIDA.

EJERCICIO 5.
Usando el archivo sequences.seq encontrar lo siguiente:
A. ¿Cuántas secuencias hay en ese archivo? Se utiliza un ciclo for y un contador
B. ¿Cuántos tienen el patrón CTATA? Se utiliza la función de if in
C. ¿Cuántos tienen más de 1000 bases? Se utiliza un ciclo for, un contador y un if
D. ¿Cuántos tienen más del 50% de composición GC? Se cuentan las bases, y los CG
E. ¿Cuántos tienen más de 2000 bases y más del 50% de composición GC?

CODIGO FUENTE Y SALIDA.

7
Preguntas (Reporte).

1- Definir una función max() que tome como argumento dos números y devuelva el mayor
de ellos. (Es cierto que python tiene una función max() incorporada, pero hacerla
nosotros mismos es un muy buen ejercicio.

2- Definir una función max_de_tres(), que tome tres números como argumentos y
devuelva el mayor de ellos.

3- Definir una función que calcule la longitud de una lista o una cadena dada. (Es cierto
que python tiene la función len() incorporada, pero escribirla por nosotros mismos resulta
un muy buen ejercicio.

4- Escribir una función que tome un carácter y devuelva True si es una vocal, de lo
contrario devuelve False.

8
5- Escribir una funcion sum() y una función multip() que sumen y multipliquen
respectivamente todos los números de una lista. Por ejemplo: sum([1,2,3,4]) debería
devolver 10 y multip([1,2,3,4]) debería devolver 24.

6- Definir una función inversa() que calcule la inversión de una cadena. Por ejemplo la
cadena "estoy probando" debería devolver la cadena "odnaborp yotse"

7 - Definir una función es_palindromo() que reconoce palíndromos (es decir, palabras
que tienen el mismo aspecto escritas invertidas), ejemplo: es_palindromo ("radar")
tendría que devolver True.

8- Definir una función superposicion() que tome dos listas y devuelva True si tienen al
menos 1 miembro en común o devuelva False de lo contrario. Escribir la función usando
el bucle for anidado.

9
9- Definir una función generar_n_caracteres() que tome un entero n y devuelva el
caracter multiplicado por n. Por ejemplo: generar_n_caracteres(5, "x") debería devolver
"xxxxx".

10- Definir un histograma procedimiento () que tome una lista de números enteros e
imprima un histograma en la pantalla. Ejemplo: procedimiento ([4, 9, 7]) debería imprimir
lo siguiente:

Conclusión.

En conclusión, los objetivos principales se lograron, pude implementar los conocimientos

vistos en las presentaciones acerca del lenguaje Python para estructurar los ejemplos
con secuencias, y las preguntas del reporte. Con esto logré también familiarizarme con
la sintaxis de Python, Linux, y como trabajar con la consola de este último para ejecutar
los programas fácilmente.

10