lunes, 24 de junio de 2013

Python para BioInformatica introducción al comando Seq (parte 1)


Las secuencias son simplemente cadenas de texto como por ejemplo “GGTCGGTGGTCG”, que representan algún tipo de información de índole biológico. Se debe distinguir algunas características de  las cadenas y las secuencias en Biopython, tienen diferentes métodos. Aun que el objeto Seq admite algunos de los métodos de una cadena simple.
Una diferencia sumamente importante es que un objeto Seq tiene, es que  depende de un alfabeto (Alphabet), el cual describe exactamente muchas de las características que posee la secuencia en estudio, esta es su gran ventaja de uso ya que  así nos permite limitar la información  que contiene el objeto Seq. En esta introducción notaremos algunas similitudes  de una secuencia y una cadena simple en python.
>>> cadena = "AGAGAGACTGCTCG"
>>> from Bio.Seq import Seq
>>> secuencia = Seq ("AGAGAGACTGCTCG")
>>> ### al aplicar el comando type notamos la diferencia
>>> print(type(cadena))
<class 'str'>
>>> print(type(secuencia))
<class 'Bio.Seq.Seq'>
>>> ### podemos conocer la magnitud de cada una
>>> print(len(secuencia))
14
>>> print(len(cadena))
14
>>> ### tambien los elementos  q la componen
>>> secuencia[6]
'A'
>>> cadena[6]
'A'
>>> ### se puede extrer un segmento de cada una como si  fuera una cadena normal
>>> cadena2 = cadena[1:3]
>>> secuencia2 = secuencia[1:3]
>>> #### hacer operaciones basicas  como un string
>>> total = secuencia + secuencia2
>>> print (total)
AGAGAGACTGCTCGGA
>>> TOTAL = cadena + cadena2
>>> print(TOTAL)
AGAGAGACTGCTCGGA
>>> ### podemos invertir una cadena
>>> cadena_invertidad = cadena[::-1]
>>> cadena_invertidad
'GCTCGTCAGAGAGA'
>>> #### de la  misma forma se puede invertir una secuencia
>>> secuencia_invertida = secuencia[::-1]
>>> secuencia_invertida
Seq('GCTCGTCAGAGAGA', Alphabet())
>>> #### empleando count
>>> ######### aplicado a una cadena
>>> cadena
'AGAGAGACTGCTCG'
>>> cadena.count("A")
4
>>> #### esto qiere decir que en nuestra cadena aparece 4 veces A
>>> ######### lo mismo se puede hacer  auna secuencia
>>> secuencia.count("A")
4
Este sencillo ejemplo nos hace  ver que muchos de nuestros comandos usados a diario  cuando programamos en python son aplicados  en una secuencia. Para demostrarlo crearemos un pequeño programa donde trataremos con el objeto secuencia y como una cadena normal y notaremos que el resultado es el mismo.


from Bio.Seq import Seq
import matplotlib.pyplot as plt
from matplotlib import font_manager as fm

secuencia = Seq ("ACGCTGCTCGATCGCTGATGCTCGCCGATCGCTCGATGCTGCTGCTGCTAGA")
a = secuencia.count("A")
g = secuencia.count("G")
c = secuencia.count("C")
t = secuencia.count("T")
D = len(secuencia)
dato = [a,g,c,t]
pa = a/D *100
pg = g/D *100
pc = c/D * 100
pt = t/D * 100
fraccion = [pa, pg, pc, pt]
nombres = 'A', 'G', 'C', 'T'
fig = plt.figure(1,figsize= (5,5))
ax = fig.add_axes([0.1,0.1,0.8,0.8])
plt.title('Composicion de la Secuencia')
p, texto, dtexto = ax.pie(fraccion, labels = nombres, autopct = '%1.1f%%')
propiedades = fm.FontProperties()
propiedades.set_size('x-large')
plt.setp(dtexto, fontproperties= propiedades)
plt.setp (texto, fontproperties = propiedades)

plt.show()
La gráfica generada  es:
 Ahora trataremos nuestra secuencia como si fuera una cadena simple  en python
from Bio.Seq import Seq
import matplotlib.pyplot as plt
from matplotlib import font_manager as fm

cadena = "ACGCTGCTCGATCGCTGATGCTCGCCGATCGCTCGATGCTGCTGCTGCTAGA"
a = cadena.count("A")
g = cadena.count("G")
c = cadena.count("C")
t = cadena.count("T")

D = len(cadena)
dato = [a,g,c,t]

pa = a/D *100
pg = g/D *100
pc = c/D * 100
pt = t/D * 100

fraccion = [pa, pg, pc, pt]
nombres = 'A', 'G', 'C', 'T'
fig = plt.figure(1,figsize= (5,5))
ax = fig.add_axes([0.1,0.1,0.8,0.8])
plt.title('Composicion de la Secuencia como cadena')
p, texto, dtexto = ax.pie(fraccion, labels = nombres, autopct = '%1.1f%%')
propiedades = fm.FontProperties()
propiedades.set_size('x-large')
plt.setp(dtexto, fontproperties= propiedades)
plt.setp (texto, fontproperties = propiedades)

plt.show()
la gráfica como cadena es:

viernes, 21 de junio de 2013

Python para Bioinformatica introducción al Alphabet (Alfabeto)

En python podemos manejar listas, y tuplas y algunas de estas contienen variables del tipo string por lo que  es necesario conocer un poco acerca de  este pido de  datos antes de  aventurarnos en  el manejo de python 3.x para  bioinformatica.
En la bioinformatica es común usar un gran conjunto de letras que representan diversos tipos de información, ejemplo el ADN está compuesto por 4 letras (A,D,G,C),  aminoácidos, y otro tipo de información son representados simbólicamente.

>> ##importando el modulo Bio.Alphabet
>>> import Bio.Alphabet
>>> ##casos mas usuales y comun mente empleados
>>> casos_comunes =Bio.Alphabet.ThreeLetterProtein.letters
>>> print (casos_comunes)
['Ala', 'Asx', 'Cys', 'Asp', 'Glu', 'Phe', 'Gly', 'His', 'Ile', 'Lys', 'Leu', 'Met', 'Asn', 'Pro', 'Gln', 'Arg', 'Ser', 'Thr', 'Sec', 'Val', 'Trp', 'Xaa', 'Tyr', 'Glx']
>>> ### estos datos y modulos tambien interaccionan con funciones endemicas de python
>>> print(type(casos_comunes))
<class 'list'>
>>> print(len(casos_comunes))
24
Los alfabetos definidos por la IUPAC se encuentran en el modulo

>>> from Bio.Alphabet import IUPAC
>>> iupac = IUPAC.IUPACProtein.letters
>>> print(iupac)
ACDEFGHIKLMNPQRSTVWY
En ocaciones se trabaja con grupos de aminoacidos que no se encuentran frecuentemente en proteínas para eso, se emplea un diccionario extendido para estos casos definido por la IUPAC, la forma de acceder a el es la siguiente.
>>> from Bio.Alphabet import IUPAC
>>> iupacext = IUPAC.ExtendedIUPACProtein.letters
>>> print(iupacext)
ACDEFGHIKLMNPQRSTVWYBXZJUO

Otro tipo de Alphabet (alfabeto) extendido, que contempla algunas propiedades fisicoquimicas comunes de los elementos que la conforman. La forma de acceder a este modulo es de la siguiente manera.



>>> from Bio.Alphabet import IUPAC
>>> iupacDNA = IUPAC.ExtendedIUPACDNA.letters
>>> print(iupacDNA)
GATCBDSW
Existe otro tipo de módulos de alfabetos que contemplan "posiciones de Ambiguedad" donde mas de un nucleotido puede estar presente, el código en python es el siguiente.

>>> al = IUPAC.unambiguous_dna.letters
>>> print(al)
GATC

Estos son los comandos basicos del manejo de los alfabetos en python, mas adelante exploraremos las propiedades de los mismos,  asi como su utilidad con el comando Seq.

martes, 18 de junio de 2013

Resolviendo un problema de fisica basica en Matlab

Hace unos días recibí un correo donde me pedían  un poco de ayuda para resolver un pequeño problema  de  física en Matlab, aun que este blog no se creo con el objetivo de resolverles sus tareas o de hacer sus proyectos de clase, realize la solución del problema simplemente para mostrar la capacidad de matlab en la solución de problemas  de cualquier índole,



1   Una partícula m se desplaza sobre el eje x de un sistema de referencia dado, de tal forma que su posición x como función del tiempo es: x = 5t^2-20t +15
      a ) obtener la velocidad y aceleración de m en función del tiempo;
           usando un poco de matlab para calculo simbólico tenemos.     

>> x = 5*t^2-20*t+15
 
x =
 
5*t^2 - 20*t + 15
 
>> %por definicion tenemos que  v = dx/dt
>> v = diff(x,t)
 
v =
 
10*t - 20
 
>> pretty (v)
 
  10 t - 20
>> %la segunda derivada es la acelracion
>> a = diff(v,t)
 
a =
 
10
b) Calcular los valores de x, v y a para los valores siguientes
 para ello recurrimos al calculo numérico en matlab 
 
>> ts = [0:5];
>> X = 20*ts.^2 -20*ts +15;
>> X = 5*ts.^2 -20*ts +15;
>> V = 10*ts -20;
>> a1 = ones(1,6);
>> a = 10*a1;
>> resultado = [ts',X',V',a'];
>> resultado

resultado =

     0    15   -20    10
     1     0   -10    10
     2    -5     0    10
     3     0    10    10
     4    15    20    10
     5    40    30    10
  c) Hacer las grafícas de posición, aceleración, y velocidad Vs tiempo

>> subplot(3,1,1)
>> plot(ts,a,'-o')
>> xlabel('Tiempo (s)')
>> ylabel('Aceleracion (m/s^2)')
>> title('aceleracion Vs Tiempo')
>> subplot(3,1,2)
>> plot(ts,V)
>> plot(ts,V,'o')
>> hold on
>> ezplot(v,[0,5])
>> title('Velocidad Vs Tiempo')
>> xlabel('tiempo (s)')
>> ylabel('aceleracion (m/s^2)')
>> subplot(3,1,3)
>> plot(ts,X,'o')
>> hold on
>> ezplot(x,[0,5])
>> title('X Vs t')
>> xlabel('t (s)')
>> ylabel ('x (m)')

sábado, 8 de junio de 2013

Fluido Newtoniano en Matlab

El Número de Newton (también llamado el coeficiente de arrastre) y el número de Arquímedes se representan frente al número de Reynolds para los tipos de flujo laminar, de transición y turbulento utilizando una escala log-log. Un ejemplo numérico de la velocidad terminal de caída cálculo de una sola partícula esférica en un fluido newtoniano, para el tipo de flujo turbulento, se da en el programa. Para flujo laminar, la expresión velocidad terminal está dada por la Stokes conocido? ley. Medición de la velocidad de caída terminal tiene importantes aplicaciones como la determinación de viscosidad (por ejemplo, viscosímetro de caída de esfera) y la jarra de tamaño.