paroxython

Introdução

O paroxython é um conjunto de ferramentas de linha de comando que marcam e filtram por algorítmico apresenta sua coleção de exercícios de programação Python.

Público

Você é professor, responsável por um curso de programação introdutório em uma instituição educacional. Ao longo dos anos, você acumulou muitos - amantes - programas e trechos de código que podem ser do interesse de seus alunos.

Ou, como desenvolvedor experiente, você gostaria de compartilhar seu conhecimento, ajudando um ente querido a aprender a codificar. Uma pesquisa superficial por material pedagógico produz uma quantidade esmagadora de sites e repositórios recheados com programas Python de vários níveis (por exemplo, 1, 2, 3, 4, 5, 6 e muito mais da Awesome Python na educação).

De qualquer forma, os códigos de origem do Python que você reuniu são tipicamente numerosos (centenas ou até milhares), tamanho razoavelmente (qualquer coisa abaixo de 100 linhas de código) e de natureza educacional (por exemplo, trechos, exemplos, testes, soluções de exercício, algoritmos clássicos). Os conceitos de programação que você planeja ensinar permanecem de nível relativamente baixo (por exemplo, atribuições, loops aninhados, padrões de acumulação, funções recursivas de cauda etc.).

Se tudo isso parece familiar, continue me lendo.

Principais objetivos

O Paroxython pretende ajudá -lo a selecionar, na sua coleção, o programa único que melhor atende às suas necessidades. Por exemplo, ele responderá com prazer as seguintes perguntas:

• Como esse conceito pode ser ilustrado?
• Que problemas usam as mesmas estruturas algorítmicas e de dados que esta?
• Que tarefa de casa devo dar aos meus alunos para que eles possam praticar o conteúdo da última lição?

Além disso, como o paroxython sabe o que sua classe sabe, ele pode recomendar o programa certo na hora certa:

• O que faria um bom exercício de revisão?
• Quais exercícios posso dar neste exame?
• Qual é o custo de aprendizado atual deste exemplo?

A longo prazo, o paroxython pode guiá -lo e, de alguma forma, fazer você repensar o esboço do curso:

• Quais são os pré -requisitos para o conceito de atribuição?
• Tenho material suficiente para introduzir sub -rotinas antes mesmo de falar sobre condicionais e loops?
• Entre os loops, que devem vir primeiro: o mais poderoso ( while ) ou o mais útil ( for )?
• Como estruturar logicamente esse grupo de padrões iterativos usuais?
• Quais são exatamente o básico ?

Todas as questões nas quais o autor mudou de idéia desde que ele começou a trabalhar neste projeto!

Em um mundo ideal, Paroxython poderia até acabar com as guerras religiosas mais mortais, com argumentos racionais e orientados a dados:

• Pai, é um pecado sair cedo?
• Um byte real deve usar uma máscara?

Como funciona

O paroxython começa em uma determinada pasta de programas . Seu conteúdo é analisado e todos os recursos que atendem às especificações fornecidos são rotulados e associados a seus vãos (por exemplo, "assignment_lhs_identifier:a": 4, 6, 18 ou "loop_with_late_exit:while": 3-7, 20-29 ).

Esses rótulos constituem apenas conhecimento disperso. O próximo passo é mapeá -los para uma taxonomia projetada com restrições hierárquicas básicas em mente (por exemplo, o fato de que a introdução do conceito de saída precoce deve vir após a do loop, que por si só requer que o fluxo de controle seja expresso pelo táxon "flow/loop/exit/early" ).

Extrato da taxonomia gerada a partir dos algoritmos - Python.
Clique para pular para sua versão dinâmica completa no manual do usuário.

Tudo é persistido em um banco de dados de tags, que mais tarde pode ser filtrado através de um pipeline de comandos, por exemplo:

• Inclua apenas os programas que apresentam uma função recursiva;
• exclua este ou aquele programa que você deseja reservar para o exame;
• “ Imparar ” Todos os programas estudados até agora, ou seja , considere que todas as noções que eles implementam são adquiridas.

O resultado é uma lista de recomendações do programa ordenadas pelo aumento do custo de aprendizado.

Exemplo

Suponha que o diretório programs contenha esses programas simples.

Primeiro, construa este banco de dados de tags:

 > paroxython collect programs
Labelling 21 programs.
Mapping taxonomy on 21 programs.
Writing programs_db.json.

Em seguida, filtá -lo através deste pipeline:

 > paroxython recommend programs
Processing 5 commands on 21 programs.
  19 programs remaining after operation 1 (impart).
  18 programs remaining after operation 2 (exclude).
  12 programs remaining after operation 3 (exclude).
  10 programs remaining after operation 4 (include).
  10 programs remaining after operation 5 (hide).
Dumped: programs_recommendations.md.

ET voilà, seu relatório de recomendação!

Instalação e teste-drive

Linha de comando

Muito para surpresa de ninguém:

 python -m pip install paroxython

O comando a seguir deve imprimir uma mensagem de ajuda e saída:

 paroxython --help

Comando Ipython Magic

Se você usar o Jupyter Notebook/Lab, também instalou o chamado comando mágico. Carregue assim:

 % load_ext paroxython

Isso deve imprimir "paroxython 0.7.0 loaded." . Execute -o em uma célula do código Python:

 % % paroxython                          # Lines
def fibonacci ( n ):                     # 2
    result = []                       # 3
    ( a , b ) = ( 0 , 1 )                   # 4
    while a < n :                      # 5
        result . append ( a )              # 6
        ( a , b ) = ( b , a + b )           # 7
    return result                     # 8

Taxon	Linhas
call/subroutine/method/sequence/list/append	6
condition/inequality	5
def/subroutine/function/impure	2-8
def/subroutine/parameter/arg	2
flow/loop/exit/late	5-7
flow/loop/while	5-7
meta/count/program/sloc/8	2-8
meta/count/subroutine/sloc/7	2-8
meta/count/variety/3	2-8
meta/program	2-8
operator/arithmetic/addition	7
style/procedural	2-8
type/number/integer/literal	4
type/number/integer/literal/zero	4
type/sequence/list	6
type/sequence/list/literal/empty	3
type/sequence/tuple/literal	4, 4, 7, 7
var/assignment/explicit/parallel	4
var/assignment/explicit/parallel/slide	7
var/assignment/explicit/single	3
var/assignment/implicit/parameter	2
var/scope/local	2-8, 2-8, 2-8, 2-8

Como você pode ver, neste programa, o paroxython identifica entre outros:

• o uso do paradigma processual ( style/procedural );
• uma função impura ( def/subroutine/function/impure );
• Um loop while ( flow/loop/while ) com uma saída tardia ( flow/loop/exit/late );
• Um pouco de vodu nas listas ( type/sequence/list/literal/empty e call/subroutine/method/sequence/list/append );
• Uma atribuição simples de tupla ( var/assignment/explicit/parallel ). Observe que distinguimos entre atribuições explícitas (com = ) e implícitas (parâmetros e variáveis ​​de iteração);
• uma atribuição de tupla “deslizante” ( var/assignment/explicit/parallel/slide ). Se a denominação é exclusiva para nós, o próprio padrão ocorre em vários programas: implementações de sequências C-Finita com C maior que 1, maior divisor comum, Quicksort, etc.
• quatro variáveis ​​locais ( var/scope/local );
• Uma estimativa da variedade de conceitos envolvidos ( meta/count/variety/3 ), dependendo do número de linhas, recursos e recursos distintos.

O comando mágico %%paroxython (correspondente à tag de subcomando) apenas arranha a superfície do sistema. Como mostrado anteriormente, para estimar o custo de aprendizado dos recursos e obter recomendações acionáveis, você precisará primeiro construir o banco de dados de tags com collect e depois ligar para recommend em um pipeline seu.

Leia -os

Embora este ainda seja um trabalho em andamento, o paroxython já deve estar bastante bem documentado:

• Manual do usuário:
  • Escreva um pipeline de comando para obter recomendações,
  • Prepare suas coleções de programas para obter melhores resultados,
  • entender e modificar a classificação taxonômica,
  • e mais.
• Manual do desenvolvedor:
  • Tenha uma idéia aproximada da estrutura e operações do programa,
  • Use os ajudantes fornecidos para contribuir com o código,
  • e mais.
• Referência do módulo.
• Especificações de recursos: um documento que mistura prosa, testes, expressões regulares e consultas SQL para descrever quais recursos algorítmicos são reconhecidos e como.
• Tipos de usuário: Todos os objetos de interesse são digitados com precisão e verificados pelo MyPy.

Finalmente, uma bateria de exemplos e cobertura abrangente de teste deve ajudar a responder a qualquer pergunta restante.