Download pocketpy - download do código-fonte pocketpy

pocketpy

Código-fonte C#

v2.0.3

Baixar

pocketpy: interpretador portátil python 3.x

pkpy é um interpretador Python 3.x leve (~ 15K LOC) para scripts de jogos, escrito em C11.

Pretende ser uma alternativa ao lua para scripts de jogos, com sintaxe elegante, recursos poderosos e desempenho competitivo. O pkpy é extremamente fácil de incorporar por meio de um único arquivo de cabeçalho pocketpy.h , sem dependências externas.

Consulte https://pocketpy.dev para obter detalhes e experimente os seguintes recursos.

Demonstração Python ao vivo: execute o código Python em seu navegador

Plataformas suportadas

O pkpy deve funcionar em qualquer plataforma com um compilador C11. Essas plataformas são testadas oficialmente.

Janelas de 64 bits
Linux de 64 bits/32 bits
macOS de 64 bits
Android de 64 bits/32 bits
iOS de 64 bits
Escrito em 32 bits
Raspberry Pi OS de 64 bits

Início rápido

Você tem duas opções para integrar o pkpy ao seu projeto.

Use o arquivo de cabeçalho único

Baixe pocketpy.h e pocketpy.c em nossa página de lançamento do GitHub. E #include o no seu projeto.

Usar CMake

Clone todo o repositório como um submódulo em seu projeto. Em seu CMakelists.txt, adicione as seguintes linhas:

 add_subdirectory (pocketpy)
target_link_libraries ( pocketpy)

Consulte CMakeLists.txt para obter detalhes.

É seguro usar a filial main na produção se o emblema CI estiver verde.

Compilar sinalizadores

Para compilá-lo com seu projeto, estes sinalizadores devem ser definidos:

--std=c11 sinalizador deve ser definido
Para MSVC, o sinalizador /utf-8 deve ser definido
A macro NDEBUG deve ser definida para compilação de lançamento, ou você obterá um desempenho ruim

Para compilação amalgamada, execute python amalgamate.py para gerar pocketpy.c e pocketpy.h no diretório amalgamated/ .

Exemplo

 #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

Nome	Exemplo	Suportado
Se mais	`if..else..elif`	✅
Laço	`for/while/break/continue`	✅
Função	`def f(x,*args,y=1):`	✅
Subclasse	`class A(B):`	✅
Lista	`[1, 2, 'a']`	✅
ListComp	`[i for i in range(5)]`	✅
Fatiar	`a[1:2], a[:2], a[1:]`	✅
Tupla	`(1, 2, 'a')`	✅
Ditado	`{'a': 1, 'b': 2}`	✅
Corda F	`f'value is {x}'`	✅
Desempacotando	`a, b = 1, 2`	✅
Desembalagem de estrelas	`a, *b = [1, 2, 3]`	✅
Exceção	`raise/try..catch..finally`	✅
Código Dinâmico	`eval()/exec()`	✅
Reflexão	`hasattr()/getattr()/setattr()`	✅
Importar	`import/from..import`	✅
Bloco de Contexto	`with as :`	✅
Anotação de tipo	`def f(a:int, b:float=1)`	✅
Gerador	`yield i`	✅
Decorador	`@cache`	✅

Desempenho

Atualmente, o pkpy é tão rápido quanto o cpython 3.9. Os resultados de desempenho do cpython 3.9 são aplicáveis ao pkpy.

Consulte https://pocketpy.dev/performance/ para obter detalhes.

E estes são os resultados do benchmark primes no Intel i5-12400F, WSL (Ubuntu 20.04 LTS), que reflete aproximadamente o desempenho entre c++, lua, pkpy e cpython.

nome	versão	tempo	arquivo
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

Usado por

	Descrição
TIC-80	TIC-80 é um computador de fantasia para criar, jogar e compartilhar pequenos jogos.
py-js	Externos Python3 para Max/MSP.
crescente	Crescent é um mecanismo de jogo 2D de luta e beat-em-up multiplataforma.
orxpy	Extensão Python para motor orx.
CANopenTermo	Ferramenta de software de código aberto para redes e dispositivos CANopen CC.

Envie uma solicitação pull para adicionar seu projeto aqui.

Contribuição

Todos os tipos de contribuições são bem-vindos.

Envie uma solicitação pull
- consertar um bug
- adicionar um novo recurso
Abra um problema
- alguma sugestão
- alguma dúvida

Se você achar o pkpy útil, considere marcar este repositório com estrela (●'◡'●)

Patrocine este projeto

Você pode patrocinar este projeto através destas formas.

Patrocinadores do Github
Compre-me um café

Seu patrocínio nos ajudará a desenvolver o pkpy continuamente.

Referência

python
A implementação oficial da linguagem de programação Python.
byterun
Um excelente material de aprendizagem. Ele ilustra como funciona a máquina virtual do Python.