Talk for the Australian Delphi User Group (ADUG), July and August 2001 -Andy Bulka [email protected]
Delphi = a great object oriented language, and a fantastic RAD environment and framework. You can build excellent GUI's in Delphi that run very fast and have a small .EXE footprint. Runs on linux too. There is a free version of Delphi, too.
Python = is rapidly rising in popularity due to its pseudo-code-like, syntactically minimalist but straightforward syntax. Like the Delphi community, the Python community of programmers has a nice feel about it, and it is committed to developing rich, high quality, open-source class libraries for Python - without the hype of Java.
This paper will demonstrate how to incorporate Python in any of your Delphi apps! Or conversely, how to use Delphi as a GUI for your python apps.
tutorial - Andy's Python Delphi Tutorial - Getting started with the basics. Also use these techniques if you are using Delphi 5 or below, and Python 2.0 or below. Includes info on getting these free components.
code - Here are Andy's Extensions - a delphi unit that adds a few utility functions to Python for Delphi.
tutorial - Here is a later tutorial using the Latest Techniques in Python for Delphi - use these if you have Delphi 6 and Python 2.1 or higher.
animated slideshow tutorial - Here is an animated visual viewlet demo of using the Python for Delphi components to build a Delphi app that talks to python.
example and screenshot of a Delphi GUI application which uses python code for all its business logic.
Create classes in python and have Delphi use these classes as if they were native Delphi classes! Benefit: python can do all the business logic and hard work, whilst Delphi can be used for the GUI and application framework etc.
The interactive shell and fast development time in python makes building business logic here. Define your domain classes and build all the units that do work. Only use Delphi for GUI.
On the other hand, if you want python to talk to and control delphi, then use COM.
Python for Delphi is a set of components that wrap up the Python 1.5 Dll into Delphi. They let you easily execute Python scripts, create new Python modules and new Python types. You can create Python extensions as Dlls and much more, including being able to create classes in python and have Delphi use these classes as if they were native Delphi classes!
so you finish up with the following palette:
which are the engine, the atomEngine, pythonDelphiVar, etc. Note: You only need to use about three of these components to do most of your python-delphi work, the rest are mostly historical or very advanced.
Basic Use - A simple test
A simple Python evaluator:
Create a new Form
Drop a TMemo (or a TRichEdit)
Drop a TPythonGUIInputOutput for displaying Python's messages
Drop a TMemo for the source code
Drop a TPythonEngine
Connect the attribute IO of the TPythonEngine to the TPythonGUIInputOutput.
Connect the attribute Output of TPythonGUIInputOutput to the TRichEdit.
Drop a TButton and call it "Execute script"
Double-click on the button and add:
PythonEngine1.ExecStrings( Memo1.Lines );
Write in the Memo1: some python code e.g. print 2+2 or that pictured below
Click on the Execute button
click the button and
python is working with Delphi at a rudimentary level.
The above demonstration is an example of sending strings of code to the python interpreter and receiving Python standard output. You can drive python in this way as much as you like, by pumping text commands to it
PythonEngine.ExecStrings( commandLines )
The above Delphi component wrapper method is not always convenient, since ExecStrings expects commandLines to be a TStrings type, whereas sometimes you want to send a single string to the python interpreter / engine (and not have to create a stringlist) So I wrote a wrapper procedure PyExe (see AndysPythonDelphi extensions) which just takes a string. You can also send multiple lines to PyExe by separating lines with #13 (carriage return) or linefeed.
PyExe('print 5');
PyExe('print 5+23'+#13+'print "welcome"');
// note two commands here
Controlling where Python standard output goes
Every Delphi form must have a PythonEngine component and a PythonInputOutput component.
There are two types of 'PythonIO' components - one that directs all output to a memo or richEdit, or you can use an IO component which lets you define a custom event handler to handle the python output. You can redirect output to raize codesite or even to the standard Delphi Debug Event Log Window: e.g.
Create a new form, add a PythonEngine component and a PythonInputOutput component.
Wire them together (Python engine's IO property to point to the PythonInputOutput component)
Redirect all python standard output to the standard Delphi debug console, by double clicking on the PythonInputOutput component's OnSendData event and putting in the code OutputDebugString( PChar(Data));
PythonDelphiVars
To communicate between Delphi and Python at a deeper level we use the Delphi PythonDelphiVar component. It is a piece of Delphi that the python interpreter / engine can actually see! It looks like this:
The most important PythonDelphiVar component property is VarName property which is the name by which python 'sees' this component.
The Name property of the PythonDelphiVar component is, of course, how Delphi refers to the PythonDelphiVar component.
The VarName property of the PythonDelphiVar component is how the Python side refers to the PythonDelphiVar component.
In the picture above, from Python's point of view, I have called the PythonDelphiVar component VAR1 which means we can write Python code like:
PyExe('VAR1.Value = 101');
or in a python script, just simply
VAR1.Value = 101
which results in the PythonDelphiVar component having a value of 101. Delphi can access this component's value with
PythonDelphiVar1.ValueAsString
TIP: In practice, I use the convention of making the name of each PythonDelphiVar component and its VarName property the same.
Example #1 - Running an entire python program and storing the results in a set of PythonDelphiVar components.
All Delphi does is trigger off the script (say when a button get hit) and then retieves the results from the PythonDelphiVar components.
The Delphi side:
Create a new form, add a PythonEngine component (name it PE) and a PythonInputOutput component. Wire them together as previously discussed in controlling where the Python output goes to, above.
Drag down two PythonDelphiVar components and name them HEADERVAR and RESULTVAR. Set the VarName properties to the same as their names.
Create a button with the code:
procedure TForm2.Button2Click(Sender: TObject);
begin
PyExeFile('unit2.py', PE);
end;
The Python side
Create a python unit called unit2.py and put it in the same folder as your delphi units. Add the following code to the python unit:
Now run the delphi form and press the button. Our PythonDelphiVar components should be populated. How do we know?
Just add another button with the code:
procedure TForm2.Button3Click(Sender: TObject);
begin
showmessage( HEADERVAR.ValueAsString
+#13+ RESULTVAR.ValueAsString );
end;
Example #2 - Loading an external python program and calling a function in it, storing the result in a PythonDelphiVar component.
The Python side
Modify the unit2.py python script as follows, to include a function which takes a comma separated list of numbers and returns the sum of those numbers. The result is stored in a PythonDelphiVar component namedRESULTVAR.
import string
def calcAvg(str):
total = 0
vallist = map(lambda n: int(n), string.split(str,','))
for val in vallist:
total += val
RESULTVAR.Value = total / len(vallist)
The Delphi side:
procedure TForm2.FormCreate(Sender: TObject);
begin
PyExeFile('unit2.py', PE);
// this loads in the python class
end;
procedure TForm2.Button4Click(Sender: TObject);
begin
PyExe('calcAvg("1,5,10")', PE);
showmessage( RESULTVAR.ValueAsString );
end;
Now add an enhancement where, on the Delphi side, you allow the user to type in the list he or she wants to calculate the average on. Add an edit component and a button with the following code.
First we used stdout to communicate between Delphi and Python.
Then we used special pigeon holes ( PythonDelphiVar components ) to communicate between Delphi and Python.
Now we are going to learn how to gain access to actual Python classes and instances, and call the methods of those instances using normal Delphi dot notation. And of course being able to set and get properties of those instances would be cool too, wouldn't it?
Using TPythonAtom
Basically the technique is to define, in Delphi, some OleVariant variables which hold references to Python objects. We can then access methods and properties on these python objects using the familiar dot syntax that we use in Delphi (and most other languages) e.g.
pythonicCustomer.Address := '23 Smith st.' ;
pythonicCustomer.RunReport() ;
Official documentation on this technique is found in Demo12 of the examples that come with the Python for Delphi components. "Simply add the PythonAtom in the uses clause, declare a new var of type OleVariant and call the function getAtom( any Python object ). It will return a new OleVariant that will let you access properties or methods very simply, as you would do with Word !" See also latest features. Note:if you don't understand the preceding paragraph, that's ok, since you won't have to know about PythonAtom in the next examples, because I have wrapped the difficult stuff up in a simple function or two.
The Delphi side:
Create a new form, and drag down the pythonAtomEngine component and name it PE. Drop a TPythonGUIInputOutput for displaying Python's messages. Connect this to your richtext or memo component. More info on redirecting python IO earlier in this article.
Add AndyDelphiPy, ComCtrls, pythonAtom units to your uses clause, e.g.
implementation
uses AndyDelphiPy, ComCtrls, pythonAtom;
var
aCustomer : OleVariant;
Then in the formshow or formCreate event add the code that loads the main unit of your python code..
procedure TfrmMain.FormShow(Sender: TObject);
begin
PyExeFile('YourPythonApp.py', PE);
At this point the python interpreter has loaded and executed your python classes and any code in the unit you are loading. Now we can create instances of python classes in Delphi and store the references to them in variants.
aCustomer := PyClass('Customer()', pdv, PE);
The above code shows how to instantiate a python class Customer and store that reference in a Delphi variant aCustomer.
The pdv is a necessary intermediate python delphi var used for the instantiation and is not used subsequently. Drag and drop a PythonDelphiVar component and name it "pdv" (the pdv simply stands for python delphi var) and set the Varname property to "pdv" [ ASIDE: ** Matthew Vincent. suggested during the talk that I could perhaps create this pdv component within my PyClass wrapper function, thus eliminating the pdv parameter from the PyClass function. I couldn't get this to work, as the pythonDelphiVar component seems to need to be created at design time - creating it at runtime with the form as the owner worked, but didn't actually satisfy the python engine. Even if this would have worked, we would still have to specify the owning form as a paramter to PyClass, which means we would have gained nothing in terms of the number of parameters we would have had to pass.... ]
Note also that the PyClass delphi function is another one of the AndysPythonDelphi extensions which simplifies the process of instantiating a python class from Delphi. Normally you have to deal with a couple of lines of code and some reference counting, in order to instantiate a python class. By using my wrapper function PyClass the process is reduced to a simple one line call.
When this particular example delphi app runs, after the execution of the FormShow event, the customer instance will have been created and will be ready to be used. Let's add a button so that we can manipulate that instance. Create a button and add the following code:
Now let's work on the python side of things, which only involved creating a single python unit named YourPythonApp.py in the same folder as your delphi app.
class Customer:
def __init__(self, surname=''):
self.Surname = surname
self.Address = 'unknown address'
self.NumOrders = 0
def RunReport(self):
return 'Customer ' + self.Surname +
' of ' + self.Address +
' has made ' + `self.NumOrders` +
' orders so far.'
Note that the method __init__ in the above class is the constructor method (like .Create in Delphi).
Running the Delphi app and clicking the button should give you:
Success!
Passing python objects as parameters
Your Delphi code can now interact seamlessly with python objects. One last thing to watch out for is the situation where your delphi code passes a python instance around as a parameter to other python methods, you cannot simply pass the variant reference e.g.
aCustomer.AddOrder(anOrder) # won't work
instead you must pass the pure python reference. So define a python method in each python class called something like 'myself' e.g.
class Order:
...
def myself(self):
return self
then you will be able to successfully:
aCustomer.AddOrder(anOrder.myself) # works
If you are lucky, you may only need to define the 'myself' function just once, perhaps in some Python base class. And of course you can call the function anything you like, just don't call it 'self' since that already reserved by both Delphi and Python.
Deployment
Easy - no registry settings or anything fancy.
As well as your compiled delphi executable, just add the python dll (only about 500 k) in the folder containing your app, plus a Lib folder containing any extra python units you are using. For example random.py and whrandom.py could be placed into the Lib folder if you had used them. The examples used in this article did not use any extra units (the string unit that we used for string.split is a "built in" unit and so does not need to be supplied with your app).
Andy's helpful minor extensions to Python-for-Delphi
These are Andy's extra high-level wrapper functions used and described in this article. These functions use and augment the standard Python-for-Delphi components.
More info on python
If you need further informations on Python, visit the official Web site at http://www.python.org/
Andy's Easy Tips on Reading Python Code
Python is a simple, straightforward and elegant language. It uses standard conventions of accessing methods and properties and is fully OO. Types are associated with objects not variables, so you don’t need to declare variables. Functions are called like afunction(param1, param2) and objects are created from classes the same way e.g. o = MyClass(). Python is case sensitive.
There are no begin end reserved words or { } symbols in Python to indicate code blocks – this is done through indentation. The colon in if lzt: simply means ‘then’. The idiom of testing objects (rather than expressions) in an if statement makes sense as python treats empty lists, None and 0 as false.
Python understands named parameters e.g. In a method call, afunction(From=None) means you are passing None (null / nil) as the ‘From’ parameter, whilst in a method definition From=None means that if the caller does not supply this parameter, then it will default to None.
The first argument of all methods defined inside classes must be ‘self’. This argument fills the role of the reserved word this in C++ or Java or self in Delphi. Most languages supply this parameter (a reference to the current instance) implicitly whereas Python makes this concept explicit. At runtime this parameter is supplied by the system, not the caller of the method, thus the def AddOrder(self, order) method in reality takes one parameter when calling it: AddOrder( order ).
The statement pass means do nothing.
You can return multiple items at once e.g.return (2, 50) and also assign multiple items at once e.g.x, y, z = 0 or even expressions like result, status, errmsg = myfunction(1, 90).
Other class files/modules are imported using import somefile. __init__methods are simply constructors. Finally, a lambda is just a one line function that reads functionname = lambda paramlist : returnedexpression.
Both Python and JPython (Java Python, now called Jython) are open source, free and available from http://www.python.org/
:-)
Related 'Python for Delphi' Links on this site:
tutorial - Andy's Python Delphi Tutorial - Getting started with the basics. Also use these techniques if you are using Delphi 5 or below, and Python 2.0 or below. Includes info on getting these free components.
code - Here are Andy's Extensions - a delphi unit that adds a few utility functions to Python for Delphi.
tutorial - Here is a later tutorial using the Latest Techniques in Python for Delphi - use these if you have Delphi 6 and Python 2.1 or higher.
animated slideshow tutorial - Here is an animated visual viewlet demo of using the Python for Delphi components to build a Delphi app that talks to python.
example and screenshot of a Delphi GUI application which uses python code for all its business logic.
Andy's helpful minor extensions to Python-for-Delphi
These are Andy's Delphi wrapper functions used and described in this article.
These functions make use of and augment the standard Python-for-Delphi components.
Save the following Delphi code as AndyDelphiPy.pas and use this unit as necessary when programming with Python-for-Delphi components . Of course, ensure it is in your delphi compilation library path.
procedure PyExe(cmds: string; engine: TAtomPythonEngine);
var
s: TStringList;
begin
s := TStringList.create;
try
s.text := cmds;
engine.ExecStrings( s );
finally
s.free;
end;
end;
procedure PyExeFile(fp: string; engine: TAtomPythonEngine);
var
s: TStringList;
begin
s := TStringList.create;
try
if pos(':\', fp) = 0 then
fp := ExtractFilePath(Application.ExeName) + fp;
s.LoadFromFile( fp );
engine.ExecStrings( s );
finally
s.free;
end;
end;
function PyVarToAtom(pydelphivar : TPythonDelphiVar; engine: TAtomPythonEngine): OleVariant;
var
v: PPyObject;
begin
v := pydelphivar.ValueObject;
result := getAtom(v);
GetPythonEngine.Py_XDECREF(v);
end;
function PyClass(pyclass: string; pydelphivar : TPythonDelphiVar; engine: TAtomPythonEngine): OleVariant;;
begin
PyExe(pydelphivar.VarName + '.Value = ' + pyclass, engine);
result := PyVarToAtom(pydelphivar, engine);
end;
procedure PyConsoleOut(const Data: String);
begin
OutputDebugString( PChar(Data));
end;
end.
Related 'Python for Delphi' Links on this site:
tutorial - Andy's Python Delphi Tutorial - Getting started with the basics. Also use these techniques if you are using Delphi 5 or below, and Python 2.0 or below. Includes info on getting these free components.
code - Here are Andy's Extensions - a delphi unit that adds a few utility functions to Python for Delphi.
tutorial - Here is a later tutorial using the Latest Techniques in Python for Delphi - use these if you have Delphi 6 and Python 2.1 or higher.
animated slideshow tutorial - Here is an animated visual viewlet demo of using the Python for Delphi components to build a Delphi app that talks to python.
example and screenshot of a Delphi GUI application which uses python code for all its business logic.
tutorial - Andy's Python Delphi Tutorial - Getting started with the basics. Also use these techniques if you are using Delphi 5 or below, and Python 2.0 or below. Includes info on getting these free components.
code - Here are Andy's Extensions - a delphi unit that adds a few utility functions to Python for Delphi.
tutorial - Here is a later tutorial using the Latest Techniques in Python for Delphi - use these if you have Delphi 6 and Python 2.1 or higher.
animated slideshow tutorial - Here is an animated visual viewlet demo of using the Python for Delphi components to build a Delphi app that talks to python.
example and screenshot of a Delphi GUI application which uses python code for all its business logic.
As of October 2001 a totally new way of talking to python we developed, within the Python for Delphi framework. You use variants, and get smart references to python objects.
So whilst before you could create a reference to an instance to a class, in an olevariant. Now we use variants.
Also we can instantiate classes directly (without needing to use my PyClass() function etc. etc.
The latest way of programming in python for Delphi if you have Delphi 6 and python 2.1 or higher.
-Andy Bulka.
These techniques are demonstrated in Demo25 in the examples folder of your Python for Delphi distribution.
The old vs. the new ways.
Because Delphi 6 has custom variants, they can point to specific smart proxies for python objects. Before Delphi 6, you could have an oleVariant pointing to a python instance, but you couldn't do the smart things like know that it was a list type etc.
The following examples assume you have a module called LoginMgr.py in the python path or in the same folder as your application .exe that you have built in Delphi. Note that the python file LoginMgr.py contains within it a python class called LoginMgr which has a method called somemethod.
Note that it it possible to slightly mix the old and new way, so that if you use the AndyDelphiPy.PyExeFile('LoginMgr.py', PE); to import the module then you can then switch to the new way, declare an obj: variant; then instantiate an instance using obj := MainModule.LoginMgr(); However you still need Delphi 6 and so you might as well just use the new way properly.
Widestrings
Declare your delphi strings widestrings if you want to get more than 255 chars back from calls to python methods that return strings. e.g.
var s : widestring; begin s := mypythonclassinstance.somemethod() ; showmessage(s) ;
Booleans
If your python method call returns 1 or 0 and this is supposed to be interpreted as a boolean, then cast it inside Delphi e.g.
if Boolean( mypythonclassinstance.somemethod()) then
....
Accessing syspath directly
Here is a function that accesses a global variable called SysModule and access the syspath directly.
This function also calls VarIsPythonSequence which tests to see if the parameter passed is a list or not.
procedure TForm1.Button2Click(Sender: TObject);
const
LIB = 'E:\\ZopeWebSite\\bin\\lib';
LIBDLL = 'E:\\ZopeWebSite\\bin\\DLLs';
var
re : variant;
m : variant;
begin
memo1.lines.Add('SysModule.path is ' + SysModule.path);
memo1.lines.Add('');
Assert(VarIsPythonSequence(SysModule.path));
displaySysPath(ListBox1);
if not Boolean(SysModule.path.Contains(LIB)) then
SysModule.path.insert(0,LIB);
SysModule.path.append(LIBDLL);
memo1.lines.Add('SysModule.path now is ' + \
SysModule.path + #13#13);
displaySysPath(ListBox1);
fixSysPath;
re := Import('re');
showmessage(re);
m := Import('xml.dom.minidom');
showmessage(m);
end;
Playing with sys paths
This is an example of how to set the python system path as seen by delphi's instance of the python interpreter (as represented by the pythonEngine component). Note that it is imperative that you have \\ as the slashed in your path as otherwise things like \fred will actually be interpreted as \f (whatever that escaped character is) plus 'red'.
Technique 1
procedure TForm1.fixSysPath;
const
LIB = 'E:\\ZopeWebSite\bin\\lib';
LIBDLL = 'E:\\ZopeWebSite\\bin\\DLLs';
begin
// this is illegal
// SysModule.path.Clear;
// this will work with latest python for delphi components OK.
//SysModule.path := NewPythonList;
// this is a boring but effective solution as well.
while SysModule.path.Length > 1 do
SysModule.path.pop;
procedure TForm1.btnClearSyspathToJustLibClick(Sender: TObject);
var
currdir, libdir : string;
begin
currdir := ExtractFilePath( Application.ExeName );
NOTE: Simply putting a window path as the currdir will ultimately fail since the paths returned by Delphi have single slashes and python needs wither unix slashes or \\ slashes. See here for an algorithm to handle this.
libdir := EnsurePathHasDoubleSlashes(libdir);
libdir := currdir + 'Lib';
SysModule.path := NewPythonList;
// Relies on Jan 2002 install of python for Delphi components
Supplimentary utility to display the python syspath in a delphi gui control.
procedure TForm1.btnDisplaySysPathClick(Sender: TObject); begin ListBox1.clear; displaySysPath(ListBox1); end;
Writing a Delphi function that uses a python function to do the hard work.
Here is an example of writing a delphi utility function that takes a string, and splits it up (delimited by comma) and puts the result into a delphi list box. We are using python split function to do the splitting - cool eh?
procedure TForm1.splitAstring(str:string; lstbox: TListBox);
var
s, lzt : variant;
i : integer;
begin
s := VarPythonCreate(str);
// convert normal string into a python string.
lzt := s.split(',');
for i := 0 to lzt.Length-1 do
lstbox.Items.Add(lzt.GetItem(i))
end;
Displaying the python syspath in a delphi listbox
Even though we have a pointer to a python list object (via a Delphi variant), we still have to call .GetItem(i) on a python list rather than the python syntax of lzt[i] - why?Because we are in Delphi and thus we cannot use python syntax.
procedure TForm1.displaySysPath(lstbox: TListBox);
var
lzt : variant;
i : integer;
begin
Assert(VarIsPythonSequence(SysModule.path));
lzt := SysModule.path;
for i := 0 to lzt.Length-1 do
lstbox.Items.Add(lzt.GetItem(i));
lstbox.Items.Add('----------------------------------');
end;
Loading python base64 and minidom module and processing XML in Delphi
procedure TForm1.minidomLoadClick(Sender: TObject);
var
m, doc, top : variant;
s : string;
begin
fixSysPath;
displaySysPath(ListBox1);
m := Import('base64');
showmessage(m);
s := m.encodestring('this is some text which I am going to encode then decode again.');
showmessage(s + #13+#13 + m.decodestring(s));
m := Import('xml.dom.minidom');
doc := m.Document();
showmessage(doc);
top := doc.createElement( 'Workspace' );
top.setAttribute('Version', '1.1 beta4');
doc.appendChild(top);
s := doc.toxml();
showmessage('doc.toxml()' + #13+#13 + s);
end;
Importing your own class
Ensure you have a TPythonAtomEngine or TPythonEngine onto your form or datamodule.
It wraps a Python object and lets you act on it (call methods or use properties) like you would do in Python, and like you did with PythonAtom, but there are differences:
the variant always maintains its link to a Python object, and is never casted to a basic variant type (integer, string, array) when returning a value, like it was with PythonAtom.
v1 + v2 will return a new variant that will hold the a Python object that is the result of the addition, and the addition will be performed by Python itself, using the PyNumber_Add API.
Previously, with PythonAtom, if you accessed a property or called a method, the value returned by Python was automatically converted to a basic variant type, or wrapped up into an PythonAtom variant otherwise.
The main advantage of this solution was to convert Python sequences (lists or tuples) into array of variants, letting us access them using the index operator (list[x]).
Now, it is not possible anymore, as the returned sequence will be returned as a new custom variant, and our custom variant doesn't support indexing!!! I don't know how to do it? Maybe adding the flag varArray to our VType and setting array bounds that let us access any item, but I'm not sure... Anyway, it could work with sequences, but not with dictionaries, as it accepts any type as a key.
So, to work around this problem I added several special methods/properties:
foo.GetItem(index): same as foo[index]
foo.SetItem(index, value): same as foo[index] = value
foo.Length or foo.Length(): same as len(foo)
foo.GetSlice(index1, index2): same as foo[index1:index2]
foo.SetSlice(index1, index2, value): same as foo[index1:index2] = value
foo.Contains(value): same as value in foo
foo.DeleteItem(Index): same del foo[index]
Note that my special methods are not case sensitive.
Note also that you must use the parenthesis with functions or methods that have no argument, to distinguish your call with a property access:
list.sort()
if you write list.sort only, you'll get the instance method object instead of performing the sort action.
The advantage of the new solution is that you always work with the Python objects, and you can do anything you want with them, like you would in Python. The arithmetic operations, or comparisons, work the same, and you can't add an integer to a string, for instance, as you can with variants.
--> Python exception as hello is converted to a Python variant and then an addition is beformed between a number and a string, and Python does not like it!
There are several facility functions that let you test the different types of Python objects, or that let you import other Python modules, or access the None object.
Now, you can easily execute a Python script and then access the global vars of the main module:
GetPythonEngine.ExecString('x = 2');
ShowMessage( MainModule.x ); // will display 2
客服电话
APP下载
官方微信
请发表评论