PROGRAMACIÓN CON PYTHON Y R

PROGRAMACIÓN CON PYTHON

1. INTRODUCCIÓN A PYTHON.
El computador tiene dos elementos básicos: la memoria y la CPU (unidad central de proceso). También tenemos la
memoria (RAM), el almacenamiento permanente (storage) y la entrada/salida (input/output). Todo lo que se ejecuta se
pasa a código máquina o binario (0s y 1s). Nosotros en vez de usar el código binario (que puede dar a mucho error)
usamos el lenguaje de programación. Un lenguaje intermedio entre el lenguaje binario y el de programación es el lenguaje
ensamblador.

Python es un lenguaje de alto nivel de programación interpretado cuya filosofía hace hincapié en la legibilidad de su
código. Se usa para desarrollar aplicaciones de todo tipo. Es un lenguaje multiparadigma ya que soporta parcialmente la
orientación a objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado,
dinámico y multiplataforma.

-​ Lenguaje muy expresivo, es muy compacto. Suele ser más corto que otros.
-​ Muy legible.
-​ Entorno interactivo.
-​ Entorno de ejecución para detectar errores.
-​ Lenguaje imperativo o orientado a objetos.
-​ Rico juego de instrucciones de datos.

Para entrar a python desde la terminal usamos: conda activate prog_python ; jupyter notebook .

2. STRINGS (SECUENCIAS DE CARACTERES).

Para crear una variable usamos: variable = “string” ; se pueden usar tanto comillas dobles como simples, y no es necesario
poner espacios entre el igual.

Para visualizar el contenido de la variable se usa el comando (o función) print(variable) .

Para obtener un caracter de un string debemos tener en cuenta que se empieza a contar desde el 0 (el primer caracter se
representa con un 0). Para indexarlo usamos [ ] : variable[n] . Si n es igual a -1 nos imprime el último caracter del string
(-2, el penúltimo…). Por último, para que nos imprima el contenido volvemos a usar la función: print(variable[n]) . Para
indexar una subcadena (substring) usamos: variable[n:m] , nos extrae de la posición n hasta la m (sin incluir la m);
variable[:] , nos extrae toda la cadena; variable[n:m:z] , de n a m con un paso de z (si z es 2 me imprime una si una no);
variable[::-1] , nos extrae la cadena en forma inversa (es necesario ponerlo si m es menor que n, sino no nos reporta nada).

Para introducir caracteres especiales dentro de un string usamos \ , ej. “Algunos caracteres especiales son: \” , \\ , \\n “.

Otras funciones para trabajar con strings son: len() , para conocer su longitud; sting + string2 , une (concatena) las
cadenas; string * n , crea una repetición de n veces la cadena; string in string2 devuelve TRUE o FASLSE según si string2
contiene string; string.find(string2) , reporta el índice en el que encuentra string2 dentro de string (empezando a contar
por 0; si no lo encuentra nos devuelve un -1); string.count(string2) , reporta el número de veces que encuentra string2
dentro de string. Además, python es sensible a mayúsculas y minúsculas.
Para convertir strings en otro tipo de dato podemos usar funciones como: int(string) , para pasar un string a número
entero; str() para convertir un objeto en string; float() , parar un objeto a número decimal.

Para cambiar partes de un string no podemos usar la indexación y asignarle un nuevo valor, los strings son inmutables, ej.
variable[n]=”nuevo string” (ESTO NO FUNCIONARÍA); para hacerlo podríamos hacer: variable=variable[:n] + “nuevo string” +
variable[m:].

Otras funciones son: .lower() , para pasar todo a minúsculas; .upper() , para pasar a mayúsculas; .replace(x, y) para
reemplazar x por y dentro del string; .startswith(string) , devuelve TRUE o FALSE si la cadena empieza por string.

Para hacer un string interactivo que pida datos al usuario usamos la función input() , ej. variable=input(string) . Los datos
los pedirá al final del string. Si imprimimos la variable nos imprimirá aquello que haya escrito el usuario.

Para eliminar una variable usamos: del variable .

3. LISTAS.
Secuencias ordenadas de objetos. Se define mediante corchetes [ ] : lista = [“objeto1”, “objeto2”] (si usasemos paréntesis
para definirla se crearía una tupla, que es inmutable).

Para añadir elementos al final de la lista usamos la función .append() , y para añadir varios elementos usamos la función
.extend([“objeto1”, “objeto2”]) . (También está insert pero no lo hemos visto aún).

Para indexar un elemento usamos lista[n] (funciona igual que con los strings pero en vez de seleccionar caracteres
selecciona objetos). Para seleccionar caracteres dentro de un objeto de una lista usamos: lista[n][m] (también para
seleccionar el elemento de una lista dentro de otra lista). (Se cuenta desde 0).

Al igual que en los strings tenemos funciones como: lista in lista2 ; * ; + …

En este caso si que podemos cambiar objetos de la lista indexando, ej. lista[n]=”nuevo_objeto” (en las tuplas no se puede).

Para las listas tenemos otras funciones, que llamamos métodos por ser específicos de un objeto concreto, como son:
.reverse() , invierte una lista (para invertir un string haríamos: string[::-1]); del lista[n] , elimina un elemento de la lista.

Para insertar un elemento en una posición concreta usamos .insert(n, “elemento”) (esto altera los índices de los demás
elementos).

También se puede cambiar el contenido de la lista mediante la indexación: lista[n]=[“elemento”] , lista[n:m]=[“elemento”,

“elemento2”] , lista[n]=[] (para eliminar un elemento) .

Para convertir strings en listas podemos usar la función .split() que separa los elementos por ciertos delimitadores (por
defecto espacios en blanco) como espacios, tabuladores, punto y coma… Podemos especificar el delimitador:
string.split(“d”).

Para convertir una línea en un string se usa .join() , en este caso, para especificar el delimitador se hace: “d”.join(lista) .

4. BUCLES Y CONDICIONALES.
4.1. BUCLES FOR.
Para realizar funciones para cada elemento de una lista, o cada caracter de un string. Estructura:
 for elemento in [lista]:
Código #La identación es necesaria.

Para imprimir variables en un print se usan llaves {} dentro del print y la función .format(variable) , ej. print(“Hola {}
{}”.format(nombre, apellido)). (Esto puede cambiarse por f”texto {variable} texto”).

Mediante la función range() podemos generar una secuencia de números, ej. range(5) nos da la lista: [0, 1, 2, 3, 4]. Para
indicar de que número a que número queremos la secuencia: range(n,m) (m no incluido); para que tenga paso:
range(n,m,z) (z puede ser -1 para que vaya decreciendo).

4.1. SENTENCIA IF.

Ejecuta un bloque de código sólo cuando algo es verdad. Estructura:

if condición:
Código #La identación es necesaria.
else:
​ Código_alternativo

La condición puede ser por ejemplo usando in o not in (pueden ir juntos o separados por secuencia1), ej. if secuencia1 in
secuencia2: código ; if secuencia1 not in secuencia2: código ; if not secuencia1 in secuencia2: código. También >, < ==, !=.
(Si lo hacemos sin if nos devuelve True o False, ej. secuencia1 in secuencia2; al hacerlo con if nos permite ejecutar ciertos
comandos solo si la condición es cierta).

Tenemos que tener en cuenta que devuelven ciertas funciones para armar las condiciones, ej. string.find(motivo) devuelve
un -1 si no se ha encontrado el motivo dentro de string.

5. FICHEROS, MÓDULOS Y FUNCIONES.

5.1. FICHEROS.
Para abrir un fichero se usa la función open(“nombrefichero.txt”, ‘r’) (la ‘r’ hace referencia a read). Con la función type() ,
después de abrir un fichero, nos indica el tipo de fichero.

Para leer las líneas del fichero usamos la función fichero.readline() que nos lee la primera línea. Para leer todas las líneas
haríamos un print(fichero.readline()) por cada línea del fichero, o simplificarlo con un bucle:

for linea in open(“fichero.txt”, ‘r’):

print(linea)

Otra función es .strip() elimina espacios tanto a la derecha como a la izquierda de una secuencia de caracteres especiales.

5.2. FUNCIONES.
Una función es un bloque de código con un nombre (como una variable que guarda código).

Para definir una función usamos def seguido del nombre de la función y del código que nos interese. Ej. Estructura:

def nombre_función(parámetro1, p2, p3):

Código “{}”.format(parámetro1)” #La identación es necesaria.
 suma = p2 + p3
return suma

Los parámetros son como las variables internas (solo tienen “vida” dentro de la función, al ejecutarla).

5.3. MÓDULOS.
Los módulos son colecciones de objetos que podemos importar. Estos se cargan mediante la función import módulo.

Un ejemplo de módulo es: math . Con este podemos hacer varios cálculos: math.pi , devuelve el número pi;
math.radians(número) , hace cálculos trigonométricos (pasa de grados a radianes); math.degrees(n) , pasa de radianes a
grados; math.cos() ; math.sqrt(n)/m , para cálculos matemáticos (como raíz cuadrada y división).

Los módulos tienen atributos (.pi) y métodos (.sqrt()).

6. DICCIONARIOS. AMPLIACIÓN.
6.1. DICCIONARIOS.
Un diccionario es una tabla de elementos. Cada elemento tiene una clave (key) y un valor (value). Podemos acceder a estos
elementos por clave.

Para crear un diccionario usamos {}. Estructura: nombre_diccionario = {‘Entrada1’ : ‘Definición1’, ‘Entrada2’ : ‘Definición2’}.

Para saber el número de elementos se usa la función len(diccionario) (cuenta claves).

Para consultar el valor de un elemento usamos la clave: diccionario[key1] . Es sensible a mayúsculas y minúsculas. Para
consultar todos los valores simplemente ponemos el nombre del diccionario. Para añadir valores usamos:
diccionario[nuevo_key] = “nuevo_valor” , este se añadirá al final del diccionario.

Para obtener las claves de un diccionario usamos la función .keys() , ej. print(diccionario.keys()) ; y para los valores la
función .values() (keys y values devuelven una lista). Para que nos imprima todos los elementos de un diccionario usamos
.items() (devuelve una lista de tuplas, donde cada tupla es un elemento (key y su valor)).

Otra forma de imprimir el diccionario de una forma más clara visualmente sería con un bucle for:

for elemento1, elemento2 in diccionario:

print(elemento1, diccionario[elemento1])
#(elemento1 es la clave, y elemento2 sería el valor)

Para eliminar elementos de un diccionario usamos la función del diccionario[key1] , con esto elimina tanto la clave como el
valor asociado. También se puede eliminar el diccionario completo con del diccionario . También podemos usar la función
.clear() para eliminar todos los elementos de un diccionario y dejarlo vacío.

6.2. Códigos de ambigüedad.

A veces las bases del ADN son ambiguas (no se sabe seguro si es una G o una T, o una A o una C…), para ello existe el
código estándar de una letra (IUPAC):

-​ M = A o C.
-​ R = A o G.
 -​ W = A o T.
-​ S = C o G.
-​ Y = C o T.
-​ K = G o T.
-​ V = A, C o G.
-​ H = A, C o T.
-​ D = A, G o T.
-​ B = C, G o T.
-​ N = G, A, T o C.

Algunas funciones nuevas son: .get(clave_diccionario, salida) , si no existe la clave que nos devuelva la salida y no un
error; .sort() .

6.3. AMPLIACIÓN.
El método substring.rfind(string) devuelve el máximo índice en el que el substring es encontrado en el string.

El método complementaria=string.maketrans(‘actgACTG’, ’tgcaTGCA’) permite hacer una tabla de traducción; y con el

método secuencia.translate(complementaria) hacer la traducción.

El bucle while itera el bloque de instrucciones siempre que la condición sea cierta. Estructura similar al for pero no
necesita un elemento para cerrar el bucle.

7. BIOPYTHON.
En primer lugar usamos la función !pip install biopython para instalar el paquete. Este paquete tiene distintos objetos
como el objeto Seq, para cargarlos usamos from Bio.Seq import Seq .

La función secuencia=Seq(“ATGC”) para que la variable sea de tipo secuencia (y no string). En algunas funciones y para
llamar los nucleótidos funciona como un string.

Algunas de las nuevas funciones son: .complement() para crear la secuencia complementaria; .reverse_complement()
para la reversa complementaria; .translate() para traducir a aminoácidos.

Para comprobar si dos secuencias son iguales usamos: secuencia1 == secuencia2, en el caso de que sean iguales devuelve
True, sino False. También tenemos la función id(secuencia) que devuelve el id de cada secuencia.

Otro objeto de biopython es SeqRecord (from Bio.SeqRecord import SeqRecord). La función sirve para crear un registro de
la secuencia, ej. registro=SeqRecord(Seq(“”), name=””, id=””, description=””) .

Otro objeto es SeqIO (from Bio import SeqIO) que esta relacionado con la capacidad de manipular ficheros. Este tiene
funciones como: SeqIO.parse(fichero, “fasta”) para leer un fichero; de este podemos extraer los .id, las .seq o la
.description por separado.

Con SeqIO también podemos convertir formatos: secuencias_entrada=SeqIO.parse(fichero_entrada, formato_entrada) ;

SeqIO.write(secuencias_entrada, fichero_salida, formato_salida).

Con SeqIO también podemos filtrar las secuencias por calidad con: .letter_annotations[‘phred_quality’] .
 PROGRAMACIÓN CON R.

1. INTRODUCCIÓN A R Y RSTUDIO.
Para tener una mejor organización de nuestros trabajos podemos crear Proyectos, vamos a: File → New Project → New
Directory ; podemos abrir este nuevo proyecto en una nueva sesión. Este podemos organizarlo en diferentes directorios:

-​ data/raw : directorio con los datos del proyecto sin procesar.

-​ data/processed : datos modificados.
-​ scripts : guiones en R para el procesamiento de datos.
-​ documents : para guardar borradores, artículos…

Estos se pueden crear desde el apartado Files añadiendo carpetas.

1.1. USO DE R Y RSTUDIO.

Rstudio tiene varias ventanas con distintas funciones.

Para saber la ruta absoluta usamos el comando (función en R) getwd() y para cambiar de ruta usamos setwd(“ruta”) .

1.2. INSTALACIÓN DE PAQUETES.

-​ loadNamespaces() : nos muestra los paquetes que tenemos instalados.
-​ library(“nombre_paquete”) : nos carga en la memoria el paquete indicado. Al cerrar Rstudio se tienen que volver
a cargar. Se pone entre comillas para que no lo interprete como una variable. Para cargar varios a la vez usamos:
invisible(lapply(list.of.packages, library, character.only=TRUE)) .
-​ install.packages(“nombre_paquete”) : nos instala el paquete indicado.
-​ help(“nombre_paquete”) : para obtener información sobre paquete.

También se pueden instalar paquetes desde el menú de RStudio: Tools→ Install Packages (Repositorio (CRAN)). Siempre
es mejor instalar con todas las dependencias.

Para instalar desde GitHub o GitLab primero tenemos que instalar y cargar el paquete devtools y después usar el comando:

-​ install_github(“nombre_cuenta/nombre_paquete”)

Para evitar cargar la librería devtools, también se puede usar el comando:

-​ devtools::install_github(“”)

Para la instalación desde Bioconductor primero tenemos que instalar el paquete BiocManager. En nuestra versión de R
tenemos que instalar la versión 3.12 de Bioconductor, para eso se usa el comando:

-​ if (!require("BiocManager", quietly = TRUE))

install.packages("BiocManager")
BiocManager::install(version = "3.12")
En este también podemos evitar cargar BiocManager y para instalar paquetes usar el comando:

-​ BiocManager::install(“”)
 -​ BiocManager::valid() : sirve para verificar la instalación.

Ej. BiocManager::install("phyloseq", version = BiocManager::version())

2. FUNCIONES.
Una función es un conjunto de instrucciones que convierten las entradas (inputs) en resultados o salidas (outputs). Partes:

-​ Argumentos: Sirven para ingresar información necesaria para realizar el procedimiento de la función. Pueden
estar vacíos (y el usuario les ingresa un valor) o tener un valor por defecto.
-​ Cuerpo: Formado por un conjunto de instrucciones que transforman las entradas en las salidas deseadas. Si tiene
varias instrucciones deben ir entre llaves {}.
-​ Salidas: Resultados de la función. Si tiene varios resultados se organiza en una lista.

Ej.​ DNI <- function(numero) {

letras <- c(“T”,”R”,”W”,”A”,”G”,”M”,”Y”,”F”,”P”,”D”,”X”,”B”,”N”,”J”,”Z”,”S”,”Q”,”V”,”H”,”L”,”C”,”K”,”E”)
letras <- letras[numero %% 23 + 1]
return(letras)
}

3. ESTRUCTURA DE DATOS.
3.1. TIPOS DE DATOS.
Hay 6 tipos de datos básicos:

-​ character : “a”, “abc def”.

-​ numeric (real o decimal) : 1, 1.5.
-​ integer (numero entero) : 1L.
-​ logical(true or false) : TRUE (1), FALSE (0).
-​ complex : 1+2i.
-​ raw (se representa en binario, 0s y 1s).

R proporciona una serie de funciones para examinar características de vectores y otros objetos:

-​ class() : ¿qué tipo de objeto es (alto nivel)? (es un vector, una lista…)
-​ typeof() : ¿cuál es el tipo de datos del objeto (bajo nivel)? (cada elemento que es: caracter, numerico…)
-​ length() : ¿cuántos elementos tiene?
-​ atributes() : ¿tiene metadatos?

3.2. ESTRUCTURAS DE DATOS.

3.2.1. VECTORES.
Un vector es la estructura de datos más básica y común en R. Es una colección de elementos del mismo tipo. Pueden ser
caracteres, lógicos, enteros o numéricos. Puede ser de dos tipos:

-​ Vectores atómicos y matrices.

-​ Listas.
3.2.1.1. CREACIÓN DE VECTORES.
Se puede crear un vector vacío con la función vector() que por defecto será lógico.

A este se le pueden añadir argumentos como el tipo de dato y la longitud del vector (el número de elementos), ej.
vector(mode=“character”, length=4) esto crea el vector: “” “” “” “”. Podemos obviar las igualdades (mode= o length=)
siempre que pongamos los argumentos por orden, ej. vector(“character”, 4). También tenemos funciones que
directamente especifican el tipo de datos como character(), numeric(), logical(), ej. para obtener el resultado anterior
sería: character(4).

Para crear vectores indicando cada uno de sus elementos usamos: variable=c(1, 2, 3, 4) (el igual es equivalente a <-).
También se puede crear una secuencia usando dos puntos : ej. variable = 1:4 o seq(1:4). Con la función seq() podemos
añadirle los elementos (from= , to= , by=) que indica desde que numero, hasta que número, y con que paso: ej. seq(from=1,
to=6, by=2) el resultado es: 1, 3, 5 ; sería equivalente a seq(1, 6, 2).

3.2.1.2. EXAMINANDO VECTORES.

Tenemos las funciones typeof() para ver el tipo de datos de los elementos; length() indica el número de elementos del
vector; class() nos da el tipo de vector; str() nos da información resumida del vector.

3.2.1.3. AGREGAR ELEMENTOS.

Para agregar elementos a un vector usamos la función c(). Podemos agregar elementos al principio o al final según donde
coloquemos el vector existente. Ej. variable= c(0, variable, 5, 6).

3.2.1.4. MISSING DATA.

Los missing data se representan con NA (Not Available). Este se indica sin ir entre comillas, sino lo representa como
cadenas de caracteres (igual que con TRUE o FALSE).

La función is.na() indica los elementos que tienen el valor NA en un vector (el resultado lo muestra en TRUE o FALSE
dependiendo de si es o no NA); y anyNA() retorna TRUE si el vector contiene algún missing value. mean(x, na.rm=TRUE)
nos elimina los NA del vector.

3.2.1.5. VARIOS TIPOS EN UN VECTOR.

En un mismo vector no pueden haber varios tipos de datos, por tanto si nosotros mezclamos números con letras va hacer
una conversión para que todos sean del mismo tipo. Ej. variable=c(1. 1.5, “a”) va a convertir los números en caracteres (los
pondrá entre comillas).

Para controlar esta conversión podemos usar la función as.numeric() o as.character().

3.2.1.6. SUBSETTINGS.
Para extraer elementos del vector que cumplan una cierta condición usamos: (imaginando: variable= c(1, 2, 3, 4, 5, 7).

-​ variable > 4 , esto nos devuelve un vector lógico: FALSE FALSE FALSE FALSE TRUE TRUE .
-​ variable[variable>4] , retorna: 5 7 .
-​ which(variable>4) , retorna las posiciones en las que se cumple la condición (empezando por 1): 5 6 .
También podemos extraer valores concretos, rangos o concatenar usando corchetes: variable[6] retorna 7 ; variable[2:4]
retorna 2 3 4 ; variable[c(2,4)] retorna 2 4 .

3.2.1.7. OPERACIONES CON VECTORES.

Suma (+), Resta (-), Producto (*), Producto escalar (%*%), División (/), Módulo o resto (%), Suma de elementos (sum()).

Si hacemos operación con vectores se hace el primer elemento de un vector con el primer elemento del otro vector, el
segundo con el segundo…

También podemos hacer operaciones estadísticas con funciones como: media mean(); mediana median(); máximo max();
mínimo min(); cuantiles quantile(); coeficiente de correlación cor(); suma acumulada cumsum(); producto acumulado
cumprod(); diferencias diff().

3.2.2. MATRICES.
Las matrices son una extensión de los vectores numéricos o de caracteres. Son vectores con dimensiones, filas y columnas.

Estas se crean: variable=matrix(c(), nrow=n, ncol=m, byrow=FASLE, dimnames=NULL). Los elementos por defecto se
añaden por columnas, esto lo indica el argumento byrow (que no tenemos que ponerlo); para cambiarlo pondríamos
byrow=TRUE. Podemos añadir valor a dimnames si queremos poner nombre a las filas y columnas (sino no se indica; se
pone primero el nombre de las filas y después el de las columnas, ej. list(c(“F1”,”F2”), c(“C1”,”C2”))).

Con la función dim() nos devuelve las dimensiones de la matriz (filas y columnas); con class() nos devuelve que es una
matriz y lista (“matrix” “array”); con typeof() nos indica el tipo de elementos.

La función dim() también nos permite transformar un vector en una matriz, ej. dim(variable) = c(nfilas, mcolumnas).

Para combinar vectores distintos en una matriz se usan las funciones cbind() (los une por columnas) y rbind() (por filas).

Para asignar nombres a las filas o columnas usamos las funciones: rownames(variable)=c(“Fila1”, “Fila2”) o colnames().

3.2.2.1. EXTRACCIÓN DE ELEMENTOS.

Es parecido a los vectores, solo que en este caso tenemos que indicar la fila y la columna variable[nfila, mcolumna]. Si
tenemos nombres asociados a las filas y columnas se indica. También se puede obtener toda una fila o toda una columna
indicando solo este parámetro, ej. variable[2, ] nos muestra todos los elementos de la fila 2.

3.2.2.2. OPERACIONES CON MATRICES.

3.2.2.2.1. OPERACIONES MATRIZ CON ESCALAR.

Realiza la operación con ese valor en cada uno de los elementos de la matriz. variable + 1 , suma 1 a todos los elementos de
la matriz.

3.2.2.2.2. OPERACIONES MATRIZ CON MATRIZ.

En este caso las dos matrices tienen que tener las mismas dimensiones. En este, el primer elemento de una matriz realiza
la operación con el primer elemento de la otra matriz, el segundo con el segundo…
Para hacer una multiplicación real de matrices se usa %*%. En este caso se multiplica la fila de la primera matriz por la
columna de la segunda matriz, por tanto, la primera matriz tiene que tener el mismo numero de filas que el número de
columnas de la segunda. Para esto, de dos matrices iguales podemos hacer la transpuesta de la segunda: t(matriz2).

3.2.2.2.3. FUNCIONES PARA MATRICES.

-​ colSums() : Vector de sumas de columnas.

-​ rowSums() : Vector de sumas de filas.
-​ colMeans() : Vector de medias de columnas.
-​ rowMeans() : Vector de medias de filas.
-​ apply(X, MARGIN, FUN, simplify=TRUE) : Permite aplicar funciones sobre filas o columnas de una matriz.
-​ X : Vector incluyendo matrices.
-​ MARGIN : Proporciona los subíndices sobre los que se aplica la función, ej. c(nfilas, mcolumnas). Se
puede especificar solo la dimensión sobre la que queremos que actúe: 1 (filas) o 2 (columnas).
-​ FUN : Función a ser aplicada. Algunas como mean (media), sd (desviación estandar), max.
-​ simplify : Argumento lógico que indica si los resultados deben simplificarse a ser posible.

3.2.3. LISTAS.
Las listas son contenedores y (a diferencia de los vectores) no hay restricción en cuanto al tipo de elemento. Para crear una
lista usamos la función list() o hacer una conversión de otro objeto a una lista mediante la función as.list().

Se le pueden asignar nombres a los distintos componentes de una lista con la función names(lista)<-c(“Nombre elemento
1”,”Nombre elemento 2”). Con esto podemos llamar cada elemento de la lista mediante su nombre. Esto se puede hacer
directamente al crear la lista, ej. list(Nombre_elemento_1=”Elemento 1”, “Nombre elemento 2”=”Elemento 2”).

Con la función str() podemos visualizar de una manera más clara la lista y información sobre esta. Esta función se puede
aplicar para otro tipo de objetos. También está la función View() que abre un panel con información del objeto. Además,
para obtener el número de componentes de una lista usamos la función length().

3.2.3.1. INDEXACIÓN.
Para extraer elementos de una lista podemos usar:

-​ [ ] , equivalente a los vectores. Si añadimos un menos a la función c() me muestra todos los componentes excepto
los indicados, ej. lista[-c(1,2)] me muestra todos los elementos de la lista excepto el 1 y el 2. También podemos
indicar que nos muestre un elemento usando el nombre asignado o TRUE o FALSE en cada uno de los elementos
según si queremos que extraerlo o no, ej. lista[-c(“Nombre1”,”Nombre2”)] o lista[c(FALSE, FALSE, TRUE)]. Al
extraer los elementos de este modo reporta una lista con el resultado y con esta no podemos hacer operaciones.
-​ [[ ]] o $, nos permite acceder al contenido de un único componente de la lista para trabajar con este.

3.2.3.2. MANIPULACIÓN DE LISTAS.

Para agregar un elemento a la lista o modificarlo le indicamos el índice, ej. lista[n]<-”Nuevo elemento” ; para eliminarlo
ponemos NULL.
3.2.3.3. FUNCIONES QUE DEVUELVEN LISTAS.
Muchas funciones devuelven listas:

-​ hist() , nos devuelve una gráfica histograma.

-​ lapply() , permite aplicar una función a los distintos componentes de una lista.

((HAY MAS PERO LO HA EXPLICADO MAL, SON COMO EN DATAFRAME MAS O MENOS; CLASE 4))

3.2.4. DATA FRAME.

Tiene filas y columnas pero los datos pueden ser de distintos tipos.

3.2.4.1. CREACIÓN DE DATA FRAME.

Se crean importando datos con read.csv() (se le indica el separador que se esta usando) y read.table() .

Si todos los datos son del mismo tipo se puede pasar a un matriz usando data.matrix() o as.matrix() .

Para crear un data frame a mano se usa: data.frame(columna1 = c(”dato1”, “dato2”), columna2 = c(“dato1”, ”dato2”)) .
Se les puede asignar nombre a las filas mediante rownames() , sino se le asigna un número por defecto.

3.2.4.2. FUNCIONES PARA VISUALIZAR.

-​ head() , retorna los primeros 6 elementos (filas) del dataframe.
-​ tail() , los últimos 6.
-​ dim() , las dimensiones (filas y columnas).
-​ nrow() , número de filas.
-​ ncol() , número de columnas.
-​ str() , estructura (nombre, tipo y previsualización de los datos de cada columna).
-​ names() o colnames() , muestra los atributos nombres del dataframe.
-​ lapply(dataframe, class) , lista con la clase de cada columna.
-​ sapply(dataframe, class) , clase de cada columna de una forma más amigable.
-​ View() , visualización de los datos en forma de tabla en una nueva pestaña.
-​ summary() , naturaleza de los datos y resumen estadístico.
-​ Podemos exportar el dataframe mediante la función write_xlsx() del paquete writexl. Para instalarlo:
list.of.packages = c(“writexl”) ; new.packages = list.of.packages[!(list.of.packages %in% installed.packages())] ;
if(length(new.packages)>0) install.packages(new.packages) ; invisible(lapply(list.of.packages, FUN=library,
character.only=TRUE)) .

3.2.4.3. EXTRACCIÓN DE DATOS.

Se puede hacer al igual que con las matrices, indexando filas y columnas entre corchetes: dataframe[n,m] .

También podemos usar doble corchete para que nos de todos los elementos de una determinada columna: dataframe[[n]] .
Usar el nombre de la columna o fila para visualizar su contenido: dataf$columna1 . O indicar solo una fila, una columna, un
rango de filas/columnas o varias específicas: dataf[n,] ; dataf[,m] ; dataf[n:m,] ; dataf[c(n,m),] . Si añadimos un menos
delante del numero de la fila o la columna excluirá esa fila o columna: dataf[-n,m]
También podemos seleccionar datos específicos que cumplan ciertas condiciones usando >, <, == o != ; y podemos poner
varias condiciones usando &.

3.2.4.4. EXPANSIÓN DE DATA FRAME.

Para agregar datos al dataframe usamos:

-​ Columnas: dataf$nombre_columna=c(dato1, dato2) .

-​ Filas: Creamos un nuevo dataframe con los mismos nombres de columnas y los nuevos datos, y usamos la
función rbind(dataframe1, dataframe2) (se debe guardar en un nuevo objeto).

3.2.5. FACTORES.
Objetos de datos que se utilizan para categorizar los datos y almacenarlos como niveles. Pueden almacenar tanto cadenas
como enteros. Son útiles en las columnas que tienen un número limitado de valores únicos (ej. Masculino/Femenino,
Verdadero/Falso); o en el análisis de datos para el modelado estadístico.

Para crearlos se usa la función factor() tomando un vector como entrada (vector <- c(dato1, dato2) ; factor(vector) ) (se
debe guardar en un nuevo objeto). Para saber si un vector es factor se usa la función is.factor(vector) que devuelve TRUE o
FALSE. Para hacer factor a un campo de un dataframe se usa la función as.factor(dataf$campo) .

Para ver los distintos niveles de un objeto usamos la función levels() (ej. hombre y mujer), y para el número de niveles
nlevels() (ej. 2). Para establecer un orden en los niveles (por defecto se hace por orden alfabético) se debe especificar el
argumento levels dentro de la función factor(vector, levels=c(dato1, dato2, dato3)) (ej. factor(colesterol, levels=c(low,
medium, high))).

Si se aplican funciones estadísticas sobre objetos factor nos reporta un error. Para solucionarlo añadimos otro argumento,
ordered=TRUE , para usar el factor como valores con orden: factor(vector, ordered=TRUE) .

4. CONDICIONALES Y BUCLES.
4.1. OPERADORES LÓGICOS.
-​ x | y​ ​ x O y es verdadero. Devuelve TRUE si algún dato es cierto y FALSE si ambos son falsos.
-​ x & y​ ​ x Y y son verdaderos. Devuelve TRUE si ambos datos son ciertos y FALSE si alguno es falso.
-​ ! x​ ​ x no es verdadero (negación).
-​ isTRUE(x)​​ x es verdadero (afirmación).

4.2. ESTRUCTURAS CONDICIONALES.

4.2.1. IF.
Decide entre varias opciones en función de si se cumplen o no determinadas condiciones. Estructura:

if (condición) {código} else {otro_código}

4.2.2. FOR.
Permite ejecutar un bucle. Estructura:
 for (elemento in objeto) {operación con elemento}

4.2.3. WHILE.
Bucle que ocurre mientras una condición es verdadera. Estructura:

while (condición) {código}

4.2.4. BREAK Y NEXT.

-​ break , permite interrumpir un bucle.
-​ next , nos deja avanzar a la siguiente iteración del bucle, saltándose la actual.

Ambos sirven tanto para for como para while,

5. PROCESAMIENTO DE DATOS.
5.1. INSTALACIÓN DEL TIDYVERSE.
El tidyverse es una nueva forma de afrontar el análisis de datos usando un grupo de paquetes como:

-​ readr para importar datos.

-​ tidyr para convertir datos a tidy data.
-​ dplyr para manipular datos.
-​ ggplot2 para hacer gráficos.
-​ stringr para trabajar con cadenas.

Este se instala usando install.packages(“tidyverse”) .

5.2. DPLYR.
Paquete para manipular datos de forma intuitiva. Tiene un grupo de funciones o verbos que hacen una sola cosa y por tanto
se tienen que ir concatenando mediante el operador pipe (%>%; similar a | en Linux).

Todas las funciones tienen una estructura similar:

-​ El primer argumento siempre es un dataframe.

-​ Los siguientes argumentos describen que hacer con los datos.
-​ El resultado es siempre un nuevo dataframe.

Las principales funciones son:

-​ filter() : permite seleccionar filas que cumplen una o varias condiciones.

-​ arrange() : reordena las filas.
-​ rename() : cambia los nombres de las columnas o variables.
-​ select() : selecciona columnas.
-​ mutate() : crea nuevas variables.
-​ summarise() : resume (colapsa) unos cuantos valores a uno sólo. Por ejemplo, calcula la media, moda…
-​ group_by() : permite agrupar filas en función de una o varias condiciones.
5.2.1. OPERAPOR PIPE %>% .
El pipe %>% permite encadenar funciones. Pasa lo que esta a su izquierda como argumento para lo que está a la derecha.
Estructura: dataframe %>% funciones_sobre_dataframe ; ej. dataframe %>% head(n=5) (en vez de head(dataframe, n=5) .

5.2.2. FILTER() .
filter() permite seleccionar filas que cumplen una o varias condiciones. Estructura: dataf %>% filter(columna1==”dato”)
(es igual a: dataf[dataf$columna1==”dato”] ) . Para poner varias condiciones usamos: condición1 | condición2 .

Para indicar varias condiciones las separamos mediante: i representado mediante una coma o & ; o representado por | .

Si queremos seleccionar datos entre n y m podemos usar la función between() dentro de filter() , ej. dataf %>%
filter(between(columna1, n, m)) .

5.2.3. ARRANGE() .
arrange() reordena las filas de un dataframe. Por defecto ordena los datos de menor a mayor. Estructura: dataframe %>%
arrange(columna1) . Para que ordene de mayor a menor usamos la función desc() : dataframe %>%
arrange(desc(columna1)) .

Se pueden indicar dos columnas para que, en el caso de que por la primera dos datos coincidan, el segundo criterio para
ordenar sea la segunda columna indicada : dataframe %>% arrange(columna1, columna2) .

5.2.4. SELECT() .
select() selecciona columnas de un dataframe. Estructura: dataframe %>% select(columna1, columna2) .

5.2.5. MUTATE() .
mutate() sirve para crear nuevas variables (columnas). Estructura: dataframe %>% mutate(nueva_variable =
columna1+columna2) . Estas nuevas columnas se crean haciendo cálculos con columnas existentes y se añaden al final del
dataframe.

5.2.6. SUMMARISE() .
summarise() sirve para resumir o colapsar filas. Coge un grupo de valores como input y devuelve un solo valor (ej. media,
mínimo, máximo…). Estructura: dataframe %>% summarise(variable_nueva = función(columna1)) . La función puede ser
mean() , para sacar la media; n() , para saber el número de filas; sd() , desviación típica; max() , máximo…

5.2.7. GROUP_BY() .
group_by() coge un dataframe y lo convierte en un dataframe agrupado para que las operaciones que hagamos con
summarise lo haga para cada uno de los grupos definidos (ej. cálculos separados para Hombres y Mujeres, o por Países…).

Estructura: dataframe %>% group_by(columna1) .

Ej. dataframe %>% group_by(Países) %>% summarise(nfilas=n()) ; para saber el número de filas que hay por país.
dataframe %>% group_by(sexo) %>% summarise(media=mean(edad)) ; para la media de edad de hombres y mujeres.
5.3. TIDYR.
La mayoría de datos son de tipo tabular, organizados en filas y columnas, almacenados en dataframes (o tibbles). Un
dataframe será tidy si cada columna es una variable y cada fila es una unidad de análisis (persona, país, región…), es decir,
cada celda contiene un valor de una variable para una unidad de análisis.

Los datos tidy pueden estar en formato: Wide (ancho) ; o Long (los paquetes del tidy trabajan mejor con este). Si tenemos
un formato wide lo pasamos a long mediante funciones.

Ej. tidy wide , columnas: nombre salario_año1 salario_año2 , filas: datos ; tidy long , columnas nombre años salario , filas:
datos repetidos (antes había ej. Pedro 1994 1996 ; y ahora Pedro 1994 , Pedro 1996).

5.3.1. WIDE A LONG - GATHER() .

gather() pasa del formato tidy wide a tidy long. Estructura: dataframe %>% gather(columna1, columna2, n:m) ; con esto
indicamos el nombre de las columnas nuevas y el rango de columnas que queremos transformar (de la n a la m) (también
podemos seleccionar todas las columnas menos una: -nombre_columna). Ej. dataframe %>% gather(años, salario, 2:3) .

Si queremos cambiar los datos usamos mutate() y str_replace(columna, “busqueda”, “reemplazo”) . Ej. dataframe %>%
mutate(años=str_replace(años, “salario_”, “”)) . Esto se consigue con la librería stringr.

5.3.2. LONG A WIDE - SPREAD() .

spread() pasa del formato tidy long a tidy wide. Estructura: dataframe %>% spread(columna1, columna2) ; con esto
indicamos el nombre de las columnas que queremos fusionar. Ej. dataframe %>% spread(años, salario) .

5.4. OTROS. (SESIÓN 21/12/2023).

rm() para borrar objetos. unlink() para eliminar archivos. download.file(URL, destfile=”nuevo_nombre_archivo”) para
descargar un archivo y ponerle nombre. gunzip() para descomprimir archivos. (También en la sesión 9).

Mediante el paquete seqinr usamos la función read.fasta(file=”archivo”) , ej. seqinr :: read.fasta(file=”archivo”) . (También
se puede hacer para otras extensiones como .csv, ej. read.csv(file=”archivo”) ). Esto es para importar los datos.

length(objeto) me muestra el numero de elementos de un objeto.

Dentro de un print() podemos usar un paste() para unir cadenas con el resultado de una función.

La función GC() nos muestra el contenido de GC. Esto lo podemos poner dentro de un aplay para que me lo haga en cada
elemento de un objeto, ej. sapply(objeto, FUN=GC) . Esto también lo podemos hacer con la función count() que muestra la
cantidad de A, T, C, G (dentro del sapply nos lo mostraría de cada secuencia). Estas dos funciones también son de seqinr.

Con el paquete tibble podemos usar la función rownames_to_column() para cambiar filas por columnas.

Con la función c2s() pasamos de caracteres a string.

También hay muchas funciones str_() útiles para el sapply(), usar un help() para verlas.

La función unique() nos muestra un único caracter de cada uno de los caracteres que hay. (después pone algo para
eliminar un caracter pero no lo termino de ver). .
6. GRÁFICOS.
R tiene diversos motores gráficos, conjuntos de funciones que permiten realizar manipulaciones gráficas básicas: generar
lienzos (o canvas), trazar líneas, dibujar puntos…

Algunas de las funciones de R son plot, hist, barplot, boxplot… pero hay otro motor gráfico menos tradicional que permite
crear gráficos Trellis o enrejados, que permiten seguir el comportamiento de unas variables de interés a través de los
distintos niveles de otras, disponiendo la información en una retícula que facilita el descubrimiento de patrones por
inspección visual (los gráficos enrejados permiten seguir el comportamiento de unas variables de interés a través de los
distintos niveles de otras; ej. gráfico que tiene varias variables y las separa hombres y mujeres).

6.1. GRAFICAR CON GGPLOT2.

ggplot2 es un paquete para graficar que facilita crear gráficos complejos a partir de un dataframe. Funciona mejor con
datos en formato long. Al ser parte del tidyverse, funciona mejor con los datos organizados de modo que las observaciones
individuales estén en filas, y las variables en columnas.

Estructura: ggplot(data = , mapping = aes()) + () . Mediante el argumento data se indica a partir de que datos se crea la
gráfica; aes() se usa para seleccionar las variables a graficar y como presentarlas (variables (columnas) y característica de
los ejes x e y, van separados por coma, ej. aes(x=columna1, y=columna2)).

Además, ggplot2 ofrece geoms (objetos geométricos) para indicar la representación gráfica de los datos (puntos, líneas y
barras). Algunos son: geom_point() , para gráficos de dispersión; geom_boxplot() , para gráficos de caja; geom_line() ,
para líneas de tendencia, series de tiempo; geom_violin() ; geom_histogram(), usa por defecto stat_bin para dibujar las
barras (intervalos de las barras (más o menos anchas)); geom_bar() cuenta el número de valores para calcular la altura de
cada barra (para vincular la altura a otra variable cuantitativa tenemos que indicar dicha variable en aes y cambiar el stat
(en geom_bar) (Sesió 8, 59); también tenemos el geom_smooth() que ajusta un modelo lineal a una recta de regresión…
Esto se agregan después del + . Se pueden combinar los geom.

Los geoms también pueden tener argumentos para visualizar mejor la gráfica, ej. el argumento shape, para geom_point,
para cambiar el tipo de punto por defecto (circulo relleno) por un círculo que solo dibuja el perímetro (evita el overploting);
ej. + geom_point(shape=n). El parámetro alpha permite agregar transparencia a los puntos; el position=”jitter”
distribuye los puntos aleatoriamente en el eje x sin que la posición sea significativa (evita el overplotting). También se
puede cambiar el color de los puntos con color; o colours dentro del aes() para especificar sobre que otra variable
queremos diferenciar. También tenemos linewidth para cambiar el ancho de las líneas. Para geom_histogram se puede
modificar el tamaño de los bins (contenedores) con el parámetro bins o su ancho con binwidth; también se puede cambiar
la densidad total del conteo con after_stat(density) .

Para agregar etiquetas a los ejes, detrás de otro + , usamos labs(title=”Nombre de la gràfica”, x=”Titulo X” , y= “Título Y”) .

Otro tipo de funciones para agregar color a los gráficos es: + scale_color_x() , donde x puede ser manual, brewer, grey…
Dentro de este se pueden especificar varios argumentos como: values=c(color1, color2, colorn) según el número de
etiquetas; o labels=c(etiqueta1, etiqueta2) para las etiquetas de la leyenda; palette (según la scale_color_x usada)…

También tenemos + xlab(“Título X”); ylab(“Título Y”); scale_x_continuos() o scale_y_continuos(labels=function(x)

format(x, scientific=FALSE)) para cambiar los datos de cada eje de científico a número normal (Sesión 8. 1:50)…
Por último, para guardar un gráfico en un archivo usamos ggsave(archivo.png). También podemos guardar todo el gràfico
en un objeto (x= ggplot()...), después se usa la función: pdf(“nombre nuevo archivo.pdf”, width=x, height=y, bg=white) x
dev.off() ; donde width y height es el ancho y alto en pulgadas, bg es el color de fondo y x el objeto donde hemos guardado
la gráfica; además, dev.off() cierra la función. También se puede hacer en formato png() , donde en vez de especificar bg
especificamos las unidades con ej. units=”px”. También en jpeg() , donde en vez de bg, se especifica la calidad: quality.

6.2. VINCULAR VARIABLES A AES.

Para que un argumento se vincule a cada uno de los grupos dentro de una variable (o columna, ej. hombres y mujeres) se
debe asignar la variable dentro de aes() , ej. aes(x=columna1, y=columna2, colour=columnax) . Si se pone fuera del aes()
se asignará un único valor a todas las observaciones.

6.3. FACETING.
El faceting es una técnica que permite dividir un gráfico en múltiples gráficos, basado en un factor incluido en el conjunto
de datos. Se escribe detrás de otro + , facet_grid() . Según si queremos que este factor esté separado por filas o columnas
usamos ~. antes o después: Factor en las filas, + facet_grid(factor ~.) ; Factor en las columnas + facet_grid(~. factor) .

##Para cargar archivos en formato excel usamos la librería: readxl ; y la función read_xlsx() . (Sesión 8, 1:30)

6.4. OTROS. (SESIÓN 12/01/2024).

Con el paquete GEOquery tenemos varias funciones como: getGEO(GEO=”nombre”, GSEMatrix=”TRUE”) donde en nombre
le indicamos el conjunto de datos de la tabla con los que vamos a trabajar y después una de las diferentes opciones que
tiene como GSEMatrix para crear una matriz de estos datos. Esto puede dar un problema en el tamaño del buffer de
conexión que se soluciona con: Sys.setenv(“VROOM_CONNECTION_SIZE”=131072*1000) .

Para la extracción de metadata usamos: pData(phenoData(matriz[[n]])) .

Para seleccionar ciertas columnas usamos: nombre_metadata_extraido %>% select(c(n1,n2,n3)) . Además, podemos
renombrar el título de las columnas mediante: rename(nombre_nuevo=nombre antiguo) . También podemos modificar los
datos mediante: mutate(nombre_columna = gsub("motivo anterior","motivo nuevo", nombre_columna)) , esto ocurre
para todos los datos de la columna indicada. En concreto, mutate() se usa para crear, modificar o eliminar columnas, y
gsub() busca el patrón y lo reemplaza.

Después para unir datos usamos la función join() (puede ser tanto left_join() como right_join() ). Ej. left_join(x, y,
by=c(“columna_datos1” = “columna_datos2”)) ; donde x e y son los diferentes datos a unir (en el caso de usar datos
%>% y después el join podríamos poner un punto . en el lugar de la x), y en el by indicamos el nombre de la columna que
se va a fusionar/combinar de cada conjunto de datos.

6.5. OTROS. (SESIÓN 16/01/2024).

stat_poly_line() ; stat_poly_eq(use_label(c("eq", "R2"))) ; scale_fill_gradient(low="color1", high="color2") .

ACTUALISAR R
posit.co/download/rstudio-desktop Fedora 19/Red hat 7
o
wget -O rstudio-latest-x86_64.rpm download1.rstudio.org/electron/centos7/x86_64/rstudio-2023.12.0-369-x86_64.rpm
sudo yum install --nogpgcheck rstudio-latest-x86_64.rpm