Come faresti l'equivalente delle direttive del preprocessore in Python?

Question

C'è un modo per eseguire le seguenti direttive del preprocessore in Python?

#if DEBUG

< do some code >

#else

< do some other code >

#endif

Answer 1

C'è __debug__, che è un valore speciale che il compilatore esegue in preelaborazione.

if __debug__:
  print "If this prints, you're not running python -O."
else:
  print "If this prints, you are running python -O!"

if 0: verrà sostituito con una costante 0 o 1 dal compilatore e l'ottimizzatore rimuoverà tutte le <=> righe prima che la tua fonte venga interpretata.

Answer 2

Ho scritto un preprocessore Python chiamato pypreprocessor che fa esattamente quello che stai descrivendo.

Il codice sorgente e la documentazione sono disponibili su GitHub.

Il pacchetto può anche essere scaricato/installato tramite PyPI.

Ecco un esempio per realizzare ciò che stai descrivendo.

from pypreprocessor import pypreprocessor

pypreprocessor.parse()

#define debug

#ifdef debug
print('The source is in debug mode')
#else
print('The source is not in debug mode')
#endif

pypreprocessor è in grado di fare molto di più della semplice preelaborazione al volo.Per vedere altri esempi di casi d'uso, controlla il progetto su Google Code.

Aggiornamento:Maggiori informazioni su pypreprocessor

Il modo in cui eseguo la preelaborazione è semplice.Dall'esempio precedente, il preprocessore importa un oggetto pypreprocessor creato nel modulo pypreprocessor.Quando chiami parse() sul preprocessore, autoconsuma il file in cui è stato importato e genera una copia temporanea di se stesso che commenta tutto il codice del preprocessore (per evitare che il preprocessore si chiami ricorsivamente in un ciclo infinito) e commenta tutte le parti inutilizzate.

Commentare le righe, invece di rimuoverle, è necessario per preservare i numeri di riga nelle tracce di errore se il modulo genera un'eccezione o si blocca.E sono arrivato addirittura a riscrivere il traceback dell'errore in modo che il rapporto rifletta il nome file corretto del modulo che si è bloccato.

Quindi, il file generato contenente il codice postelaborato viene eseguito al volo.

Il vantaggio di usare questo metodo invece di aggiungere semplicemente un gruppo di istruzioni if ​​inline nel codice è che non ci sarà tempo di esecuzione sprecato valutando istruzioni inutili perché le parti commentate del codice verranno escluse dai file .pyc compilati.

Lo svantaggio (e il motivo originale per cui ho creato il modulo) è che non è possibile eseguire sia Python 2x che Python 3x nello stesso file perché l'interprete Python esegue un controllo completo della sintassi prima di eseguire il codice e rifiuterà qualsiasi codice specifico della versione prima del il preprocessore può eseguire ::sigh::.Il mio obiettivo originale era quello di essere in grado di sviluppare codice 2x e 3x fianco a fianco nello stesso file in modo da creare bytecode specifici della versione a seconda di cosa è in esecuzione.

In ogni caso, il modulo preprocessore è comunque molto utile per implementare le comuni capacità di preelaborazione in stile c.Inoltre, il preprocessore è in grado di produrre il codice postelaborato in un file per un utilizzo successivo, se lo si desidera.

Inoltre, se vuoi generare una versione che abbia tutte le direttive del preprocessore così come tutti i #ifdef esclusi rimossi, è semplice come impostare un flag nel codice del preprocessore prima di chiamare parse().Ciò rende la rimozione del codice indesiderato da un file sorgente specifico della versione un processo in un unico passaggio (rispetto alla scansione del codice e alla rimozione manuale delle istruzioni if).

Answer 3

Sospetto che odierai questa risposta. Il modo in cui lo fai in Python è

# code here
if DEBUG:
   #debugging code goes here
else:
   # other code here.

Poiché python è un interprete, non è necessario applicare alcuna fase di preelaborazione e nessun vantaggio particolare nell'avere una sintassi speciale.

Answer 4

È possibile utilizzare il preprocessore in Python. Basta eseguire i tuoi script attraverso il cpp (C-Preprocessor) nella directory bin. Comunque l'ho fatto con Lua e i vantaggi della facile interpretazione hanno superato la compilazione più complessa IMHO.

Answer 5

Puoi semplicemente usare i normali costrutti del linguaggio:

DEBUG = True
if DEBUG:
  # Define a function, a class or do some crazy stuff
  def f():
    return 23
else:
  def f():
    return 42

Answer 6

Un metodo alternativo è usare uno script bash per commentare porzioni di codice che sono rilevanti solo per il debug. Di seguito è riportato uno script di esempio che commenta le righe che contengono un'istruzione '#DEBUG'. Può anche rimuovere di nuovo questi marcatori di commento.

if [ "$1" == "off" ]; then
  sed -e '/^#/! {/#DEBUG/ s/^/#/}' -i *.py
  echo "Debug mode to $1"
elif [ "$1" == "on" ]; then
  sed -e '/#DEBUG/ s/^#//' -i *.py
  echo "Debug mode to $1"
else
  echo "usage: $0 on | off"
fi

Answer 7

• Python se non è in grado di eliminare elementi dagli array.
• I precompilatori C non gestiscono #! o altre righe che iniziano con # secondo necessità.
• pypreprocessor sembra essere specifico di Python

Usa invece un m4 comune, in questo modo:

ifelse(DEBUG,True,dnl`
  < do some code >
dnl,dnl`
  < do some other code >dnl
')

ifelse(
  M4_CPU,x86_64,`
    < do some code specific for M4_CPU >
',M4_CPU,arm,`
    < do some code specific for M4_CPU >
',M4_CPU,ppc64le,`
    < do some code specific for M4_CPU >
')

ifelse(
  M4_OS,windows,`
    < do some code specific for M4_OS >
  ',M4_OS,linux,`
    < do some code specific for M4_OS >
  ',M4_OS,android,`
    < do some code specific for M4_OS >
')

  

m4 -D DEBUG = True -D M4_OS = android -D M4_CPU = arm test.py.m4 > test.py