Variables, operadores y tipos

de datos en Python
Variables
• Las variables son entidades que nos permiten referirnos a un valor con un
nombre.
• Pueden cambiar su contenido durante la ejecución de un programa.
• En Python, se declara una variable y se le asigna un valor mediante el
operador de asignación =.
• Este operador es diferente de ==, que se usa para una comparación entre
dos variables, probando su igualdad.
• La variable está en el lado izquierdo del operador y el valor asignado se
encuentra en el lado derecho. Por ejemplo:
Reglas para nombrar variables
• El nombre de la variable debe de estar compuesto por MAYÚSCULAS,
minúsculas, dígitos, y el carácter _ (guion bajo)
• El nombre de la variable debe comenzar con una letra;
• El carácter_ (guion bajo) es considerado una letra;
• Las mayúsculas y minúsculas se tratan de forma distinta (Alicia y ALICIA son
el mismo nombre, pero en Python son dos variables diferentes);
• El nombre de las variables no puede ser igual a alguna de las palabras
reservadas (predefinidas) de Python:
• False', 'None', 'True', 'and' 'as', 'assert', 'break',
'class', 'continue', 'def', 'del', 'elif', 'else',
'except', 'finally', 'for', 'from', 'global', 'if',
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or'
'pass', 'raise', 'return', 'try', 'while', 'with',
'yield'
La función print()

• La anterior línea consta de las siguientes partes:

• La palabra print;
• Un paréntesis de apertura;
• Una comilla;
• Una línea de texto: ¡Hola, Mundo!;
• Otra comilla;
• Un paréntesis de cierre.
• Cada uno de los elementos anteriores juega un papel muy importante en el código.
• La palabra print es el nombre de una función.
• Una función contiene código que siempre devuelve un valor (o valores).
• El nombre de la función junto con los paréntesis y el/los argumento/s, forman la invocación de la función.
• Los argumentos se utilizan para pasar datos a la función para que pueda realizar su tarea.
Operadores
• Los operadores son símbolos que le indican al intérprete que realice
una operación específica, como aritmética, comparación, lógica,
etc.
• Operadores aritméticos
• Operadores de asignación
• Operadores de comparación
Operadores Aritméticos
• Los siguientes operadores
aritméticos se pueden aplicar a
dos variables numéricas:
Operador Símbolo
Suma +
Resta -
Multiplicación *
División /
División entera //
Exponencial **
Módulo %
Orden de las operaciones
• Python respeta el orden de las operaciones en matemáticas.
• El orden de las operaciones determina que las expresiones se deben evaluar en el siguiente
orden:
1. Paréntesis
2. Exponentes
3. Multiplicación y división
4. Suma y resta
• Usar paréntesis le permite asegurarse de que el código se ejecute de una manera predecible y el
código resulta más fácil de leer y mantener:
Operadores de asignación
• Los operadores de asignación nos permiten realizar una operación y
almacenar su resultado en la variable inicial.

Operador Expresión Equivalente

+= a += 5 a=a+5
-= a -= 5 a=a-5
*= a *= 3 a=a*3
/= a /= 3 a=a/3
%= a %= 3 a=a%3
**= a **= 3 a = a ** 3
Operadores de comparación
• Requieren dos variables y devuelven un
resultado booleano:
Operador Símbolo
Menor que <
Mayor que >
Igual a ==
Menor o igual que <=
Mayor o igual que >=
No igual a !=

• Para probar si un valor forma parte de un elemento en un

contenedor, el operador in se puede utilizar de la
siguiente manera: valor in contenedor, mientras que la
ausencia se puede probar como: valor not in contenedor.
is e is not
• Comparan la identidad de dos objetos (su
dirección de memoria). Todo en Python es un
objeto y cada objeto se almacena en una
ubicación de memoria específica.
• Estos operadores verifican si dos variables se
refieren al mismo objeto en la memoria.
• Puede utilizar id() para comprobar la identidad
de un objeto
• La mayoría de las veces, diferentes objetos
con el mismo valor se almacenarán en
direcciones de memoria separadas.
• Python interna objetos con valores de uso
común (por ejemplo, los números enteros -5 a
256) para ahorrar memoria.
• No se debe usar el operador is para
comparar valores.
Calculando el Índice de Masa Corporal
Calcular en Python el índice de masa corporal para una persona con un
peso de 65.7 kg y una altura de 1.75 m

Respuesta = 21.45
Tipos de datos
Numéricos:
• Python crea enteros a partir de un tipo de datos integrado llamado int y
de decimales (números de punto flotante) como instancias de float.
• La función integrada type() de Python devuelve el tipo de datos de una
variable. El código siguiente da como resultado tipos de datos:
Tipos de datos
Booleanos:
• Otro tipo de datos habitual es el tipo booleano, que contiene el
valor True o False, y son un caso particular del tipo entero,
correspondiendo a 1 (verdadero) y 0 (falso).
Tipos de datos
Cadenas:
• Las cadenas son secuencias de caracteres, que se pueden definir
mediante texto encerrado entre los caracteres " " (comillas dobles)
o ' ' (comillas simples).
Tipos de datos

El comportamiento del código depende de los tipos de

datos con los que esté trabajando
Conversión

• No podemos sumar cadenas y enteros/flotantes

• Convertir explícitamente los tipos de variables
Conversión
• str() es una función que toma un argumento (cuyo tipo es un
número) y devuelve un valor (cuyo tipo es una cadena) que
representa ese número.
• Funciones como int(), float() y bool() nos ayudarán a convertir los
valores de Python en cualquier tipo.
¿Cuál arrojará un error?
¿Cuál arrojará un error?
Interacción con el usuario
• Un programa que se ejecuta de
forma diferente en función de la
entrada.
• Normalmente, quien introduce
datos en un programa es un
usuario, pero también puede ser • La función input() se invoca con
otro programa. un argumento: es una cadena
que contiene un mensaje;
• Para leer una entrada hecha • El mensaje se mostrará en la
desde el teclado, Python consola antes de que el usuario
proporciona la función input(). tenga la oportunidad de ingresar
algo;
• input() lee lo que el usuario
escribe en el teclado y lo • input() entonces hará su trabajo.
devuelve como una cadena.
Lectura de números como entrada
• La función input siempre devuelve el
valor escrito como una cadena
(texto):
• Para convertir el valor en una
variable de entero verdadera, se
puede usar la función int():
• Se puede usar la función float() de
igual forma, cuando se espera un
componente fraccional:
Manipulación de cadenas
Impresión de un mensaje en pantalla
• Cadena = fragmento de texto = cadena de caracteres.
• En Python las cadenas siempre están entre comillas “texto”.
• Podemos usar comillas simples o dobles para las cadenas
Comentarios
• Importantes para asegurarnos de que yo y los demás puedan
entender de qué se trata nuestro código.
• Para incluir un comentario en nuestro código fuente debemos
comenzar la línea con un símbolo de #:
Mensajes de error y depuración
• Olvidando comillas

• SyntaxError: significa que Python no puede entender el código; de alguna manera infringe las reglas (en este caso, la
regla de que las cadenas deben estar entre comillas).

• Nombre de función mal escrito

• NameError: El mensaje de error nos dice qué palabra no entiende Python, por lo que en este caso es bastante fácil de
solucionar.
Impresión de caracteres especiales
Herramientas para manipular cadenas
• Concatenación

• también podemos usar variables que apunten a cadenas:

Herramientas para manipular cadenas
• Encontrar la longitud
de una cadena

• Función len(): para

calcular la longitud de
una cadena
Herramientas para manipular cadenas
• Cambiar entre mayúsculas y minúsculas
• Podemos convertir una cadena a minúsculas usando un nuevo tipo de
sintaxis: un método que pertenece a las cadenas.
• lower(), que pertenece al tipo cadena (solo podemos usarlo en tipos de datos
que son cadenas)

• Devuelve una copia de la variable en minúsculas.

• upper(), convierte una cadena a mayúsculas.
Herramientas para manipular cadenas
• Reemplazo
• replace(), método que pertenece al tipo cadena, toma dos argumentos (ambas
cadenas) y devuelve una copia de la variable donde todas las apariciones de la
primera cadena se reemplazan por la segunda cadena.
Herramientas para manipular cadenas
• Extraer parte de una cadena
• Para obtener una subcadena, seguimos el nombre de la variable con un par de
corchetes que encierran una posición inicial y final, separados por dos puntos.
v l s p a d k t n v
0 1 2 3 4 5 6 7 8 9
Herramientas para manipular cadenas
• Contar subcadenas
• count(), toma un solo argumento cuyo tipo es una cadena y devuelve el
número de veces que el argumento se encuentra en la variable.
Herramientas para manipular cadenas
• Encontrar subcadenas
• find(), toma un único argumento de cadena y devuelve un número que es la
posición en la que esa subcadena aparece por primera vez en la cadena
EJERCICIO
Desempalme de intrones

Aquí hay una secuencia corta de ADN genómico:

ATCGATCGATCGATCGACTGACTAGTCATAGCTATGCATGTAGCTACTCGATCGATCGATCGATCGATCGATCGAT
CGATCGATCATGCTATCATCGATCGATATCGATGCATCGACTACTAT
Se compone de dos exones y un intrón. El primer exón va desde el inicio de la secuencia hasta la
base número 63, y el segundo exón va desde la base número 91 hasta el final de la secuencia .
1. Escriba un programa que imprima solo las regiones codificantes de la secuencia de ADN.
2. Usando los datos de la primera parte, escriba un programa que calcule qué porcentaje de la
secuencia de ADN está codificado.
3. Usando los datos de la primera parte, escriba un programa que imprima la secuencia de ADN
genómico original con las bases codificantes en mayúsculas y las bases no codificantes en
minúsculas.
Tarea
• Realizar los ejercicios de la página 36-38 del libro de Jones, M. (2013)
Python for Biologist.
• Nombre de archivo: apellido_manipulación_de_cadenas.html
• Subir al aula virtual en formato HTML.
Manipulación de Archivos
Archivos de texto
• Ejemplos de archivos de texto:
• FASTA de secuencias de ADN o proteínas
• Archivos con resultados de programas de línea de comandos (BLAST)
• FASTQ con lecturas de secuenciación masiva de ADN
• Archivos HTML
• Código de Python
• Abrir un archivo: función open()
• Devuelve un objeto de archivo
• Leer el contenido: método read()
Archivos, contenidos y nombres de archivo

• my_file_name: es una cadena y almacena el nombre de un archivo en el disco.

• my_file: es un objeto de archivo y representa el archivo en sí.
• my_file_contents: es una cadena y almacena el texto que está en el archivo.
Ejercicio
• Escribir un programa simple para leer la secuencia de ADN de un archivo e
imprimirlo junto con su longitud.

• Método rstrip(): toma argumento de cadena, que es el carácter a eliminar.

Archivos perdidos

• Nombre de archivo incorrecto.

• Carpeta incorrecta.
• No existe el archivo.
Escribir texto en archivos

• Versión de dos argumentos de la función open(), donde el segundo

argumento es una cadena corta que describe lo que queremos hacer
con el archivo:
• "r" para leer (predeterminado).
• "w“ para escribir (sobrescribir).
• "a“ para agregar (agregar nuevos datos).
• Método write() de archivo para escribir texto en él.
Cierre de expedientes
• Debemos llamar al método close() después de que hayamos
terminado de leer o escribir en un archivo.
• Evita algunos tipos de errores que pueden ser difíciles de rastrear.
• El método close() es inusual ya que no toma argumentos y no
devuelve ningún valor útil.
Rutas y Carpetas

• Windows:

• Mac o Linux:
Ejercicio
• Dividiendo el ADN genómico
Utilice el archivo llamado genomic_dna.txt (que contiene la misma
secuencia de ADN genómico que usamos en el ejercicio final del
módulo anterior). Escriba un programa que divida el ADN genómico en
partes, una codificantes y otra no codificantes, y escriba estas
secuencias en dos archivos separados.
Tarea
• Realizar los ejercicios de la página 65-66 del libro de Jones, M. (2013)
Python for Biologist.
• Nombre de archivo: apellido_manipulación_de_archivos.html
• Subir al aula virtual en formato HTML.
Listas, Tuplas y Bucles
¿Por qué necesitamos listas y bucles?
• Una situación muy común en la investigación biológica es tener una gran
colección de datos (secuencias de ADN, posiciones de SNP, medidas de expresión
génica) que deben procesarse de la misma manera.
• Limitación: para almacenar múltiples bits de información (por ejemplo, varias
secuencias de ADN), simplemente hemos creado más variables para
almacenarlos:

• Solución: Lista, permite contener y procesar múltiples piezas de datos al mismo

tiempo.
¿Por qué necesitamos listas y bucles?
• También hemos tratado exclusivamente con programas cuyas declaraciones se
ejecutan de arriba a abajo de una manera muy sencilla.
• Ventaja: hace que sea muy fácil seguir el flujo de un programa.
• Desventaja: conduce a un código muy redundante (la misma declaración que se
ejecuta varias veces).

• Solución: Bucle, que es una estructura de control que repite un bloque de

instrucciones.
Creación de listas y recuperación de elementos
• Nueva lista:

elemento

• Obtener un solo elemento de la lista:

nombre de la variable índice del elemento

Creación de listas y recuperación de elementos
• Si sabemos qué elemento queremos pero no sabemos el índice, podemos usar el
método index():

• Contar desde el final de la lista:

• Obtener más de un elemento de una lista:

Trabajar con elementos de lista
• Para agregar otro elemento al final de una lista existente, podemos
usar el método append():

• Obtener la longitud de una lista usando la función len()

Trabajar con elementos de lista
• Concatenar dos listas usando el símbolo +

• Métodos reverse() y sort(): Cambian el orden de los elementos en la lista.

Escribiendo un bucle
• Homo sapiens es un simio, Pan troglodytes es un simio, Gorila gorila
es un simio.

• Para cada elemento (ape) de la lista de simios (apes), imprima el

elemento (ape), seguido de las palabras "es un simio".
Escribiendo un bucle
nombre de variable
nombre de la lista que queremos procesar

cuerpo del ciclo

las líneas dentro del cuerpo del ciclo
sangría se ejecutarán una vez para cada
elemento de la lista.
Usando una cadena como una lista
• Podemos usar la notación de índice de lista para obtener carácteres individuales
o subcadenas desde el interior de una cadena.
• ¿Podemos usar también la notación de bucle para procesar una cadena como si
fuera una lista?

• El proceso de repetir un conjunto de instrucciones para cada elemento de una

lista (o carácter en una cadena) se denomina iteración y, a menudo, hablamos
de iterar sobre una lista o cadena.
Dividir una cadena para hacer una lista
• Método split() funciona con cadenas: toma un solo argumento,
llamado delimitador, y divide la cadena original donde quiera que
encuentre el delimitador, produciendo una lista.
Iterando sobre líneas en un archivo
• Cuando tratamos una cadena como una lista, cada carácter se
convierte en un elemento individual, pero cuando tratamos un
archivo como una lista, cada línea se convierte en un elemento
individual:
Bucles con rangos
• En la siguiente secuencia de proteína:
protein = "vlspadktnv"
• Queremos imprimir los primeros tres residuos, luego los primeros
cuatro residuos, etc.:

• Necesitamos un ciclo para hacer esto, pero ¿sobre qué vamos a

iterar?
Bucles con rangos
• Podemos ensamblar manualmente una lista de posiciones de parada
e iterar sobre eso:

• Resulta engorroso y sólo funciona si conocemos de antemano la

longitud de la secuencia de la proteína.
Bucles con rangos
• Función range(): Es una función integrada de Python que genera una lista de
números.
Bucles con rangos
• ¿Cómo aplicaríamos rangos en el ejemplo de la proteína?
Tuplas
• Estructura de datos integrada que forma parte del núcleo de Python.
• Se parecen mucho a las listas:
• podemos recuperar un solo elemento usando corchetes
• podemos iterar sobre los elementos de una tupla.
• Diferencia aparente: la definimos usando paréntesis en lugar de
corchetes
Tuplas
• Tratemos de cambiar uno de los elementos:

• Una tupla no se puede cambiar una vez que se ha creado.

• Tampoco podemos agregar o eliminar elementos, invertir u ordenar los
elementos, o realizar cualquier otra operación que cambie la tupla.
• Las tuplas son inmutables.
EJERCICIO
• El archivo genomic_dna.txt contiene una sección de ADN genómico y el
archivo [Link] contiene una lista de las posiciones de inicio/finalización
de los exones. Cada exón está en una línea separada y las posiciones inicial
y final están separadas por una coma. Las posiciones de inicio y fin siguen
las convenciones de Python; parten de cero y son inclusivos al principio y
exclusivos al final. Escriba un programa que extraiga los segmentos de
exón, los concatene y los escriba en un archivo nuevo.
• Este ejercicio consta de varias partes, su programa tendrá que:
• leer el archivo de exón línea por línea
• dividir cada línea de exón en dos números
• convertir esos números en números enteros
• extraer la parte codificante de la secuencia de ADN genómico
• concatenar todas las secuencias de exones
Tarea
• Realizar los ejercicios de la página 89 del libro de Jones, M. (2013)
Python for Biologist.
Escritura de funciones
¿Por qué queremos escribir nuestras propias
funciones?

• get_at_content()
• print()
• len()
• open()
Definición de una función
• Antes de comenzar a escribir:
• Entradas: el número y los tipos de argumentos de la función.
• Salidas: el tipo del valor devuelto
• get_at_content()
• Entrada: un solo argumento de tipo cadena
• Salida: un valor de tipo numérico.
Llamando y mejorando nuestra función
Llamando y mejorando nuestra función
Las funciones se pueden llamar con
argumentos con nombre
Argumentos de
palabras clave:
nos permite
llamar funciones
proporcionando
nombres de
variables de
argumento y
valores
Los argumentos de función pueden tener
valores predeterminados
Funciones de prueba
• assert: una afirmación consta de la palabra assert, seguida de una llamada a nuestra
función, luego dos signos de igual y luego el resultado que esperamos.

• Si una afirmación resulta ser falsa el programa se detendrá y obtendremos un

AssertionError
• Las afirmaciones son útiles de varias maneras:
• Nos brindan un medio para verificar si nuestras funciones funcionan según lo previsto y, por lo tanto, nos
ayudan a rastrear errores en nuestros programas.
• Nos permiten modificar una función y comprobar que no hemos introducido ningún error.
• Podemos usar afirmaciones para probar el comportamiento de nuestra función para entradas inusuales.
Funciones de prueba

• Es común agrupar una colección de afirmaciones para una función particular para
probar el comportamiento correcto en diferentes tipos de entrada:
Ejercicio
El ejercicio de esta sección requiere que pruebe sus respuestas con una
colección de afirmaciones assert.
1. Porcentaje de residuos de aminoácidos, primera parte.
Escriba una función que tome dos argumentos, una secuencia de proteína y
un código de residuo de aminoácido, y devuelva el porcentaje de proteína
que forma el aminoácido. Use las siguientes afirmaciones para probar su
función:
• assert my_function("MSRSLLLRFLLFLLLLPPLP", "M") == 5
• assert my_function("MSRSLLLRFLLFLLLLPPLP", "r") == 10
• assert my_function("msrslllrfllfllllpplp", "L") == 50
• assert my_function("MSRSLLLRFLLFLLLLPPLP", "Y") == 0
Tarea
2. Porcentaje de residuos de aminoácidos, segunda parte.
Modifique la función de la primera parte para que acepte una lista de
residuos de aminoácidos en lugar de uno solo. Si no se proporciona una
lista, la función debe devolver el porcentaje de residuos de
aminoácidos hidrofóbicos (A, I, L, M, F, W, Y y V). Su función debe pasar
las siguientes afirmaciones:
• assert my_function("MSRSLLLRFLLFLLLLPPLP", ["M"]) == 5
• assert my_function("MSRSLLLRFLLFLLLLPPLP", ['M', ‘P']) == 20
• assert my_function("MSRSLLLRFLLFLLLLPPLP", ['F', 'S', 'L']) == 70
• assert my_function("MSRSLLLRFLLFLLLLPPLP") == 65
Sentencias Condicionales
Condiciones verdadero y falso
• Condición = fragmento de código que puede producir una respuesta
verdadera o falsa.
• Hay una amplia gama de construcciones que podemos incluir en las
condiciones.
• Bloques de construcción básicos:
• es igual a (==)
• mayor y menor que (> y <)
• mayor o igual que, y menor o igual que (>= y <=)
• no igual (!=)
• está un valor en un contenedor (in)
• no se encuentra un valor en un contenedor (not in)
Declaraciones if

sangría 1 sangría 2
Más declaraciones
• A menudo necesitamos un tipo de decisión, donde tenemos dos
acciones posibles para tomar. Para hacer esto, podemos agregar una
cláusula else después del final del cuerpo de una declaración if:
Declaraciones elif
• ¿Y si tenemos más de dos ramas posibles? Por ejemplo, queremos tres archivos de nombres de
acceso: los que comienzan con "a", los que comienzan con "b" y todos los demás.

• Declaración elif fusiona else e if

Para opciones
mutuamente
excluyentes
Serie de declaraciones if
• Cuando no son mutuamente excluyentes
Condiciones en bucles
• Usarlas para determinar cuándo salir de un ciclo.
• Bucle while: se ejecuta hasta que se cumple alguna condición.
Construyendo condiciones complejas
• ¿Y si quisiéramos expresar una condición que estuviera compuesta
por varias partes?
• Queremos revisar nuestra lista de accesos e imprimir solo las que
comienzan con "a" y terminan con "3".
Construyendo condiciones complejas
• Operadores booleanos: and/or para unir dos condiciones

• Unir condiciones complejas:

Construyendo condiciones complejas
• Podemos negar cualquier tipo de condición prefijándola con la
palabra not:
Escribir funciones de verdadero/falso
• Escribir una función que determine si una secuencia de ADN es rica
en AT (suponiendo que una secuencia es rica en AT si tiene un
contenido de AT de más de 0,65).
Escribir funciones de verdadero/falso
• Escribir una función que determine si una secuencia de ADN es rica
en AT (suponiendo que una secuencia es rica en AT si tiene un
contenido de AT de más de 0,65).
Ejercicio
• Para el siguiente ejercicio se utilizará el archivo de texto llamado [Link] , que contiene algunos datos inventados
para varios genes. Cada línea contiene los siguientes campos para un solo gen en este orden: nombre de la especie,
secuencia, nombre del gen, nivel de expresión. Los campos están separados por comas (de ahí el nombre del
archivo: csv significa valores separados por comas). Piense en ello como una representación de una tabla en una
hoja de cálculo: cada línea es una fila y cada campo en una línea es una columna.

• Este es un ejercicio de varias partes que implica extraer e imprimir datos del archivo. La naturaleza de este tipo de
problema significa que es bastante fácil obtener un programa que se ejecute sin errores, pero que no produzca el
resultado correcto, así que asegúrese de verificar sus soluciones manualmente.
1. Imprima los nombres de todos los genes pertenecientes a Drosophila melanogaster o Drosophila simulans.
2. Imprima los nombres de todos los genes entre 90 y 110 bases de largo.
3. Imprima los nombres de todos los genes cuyo contenido de AT sea inferior a 0,5 y cuyo nivel de expresión sea
superior a 200.
Tarea
4. Imprima los nombres de todos los genes cuyo nombre comience
con "k" o "h", excepto los que pertenecen a Drosophila
melanogaster.
5. Para cada gen, imprima un mensaje dando el nombre del gen y
diciendo si su contenido de AT es alto (más de 0,65), bajo (menos
de 0,45) o medio (entre 0,45 y 0,65).
Expresiones regulares
Los patrones en biología
Patrones fijos:
• Dominios de proteínas: verificar si una secuencia proteica contiene un dominio específico
basándose en un patrón conservado.
• Identificación de patrones específicos en secuencias de ADN o proteínas: sitios de unión de
factores de transcripción, secuencias promotoras, o motivos de unión de proteínas.
• Sitios de corte de enzimas de restricción.
• Sitios de cebadores de PCR degenerados.
• Series de mononucleótidos

Patrones más flexibles:

• Dada una secuencia de ADN, ¿Cuál es la longitud de la cola poli-A?
• Dado un nombre de acceso de gen, extraiga la parte entre el tercer carácter y el guion bajo.
• Dada una secuencia de proteína, determine si este contiene un motivo de proteína altamente
redundante.
Automatización
• Leer archivos de datos biológicos (como
archivos FASTA, archivos de resultados de
secuenciación, etc.) y extraer información
específica.
• Realizar búsquedas en bases de datos
biológicas y analizar los resultados para
extraer información útil.
• Generación de informes automatizados
Módulos en Python
• Módulo: Una colección de funciones especializadas y tipos de datos.
• import: para cargar un módulo
• re: módulo que trata con expresiones regulares

• Cuando queremos usar una de las herramientas de un módulo,

tenemos que anteponerle el nombre del módulo:
Raw strings
• Escribir expresiones regulares requiere que escribamos muchos
caracteres especiales (\n, \t).
• Algunos caracteres con expresiones regulares chocan con caracteres
que ya tienen un significado especial.
• Al colocar r (raw) inmediatamente antes de las comillas de apertura,
se ignoran los caracteres especiales dentro de la cadena.
Buscando un patrón en una cadena
• [Link]() es una función verdadero/falso que determina si un
patrón aparece o no en algún lugar de una cadena.
Alternancia
• Comprobar la presencia de un sitio de reconocimiento de Avall que
puede tener dos secuencias diferentes: GGACC y GGTCC.

• Alternancia (│): para representar varias alternativas diferentes:

Grupos de caracteres
• La enzima de restricción BisI corta en una gama aún más amplia de
motivos: el patrón es GCNGC, donde N representa cualquier base.

• Si queremos que un carácter en un patrón coincida con cualquier carácter

en la entrada, podemos usar un punto (.)
• [Link] coincidiría con las cuatro posibilidades en el ejemplo de BisI anterior.
• El patrón también coincidiría con cualquier carácter que no sea una base de ADN:
GCFGC, GC&GC y GC9GC.
• Podemos especificar los caracteres que no queremos que coincidan: [^XYZ]
Cuantificadores
• ? Un signo de interrogación inmediatamente después de un carácter
significa que ese carácter es opcional: puede no estar o coincidir una
vez:
• GAT?C la T es opcional y el patrón coincidirá con GATC o GAC.
• Aplicar un signo de interrogación a más de un carácter: GGG(AAA)?TTT el
patrón coincidirá con GGGAAATTT o GGGTTT.
• + Un signo más inmediatamente después de un carácter o grupo
significa que el carácter o grupo coincidirá una o más veces:
• GGGA+TTT coincidirá con tres G, seguidas de una o más A, seguidas de tres T:
coincidirá con GGGATTT, GGGAATT, GGGAAATT, etc.
Cuantificadores
• * Un asterisco inmediatamente después de un carácter o grupo
significa que el carácter o grupo puede no estar o coincidir varias
veces.
• GGGA*TTT coincidirá con tres G, seguido de ninguna o más A, seguido de tres
T. Entonces coincidirá con GGGTTT, GGGATTT, GGGAATTT, etc.
• Si queremos hacer coincidir un número específico de repeticiones,
podemos usar llaves {}.
• GA{5}T coincidirá con GAAAAAT.
• GA{2,4}T significa G, seguido de entre 2 y 4 As, seguido de T: coincidirá con
GAAT, GAAAT y GAAAAT.
• Podemos omitir los límites inferior o superior.
• A{3,} coincidirá con tres o más As, y
• G{,7} coincidirá con hasta siete Gs.
Posiciones
• Conjunto de herramientas de expresión regular que representan
posiciones en la cadena de entrada:
• El símbolo de intercalación ^ coincide con el comienzo de una cadena.
• El patrón ^AAA coincidirá con AAATTT pero no con GGGAAATTT.
• El símbolo de dólar $ coincide con el final de una cadena.
• El patrón GGG$ coincidirá con AAAGGG pero no con AAAGGGCCC.
Combinación
• Podemos usar cuantificadores junto con alternancias y grupos de
caracteres para especificar patrones muy flexibles.
• Patrón complejo para identificar secuencias de ARN mensajero
eucariótico de longitud completa:

^AUG[AUGC]{30,1000}A{5,10}$

• un codón de inicio AUG al comienzo de la secuencia,

• seguido de entre 30 y 1000 bases que pueden ser A, U, G o C
• seguido de una cola poli-A de entre 5 y 10 bases al final de la secuencia
Extrayendo la parte que coincide con el patrón
• Averiguar no solo si un patrón coincide, sino también qué parte de la
cadena coincide.
• Para hacer esto, necesitamos almacenar el resultado de usar
[Link]() y luego usar el método group() en el objeto resultante.
• [Link]() devuelve un objeto de coincidencia: representa los
resultados de una búsqueda de expresiones regulares y tiene varios
métodos:
• Método group(): obtenemos la parte de la cadena de entrada que coincidió
con el patrón:
Extrayendo la parte que coincide con el patrón
• Queremos tomar una secuencia de ADN y determinar si contiene o no
bases ambiguas, es decir, cualquier base que no sea A, T, G o C, y
señalar cuál es.

Símbolo Nucleótido Categoría

A Adenina Purina
C Citosina Pirimidina
G Guanina Purina
T Timina Pirimidina
Cualquier
N ----------------
nucleótido
R AoG Purinas
Y CoT Pirimidinas
S CoG
W AoT
Extraer varios grupos
• ¿Qué pasa si queremos extraer más de un bit del patrón?
• Queremos hacer coincidir un nombre científico como Homo sapiens o
Drosophila melanogaster . El patrón: varios caracteres, seguidos de un
espacio, seguidos de varios caracteres:
.+ .+ repetido al menos una vez

cualquier carácter

• Queremos extraer el nombre del género y el nombre de la especie en

variables separadas:
(.+) (.+)
Llamamos a esto capturar parte del patrón
Extraer varios grupos
• Ahora podemos referirnos a los bits capturados del patrón proporcionando un argumento al
método group():
• group(1) devolverá el bit de la cadena que coincida con la sección del patrón en el primer paréntesis,
• group(2) devolverá el bit que coincida con el segundo, etc.

espacio
Obtener posiciones de coincidencia
• Los métodos start() y end() obtienen las posiciones de inicio y final
del patrón en la cadena.
Múltiples coincidencias
• [Link]() solo puede encontrar una sola coincidencia.
• Para procesar varias coincidencias, debemos usar [Link](), que
devuelve una lista de objetos de coincidencia que podemos procesar en un
bucle:
Obtener múltiples coincidencias como cadenas
• Aquí hay una secuencia de ADN con los bits que queremos extraer en
negrita:
ACTGCATTATATCGTACGAAATTATACGCGCG
• Este es un patrón de expresión regular que coincide con series de A o
T de más de seis bases: [AT]{6,}
Obtener múltiples coincidencias como cadenas
• [Link]() toma el patrón y la cadena como argumentos, pero en
lugar de devolver objetos coincidentes, devuelve una lista de cadenas:
Dividir una cadena usando una expresión
regular
• Podemos dividir una cadena utilizando un patrón de expresión regular
como delimitador.
• [Link] toma un patrón de expresión regular como primer argumento y el
segundo argumento es la cadena que se dividirá.
• EJEMPLO: tenemos una secuencia de ADN consenso que contiene códigos
de ambigüedad y queremos extraer todas las series de bases no ambiguas
contiguas. Necesitamos dividir la cadena de ADN cada vez que veamos una
base que no sea A, T, G o C:
EJERCICIO
Doble digestión
• Utilizaremos el archivo [Link] que contiene una secuencia de ADN
inventada. A partir de este archivo, prediga las longitudes de los
fragmentos que obtendremos si digerimos la secuencia con dos enzimas de
restricción compuestas: AbcI, cuyo sitio de reconocimiento es ANT/AAT, y
AbcII, cuyo sitio de reconocimiento es GCRW/TG.
• Las barras diagonales (/) en los sitios de reconocimiento representan el
lugar donde la enzima corta el ADN.
• N significa cualquier base.
• El código de ambigüedad R significa A o G y el código W significa A o T.
TAREA
• Realizar los ejercicios de la página 157 del libro de Jones, M. (2013)
Python for Biologist.
• Nombre de archivo: apellido_expresiones_regulares.html
• Subir al aula virtual en formato HTML.
Diccionarios
Problema

16

64
Problema
• Una secuencia de ADN con una longitud de 20 bases contendrá 18
trinucleótidos superpuestos en total:

• Puede haber, como máximo, 18 trinucleótidos únicos en la secuencia (y

para una secuencia repetitiva, muchos menos trinucleótidos únicos). Esto
significa que al menos 46 de nuestras 64 variables tendrán el valor cero.
Problema
Problema
• Dos problemas con este enfoque:
• La gran mayoría de los recuentos son cero.
• Los recuentos están desconectados de los dinucleótidos.
• Si queremos buscar el recuento de un solo dinucleótido, por ejemplo, TG, primero
tenemos que averiguar si ese TG fue el séptimo dinucleótido de la lista:

• Podemos usar el método index() para averiguar la posición del dinucleótido que estamos
buscando en la lista

• Esto funciona porque tenemos dos listas de la misma longitud, con una correspondencia
uno a uno entre los elementos:
Problema
• Aún estamos almacenando todos los ceros, y ahora tenemos dos
listas para realizar un seguimiento.
• Debemos tener mucho cuidado al manipular cualquiera de las dos
listas para asegurarnos de que permanezcan perfectamente
sincronizadas.
• Este enfoque también es lento. Para encontrar el índice de un
dinucleótido dado en la lista de dinucleótidos, Python tiene que mirar
cada elemento de uno en uno hasta encontrar el que estamos
buscando.
Solución: diccionario
• Lo que necesitamos es una forma de almacenar pares de datos (dinucleótidos y
sus conteos) de una manera que nos permita buscar de manera eficiente el
conteo de cualquier dinucleótido dado.
• Este problema es muy común en la programación, podríamos querer almacenar:
• Nombres de secuencias de proteínas y sus secuencias.
• Nombres de enzimas de restricción de ADN y sus motivos.
• Codones y sus residuos de aminoácidos asociados.
• Nombres de muestras y sus coordenadas.
• Palabras y sus definiciones.
• La herramienta de Python para resolver este tipo de problemas se llama
diccionario.
Creando un diccionario
• La sintaxis para crear un diccionario es similar a la de crear una lista,
pero usamos llaves {} en lugar de corchetes.

elemento

clave valor
Construyendo diccionarios
Construyendo diccionarios
Construyendo diccionarios
Construyendo diccionarios
Iterando sobre un diccionario
• ¿Qué pasa si, en lugar de buscar un solo elemento de un diccionario,
queremos hacer algo para todos los elementos?
• Por ejemplo, queremos tomar nuestra variable all_counts del código
anterior e imprimir todos los dinucleótidos donde el conteo fue 2.

• Funciona bien porque tenemos una lista de dinucleótidos ya escrita como

parte del programa.
Iterando sobre un diccionario
• La mayoría de las veces, cuando creamos un diccionario, lo hacemos
usando algún otro método que no requiera una lista explícita de las
claves.
Iterando sobre un diccionario
• La mayoría de las veces, cuando creamos un diccionario, lo hacemos
usando algún otro método que no requiera una lista explícita de las
claves.
Iterando sobre claves
• El método keys() devuelve una lista de todas las claves en el diccionario:

• Para encontrar todos los dinucleótidos que ocurren exactamente dos

veces en la secuencia de ADN, podemos tomar el resultado de keys() e
iterarlo:
Iterando sobre elementos
• Podemos usar el método items() para iterar sobre pares de datos, en
lugar de solo claves
Búsqueda frente a iteración
• No cometer el error de iterar sobre todos los elementos en un diccionario para
buscar un solo valor.
• Queremos buscar la cantidad de veces que ocurre el dinucleótido AT en nuestro
ejemplo anterior.

• Simplemente usar el método get() para solicitar el valor asociado con la clave que
desea:
EJERCICIO / TAREA
Traducción de ADN
• Aquí hay un diccionario que representa el código genético: las claves son codones y los valores son residuos de aminoácidos:
gencode = {
'ATA':'I', 'ATC':'I', 'ATT':'I', 'ATG':'M',
'ACA':'T', 'ACC':'T', 'ACG':'T', 'ACT':'T',
'AAC':'N', 'AAT':'N', 'AAA':'K', 'AAG':'K',
'AGC':'S', 'AGT':'S', 'AGA':'R', 'AGG':'R',
'CTA':'L', 'CTC':'L', 'CTG':'L', 'CTT':'L',
'CCA':'P', 'CCC':'P', 'CCG':'P', 'CCT':'P',
'CAC':'H', 'CAT':'H', 'CAA':'Q', 'CAG':'Q',
'CGA':'R', 'CGC':'R', 'CGG':'R', 'CGT':'R',
'GTA':'V', 'GTC':'V', 'GTG':'V', 'GTT':'V',
'GCA':'A', 'GCC':'A', 'GCG':'A', 'GCT':'A',
'GAC':'D', 'GAT':'D', 'GAA':'E', 'GAG':'E',
'GGA':'G', 'GGC':'G', 'GGG':'G', 'GGT':'G',
'TCA':'S', 'TCC':'S', 'TCG':'S', 'TCT':'S',
'TTC':'F', 'TTT':'F', 'TTA':'L', 'TTG':'L',
'TAC':'Y', 'TAT':'Y', 'TAA':'_', 'TAG':'_',
'TGC':'C', 'TGT':'C', 'TGA':'_', 'TGG':'W'}

• Copie y pegue este trozo de código en un nuevo programa, luego use este diccionario para escribir un programa que
traducirá una secuencia de ADN en proteína. Tendrá que descubrir cómo:
• dividir la secuencia de ADN en codones.
• buscar el residuo de aminoácido para cada codón.
• unir todos los aminoácidos para dar una proteína.
• ¿Cómo maneja su programa una secuencia cuya longitud no es un múltiplo de 3?, ¿Cómo se enfrenta a una secuencia que
contiene bases desconocidas?
Introducción a Python
¿Qué es Python?
• Python es un lenguaje de programación de alto nivel
interpretado, que permite la interactividad (obtener
una retroalimentación inmediata sobre la ejecución
de cada sentencia de código).
• Lenguaje interpretado: no requiere compilación
previa del programa y todas sus instrucciones se
ejecutan directamente (en tiempo de ejecución).
• Para que esto sea posible, se requiere de un
programa de computadora llamado intérprete que
entienda la sintaxis del lenguaje de programación y
ejecute directamente las instrucciones definidas por
el programador.
• Fue creado por Guido van Rossum. Publicó la
primera versión del código Python en 1991.
¿Cómo funciona Python?
El intérprete de Python realiza las siguientes tareas para ejecutar un programa:
1. El intérprete lee un código o instrucción python. Luego verifica que la instrucción
esté bien formateada, es decir, comprueba la sintaxis de cada línea. Si encuentra
algún error, detiene inmediatamente la traducción y muestra un mensaje de error.
2. Si no hay ningún error, el intérprete lo traduce a su forma equivalente en un
lenguaje intermedio llamado «código Byte».
3. El código del byte se envía a la Máquina Virtual Python, donde se ejecuta realizando
todas las operaciones definidas por el código fuente.
 Índice TIOBE abril de 2023 - 2024

¿Por qué Python?

• Es un lenguaje de programación de código abierto
(gratuito).
• Relativamente simple, sintaxis consistente.
• Uno de los lenguajes más utilizados en el mundo.
• Gran comunidad, amplio soporte.
• Multiplataforma. Portable.
• Bibliotecas diseñadas para hacer computación
científica compleja.
• Facilita la manipulación de cadenas de caracteres.
Usos de Python
• Análisis de datos.
• Aplicaciones de escritorio.
• Bases de datos relacionales / NoSQL
• Criptomonedas / Blockchain.
• Desarrollo de aplicaciones multimedia.
• Desarrollo de juegos.
• Desarrollo web.
• Gráficos por ordenador.
• Inteligencia artificial.
• Internet de las cosas.
• Machine Learning.
• Seguridad.
Python 2 vs Python 3
• Hay dos versiones de Python actualmente disponibles Python 2 y
Python 3.
• En el cambio de Python 2 a Python 3 se perdió la compatibilidad en
muchas de las estructuras del lenguaje.
• Los desarrolladores, con Guido van Rossum a la cabeza, vieron la
necesidad de aplicar estas modificaciones en beneficio del
rendimiento y expresividad del lenguaje de programación.
• Usaremos Python 3.x, ya que es el más reciente y elimina algunas
peculiaridades de las versiones anteriores de Python 2.x, siendo el
futuro del lenguaje.
Python 3 con Anaconda
• Anaconda: es una distribución libre y abierta​ de los lenguajes Python y R,
utilizada en ciencia de datos, y aprendizaje automático, incluye las librerías
más habituales para el día a día del análisis de datos.
• Anaconda está pensada para ser utilizada principalmente por científicos de
datos. Está disponible para Linux, Windows y MacOS.
• Utiliza entornos Conda (gestor de paquetes) para ofrecer amplias
colecciones de herramientas de Python y R.
• La gestión de versiones y dependencias de Conda asegura que, en un
entorno, los componentes individuales sean compatibles, es decir, que no
existan conflictos entre ellos.
• Anaconda tiene como ventaja simplificar la gestión e implementación de
paquetes.
Anaconda Cloud
• [Link]
Instalación local
• [Link]