Regresión lineal y series de tiempo con Python y R

library(knitr)
include_graphics("images.jpg")

R es un conjunto de programas para cálculo numérico, creación de gráficos, manipulación de datos, análisis estadísticos, aprendizaje automático, entre muchas otras más. Iniciaremos el curso indagando en los conceptos más fundamentales (como lenguaje de programación) del mismo para enfocarnos en temas de probabilidad y análisis estadístico.

Conceptos básicos

Artimética

Comenzaremos viendo que R puede realizar de manera directa operaciones como si fuera una calculadora:

# Esto es un comentario, solo sirve para hacer anotaciones en nuestras celdas de codigo.
# ------
# SUMA
41 + 8

## [1] 49

# MULTIPLICACION
4 * 7

## [1] 28

# DIVISION
14 / 7

## [1] 2

# POTENCIA
2 ** 3

## [1] 8

Resaltamos que R ejecuta el código de arriba hacía abajo. Además, una alternativa para ** a la hora de la exponenciación es el símbolo ^

# POTENCIA (ALTERNATIVA)
2 ^ 3

## [1] 8

Para el operador de residuo utilizamos %%. Por ejemplo, el residuo de efectuar la división $\frac{5}{2}$ es uno, por lo cual

5 %% 2

## [1] 1

Variables

Podemos utilizar variables para almacenar información. Por ejemplo, en la celda de código anterior obtivimos el residuo de dividir 5 entre 2, pero puede ser que querramos almacenar dicho valor en una variable para utilizarla después. Para asignar un valor a una variable utilizamos el operador <-, o equivalentemente el operador =. Éstos significan exactamente lo mismo: asignación.

# Asignamos a la variable x el valor resultante de 5 %% 2
x <- 5 %% 2

Ahora podemos utilizar la variable x en celdas de código posteriores:

# Al residuo de dividir 5 entre 2, le sumamos un 10
x + 10

## [1] 11

Apesar de que a x le sumamos un 10, el valor de x sigue siendo el mismo

## [1] 1

Si queremos almacenar un resultado, deberemos asignarlo a una variable

# Definimos una nueva variable con la notacion alternativa de =
y = x + 10
# Veamos el valor de la variable y
y

## [1] 11

En ese caso, asignamos el resultado de x+10 a la variable y. No obstante, podemos redefinir variables, esto es, podemos actualizar o cambiar el valor de x. Por ejemplo, por el momento sabemos que x vale 1, pero puede ser de nuestro interés que ahora valga 1, lo cual hacemos simplemente escribiendo

# Cambiamos el valor almacenada de la x
x <- 11
# Veamos el valor actual de la x
x

## [1] 11

Podemos operar aritméticamente con las variables

# Potencia
y ^ x

## [1] 285311670611

Vectores

Los vectores representan conjuntos de datos ordenados, por ejemplo $(1,5)$ es un vector, o también $(0,1,5,4.2)$ es un vector, donde vemos que están ordenados pues, para $(1,5)$, tenemos que el número 1 está en la primera posición (o entrada) del vector y el 5 en la segunda posición. Definimos vectores en R utilizando la función c(). Por ejemplo

# Definimos dos vectores
vector1 <- c(1, 5)
vector2 <- c(0,1,5,4.2)
vector3 <- c(2, -8)

# Veamos los vectores
vector1

## [1] 1 5

vector2

## [1] 0.0 1.0 5.0 4.2

vector3

## [1]  2 -8

Podemos operar aritméticamente los vectores, donde las operaciones se harán entrada a entrada. Por ejemplo:

# Sumamos dos vectores
vector1 + vector3

## [1]  3 -3

donde la suma se realizó entrada a entrada.

# Multiplicamos dos vectores
vector1 * vector3

## [1]   2 -40

Etcétera. Podemos obtener el número de elementos que tiene un vector utilizando la función length()

# Numero de elementos de cada vector
length(vector1)

## [1] 2

length(vector2)

## [1] 4

length(vector3)

## [1] 2

Ya vimos cómo sumar dos vectores, pero también podemos sumar todas las entradas de un vector. Por ejemplo:

# Definimos un vector nuevo
ganancias <- c(100, 1500, 20)
# Suma de las ganancias
sum(ganancias)

## [1] 1620

O también podemos obtener el promedio de las entradas de un vector

# Promedio de las ganancias
mean(ganancias)

## [1] 540

Podemos ordenar el vector de menor a mayor con la función sort()

sort(ganancias)

## [1]   20  100 1500

o de mayor a menor

sort(ganancias, decreasing = TRUE)

## [1] 1500  100   20

Veamos que los vectores en R son muy vérsatiles, y de hecho serán de gran utilidad al utilizarlos como estructuras de datos. Podemos agregar elementos nuevos a un vector, utilizando la función append():

# Al vector de ganancias le agregamos una nueva entrada 
#                nueva entrada
#                al vector
append(ganancias, 70)

## [1]  100 1500   20   70

Generación de secuencias

Supongamos que definimos el vector

vect1 <- c(1,2,3,4,5,6,7,8,9)
vect1

## [1] 1 2 3 4 5 6 7 8 9

puede ser una labor tediosa definir un vector que contenga todos los números enteros del 1 al 100, así como lo definimos manualmente para el caso del 1 al 9. Para ello podemos generar secuencias de números:

# Secuencia de enteros del 1 al 9
1:9

## [1] 1 2 3 4 5 6 7 8 9

O también

# Secuencia de enteros del 1 al 100 almacenada en una variable
seq1 = 1:100
seq1

##   [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
##  [19]  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
##  [37]  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
##  [55]  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
##  [73]  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
##  [91]  91  92  93  94  95  96  97  98  99 100

Donde en las secuencias anteriores el incremento es de uno en uno. Como alternativa para crear secuencias, podemos utilizar seq(). Así, 1:100 es totalmente equivalente a seq(1, 100). Con la función seq() podemos modificar el incremento

Podemos modificar el incremento:

# Secuencia del 1 al 9 modificando el incremento
seq2 <- seq(1, 9, by=0.5)
seq2

##  [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0

Tipos de datos

Los números enteros y decimales son tipos de datos numéricos (numeric). Existen otros tipos de datos importantes con los cuales trabajaremos:

Cadenas de texto (character): Nos permiten colocar lenguaje natural (lenguaje que utilizamos entre nosotros para comunicarnos) dentro de las celdas de código, para lo cual encerramos el texto entre comillas dobles o simples. Por ejemplo

# Definimos una variable del tipo character
saludo <- "Hola Mundo"
saludo

## [1] "Hola Mundo"

Booleanos (logical): Son datos lógicos, los cuales solo pueden ser o TRUE (verdadero) o FALSE (falsos).

# Definiendo una variable booleana
esta_lloviendo <- FALSE
esta_lloviendo

## [1] FALSE

Notemos que escribimos esta_lloviendo uniendo las palabras mediante el guión bajo pues, no podemos definir variables dejando espacios en blanco:

# Obtendremos un error:

# Definiendo una variable booleana
esta lloviendo <- FALSE
esta lloviendo

## Error: <text>:4:6: unexpected symbol
## 3: # Definiendo una variable booleana
## 4: esta lloviendo
##         ^

Las variables booleanas son muy importantes, además de que podemos combinarlas con operadores booleanos:

Operador or (|): Considera dos variables booleanas y regresa una variable booleana, donde:
- TRUE | TRUE regresa TRUE
- TRUE | FALSE regresa TRUE
- FALSE | TRUE regresa TRUE
- FALSE | FALSE regresa FALSE

# Veamos dos ejemplos aplicando el operador or (|)
TRUE | FALSE

## [1] TRUE

FALSE | FALSE

## [1] FALSE

Operador and (&): Considera dos variables booleanas y regresa una variable booleana, donde:
- TRUE & TRUE regresa TRUE
- TRUE & FALSE regresa FALSE
- FALSE & TRUE regresa FALSE
- FALSE & FALSE regresa FALSE

# Veamos dos ejemplos aplicando el operador and (&)
TRUE & TRUE

## [1] TRUE

FALSE & FALSE

## [1] FALSE

Operador de negación (!): Considera una variable booleana y regresa una variable booleana, donde:
- !TRUE regresa FALSe
- !FALSE regresa TRUE

# Veamos un ejemplo del operador de negacion
!TRUE

## [1] FALSE

Cabe mencionar que hasta ahora para ver algún tipo de dato o una variable simplemente escribimos dicho dato o dicha variable en una línea nueva para poder verla en consola. Esto es

# Definimos una variable:
# (Podemos combinar operadores booleanos)
#               (TRUE)
bool1 <- TRUE & !FALSE
# Para ver el valor de dicha variable escribimos en una linea nueva sun nombre que le asignamos
bool1

## [1] TRUE

De manera alternativa podemos utilizar la función print() para ver los resultados en salida:

print(bool1)

## [1] TRUE

Condicionales

Los condicionales corresponden a una estructura en la cual ejecutaremos una acción si cierta condición es verdadera, y ejecutaremos otra acción para el caso en que dicha condición sea falsa. Por ejemplo consideremos la siguiente idea

Si el semáforo está en verde, entonces no cruzamos la calle. Tenemos en dicho ejemplo que la condición es “el semáforo está en verde”; si dicha condición es verdadera, entonces no cruzamos la calle; si dicha condición es falsa, cruzaremos la calle. De tal modo realizaremos alguna acción en caso de que la condición impuesta sea o no verdadera.

Podemos implementar condicionales en R siguiendo la siguiente estructura:

if (condicion) {
  acciones a realizar en caso de que la condicion
  sea verdadera
} else {
  acciones a realizar en caso de que la condicion
  sea verdadera
}

Por ejemplo

# Condicion
semaforo_en_verde = TRUE

# Implementamos el condicional if
if (semaforo_en_verde) {
  # Accion a realizar en caso de que la condicion sea verdadera:
  # Imprimieremos un mensaje
  print("No cruzar")
} else {
  # Accion a realizar en caso de que la condicion sea falsa:
  # Imprimieremos un mensaje
  print("Puedes cruzar")
}

## [1] "No cruzar"

Dado que la condición impuesta es verdadera, entonces se ha impreso el mensaje "No cruzar".

Veamos un ejemplo práctico. Escribiremos un código para determinar si un número es par o impar. Para ello utilizaremos el siguiente criterio: un número entero $n$ es par si el residuo de la división $\frac{n}{2}$ es cero. En caso contrario el número $n$ será impar. Así:

# Identificador de numeros pares e impares.
# Definimos el numero n:
n = 7
# Implementamos un condicional
if (n %% 2 == 0) {
  print("El número considerado es par")
} else {
  print("El número considerado es impar")
}

## [1] "El número considerado es impar"

donde el símbolo == significa igualdad, pues recordemos que el símbolo = significa asignación. Luego, la condición n %% 2 == 0 puede leerse como: el residuo de dividir n entre 2 es igual a 0. Lo anterior puede ser verdadero o falso, según sea el valor de $n$, lo cual nos arrojará un booleano (FALSE o TRUE).

Bucles

Bucle `for`

Como su nombre lo indica, el bucle for representa un proceso repetitivo, donde ciertas instrucciones se estarán repitiendo un número determinado de veces. Por ejemplo, consideremos un vector e imprimamos cada uno de sus elementos

# Vector con entradas de varios tipos de datos
vect2 <- c(10, 'nombre', FALSE)
# Podemos imprimir el PRIMER ELEMENTO del vector anterior colocando entre corchetes el numero 1
print(vect2[1])

## [1] "10"

# Imprimimos el segundo elemento
print(vect2[2])

## [1] "nombre"

# Imprimimos el tercer elemento
print(vect2[3])

## [1] "FALSE"

Supongamos que tenemos un vector con 100 entradas y queremos imprimir cada una de ellas. Si realizamos el mismo proceso anterior pero ahora para el vector de 100 entradas, tardaremos un tiempo considerable. Como alternativa podemos utilizar un bucle for cuya estructura básica es:

for (recorrido) {
  acción a repetir
}

Por ejemplo

# Creamos un vector 
vect_recorrido <- 1:3
vect_recorrido

## [1] 1 2 3

el cual tiene los elementos que ocupamos para acceder a todos los elementos del vector vect2. Luego implementamos el for

for (i in vect_recorrido){
  # Accion a ejecutar repetidamente
  print(vect2[i])
}

## [1] "10"
## [1] "nombre"
## [1] "FALSE"

donde la i es una variable propia del bucle for (y en realidad puede llamarse como sea). La variable del for recorrerá cada elemento del vector vect_recorrido de la siguiente manera:

Inicialmente en el bucle la i vale 1 (que es el primer valor del vector vect_recorrido) y así se ejecuta la acción print(vect2[i]), pero i vale 1, por lo cual se ejecuta print(vect2[1]), lo que nos arroja "10".
Luego, la i vale 2 (que es el segundo elemento del vector vect_recorrido) y por ello se ejecuta print(vect2[2]) que nos arroja "nombre".
Finalmente se ejecuta ``print(vect2[3]) que nos arroja "FALSE".

El bucle finaliza cuando la i recorre todos los elementos de vect_recorrido. Veamos una alternativa del código anterior

# directamente colocamos la secuencia del 1 al 3
for (i in 1:3){
  # Accion a ejecutar repetidamente
  print(vect2[i])
}

## [1] "10"
## [1] "nombre"
## [1] "FALSE"

O también, directamente podemos recorrer los elementos del vector Vect2:

# Recorremos directamente los elementos de vect2
for (i in vect2){
  # Accion a ejecutar repetidamente
  print(i)
}

## [1] "10"
## [1] "nombre"
## [1] "FALSE"

donde en este caso:

Al inicio la i tomará el valor de "10".
En la siguiente iteración la i tomará el valor de "nombre".
Finalmente la i tomará el valor de "FALSE" y el bucle termina.

Veamos un ejemplo práctico. Lo que haremos será definir un vector sin elementos, y en éste le iremos agregando únicamente los números pares en el rango del 1 al 50:

# Definimos un vector con la secuencia de numeros del 1 al 50
secuencia <- 1:50

# definimos un vector vacio para ir almacenando los numeros pares
pares <- c()

# Implementamos el for
for (i in secuencia){
  # Utilizaremos un condicional para detectar los numeros pares
  if (i %% 2 == 0){
    # Si i es par, lo agregamos a la lista pares
    pares = append(pares, i)
  }
}
# Veamos
pares

##  [1]  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50

donde:

Con el bucle for recorrimos todos los elementos del 1 al 50.
Con el condicional if filtramos solo los numeros pares. Dichos paremos los agregamos a la lista pares append(pares, i), pero para guardar la lista paremos con los elementos nuevos debemos estar actualizando la variable pares, por lo cual escribimos pares = append(pares, i).
El bucle funciona de la siguiente manera:
- En la primera iteración la i vale 1, como el 1 no es par, entonces pasamos a la siguiente iteración.
- En la siguiente iteración la i vale 2, como el dos es par, entonces append(pares, i) resulta en el vector c(2). Para guardar ese vector resultanto lo almacenamos en la variable pares.
- En la cuarta iteración la i vale 4, de modo que append(pares, i) resulta en el vector c(2, 4) y guardamos ese vector en la variable pares.
- Y así sucesivamente.

Bucle `while`

El bucle while es muy similar al for. El bucle for repite instrucciones un número determinado de veces, pero el bucle while repetirá la instrucción mientras una condición sea verdadera. Cuando dicha condición impuesta sea falsa, el bucle while finalizará. La estructura básica es

while (condicion) {
  acción a repetir
}

Debemos ser cuidadosos con el bucle while pues si la condición que imponemos nunca será falsa, entonces, en teoría, el bucle while tampoco se detendrá. Así, dentro del código del while debemos escribir el código necesario para evitar que el bucle while sea “infinito”. Veamos algunos ejemplos

# Definimos la condicion del while
continuar = TRUE

# Definiremos un contador auxiliar
contador <- 0
while (continuar){
  print("Hola")
  # Aumentaremos en uno el contador
  contador = contador + 1
  # Implementamos un condicional para hacer que el
  # bucle no sea infinito
  if (contador == 3){
    continuar = FALSE
  }
}

## [1] "Hola"
## [1] "Hola"
## [1] "Hola"

donde:

En la primer iteración la variable continuar es verdadera por lo que se ejecuta print("hola"). Aumentamos en uno el contador, por lo cual contador ahora vale 1. Luego, en el if vemos su contador==3, lo cual es falso pues ahora contador vale 1, de modo que continuar sigue siendo verdadera.
En la segunda iteración contador vale 2 y de nuevo se ejecuta print("hola").
En la tercera iteración contador vale 3 y de nuevo se ejecuta print("hola"). Pero ahora continuar==3 es verdadera, por lo cual se ejecuta la acción del condicional, así continuar ahora será falsa y por ende el bucle while finaliza. Es usual utilizar variables como contadores para hacer que el bucle while no sea infinito. Abordemos otro ejemplo

# Definimos una variable inicial en 0
n <- 0
# Ejecutamos un bucle while mientras n sea menor a 10
while (n < 10){
  # Imprimos el valor de n
  print(n)
  # aumentamos en 1 el valor de la n para que eventualmente el bucle se detenga
  n = n + 1
}

## [1] 0
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9

En resumen vemos que el funcionamiento del while y del for son muy similares.

Lectura de datos

Dentro de R existen librería que traen funcionalidades adicionales. Por ejemplo, en la librería datasets vienen integrados varios conjuntos de datos, por ejemplo:

# Cargamos la libreria datasets para poderla utilizar
library(datasets)

# De la libreria datasets accedemos al conjunto de datos iris
data <- datasets::iris

# Veamos
head(data)

con la función head() solo vemos la información de las primeras 6 filas. O podemos especificar el número de fulas que queremos ver si escribimos head(data, 10) para ver las 10 primeras filas.

Podemos acceder a la información de una columna en específico

# Vemos los primeros 6 valores de la columna Petal.Length escribiendo para ello data$Petal.Length

head(data$Petal.Length)

## [1] 1.4 1.4 1.3 1.5 1.4 1.7

esto es, dado un conjunto de datos, accedemos a los elementos de una columna utilizando el símbolo $. Adicionalmente, podemos acceder a un número determinado de filas y columnas:

# Entre corchetes escribimos:
# [numero de fila, numero de columna]
data[1, 3]

## [1] 1.4

O también podemos obtener rangos de filas y/o de columnas

# Datos de la fila 1 a la 3 considerando solo las columnas de la 2 a la 5
data[1:3, 2:5]

Por otro lado, con la función plot() podemos crear gráficos, por ejemplo

#    eje x                eje y
plot(x=data$Sepal.Length, y=data$Sepal.Width)

En clases posteriores veremos más a detalle el manejo de datos, carga de datos y su manipulación, así como otros tipos de gráficos o personalización de los mismos.

Introducción a Python

library(knitr)
include_graphics("pylogo.png")

Lo que haremos a continuación será ver los mismos temas anteriores pero ahora utilizando Python. De tal manera comenzamos por:

Aritmética

# Esto es un comentario
# SUMA
1 + 3
# MULTIPLICACION

## 4

5 * 7
# DIVISION

## 35

4 / 2
# RESIDUO

## 2.0

5 % 2
# POTENCIA

## 1

2 ** 3

## 8

Luego, en este caso solo podremos definir variables con el operador de asignación =:

# Definimos una variable
x = 2 ** 5
# Definimos una segunda variable
y = x + 7

# Podemos utilizar la funcion print() para imprimir los valores de nuestras variables
print(x)

## 32

print(y)

## 39

cabe mencionar que en python también la ejecución es de arriba hacía abajo. Podemos imprimir valores en una misma línea

# Separamos los valores por comas
print(x, y, 5)

## 32 39 5

Las cadenas de texto en python se definen al igual que en R:

print("Hola Mundo desde Python")

## Hola Mundo desde Python

Vectores

De manera predeterminada no podemos trabajar con vectores en Python. Para ello requeriremos una librería denominada numpy (numerical python) destinada para el cálculo numérico. Así, lo que haremos será importar dicha librería

# importamos la libreria y le asociamos un alias (as np)
import numpy as np

de modo que para referirnos a la librería numpy bastará con que escribamos np. Por ejemplo, crearemos un vector para lo cual escribiremos np.array() y dentro de los paréntesis escribimos (1,2,3,4,5,6,7,8,9) para definir un vector:

# Creamos un vector y lo almacenamos en una variable
vect1 = np.array((1,2,3,4,5,6,7,8,9))
vect1

## array([1, 2, 3, 4, 5, 6, 7, 8, 9])

donde np.array((1,2,3,4,5,6,7,8,9)) es equivalente en R a escribir c(1,2,3,4,5,6,7,8,9). Los vectores en python, o mejor dicho arrays, también pueden ser operados entrada a entrada

# Definimos otro vector
vect2 = np.array((11,12,13,14,15,16,17,18,19))
# Operaciones:
# Suma
print(vect1 + vect2)
# Multiplicacion

## [12 14 16 18 20 22 24 26 28]

print(vect1 * vect2)

## [ 11  24  39  56  75  96 119 144 171]

Podemos obtener la suma de todas las entradas de un array

vect1.sum()

## 45

o el promedio

vect1.mean()

## 5.0

Podemos acceder a los elementos de un array utilizando corchetes:

# Accedemos al primer elemento
vect1[0]

## 1

donde, en python el primer elemento está representado con el número cero; el segundo elemento con el número 1, etcétera.

Generando secuencias

Podemos generar secuencias de enteros del 1 al 9 utilizando la función np.arange():

# inicio: 1
# fin: 9
# incremento: 1 
np.arange(1,10, 1)

## array([1, 2, 3, 4, 5, 6, 7, 8, 9])

notamos que el último número (10) no se considera, en su lugar, el número que se toma en cuenta es el 10-1=9. Podemos configurar un incremento decimal

# inicio: 1
# fin: 5
# incremento: 0.5 
np.arange(1,6, 0.5)

## array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5])

De manera alternativa, podemos generar secuencias utilizando la función range()

# Generamos los numeros del 1 al 9 con un incremento de 1
range(1,10)

## range(1, 10)

el rango de números, en este caso, no es visible. En su lugar vemos simplemente range(1,10). No obstante, este tipo de secuencias son muy utilizadas en los bucles for como veremos más adelante.

Tipos de datos

Las cadenas de texto dentro de python se denominan strings; los números enteros son del tipo int; los decimales del tipo float; y los booleanos del tipo bool. Por ejemplo, podemos definir una variable booleana

bool1 = True
bool2 = False
print(bool1, bool2)

## True False

En este caso el valor booleano de verdadero se escribe como True, en cambio, en R se escribe con mayúsculas TRUE. Lo mismo para el valor de falso.

Condicionales

La estructura básica del condicional en python es

if condicion:
  acción a implementar en caso de que la condición sea
  verdadera
else:
  acción a implementar en caso de que la condición sea
  falsa

Notamos que la notación es diferente a la de R, pero en esencia representan lo mismo. Veamos un ejemplo:

# Condicion
semaforo_verde = True

# Implementamos el if
if semaforo_verde:
  print("No cruce")
else:
  print("Cruce")

## No cruce

Bucles

Análogamente, la implementación del bucle for y while es esencialmente la misma en python que en R, aunque la sintaxis sea diferente.

Estructura del for en python:

for recorrido:
  acción a repetir

Veamos un ejemplo:

# Imprimiremos los numeros pares comprendidos
# del 1 al 9.
# range(1, 10) equivale a: 1,2,3,4,5,6,7,8,9
for i in range(1,10):
  # Implementamos un condicional para filtrar los numeros pares
  if i % 2 == 0:
    print(i)

## 2
## 4
## 6
## 8

De nuevo, las secuencias obtenidas por la función range() son muy utilizadas dentro de los bucles for. Veamos otro ejemplo:

# Accederemos a todos los elementos del vector vect1, antes de ello
# veamos de nuevo dicho vector
vect1

## array([1, 2, 3, 4, 5, 6, 7, 8, 9])

el cual tiene

# podemos ver cuantos elementos tiene un vector de python con la funcion len()
len(vect1)

## 9

elementos. De tal manera

# recorremos todos los elementos del vector anterior
# range(0,10) genera: 0,1,2,3,4,5,6,7,8
for i in range(0,9):
  print(vect1[i])

## 1
## 2
## 3
## 4
## 5
## 6
## 7
## 8
## 9

cuando i vale 0 tenemos print(vect1[0]) por lo cual se imprime el primer elemento del vector. Para i igual a 8, se imprime el último elemento del vector, el cual es el 9. O de manera alternativa podemos recorrer directamente los elementos del vector

for i in vect1:
  print(i)

## 1
## 2
## 3
## 4
## 5
## 6
## 7
## 8
## 9

Pasamos ahora el bucle while cuya estructura es

while condicion:
  acciones a realizar mientras la condicion sea verdadera

por ejemplo

# Contador auxiliar para evitar que el bucle sea infinito
contador = 0
# Condicion del while
condicion = True

# Implementamos el while
while condicion:
  print("Hola")
  # Aumentamos el contador en 1
  contador = contador + 1
  # Si el contador vale 3, entonces detendremos el bucle
  if contador ==3:
    condicion = False

## Hola
## Hola
## Hola

Ejercicios

R

Define un vector con los números del 1 al 1000, configurando un incremento de 0.5. Obtén la suma de las entradas de ese vector así como su promedio. Adicionalmente obtén la longitud de dicho vector.
Considera la siguiente situación: si un estudiante obtiene una calificación menor a 6 entonces estará reprobado, caso contrario el alumnos pasará. Implementa dicha situación utilizando un condicional. (Auxíliate del ejemplo que vimos del semáforo).
Mediante un bucle for, accede a todos los elementos del vector que definiste en el punto 1. Deberás acceder a sus elementos de dos formas distintas.
Mediante un bucle while y auxíliante de un condicional, imprime todos los números impares del rango de números del 1 al 20.

Python

Realiza exactamente los mismos ejercicios anteriores pero ahora utilizando su equivalente de sintaxis en python.

Ejercicio de programación

Dado un número entero $n$, podemos conocer todos sus divisores ayudándonos de operador de residuo. Por ejemplo, notemos para $n=6$ que

Usando `python`

print(6 % 1)

## 0

print(6 % 2)

## 0

print(6 % 3)

## 0

print(6 % 4)

## 2

print(6 % 5)

## 1

el residuo de 6 y 1, el de 6 y 2, y el de 6 y 3 es cero. Adicionalmente sabemos que los divisores del 6 son: 1,2 y 3. El 4 y el 5 no son divisores del 6, por ello el residuo de 6 y 4, y el de 6 y 5 no fue cero. De tal manera, un número $k$ es divisor de $n$ si al efectuar n % k el resultado es cero. Así, podremos obtener todos los divisores de un número $n$ escribiendo:

# Por ejemplo, configuramos n igual a 10
n = 10

# Recorremos todos los numeros enteros menores a 10.
# range(1,10) genera: 1,2,3,4,5,6,7,8,9
for i in range(1,10):
  # implementamos un condicional para detectar los divisores del 10
  if n % i == 0:
    # Recordemos que, en python, podemos imprimir varios valores separandolos por comas
    print(i, 'Es divisor de 10')
  else:
    print(i, 'No es divisor de 10')

## 1 Es divisor de 10
## 2 Es divisor de 10
## 3 No es divisor de 10
## 4 No es divisor de 10
## 5 Es divisor de 10
## 6 No es divisor de 10
## 7 No es divisor de 10
## 8 No es divisor de 10
## 9 No es divisor de 10

Lo que deberás hacer es “traducir” exactamente lo anterior hecho, pero utilizando el lenguaje R.

Regresión lineal y series de tiempo con Python y R

Autor: Luis Apáez Álvarez

Fecha: 30 de diciembre del 2022

Conceptos básicos

Artimética

Variables

Vectores

Generación de secuencias

Tipos de datos

Condicionales

Bucles

Bucle `for`

Bucle `while`

Lectura de datos

Introducción a Python

Aritmética

Vectores

Generando secuencias

Tipos de datos

Condicionales

Bucles

Ejercicios

R

Python

Ejercicio de programación

Usando `python`

Regresión lineal y series de tiempo con Python y R

Autor: Luis Apáez Álvarez

Fecha: 30 de diciembre del 2022

Conceptos básicos

Artimética

Variables

Vectores

Generación de secuencias

Tipos de datos

Condicionales

Bucles

Bucle for

Bucle while

Lectura de datos

Introducción a Python

Aritmética

Vectores

Generando secuencias

Tipos de datos

Condicionales

Bucles

Ejercicios

R

Python

Ejercicio de programación

Usando python

Bucle `for`

Bucle `while`

Usando `python`