Definieren von benutzerdefinierten Befehlen für Python-Projekte in Visual Studio

Artikel
02/03/2025

Während Sie Ihre Python-Projekte entwickeln, können Sie zu einem Befehlsfenster wechseln, um bestimmte Skripts oder Module auszuführen, Pip-Befehle auszuführen oder andere Tools mit Ihrem Code zu verwenden. Um Ihren Workflow zu verbessern, können Sie dem Python Projektmenü in Visual Studio benutzerdefinierte Befehle hinzufügen. Die benutzerdefinierten Python-Befehle können in einem Konsolenfenster oder im Visual Studio-Ausgabefenster ausgeführt werden. Sie können auch reguläre Ausdrücke verwenden, um Visual Studio anzuweisen, wie Fehler und Warnungen aus der Befehlsausgabe analysiert werden.

Voraussetzungen

Visual Studio unter Windows mit Unterstützung für Python-Workloads installiert. Weitere Informationen finden Sie unter Installieren der Python-Unterstützung in Visual Studio.

Visual Studio für Mac wird nicht unterstützt. Weitere Informationen finden Sie unter Was geschieht mit Visual Studio für Mac? Visual Studio Code unter Windows, Mac und Linux funktioniert gut mit Python über verfügbare Erweiterungen.

Benutzerdefinierte Befehle erkunden

Standardmäßig enthält das Python Projektmenü zwei Befehle, "PyLint ausführen" und "Mypy ausführen":

Alle benutzerdefinierten Python-Befehle, die Sie definieren, werden in diesem Menü angezeigt. Ein benutzerdefinierter Befehl kann auf eine Python-Datei, ein Python-Modul, inline Python-Code, eine beliebige ausführbare Datei oder einen Pip-Befehl verweisen. Sie können auch angeben, wie und wo der Befehl ausgeführt wird.

Sie können benutzerdefinierte Befehle auf verschiedene Arten hinzufügen:

Definieren Sie benutzerdefinierte Befehle in einer Python-Projektdatei (.pyproj) direkt. Diese Befehle gelten für dieses bestimmte Projekt.
Definieren von benutzerdefinierten Befehlen in einer Zieldatei (.targets). Sie können die Befehle in dieser Datei ganz einfach importieren, um sie mit mehreren Projekten zu verwenden.
Erstellen Sie ein Python-Projekt aus einer Projektvorlage in Visual Studio, die benutzerdefinierte Python-Befehle definiert.

Bestimmte Python-Projektvorlagen in Visual Studio fügen benutzerdefinierte Befehle mithilfe einer Zieldatei hinzu. Die Vorlagen "Bottle Web Project" und "Flask Web Project" fügen zwei Befehle hinzu, Startserver und Start debug server. Die Vorlage "Django Web Project" fügt diese Befehle und mehrere weitere Befehle hinzu:

Projekt erneut laden, um auf benutzerdefinierte Befehle zuzugreifen

Wenn ein Projekt in Visual Studio geöffnet ist, müssen Sie das Projekt neu laden, um die Änderungen an der entsprechenden Projektdatei in einem Editor anzuwenden. Nachdem Sie benutzerdefinierte Python-Befehle in einer Python-Projektdatei definiert haben, müssen Sie das Python-Projekt neu laden, damit die Befehle im Python Projektmenü angezeigt werden. Wenn Sie benutzerdefinierte Befehle ändern, die in einer Zieldatei definiert sind, müssen Sie die vollständige Visual Studio-Projektmappe für jedes Projekt neu erstellen, das die Datei importiert.

Ein allgemeiner Ansatz besteht darin, die Änderungen an der Python-Projektdatei direkt in Visual Studio vorzunehmen:

Öffnen Sie Ihr Python-Projekt in Visual Studio. (Wenn Sie ein Projekt in Visual Studio öffnen, wird das Projekt standardmäßig geladen.)
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Python-Projekt, und wählen Sie Projekt entladen aus.

Visual Studio entlädt das Projekt und öffnet die entsprechende Python-Projektdatei (.pyproj) im Editor.

Wenn die Projektdatei nicht geöffnet wird, klicken Sie erneut mit der rechten Maustaste auf das Python-Projekt, und wählen Sie Projektdatei bearbeitenaus:
Nehmen Sie ihre Änderungen an der Projektdatei im Visual Studio-Editor vor, und speichern Sie Ihre Arbeit.
Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das entladene Projekt, und wählen Sie Projekt neu ladenaus. Wenn Sie versuchen, das Projekt neu zu laden, ohne die Änderungen in der Projektdatei zu speichern, fordert Visual Studio Sie auf, die Aktion abzuschließen.

Der Prozess des Entladens-Bearbeitens-Speicherns-Neuladens kann beim Entwickeln von benutzerdefinierten Befehlen mühsam werden. Ein effizienterer Workflow umfasst das gleichzeitige Laden des Projekts in Visual Studio und das Öffnen der Python-Projektdatei in einem separaten Editor. Sie können einen beliebigen Editor verwenden, z. B. eine andere Instanz von Visual Studio, Visual Studio Code, Editor usw. Nachdem Sie Ihre Änderungen im Editor gespeichert und wieder zu Visual Studio gewechselt haben, erkennt Visual Studio die Projektdateiänderungen für das geöffnete Projekt und fordert Sie auf, Maßnahmen zu ergreifen:

Wählen Sie Erneut laden oder Alle erneut laden aus, und Visual Studio wendet die Projektdateiänderungen sofort auf das geöffnete Projekt an.

Hinzufügen von benutzerdefinierten Befehlen in der Projektdatei

Das folgende Verfahren zeigt, wie Sie einen benutzerdefinierten Befehl erstellen, indem Sie die Definition in der Python-Projektdatei (.pyproj) hinzufügen und Ihr Projekt in Visual Studio neu laden. Der benutzerdefinierte Befehl führt die Startdatei eines Projekts direkt mithilfe des Befehls python.exe aus. Dies ist im Grunde identisch mit der Verwendung der Option Debuggen>Starten ohne Debuggen Option auf der Visual Studio-Hauptsymbolleiste.

Erstellen Sie in Visual Studio ein neues Python-Projekt mit dem Namen Python-CustomCommands mithilfe der Vorlage Python Application. Anweisungen finden Sie unter Schnellstart: Erstellen eines Python-Projekts aus einer Vorlage.

Visual Studio erstellt das Python-Projekt und lädt es in Ihre Sitzung. Sie können das Projekt über die Projektdatei konfigurieren (.pyproj). Diese Datei ist nur in Visual Studio sichtbar, wenn das Projekt geöffnet, aber entladen ist. Das Projekt verfügt auch über eine Python-Datei (.py) für den Anwendungscode.
Öffnen Sie die Python_CustomCommands.py Anwendungsdatei im Editor, und fügen Sie den folgenden Code hinzu:
```
print("Hello custom commands")
```
Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das Python-Projekt, wählen Sie Python-aus, und beachten Sie die Befehle im Kontextmenü. Derzeit sind die einzigen Befehle im Kontextmenü Run PyLint und Run Mypy. Wenn Sie benutzerdefinierte Befehle definieren, werden sie auch in diesem Menü angezeigt.
Starten Sie einen separaten Editor außerhalb Ihrer Visual Studio-Sitzung, und öffnen Sie die Python-Projektdatei (Python-CustomCommands.pyproj) im Editor. (Öffnen Sie die Projektdatei (.pyproj) und nicht die Python-Anwendungsdatei (.py).)
Suchen Sie in der Projektdatei das schließende </Project>-Element am Ende der Datei, und fügen Sie den folgenden XML-Code unmittelbar vor dem schließende Element hinzu:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Speichern Sie Ihre Projektdateiänderungen, und wechseln Sie zurück zu Visual Studio. Visual Studio erkennt Ihre Projektdateiänderungen und fordert Sie auf, Maßnahmen zu ergreifen. Wählen Sie an der Eingabeaufforderung Reload aus, um Ihr geöffnetes Projekt mit den Änderungen der Projektdatei zu aktualisieren.
Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das Python-Projekt, wählen Sie Python-aus, und überprüfen Sie die Befehle im Kontextmenü.

Das Kontextmenü zeigt weiterhin nur die befehle Run PyLint und Run Mypy. Der Code, den Sie soeben der Projektdatei hinzugefügt haben, repliziert einfach die Standardeigenschaftsgruppe <PythonCommands>, die den PyLint-befehl enthält. Im nächsten Schritt fügen Sie weiteren Code für den benutzerdefinierten Befehl hinzu.
Wechseln Sie zum Editor, in dem Sie die Projektdatei aktualisieren. Fügen Sie die folgende <Target> Elementdefinition innerhalb des <Project> Elements hinzu. Sie können die <Target> Definition vor oder nach der zuvor beschriebenen <PropertyGroup> Definition positionieren.

Dieses <Target>-Element definiert einen benutzerdefinierten Befehl zum Ausführen der Startdatei für das Projekt (identifiziert durch die StartupFile--Eigenschaft) mithilfe des Befehls python.exe in einem Konsolenfenster. Die Attributdefinition ExecuteIn="consolepause" verwendet eine Konsole, die wartet, bis Sie einen Schlüssel zum Schließen des Konsolenfensters auswählen.
```
<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>
```
Ersetzen Sie die <PythonCommands>-Eigenschaftengruppe (hinzugefügt in Schritt 5) durch den folgenden XML-Code. Diese Syntax definiert das Name-Attribut für das <Target>-Element, das dem Python Kontextmenü den benutzerdefinierten Befehl hinzufügt. Der Befehl verfügt über die Menübezeichnung Startdatei ausführen.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Tipp

Wenn Ihr benutzerdefinierter Befehl im Kontextmenü vor den im $(PythonCommands) Token definierten Standardbefehlen angezeigt werden soll, positionieren Sie die <Target> Syntax für den Befehl vor diesem Token.
Speichern Sie Ihre Projektdateiänderungen, und wechseln Sie zurück zu Visual Studio. Laden Sie Ihr Projekt bei der Aufforderung neu.
Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das Python-Projekt, wählen Sie Python-aus, und überprüfen Sie die Befehle im Kontextmenü erneut.

Nun ist der benutzerdefinierte Befehl Startdatei ausführen im Menü. Wenn der benutzerdefinierte Befehl nicht angezeigt wird, bestätigen Sie, dass Sie den Name Attributwert für das <Target> Element dem <PythonCommands> Element hinzugefügt haben, wie in schritt 9beschrieben. Lesen Sie auch die im Abschnitt Problembehandlung weiter unten in diesem Artikel aufgeführten Überlegungen.
Wählen Sie den Befehl Startdatei ausführen aus. Ein Konsolenfenster wird geöffnet und zeigt den Text Benutzerdefinierte Hello-Befehle gefolgt von Drücken Sie eine beliebige Taste, um den Vorgang fortzusetzen an. Bestätigen Sie die Ausgabe, und schließen Sie das Konsolenfenster.

Anmerkung

Das benutzerdefinierte Befehlsskript wird in der aktivierten Umgebung für Ihr Python-Projekt ausgeführt.
Wechseln Sie mit der Projektdatei zum Editor. Ändern Sie in der <Target> Elementdefinition (hinzugefügt in Schritt 8) den Wert des ExecuteIn Attributs in output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Speichern Sie Ihre Änderungen, wechseln Sie zurück zu Visual Studio, und laden Sie das Projekt neu.
Wählen Sie den benutzerdefinierten Befehl Startdatei ausführen erneut aus dem Kontextmenü Python aus. Jetzt wird die Programmausgabe im Visual Studio Ausgabefenster anstelle eines Konsolenfensters angezeigt:
Gehen Sie wie folgt vor, um weitere benutzerdefinierte Befehle hinzuzufügen:
1. Definieren Sie ein geeignetes <Target>-Element für den benutzerdefinierten Befehl in der Projektdatei.
2. Fügen Sie den Name Attributwert für das <Target>-Element zur <PythonCommands> Eigenschaftengruppe hinzu.
3. Speichern Sie Ihre Änderungen in der Projektdatei.
4. Laden Sie Ihr Projekt in Visual Studio neu.

Verwenden von Projekteigenschaften

Um auf Projekteigenschaften oder Umgebungsvariablen in <Target> Elementattributewerten zu verweisen, verwenden Sie den Eigenschaftennamen in einem $()-Token, z. B. $(StartupFile) und $(MSBuildProjectDirectory). Weitere Informationen finden Sie unter MSBuild-Eigenschaften.

Wenn Sie einen Befehl wie ($StartupFile) aufrufen, der Projekteigenschaften wie die StartupFile--Eigenschaft verwendet, und der Befehl schlägt fehl, da das Token nicht definiert ist, deaktiviert Visual Studio den Befehl, bis Sie das Projekt neu laden. Wenn Sie Änderungen am Projekt vornehmen, das die Eigenschaftsdefinition ändert, aktualisieren Ihre Änderungen nicht den Status des zugehörigen Befehls. In diesem Fall müssen Sie das Projekt immer noch neu laden.

Grundlegendes zur <Target>-Elementstruktur

Sie definieren die Details für einen benutzerdefinierten Befehl mithilfe des <Target>-Elements. Die allgemeine Form des <Target>-Elements wird im folgenden Pseudocode angezeigt:

<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>

Zielattribute

In der folgenden Tabelle sind die <Target>-Elementattribute aufgeführt.

Attribut	Erforderlich	Beschreibung
`Name`	Ja	Der Bezeichner für den Befehl im Visual Studio-Projekt. Dieser Name muss der `<PythonCommands>` Eigenschaftengruppe hinzugefügt werden, damit der Befehl im Kontextmenü Python angezeigt wird.
`Label`	Ja	Der Anzeigename der Benutzeroberfläche, der im Kontextmenü Python angezeigt wird.
`Returns`	Ja	Die zurückgegebenen Informationen müssen das `@(Commands)`-Token enthalten, das das Ziel als Befehl identifiziert.

CreatePythonCommandItem-Attribute

Das <Target>-Element enthält <CreatePythonCommandItem> und <Output> Elemente, die das detaillierte Verhalten für den benutzerdefinierten Befehl definieren. In der folgenden Tabelle sind die verfügbaren <CreatePythonCommandItem> Elementattribute aufgeführt. Alle Attributwerte beachten die Groß-/Kleinschreibung.

`Attribute`	Erforderlich	Beschreibung
`TargetType`	Ja	Gibt an, was das attribut `Target` enthält und wie der Wert zusammen mit dem attribut `Arguments` verwendet wird: - `executable`: Führen Sie die im attribut `Target` benannte ausführbare Datei aus, und fügen Sie den Wert im attribut `Arguments` an, als ob sie direkt in die Befehlszeile eingegeben wurde. Der Wert darf nur einen Programmnamen ohne Argumente enthalten. - `script`: Führen Sie den befehl `python.exe` mit dem Dateinamen im attribut `Target` gefolgt vom Wert im attribut `Arguments` aus. - `module`: Führen Sie den befehl `python -m` gefolgt vom Modulnamen im attribut `Target` gefolgt vom Wert im attribut `Arguments` aus. - `code`: Führen Sie den Inlinecode aus, der im attribut `Target` enthalten ist. Ignorieren Sie den Attributwert `Arguments`. - `pip`: Führen Sie PIP mit dem Befehl im Attribut `Target` aus, gefolgt vom Wert im Attribut `Arguments`. Wenn das attribut `ExecuteIn` auf `output`festgelegt ist, geht pip davon aus, dass die Anforderung das `install`-Befehl ausführt und das attribut `Target` als Paketname verwendet.
`Target`	Ja	Gibt den zu verwendenden Dateinamen, Modulnamen, Code oder Pip-Befehl abhängig vom Wert des attributs `TargetType` an.
`Arguments`	Wahlfrei	Stellt eine Zeichenfolge mit Argumenten (falls vorhanden) bereit, die mit dem attribut `Target` verwendet werden sollen. - Wenn der `TargetType` Attributwert `script`ist, wird der `Arguments` Wert anstelle des befehls `python.exe` an das Python-Programm übergeben. - Wenn der `TargetType` Attributwert `code`ist, wird der `Arguments` Wert ignoriert.
`ExecuteIn`	Ja	Gibt die Umgebung an, in der der Befehl ausgeführt werden soll: - `console`: (Standard) Führt das `Target`-Attribut mit dem `Arguments`-Wert aus, als wären sie direkt in die Befehlszeile eingegeben. Während das attribut `Target` ausgeführt wird, wird automatisch ein Befehlsfenster angezeigt und geschlossen. - `consolepause`: Dasselbe Verhalten wie `console`, wartet jedoch, bis eine Taste gedrückt wird, bevor das Fenster geschlossen wird. - `output`: Führt das Attribut `Target` aus und zeigt die Ergebnisse im Fenster Ausgabe von Visual Studio an Wenn das attribut `TargetTypepip`ist, verwendet Visual Studio das `Target` Attribut als Paketnamen und fügt den `Arguments` Attributwert an. - `repl`: Führt das `Target`-Attribut im Python Interactive Windowaus. Der optionale Anzeigename wird für den Titel des Fensters verwendet. - `none`: Gleiches Verhalten wie `console`.
`WorkingDirectory`	Wahlfrei	Gibt den Ordner an, in dem der Befehl ausgeführt werden soll.
`ErrorRegex` `WarningRegEx`	Wahlfrei	Wird nur verwendet, wenn das attribut `ExecuteIn` auf `output`festgelegt ist. Beide Attributwerte geben einen regulären Ausdruck an, den Visual Studio zum Analysieren der Befehlsausgabe verwendet und Fehler und Warnungen im Fehlerliste Fenster anzeigt. Wenn diese Attribute nicht angegeben sind, wirkt sich der Befehl nicht auf das fenster Fehlerliste aus. Weitere Informationen darüber, was Visual Studio erwartet, finden Sie unter Benannte Erfassungsgruppen.
`RequiredPackages`	Wahlfrei	Stellt eine Liste der Paketanforderungen für den Befehl mithilfe desselben Formats wie die requirements.txt-Datei (pip.readthedocs.io) bereit. Beispielsweise gibt der Befehl Ausführen von PyLint das Format `pylint>=1.0.0`an. Bevor Sie den Befehl ausführen, bestätigt Visual Studio, dass alle Pakete in der Liste installiert sind. Visual Studio verwendet Pip, um fehlende Pakete zu installieren.
`Environment`	Wahlfrei	Identifiziert eine Zeichenfolge von Umgebungsvariablen, die vor dem Ausführen des Befehls definiert werden sollen. Jede Variable verwendet das Formular `\<NAME>=\<VALUE>` mit mehreren Variablen, die durch Semikolons getrennt sind. Eine Variable mit mehreren Werten muss wie in `'NAME=VALUE1;VALUE2'`in einfachen oder doppelten Anführungszeichen enthalten sein.

Benannte Erfassungsgruppen für reguläre Ausdrücke

Wenn Visual Studio Fehler und Warnungen aus der benutzerdefinierten Befehlsausgabe analysiert, erwartet es reguläre Ausdrücke in den Attributwerten ErrorRegex und WarningRegex, um die folgenden benannten Gruppen zu nutzen:

(?<message>...): Text des Fehlers.
(?<code>...): Fehlercodewert.
(?<filename>...): Name der Datei, für die der Fehler gemeldet wird.
(?<line>...): Zeilennummer der Position in der Datei, für die der Fehler gemeldet wird.
(?<column>...): Spaltennummer des Speicherorts in der Datei, für den der Fehler gemeldet wird.

PyLint erzeugt z. B. Warnungen des folgenden Formulars:

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

Damit Visual Studio die richtigen Informationen aus diesen Warnungen extrahieren und im Fenster Fehlerliste anzeigen kann, lautet der WarningRegex Attributwert für den Befehl Ausführen von Pylint wie folgt:

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

Anmerkung

Die msg_id-Syntax im Attributwert WarningRegex sollte code sein, wie in Problem 3680 beschrieben.

Importieren benutzerdefinierter Befehle mit targets-Datei

Wenn Sie benutzerdefinierte Befehle in einer Python-Projektdatei definieren, sind die Befehle nur für dieses bestimmte Projekt verfügbar. Wenn Sie benutzerdefinierte Befehle erstellen und in mehreren Projekten verwenden möchten, können Sie die <PythonCommands> Eigenschaftengruppe mit allen <Target> Elementen in einer Zieldatei (.targets) definieren und diese Datei dann in Ihre Python-Projekte importieren.

Die Zieldatei verwendet dasselbe Format und dieselbe Syntax, um benutzerdefinierte Befehle zu definieren, wie für die Python-Projektdatei beschrieben (.pyproj). Die zu konfigurierenden allgemeinen Elemente umfassen <PythonCommands>, <Target>, <CreatePythonCommandItem>und <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>

Um eine Zieldatei in Ihr Projekt zu importieren, fügen Sie ein <Import Project="(path)"> Element an einer beliebigen Stelle innerhalb des <Project> Elements in Ihrer Projektdatei hinzu.

Wenn Sie z. B. eine Projektdatei mit dem Namen CustomCommands.targets in einem Zielordner in Ihrem Python-Projekt haben, fügen Sie der Projektdatei den folgenden Code hinzu:
```
<Import Project="targets/CustomCommands.targets"/>
```
Wenn Ihre Projektdatei eine targets-Datei importiert und Sie Änderungen an dieser vornehmen, während das Projekt in Visual Studio geöffnet ist, müssen Sie die Visual Studio-Projektmappe, die Ihr Projekt enthält, erneut erstellen und nicht nur Ihr Projekt.

Beispielbefehle

In den folgenden Abschnitten finden Sie Beispielcode, mit dem Sie benutzerdefinierte Befehle für Ihre Python-Projekte definieren können.

PyLint ausführen (Modulziel)

Der folgende Code wird in der Microsoft.PythonTools.targets Datei angezeigt:

<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>

Ausführen der PIP-Installation mit einem spezifischen Paket (PIP-Target)

Mit dem folgenden Befehl wird der Befehl pip install my-package im Fenster "Ausgabe " von Visual Studio ausgeführt. Sie können einen Befehl wie diesen verwenden, wenn Sie ein Paket entwickeln und dessen Installation testen. Das <Target>-Element enthält den Paketnamen und nicht den befehl install, der bei Verwendung der ExecuteIn="output" Attributdefinition angenommen wird.

<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>

Anzeigen von veralteten PIP-Paketen (PIP-Target)

Der folgende Befehl führt pip mit der list-Funktion aus, um veraltete Pip-Pakete zu identifizieren:

<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>

Ausführen einer ausführbaren Datei mit „consolepause“

Mit dem folgenden Befehl wird die where-Funktion ausgeführt, um den Speicherort von Python-Dateien anzuzeigen, die mit dem Projektordner beginnen:

<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>

Server- und Debugserver-Befehle ausführen

Um zu erfahren, wie der Startserver und Start debug server Befehle für Webprojekte definiert sind, untersuchen Sie die Microsoft.PythonTools.Web.targets Repository auf GitHub.

Installationspaket für die Entwicklung

Der folgende Code führt pip aus, um Pakete zu installieren:

<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>

From fxthomas/Example.pyproj.xml (GitHub), verwendet mit Erlaubnis.

Windows-Installationsprogramm generieren

Das folgende Skript generiert ein Windows-Installationsprogramm:

<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>

Aus fxthomas/Example.pyproj.xml (GitHub), Verwendung mit Berechtigung

Python-Radpaket generieren

Das folgende Skript generiert ein Python-Rad Paket:

<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>

From fxthomas/Example.pyproj.xml (GitHub), mit Genehmigung verwendet.

Behandeln von Problemen mit benutzerdefinierten Befehlen

Lesen Sie die folgenden Abschnitte, um mögliche Probleme im Zusammenhang mit der Arbeit mit benutzerdefinierten Befehlen zu erfahren.

Project-Datei nicht geladen

Diese Fehlermeldung gibt an, dass In der Projektdatei Syntaxfehler auftreten. Die Nachricht enthält den spezifischen Fehler mit einer Zeilennummer und Zeichenposition.

Das Konsolenfenster wird geschlossen, nachdem der Befehl ausgeführt wurde.

Wenn das Konsolenfenster unmittelbar nach dem Ausführen des Befehls geschlossen wird, verwenden Sie die ExecuteIn="consolepause" Attributdefinition anstelle von ExecuteIn="console".

Wenn der benutzerdefinierte Befehl im Python Kontextmenü nicht angezeigt wird, überprüfen Sie die folgenden Elemente:

Vergewissern Sie sich, dass der Befehl in der <PythonCommands>-Eigenschaftengruppe enthalten ist.
Stellen Sie sicher, dass der Befehlsname gemäß der Definition der Befehlsliste mit dem im <Target>-Element angegebenen Namen übereinstimmt.

Hier ist ein Beispiel. Im folgenden XML-Codeausschnitt entspricht der Example Name in der <PythonCommands>-Eigenschaftengruppe nicht dem ExampleCommand Namen in der <Target> Elementdefinition. Visual Studio findet keinen Befehl namens Example, sodass kein Befehl angezeigt wird. Verwenden Sie entweder ExampleCommand in der Befehlsliste, oder ändern Sie den Namen des Ziels so, dass er nur Exampleist.

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

Fehler beim Ausführen des Befehls, Fehler beim Abrufen des Zielbefehls

Diese Fehlermeldung gibt an, dass der Inhalt der <Target> oder <CreatePythonCommandItem> Elemente falsch ist.

Hier sind einige mögliche Ursachen für diesen Fehler:

Das erforderliche <Target>-Elementattribut ist leer.
Das erforderliche TargetType Attribut ist leer oder enthält einen unbekannten Wert.
Das erforderliche ExecuteIn Attribut ist leer oder enthält einen unbekannten Wert.
Das attribut ErrorRegex oder WarningRegex wird ohne Festlegen der attributdefinition ExecuteIn="output" angegeben.
Nicht erkannte Attribute sind im Element vorhanden. Der Attributverweis kann z. B. als Argumnets und nicht als Argumentsfalsch geschrieben werden.

Attributwerte können leer sein, wenn Sie auf eine Eigenschaft verweisen, die nicht definiert ist. Wenn Sie das Token $(StartupFile) verwenden, aber keine Startdatei im Projekt definiert ist, wird das Token in eine leere Zeichenfolge aufgelöst. In solchen Fällen möchten Sie möglicherweise einen Standardwert definieren. Beispielsweise verwenden die in den Projektvorlagen "Bottle", "Flask" und "Django" definierten Befehle Ausführen des Servers und Ausführen des Debugservers standardmäßig die Datei manage.py, sofern in den Projekteigenschaften keine Serverstartdatei spezifiziert wurde.

Visual Studio reagiert nicht mehr, stürzt ab

Wenn Visual Studio nicht mehr reagiert und abstürzt, wenn Sie den benutzerdefinierten Befehl ausführen, versuchen Sie wahrscheinlich, einen Konsolenbefehl mit der ExecuteIn="output" Attributdefinition auszuführen. In solchen Fällen stürzt Visual Studio möglicherweise ab, wenn versucht wird, die Ausgabe zu parsen. Um diese Bedingung zu vermeiden, verwenden Sie stattdessen die ExecuteIn="console" Attributdefinition. Weitere Informationen finden Sie unter Problem 3681.

Befehl nicht als operierbare Programm- oder Batchdatei erkannt

Wenn Sie die TargetType="executable"-Attributdefinition festlegen, muss der Wert im Attribut Target nur der Programmname ohne Argumente sein, z. B. nur python oder nur python.exe. Verschieben Sie in diesem Fall alle Argumente in das attribut Arguments.

Freigeben über