http://www.csh.rit.edu/~jon/projects/pip/index.

php

Traducido al español por Jesús Arce – ositopicaron@gmail.com

Tanto Python y PHP son lo que se conoce como lenguajes de scripting interpretado. Cada uno
ha alcanzado una popularidad considerable, debido principalmente a su capacidad para
facilitar la creación rápida de prototipos. Dado que soy un entusiasta de Python y PHP, he
querido combinar estos dos sistemas para promover mayores y más interesantes
oportunidades de desarrollo.

A tal fin, he escrito una extensión de Python para PHP. En resumen, esta extensión permite
que el Intérprete de Python pueda ser embebido dentro de PHP. Esto permite que objetos
nativos de Python sean instanciados y manipulados desde PHP. También existe un apoyo inicial
para acceder a las funciones de PHP y los datos desde el entorno de Python integrado.

Lo que veremos ahora es fundamentalmente una "prueba de concepto" de implementación.

Servirá como desarrollo de un sólido punto de partida.

La extensión de Python está disponible en su página de paquetes PECL. El código fuente está
actualmente en los repositorios CVS de PECL. Algunas distribuciones de paquetes también
están disponibles.

Diapositivas de mis presentaciones en la Conferencia Internacional de 2002 de PHP están

disponibles. Discusiones internas y aplicaciones.

Ejemplo
He aquí un ejemplo de lo que puede hacer en este momento:

1. La evaluación de código Python desde PHP

<?php
$a = "test";
$b = true;
$c = 50;
$d = 60.4;

$code = <<<EOD
import php

a = php.var('a')
b = php.var('b')
c = php.var('c')
d = php.var('d')

print a, b, c, d
print a, d / c + b, a
EOD;

py_eval($code);
?>
Resultado
test 1 50 60.4
test 2.208 test

2. Instanciación de Objeto Python

# module.py
class TestClass:
def __init__(self, foo):
self.foo = foo

def returnInt(self):
return 1113

def test(self, a, b = 'str'):

return "a = %d, b = %s" % (a, b)

def returnMe(self):
return self

def returnTuple(self):
return (1, "two", 3.0)

def returnList(self):
return [1, "two", 3.0]

def returnDict(self):
d = {}
d['one'] = 1
d['two'] = 2
d['three'] = 3
return d

def p(self, var):

print var
<?php
$p = new Python('module', 'TestClass', array(435));
print $p->returnInt() . "\n";
print $p->test(1, 'bar') . "\n";

print $p->foo . "\n";

$p->foo = 987;
print $p->foo . "\n"; <?php
$p = new Python('module', 'TestClass', array(435));
# $copy points to the same object print $p->returnInt() . "\n";
$copy = $p->returnMe(); print $p->test(1, 'bar') . "\n";
print $copy->foo . "\n";
$p->foo = 987; print $p->foo . "\n";
print $copy->foo . "\n"; $p->foo = 987;
?> print $p->foo . "\n";

# $copy points to the same object

$copy = $p->returnMe();
print $copy->foo . "\n";
$p->foo = 987;
print $copy->foo . "\n";
Resultado ?>

1113
a = 1, b = bar
435
987
987
987
3. Conversión de Tipos

<?php
var_dump($p->returnTuple());
var_dump($p->returnList());
var_dump($p->returnDict());

$a = array('one' => 1, 2, 3);

$p->p($a);

class Test {
var $member = 'test';
}

$t = new Test();
$p->p($t);
?>

Resultado
array(3) {
[0]=>
int(1)
[1]=>
string(3) "two"
[2]=>
float(3)
}
array(3) {
[0]=>
int(1)
[1]=>
string(3) "two"
[2]=>
float(3)
}
array(3) {
["three"]=>
int(3)
["two"]=>
int(2)
["one"]=>
int(1)
}
{'1': 3, '0': 2, 'one': 1}
{'member': 'test'}

Como puedes ver, estos ejemplos actuales son bastante crudos. Con el tiempo, voy a trabajar
en algunos ejemplos más detallados.