Python a C/C++
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Reklama

Python a C/C++Python a C/C++

 

Python a C/C++

Google       Google       27. 4. 2007       12 952×

Keď sa navrhuje aplikácia, často sa kladie doraz na to, aby bola modulárna, ľahko rozšíriteľná, aby sa dala ľahko upravovať podla potrieb. Pri takýchto myšlienkach si programátor nie raz povie, žeby nebolo zle ak by jeho aplikácia mala skriptovací jazyk.

Reklama
Reklama

Vyvinúť vlastný skriptovací jazyk v C nieje malé sústo a taktiež prináša viac nevýhod ako výhod. To však nemusí platiť ak sa človek rozhodne implementovať už existujúci interpreter. Práve v tomto ja osobne vidím jednu z najväčších výhod Perlu a Pythona. Totižto ich interpreter sa dá ľahko implementovať do C aplikácie a sú doslova predurčene na takéto využitie. Jedným z mnoho príkladov je napríklad 3D modelovacia aplikácia Blender, ktorej funkcionalitu môže užívateľ vylepšiť práve modulmi napísanými v Pythone. V tomto článku vám ukážem, ako môžete vykonávať vo vašej C aplikácii Python skript, ako môžete volať funkcie Pythonu, taktiež ako môžete volať C funkcie z Python skriptu. Tieto poznatky by vám mali umožniť obojstrannú interakciu medzi skriptom a C aplikáciou.

Počiatočné strasti a priepasti

Asi najproblematickejší krok je, že ako začať. Na úplnom začiatku bude nutne nastaviť náš kompilátor, naše vývojové prostredie na prácu s Python API. K tomu sú potrebne 2 základné kroky. Nastaviť cestu k python.h i ostatným hlavičkovým súborom, a pre linker nastaviť Python knižnicu. Tieto kroky sa líšia od toho aké vývojové prostredie a aký OS používate. Ak mame všetko správne nastavené, môžeme prejsť k napísaniu prvého príkladu.

main.c:


#include <Python.h>

int main()
{
   Py_Initialize();
   PyRun_SimpleString("print 'Hello World'");
   Py_Finalize();
   return 0;
}

Príklad je momentálne dosť strohý a veľa toho nedokáže. Na začiatku sa vola funkcia Py_Initialize(), ktorá vytvorí interpreter. Za ňou nasleduje PyRun_SimpleString(). Táto funkcia vykoná Python skript, ktorý jej predáme ako reťazec. Konkrétne ide o vypísanie textu 'Hello World' na výstup. Následne je volaná Py_Finalize(). Ta interpreter zruší a uprace za sebou pamäť. To nám na začiatok úplne stačí aby sme zistili, či máme všetko správne nastavené. Náš mini-program skompilujeme a spustíme.


sn3d@laptop$ g++ -I/cesta_k_python_h -L/cesta_k_python2.4_so -lpython2.4 -o out main.c
sn3d@laptop$ ./out
Hello World

Ak používate C++ prekladač a includujete iostream pred includovaním Python.h tak vtedy môže nastať nasledujúci warning:


warning: "_POSIX_C_SOURCE" redefined

Je to tak trošku bug Python headrov. Zbaviť sa ho môžete tým, že includovanie Python.h umiestnite pred includovanie iostream headru. Taktiež môžete naraziť na problém, že program sa skompilujte bez chyby, no po spustení nás program ovalí error správou, ktorá hovorí, že nieje možne nájsť libpython2.4.so knižnicu. V tomto prípade doporučujem ešte doplniť do LD_LIBRARY_PATH premennej prostredia cestu k tejto knižnici, alebo v prípade UBUNTU je potrebne tuto cestu vložiť do súboru /etc/ld.so.conf.

Pár slov ohľadom PyObject

V momente keď začnete používať API funkcie Pythonu alebo sa len letmo prejdete zrakom po dokumentácii, tak takmer všade natrafíte na typ PyObject. Je to zakladaný prvok všetkých API. PyObject reprezentuje akúkoľvek súčasť Python interpretera od globálnych premenných, všetkých možných funkcii v skripte, cez moduly a hodnoty, až po samotné prostredie interpretéra. PyObject obsahuje 2 dôležité informácie. Prvou je ukazovateľ na akýkoľvek objekt pythonu, a druha dôležitá informácia je počítadlo referencii. Python ma v sebe vstavaný mechanizmus garbage collectora, ktorý sa stará o správne uvoľnenie pamäti. Tento garbage collector uvoľňuje všetky tie objekty, u ktorých je práve toto počítadlo nulové. Keďže mi pristupujeme k Python interpreteru cez C kód, ktorý takýto pamäťový manažment nemá, musíme toto počítadlo pri inicializovaní Python objektu zvýšiť a naopak, pri ukončení prace znížiť. Na tuto činnosť slúži dvojica makro funkcii Py_INCREF(), ktorá zvýši počítadlo objektu o jeden a Py_DECREF(), ktorá naopak zníži počítadlo objektu o jeden.

Volanie Python funkcie

Keďže už mame základné korky za sebou, pustíme sa do niečoho zmysluplnejšieho. Zavoláme Python funkciu compute zo súboru scrip.py. Tato funkcia obdrží 2 číselné parametre, ktoré spočíta a jeden textový parameter, ktorý vypíše na výstup. Funkcia bude vracať číselný výsledok spočítania.

script.py:


def compute(a, b, text):
   print 'message is:', text
   c = a + b
   return c

print 'script.py loaded \n'

Teraz príde ta zaujímavejšia časť. Naprogramujeme aplikáciu, ktorá inicializuje prostredie interpretera. Ďalej načíta a vykoná súbor script.py. Ziska ukazovateľ na PyObject, ktorý reprezentuje v prostredí interpretera funkciu compute. Pripraví premenné, ktoré sa budú predávať tejto funkcii a zavolá funkciu. Nakoniec spracuje výsledok volania funkcie.

main.c:


#include <stdio.h>
#include <Python.h>

int main()
{
   //Deklaracia premenných.
   PyObject* pMain;
   PyObject* pMainDict;
   PyObject* pFunc;
   PyObject* pArgs;
   PyObject* pArgA;
   PyObject* pArgB;
   PyObject* pArgText;
   PyObject* pReturn;
   FILE*     file;
   long      retuned;

   //Inicializácia python interpretera.
   Py_Initialize();
   pMain = PyImport_AddModule("__main__");
   pMainDict = PyModule_GetDict(pMain);

   //Otvorenie súboru a jeho vykonanie v main module.
   file = fopen("script.py", "r");
   if (file) {
      PyRun_SimpleFile(file, "script.py");
   }

   //Vyhladanie existencie funkcie.
   pFunc = PyDict_GetItemString(pMainDict, "compute");
   if (PyCallable_Check(pFunc)) {

      //Prírava argumentov funkcie.
      pArgA    = PyInt_FromLong(1);
      pArgB    = PyInt_FromLong(3);
      pArgText = PyString_FromString("Hello Python");

      //Vytvorenie objektu argumentov.
      pArgs = PyTuple_New(3);
      PyTuple_SetItem(pArgs, 0, pArgA);
      PyTuple_SetItem(pArgs, 1, pArgB);
      PyTuple_SetItem(pArgs, 2, pArgText);

      //Volanie funkcie a spracovanie result hodnoty.
      pReturn = PyObject_CallObject(pFunc, pArgs);
      Py_DECREF(pArgs);

      //Spracovanie návratovej hodnoty.
      if (pReturn) {
         returned = PyInt_AsLong(pReturn);
         Py_DECREF(pReturn);
         printf("function return: %d\n", returned);
      }
   }

   Py_Finalize();
   return 0;
}

Na začiatku je deklarácia všetkých premenných použitých v main() funkcii. Všimnite si, že všetky premenné, ktoré budú ďalej použité v súvislosti z Pythonom, sú ukazovatele na PyObject o ktorom som sa už rozpisoval. Po deklarácii nasleduje inicializácia Python interpretera. Ta je však o niečo zložitejšia ako v prvom príklade. V Pythone je kód delený na moduly. Zakladaný modul sa vola __main__. Je to zakladaný modul, v ktorom sa vykoná script.py. Modul inicializujeme pomocou funkcie PyImport_AddModule(), ktorá vráti ukazovateľ na tento modul. To však nieje všetko. Na to aby sme mohli pristupovať k prvkom modulu, v našom prípade aby sme mohli zavolať funkciu, budeme potrebovať objekt Dictionary. Ide o akýsi priestor modulu, v ktorom sa nachádzajú globálne premenne, funkcie atď. Získame ho volaním funkcie PyModule_GetDict().

Python funkcia, ktorú chceme volať, sa nachádza v súbore script.py. Potrebujeme teda otvoriť tento súbor a nechať vykonať jeho kód, aby sa v __main__ module nachádzala tato funkcia. Súbor otvoríme pomocou bežnej funkcie fopen() a následne file descriptor predáme funkcii PyRun_SimpleFile(), ktorá skript vykoná.

Teraz nám už len stačí získať ukazovateľ na compute funkciu, predať jej argumenty a zavolať ju. Znie to celkom jednoducho. Ukazovateľ na funkciu získame nasledujúcim kódom.


   ...
   pFunc = PyDict_GetItemString(pMainDict, "compute");
   if (PyCallable_Check(pFunc)) {
   ...

Funkcia PyDict_GetItemString() vráti ukazovateľ na Python funkciu. PyDict_GetItemString() môže vrátiť akýkoľvek ukazovateľ na akýkoľvek prvok v module __main__, pci už je to spomínaná funkcia alebo napríklad globálna premenná. Pomocou funkcie PyCallable_Check() otestujeme, či funkcia existuje a či je možné túto funkciu volať. V prípade, že všetko je v poriadku, program pokračuje ďalej konvertovaním Céčkovských premenných na premenne ktorým rozumie Python.


   pArgA    = PyInt_FromLong(1);
   pArgB    = PyInt_FromLong(3);
   pArgText = PyString_FromString("Hello Python");
   ...

Všetky hodnoty, ktoré chceme preniesť do Pythonu, je potrebne skonvertovať. Python totižto nerozumie presne hodnotám v Céčku, taktiež textové reťazce fungujú odlišnejšie ako v Céčku. Pre tento účel existujú funkcie PyInt_FromLong, PyString_FromString. Python funkcia compute prijíma 3 argumenty. Prvé dva sú číselné a posledný je text. Najprv si teda pre hodnoty vytvoríme Python objekty spomínanými konverznými funkciami. Po konverzii budeme musieť vytvoriť objekt argumentov. Tento objekt sa volá Tuple(násobok) a môžeme si ho predstaviť ako zásobník do ktorého vložíme všetky hodnoty, ktoré chceme predať funkcii compute().


   ...
   //Vytvorenie objektu argumentov.
   pArgs = PyTuple_New(3);
   PyTuple_SetItem(pArgs, 0, pArgA);
   PyTuple_SetItem(pArgs, 1, pArgB);
   PyTuple_SetItem(pArgs, 2, pArgText);
   ...

Pomocou PyTuple_New() sa vytvorí Tuple objekt reprezentujúci argumentami. Funkcia potrebuje len jeden parameter, a tým je počet hodnôt-argumentov. Sled funkcii PyTuple_SetItem už len nastavuje hodnoty a ich pozíciu v Tuple objekte. Keď už máme ukazovateľ na funkciu a objekt reprezentujúci argumenty, s ktorými funkcia bude volána, tak môžeme prejsť k volaniu compute funkcie.


   ...
   pReturn = PyObject_CallObject(pFunc, pArgs);
   Py_DECREF(pArgs);

   //Spracovanie návratovej hodnoty.
   if (pReturn) {
      returned = PyInt_AsLong(pReturn);
      Py_DECREF(pReturn);
      printf("function return: %d\n", returned);

   }

Funkcia PyObject_CallObject() vykoná volanie Python funkcie s argumentami, vykoná kód funkcie a vráti ukazovateľ na návratovú hodnotu Python funkcie. V prípade, ak dôjde k zlyhaniu, funkcia vráti NULL. Nakoľko, už ďalej nebudeme potrebovať objekt pArgs, znížime počet referencii pomocou Py_DECREF(). Python funkcia compute nám vráti súčet hodnôt pArgA a pArgB. Ten je potrebne zase spätne konvertovať na hodnotu, ktorej rozumie Céčko. Na to nám poslúži funkcia PyInt_AsLong(), ktorá vráti číselnú hodnotu, ktorej už Céčko rozumie. Nakoniec zavoláme Py_Finalize(). Tá ukonči python interpreter v nasej aplikácii. Program by mal vypisovať nasledujúci text na výstup.


script.py loaded
message is:Hello Python
function return: 4

Volanie C funkcie

Predchádzajúci príklad je vcelku fajn, no na komplexnejšiu implementáciu pythona, ako skriptovacieho jazyka, nám to nestačí. Totižto, akosi nám začne chýbať spätná interakcia. Ako teda volať Céčkovskú funkciu s Pythona? Tak to si teraz hneď ukážeme. Zoberme si imaginárnu situáciu, že mame C funkciu computeEx(), ktorú chceme volať z Python skriptu. Túto funkciu budeme musieť obaliť ďalšou funkciou, ktorá sa postará o konvertovanie Python hodnôt na Céčkovské. Taktiež budeme musieť túto funkciu zaregistrovať, aby Python interpreter o nej vedel. Cely kód teda bude vyzerať nasledovne.

main.c:


#include <stdio.h>
#include <Python.h>

#define SCRIPT_FILE "script.py"

int computeEx(int a, const char* text)
{
   printf("C SAY: computeEx write:%s\n", text);
   return (a+a);
}


PyObject* computeExWrap(PyObject* self, PyObject* args)
{
   //Deklaracia premenných.
   PyObject* pResult;
   int       result;
   int       arg_a;
   char*     arg_text;

   //Konvertovanie python argumentov na C hodnoty.
   PyArg_ParseTuple(args, "is", &arg_a, &arg_text);

   //Zavolanie computeEx a spracovanie return hodnoty.
   result = computeEx(arg_a, arg_text);
   pResult = Py_BuildValue("i", result);

   return pResult;
}


static PyMethodDef methods[] = {
   {"computeEx", computeExWrap, METH_VARARGS, "my own C-function"},
   {NULL, NULL, 0, NULL}
};


int main()
{
   //Deklaracia premenných.
   PyObject* pMain;
   PyObject* pMainDict;
   FILE*     file;

   //Inicializácia.
   Py_Initialize();
   Py_InitModule("c_module", methods);

   //Otvorenie súboru a jeho vykonanie v main module.
   file = fopen(SCRIPT_FILE, "r");
   if (file) {
      PyRun_SimpleFile(file, SCRIPT_FILE);
   }

   Py_Finalize();
   return 0;
}


script.py:


import c_module

print 'PYTHON SAY: calling c_module.computeEx()'
ret = c_module.computeEx(2, "Hello Python")
print 'PYTHON SAY:c_module.computeEx() return is:', ret

Najprv si rozoberieme tú jednoduchšiu časť, ktorou je scrypt.py. Tento skript sa bude vykonávať vo vnútri našej aplikácie. Ako prvé bude treba importovať Python modul, v ktorom sa bude nachádzať funkcia computeEx(). Vytvorenie modulu popíšem neskôr. Na ďalších riadkoch už len zavoláme funkciu, predáme jej hodnoty a vypíšeme hodnotu, ktorú nám funkcia vráti. Teraz však prejdeme ku kódu, ktorý sa nachádza v main.c. Začnem vysvetľovať netradične, nie od main() funkcie, ale od prvej funkcie computeEx(). Ide o hypotetickú funkciu, ktorú chceme sprístupniť a umožniť jej volanie z Python skriptu. Funkcia je jednoduchá a nevykonáva nič podstatne. Ma 2 vstupne premenne. Prvou je číslo, ktoré sa počíta a druhou je text, ktorý sa vypíše na výstup. Naschvál som zvolil dvojicu číslo-text, aby ste videli ako na textové hodnoty a ako na číselne hodnoty. Teraz však príde omnoho dôležitejšia časť s pohľadu pythonu. Je ňou funkcia computeExWrap. Python pracuje práve s touto funkciou. Funkcia je akýmsi baleným volaním funkcie computeEx(). Jej význam spočíva v konverzii vstupných a výstupných hodnôt.


PyObject* computeExWrap(PyObject* self, PyObject* args)
{
   //Deklaracia premenných.
   PyObject* pResult;
   int       result;
   int       arg_a;
   char*     arg_text;

   //Konvertovanie python argumentov na C hodnoty.
   PyArg_ParseTuple(args, "is", &arg_a, &arg_text);

   //Zavolanie computeEx a spracovanie return hodnoty.
   result = computeEx(arg_a, arg_text);
   pResult = Py_BuildValue("i", result);

   return pResult;
}

Funkcia sa vykoná pri každom volaní computeEx() z pythonu. Do self sa uloží ukazovateľ na Python objekt funkcie a do args sa uloží ukazovateľ na Tuple objekt, ktorý by vám mal byt známy z predchádzajúcej časti. Ak ste zabudli, je možne si ho predstaviť ako objekt zásobníka funkcie. Volaním funkcie PyArg_ParseTuple() konvertujeme Python hodnoty na hodnoty, ktorým rozumie Céčko. Pozorne sa pozrite na druhy parameter funkcie. Ide o reťazec „is“. Ak viete, ako pracuje funkcia printf(), tak s touto funkciu by ste taktiež nemali mat problém. Reťazcom „is“ hovoríme, aké typy hodnôt sa nachádzajú v zásobníku a v akom poradí sú uložene. V tomto prípade ide o i – integer, a s – string. Hodnoty sa uložia následne no premenných arg_a a arg_text. Okrem 'i' a 's' môžu byt použite nasledujúce písmena určujúce typ:

znak Python C komentár
s string char* konverzia zo string na char*
s# string char*, int konverzia zo string na char* a int, ktorý je dĺžka textu
z string char* konverzia zo string na char*, string môže byť None
z# string char*, int konverzia zo string na char* a int, ktorý je dĺžka textu kde string môže byt None
b integer char prevedie číslo na char hodnotu(rozsah 0-255)
h integer short int prevedie číslo na short int hodnotu
i integer int prevedie číslo na int hodnotu
f float float prevedie číslo na float hodnotu
d float double prevedie číslo na double hodnotu
Viac o konverzii argumentov sa môžete dozvedieť priamo v dokumentácii k funkcii na www.python.org.

Akonáhle už mame skonvertované hodnoty do Céčka, môžeme zavolať funkciu computeEx(), ktorej tieto hodnoty predáme. Výsledok funkcie si uložíme a ďalšou funkciou Py_BuildValue() ju naopak konvertujeme z Céčka do Pythonu. Funkcia používa rovnaký konverzný reťazec, v tomto prípade len „i“, nakoľko výstup funkcie je len číslo. Návratovú hodnotu použijeme aj ako návratovú hodnotu funkcie computeExWrap(). Ďalej nasleduje akési prepojenie medzi pythonom a Céčkom. Ide o pole prvkov PyMethodDef.


static PyMethodDef methods[] = {
   {"computeEx", computeExWrap, METH_VARARGS, "my own C-function"},
   {NULL, NULL, 0, NULL}
};

Toto pole ma 2 dôležité vlastnosti. Prvou je to, že je deklarovaná ako statická. Dôvod je jednoduchý. Pri registrácii a volaní metód, používa Python práve toto pole, nie jeho kópiu. Platnosť pola teda nesmie vypršať skôr, ako neukončíme interpreter pomocou Py_Finalize(). V opačnom prípade by mohlo dojsť k pádu aplikácie. Ďalšou dôležitou vlastnosťou je posledný prvok pola. Všimnite si, že je prázdny. Hodnoty sú nastavene na NULL. Tento posledný prvok funguje podobne ako NULL znak pri reťazcoch. Označuje koniec pola. V prípade ak posledný prvok nebude nastavený na NULL, dôjde k pádu aplikácie. Prvky pola sú typu PyMethodDef. Ide o štruktúru, ktorá obsahuje všetko potrebne aby Python vedel zavolať Céčkovskú funkciu. Štruktúra obsahuje nasledujúce položky:

položka typ význam
ml_name char* meno metódy
ml_meth PyCFunction ukazovateľ na metódu, ktorá sa bude volať
ml_flags int flagy určujúce ako bude konštruované volanie funkcie(v našom prípade METH_VARARGS, ktoré je najčastejšie používane. Okrem iného môže isť o METH_NOARGS, METH_CLASS atď.)
ml_doc char* popisujúci komentár

V tejto chvíli už mame všetko potrebne, aby sme zavolali computeEx() funkciu a dostávame sa pomaličky ku koncu a k funkcii main(). Funkcia nieje zložitá a už by vám mala byt jasná.


int main()
{
   //Deklaracia premenných.
   PyObject* pMain;
   PyObject* pMainDict;
   FILE*     file;
   //inicializácia
   Py_Initialize();
   Py_InitModule("c_module", methods);

   //Otvorenie súboru a jeho vykonanie v main module.
   file = fopen(SCRIPT_FILE, "r");
   if (file) {
      PyRun_SimpleFile(file, SCRIPT_FILE);
   }

   Py_Finalize();
   return 0;
}

Najdôležitejšie je volanie funkcie Py_InitModule(). Funkcia zaregistruje pole metód pod modulom nazvaným „c_module“. Od tohto miesta je možné vykonať kód „script.py“, v ktorom sa modul importuje. Preklad programu by nemal byť problém a program by vám mal vypisovať na vystúp nasledujúci text:


PYTHON SAY: calling c_module.computeEx()
C SAY: computeEx write:Hello Python
PYTHON SAY:c_module.computeEx() return is: 4

Z textu môžete vidieť priebeh, ako je volaná Python funkcia computeEx(), ktorá spočíta 2 + 2, Ďalej vypíše text na výstup a následne vráti vypočítaný výsledok, ktorý je následne vypísaný na vystúp v Python skripte.

Článok si dával za cieľ vysvetliť princíp implementácie Pythona do Céčkovského kódu. Dúfam, že sa mi podarilo vám tento mechanizmus priblížiť.

×Odeslání článku na tvůj Kindle

Zadej svůj Kindle e-mail a my ti pošleme článek na tvůj Kindle.
Musíš mít povolený příjem obsahu do svého Kindle z naší e-mailové adresy kindle@programujte.com.

E-mailová adresa (např. novak@kindle.com):

TIP: Pokud chceš dostávat naše články každé ráno do svého Kindle, koukni do sekce Články do Kindle.

Hlasování bylo ukončeno    
0 hlasů

Nové články

Obrázek ke článku Hackerský kongres přiveze v září do Prahy špičky světové kryptoanarchie

Hackerský kongres přiveze v září do Prahy špičky světové kryptoanarchie

Hackerský kongres HCPP16 pořádá od 30. září do 2. října nezisková organizace Paralelní Polis již potřetí, a to ve stejnojmenném bitcoinovém prostoru v pražských Holešovicích. Letos přiveze na třídenní konferenci přes 40 většinou zahraničních speakerů – lídrů z oblastí technologií, decentralizované ekonomiky, politických umění a aktivismu. Náměty jejich přednášek budou také hacking, kryptoměny, věda, svoboda nebo kryptoanarchie.

Reklama
Reklama
Obrázek ke článku ICT PRO školení zaměřené nejenom na ICT

ICT PRO školení zaměřené nejenom na ICT

Dovolte, abychom se představili. Jsme zaměstnanci společnosti ICT Pro, profesionálové v oblasti poskytování komplexních ICT služeb. Neboli služeb spojených s informačními a komunikačními technologiemi, které dnes - ve 21. století - tvoří  nedílnou součást běžného provozu všech moderních firem.

loadingtransparent (function() { var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true; po.src = 'https://apis.google.com/js/plusone.js'; var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s); })();
Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032016 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý