---
title: "R y Python Notebook"
output: html_notebook
---



# Ejemplos de códigi R y Python comparables


## Códigos triviales

Los siguientes dos códigos son casi idénticos: en el código
R usamos la flecha de asignación porque es una buena práctica, pero
el mismo signo igual que en Python habría funcionado bien.

```{r  }
# >>>> un código R <<<<
a <-  1
b <- 10
c <-  2 * a + b
c
c**2
```



```{python  }
# >>>> un código Python <<<<
a = 1
b = 10
c = 2 * a + b
c
c**2
```

## Packages

En ambos lenguajes hay varias sintaxis para cargar o usar **packages**,
Aquí están los que tienen el efecto más similar:

```{r}
# >>>> Códigos R <<<<
library(stats)         # acceso a la funciones estadísticas
```

\( \)

```{python}
# >>>> Códigos Python <<<<
from numpy import *   # funciones maths potentes 
```


## funciones simples

Uso de las **funciones básicas** es comparable.

```{r  }
# >>>> funciones en R <<<<
print(a)
sin(pi)
exp(2)
sqrt(9)
round(1.749999,2)
log(1)
```

\( \)


```{python  }
# >>>> funciones en Python <<<<
print(a)
sin(pi)
exp(2)
sqrt(9)
round(1.749999,2)
log(1)
```


## Estructuras de datos

Las creaciones de **estructuras** son similares, pero su uso difiere en
con respecto a "subsetting".

```{r  }
# >>>> Códigos R <<<<
w = as.array(c(1,2,3,4,55,66)) 
w
sum(w)
max(w)
w[1]
w[1:3]
w/2
length(w)
```

\( \)

```{python  }
# >>>> Códigos Python <<<<
w = array([1,2,3,4,55,66])
w
sum(w)
max(w)
w[0]
w[0:3]
w/2
len(w)
```

Pero ojo, en R las posiciones empiezan en 1 (como en matemáticas), así que
 en Python comienzan en 0 (como en C). Compare cuidadosamente la expresión R [1:3]
que significa "de 1 a 3", mientras que en Python [1:3] significa "3 posiciones desde 1 inclusive".

La búsqueda de elementos y el **filtrado** son muy similares.

```{r}
# >>>> Códigos R <<<<
w[w >= 4] # filtrando un vector
which(w == 66) # >>>> Códigos R <<<<búsqueda de posición

```


\( \)

```{python  }
# >>>> Códigos Python <<<<
w[w >= 4]          # filtrando un vector
where(w == 66)     # búsqueda de posición
```


## Booleanos

**Las operaciones booleanas** también son similares.

```{r  }
# >>>> Códigos R <<<<
a == 1
B <- as.array(c(TRUE, FALSE, TRUE))
B & TRUE                  # Y
B | TRUE                  # O
!B
```


\( \)

```{python  }
# >>>> Códigos Python <<<<
a == 1
B =  array([True, False, True])
B & True                  # Y
B | True                  # O
logical_not(B)
```



## programación básica

Los **bucles y las estructuras de control** también se parecen:

```{r  }
# >>>> Códigos R <<<<
for(i in 1:3) print(i**2)
if (a==1) print(a + 100)
```

\( \)

```{python  }
# >>>> Códigos Python <<<<
for i in range(1,4) : print(i**2)
if a==1 : print(a + 100)

```

Tenga en cuenta que el intervalo de **rango** va de 1 incluido a 4 excluidos.

## Creación de funciones

**Crear una función** también es similar:

```{r  }
# >>>> Códigos R <<<<
mi_funcion <- function(x) return(x + 1000)
m <- mi_funcion(1)
print(m)
```


\( \)


```{python   }
# >>>> Códigos Python <<<<
def mi_funcion(x): return(x + 1000)
m = mi_funcion(1)
print(m)
```


## Bloques e indentación

La presentación, el **anidamiento de los bloques de código** difieren: en R, estructuramos
poniendo llaves **{}**, como en C, mientras que en Python estructuramos 
**sangrado** instrucciones de bloque (lo que hacemos en R para mejorar la
presentación, pero sin que esto influya en el significado del código).

```{r }
# >>>> Códigos R <<<<
mi_funcion <- function(x) {
  if (x < 1000) {
    print('zero')
    return(0)
    }
  if (x >= 1000) {
    print('one')
    return(1)
    } 
}
mi_funcion(800)
mi_funcion(1200)
```


\( \)


```{python  }
# >>>> Códigos Python <<<<
def mi_funcion(x): 
  if x < 1000  :
     print('zero')
     return(0)
  if x >= 1000 :
     print('one')
     return(1)
     
mi_funcion(800)
mi_funcion(1200)
```

## Datasets



```{r}
# >>>> Códigos R <<<<
data <- read.csv2('fich.csv')
data
data + 100
```


```{r}
library(reticulate)
py_install('pandas')
```

\( \)

```{python}
# >>>> Códigos Python <<<<
from pandas import *
data = read_csv('fich.csv', delimiter = ";")
data
data + 100
```

Podemos acceder fácilmente a las columnas:

```{r warning=FALSE}
# >>>> Códigos R <<<<
data$col1
data['col2']
col3 <- data['col3']
col3
```

\( \)

```{python}
# >>>> Códigos Python <<<<
data.col1
data['col2']
col3 = data['col3']
col3
```



# Acceder a Python a partir de R



## Instalación e inicialización del contexto técnico

No dude en evaluar su contexto antes de iniciar su
trabajo, comprobando su configuración de Python y su correcto funcionamiento.

```{r warning= F, message=F, comment =F, results='hide'}
getwd()               # ¿dónde estoy?
library(reticulate)   # carga de reticulate
```
¿está disponible Python?

```{r warning= F, message=F, comment =F, results='hide'}
py_available(initialize = FALSE)
```

¿Cuál es el Python de mi máquina que estoy usando?

```{r warning= F, message=F, comment =F, results='hide'}
py_config()                          # la configuración python local
```

\( \)


¿Qué entornos virtuales **conda** tengo disponibles?

```{r warning= F, message=F, comment =F, results='hide'}
conda_list()    # eventual configuración conda
```

Verifique si su entorno funciona: 


```{r warning= F, message=F, comment =F, results='hide'}
os <- reticulate::import("os") # una pequeña prueba funcional
os$listdir(".") # si todo va bien: directorio local
```

\(\)



## Interacciones de R y Python, ¡desde el punto de vista de R!

### Compartiendo variables y ejecutando Python código en el biotopo R



```{python}
# Escribir un archivo: la primera vez si el archivo no existe, reinicie R después
# f = open('test.py', 'w')
# f.write('a = 666') # un código de Python si todo está bien devuelve 7
# f.close() 
```


```{r eval=FALSE}
a <- 0 
reticulate::source_python("test.py")
a
```




```{python}
variable_python = 777
```



```{r}
py$variable_python
```




```{r}
variable_R <- 888
```

En el context0 Python, encontrará la variable con el prefijo *r.*

```{python}
r.variable_R
```

### Bibliotecas de Python en R código, ejemplos de NLP.



Instale antes de ejecutar los ejemplos.

```{r}
# instalación de librerías: eliminar '#' al principio de la línea
library(reticulate)
# py_install('pyfiglet') # Para geeks
# py_install('pendulum') # fecha y hora... en todas partes
# py_install('nltk') # un estándar de PNL
# nltk$download('punkt') # un recurso nltk útil más adelante
# py_install('faker') # para crear datos falsos
# py_install('fuzzywuzzy') # comparación de cadenas difusas
# py_install('wikipedia') # para acceder a los textos de Wikipedia

                             # gran librería de PNL
# py_install('stanza')
# stanza        <- reticulate::import("stanza")
# stanza$download('en')
# stanza$download('fr')
```


#### librería Python : pyfiflet


```{r , comment = ""}
pf <- reticulate::import("pyfiglet")

f  <-  pf$Figlet(font='slant')
f$renderText('Python vs R')

f  <-  pf$Figlet(font='doh')
f$renderText('x')
```

#### librería Python : pendulum



```{r}
pdl   <- reticulate::import("pendulum")
time_Londres = pdl$now('Europe/London')
time_Londres 
```


#### librería Python : nltk



```{r}
nltk   <- reticulate::import("nltk")

phrase <- "NLTK is a leading platform for building Python programs 
           to work with human language data. 
           It provides easy-to-use interfaces to over 50 corpora 
           and lexical resources "

tokens <- nltk$word_tokenize(phrase)
tokens
```


#### librería Python : faker



```{r}
faker     <- reticulate::import("faker")
fake <-faker$Faker(c("fr-FR","de-DE")) # elección del idioma y la localización geográfica
faker$Faker$seed(66)                   # seed para garantizar la reproductibilidad
fake$email()
fake$email("gmail")                    # forzamos el proveedor del correo electrónico
d'email
fake$name()
fake$address()
```


#### librería Python : fuzzywuzzy



```{r}
fuzz        <- reticulate::import("fuzzywuzzy")
process     <- reticulate::import("fuzzywuzzy.process") # importación de segundo nivel
### Librerías de Python en R código, PNL ejemplos.
proceso$fuzz$ratio("este es el final de los frijoles", # comparación 2 textos
                    "este es el fin de los fines")
process$fuzz$ratio("este es el final de los frijoles",
                    "los hijos del frijol, eso es")
process$fuzz$token_sort_ratio("este es el final de los frijoles",
                               "los hijos del frijol, eso es")```


#### librería Python : wikipedia



```{r}
wikipedia        <- reticulate::import("wikipedia")
wikipedia$set_lang('fr') # tenemos disponibles muchos lenguajes
result           <- wikipedia$page("R (langage)")
result$summary           # es un resumen del contenido
```

#### librería Python : stanza



```{r warning= F, message=F, comment =F, results='hide'}
stanza        <- reticulate::import("stanza")
nlp           <- stanza$Pipeline('es')          # para trabajar en español
```

\( \)



```{r}
doc1 = nlp("¡Yo, Jean, estoy encantada de trabajar!")
doc2 = nlp("result$content") # ejemplo: cómo cargar el documento desde wikipedia```



```{r warning= F, message=F, comment =F, results='hide'}
print(doc1)
```



