Programando de Python a R studio

Author

Norah Jones

Published

Invalid Date

Preface

This is a Quarto book.

To learn more about Quarto books visit https://quarto.org/docs/books.

Operadores aritmeticos

Los operadores aritméticos son necesarios para realizar operaciones aritméticas como suma, resta, multiplicación, división, etc. La siguiente tabla es la lista de operadores aritméticos en Python:

aritmetic_operators <-  data.frame(
Nombre_del_operador = c("suma", "resta", "multiplicacion","division o division flotante",
"division de piso", "exponente", "modulos"),
Simbolo_del_operador = c("+", "-", "*", "/", "%/%", "^", "%%"),
Descripcion = c("Suma los dos operandos", "Resta los operandos derechos del operando
izquierdo", "Multiplica los dos operandos", "El operando izquierdo se divide por el operando
derecho y da como resultado el valor flotante", "El operando izquierdo se divide por el
operando derecho y da como resultado el valor minimo de division", "Eleva el operando
izquierdo a la potencia del derecho", "Da el resto de la division del operando izquierdo por el
operando derecho"),
Ejemplo = c("a + b", "a - b", "a * b", "a / b", "a%/%b", "a ^ b", "a %% b")
)
print(aritmetic_operators)

           Nombre_del_operador Simbolo_del_operador
1                         suma                    +
2                        resta                    -
3               multiplicacion                    *
4 division o division flotante                    /
5             division de piso                  %/%
6                    exponente                    ^
7                      modulos                   %%
                                                                                               Descripcion
1                                                                                   Suma los dos operandos
2                                                     Resta los operandos derechos del operando\nizquierdo
3                                                                             Multiplica los dos operandos
4           El operando izquierdo se divide por el operando\nderecho y da como resultado el valor flotante
5 El operando izquierdo se divide por el\noperando derecho y da como resultado el valor minimo de division
6                                                   Eleva el operando\nizquierdo a la potencia del derecho
7                               Da el resto de la division del operando izquierdo por el\noperando derecho
  Ejemplo
1   a + b
2   a - b
3   a * b
4   a / b
5   a%/%b
6   a ^ b
7  a %% b

# Ejemplo suma
10+20

[1] 30

#Ejemplo resta
20-5

[1] 15

#Ejemplo multiplicacion
10*9

[1] 90

#Ejemplo division
80/4

[1] 20

#Ejemplo exponente
3^2

[1] 9

Operaciones relacionales

Los operadores relacionales se utilizan para comprobar la relación entre operandos y comparar los valores. Según la condición, estos operadores devuelven como resultado “Verdadero” o “Falso”:

Relationals_operators <-  data.frame(
Nombre_del_operador = c("igualdad", "diferente", "Menor que", "Mayor que", "Menor o
igual", "Mayor o igual"),
Simbolo_del_operador = c("==", "!=", "<", ">", "<=", ">="),
Descripcion = c("comparar si el valor del operando izquierdo es igual al valor del operando
derecho", "comparar si el valor del operando izquierdo no es igual al valor del operando
derecho", "comparar si el valor del operando izquierdo es menor que el valor del operando
derecho", "comparar si el valor del operando izquierdo es mayor que el valor del operando
derecho", "comparar el valor del operando izquierdo es menor o igual que el valor del
operando derecho", "comparar el valor del operando izquierdo es mayor o igual que el valor
del operando derecho"),
Ejemplo = c("a == b", "a != b", "a < b", "a > b", "a<=b", "a>=b")
)
print(Relationals_operators)

  Nombre_del_operador Simbolo_del_operador
1            igualdad                   ==
2           diferente                   !=
3           Menor que                    <
4           Mayor que                    >
5      Menor o\nigual                   <=
6       Mayor o igual                   >=
                                                                                   Descripcion
1          comparar si el valor del operando izquierdo es igual al valor del operando\nderecho
2       comparar si el valor del operando izquierdo no es igual al valor del operando\nderecho
3      comparar si el valor del operando izquierdo es menor que el valor del operando\nderecho
4      comparar si el valor del operando izquierdo es mayor que el valor del operando\nderecho
5 comparar el valor del operando izquierdo es menor o igual que el valor del\noperando derecho
6 comparar el valor del operando izquierdo es mayor o igual que el valor\ndel operando derecho
  Ejemplo
1  a == b
2  a != b
3   a < b
4   a > b
5    a<=b
6    a>=b

# Ejemplo 
#Tenemos las variables
a=20
b=28

# igual a la relacion (==)
a==b

[1] FALSE

print(paste("igual a la relacion => (a==b) es", a==b))

[1] "igual a la relacion => (a==b) es FALSE"

# No es igual a la relacion (!=)
a!=b

[1] TRUE

print(paste("no es igual a la relacion => (a!=b) es", a!=b))

[1] "no es igual a la relacion => (a!=b) es TRUE"

# relacion menor que (<)
a<b

[1] TRUE

print(paste("relacion menor que => (a<b) es", a<b))

[1] "relacion menor que => (a<b) es TRUE"

# relacion mayor que (>)
a>b

[1] FALSE

print(paste("relacion mayor que => (a>b) es", a>b))

[1] "relacion mayor que => (a>b) es FALSE"

# Menor o igual a relacion (<=)
a<=b

[1] TRUE

print(paste("Menor o igual a relacion => (a<=b) es", a<=b))

[1] "Menor o igual a relacion => (a<=b) es TRUE"

# Mayor o igual a relacion (>=)
a>=b

[1] FALSE

print(paste("Mayor o igual a relacion => (a>=b) es", a>=b))

[1] "Mayor o igual a relacion => (a>=b) es FALSE"

Operador de asignacion

Para asignar el valor a una variable, utilizamos operadores de asignación. La siguiente es una lista de operadores de asignación en Python:

Asigment_operators <-  data.frame(
Nombre_del_operador = c("Asignar"),
Simbolo_del_operador = c("<- ∨ ="),
Descripcion = c("Asigna un valor a una variable"),
Ejemplo = c("a = b o a <- b")

)
print(Asigment_operators)

  Nombre_del_operador Simbolo_del_operador                    Descripcion
1             Asignar               <- ∨ = Asigna un valor a una variable
         Ejemplo
1 a = b o a <- b

# Asignar (=)
a <-  20
print(paste("Asignar(a=20) =>",a))

[1] "Asignar(a=20) => 20"

b <-  25
print(paste("Asignar(b=25) =>",b))

[1] "Asignar(b=25) => 25"

# Suma y asignacion (+=)
a <-  +10
print(paste("Suma y asignacion(a+=10) => ",a))

[1] "Suma y asignacion(a+=10) =>  10"

b <-  25
print(paste("Suma y asignacion(b+=25) =>",b))

[1] "Suma y asignacion(b+=25) => 25"

Operadores logicos

Estos operadores se utilizan para combinar expresiones condicionales en Python.

La siguiente tabla tiene la información completa sobre los operadores lógicos en Python.

# Creacion de vectores de ejemplo
vector_a <- c(TRUE,TRUE,FALSE,FALSE)
vector_b <- c(TRUE,FALSE,TRUE,FALSE)

# Operador AND logico (&& y &)
resultado_and <- vector_a & vector_b
resultado_and

[1]  TRUE FALSE FALSE FALSE

# Operador OR logico (|| y |)
resultado_or <- vector_a | vector_b
resultado_or

[1]  TRUE  TRUE  TRUE FALSE

# Operador NOT logico (!)
resultado_not_a <- !vector_a
resultado_not_b <- !vector_b
resultado_not_a

[1] FALSE FALSE  TRUE  TRUE

resultado_not_b

[1] FALSE  TRUE FALSE  TRUE

# Operador XOR logico (xor())
resultado_xor <- xor(vector_a, vector_b)
resultado_xor

[1] FALSE  TRUE  TRUE FALSE

# Ejemplo 
#Tenemos las variables
a <- FALSE
b <- TRUE

# Operador logico AND (y)
print(paste("AND logico => a y b es:", a & b))

[1] "AND logico => a y b es: FALSE"

# Operador logico OR (o)
print(paste("OR logico => a o b es:", a | b))

[1] "OR logico => a o b es: TRUE"

# Operador logico NOT (no)
print(paste("NO logico => no b es:", ! b))

[1] "NO logico => no b es: FALSE"

Tipos de datos integrados en Python

Tipo Numerico

Al trabajar con números, necesitamos tipos de datos numéricos. En Python, los números son inmutables. En Python 3.x, tenemos tres tipos de datos numéricos.

Int o Integer: Los números enteros son números enteros positivos o negativos; es decir, no tienen punto decimal.

Flotante: Son valores flotantes de tipo numérico o valores reales; a diferencia de los números enteros, el flotante tiene un punto decimal.

Complejo: Los números complejos se pueden expresar en la forma a + bi, aquí, a es la parte real y b es la parte imaginaria [a y b son los números enteros pero i es el número imaginario (raíz cuadrada de -1)].

# Ejemplo de tipo de datos int
a <- 20 # valor entero positivo
a1 <- -20 # Valor entero negativo

# imprimiendo el valor
print(paste("a =", a))

[1] "a = 20"

print(paste("a1 =", a1))

[1] "a1 = -20"

# comprobar el tipo de variable a
print(paste("El tipo de variable a es:", typeof(a)))

[1] "El tipo de variable a es: double"

print(paste("El tipo de variable a1 es:", typeof(a1)))

[1] "El tipo de variable a1 es: double"

# Ejemplo de tipo de datos flotante
b <- 20.5 # valor flotante positivo
b1 <- -20.5 # Valor flotante negativo

# imprimiendo el valor
print(paste("b =", b))

[1] "b = 20.5"

print(paste("b1 =", b1))

[1] "b1 = -20.5"

# comprobar el tipo de variable a
print(paste("El tipo de variable b es:", typeof(b)))

[1] "El tipo de variable b es: double"

print(paste("El tipo de variable b1 es:", typeof(b1)))

[1] "El tipo de variable b1 es: double"

# Ejemplo de datos complejos

a <- complex(real = 20, imaginary = 5)
b <- complex(real = 0, imaginary = 5)
c <- complex(real = 10, imaginary = -5)
d <- complex(real = 0, imaginary = -5)


# imprimiendo el valor de un
print (paste("a = ", a))

[1] "a =  20+5i"

# comprobar el tipo de variable a
print(paste("El tipo de variable c es :", typeof(a)))

[1] "El tipo de variable c es : complex"

print(paste("El tipo de variable d e :", typeof(b)))

[1] "El tipo de variable d e : complex"

print(paste("El tipo de variable d es :", typeof(c)))

[1] "El tipo de variable d es : complex"

print(paste("El tipo de variable d e s:", typeof(d)))

[1] "El tipo de variable d e s: complex"

Cadenas

Las cadenas son una secuencia de caracteres encerrados entre comillas simples, dobles o triples o comillas dobles triples.

Se utilizan comillas simples y dobles para escribir una cadena de una sola línea, pero se utilizan comillas triples para escribir una cadena de varias líneas.

# Ejemplos de codificacion
cadena1 <- 'Esta es una cadena entre comillas simples'
cadena2 <- "Esta es una cadena entre comillas dobles"
# Mostrar resultados
print(cadena1)

[1] "Esta es una cadena entre comillas simples"

print(cadena2)

[1] "Esta es una cadena entre comillas dobles"

Concatenacion de cadenas

# concatenando dos cadenas
cadena1 <- "Hola"
cadena2 <- "Python"
cadena3 <- paste(cadena1, cadena2, sep = " ")
print(paste("La cadena concatenada es:", cadena3))

[1] "La cadena concatenada es: Hola Python"

Lista

Una lista es una colección ordenada de elementos. Las listas son mutables, lo que significa que podemos actualizar el elemento de la lista a nivel de índice.

Sin embargo, una lista también es un tipo de secuencia, por lo que admite la indexación. Para crear la lista, necesitamos poner elementos dentro de los corchetes ([ ]) separándolos con una coma.

# Ejemplo
mi_lista <- list(20,25,22,64,15,28,25,30,25)
cat("Mi lista:\n")

Mi lista:

print(mi_lista)

[[1]]
[1] 20

[[2]]
[1] 25

[[3]]
[1] 22

[[4]]
[1] 64

[[5]]
[1] 15

[[6]]
[1] 28

[[7]]
[1] 25

[[8]]
[1] 30

[[9]]
[1] 25

# Calcular la longitud 
longitud_lista <- length(mi_lista)
print(longitud_lista)

[1] 9

# Calcular cuantas veces contengo un elemento
cant_lista <- sum(mi_lista==25)
print(cant_lista)

[1] 3

Concatenacion y repeticion

Para concatenar dos listas de Python, podemos usar el operador o extend(sequence )función “+”.

# Ejemplo
lista1 <-  list(2, 4, 6, 8, 10)
lista2 <-  list(1, 3, 5, 7)
numeros <- list(lista2, lista1)
print(numeros)

[[1]]
[[1]][[1]]
[1] 1

[[1]][[2]]
[1] 3

[[1]][[3]]
[1] 5

[[1]][[4]]
[1] 7


[[2]]
[[2]][[1]]
[1] 2

[[2]][[2]]
[1] 4

[[2]][[3]]
[1] 6

[[2]][[4]]
[1] 8

[[2]][[5]]
[1] 10

Actualizar la lista de Python

Usando la indexación, podemos actualizar el valor indexado especificado en una lista.

# Ejemplo
numeros <-  list(1,2,3,4,5,6)
numeros[2] <-  22
print(numeros)

[[1]]
[1] 1

[[2]]
[1] 22

[[3]]
[1] 3

[[4]]
[1] 4

[[5]]
[1] 5

[[6]]
[1] 6

Eliminar un elemento de la lista de Python

Las listas de Python tienen funciones remove()y pop() eliminan un elemento de la lista.

remove(value): Toma un valor o un objeto de lista como argumento y elimina ese elemento de la lista.

pop(index): Toma el índice como argumento, lo elimina y devuelve el valor en el índice dado. Si no pasamos ningún índice como argumento, eliminará y devolverá el valor del último índice de la lista.

numeros <-  list(1,2,3,4,5,6)
numeros <-  numeros[numeros != 6]
print(numeros)

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 4

[[5]]
[1] 5

Comprobar la pertenencia de un elemento

Al utilizar el operador ‘in’, podemos verificar si algún valor está presente en la lista o no. Si el valor existe en la lista, devolverá “True”.

frutas <-  list("fresa", "papaya", "piña")
"fresa" %in% frutas

[1] TRUE

cat("Comprobando si el mango está en la lista:", "plátano" %in% frutas)

Comprobando si el mango está en la lista: FALSE

Ordenar los elementos de la lista

Usando el método sort(), podemos ordenar los elementos de la lista

mi_lista <-  list(20, 25, 22, 64, 15, 28)

mi_vector <-  unlist(mi_lista)
mi_vector_ordenado <-  sort(mi_vector)

mi_lista_ordenada <- list(mi_vector_ordenado)
print(mi_lista_ordenada)

[[1]]
[1] 15 20 22 25 28 64

# Ordenar de manera decreciente
mi_lista <-  list(20, 25, 22, 64, 15, 28)

mi_vector <- unlist(mi_lista)
mi_vector_ordenado <-  sort(mi_vector, decreasing = TRUE)

mi_lista_ordenada <- list(mi_vector_ordenado)
print(mi_lista_ordenada)

[[1]]
[1] 64 28 25 22 20 15

Longitud de una lista y recuento de un elemento en la lista

Para obtener la longitud de cualquier lista (tamaño de la lista), podemos usar la función len(). Y para obtener el recuento de cuántas apariciones del elemento o elemento especificado, podemos usar la función count().

# Ejemplo
mi_lista <- list(20, 25, 22, 64, 15, 28,25,30,25)

cat("Mi Lista:\n")

Mi Lista:

print(mi_lista)

[[1]]
[1] 20

[[2]]
[1] 25

[[3]]
[1] 22

[[4]]
[1] 64

[[5]]
[1] 15

[[6]]
[1] 28

[[7]]
[1] 25

[[8]]
[1] 30

[[9]]
[1] 25

# Calcular la longitud 
longitud_lista <- length(mi_lista)

print(longitud_lista)

[1] 9

# Hallar cuantas veces contengo un elemento 
cant_lista <- sum(mi_lista ==25) 
print(cant_lista)

[1] 3

# Ejemplo 2
mi_lista <- c(1,2,3,4,5)

Agregar elemento(s) en tupla

Como las tuplas son inmutables, no podemos agregar ni modificar la tupla existente. Pero de otra forma, podemos usar el operador de concatenación “+” y concatenar la nueva tupla con un solo elemento de la existente y crear una nueva referencia de tupla.

# Ejemplo 1 
# Tupla Inicial
tupla_inicial <- c(1, 2, 3)
print(paste("tupla t1 =", tupla_inicial))

[1] "tupla t1 = 1" "tupla t1 = 2" "tupla t1 = 3"

# Crear una nueva tupla agregando (4,), tupla con un solo elemento en la tupla inicial

tupla_inicial_1 <- c(tupla_inicial, 4)
print(paste("tuple tupla_inicial_1.1 =", tupla_inicial_1))

[1] "tuple tupla_inicial_1.1 = 1" "tuple tupla_inicial_1.1 = 2"
[3] "tuple tupla_inicial_1.1 = 3" "tuple tupla_inicial_1.1 = 4"

tupla_inicial_1

[1] 1 2 3 4

# Para crear una tupla con un solo elemento, es necesario incluir una coma al final:

t1 <- c('a')
t1

[1] "a"

# Averiguar el tipo de data
class(t1)

[1] "character"

# Otra forma de construir una tupla es utilizando la función interna tuple. Sin argumentos, ésta crea una tupla vacía:
t3 <- c()
t3

NULL

# Si el argumento es una secuencia (cadena, lista, o tupla), el resultado de la llamada a tuple es una tupla con los elementos de la secuencia:

# Crear una lista con cada letra de la palabra "Programación"
palabra <- 'Programación'
lista_de_letras <- strsplit(palabra, split = '')[[1]]

# Imprimir la lista de letras
print(lista_de_letras)

 [1] "P" "r" "o" "g" "r" "a" "m" "a" "c" "i" "ó" "n"

TUPLAS

Una tupla también es una colección ordenada de elementos como una lista, pero las tuplas son inmutables, es decir, no podemos cambiar ni modificar el valor de los elementos de la tupla.

# crear una tupla como un vector
mi_tupla <- c("valor1",42,TRUE,5,0)

# Accerder a los elementos de la tupla
primer_elemento <- mi_tupla[1]
primer_elemento

[1] "valor1"

# Accerder a los elementos de la tupla
segundo_elemento <- mi_tupla[2]
segundo_elemento

[1] "42"

# Accerder a los elementos de la tupla
tercer_elemento <- mi_tupla[3]
tercer_elemento

[1] "TRUE"

# Ejemplo
# tupla inicial
tupla_inicial <- c(1,2,3,7,9,12,15)
tupla_inicial

[1]  1  2  3  7  9 12 15

# Crear una nueva tupla agregando 60, tupla con un solo elemento en la tupla inicial
tupla_nueva <-  c(tupla_inicial, 60)
tupla_nueva

[1]  1  2  3  7  9 12 15 60

# Eliminar el elemento del índice 5
tupla_e <-  tupla_inicial[-5]
tupla_e

[1]  1  2  3  7 12 15

DICCIONARIOS

# Creando un diccionario 
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")
print(mi_diccionario)

$`1`
[1] "60%"

$`2`
[1] "50%"

$`3`
[1] "30%"

Trabajar con diccionarios

En el diccionario de Python, podemos acceder al valor especificando la clave dentro del corchete ([ ]) o pasar la clave como argumento en el método get() para obtener el valor de una clave específica.

Si la clave especificada no está disponible en un diccionario, generará un error, pero devolverá “None” con los métodos get().

# diccionario [key]=> devuelve el valor de la clase especificada
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")
print(paste("El valor de la clave 2 es", mi_diccionario$`2`))

[1] "El valor de la clave 2 es 50%"

# Ejemplo
semaforo <- list(Rojo = "Parar", Ambar = "Precaución", Verde = "Adelante")
print(semaforo$Ambar)

[1] "Precaución"

AGREGAR ELEMENTO(S) EN EL DICCIONARIO

Usando la clave y pasando el valor, podemos agregar una nueva clave, par de valores, en el diccionario. Si ya hay una clave presente, actualizará el valor de esa clave.

# Ejemplos de codificacion
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")
print(mi_diccionario)

$`1`
[1] "60%"

$`2`
[1] "50%"

$`3`
[1] "30%"

mi_diccionario[["4"]] <- "25%"
print(paste("Después de agregar un elemento:", mi_diccionario))

[1] "Después de agregar un elemento: 60%" "Después de agregar un elemento: 50%"
[3] "Después de agregar un elemento: 30%" "Después de agregar un elemento: 25%"