Definiera anpassade kommandon för Python-projekt i Visual Studio

När du utvecklar dina Python-projekt kanske du växlar till ett kommandofönster för att köra specifika skript eller moduler, köra pip-kommandon eller använda andra verktyg med din kod. För att förbättra arbetsflödet kan du lägga till anpassade kommandon på Python-projektmenyn i Visual Studio. De anpassade Python-kommandona kan köras i ett konsolfönster eller i Visual Studio-utdatafönstret . Du kan också använda reguljära uttryck för att instruera Visual Studio hur du parsar fel och varningar från kommandoutdata.

Förutsättningar

Visual Studio på Windows installerat med stöd för Python-arbetsbelastningar. Mer information finns i Installera Python-stöd i Visual Studio.

Visual Studio för Mac stöds inte. Visual Studio Code på Windows, Mac och Linux fungerar bra med Python via tillgängliga tillägg.

Utforska anpassade kommandon

Som standard innehåller Python-projektmenyn två kommandon, Kör PyLint och Kör Mypy:

Alla anpassade Python-kommandon som du definierar visas på samma meny. Ett anpassat kommando kan referera till en Python-fil, en Python-modul, infogad Python-kod, en godtycklig körbar fil eller ett pip-kommando. Du kan också ange hur och var kommandot körs.

Du kan lägga till anpassade kommandon på flera sätt:

Definiera anpassade kommandon i en Python-projektfil (.pyproj) direkt. Dessa kommandon gäller för det specifika projektet.
Definiera anpassade kommandon i en målfil (.targets). Du kan enkelt importera kommandona i den här filen för att använda dem med flera projekt.
Skapa ett Python-projekt från en projektmall i Visual Studio som definierar anpassade Python-kommandon.

Vissa Python-projektmallar i Visual Studio lägger till anpassade kommandon med hjälp av en målfil. Mallarna Bottle Web Project och Flask Web Project lägger till två kommandon, Start server och Start debug server. Mallen Django Web Project lägger till följande kommandon och flera till:

Läs in projektet igen för att få åtkomst till anpassade kommandon

När ett projekt är öppet i Visual Studio måste du läsa in projektet igen om du gör ändringar i motsvarande projektfil i ett redigeringsprogram för att kunna tillämpa ändringarna på nytt. När du har definierat anpassade Python-kommandon i en Python-projektfil på liknande sätt måste du läsa in Python-projektet igen för att kommandona ska visas på Python-projektmenyn . När du ändrar anpassade kommandon som definierats i en målfil måste du återskapa den fullständiga Visual Studio-lösningen för alla projekt som importerar filen.

En vanlig metod är att göra ändringarna i Python-projektfilen direkt i Visual Studio:

Öppna Python-projektet i Visual Studio. (När du öppnar ett projekt i Visual Studio laddas projektet som standard.)
Högerklicka på Python-projektet i Solution Explorer och välj Ta bort projekt.

Visual Studio tar bort projektet och öppnar motsvarande Python-projektfil (.pyproj) i redigeraren.

Om projektfilen inte öppnas högerklickar du på Python-projektet igen och väljer Redigera projektfil:
Gör dina ändringar i projektfilen i Visual Studio-redigeraren och spara ditt arbete.
Högerklicka på det borttagna projektet i Solution Explorer och välj Läs in projektet igen. Om du försöker läsa in projektet igen utan att spara ändringarna i projektfilen uppmanar Visual Studio dig att slutföra åtgärden.

Processen för att ta bort-redigera-spara-ladda om kan bli omständlig när du utvecklar anpassade kommandon. Ett effektivare arbetsflöde innebär att projektet läses in samtidigt i Visual Studio och att Python-projektfilen öppnas i en separat redigerare. Du kan använda valfri redigerare, till exempel en annan instans av Visual Studio, Visual Studio Code, Anteckningar och så vidare. När du har sparat ändringarna i redigeraren och växlat tillbaka till Visual Studio identifierar Visual Studio projektfiländringarna för det öppna projektet och uppmanar dig att vidta åtgärder:

Välj Läs in igen eller läs in alla igen och Visual Studio tillämpar omedelbart dina projektfiländringar på det öppna projektet.

Lägga till anpassade kommandon med projektfilen

Följande procedur visar hur du skapar ett anpassat kommando genom att lägga till definitionen i Python-projektfilen (.pyproj) och läsa in projektet igen i Visual Studio. Det anpassade kommandot kör ett projekts startfil direkt med hjälp python.exe av kommandot, vilket i princip är detsamma som att använda alternativet Felsöka>start utan felsökning i huvudverktygsfältet i Visual Studio.

I Visual Studio skapar du ett nytt Python-projekt med namnet Python-CustomCommands med hjälp av Python-programmallen . Anvisningar finns i Snabbstart: Skapa ett Python-projekt från en mall.

Visual Studio skapar Python-projektet och läser in det i sessionen. Du kan konfigurera projektet via projektfilen (.pyproj). Den här filen visas bara i Visual Studio när projektet är öppet, men tas bort. Projektet har också en Python-fil (.py) för programkoden.
Öppna Python_CustomCommands.py-programfilen i redigeraren och lägg till följande kod:
```
print("Hello custom commands")
```
Högerklicka på Python-projektet i Solution Explorer, välj Python och lägg märke till kommandona på snabbmenyn. För närvarande är de enda kommandona på snabbmenyn Kör PyLint och Kör Mypy. När du definierar anpassade kommandon visas de också på den här menyn.
Starta en separat redigerare utanför Visual Studio-sessionen och öppna Python-projektfilen (Python-CustomCommands.pyproj) i redigeraren. (Se till att öppna projektfilen (.pyproj) och inte Python-programfilen (.py).)
Leta upp det avslutande </Project> elementet i slutet av filen i projektfilen och lägg till följande XML omedelbart före det avslutande elementet:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Spara ändringarna i projektfilen och växla tillbaka till Visual Studio. Visual Studio identifierar ändringar i projektfilen och uppmanar dig att vidta åtgärder. I kommandotolken väljer du Läs in igen för att uppdatera det öppna projektet med ändringarna i projektfilen.
Högerklicka på Python-projektet i Solution Explorer, välj Python och kontrollera kommandona på snabbmenyn.

Snabbmenyn visar fortfarande bara kommandona Kör PyLint och Kör Mypy . Koden som du precis lade till i projektfilen replikerar bara standardegenskapsgruppen <PythonCommands> som innehåller PyLint-kommandot . I nästa steg lägger du till mer kod för det anpassade kommandot.
Växla till redigeraren där du uppdaterar projektfilen. Lägg till följande <Target> elementdefinition i elementet <Project> . Du kan placera <Target> definitionen före eller efter definitionen <PropertyGroup> som beskrevs tidigare.

Det här <Target> elementet definierar ett anpassat kommando för att köra startfilen för projektet (identifieras av egenskapen StartupFile ) med hjälp python.exe av kommandot i ett konsolfönster. Attributdefinitionen ExecuteIn="consolepause" använder en konsol som väntar på att du ska välja en nyckel för att stänga konsolfönstret.
```
<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>
```
<PythonCommands> Ersätt egenskapsgruppen (läggs till i steg 5) med följande XML. Den här syntaxen definierar Name-attributet för <Target>-elementet, vilket lägger till det anpassade kommandot till Python-kontextmenyn. Kommandot har menyetiketten Kör startfil.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Tips/Råd

Om du vill att det anpassade kommandot ska visas på snabbmenyn innan standardkommandona som definierats i $(PythonCommands) token placerar du syntaxen <Target> för kommandot före den token.
Spara ändringarna i projektfilen och växla tillbaka till Visual Studio. När du får en uppmaning, ladda om ditt projekt.
Högerklicka på Python-projektet i Solution Explorer, välj Python och kontrollera kommandona på snabbmenyn igen.

Nu finns det anpassade kommandot Kör startfil på menyn. Om du inte ser det anpassade kommandot bekräftar du att du har lagt till Name attributvärdet för elementet <Target> i elementet enligt beskrivningen <PythonCommands> i steg 9. Granska även de överväganden som anges i avsnittet Felsökning senare i den här artikeln.
Välj kommandot Kör startfil . Ett konsolfönster öppnas och texten Hello custom commands (Hello custom commands ) visas följt av Tryck på valfri tangent för att fortsätta. Bekräfta utdata och stäng konsolfönstret.

Anmärkning

Det anpassade kommandoskriptet körs i den aktiverade miljön för Python-projektet.
Växla till redigeraren med projektfilen. I elementdefinitionen <Target> (som lades till i steg 8) ändrar du värdet för attributet ExecuteIn till output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Spara ändringarna, växla tillbaka till Visual Studio och läs in projektet igen.
Välj kommandot Kör den anpassade startfilen igen från Snabbmenyn i Python . Nu visas programutdata i fönstret Visual Studio-utdata i stället för ett konsolfönster:
Följ samma process om du vill lägga till fler anpassade kommandon:
1. Definiera ett lämpligt <Target> element för det anpassade kommandot i projektfilen.
2. Name Lägg till attributvärdet för elementet <Target> i <PythonCommands> egenskapsgruppen.
3. Spara ändringarna i projektfilen.
4. Ladda om projektet i Visual Studio.

Använda projektegenskaper

Om du vill referera till projektegenskaper eller miljövariabler i <Target> elementattributvärden använder du egenskapsnamnet i en $() token, till exempel $(StartupFile) och $(MSBuildProjectDirectory). Mer information finns i MSBuild-egenskaper.

Om du anropar ett kommando som ($StartupFile) det använder projektegenskaper som egenskapen StartupFile , och kommandot misslyckas eftersom token är odefinierad, inaktiverar Visual Studio kommandot tills du läser in projektet igen. Om du gör ändringar i projektet som ändrar egenskapsdefinitionen uppdateras inte tillståndet för det relaterade kommandot. I det här fallet måste du fortfarande läsa in projektet igen.

Förstå <målelementstrukturen>

Du definierar informationen för ett anpassat kommando med hjälp av -elementet <Target> . Elementets <Target> allmänna form visas i följande pseudokod:

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

Målattribut

I följande tabell visas elementattributen <Target> .

Attribute	Krävs	Description
`Name`	Yes	Identifieraren för kommandot i Visual Studio-projektet. Det här namnet måste läggas till i `<PythonCommands>` egenskapsgruppen för att kommandot ska visas på Python-snabbmenyn .
`Label`	Yes	Visningsnamnet för användargränssnittet som visas i Python-snabbmenyn .
`Returns`	Yes	Informationen som returneras, som måste innehålla `@(Commands)` token, som identifierar målet som ett kommando.

CreatePythonCommandItem-attribut

Elementet <Target> innehåller <CreatePythonCommandItem> och <Output> element som definierar det detaljerade beteendet för det anpassade kommandot. I följande tabell visas de tillgängliga <CreatePythonCommandItem> elementattributen. Alla attributvärden är skiftlägesokänsliga.

`Attribute`	Krävs	Description
`TargetType`	Yes	Anger vad `Target` attributet innehåller och hur värdet används tillsammans med attributet `Arguments` : - `executable`: Kör den körbara filen med namnet i `Target` attributet och lägg till värdet i `Arguments` attributet, som om det angavs direkt på kommandoraden. Värdet får bara innehålla ett programnamn utan argument. - `script`: Kör `python.exe` kommandot med filnamnet i `Target` attributet följt av värdet i `Arguments` attributet. - `module`: Kör `python -m` kommandot följt av modulnamnet i `Target` attributet följt av värdet i `Arguments` attributet. - `code`: Kör den infogade koden som finns i attributet `Target` . `Arguments` Ignorera attributvärdet. - `pip`: Kör pip med kommandot i `Target` attributet följt av värdet i attributet `Arguments` . `ExecuteIn` Om attributet är inställt på `output`förutsätter pip att begäran är att köra `install` kommandot och använder `Target` attributet som paketnamn.
`Target`	Yes	Anger det filnamn, modulnamn, kod eller pip-kommando som ska användas, beroende på värdet för attributet `TargetType` .
`Arguments`	Valfritt	Innehåller en sträng med argument (om några) som ska användas med attributet `Target` . – När `TargetType`-attributvärdet är `script`, anges `Arguments`-värdet till Python-programmet i stället för `python.exe`-kommandot. – När `TargetType` attributvärdet är `codeArguments` ignoreras värdet.
`ExecuteIn`	Yes	Anger i vilken miljö kommandot ska köras: - `console`: (Standard) Kör `Target` attributet med `Arguments` värdet som om de anges direkt på kommandoraden. `Target` När attributet körs visas ett kommandofönster och stängs automatiskt. - `consolepause`: Samma beteende som `console`, men väntar på en tangenttryckning innan fönstret stängs. - `output`: Kör `Target` attributet och visar resultatet i Visual Studio Output fönstret. Om `TargetType` attributet är `pip`, använder Visual Studio attributet `Target` som paketnamn och lägger till `Arguments` attributvärdet. - `repl`: Kör attributet `Target` i det interaktiva Python-fönstret. Det valfria visningsnamnet används för fönstrets rubrik. - `none`: Samma beteende som `console`.
`WorkingDirectory`	Valfritt	Identifierar mappen där kommandot ska köras.
`ErrorRegex` `WarningRegEx`	Valfritt	Används endast när `ExecuteIn` attributet är inställt på `output`. Båda attributvärdena anger ett reguljärt uttryck som Visual Studio använder för att parsa kommandoutdata och visa fel och varningar i fönstret Fellista . Om dessa attribut inte anges påverkar kommandot inte fönstret Fellista . Mer information om vad Visual Studio förväntar sig finns i Namngivna avbildningsgrupper.
`RequiredPackages`	Valfritt	Innehåller en lista över paketkrav för kommandot med samma format som requirements.txt -filen (pip.readthedocs.io). Kommandot Kör PyLint anger till exempel formatet `pylint>=1.0.0`. Innan du kör kommandot bekräftar Visual Studio att alla paket i listan är installerade. Visual Studio använder pip för att installera eventuella paket som saknas.
`Environment`	Valfritt	Identifierar en sträng med miljövariabler som ska definieras innan kommandot körs. Varje variabel använder formuläret `\<NAME>=\<VALUE>` med flera variabler avgränsade med semikolon. En variabel med flera värden måste finnas i enkla eller dubbla citattecken, som i `'NAME=VALUE1;VALUE2'`.

Namngivna insamlingsgrupper för reguljära uttryck

När Visual Studio parsar fel och varningar från anpassade kommandoutdata förväntar den sig att reguljära uttryck i ErrorRegex attributvärdena och WarningRegex använder följande namngivna grupper:

(?<message>...): Text för felmeddelandet.
(?<code>...): Felkodsvärde.
(?<filename>...): Namnet på filen som felet rapporteras för.
(?<line>...): Radnummer för platsen i filen som felet rapporteras för.
(?<column>...): Kolumnnummer för platsen i filen som felet rapporteras för.

PyLint skapar till exempel varningar i följande formulär:

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

Om du vill tillåta att Visual Studio extraherar rätt information från dessa varningar och visar dem i fönstret Fellista är WarningRegex attributvärdet för kommandot Kör Pylint följande:

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

Anmärkning

Syntaxen msg_idWarningRegex i attributvärdet ska faktiskt vara code, enligt beskrivningen i Ärende 3680.

Importera anpassade kommandon med målfil

Om du definierar anpassade kommandon i en Python-projektfil är kommandona endast tillgängliga för det specifika projektet. När du vill skapa anpassade kommandon och använda dem i flera projekt kan du definiera <PythonCommands> egenskapsgruppen med alla element <Target> i en målfil (.targets) och sedan importera filen till dina Python-projekt.

Målfilen använder samma format och syntax för att definiera anpassade kommandon enligt beskrivningen för Python-projektfilen (.pyproj). De vanliga elementen som ska konfigureras är <PythonCommands>, <Target>, <CreatePythonCommandItem>och <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>

Om du vill importera en målfil till projektet lägger du till ett <Import Project="(path)"> element var som helst i elementet <Project> i projektfilen.

Om du till exempel har en projektfil med namnet CustomCommands.targets i en målmapp i Python-projektet lägger du till följande kod i projektfilen:
```
<Import Project="targets/CustomCommands.targets"/>
```
Om projektfilen importerar en målfil och du gör ändringar i målfilen medan projektet är öppet i Visual Studio, måste du återskapa Visual Studio-lösningen som innehåller projektet och inte bara projektet.

Exempelkommandon

Följande avsnitt innehåller exempelkod som du kan använda för att definiera anpassade kommandon för dina Python-projekt.

Kör PyLint (modultarget)

Följande kod visas i filen 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>

Kör pip-installation med ett specifikt paket (pip-mål)

Följande kommando kör kommandot pip install my-package i Visual Studios utdata-fönster. Du kan använda ett kommando som det här när du utvecklar ett paket och testar installationen. Elementet <Target> innehåller paketnamnet i stället install för kommandot, vilket förutsätts när du använder attributdefinitionen 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>

Visa inaktuella pip-paket (pip-mål)

Följande kommando kör pip med list funktionen för att identifiera inaktuella pip-paket:

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

Kör körbar fil med consolepause

Följande kommando kör where funktionen för att visa platsen för Python-filer från projektmappen:

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

Köra server- och felsökningsserverkommandon

Om du vill utforska hur kommandona Start server och Start debug server för webbprojekt definieras, går du till lagringsplatsen Microsoft.PythonTools.Web.targets på GitHub.

Installationspaket för utveckling

Följande kod kör pip för att installera paket:

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

Från fxthomas/Example.pyproj.xml (GitHub), som används med behörighet.

Generera Windows-installationsprogram

Följande skript genererar ett Windows-installationsprogram:

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

Från fxthomas/Example.pyproj.xml (GitHub), som används med behörighet.

Generera Python-hjulpaket

Följande skript genererar ett Python-hjulpaket :

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

Från fxthomas/Example.pyproj.xml (GitHub), som används med behörighet.

Felsöka anpassade kommandon

Granska följande avsnitt för eventuella problem relaterade till arbete med anpassade kommandon.

Projektfilen har inte lästs in

Det här felmeddelandet anger att du har syntaxfel i projektfilen. Meddelandet innehåller det specifika felet med ett radnummer och teckenposition.

Konsolfönstret stängs efter att kommandot har körts

Om konsolfönstret stängs omedelbart efter att kommandot har körts använder du attributdefinitionen ExecuteIn="consolepause" i stället för ExecuteIn="console".

Om du inte ser det anpassade kommandot på Python-snabbmenyn kontrollerar du följande:

Bekräfta att kommandot ingår i <PythonCommands> egenskapsgruppen.
Kontrollera att kommandonamnet som definierats i kommandolistan matchar det namn som anges i elementet <Target> .

Här följer ett exempel. I följande XML-kodfragment matchar inte namnet i Example-egenskapsgruppen <PythonCommands> namnet i ExampleCommand-elementdefinitionen <Target>. Visual Studio hittar inget kommando med namnet Example, så inget kommando visas. Antingen använd ExampleCommand i kommandolistan eller ändra namnet på målet till bara Example.

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

Fel vid körning av kommandot, det gick inte att hämta kommandomålet

Det här felmeddelandet anger att innehållet i elementen <Target> eller <CreatePythonCommandItem> är felaktigt.

Här är några möjliga orsaker till det här felet:

Elementattributet som krävs <Target> är tomt.
Det obligatoriska TargetType attributet är tomt eller innehåller ett okänt värde.
Det obligatoriska ExecuteIn attributet är tomt eller innehåller ett okänt värde.
Attributet ErrorRegex eller WarningRegex anges utan att attributdefinitionen ExecuteIn="output" anges.
Okända attribut finns i elementet. Attributreferensen kan till exempel vara felstavad som Argumnets istället för Arguments.

Attributvärden kan vara tomma om du refererar till en egenskap som är odefinierad. Om du använder token $(StartupFile) men ingen startfil har definierats i projektet matchas token till en tom sträng. I sådana fall kanske du vill definiera ett standardvärde. Till exempel använder kommandona Kör server och Kör felsökningsserver som definierats i projektmallarna Bottle, Flask och Django den manage.py filen som standard (om en serverstartfil inte anges i projektegenskaperna).

Visual Studio slutar svara, kraschar

Om Visual Studio slutar svara och kraschar när du kör det anpassade kommandot försöker du förmodligen köra ett konsolkommando med attributdefinitionen ExecuteIn="output" . I sådana fall kan Visual Studio krascha när det försöker parsa utdata. Undvik det här villkoret genom att använda attributdefinitionen ExecuteIn="console" i stället. Mer information finns i Problem 3681.

Kommandot känns inte igen som ett fungerande program eller en batchfil

När du anger attributdefinitionen TargetType="executable"Target får värdet i attributet bara vara programnamnet utan argument, till exempel python eller python.exe endast. I det här fallet flyttar du alla argument till attributet Arguments .

Feedback

Var den här sidan till hjälp?

Last updated on 2025-12-12

Definiera anpassade kommandon för Python-projekt i Visual Studio

Förutsättningar

Utforska anpassade kommandon

Läs in projektet igen för att få åtkomst till anpassade kommandon

Lägga till anpassade kommandon med projektfilen

Använda projektegenskaper

Förstå <målelementstrukturen>

Målattribut

CreatePythonCommandItem-attribut

Namngivna insamlingsgrupper för reguljära uttryck

Importera anpassade kommandon med målfil

Exempelkommandon

Kör PyLint (modultarget)

Kör pip-installation med ett specifikt paket (pip-mål)

Visa inaktuella pip-paket (pip-mål)

Kör körbar fil med consolepause

Köra server- och felsökningsserverkommandon

Installationspaket för utveckling

Generera Windows-installationsprogram

Generera Python-hjulpaket

Felsöka anpassade kommandon

Projektfilen har inte lästs in

Konsolfönstret stängs efter att kommandot har körts

Kommandot saknas på menyn

Fel vid körning av kommandot, det gick inte att hämta kommandomålet

Visual Studio slutar svara, kraschar

Kommandot känns inte igen som ett fungerande program eller en batchfil

Feedback

Ytterligare resurser