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

Bei der Entwicklung Ihrer Python-Projekte werden Sie vielleicht zu einem Befehlsfenster wechseln, um bestimmte Skripte oder Module auszuführen, pip-Befehle auszuführen oder andere Werkzeuge 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 Ausgabefenster von Visual Studio ausgeführt werden. Sie können auch reguläre Ausdrücke verwenden, um Visual Studio anzuweisen, wie Fehler und Warnungen von der Befehlsausgabe analysiert werden sollen.

Voraussetzungen

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

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

Erkunden von benutzerdefinierten Befehlen

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 Folgendes verweisen: Eine Python-Datei, ein Python-Modul, Inline-Python-Code, eine beliebige ausführbare Datei oder ein PIP-Befehl. 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 Zieledatei (.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 mit Hilfe einer Zieledatei hinzu. Die Vorlagen „Bottle-Webprojekt“ und „Flask-Webprojekt“ fügen die Befehle Start server und Start debug server hinzu. Die Vorlage „Django-Webprojekt“ fügt diese Befehle und einige weitere hinzu:

  

Projekt erneut laden, um auf benutzerdefinierte Befehle zuzugreifen

Wenn ein Projekt in Visual Studio geöffnet ist und Sie Änderungen an der entsprechenden Projektdatei in einem Editor vornehmen, müssen Sie das Projekt neu laden, um die Änderungen zu übernehmen. In ähnlicher Weise müssen Sie, nachdem Sie benutzerdefinierte Python-Befehle in einer Python-Projektdatei definiert haben, das Python-Projekt neu laden, damit die Befehle im Python-Projektmenü erscheinen. Wenn Sie benutzerdefinierte Befehle ändern, die in einer Zieledatei 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:

1. Öffnen Sie Ihr Python-Projekt in Visual Studio. (Wenn Sie ein Projekt in Visual Studio öffnen, wird das Projekt standardmäßig geladen.)

2. 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 bearbeiten aus:

   

3. Nehmen Sie ihre Änderungen an der Projektdatei im Visual-Studio-Editor vor und speichern Sie Ihre Arbeit.

4. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das entladene Projekt und wählen Sie Projekt erneut laden aus. 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 Entladen-Bearbeiten-Speichern-Laden kann mühsam werden, wenn Sie benutzerdefinierte Befehle entwickeln. 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 Instance von Visual Studio, Visual Studio Code, Windows-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 Neu laden oder Alles neu laden und Visual Studio wendet die Änderungen an der Projektdatei sofort auf das geöffnete Projekt an.

Hinzufügen von benutzerdefinierten Befehlen mit der Projektdatei

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

1. Erstellen Sie in Visual Studio ein neues Python-Projekt mit dem Namen Python-CustomCommands, indem Sie die Vorlage Python-Anwendung verwenden. Eine Anleitung finden Sie unter Schnellstart: Ein Python-Projekt aus einer Vorlage erstellen.

   Visual Studio erstellt das Python-Projekt und lädt es in Ihre Sitzung. Sie können das Projekt über die Projektdatei (.pyproj) konfigurieren. Diese Datei ist nur in Visual Studio sichtbar, wenn das Projekt geöffnet ist, aber entladen. Das Projekt verfügt außerdem über eine Python-Datei (.py) für den Anwendungscode.

2. Öffnen Sie die Python_CustomCommands.py-Anwendungsdatei im Editor und fügen Sie den folgenden Code hinzu:

   print("Hello custom commands")
   

3. Klicken Sie in Projektmappen-Explorer mit 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ü PyLint ausführen und Mypy ausführen. Wenn Sie benutzerdefinierte Befehle definieren, werden sie auch in diesem Menü angezeigt.

4. Starten Sie einen separaten Editor außerhalb Ihrer Visual-Studio-Sitzung und öffnen Sie die Python-Projektdatei (Python-CustomCommands.pyproj) im Editor. (Öffnen Sie unbedingt die Projektdatei (.pyproj) und nicht die Python-Anwendungsdatei (.py).)

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

6. 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 Neu laden aus, um das geöffnete Projekt mit den Änderungen der Projektdatei zu aktualisieren.

7. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Python-Projekt, wählen Sie Python aus und überprüfen Sie die Befehle im Kontextmenü.

   Im Kontextmenü werden weiterhin nur die Befehle PyLint ausführen und Mypy ausführen angezeigt. 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.

8. 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 python.exe-Befehls in einem Konsolenfenster. Die Attributdefinition ExecuteIn="consolepause" verwendet eine Konsole, die wartet, bis Sie einen Schlüssel auswählen, um das Konsolenfenster zu schließen.

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

9. Ersetzen Sie die <PythonCommands>-Eigenschaftengruppe (in Schritt 5 hinzugefügt) 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 enthält die Menübeschriftung 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.

10. Speichern Sie Ihre Projektdateiänderungen und wechseln Sie zurück zu Visual Studio. Laden Sie an der Eingabeaufforderung Ihr Projekt neu.

11. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Python-Projekt, wählen Sie Python aus und überprüfen Sie die Befehle im Kontextmenü erneut.

    Nun befindet sich 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 9 beschrieben. Beachten Sie auch die Hinweise im Abschnitt Problembehandlung weiter unten in diesem Artikel.

    

12. Wählen Sie den Befehl Startdatei ausführen. Ein Konsolenfenster wird geöffnet und zeigt den Text Hello benutzerdefinierte Befehle gefolgt von Drücken Sie eine beliebige Taste, um fortzufahren an. Bestätigen Sie die Ausgabe und schließen Sie das Konsolenfenster.

    

    Hinweis

    Das benutzerdefinierte Befehlsskript wird in der aktivierten Umgebung für Ihr Python-Projekt ausgeführt.

13. Wechseln Sie in den Editor mit der Projektdatei. Ändern Sie in der <Target>-Elementdefinition (in Schritt 8 hinzugefügt) den Wert des ExecuteIn-Attributs in output.

      <CreatePythonCommandItem
        ...
        ExecuteIn="output">
        ...
      </CreatePythonCommandItem>
    

14. Speichern Sie Ihre Änderungen, wechseln Sie zurück zu Visual Studio und laden Sie das Projekt neu.

15. Wählen Sie den benutzerdefinierten Befehl Startdatei ausführen erneut im Python-Kontextmenü aus. Jetzt wird die Programmausgabe im Visual Studio-Ausgabefenster anstelle eines Konsolenfensters angezeigt:

    

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

Verwenden Sie zum Verweisen auf Projekteigenschaften oder Umgebungsvariablen in <Target>-Element-Attributwerten den Namen 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 Eigenschaft StartupFile und der Befehl fehlschlägt, da das Token nicht definiert ist, deaktiviert Visual Studio den Befehl, bis Sie das Projekt erneut laden. Wenn Sie Änderungen am Projekt vornehmen, die die Eigenschaftsdefinition verändern, wird der Status des entsprechenden Befehls nicht aktualisiert. In diesem Fall müssen Sie das Projekt immer noch neu laden.

Grundlegendes zur <Ziel>elementstruktur

Sie definieren die Details für einen benutzerdefinierten Befehl mithilfe des <Target>-Elements. Das allgemeine Format des Elements <Target> wird im folgenden Codebeispiel gezeigt:

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

Attribute von „Target“

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

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

Attribute von CreatePythonCommandItem

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>-Element-Attribute 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ührt die ausführbare Datei aus, die im Target-Attribut angegeben ist und fügt den Wert an Arguments-Attribut an, als ob er direkt in die Befehlszeile eingegeben worden wäre. Der Wert darf nur einen Programmnamen ohne Argumente enthalten. - script: Führen Sie den python.exe-Befehl mit dem Dateinamen im Target-Attribut aus, gefolgt vom Wert im Arguments-Attribut. - module: Führen Sie den python -m-Befehl aus, gefolgt von dem Modulnamen im Target-Attribut aus, gefolgt vom Wert im Arguments-Attribut. - code: Führen Sie den Inlinecode aus, der im Target-Attribut enthalten ist. Ignorieren Sie den Arguments-Attributwert. - pip: Führen Sie pip mit dem Befehl im Attribut Target aus, gefolgt von dem Wert im Attribut Arguments. Wenn das ExecuteIn-Attribut auf output festgelegt ist, geht pip davon aus, dass die Anforderung den install-Befehl ausführt und das Target-Attribut als Paketname verwendet.
Target	Ja	Gibt den zu verwendenden Dateinamen, Modulnamen, Code oder Pip-Befehl abhängig vom Wert des TargetType-Attributs an.
Arguments	Optional	Stellt eine Zeichenfolge mit Argumenten bereit (falls vorhanden), die mit dem Target-Attribut verwendet werden sollen. – Wenn der TargetType-Attributwert script lautet, wird der Arguments-Wert anstelle des python.exe-Befehls an das Python-Programm übergeben. – Wenn der TargetType-Attributwert code ist, wird der Arguments-Wert ignoriert.
ExecuteIn	Ja	Gibt die Umgebung an, in der die Anwendung ausgeführt wird: - console: (Standard) Führt das Target-Attribut mit dem Arguments-Wert aus, als ob es direkt in die Befehlszeile eingegeben wird. Während das Target-Attribut ausgeführt wird, erscheint ein Befehlsfenster, das automatisch geschlossen wird. - consolepause: Gleiches Verhalten wie bei console, wartet aber auf einen Tastendruck, bevor das Fenster geschlossen wird. - output: Führt das Target-Attribut aus und zeigt die Ergebnisse im Visual Studio-Ausgabefenster an. Wenn das TargetType-Attribut pip lautet, verwendet Visual Studio das Target-Attribut als Paketnamen und fügt den Arguments-Attributwert an. - repl: Führt das Target-Attribut im Python Interactive Window aus. Der optionale Anzeigename wird für den Titel des Fensters verwendet. - none: Gleiches Verhalten wie console.
WorkingDirectory	Optional	Gibt den Ordner an, in dem der Befehl ausgeführt werden soll.
ErrorRegex WarningRegEx	Optional	Wird nur verwendet, wenn das ExecuteIn-Attribut auf output gesetzt ist. Beide Attributwerte geben einen regulären Ausdruck an, den Visual Studio verwendet, um die Befehlsausgabe zu analysieren und Fehler und Warnungen im Fenster Fehlerliste anzuzeigen. Wenn diese Attribute nicht angegeben sind, wirkt der Befehl sich nicht auf das Fenster Fehlerliste aus. Weitere Informationen darüber, was Visual Studio erwartet, finden Sie unter Named capture groups (Benannte Erfassungsgruppen).
RequiredPackages	Optional	Stellt eine Liste der Paketanforderungen für den Befehl bereit, wobei dasselbe Format wie bei der Datei requirements.txt (pip.readthedocs.io) verwendet wird. Der Befehl PyLint ausführen gibt zum Beispiel 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 nutzt PIP zum Installieren fehlender Pakete.
Environment	Optional	Gibt eine Reihe von Umgebungsvariablen an, die vor der Ausführung des Befehls zu definieren sind. Jede Variable verwendet das Format \<NAME>=\<VALUE> mit mehreren Variablen, die durch Semikolons getrennt werden. Eine Variable mit mehreren Werten muss in einfache oder doppelte Anführungszeichen gesetzt werden, z. B. 'NAME=VALUE1;VALUE2'.

Benannte Erfassungsgruppen für reguläre Ausdrücke

Wenn Visual Studio Fehler und Warnungen aus benutzerdefinierten Befehlsausgaben analysiert, erwartet es, dass reguläre Ausdrücke in den ErrorRegex- und WarningRegex-Attributwerten die folgenden benannten Gruppen verwenden:

• (?<message>...): Fehlertext.
• (?<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 der Position in der Datei, für die der Fehler gemeldet wird.

Zum Beispiel erzeugt PyLint Warnungen in folgendem Format:

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

Damit Visual Studio die richtigen Informationen aus diesen Warnungen extrahieren und in dem Fenster Fehlerliste anzeigen kann, sollte der Attributwert WarningRegex für den Befehl PyLint ausführen wie folgt aussehen:

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

Hinweis

Die msg_id-Syntax im WarningRegex-Attributwert sollte tatsächlich code lauten, wie in Problem 3680 beschrieben.

Importieren von benutzerdefinierten Befehlen mit Zieledatei

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>-Eigenschaftsgruppe mit all Ihren <Target>-Elementen in einer Zieledatei (.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 (.pyproj) beschrieben. Die allgemeinen zu konfigurierenden 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 der Projektdatei hinzu.

  Wenn Sie zum Beispiel eine Projektdatei mit dem Namen CustomCommands.targets in einem Ziele-Ordner innerhalb Ihres Python-Projekts haben, fügen Sie den folgenden Code in Ihre Projektdatei ein:

  <Import Project="targets/CustomCommands.targets"/>
  

• Wenn Ihre Projektdatei eine Zieldatei importiert und Sie Änderungen an der Zieledatei vornehmen, während das Projekt in Visual Studio geöffnet ist, müssenSie die Visual Studio-Projektmappe neu erstellen, die Ihr Projekt enthält und nicht nur das 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 (Target-Modul)

Der folgende Code wird in der Datei Microsoft.PythonTools.targets 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)

Der folgende Befehl führt den pip install my-package-Befehl im Visual Studio-Ausgabefenster aus. 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 install-Befehl, 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“

Der folgende Befehl führt die where-Funktion aus, um den Speicherort der Python-Dateien ab dem Projektordner anzuzeigen:

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

Ausführen der Befehle „run server“ und „run debug server“

Für Informationen darüber, wie die Befehle Start server (Server starten) und Start debug server (Debugserver starten) für Webprojekte definiert werden, sehen Sie sich Microsoft.PythonTools.Web.targets-Repository auf GitHub an.

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>

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

Generieren des Windows Installer

Das folgende Skript generiert einen Windows Installer:

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

Generieren des Python-Wheel-Pakets

Das folgende Skript generiert ein Python-Wheel-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>

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

Problembehandlung bei benutzerdefinierten Befehlen

Informieren Sie sich in den folgenden Abschnitten über mögliche Probleme im Zusammenhang mit der Arbeit mit benutzerdefinierten Befehlen.

Projektdatei nicht geladen

Diese Fehlermeldung zeigt an, dass Sie Syntaxfehler in der Projektdatei haben. Die Meldung enthält den spezifischen Fehler mit einer Zeilennummer und Zeichenposition.

Konsolenfenster wird nach Ausführung des Befehls geschlossen

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

Befehl fehlt im Menü

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äß Definition der Befehlsliste mit dem im <Target>-Element angegebenen Namen übereinstimmt.

Im Folgenden sehen Sie ein Beispiel. Im folgenden XML-Codeausschnitt stimmt der Example-Name in der <PythonCommands>-Eigenschaftengruppe nicht mit dem ExampleCommand-Namen in der <Target>-Elementdefinition überein. Visual Studio findet keinen Befehl mit dem Namen Example, weshalb kein Befehl erscheint. Nutzen Sie entweder ExampleCommand in der Befehlsliste, oder ändern Sie den Namen von Target so, dass er nur Example lautet.

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

Fehler beim Ausführen des Befehls, Befehlsziel konnte nicht ermittelt werden

Diese Fehlermeldung weist darauf hin, dass der Inhalt der Elemente <Target> oder <CreatePythonCommandItem> falsch ist.

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

• Das erforderliche Attribut des Elements <Target> ist leer.
• Das benötigte Attribut TargetType ist leer oder enthält einen unbekannten Wert.
• Das benötigte Attribut ExecuteIn ist leer oder enthält einen unbekannten Wert.
• Das Attribut ErrorRegex oder WarningRegex wird ohne Festlegen der ExecuteIn="output"-Attributdefinition angegeben.
• Unbekannte Attribute sind in dem Element vorhanden. Der Attributverweis kann z. B. als Argumnets und nicht als Arguments falsch geschrieben sein.

Attributwerte können leer sein, wenn Sie auf eine nicht definierte Eigenschaft verweisen. 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 sollten Sie einen Standardwert definieren. Die Befehle Run server (Server ausführen) und Run debug server (Debugserver ausführen), die in den Projektvorlagen Bottle, Flask und Django definiert sind, verwenden beispielsweise standardmäßig die Datei manage.py (wenn in den Projekteigenschaften keine Server-Startdatei angegeben ist).

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 analysieren. Um diese Bedingung zu vermeiden, verwenden Sie stattdessen die ExecuteIn="console"-Attributdefinition. Weitere Informationen finden Sie im Issue 3681.

Befehl nicht als lauffähige Programm- oder Batchdatei erkannt

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