pocketpy

pocketpy : interpréteur portable python 3.x

pkpy est un interpréteur Python 3.x léger (~ 15 000 LOC) pour les scripts de jeux, écrit en C11.

Il vise à être une alternative à Lua pour la création de scripts de jeux, avec une syntaxe élégante, des fonctionnalités puissantes et des performances compétitives. pkpy est extrêmement facile à intégrer via un seul fichier d'en-tête pocketpy.h , sans dépendances externes.

Veuillez consulter https://pocketpy.dev pour plus de détails et essayer les ressources suivantes.

• Démo Python en direct : exécutez du code Python dans votre navigateur

Plateformes prises en charge

pkpy devrait fonctionner sur n'importe quelle plateforme dotée d'un compilateur C11. Ces plateformes sont officiellement testées.

• Windows 64 bits
• Linux 64 bits / 32 bits
• macOS 64 bits
• Android 64 bits/32 bits
• iOS 64 bits
• Emscript 32 bits
• Système d'exploitation Raspberry Pi 64 bits

Démarrage rapide

Vous avez deux options pour intégrer pkpy dans votre projet.

Utiliser le fichier d'en-tête unique

Téléchargez pocketpy.h et pocketpy.c sur notre page GitHub Release. Et #include le dans votre projet.

Utiliser CMake

Clonez l'intégralité du référentiel en tant que sous-module dans votre projet. Dans votre CMakelists.txt, ajoutez les lignes suivantes :

 add_subdirectory (pocketpy)
target_link_libraries ( pocketpy)

Voir CMakeLists.txt pour plus de détails.

Il est sûr d'utiliser la branche main en production si le badge CI est vert.

Compiler les drapeaux

Pour le compiler avec votre projet, ces indicateurs doivent être définis :

• --std=c11 l'indicateur doit être défini
• Pour MSVC, l'indicateur /utf-8 doit être défini
• La macro NDEBUG doit être définie pour la version release, sinon vous obtiendrez de mauvaises performances

Pour une version fusionnée, exécutez python amalgamate.py pour générer pocketpy.c et pocketpy.h dans le répertoire amalgamated/ .

Exemple

 #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 ;
}

Caractéristiques

Nom	Exemple	Soutenu
Si autrement	if..else..elif	✅
Boucle	for/while/break/continue	✅
Fonction	def f(x,*args,y=1):	✅
Sous-classe	class A(B):	✅
Liste	[1, 2, 'a']	✅
ListeComp	[i for i in range(5)]	✅
Tranche	a[1:2], a[:2], a[1:]	✅
Tuple	(1, 2, 'a')	✅
Dicté	{'a': 1, 'b': 2}	✅
Corde de Fa	f'value is {x}'	✅
Déballage	a, b = 1, 2	✅
Déballage des étoiles	a, *b = [1, 2, 3]	✅
Exception	raise/try..catch..finally	✅
Code dynamique	eval()/exec()	✅
Réflexion	hasattr()/getattr()/setattr()	✅
Importer	import/from..import	✅
Bloc de contexte	with as :	✅
Annotations de type	def f(a:int, b:float=1)	✅
Générateur	yield i	✅
Décorateur	@cache	✅

Performance

Actuellement, pkpy est aussi rapide que python 3.9. Les résultats de performances pour cpython 3.9 sont applicables à pkpy.

Voir https://pocketpy.dev/performance/ pour plus de détails.

Et ce sont les résultats du benchmark prime sur Intel i5-12400F, WSL (Ubuntu 20.04 LTS), qui reflète approximativement les performances entre c++, lua, pkpy et cpython.

nom	version	temps	déposer
c++	gnu++11	0.104s ■□□□□□□□□□□□□□□□	benchmarks/primes.cpp
Lua	5.3.3	1.576s ■■■■■■■■■□□□□□□□	benchmarks/primes.lua
pkpy	1.2.7	2.385s ■■■■■■■■■■■■■□□□	benchmarks/primes.py
python	3.8.10	2.871s ■■■■■■■■■■■■■■■■	benchmarks/primes.py

Utilisé par

	Description
TIC-80	TIC-80 est un ordinateur fantastique permettant de créer, de jouer et de partager de petits jeux.
py-js	Externes Python3 pour Max / MSP.
croissant	Crescent est un moteur de jeu de combat et de beat-em-up multiplateforme en 2D.
orxpy	Extension Python pour le moteur orx.
CANopenTerm	Outil logiciel open source pour les réseaux et appareils CANopen CC.

Soumettez une pull request pour ajouter votre projet ici.

Contribution

Toutes sortes de contributions sont les bienvenues.

• Soumettre une demande de tirage
  • corriger un bug
  • ajouter une nouvelle fonctionnalité
• Ouvrir un problème
  • des suggestions
  • des questions

Si vous trouvez pkpy utile, envisagez de mettre en vedette ce référentiel (greep)

Parrainez ce projet

Vous pouvez parrainer ce projet via ces moyens.

• Commanditaires Github
• Achetez-moi un café

Votre parrainage nous aidera à développer pkpy en continu.

Référence

• python

  L'implémentation officielle du langage de programmation Python.

• byterun

  Un excellent matériel d'apprentissage. Il illustre le fonctionnement de la machine virtuelle Python.

Histoire des étoiles

Licence

Licence MIT