pocketpy

pocketpy: intérprete portátil de Python 3.x

pkpy es un intérprete Python 3.x liviano (~15K LOC) para secuencias de comandos de juegos, escrito en C11.

Su objetivo es ser una alternativa a lua para secuencias de comandos de juegos, con una sintaxis elegante, funciones potentes y un rendimiento competitivo. pkpy es extremadamente fácil de incrustar a través de un único archivo de encabezado pocketpy.h , sin dependencias externas.

Consulte https://pocketpy.dev para obtener más detalles y pruebe los siguientes recursos.

• Demostración en vivo de Python: ejecute código Python en su navegador

Plataformas compatibles

pkpy debería funcionar en cualquier plataforma con un compilador C11. Estas plataformas están oficialmente probadas.

• ventanas de 64 bits
• Linux de 64 bits/32 bits
• MacOS de 64 bits
• Android de 64 bits/32 bits
• iOS de 64 bits
• Escritura de 32 bits
• Sistema operativo Raspberry Pi de 64 bits

Inicio rápido

Tienes dos opciones para integrar pkpy en tu proyecto.

Utilice el archivo de encabezado único

Descargue pocketpy.h y pocketpy.c en nuestra página de lanzamiento de GitHub. Y #include inclúyelo en tu proyecto.

Utilice CMake

Clona todo el repositorio como un submódulo en tu proyecto. En tu CMakelists.txt, agrega las siguientes líneas:

 add_subdirectory (pocketpy)
target_link_libraries ( pocketpy)

Consulte CMakeLists.txt para obtener más detalles.

Es seguro utilizar la rama main en producción si la insignia CI es verde.

Compilar banderas

Para compilarlo con su proyecto, se deben configurar estos indicadores:

• --std=c11 debe estar configurado
• Para MSVC, se debe configurar el indicador /utf-8
• La macro NDEBUG debe definirse para la versión de lanzamiento o obtendrá un rendimiento deficiente

Para una compilación amalgamada, ejecute python amalgamate.py para generar pocketpy.c y pocketpy.h en el directorio amalgamated/ .

Ejemplo

 #include "pocketpy.h"
#include 

static bool int_add ( int argc , py_Ref argv ) {
    PY_CHECK_ARGC ( 2 );
    PY_CHECK_ARG_TYPE ( 0 , tp_int );
    PY_CHECK_ARG_TYPE ( 1 , tp_int );
    py_i64 a = py_toint ( py_arg ( 0 ));
    py_i64 b = py_toint ( py_arg ( 1 ));
    py_newint ( py_retval (), a + b );
    return true;
}

int main () {
    // Initialize pocketpy
    py_initialize ();

    // Hello world!
    bool ok = py_exec ( "print('Hello world!')" , "" , EXEC_MODE , NULL );
    if (! ok ) goto __ERROR;

    // Create a list: [1, 2, 3]
    py_Ref r0 = py_getreg ( 0 );
    py_newlistn ( r0 , 3 );
    py_newint ( py_list_getitem ( r0 , 0 ), 1 );
    py_newint ( py_list_getitem ( r0 , 1 ), 2 );
    py_newint ( py_list_getitem ( r0 , 2 ), 3 );

    // Eval the sum of the list
    py_Ref f_sum = py_getbuiltin ( py_name ( "sum" ));
    py_push ( f_sum );
    py_pushnil ();
    py_push ( r0 );
    ok = py_vectorcall ( 1 , 0 );
    if (! ok ) goto __ERROR;

    printf ( "Sum of the list: %dn" , ( int ) py_toint ( py_retval ()));  // 6

    // Bind native `int_add` as a global variable
    py_newnativefunc ( r0 , int_add );
    py_setglobal ( py_name ( "add" ), r0 );

    // Call `add` in python
    ok = py_exec ( "add(3, 7)" , "" , EVAL_MODE , NULL );
    if (! ok ) goto __ERROR;

    py_i64 res = py_toint ( py_retval ());
    printf ( "Sum of 2 variables: %dn" , ( int ) res );  // 10

    py_finalize ();
    return 0 ;

__ERROR:
    py_printexc ();
    py_finalize ();
    return 1 ;
}

Características

Nombre	Ejemplo	Apoyado
Si no	if..else..elif	✅
Bucle	for/while/break/continue	✅
Función	def f(x,*args,y=1):	✅
Subclase	class A(B):	✅
Lista	[1, 2, 'a']	✅
ListaComp	[i for i in range(5)]	✅
Rebanada	a[1:2], a[:2], a[1:]	✅
tupla	(1, 2, 'a')	✅
dictar	{'a': 1, 'b': 2}	✅
cuerda fa	f'value is {x}'	✅
Desembalaje	a, b = 1, 2	✅
Desembalaje de estrellas	a, *b = [1, 2, 3]	✅
Excepción	raise/try..catch..finally	✅
Código dinámico	eval()/exec()	✅
Reflexión	hasattr()/getattr()/setattr()	✅
Importar	import/from..import	✅
Bloque de contexto	with as :	✅
Tipo de anotación	def f(a:int, b:float=1)	✅
Generador	yield i	✅
Decorador	@cache	✅

Actuación

Actualmente, pkpy es tan rápido como cpython 3.9. Los resultados de rendimiento de cpython 3.9 son aplicables a pkpy.

Consulte https://pocketpy.dev/performance/ para obtener más detalles.

Y estos son los resultados de la prueba comparativa principal en Intel i5-12400F, WSL (Ubuntu 20.04 LTS), que refleja aproximadamente el rendimiento entre c++, lua, pkpy y cpython.

nombre	versión	tiempo	archivo
c++	ñu++11	0.104s ■□□□□□□□□□□□□□□□	puntos de referencia/primes.cpp
lua	5.3.3	1.576s ■■■■■■■■■□□□□□□□	puntos de referencia/primes.lua
pkpy	1.2.7	2.385s ■■■■■■■■■■■■■□□□	puntos de referencia/primes.py
cpython	3.8.10	2.871s ■■■■■■■■■■■■■■■■	puntos de referencia/primes.py

Utilizado por

	Descripción
TIC-80	TIC-80 es una computadora de fantasía para crear, jugar y compartir pequeños juegos.
py-js	Externos de Python3 para Max/MSP.
creciente	Crescent es un motor de juegos beat-em-up y lucha en 2D multiplataforma.
orxpy	Extensión de Python para motor orx.
CANopenTerm	Herramienta de software de código abierto para redes y dispositivos CANopen CC.

Envíe una solicitud de extracción para agregar su proyecto aquí.

Contribución

Todo tipo de aportaciones son bienvenidas.

• Enviar una solicitud de extracción
  • arreglar un error
  • agregar una nueva característica
• Abrir un problema
  • alguna sugerencia
  • cualquier pregunta

Si encuentra útil pkpy, considere destacar este repositorio (●'◡'●)

Patrocina este proyecto

Puedes patrocinar este proyecto a través de estas formas.

• Patrocinadores de Github
• Cómprame un café

Su patrocinio nos ayudará a desarrollar pkpy continuamente.

Referencia

• cpython

  La implementación oficial del lenguaje de programación Python.

• byterun

  Un excelente material de aprendizaje. Ilustra cómo funciona la máquina virtual de Python.

Historia de las estrellas

Licencia

Licencia MIT