string "hugo" em "HUGO" usando o metodo upper:#include "Python.h"int main(){ PyObject *modulo_string, *string_maiuscula; char *string_minuscula = "hugo", *resultado; Py_Initialize(); modulo_string = PyImport_ImportModule("string"); string_maiuscula = PyObject_CallMethod(modulo_string, "upper", "s", string_minuscula); resultado = PyString_AsString(string_maiuscula); printf("antes: %s, depois: %s\n", string_minuscula, resultado); Py_Finalize(); return 0;}Primeiro nos incluimos o nosso cabecalho padrao Python.h, depois definimos duas variaveis do tipo PyObject * que serao usadas posteriormente para armazenar o modulo string e o resultado do metodo upper; em seguida definimos duas variaveis do tipo char * que armazenarao a nossa string "hugo" e o resultado da chamada ao metodo upper convertido pra C, para que usassemos com a funcao printf (perceba que nao inclui-se <stdio.h> pois esta implicito).Apos nossas declaracoes iniciamos o interpretador Python para que possamos usar uma de suas bibliotecas padroes.O modulo string e obtivo atraves da chamada a funcao PyImport_ImportModule, que importa um modulo (dos modulos definidos em sys.modules).Depois que ja temos o modulo string precisamos chamar o metodo upper, passando como argumento uma unica string (indicada por "s").Quem nos auxilia nesse caso e a funcao PyObject_CallMethod, que espera como primeiro parametro um objeto python, como segundo o nome do metodo (tipo char *) e em seguida um formato dos parametros (que no nosso caso o "s" significa que havera em seguida apenas UM parametro e que sera uma string) e por ultimo passamos o nosso tao aguardado parametro pro metodo upper.Talvez observando os prototipos destas duas funcoes os parametros fiquem mais claros:PyObject* PyImport_ImportModule(const char *name)PyObject* PyObject_CallMethod(PyObject *o, char *method, char *format, ...)O retorno da chamada a PyObject_CallMethod no codigo acima e um objeto python que guardara a nossa string em upper case. Porem, a funcao printf definida em <stdio.h> nao conhece os PyObject * da vida. Assim e necessario converter o valor de PyObject * pra char *, usando a funcao PyString_AsString.Por fim encerramos o interpretador Python atraves da funcao Py_Finalize.Nos temos o codigo, mas nao temos o executavel ainda. Usarei o GCC pra compilar esse codigo (meu fonte e up.c):hugo@hugo-laptop:~/pythoncapi$ gcc -o up up.c -I/usr/include/python2.5 -lpython2.5hugo@hugo-laptop:~/pythoncapi$ ./upantes: hugo, depois: HUGOA opcao -lpython2.5 foi usada pra linkar a biblioteca do python2.5.Um pouco trabalhoso, nao? Se fosse em Python puro (usando a mesma abordagem) seria apenas:>>> import string>>> string_minuscula = "hugo">>> resultado = string.upper(string_minuscula)>>> print resultadoHUGOExemplo #2 - estendendo o interpretador: Criando um modulo com funcoes matematicasModulos de extensao nao necessariamente usam as facilidades do interpretador Python, podendo somente criar extensoes pro intepretador. Assim, no nosso caso vamos criar apenas duas funcoes: fatorial e raiz_quadrada e as mesmas serao acessiveis atraves do modulo matematica.Para todo modulo de extensao e necessario uma funcao initNOMEDOMODULO e uma definicao de metodos que o modulo contera. Vamos ao codigo:#include "Python.h"#include <math.h>int fatorial_c_puro(int n){ if (n <= 1) return 1; return n * fatorial_c_puro(n - 1);}PyObject *raiz_quadrada(PyObject *self, PyObject *n){ double raiz = sqrt(PyFloat_AsDouble(n)); return PyFloat_FromDouble(raiz);}PyObject *fatorial(PyObject *self, PyObject *n){ int n_int = PyInt_AsLong(n); return PyInt_FromLong(fatorial_c_puro(n_int));}PyMethodDef funcoes_matematicas[] = { {"raiz_quadrada", (PyCFunction)raiz_quadrada, METH_O}, {"fatorial", (PyCFunction)fatorial, METH_O}, {NULL, NULL},};void initmatematica(){ Py_InitModule("matematica", funcoes_matematicas);}A primeira funcao - fatorial_c_puro - foi criada somente pra "limpar" o nosso codigo e deixar mais simples de entender as chamadas