Pythonic: Difference between revisions

From Octave
Jump to navigation Jump to search
Line 38: Line 38:
<!-- {{SyntaxHighlight| -->
<!-- {{SyntaxHighlight| -->
{{Code|pyeval optional argument|<syntaxhighlight lang="octave" style="font-size:13px">
{{Code|pyeval optional argument|<syntaxhighlight lang="octave" style="font-size:13px">
x = pyeval ("{1:'one',2:'two'}",@cell);
> x = pyeval ("{1:'one',2:'two'}",@cell);
x{1}
> x{1}
ans = one
ans = one
x{2}
> x{2}
ans = two
ans = two
x = pyeval ("{1:'one',2:'two'}",@char);
 
x
> x = pyeval ("{1:'one',2:'two'}",@char);
> x


x =  
x =  
Line 50: Line 51:
one
one
two
two
 
whos x
> whos x
Variables in the current scope:
Variables in the current scope:


Line 60: Line 61:
Total is 6 elements using 6 bytes
Total is 6 elements using 6 bytes


> x = pyeval ("[i for i in xrange(3)]",@double)
x =
0 1 2
</syntaxhighlight>}}
</syntaxhighlight>}}


The optional argument could be the constructor of an Octave class.
The optional argument could be the constructor of an Octave class.

Revision as of 19:51, 17 April 2016

There is a small project in development to bring a Python calling interface to Octave. The broad goal of this project is to add functions and types to Octave to allow calling Python functions directly from Octave.

Features

Features and capabilities of Octave's Python interface may include:

  • Import and call Python modules and functions from the Octave interpreter
  • Automatically convert basic Octave and Python types seamlessly between the two environments
  • Be able to handle arbitrary unknown Python objects (print their repr, store in a variable, pass back in to a Python function)
  • Store references to Python functions (and other "callables") and be able to call them as if they were function handles

Development

Project development is ongoing among a small group of developers. Communication takes place on the Octave maintainers mailing list. The official Mercurial repository is at http://hg.octave.org/pytave, but there is also a Bitbucket clone and a network of forks, for those who prefer that model of development, at https://bitbucket.org/mtmiller/pytave.

Pytave

This project is currently derived from an earlier project called Pytave, which was developed to work in the opposite direction, to allow Python to call Octave functions on an embedded Octave interpreter. The bulk of the project is in the code to convert between Octave and Python data types, so most of that is reusable and serves both purposes. As a side goal, we may continue to maintain the Python wrapper around Octave and incorporate that into Octave as well, so that Octave can provide its own native Python module.

Documentation

The current development needs to be documented. We are using doxygen for the documentation documentation.

Python from Octave

The conversion of Python's dict is not unique. For that we have decided to load a Python's dict as a structure. This works only when all the keys fo the dict are strings. When the keys are something else there is the option to use `repr` to create the fields of the Octave's struct, e.g.

Code: Conversion of Python's dict to structure
x = pyeval ("{1:'one',2:'two'}");
x.("1")
ans = one
x.("2")
ans = two

This would be the default behavior. We will extend pyeval to receive an optional argument specifying the Octave type that should be used as the output of the conversion, e.g. when the dict uses continuos numbers as keys one could do

Code: pyeval optional argument
> x = pyeval ("{1:'one',2:'two'}",@cell);
> x{1}
ans = one
> x{2}
ans = two

> x = pyeval ("{1:'one',2:'two'}",@char);
> x

x = 

one
two
 
> whos x
Variables in the current scope:

   Attr Name        Size                     Bytes  Class
   ==== ====        ====                     =====  ===== 
        x           2x3                          6  char

Total is 6 elements using 6 bytes

> x = pyeval ("[i for i in xrange(3)]",@double)
x =
0 1 2

The optional argument could be the constructor of an Octave class.