Definování vlastních příkazů pro projekty Pythonu v sadě Visual Studio

2025-06-12

Při vývoji projektů Pythonu můžete přejít do příkazového okna, kde můžete spouštět konkrétní skripty nebo moduly, spouštět příkazy pip nebo používat jiné nástroje s vaším kódem. Pokud chcete pracovní postup vylepšit, můžete do nabídky projektu Pythonu v sadě Visual Studio přidat vlastní příkazy. Vlastní příkazy Pythonu lze spouštět v okně konzole nebo ve výstupním okně Visual Studio . Pomocí regulárních výrazů také můžete sadě Visual Studio dát pokyn, jak analyzovat chyby a upozornění z výstupu příkazu.

Požadavky

Visual Studio ve Windows nainstalované s podporou úloh Pythonu Další informace najdete v tématu Instalace podpory Pythonu v sadě Visual Studio.

Visual Studio pro Mac se nepodporuje. Další informace najdete v tématu Co se děje se sadou Visual Studio pro Mac? Visual Studio Code ve Windows, Mac a Linuxu dobře funguje s Pythonem prostřednictvím dostupných rozšíření.

Prozkoumání vlastních příkazů

Ve výchozím nastavení obsahuje nabídka projektu Python dva příkazy, Spustit PyLint a SpustitMypy:

Všechny vlastní příkazy Pythonu, které definujete, se zobrazí ve stejné nabídce. Vlastní příkaz může odkazovat na soubor Pythonu, modul Pythonu, vložený kód Pythonu, libovolný spustitelný soubor nebo příkaz pip. Můžete také určit, jak a kde se příkaz spouští.

Vlastní příkazy můžete přidat několika způsoby:

Definujte vlastní příkazy v souboru projektu Pythonu (.pyproj) přímo. Tyto příkazy platí pro tento konkrétní projekt.
Definování vlastních příkazů v souboru cílů (.targets). Příkazy v tomto souboru můžete snadno importovat, abyste je mohli použít s více projekty.
Vytvořte projekt Pythonu ze šablony projektu v sadě Visual Studio, který definuje vlastní příkazy Pythonu.

Některé šablony projektů Pythonu v sadě Visual Studio přidávají vlastní příkazy pomocí souboru cílů. Šablony webového projektu Bottle a Flask přidávají dva příkazy: Spustit server a Spustit ladicí server. Šablona webového projektu Django přidá tyto příkazy a několik dalších:

Opětovné načtení projektu pro přístup k vlastním příkazům

Pokud je projekt otevřený v sadě Visual Studio a provedete změny v odpovídajícím souboru projektu v editoru, musíte projekt znovu načíst, aby se změny použily. Podobně je potřeba po definování vlastních příkazů Pythonu v souboru projektu Pythonu znovu načíst projekt Pythonu, aby se příkazy zobrazily v nabídce projektu Pythonu. Při úpravě vlastních příkazů definovaných v souboru cílů je nutné znovu sestavit úplné řešení sady Visual Studio pro všechny projekty, které importuje soubor cíle.

Běžným přístupem je provést změny souboru projektu Pythonu přímo v sadě Visual Studio:

Otevřete projekt Pythonu ve Visual Studio. (Když otevřete projekt v sadě Visual Studio, projekt se ve výchozím nastavení načte.)
V Průzkumníku řešeníklikněte pravým tlačítkem na Pythonový projekt a vyberte Uvolnit projekt.

Visual Studio rozbalí projekt a otevře odpovídající soubor projektu Pythonu (.pyproj) v editoru.

Pokud se soubor projektu neotevře, znovu klikněte pravým tlačítkem myši na projekt Pythonu a vyberte Upravit soubor projektu:
Proveďte změny v souboru projektu v editoru sady Visual Studio a uložte svoji práci.
V Průzkumníku řešeníklikněte pravým tlačítkem na uvolněný projekt a vyberte Znovu načíst projekt. Pokud se pokusíte projekt znovu načíst bez uložení změn v souboru projektu, Visual Studio vás vyzve k dokončení akce.

Proces vyložení, úpravy, uložení a znovunačtení se při vývoji vlastních příkazů může stát únavným. Efektivnější pracovní postup zahrnuje souběžné načítání projektu v sadě Visual Studio a otevření souboru projektu Pythonu v samostatném editoru. Můžete použít libovolný editor, například jinou instanci sady Visual Studio, Visual Studio Code, Poznámkový blok atd. Po uložení změn v editoru a přepnutí zpět do sady Visual Studio sada Visual Studio rozpozná změny souboru projektu pro otevřený projekt a vyzve vás k provedení akce:

Vyberte Znovu načíst nebo Znovu načíst všechny a Visual Studio okamžitě použije změny souboru projektu na otevřený projekt.

Přidání vlastních příkazů se souborem projektu

Následující postup ukazuje, jak vytvořit vlastní příkaz přidáním definice do souboru projektu Pythonu (.pyproj) a opětovným načtením projektu v sadě Visual Studio. Vlastní příkaz spustí spouštěcí soubor projektu přímo pomocí příkazu python.exe, což je v podstatě stejné jako použití možnosti „Ladění>Spustit bez ladění“ na hlavním panelu nástrojů sady Visual Studio.

V sadě Visual Studio vytvořte nový projekt Pythonu s názvem Python-CustomCommands pomocí šablony aplikace Pythonu. Pokyny najdete v tématu Rychlý start: Vytvoření projektu Pythonu ze šablony.

Visual Studio vytvoří projekt Pythonu a načte ho do vaší relace. Projekt můžete nakonfigurovat prostřednictvím souboru projektu (.pyproj). Tento soubor je viditelný pouze v sadě Visual Studio, když je projekt otevřený, ale nenahraný. Projekt má také soubor Pythonu (.py) pro kód aplikace.
Otevřete soubor Python_CustomCommands.py aplikace v editoru a přidejte následující kód:
```
print("Hello custom commands")
```
V Průzkumníku řešeníklikněte pravým tlačítkem na projekt Pythonu, vyberte Pythona všimněte si příkazů v místní nabídce. V současné době jsou jedinými příkazy v kontextové nabídce Spustit PyLint a SpustitMypy. Když definujete vlastní příkazy, zobrazí se také v této nabídce.
Spusťte samostatný editor mimo relaci sady Visual Studio a v editoru otevřete soubor projektu Pythonu (Python-CustomCommands.pyproj). (Nezapomeňte otevřít soubor projektu (.pyproj) a ne soubor aplikace Pythonu (.py).)
Ve souboru projektu vyhledejte na konci souboru element </Project> a bezprostředně před uzavírací prvek přidejte následující XML:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Uložte změny souboru projektu a přepněte zpět do sady Visual Studio. Visual Studio zjistí změny souboru projektu a vyzve vás k provedení akce. Na příkazovém řádku vyberte Znovu načíst a aktualizujte otevřený projekt změnami souboru projektu.
V Průzkumníku řešeníklikněte pravým tlačítkem na Pythonový projekt, vyberte Pythona zkontrolujte příkazy v kontextové nabídce.

V místní nabídce se stále zobrazují jenom příkazy Spustit PyLint a Spustit Mypy. Kód, který jste právě přidali do souboru projektu, jednoduše replikuje výchozí skupinu vlastností <PythonCommands>, která obsahuje příkaz PyLint. V dalším kroku přidáte další kód pro vlastní příkaz.
Přepněte do editoru, do kterého aktualizujete soubor projektu. Do elementu <Target> přidejte následující definici elementu <Project>. Definici <Target> můžete umístit před nebo za definici <PropertyGroup> popsanou výše.

Tento <Target> element definuje vlastní příkaz pro spuštění spouštěcího souboru projektu (identifikovaný vlastností StartupFile) pomocí příkazu python.exe v okně konzoly. Definice atributu ExecuteIn="consolepause" používá konzolu, která počká, až vyberete klíč pro zavření okna konzoly.
```
<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>
```
Nahraďte skupinu vlastností <PythonCommands> (přidanou v kroku 5) následujícím kódem XML. Tato syntaxe definuje atribut Name pro prvek <Target>, který přidá vlastní příkaz do místní nabídky Pythonu. Příkaz má popisek nabídky Spustit spouštěcí soubor.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Spropitné

Pokud chcete, aby se váš vlastní příkaz zobrazoval v místní nabídce před výchozími příkazy definovanými v tokenu $(PythonCommands), umístěte před tento token syntaxi <Target>.
Uložte změny souboru projektu a přepněte zpět do sady Visual Studio. Na příkazovém řádku znovu načtěte projekt.
V Průzkumníku řešeníklikněte pravým tlačítkem na Pythonový projekt, vyberte Pythona opakovaně zkontrolujte příkazy v místní nabídce.

Teď je v nabídce vlastní příkaz Spustit startovací soubor. Pokud vlastní příkaz nevidíte, potvrďte, že jste přidali hodnotu atributu Name pro element <Target> do elementu <PythonCommands>, jak je popsáno v kroku 9 . Projděte si také aspekty uvedené v části Řešení potíží dále v tomto článku.
Vyberte příkaz Spustit spouštěcí soubor. Otevře se okno konzoly a zobrazí text Hello vlastní příkazy následovaný Stiskněte libovolnou klávesu pro pokračování. Potvrďte výstup a zavřete okno konzoly.

Poznámka

Vlastní příkazový skript se spustí v aktivovaném prostředí pro váš projekt Pythonu.
Přepněte do editoru se souborem projektu. V definici elementu <Target> (přidáno v kroku 8), změňte hodnotu atributu ExecuteIn na output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Uložte změny, přepněte zpět do sady Visual Studio a znovu načtěte projekt.
V místní nabídce Python vyberte spouštěcí soubor vlastní příkaz ještě jednou. Teď se výstup programu zobrazí v okně Visual Studio Output, nikoli v okně konzoly.
Pokud chcete přidat další vlastní příkazy, postupujte stejným způsobem:
1. Definujte vhodný prvek <Target> pro vlastní příkaz v souboru projektu.
2. Do skupiny vlastností Name přidejte hodnotu atributu <Target> prvku <PythonCommands>.
3. Uložte změny do souboru projektu.
4. Načtěte znovu projekt ve Visual Studiu.

Použití vlastností projektu

Chcete-li odkazovat na vlastnosti projektu nebo proměnné prostředí v hodnotách atributů elementu <Target>, použijte název vlastnosti v rámci $() tokenu, například $(StartupFile) a $(MSBuildProjectDirectory). Další informace naleznete v tématu vlastnosti nástroje MSBuild.

Pokud vyvoláte příkaz, jako je ($StartupFile), který používá vlastnosti projektu, jako je StartupFile vlastnost, a příkaz selže, protože token není definován, Visual Studio příkaz zakáže, dokud projekt znovu nenačtete. Pokud v projektu provedete změny, které upravují definici vlastnosti, změny neaktualizuje stav souvisejícího příkazu. V takovém případě stále potřebujete projekt znovu načíst.

Pochopit strukturu prvku <Target>

Pomocí elementu <Target> definujete podrobnosti vlastního příkazu. Obecná forma <Target> elementu je uvedena v následujícím pseudokódu:

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

Cílové atributy

Následující tabulka uvádí atributy elementu <Target>.

Atribut	Požadovaný	Popis
`Name`	Ano	Identifikátor příkazu v projektu sady Visual Studio. Tento název musí být přidán do skupiny vlastností `<PythonCommands>`, aby se příkaz zobrazil v místní nabídce Pythonu.
`Label`	Ano	Zobrazovaný název uživatelského rozhraní, který se zobrazí v místní nabídce Pythonu.
`Returns`	Ano	Informace, které jsou vráceny, musí obsahovat token `@(Commands)`, který cílový objekt identifikuje jako příkaz.

Atributy CreatePythonCommandItem

Element <Target> obsahuje prvky <CreatePythonCommandItem> a <Output>, které definují podrobné chování vlastního příkazu. Následující tabulka uvádí dostupné atributy elementu <CreatePythonCommandItem>. Všechny hodnoty atributů jsou nerozlišující mezi malými a velkými písmeny.

`Attribute`	Požadovaný	Popis
`TargetType`	Ano	Určuje, co atribut `Target` obsahuje a jak se hodnota používá spolu s atributem `Arguments`: - `executable`: Spusťte spustitelný soubor pojmenovaný v atributu `Target` a připojte hodnotu v atributu `Arguments`, jako by byl zadán přímo na příkazovém řádku. Hodnota musí obsahovat pouze název programu bez argumentů. - `script`: Spusťte příkaz `python.exe` s názvem souboru v atributu `Target` následovaný hodnotou v atributu `Arguments`. - `module`: Spusťte příkaz `python -m` následovaný názvem modulu v atributu `Target` následovaný hodnotou v atributu `Arguments`. - `code`: Spusťte vložený kód obsažený v atributu `Target`. Ignorujte hodnotu atributu `Arguments`. - `pip`: Spusťte pip s příkazem v atributu `Target` následovanou hodnotou v atributu `Arguments`. Pokud je atribut `ExecuteIn` nastaven na `output`, pip předpokládá, že požadavek je spustit příkaz `install` a jako název balíčku použije atribut `Target`.
`Target`	Ano	Určuje název souboru, název modulu, kód nebo příkaz pip, který se má použít, v závislosti na hodnotě atributu `TargetType`.
`Arguments`	Volitelný	Poskytuje řetězec argumentů (pokud existuje) pro použití s atributem `Target`. – Pokud je hodnota atributu `TargetTypescript`, `Arguments` hodnota se do programu Pythonu zadává místo příkazu `python.exe`. – Pokud je hodnota atributu `TargetTypecode`, `Arguments` hodnota bude ignorována.
`ExecuteIn`	Ano	Určuje prostředí, ve kterém se má příkaz spustit: - `console`: (Výchozí) Spustí atribut `Target` s hodnotou `Arguments`, jako by byly zadány přímo do příkazového řádku. Zatímco je atribut `Target` spuštěný, zobrazí se příkazové okno a automaticky se zavře. - `consolepause`: Stejné chování jako `console`, ale před zavřením okna počká na stisknutí klávesy. : Spustí atribut a zobrazí výsledky v okně výstupu sady Visual Studio . Pokud je atribut `TargetTypepip`, Visual Studio jako název balíčku použije atribut `Target` a připojí hodnotu atributu `Arguments`. - `repl`: Spustí atribut `Target` v interaktivním okně Pythonu . Volitelný zobrazovaný název se používá jako název okna. - `none`: Stejné chování jako `console`.
`WorkingDirectory`	Volitelný	Identifikuje složku, ve které se má příkaz spustit.
`ErrorRegex` `WarningRegEx`	Volitelný	Používá se pouze v případech, kdy je atribut `ExecuteIn` nastaven na `output`. Obě hodnoty atributů určují regulární výraz, který Visual Studio používá k analýze výstupu příkazu a zobrazení chyb a upozornění v okně Seznam chyb. Pokud tyto atributy nejsou zadané, příkaz nemá vliv na okno Seznam chyb. Další informace o tom, co sada Visual Studio očekává, najdete v tématu pojmenované skupiny zachycení.
`RequiredPackages`	Volitelný	Poskytuje seznam požadavků na balíček pro příkaz pomocí stejného formátu jako soubor requirements.txt (pip.readthedocs.io). Například příkaz Spustit PyLint určuje formát `pylint>=1.0.0`. Před spuštěním příkazu sada Visual Studio potvrdí, že jsou nainstalované všechny balíčky v seznamu. Visual Studio k instalaci chybějících balíčků používá pip.
`Environment`	Volitelný	Identifikuje řetězec proměnných prostředí, který se má definovat před spuštěním příkazu. Každá proměnná používá formát `\<NAME>=\<VALUE>` s více proměnnými, které jsou odděleny středníky. Proměnná s více hodnotami musí být obsažena v jednoduchých nebo dvojitých uvozovkách, stejně jako v `'NAME=VALUE1;VALUE2'`.

Pojmenované zachytávací skupiny regulárních výrazů

Když Visual Studio analyzuje chyby a upozornění z výstupu vlastního příkazu, očekává regulární výrazy v hodnotách atributů ErrorRegex a WarningRegex používat následující pojmenované skupiny:

(?<message>...): Text chyby.
(?<code>...): Hodnota kódu chyby
(?<filename>...): Název souboru, pro který je chyba hlášena.
(?<line>...): Číslo řádku v souboru, kde je hlášena chyba.
(?<column>...): Číslo sloupce umístění v souboru, pro který je chyba hlášena.

PyLint například generuje upozornění na následující formulář:

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

Pokud chcete sadě Visual Studio povolit extrakci správných informací z těchto upozornění a zobrazit je v okně seznamu chyb , hodnota atributu Spustit Pylint je následující:

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

Poznámka

Syntaxe msg_id v hodnotě atributu WarningRegex by měla být ve skutečnosti code, jak je popsáno v Issue 3680.

Import vlastních příkazů se souborem cílů

Pokud definujete vlastní příkazy v souboru projektu Pythonu, jsou příkazy k dispozici pouze pro tento konkrétní projekt. Pokud chcete vytvořit vlastní příkazy a použít je v několika projektech, můžete definovat skupinu vlastností <PythonCommands> se všemi vašimi <Target> prvky v souboru cíle (.targets) a pak tento soubor importovat do projektů Pythonu.

Soubor cílů používá stejný formát a syntaxi k definování vlastních příkazů, jak je popsáno pro soubor projektu Pythonu (.pyproj). Mezi běžné prvky konfigurace patří <PythonCommands>, <Target>, <CreatePythonCommandItem>a <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>

Pokud chcete do projektu importovat cílový soubor, přidejte do souboru projektu prvek <Import Project="(path)"> kdekoli v <Project> prvku.

Pokud máte například soubor projektu s názvem CustomCommands.targets ve složce cíle v projektu Pythonu, přidejte do souboru projektu následující kód:
```
<Import Project="targets/CustomCommands.targets"/>
```
Pokud soubor projektu naimportuje soubor cílů a v době, kdy je projekt otevřený v sadě Visual Studio, musíte znovu sestavit řešení sady Visual Studio, které obsahuje váš projekt, a ne pouze projekt.

Ukázkové příkazy

Následující části obsahují ukázkový kód, který můžete použít k definování vlastních příkazů pro projekty Pythonu.

Spuštění PyLintu (cíl modulu)

V souboru Microsoft.PythonTools.targets se zobrazí následující kód:

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

Spusťte pip install s konkrétním balíčkem (cílový balíček)

Následující příkaz spustí příkaz v okně výstupu sady Visual Studio . Tento příkaz můžete použít při vývoji balíčku a otestování jeho instalace. Prvek <Target> obsahuje název balíčku, nikoli install příkaz, který se předpokládá při použití definice atributu 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>

Zobrazení zastaralých balíčků pip (cíl pip)

Následující příkaz spustí pip s funkcí list k identifikaci zastaralých balíčků pip:

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

Spuštění spustitelného souboru s pauzou konzoly

Následující příkaz spustí funkci where, která zobrazí umístění souborů Pythonu počínaje složkou projektu:

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

Spuštění serveru a spuštění příkazů ladicího serveru

Pokud chcete zjistit, jak jsou definovány příkazy Start server a Start debug server pro webové projekty, prozkoumejte úložiště Microsoft.PythonTools.Web.targets na GitHubu.

Instalace balíčku pro vývoj

Následující kód spustí pip pro instalaci balíčků:

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

z fxthomas/Example.pyproj.xml (GitHub) použito s povolením.

Generování instalátoru Windows

Následující skript vygeneruje instalační službu systému 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>

z fxthomas/Example.pyproj.xml (GitHub) použito s povolením.

Vygenerování balíčku kolečka Pythonu

Následující skript vygeneruje balíček typu wheel pro 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>

z fxthomas/Example.pyproj.xml (GitHub) použito s povolením.

Řešení potíží s vlastními příkazy

V následujících částech najdete možné problémy související s prací s vlastními příkazy.

Soubor projektu nebyl načten.

Tato chybová zpráva značí, že v souboru projektu máte chyby syntaxe. Zpráva obsahuje konkrétní chybu s číslem řádku a umístěním znaku.

Okno konzoly se zavře po spuštění příkazu.

Pokud se okno konzoly hned po spuštění příkazu zavře, použijte místo ExecuteIn="consolepause"definici atributu ExecuteIn="console" .

Pokud se v místní nabídce Pythonu nezobrazuje vlastní příkaz, zkontrolujte následující položky:

Ověřte, že je příkaz zahrnutý ve skupině vlastností <PythonCommands>.
Ověřte, že název příkazu definovaný v seznamu příkazů odpovídá názvu zadanému v elementu <Target>.

Tady je příklad. V následujícím fragmentu kódu XML se název Example ve skupině vlastností <PythonCommands> neshoduje s názvem ExampleCommand v definici elementu <Target>. Visual Studio nenajde příkaz s názvem Example, takže se nezobrazí žádný příkaz. Buď použijte ExampleCommand v seznamu příkazů, nebo změňte název cíle tak, aby byl pouze Example.

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

Chyba při spuštění příkazu, nepodařilo se získat cíl příkazu

Tato chybová zpráva označuje, že obsah prvků <Target> nebo <CreatePythonCommandItem> jsou nesprávné.

Tady je několik možných důvodů této chyby:

Požadovaný atribut elementu <Target> je prázdný.
Požadovaný atribut TargetType je prázdný nebo obsahuje nerozpoznanou hodnotu.
Požadovaný atribut ExecuteIn je prázdný nebo obsahuje nerozpoznanou hodnotu.
Atribut ErrorRegex nebo WarningRegex je zadán bez nastavení definice atributu ExecuteIn="output".
Nerozpoznané atributy existují v elementu. Odkaz na atribut může být například nesprávně napsaný jako Argumnets místo Arguments.

Hodnoty atributů můžou být prázdné, pokud odkazujete na vlastnost, která není definována. Pokud použijete token $(StartupFile), ale není definován žádný spouštěcí soubor v projektu, token se automaticky přeloží na prázdný řetězec. V takových případech můžete chtít definovat výchozí hodnotu. Například příkazy Spustit server a Spustit ladicí server příkazy definované v šablonách projektů Bottle, Flask a Django ve výchozím nastavení používají soubor manage.py (pokud spouštěcí soubor serveru není zadaný ve vlastnostech projektu).

Visual Studio přestane reagovat, zhroutí se

Pokud Visual Studio přestane reagovat a při spuštění vlastního příkazu dojde k chybovému ukončení, pravděpodobně se pokoušíte spustit příkaz konzoly s definicí atributu ExecuteIn="output". V takových případech se může Visual Studio zhroutit, když se pokusí analyzovat výstup. Chcete-li se této podmínce vyhnout, použijte místo toho definici atributu ExecuteIn="console". Další informace najdete v tématu Problém 3681.

Příkaz není rozpoznán jako operovatelný program nebo dávkový soubor.

Při nastavení definice atributu TargetType="executable" musí být hodnota v atributu Targetpouze název programu bez argumentů, například python nebo pouze python.exe. V tomto případě přesuňte všechny argumenty do atributu Arguments.

Sdílet prostřednictvím

Definování vlastních příkazů pro projekty Pythonu v sadě Visual Studio

Požadavky

Prozkoumání vlastních příkazů

Opětovné načtení projektu pro přístup k vlastním příkazům

Přidání vlastních příkazů se souborem projektu

Použití vlastností projektu

Pochopit strukturu prvku <Target>

Cílové atributy

Atributy CreatePythonCommandItem

Pojmenované zachytávací skupiny regulárních výrazů

Import vlastních příkazů se souborem cílů

Ukázkové příkazy

Spuštění PyLintu (cíl modulu)

Spusťte pip install s konkrétním balíčkem (cílový balíček)

Zobrazení zastaralých balíčků pip (cíl pip)

Spuštění spustitelného souboru s pauzou konzoly

Spuštění serveru a spuštění příkazů ladicího serveru

Instalace balíčku pro vývoj

Generování instalátoru Windows

Vygenerování balíčku kolečka Pythonu

Řešení potíží s vlastními příkazy

Soubor projektu nebyl načten.

Okno konzoly se zavře po spuštění příkazu.

V nabídce chybí příkaz

Chyba při spuštění příkazu, nepodařilo se získat cíl příkazu

Visual Studio přestane reagovat, zhroutí se

Příkaz není rozpoznán jako operovatelný program nebo dávkový soubor.

Váš názor

Další materiály