Freigeben über

Arbeiten mit Q# Projekten

  • Artikel

Mit der Veröffentlichung von Azure Quantum Development Kitkönnen Sie Projekte definierenQ#, bei denen es sich um Ordnerstrukturen mit mehreren Q# Dateien handelt, die auf die Ressourcen der anderen zugreifen können. Projekte sind hilfreich für die Erstellung wiederverwendbarer Bibliotheken und das logische Organisieren des Quellcodes.

Ein Q# Projekt enthält eine Q# Manifestdatei mit dem Namen qsharp.json und eine oder mehrere *.qs-Dateien in einer angegebenen Ordnerstruktur. Wenn ein Benutzer eine *.qs-Datei in VS Code öffnet oder die project_root Datei in einer Jupyter-Notizbuch- oder Python-Datei festlegt, durchsucht der Compiler die umgebende Ordnerhierarchie nach der Manifestdatei und bestimmt den Bereich des Projekts. Wenn keine Manifestdatei gefunden wird, wird der Compiler in einem einzigen Dateimodus ausgeführt. Ein Q# Projekt kann manuell oder direkt in VS Code erstellt werden.

Voraussetzungen

Definieren eines Q# Projekts

Ein Q# Projekt wird durch das Vorhandensein einer qsharp.json Manifestdatei und eines src-Ordners (der die Q# Quelldateien enthält) definiert, die sich beide im Stammordner des Projekts befinden müssen. Bei Q# Programmen erkennt der Q# Compiler den Projektordner automatisch. Für Python-Programme und Jupyter-Notizbücher müssen Sie den Q# Projektordner mit einem qsharp.init Aufruf angeben. Die Ordnerstruktur für ein Q# Projekt bleibt jedoch für alle Arten von Programmen gleich.

Abbildung der Ordnerhierarchie für ein Q# Projekt.

Definieren des Projektordners (Q# Programme)

Wenn eine *.qs-Datei in VS Code geöffnet wird, sucht der Q# Compiler in der Ordnerstruktur nach oben nach einer qsharp.json Manifestdatei. Wenn eine Manifestdatei gefunden wird, durchsucht der Compiler nach unten alle Unterordner des src-Verzeichnisses nach *.qs-Dateien und speichert alle Vorgänge oder Funktionen zwischen und stellt diese Vorgänge und Funktionen für alle *.qs-Dateien gemäß den Ausschlussregeln der Manifestdatei zur Verfügung.

Beispiel:

  • Teleportation_project
    • qsharp.json
    • src
      • RunTeleport.qs
      • TeleportOperations
        • Teleport.qs
        • PrepareState
          • PrepareState.qs

wenn Sie die Datei "/src/TeleportOperation/PrepareState/PrepareState.qs" öffnen, wird der Q# Compiler:

  1. Überprüft /src/TeleportOperation/PrepareState/ auf eine qsharp.json Datei.
  2. Überprüft /src/TeleportOperation auf qsharp.json.
  3. Überprüft /src auf qsharp.json.
  4. Sucht / nach qsharp.json.
  5. Richtet / als Stammverzeichnis des Projekts ein und enthält alle *.qs-Dateien unter dem Stamm im Projekt gemäß den Einstellungen der Manifestdatei.

So erstellen Sie eine Manifestdatei

Eine Manifestdatei ist eine einfache .json Datei mit dem Namen qsharp.json, die optional Autoren-, Lizenz- und INTS-Felder enthalten kann. Die mindestfähige Manifestdatei ist die Zeichenfolge {}. Wenn Sie ein Q# Projekt in VS Code erstellen, wird eine minimale Manifestdatei für Sie erstellt.

{}

Manifestdateibeispiele

Im Folgenden finden Sie einige Beispiele dafür, wie Manifestdateien den Umfang Ihres Q# Projekts definieren können.

In diesem Beispiel ist Author das einzige angegebene Feld, und daher werden alle *.qs-Dateien in diesem Verzeichnis und alle unterverzeichnisse im Q# Projekt enthalten.

{
    "author":"Microsoft"
}

{
    "author":"Microsoft",
    "license":"MIT"
}

In einem Q# Projekt können Sie auch die Manifestdatei verwenden, um die VS Code Q# Linter-Einstellungen zu optimieren. Standardmäßig sind die drei Linter-Regeln:

  • needlessParens: default = allow
  • divisionByZero: default = warn
  • redundantSemicolons: default = warn

Mit der Manifestdatei können Sie jede Regel entweder allowauf , , warnoder error, z. B.

{
    "author":"Microsoft",
    "lints": [
        {
          "lint": "needlessParens",
          "level": "allow"
        },
        {
          "lint": "redundantSemicolons",
          "level": "warn"
        },
        {
          "lint": "divisionByZero",
          "level": "error"
        }
      ]
}

Q# Projektanforderungen und Eigenschaften

Die folgenden Anforderungen und Konfigurationen gelten für alle Q# Projekte.

  • Alle *.qs-Dateien, die Sie in das Projekt einbeziehen möchten, müssen sich unter einem Ordner mit dem Namen "src" befinden, der sich unter dem Q# Projektstammordner befinden muss. Wenn Sie ein Q# Projekt in VS Code erstellen, wird der /src Ordner automatisch erstellt.
  • Die qsharp.json Manifestdatei sollte auf derselben Ebene wie der src-Ordner sein. Wenn Sie ein Q# Projekt in VS Code erstellen, wird die qsharp.json Datei automatisch erstellt.
  • Auf Vorgänge und Funktionen in verfügbaren Quelldateien kann mithilfe von open Anweisungen zugegriffen werden:
open MyMathLib;
...
    Multiply(x,y);

oder verweisen Sie mit dem Namespace auf sie:

MyMathLib.Multiply(x,y);

Nur für Q# Programme

  • Es kann nur eine *.qs-Datei in einem Q# Projekt definiert sein @EntryPoint() .
  • Die Datei "*.qs" mit der @EntryPoint() Definition kann sich auf einer beliebigen Ebene unterhalb der Manifestdatei befinden.
  • Alle Vorgänge oder Funktionen, die von einer *.qs-Datei an einer beliebigen Stelle im Q# Projekt zwischengespeichert werden, werden im Vorhersagetext in VS Code angezeigt.
  • Wenn der Namespace für einen ausgewählten Vorgang oder eine ausgewählte Funktion noch nicht hinzugefügt wurde, fügt VS Code automatisch die erforderliche open Anweisung hinzu.

Schritte zum Erstellen eines Q# Projekts

  1. Klicken Sie im VS Code-Datei-Explorer mit der rechten Maustaste auf den Ordner, den Sie für den Q# Projektstammordner verwenden möchten, und wählen Sie "Projekt erstellenQ#" aus, oder öffnen Sie den Ordner, und wählen Sie "Befehlspalette >Q#anzeigen>" aus: Projekt erstellenQ#....

  2. VS Code erstellt eine minimale qsharp.json Manifestdatei im Ordner und fügt einen /src Ordner mit einer Main.qs Vorlagendatei hinzu.

  3. Bearbeiten Sie die Manifestdatei nach Bedarf. Siehe Manifestdateibeispiele.

  4. Fügen Sie Ihre Q# Quelldateien unter dem Ordner hinzu und organisieren Sie sie /src .

  5. Wenn Sie über ein Python-Programm oder Jupyter-Notizbuch auf das Q# Projekt zugreifen, legen Sie den Pfad des Stammordners mithilfe von qsharp.init. In diesem Beispiel wird davon ausgegangen, dass sich Ihr Programm im selben Ordner wie der Stammordner des Q# Projekts befindet:

    qsharp.init(project_root = './Teleportation_project')

  6. Wenn Sie nur Q# Dateien in VS Code verwenden, sucht der Compiler beim Öffnen einer Q# Datei nach der qsharp.json Manifestdatei, bestimmt den Projektstammordner und durchsucht dann den Unterordner nach *.qs-Dateien.

Hinweis

Sie können die Manifestdatei und den /src Ordner auch manuell in Schritt 2 erstellen.

Beispielprojekt

Dieses Quantenteleportationsprogramm ist ein Beispiel für ein Q# Projekt, das auf der zuvor gezeigten Ordnerstruktur basiert und auf dem lokalen Simulator in VS Code ausgeführt wird. Informationen zum Ausführen des Programms auf Azure Quantum-Hardware oder Simulatoren von Drittanbietern finden Sie unter "Erste Schritte mit Q# Programmen und VSCode ", um Ihr Programm zu kompilieren und eine Verbindung mit Ihrem Azure-Arbeitsbereich herzustellen.

Im Beispiel wird diese Verzeichnisstruktur verwendet:

  • Teleportation_project
    • qsharp.json
    • src
      • RunTeleport.qs
      • TeleportOperations
        • Teleport.qs
        • PrepareState
          • PrepareState.qs

Die qsharp.json Manifestdatei enthält die Autoren - und Lizenzfelder :

{
    "author":"Microsoft",
    "license":"MIT"
}

Q# Quelldateien

Mit einem kleinen Unterschied - der Anweisung - sind die @EntryPoint() Quelldateien für ein Programm, ein Q# Python-Programm oder ein Jupyter-Notizbuch identisch.

Die Hauptdatei RunTeleport.qs enthält den Einstiegspunkt und verweist auf den TeleportLib Namespace in Teleport.qs.

namespace RunTeleport {

    open TeleportLib;   // references the TeleportLib namespace in Teleport.qs

    @EntryPoint()       // @EntryPoint() not necessary for Python or Jupyter Notebook programs
    operation RunTeleportationExample() : Unit {
        use msg = Qubit();
        use target = Qubit();

        H(msg);
        Teleport(msg, target);    // calls the Teleport() operation from Teleport.qs
        H(target);

        if M(target) == Zero {
            Message("Teleported successfully!");
        
        Reset(msg);
        Reset(target);
        }
    }
}

Teleport.qs definiert den Teleport() Vorgang und ruft den PrepareBellPair() Vorgang von PrepareState.qs auf.

namespace TeleportLib {

    open PrepareBell;     // references the PrepareBell namespace in PrepareState.qs
 
    operation Teleport(msg : Qubit, target : Qubit) : Unit {
        use here = Qubit();

        PrepareBellPair(here, target);      // calls the PrepareBellPair() operation from PrepareState.qs
        Adjoint PrepareBellPair(msg, here);

        if M(msg) == One { Z(target); }
        if M(here) == One { X(target); }

        Reset(here);
    }
}

Die Datei PrepareState.qs enthält einen standardmäßigen wiederverwendbaren Vorgang zum Erstellen eines Bell-Paares .

namespace PrepareBell {    
    
    operation PrepareBellPair(left : Qubit, right : Qubit) : Unit is Adj + Ctl {
        H(left);
        CNOT(left, right);
    }
}

Ausführen der Programme

Wählen Sie die Registerkarte für die Umgebung aus, in der Sie Ihr Programm ausführen.

Öffnen Sie zum Ausführen dieses Programms die Datei RunTeleport.qs in VS Code, und wählen Sie "Ausführen" aus.