+   

Using Delphi and Python together

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.

Here is an example of a finished app.

Related 'Python for Delphi' Links on this site:

return to main Andy Patterns home page

Introduction and Tutorial

Introduction

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.

Installation

Install Python for win32 Official distribution installer           

Then install the Python for Delphi components from
     http://www.multimania.com/marat/delphi/python.htm    

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:

1. Create a new Form
2. Drop a TMemo (or a TRichEdit)
3. Drop a TPythonGUIInputOutput 
   for displaying Python's messages
4. Drop a TMemo for the source code
5. Drop a TPythonEngine
6. Connect the attribute IO of the 
   TPythonEngine to the 
   TPythonGUIInputOutput.
7. Connect the attribute Output of 
   TPythonGUIInputOutput to 
   the TRichEdit.
8. Drop a TButton and 
   call it "Execute script"
9. Double-click on the button and add:

     PythonEngine1.ExecStrings( Memo1.Lines );    

10. Write in the Memo1: some python code e.g. print 2+2 or 
    that pictured below
11. 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.

  procedure PyExe(cmds: string; 
               engine: TAtomPythonEngine);    

So that you can do things like:

  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.

1. Create a new form, add a PythonEngine component and a PythonInputOutput component.
2. Wire them together (Python engine's IO property to point to the PythonInputOutput component)
3. 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. 

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:

1. 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.
2. Drag down two PythonDelphiVar components and name them HEADERVAR and RESULTVAR.  Set the VarName properties to the same as their names.
3. Create a button with the code:

procedure TForm2.Button2Click(Sender: TObject);
begin
    PyExeFile('unit2.py', PE);
end;

The Python side

4. 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:

print "Welcome to Python unit2"
HEADERVAR.Value = '----- Welcome -------'
RESULTVAR.Value = 200 * 3

Now run the delphi form and press the button.  Our PythonDelphiVar components should be populated.  How do we know? 

5. 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 named RESULTVAR.

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. 

procedure TForm2.Button5Click(Sender: TObject);
begin
  PyExe('calcAvg("' + edit1.text + '")', PE);
  showmessage( RESULTVAR.ValueAsString );
end;

    yields 13.  Success!

Direct access to Python Classes

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:

1. 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.
2. Add AndyDelphiPy, ComCtrls, pythonAtom units to your uses clause, e.g.

implementation

uses AndyDelphiPy, ComCtrls, pythonAtom;

var
   aCustomer : OleVariant;

3. 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 pdvsimply 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.

4. 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:

  aCustomer.Surname := 'Bloggs' ;
  aCustomer.Address := '23 Smith st.' ;
  inc( aCustomer.NumOrders ); 
  showmessage( 'Customer info: ' + 
      aCustomer.RunReport() );

That's it for the Delphi side of things. 

The Python side:

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).

 
          plus

Advanced topic: Here is a discussion and tips on python for delphi deployment issues.

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:

return to main Andy Patterns home page

if Boolean( mypythonclassinstance.somemethod()) then
    ....

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;    

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;    

  SysModule.path.append(LIBDLL);
  SysModule.path.append(LIB);
end;    

procedure TForm1.btnClearSyspathToJustLibClick(Sender: TObject);
var
  currdir, libdir : string;
begin
  currdir := ExtractFilePath( Application.ExeName );    

  libdir := EnsurePathHasDoubleSlashes(libdir);    

  libdir := currdir + 'Lib';    

  SysModule.path := NewPythonList;      
  // Relies on Jan 2002 install of python for Delphi components    

  SysModule.path.append(currdir);
  SysModule.path.append(libdir);
end;    

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;    

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;    

procedure TForm1.minidomLoadClick(Sender: TObject);
var
  m, doc, top : variant;
  s : string;
begin
  fixSysPath;
  displaySysPath(ListBox1);    

  m := Import('base64');
  showmessage(m);
  s := m.encodestring(

);
  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;    

var
  mymodule, obj: variant;
begin    

mymodule := Import('LoginMgr');
obj := mymodule.LoginMgr();
obj.somemethod()    // call the method    

v1 := VarPythonCreate(1);
v2 := VarPythonCreate(2);    

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]          

list.sort()    

v1 := VarPythonCreate(1);
v2 := v1 + 'hello'; --> Python exception    

v2 := 'hello' + v1;     

v2 := VarPythonCreate('hello') + v1; --> Python exception  

v2 := v1 + 'hello';     

v1 := VarPythonCreate([1, 2, 3]);
v2 := v1 + VarPythonCreate([4, 5, 6]); --> you'll get: [1, 2, 3, 4, 5, 6]          

GetPythonEngine.ExecString('x = 2');
ShowMessage( MainModule.x ); // will display 2          

myModule := Import('myModule');
myModule.foo(bar);          

v := VarPythonCreate(myPythonObjectPointer);
v := VarPythonCreate(1);
v := VarPythonCreate('abc');
v := VarPythonCreate(3.14);
v := VarPythonCreate(True);
v := VarPythonCreate(VarArrayOf([1, 2, 3]));
v := VarPythonCreate([1, 2, 3]);
v := VarPythonCreate([1, 2, 3], stTuple);
v := None;
v := NewPythonList;
v := NewPythonList(3);
v := NewPythonDict;          

ptr := ExtractPythonObjectFrom(v);          

VarIsPython(v)
VarIsSequence(v)
VarIsMapping(v)
VarIsNumber(v)
...          

VarIsSame(v1, v2)          

VarIsInstanceOf(AInstance, AClass)          

VarIsSubclassOf(ADerived, AClass)          

  VarIsNone(v)
or
  v = None
or
  VarIsSame(v, None)         

v := MainModule.MyClass()          

cl := MainModule.MyClass; // cl refers to MyClass
v := cl(); // won't work because Delphi refuses to compile it!         

if Boolean(list.Contains(1)) then ...          

鲜花

握手

雷人

路过

鸡蛋

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期
11-06 可心卡盟:win10系统火狐flash插件崩溃怎么
11-06 亲亲特价:怎么删除回收站图标
11-06 济南大学虚拟社区:鲁大师节能降温的具体办
11-06 xlueops.exe:无线网络安装向导
11-06 女斗合众国:win7系统cf与主机连接不稳定怎
11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头
11-06 qizideyouhuo:应用程序无法正常启动0xc0000
11-06 ipz-185:win7系统vcf文件怎么打开
11-06 傻哥蹦迪:win10系统s4怎么打开usb调试
11-06 八神浩树gtaste:回收站清空了怎么恢复
11-06 妖尾之黑色守护:win10系统电脑没有1440x900
11-06 校园至尊魔王小说:win7系统浏览网页时字体
11-06 女斗合众国:win10系统访问共享文件夹提示请
11-06 tokyo hot n0654:恢复win7系统默认字体一招
11-06 雨酷仙境:设置win7系统转移临时文件夹腾出
11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原
11-06 tunespotting:win10系统火狐flash插件总是
11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什
11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密
11-06 博益网首页:ao3网页版进入不了解决方法
11-06 漏斗子专栏: 网站数据分析小白易懂精华篇
11-06 见证双虹怎么做:win7系统开启telnet命令的
11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务
11-06 国光中学校歌:提交网站到alexa查询详细步骤
11-06 西安有情天:静态网页和动态网页的区别
11-06 红木雅尚斋:外部链接构造对网站的好处
11-06 前官礼遇：防止域名劫持–增强域安全性的10
11-06 密传二转答案: 中文分词算法有哪些
11-06 金泉家园邮编:百度快照劫持的表现及应对方

上一篇：

用Matlab求解微分方程发布时间：2022-07-18

下一篇：

matlab——微分方程发布时间：2022-07-18

热门推荐

More+

• 

  PacktPublishing/Python-Machine-Learning-

• 

  CVE-2022-31137

• 

  sussillo/hfopt-matlab: A parallel, cpu-b

• 

  鲁东大学一米网:Win7系统USB驱动器RAM的操

• 

  urbanairship/php-library2: Urban Airship

热门话题

More+

2022-11-06
剪的笔顺,诠释剪的笔画,认识剪的部首

florent37/ViewAnimator: A fluent Android
2022-08-15

florent37/Shrine-MaterialDesign2: implem
2022-08-17

CVE-2020-36276
2022-09-23

六六分期app的软件客服如何联系？(六六分期
2023-10-27

doraiso/Mastodon
2022-08-18

阅读排行榜

1 六六分期app的软件客服如何联系？(六六分期

六六分期app的软件客服如何联系？不知道吗？加qq群【895510560】即可！标题：六六分期
阅读：9299|2023-10-27
2 可心卡盟:win10系统火狐flash插件崩溃怎么

今天小编告诉大家如何处理win10系统火狐flash插件总是崩溃的问题，可能很多用户都不知
阅读：6606|2022-11-06
3 亲亲特价:怎么删除回收站图标

今天小编告诉大家如何对win10系统删除桌面回收站图标进行设置，可能很多用户都不知道
阅读：5500|2022-11-06
4 济南大学虚拟社区:鲁大师节能降温的具体办

今天小编告诉大家如何对win10系统电脑设置节能降温的设置方法，想必大家都遇到过需要
阅读：5987|2022-11-06
5 xlueops.exe:无线网络安装向导

我们在使用xp系统的过程中,经常需要对xp系统无线网络安装向导设置进行设置，可能很多
阅读：5858|2022-11-06
6 女斗合众国:win7系统cf与主机连接不稳定怎

今天小编告诉大家如何处理win7系统玩cf老是与主机连接不稳定的问题，可能很多用户都不
阅读：6228|2022-11-06
7 0xc000022-[cf烟雾头]cf怎么调烟雾头

电脑对日常生活的重要性小编就不多说了，可是一旦碰到win7系统设置cf烟雾头的问题，很
阅读：5812|2022-11-06
8 qizideyouhuo:应用程序无法正常启动0xc0000

我们在日常使用电脑的时候，有的小伙伴们可能在打开应用的时候会遇见提示应用程序无法
阅读：5282|2022-11-06
9 ipz-185:win7系统vcf文件怎么打开

今天小编告诉大家如何对win7系统打开vcf文件进行设置，可能很多用户都不知道怎么对win
阅读：5656|2022-11-06
10 傻哥蹦迪:win10系统s4怎么打开usb调试

今天小编告诉大家如何对win10系统s4开启USB调试模式进行设置，可能很多用户都不知道怎
阅读：5004|2022-11-06

• 关于我们

  创业团队 加入我们 媒体报道 合作伙伴 公益事业

• 产品与服务

  寻求合作 项目投资 干货视频 经理人培训 招聘代理

• 解决方案

  一站式 制造业 教育科研 行业案例

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服

地址：深圳市南山区西丽大学城创智工业园

电邮：jeky_zhao#qq.com

移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap