pyExecg: Executes multiple lines of python code and gets the output
In PythonInR: Use 'Python' from Within 'R'

Description Usage Arguments Details Value Examples

The function pyExecg is designed to execute multiple lines of Python code and returns the thereby generated variables to R.

1
2
3

pyExecg(code, returnValues = character(), autoTypecast = TRUE,
  returnToR = TRUE, mergeNamespaces = FALSE, override = FALSE,
  simplify = TRUE)

`code`	a string of Python code to be executed in Python.
`returnValues`	a character vector containing the names of the variables, which should be returned to R.
`autoTypecast`	a an optional logical value, default is TRUE, specifying if the return values should be automatically typecasted if possible.
`returnToR`	an optional logical, default is TRUE, specifying if the generated variables should be returned to R.
`mergeNamespaces`	an optional logical, default is FALSE, specifying if the internally generated temporary namespace should be merged with the name space __main__. See Details.
`override`	an optional logical value, default is FALSE, specifying how to merge the temporary namespace with the __main__ namespace.
`simplify`	an optional logical, if TRUE (default) R converts Python lists into R vectors whenever possible, else it translates Python lists always to R lists.

The function pyExecg executes the code in a temporary namespace, after the execution every variable from the namespace is returned to R. If the mergeNamespaces is set to TRUE the temporary namespace gets merged with the (global) namespace __main__. The logical variable override is used to control, if already existing variables in the namespace __main__ should be overridden, when a variable with the same name get's assigned to the temporary namespace. If a python object can't be converted to an R object it is assigned to the Python dictionary __R__.namespace and the type, id and an indicator if the object is a callable are returned.

Returns a list containing all the variables of the __main__ namespace.

if ( pyIsConnected() ){
# 1. assigns x to the global namespace
pyExec("x=4")
# 2. assigns y to the temp namespace
pyExecg("y=4", simplify=TRUE)
# 3. assign again to the temp namespace
pyExecg("
y=[i for i in range(1,4)]
x=[i for i in range(3,9)]
z=[i**2 for i in range(1,9)]
", returnValues=c("x", "z"), simplify=TRUE)
# 4. assign x to the temp namespace, x gets returned as vector
pyExecg("x=[i for i in range(0,5)]", simplify=TRUE)
# 5. assign x to the temp namespace, x gets returned as list
pyExecg("x=[i for i in range(0,5)]", simplify=FALSE)
# 6. x is still 4 since except assignment 1 all other assignments
#    took place in the temp namespace
pyPrint("x")
# 7. note y has never been assigned to the main namespace
"y" %in% pyDir()
# 8. since mergeNamespaces is TRUE PythonInR will try
#     to assign x to the main namespace but since override is
#     by default FALSE and x already exists in the main namespace
#     x will not be changed
pyExecg("x=10", simplify=TRUE, mergeNamespaces=TRUE)
# 9. there is no y in the main namespace therefore it can be assigned
pyExecg("y=10", simplify=TRUE, mergeNamespaces=TRUE)
pyPrint("x") # NOTE: x is still unchanged!
pyPrint("y") # NOTE: a value has been assigned to y!
# 10. since override is now TRUE the value of x will be changed in the
#      main namespace
pyExecg("x=10", simplify=TRUE, mergeNamespaces=TRUE, override=TRUE)
pyPrint("x") # NOTE: x is changed now!
# 11. get an object which can't be typecast to an R object
#     pyExecg does not transform these objects automatically
pyExec("import os")
z <- pyExecg("x = os")
os <- PythonInR:::pyTransformReturn(z[[1]])
os$getcwd()
}