pocketpy

Pocketpy: tragbarer Python 3.x-Interpreter

pkpy ist ein leichter (~15K LOC) Python 3.x-Interpreter für Spielskripte, geschrieben in C11.

Ziel ist es, eine Alternative zu Lua für die Skripterstellung von Spielen zu sein, mit eleganter Syntax, leistungsstarken Funktionen und konkurrenzfähiger Leistung. pkpy lässt sich extrem einfach über eine einzige Header-Datei pocketpy.h einbetten, ohne externe Abhängigkeiten.

Weitere Informationen finden Sie unter https://pocketpy.dev und probieren Sie die folgenden Ressourcen aus.

• Live-Python-Demo: Führen Sie Python-Code in Ihrem Browser aus

Unterstützte Plattformen

pkpy sollte auf jeder Plattform mit einem C11-Compiler funktionieren. Diese Plattformen sind offiziell getestet.

• Windows 64-Bit
• Linux 64-Bit / 32-Bit
• macOS 64-Bit
• Android 64-Bit / 32-Bit
• iOS 64-Bit
• Emscripten 32-bit
• Raspberry Pi OS 64-Bit

Schnellstart

Sie haben zwei Möglichkeiten, pkpy in Ihr Projekt zu integrieren.

Verwenden Sie die einzelne Header-Datei

Laden Sie pocketpy.h und pocketpy.c auf unserer GitHub-Release-Seite herunter. Und #include es in Ihr Projekt ein.

Verwenden Sie CMake

Klonen Sie das gesamte Repository als Submodul in Ihr Projekt. Fügen Sie in Ihrer CMakelists.txt die folgenden Zeilen hinzu:

 add_subdirectory (pocketpy)
target_link_libraries ( pocketpy)

Weitere Informationen finden Sie in CMakeLists.txt.

Es ist sicher, main in der Produktion zu verwenden, wenn das CI-Logo grün ist.

Flags kompilieren

Um es mit Ihrem Projekt zu kompilieren, müssen diese Flags gesetzt sein:

• Das Flag --std=c11 muss gesetzt sein
• Für MSVC muss das /utf-8 Flag gesetzt sein
• NDEBUG Makro sollte für den Release-Build definiert werden, sonst wird die Leistung beeinträchtigt

Führen Sie für einen amalgamierten Build python amalgamate.py aus, um pocketpy.c und pocketpy.h im Verzeichnis amalgamated/ zu generieren.

Beispiel

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

Merkmale

Name	Beispiel	Unterstützt
Wenn sonst	if..else..elif	✅
Schleife	for/while/break/continue	✅
Funktion	def f(x,*args,y=1):	✅
Unterklasse	class A(B):	✅
Liste	[1, 2, 'a']	✅
ListComp	[i for i in range(5)]	✅
Scheibe	a[1:2], a[:2], a[1:]	✅
Tupel	(1, 2, 'a')	✅
Diktat	{'a': 1, 'b': 2}	✅
F-Saite	f'value is {x}'	✅
Auspacken	a, b = 1, 2	✅
Star-Auspacken	a, *b = [1, 2, 3]	✅
Ausnahme	raise/try..catch..finally	✅
Dynamischer Code	eval()/exec()	✅
Spiegelung	hasattr()/getattr()/setattr()	✅
Import	import/from..import	✅
Kontextblock	with as :	✅
Geben Sie Anmerkung ein	def f(a:int, b:float=1)	✅
Generator	yield i	✅
Dekorateur	@cache	✅

Leistung

Derzeit ist pkpy so schnell wie cpython 3.9. Die Leistungsergebnisse für cpython 3.9 gelten für pkpy.

Weitere Informationen finden Sie unter https://pocketpy.dev/performance/.

Und das sind die Ergebnisse des Primes-Benchmarks auf Intel i5-12400F, WSL (Ubuntu 20.04 LTS), der in etwa die Leistung zwischen C++, Lua, PKPY und Cpython widerspiegelt.

Name	Version	Zeit	Datei
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

Verwendet von

	Beschreibung
TIC-80	TIC-80 ist ein Fantasy-Computer zum Erstellen, Spielen und Teilen kleiner Spiele.
py-js	Python3-Externals für Max / MSP.
Halbmond	Crescent ist eine plattformübergreifende 2D-Kampf- und Beat-Em-Up-Spiel-Engine.
orxpy	Python-Erweiterung für die Orx-Engine.
CANopenBegriff	Open-Source-Softwaretool für CANopen CC-Netzwerke und -Geräte.

Senden Sie eine Pull-Anfrage, um Ihr Projekt hier hinzuzufügen.

Beitrag

Alle Arten von Beiträgen sind willkommen.

• Senden Sie eine Pull-Anfrage
  • einen Fehler beheben
  • eine neue Funktion hinzufügen
• Öffnen Sie ein Problem
  • irgendwelche Vorschläge
  • irgendwelche Fragen

Wenn Sie pkpy nützlich finden, sollten Sie dieses Repository markieren (●'◡'●)

Sponsern Sie dieses Projekt

Über diese Möglichkeiten können Sie dieses Projekt sponsern.

• Github-Sponsoren
• Kauf mir einen Kaffee

Ihr Sponsoring wird uns helfen, pkpy kontinuierlich weiterzuentwickeln.

Referenz

• Python

  Die offizielle Implementierung der Programmiersprache Python.

• byterun

  Ein ausgezeichnetes Lernmaterial. Es veranschaulicht, wie die virtuelle Maschine von Python funktioniert.

Sternengeschichte

Lizenz

MIT-Lizenz