Definire comandi personalizzati per i progetti Python in Visual Studio

2025-06-12

Durante lo sviluppo dei progetti Python, è possibile passare a una finestra di comando per eseguire script o moduli specifici, eseguire comandi pip o usare altri strumenti con il codice. Per migliorare il flusso di lavoro, è possibile aggiungere comandi personalizzati al menu progetto Python in Visual Studio. I comandi Python personalizzati possono essere eseguiti in una finestra della console o nella finestra output di Visual Studio . È anche possibile usare espressioni regolari per indicare a Visual Studio come analizzare gli errori e gli avvisi dall'output del comando.

Prerequisiti

Visual Studio in Windows installato con il supporto per i carichi di lavoro Python. Per Altre Informazioni, Vedere Installare il Supporto Python in Visual Studio.

Visual Studio per Mac non è supportato. Per altre informazioni, vedere Cosa accade a Visual Studio per Mac? Visual Studio Code in Windows, Mac e Linux funziona bene con Python tramite le estensioni disponibili.

Esplorare i comandi personalizzati

Per impostazione predefinita, il menu del progetto Python contiene due comandi: Esegui PyLint e Esegui Mypy.

Tutti i comandi Python personalizzati definiti vengono visualizzati nello stesso menu. Un comando personalizzato può fare riferimento a un file Python, a un modulo Python, a codice Python inline, a un eseguibile arbitrario o a un comando pip. È anche possibile specificare come e dove viene eseguito il comando.

È possibile aggiungere comandi personalizzati in diversi modi:

Definire comandi personalizzati in un file di progetto Python (direttamente con estensione pyproj). Questi comandi si applicano a tale progetto specifico.
Definire comandi personalizzati in un file di destinazione (.targets). È possibile importare facilmente i comandi in questo file per usarli con più progetti.
Creare un progetto Python da un modello di progetto in Visual Studio che definisce comandi Python personalizzati.

Alcuni modelli di progetto Python in Visual Studio aggiungono comandi personalizzati usando un file di destinazioni. I modelli Progetto Web Bottle e Progetto Web Flask aggiungono due comandi, Avvia server e Avvia server di debug. Il modello Progetto Web Django aggiunge questi comandi e molti altri:

Ricaricare il progetto per accedere ai comandi personalizzati

Quando un progetto è aperto in Visual Studio, se si apportano modifiche al file di progetto corrispondente in un editor, è necessario ricaricare il progetto per applicare le modifiche. In modo analogo, dopo aver definito comandi Python personalizzati in un file di progetto Python, è necessario ricaricare il progetto Python per visualizzare i comandi nel menu di progetto Python. Quando si modificano i comandi personalizzati definiti in un file di destinazioni, è necessario ricompilare la soluzione completa di Visual Studio per qualsiasi progetto che importa il file di destinazione.

Un approccio comune consiste nell'apportare le modifiche al file di progetto Python direttamente in Visual Studio:

Aprire il progetto Python in Visual Studio. Quando si apre un progetto in Visual Studio, il progetto viene caricato per impostazione predefinita.
In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Python e selezionare Scarica progetto.

Visual Studio scarica il progetto e apre il file di progetto Python corrispondente (.pyproj) nell'editor.

Se il file di progetto non viene aperto, fare di nuovo clic con il pulsante destro del mouse sul progetto Python e selezionare Modifica file di progetto:
Apportare le modifiche al file di progetto nell'editor di Visual Studio e salvare il lavoro.
In Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto non caricato e selezionare Ricarica progetto. Se si tenta di ricaricare il progetto senza salvare le modifiche apportate al file di progetto, Visual Studio richiede di completare l'azione.

Il processo di scaricamento, modifica, salvataggio e ricaricamento può diventare noioso quando si sviluppano comandi personalizzati. Un flusso di lavoro più efficiente comporta il caricamento simultaneo del progetto in Visual Studio e l'apertura del file di progetto Python in un editor separato. È possibile usare qualsiasi editor, ad esempio un'altra istanza di Visual Studio, Visual Studio Code, Blocco note e così via. Dopo aver salvato le modifiche nell'editor e tornare a Visual Studio, Visual Studio rileva le modifiche apportate al file di progetto per il progetto aperto e richiede di intervenire:

Seleziona Ricarica o Ricarica Tutto e Visual Studio applica immediatamente le modifiche ai file di progetto nel progetto aperto.

Aggiungere comandi personalizzati con il file di progetto

La procedura seguente illustra come creare un comando personalizzato aggiungendo la definizione nel file di progetto Python (.pyproj) e ricaricando il progetto in Visual Studio. Il comando personalizzato esegue direttamente il file di avvio di un progetto usando il comando python.exe, che è praticamente uguale all'uso dell'opzione Debug>Avvia senza eseguire debug sulla barra degli strumenti principale di Visual Studio.

In Visual Studio, creare un nuovo progetto Python denominato Python-CustomCommands usando il modello un'applicazione Python. Per istruzioni, vedere Avvio rapido: Creare un progetto Python da un modello.

Visual Studio crea il progetto Python e lo carica nella sessione. È possibile configurare il progetto tramite il file di progetto (.pyproj). Questo file è visibile solo in Visual Studio quando il progetto è aperto, ma scaricato. Il progetto include anche un file Python (.py) per il codice dell'applicazione.
Aprire il file dell'applicazione Python_CustomCommands.py nell'editor e aggiungere il codice seguente:
```
print("Hello custom commands")
```
In Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto Python, scegliere Pythone osservare i comandi nel menu di scelta rapida. Attualmente, gli unici comandi del menu di scelta rapida sono Esegui pyLint e Esegui Mypy. Quando si definiscono comandi personalizzati, vengono visualizzati anche in questo menu.
Avviare un editor separato all'esterno della sessione di Visual Studio e aprire il file di progetto Python (Python-CustomCommands.pyproj) nell'editor. Assicurarsi di aprire il file di progetto (.pyproj) e non il file dell'applicazione Python (.py).)
Nel file di progetto individuare l'elemento </Project> di chiusura alla fine del file e aggiungere il codice XML seguente immediatamente prima dell'elemento di chiusura:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Salvare le modifiche al file di progetto e tornare a Visual Studio. Visual Studio rileva le modifiche apportate al file di progetto e chiede di intervenire. Al prompt selezionare Ricaricare per aggiornare il progetto aperto con le modifiche apportate al file di progetto.
In Esplora Soluzioni, fare clic destro sul progetto Python, selezionare Pythone controllare i comandi nel menu di scelta rapida.

Il menu di scelta rapida mostra ancora solo i comandi Esegui PyLint e Esegui Mypy. Il codice appena aggiunto al file di progetto replica semplicemente il gruppo di proprietà <PythonCommands> predefinito che contiene il comando PyLint. Nel passaggio successivo si aggiunge altro codice per il comando personalizzato.
Passare all'editor in cui si sta aggiornando il file di progetto. Aggiungere la definizione di elemento <Target> seguente all'interno dell'elemento <Project>. È possibile posizionare la definizione di <Target> prima o dopo la definizione di <PropertyGroup> descritta in precedenza.

Questo elemento definisce un comando personalizzato per eseguire il file di avvio per il progetto (identificato dalla proprietà StartupFile ) usando il comando in una finestra della console. La definizione dell'attributo ExecuteIn="consolepause" utilizza una console che attende che venga premuto un tasto per chiudere la finestra della console.
```
<Target Name="Example_RunStartupFile" Label="Run startup file" Returns="@(Commands)">
  <CreatePythonCommandItem
    TargetType="script"
    Target="$(StartupFile)"
    Arguments=""
    WorkingDirectory="$(MSBuildProjectDirectory)"
    ExecuteIn="consolepause">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>
```
Sostituire il gruppo di proprietà <PythonCommands> (aggiunto nel passaggio ) con il seguente codice XML. Questa sintassi definisce l'attributo Name per l'elemento <Target>, aggiungendo il comando personalizzato al menu contestuale Python. Il comando ha l'etichetta di menu Esegui file di avvio.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Suggerimento

Se si vuole che il comando personalizzato venga visualizzato nel menu di scelta rapida prima dei comandi predefiniti definiti nel token $(PythonCommands), posizionare la sintassi <Target> per il comando prima di tale token.
Salvare le modifiche al file di progetto e tornare a Visual Studio. Al prompt, ricarica il progetto.
In Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto Python, scegliere Pythone ricontrollare i comandi nel menu di scelta rapida.

Ora il comando personalizzato Esegui file di avvio è disponibile nel menu. Se il comando personalizzato non viene visualizzato, verificare di aver aggiunto il valore dell'attributo Name per l'elemento <Target> all'elemento <PythonCommands> come descritto in passaggio 9. Esaminare anche le considerazioni elencate nella sezione Risoluzione dei Problemi più avanti nell'articolo.
Selezionare il comando Eseguire il file di avvio. Si apre una finestra della console e viene visualizzato il testo Ciao comandi personalizzati seguito da Premere un tasto qualsiasi per continuare. Confermare l'output e chiudere la finestra della console.

Nota

Lo script di comando personalizzato viene eseguito nell'ambiente attivato per il progetto Python.
Passare all'editor con il file di progetto. Nella definizione dell'elemento <Target> (aggiunto nel passaggio step 8), modificare il valore dell'attributo ExecuteIn in output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Salvare le modifiche, tornare a Visual Studio e ricaricare il progetto.
Selezionare di nuovo il comando Esegui file di avvio personalizzato dal menu di scelta rapida Python. L'output del programma ora appare nella finestra Output di Visual Studio invece che in una finestra della console.
Per aggiungere altri comandi personalizzati, seguire questo stesso processo:
1. Definire un elemento <Target> appropriato per il comando personalizzato nel file di progetto.
2. Aggiungere il valore dell'attributo Name per l'elemento <Target> nel gruppo di proprietà <PythonCommands>.
3. Salvare le modifiche apportate al file di progetto.
4. Ricaricare il progetto in Visual Studio.

Usare le proprietà del progetto

Per fare riferimento alle proprietà del progetto o alle variabili di ambiente nei valori degli attributi degli elementi <Target>, usare il nome della proprietà all'interno di un token $(), ad esempio $(StartupFile) e $(MSBuildProjectDirectory). Per altre informazioni, vedere proprietà di MSBuild.

Se si richiama un comando come ($StartupFile) che usa proprietà di progetto come la proprietà StartupFile e il comando non riesce perché il token non è definito, Visual Studio disabilita il comando fino a quando non si ricarica il progetto. Se si apportano modifiche al progetto che modificano la definizione della proprietà, le modifiche non aggiornano lo stato del comando correlato. In questo caso, è comunque necessario ricaricare il progetto.

Comprendere la struttura dell'elemento target <>

È possibile definire i dettagli per un comando personalizzato usando l'elemento <Target>. La forma generale dell'elemento <Target> è illustrata nello pseudo-codice seguente:

<Target Name="Name1" Label="Display Name" Returns="@(Commands)">
    <CreatePythonCommandItem Target="filename, module name, or code"
        TargetType="executable/script/module/code/pip"
        Arguments="..."
        ExecuteIn="console/consolepause/output/repl[:Display name]/none"
        WorkingDirectory="..."
        ErrorRegex="..."
        WarningRegex="..."
        RequiredPackages="...;..."
        Environment="...">

      <!-- Output always appears in this form, with these exact attributes -->
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Attributi di destinazione

Nella tabella seguente sono elencati gli attributi dell'elemento <Target>.

Attributo	Obbligatorio	Descrizione
`Name`	Sì	Identificatore del comando all'interno del progetto di Visual Studio. Questo nome deve essere aggiunto al gruppo di proprietà `<PythonCommands>` affinché il comando venga visualizzato nel menu di scelta rapida Python.
`Label`	Sì	Nome visualizzato dell'interfaccia utente che appare nel menu contestuale di Python .
`Returns`	Sì	Le informazioni restituite devono contenere il token `@(Commands)`, il quale identifica il bersaglio come un comando.

Attributi di createPythonCommandItem

L'elemento <Target> contiene <CreatePythonCommandItem> e <Output> elementi, che definiscono il comportamento dettagliato per il comando personalizzato. Nella tabella seguente sono elencati gli attributi dell'elemento <CreatePythonCommandItem> disponibili. Tutti i valori degli attributi sono insensibili alle maiuscole.

`Attribute`	Obbligatorio	Descrizione
`TargetType`	Sì	Specifica il contenuto dell'attributo `Target` e la modalità di utilizzo del valore insieme all'attributo `Arguments`: - `executable`: eseguire l'eseguibile denominato nell'attributo `Target`, aggiungendo il valore nell'attributo `Arguments`, come se immesso direttamente nella riga di comando. Il valore deve contenere solo un nome di programma senza argomenti. - `script`: eseguire il comando `python.exe` con il nome file nell'attributo `Target`, seguito dal valore nell'attributo `Arguments`. - `module`: eseguire il comando `python -m` seguito dal nome del modulo nell'attributo `Target`, seguito dal valore nell'attributo `Arguments`. - `code`: eseguire il codice inline contenuto nell'attributo `Target`. Ignorare il valore dell'attributo `Arguments`. - `pip`: eseguire pip con il comando nell'attributo `Target`, seguito dal valore nell'attributo `Arguments`. Se l'attributo `ExecuteIn` è impostato su `output`, pip presuppone che la richiesta esegua il comando `install` e usi l'attributo `Target` come nome del pacchetto.
`Target`	Sì	Specifica il nome file, il nome del modulo, il codice o il comando pip da usare, a seconda del valore dell'attributo `TargetType`.
`Arguments`	Opzionale	Fornisce una stringa di argomenti (se presenti) da utilizzare con l'attributo `Target`. - Quando il valore dell'attributo `TargetType` è `script`, il valore `Arguments` viene fornito al programma Python anziché al comando `python.exe`. - Quando il valore dell'attributo `TargetType` è `code`, il valore `Arguments` viene ignorato.
`ExecuteIn`	Sì	Specifica l'ambiente in cui eseguire il comando: - `console`: (impostazione predefinita) Esegue l'attributo `Target` con il valore `Arguments` come se fossero immessi direttamente nella riga di comando. Mentre l'attributo `Target` è in esecuzione, viene visualizzata e chiusa automaticamente una finestra di comando. - `consolepause`: lo stesso comportamento di `console`, ma attende la pressione di un tasto prima di chiudere la finestra. : esegue l'attributo e visualizza i risultati nella finestra di output di Visual Studio . Se l'attributo `TargetType` è `pip`, Visual Studio usa l'attributo `Target` come nome del pacchetto e aggiunge il valore dell'attributo `Arguments`. - `repl`: esegue l'attributo `Target` nella finestra interattiva di Python . Il nome facoltativo di visualizzazione viene utilizzato per il titolo della finestra. - `none`: stesso comportamento di `console`.
`WorkingDirectory`	Opzionale	Identifica la cartella in cui eseguire il comando.
`ErrorRegex` `WarningRegEx`	Opzionale	Utilizzato solo quando l'attributo `ExecuteIn` è impostato su `output`. Entrambi i valori degli attributi specificano un'espressione regolare che Visual Studio utilizza per analizzare l'output dei comandi e mostrare errori e avvisi nella finestra Elenco Errori. Se questi attributi non vengono specificati, il comando non influisce sulla finestra elenco errori. Per altre informazioni sulle aspettative di Visual Studio, vedere gruppi di acquisizione denominati.
`RequiredPackages`	Opzionale	Fornisce un elenco dei requisiti del pacchetto per il comando usando lo stesso formato del file requirements.txt (pip.readthedocs.io). Ad esempio, il comando Esegui PyLint specifica il formato `pylint>=1.0.0`. Prima di eseguire il comando, Visual Studio conferma che tutti i pacchetti nell'elenco sono installati. Visual Studio usa pip per installare eventuali pacchetti mancanti.
`Environment`	Opzionale	Identifica una stringa di variabili di ambiente da definire prima di eseguire il comando. Ogni variabile usa il form `\<NAME>=\<VALUE>` con più variabili separate da punto e virgola. Una variabile con più valori deve essere contenuta tra virgolette singole o doppie, come in `'NAME=VALUE1;VALUE2'`.

Gruppi di acquisizione denominati per le espressioni regolari

Quando Visual Studio analizza gli errori e gli avvisi dall'output dei comandi personalizzati, prevede espressioni regolari nei valori degli attributi ErrorRegex e WarningRegex per usare i gruppi denominati seguenti:

(?<message>...): testo dell'errore.
(?<code>...): valore del codice di errore.
(?<filename>...): nome del file per cui viene segnalato l'errore.
(?<line>...): numero della riga della posizione nel file per cui viene segnalato l'errore.
(?<column>...): numero di colonna della posizione nel file per cui viene segnalato l'errore.

Ad esempio, PyLint genera avvisi del formato seguente:

************* Module hello
C:  1, 0: Missing module docstring (missing-docstring)

Per consentire a Visual Studio di estrarre le informazioni corrette da questi avvisi e visualizzarle nella finestra Elenco errori , il valore dell'attributo per il comando Esegui pylint è il seguente:

^(?<filename>.+?)\((?<line>\d+),(?<column>\d+)\): warning (?<msg_id>.+?): (?<message>.+?)$]]

Nota

La sintassi msg_id nel valore dell'attributo WarningRegex deve essere effettivamente code, come descritto in Problema 3680.

Importare comandi personalizzati con il file di destinazione

Se si definiscono comandi personalizzati in un file di progetto Python, i comandi sono disponibili solo per tale progetto specifico. Quando si vogliono creare comandi personalizzati e usarli in più progetti, è possibile definire il gruppo di proprietà <PythonCommands> con tutti gli elementi <Target> in un file di destinazioni (.targets) e quindi importare il file nei progetti Python.

Il file di destinazione usa lo stesso formato e la stessa sintassi per definire comandi personalizzati come descritto per il file di progetto Python (.pyproj). Gli elementi comuni da configurare includono <PythonCommands>, <Target>, <CreatePythonCommandItem>e <Output>:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <PythonCommands>
       $(PythonCommands);
       <!-- Additional command names -->
     </PythonCommands>
   </PropertyGroup>

   <Target Name="..." Label="..." Returns="@(Commands)">
     <!-- CreatePythonCommandItem and Output elements... -->
   </Target>

   <!-- Any number of additional Target elements-->
</Project>

Per importare un file di destinazioni nel progetto, aggiungere un elemento <Import Project="(path)"> ovunque all'interno dell'elemento <Project> nel file di progetto.

Ad esempio, se si dispone di un file di progetto denominato CustomCommands.targets in una cartella di destinazione all'interno del progetto Python, aggiungere il codice seguente al file di progetto:
```
<Import Project="targets/CustomCommands.targets"/>
```
Se il file di progetto importa un file di destinazioni e si apportano modifiche al file di destinazione mentre il progetto è aperto in Visual Studio, è necessario ricompilare la soluzione di visual Studio che contiene il progetto e non solo il progetto.

Comandi di esempio

Le sezioni seguenti forniscono codice di esempio che è possibile usare per definire comandi personalizzati per i progetti Python.

Eseguire PyLint (destinazione del modulo)

Il codice seguente si trova nel file Microsoft.PythonTools.targets:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);PythonRunPyLintCommand</PythonCommands>
  <PyLintWarningRegex>
    <![CDATA[^(?<filename>.+?)\((?<line>\d+),(?<column>\d+)\): warning (?<msg_id>.+?): (?<message>.+?)$]]>
  </PyLintWarningRegex>
</PropertyGroup>

<Target Name="PythonRunPyLintCommand"
        Label="resource:Microsoft.PythonTools.Common;Microsoft.PythonTools.Common.Strings;RunPyLintLabel"
        Returns="@(Commands)">
  <CreatePythonCommandItem Target="pylint.lint"
                           TargetType="module"
                           Arguments="&quot;--msg-template={abspath}({line},{column}): warning {msg_id}: {msg} [{C}:{symbol}]&quot; -r n @(Compile, ' ')"
                           WorkingDirectory="$(MSBuildProjectDirectory)"
                           ExecuteIn="output"
                           RequiredPackages="pylint&gt;=1.0.0"
                           WarningRegex="$(PyLintWarningRegex)">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Eseguire pip install con un pacchetto specifico (target pip)

Il comando seguente esegue il comando nella finestra output di Visual Studio . È possibile usare un comando simile a questo quando si sviluppa un pacchetto e si testa l'installazione. L'elemento <Target> contiene il nome del pacchetto anziché il comando install, che si presuppone quando si usa la definizione dell'attributo ExecuteIn="output".

<PropertyGroup>
  <PythonCommands>$(PythonCommands);InstallMyPackage</PythonCommands>
</PropertyGroup>

<Target Name="InstallMyPackage" Label="pip install my-package" Returns="@(Commands)">
  <CreatePythonCommandItem Target="my-package" TargetType="pip" Arguments=""
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Mostra pacchetti pip obsoleti (obiettivo pip)

Il comando seguente esegue pip con la funzione list per identificare i pacchetti pip obsoleti:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);ShowOutdatedPackages</PythonCommands>
</PropertyGroup>

<Target Name="ShowOutdatedPackages" Label="Show outdated pip packages" Returns="@(Commands)">
  <CreatePythonCommandItem Target="list" TargetType="pip" Arguments="-o --format columns"
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="consolepause">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Eseguire il file eseguibile con il programma consolepause

Il comando seguente esegue la funzione where per visualizzare il percorso dei file Python a partire dalla cartella del progetto:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);ShowAllPythonFilesInProject</PythonCommands>
</PropertyGroup>

<Target Name="ShowAllPythonFilesInProject" Label="Show Python files in project" Returns="@(Commands)">
  <CreatePythonCommandItem Target="where" TargetType="executable" Arguments="/r . *.py"
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Eseguire il server ed eseguire i comandi del server di debug

Per esplorare come vengono definiti i comandi Start server e Start debug server per progetti web, esaminare il repository Microsoft.PythonTools.Web.targets su GitHub.

Installare il pacchetto per lo sviluppo

Il codice seguente esegue pip per installare i pacchetti:

<PropertyGroup>
  <PythonCommands>PipInstallDevCommand;$(PythonCommands);</PythonCommands>
</PropertyGroup>

<Target Name="PipInstallDevCommand" Label="Install package for development" Returns="@(Commands)">
    <CreatePythonCommandItem Target="pip" TargetType="module" Arguments="install --editable $(ProjectDir)"
        WorkingDirectory="$(WorkingDirectory)" ExecuteIn="Repl:Install package for development">
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Da fxthomas/Example.pyproj.xml (GitHub), usato con l'autorizzazione.

Genera programma di installazione di Windows

Lo script seguente genera un programma di installazione di Windows:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);BdistWinInstCommand;</PythonCommands>
</PropertyGroup>

<Target Name="BdistWinInstCommand" Label="Generate Windows Installer" Returns="@(Commands)">
    <CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
        Arguments="bdist_wininst --user-access-control=force --title &quot;$(InstallerTitle)&quot; --dist-dir=&quot;$(DistributionOutputDir)&quot;"
        WorkingDirectory="$(WorkingDirectory)" RequiredPackages="setuptools"
        ExecuteIn="Repl:Generate Windows Installer">
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Da fxthomas/Example.pyproj.xml (GitHub), usato con l'autorizzazione.

Generare un pacchetto wheel di Python

Lo script seguente genera un pacchetto wheel Python:

<PropertyGroup>
  <PythonCommands>$(PythonCommands);BdistWheelCommand;</PythonCommands>
</PropertyGroup>

<Target Name="BdistWheelCommand" Label="Generate Wheel Package" Returns="@(Commands)">

  <CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
      Arguments="bdist_wheel --dist-dir=&quot;$(DistributionOutputDir)&quot;"
      WorkingDirectory="$(WorkingDirectory)" RequiredPackages="wheel;setuptools"
      ExecuteIn="Repl:Generate Wheel Package">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Da fxthomas/Example.pyproj.xml (GitHub), usato con l'autorizzazione.

Risolvere i problemi relativi ai comandi personalizzati

Esaminare le sezioni seguenti per individuare i possibili problemi relativi all'uso di comandi personalizzati.

File di progetto non caricato

Questo messaggio di errore indica che sono presenti errori di sintassi nel file di progetto. Il messaggio include l'errore specifico con un numero di riga e una posizione del carattere.

La finestra della console si chiude dopo l'esecuzione del comando

Se la finestra della console viene chiusa immediatamente dopo l'esecuzione del comando, usare la definizione dell'attributo ExecuteIn="consolepause" anziché ExecuteIn="console".

Se non vedi il comando personalizzato nel menu di scelta rapida Python, verifica i seguenti elementi:

Verificare che il comando sia incluso nel gruppo di proprietà <PythonCommands>.
Verificare che il nome del comando definito dall'elenco di comandi corrisponda al nome specificato nell'elemento <Target>.

Ecco un esempio. Nel frammento di codice XML seguente il nome Example nel gruppo di proprietà <PythonCommands> non corrisponde al nome ExampleCommand nella definizione dell'elemento <Target>. Visual Studio non trova un comando denominato Example, quindi non viene visualizzato alcun comando. Usare ExampleCommand nell'elenco dei comandi o modificare il nome della destinazione in modo che sia solo Example.

  <PropertyGroup>
    <PythonCommands>$(PythonCommands);Example</PythonCommands>
  </PropertyGroup>
  <Target Name="ExampleCommand" Label="Example Command" Returns="@(Commands)">
    <!-- ... -->
  </Target>

Errore durante l'esecuzione del comando, non è stato possibile ottenere la destinazione del comando

Questo messaggio di errore indica che il contenuto degli elementi <Target> o <CreatePythonCommandItem> non è corretto.

Ecco alcuni possibili motivi per questo errore:

L'attributo dell'elemento <Target> obbligatorio è vuoto.
L'attributo TargetType obbligatorio è vuoto o contiene un valore non riconosciuto.
L'attributo ExecuteIn obbligatorio è vuoto o contiene un valore non riconosciuto.
L'attributo ErrorRegex o WarningRegex viene specificato senza impostare la definizione dell'attributo ExecuteIn="output".
Gli attributi non riconosciuti esistono nell'elemento . Ad esempio, il riferimento all'attributo potrebbe essere digitato erroneamente come Argumnets anziché Arguments.

I valori degli attributi possono essere vuoti se si fa riferimento a una proprietà non definita. Se si usa il token $(StartupFile) ma non viene definito alcun file di avvio nel progetto, il token viene risolto in una stringa vuota. In questi casi, potrebbe essere necessario definire un valore predefinito. Ad esempio, i comandi Esegui server e Esegui il server di debug, definiti nei modelli di progetto Bottle, Flask e Django, usano il file manage.py per impostazione predefinita (se non viene specificato un file di avvio del server nelle proprietà del progetto).

Visual Studio smette di rispondere e si arresta in modo anomalo

Se Visual Studio smette di rispondere e si arresta in modo anomalo quando si esegue il comando personalizzato, è probabile che si stia tentando di eseguire un comando della console con la definizione dell'attributo ExecuteIn="output". In questi casi, Visual Studio potrebbe arrestarsi in modo anomalo quando tenta di analizzare l'output. Per evitare questa condizione, usare invece la definizione dell'attributo ExecuteIn="console". Per ulteriori informazioni, vedere issue 3681.

Comando non riconosciuto come programma eseguibile o file batch

Quando si imposta la definizione dell'attributo TargetType="executable", il valore dell'attributo Target deve essere solo il nome del programma senza argomenti, ad esempio python o solo python.exe. In questo caso, spostare tutti gli argomenti nell'attributo Arguments.

Condividi tramite

Definire comandi personalizzati per i progetti Python in Visual Studio

Prerequisiti

Esplorare i comandi personalizzati

Ricaricare il progetto per accedere ai comandi personalizzati

Aggiungere comandi personalizzati con il file di progetto

Usare le proprietà del progetto

Comprendere la struttura dell'elemento target <>

Attributi di destinazione

Attributi di createPythonCommandItem

Gruppi di acquisizione denominati per le espressioni regolari

Importare comandi personalizzati con il file di destinazione

Comandi di esempio

Eseguire PyLint (destinazione del modulo)

Eseguire pip install con un pacchetto specifico (target pip)

Mostra pacchetti pip obsoleti (obiettivo pip)

Eseguire il file eseguibile con il programma consolepause

Eseguire il server ed eseguire i comandi del server di debug

Installare il pacchetto per lo sviluppo

Genera programma di installazione di Windows

Generare un pacchetto wheel di Python

Risolvere i problemi relativi ai comandi personalizzati

File di progetto non caricato

La finestra della console si chiude dopo l'esecuzione del comando

Comando mancante dal menu

Errore durante l'esecuzione del comando, non è stato possibile ottenere la destinazione del comando

Visual Studio smette di rispondere e si arresta in modo anomalo

Comando non riconosciuto come programma eseguibile o file batch

Commenti e suggerimenti

Risorse aggiuntive