Programar com o Q# Jupyter NotebookDevelop with Q# Jupyter Notebooks

Instale o QDK para desenvolver operações Q# no Q# Jupyter Notebook.Install the QDK for developing Q# operations on Q# Jupyter Notebooks.

O Jupyter Notebook permitem executar código no local juntamente com instruções, notas e outros conteúdos.Jupyter Notebooks allow running code in-place alongside instructions, notes, and other content. Este ambiente é ideal para escrever código Q# com explicações incorporadas ou tutoriais interativos de computação quântica.This environment is ideal for writing Q# code with embedded explanations or quantum computing interactive tutorials. Eis o que tem de fazer para começar a criar os seus próprios blocos de notas em Q#.Here's what you need to do to start creating your own Q# notebooks.

Instale o kernel do IQ# JupyterInstall the IQ# Jupyter kernel

IQ# (pronunciado i-q-sharp) é uma extensão principalmente utilizada pelo Jupyter e Python para o SDK de .NET Core que fornece a funcionalidade principal que permite compilar e simular operações Q#.IQ# (pronounced i-q-sharp) is an extension primarily used by Jupyter and Python to the .NET Core SDK that provides the core functionality for compiling and simulating Q# operations.

  1. Instale o Miniconda ou o Anaconda.Install Miniconda or Anaconda. Nota: Instalação de 64 bits obrigatória.Note: 64-bit installation required.

  2. Abra um Pedido do Anaconda.Open an Anaconda Prompt.

    • Em alternativa, se preferir utilizar o PowerShell ou o pwsh:, abra uma shell, execute conda init powershell, feche e reabra a shell.Or, if you prefer to use PowerShell or pwsh: open a shell, run conda init powershell, then close and re-open the shell.
  3. Crie e ative um novo ambiente conda com o nome qsharp-env com os pacotes necessários (incluindo Jupyter Notebook e IQ#) ao executar os seguintes comandos:Create and activate a new conda environment named qsharp-env with the required packages (including Jupyter Notebook and IQ#) by running the following commands:

    conda create -n qsharp-env -c quantum-engineering qsharp notebook
    
    conda activate qsharp-env
    
  4. Execute python -c "import qsharp" a partir do mesmo terminal para verificar a instalação e povoar a cache de pacotes local com todos os componentes QDK necessários.Run python -c "import qsharp" from the same terminal to verify your installation and populate your local package cache with all required QDK components.

Já está!That's it! Tem agora o kernel do IQ# para Jupyter, que fornece a principal funcionalidade para compilar e executar operações Q# a partir do Q# Jupyter Notebook.You now have the IQ# kernel for Jupyter, which provides the core functionality for compiling and running Q# operations from Q# Jupyter Notebooks.

Crie o seu primeiro bloco de notas Q#Create your first Q# notebook

Agora, está preparado para verificar a instalação do Q# Jupyter Notebook ao escrever e executar uma operação Q# simples.Now you are ready to verify your Q# Jupyter Notebook installation by writing and running a simple Q# operation.

  1. A partir do ambiente que criou durante a instalação (ou seja, o ambiente conda que criou ou o ambiente Python onde instalou o Jupyter), execute o seguinte comando para iniciar o servidor do Jupyter Notebook:From the environment you created during installation (i.e., either the conda environment you created, or the Python environment where you installed Jupyter), run the following command to start the Jupyter Notebook server:

    jupyter notebook
    
    • Se o Jupyter Notebook não abrir automaticamente no browser, copie e cole o URL fornecido pela linha de comandos no browser.If the Jupyter Notebook doesn't open automatically in your browser, copy and paste the URL provided by the command line into your browser.
  2. Escolha Novo → Q# para criar um Jupyter Notebook com um kernel do Q# e adicione o seguinte código à primeira célula do bloco de notas:Choose New → Q# to create a Jupyter Notebook with a Q# kernel, and add the following code to the first notebook cell:

    operation SampleQuantumRandomNumberGenerator() : Result {
        using (q = Qubit())  { // Allocate a qubit.
            H(q);             // Put the qubit to superposition. It now has a 50% chance of being 0 or 1.
            let r = M(q);     // Measure the qubit value.
            Reset(q);
            return r;
        }
    }
    
  3. Execute esta célula do bloco de notas:Run this cell of the notebook:

    Célula do Jupyter Notebook com código Q#

    Deverá ver SampleQuantumRandomNumberGenerator na saída da célula.You should see SampleQuantumRandomNumberGenerator in the output of the cell. Ao executar no Jupyter Notebook, o código Q# é compilado e a célula produz o nome das operações que encontra.When running in Jupyter Notebook, the Q# code is compiled, and the cell outputs the name of any operations that it finds.

  4. Numa célula nova, execute a operação que acabou de criar (num simulador) com o comando %simulate:In a new cell, run the operation you just created (in a simulator) by using the %simulate command:

    Célula do bloco de notas do Jupyter Notebook com o magic %simulate

    Deverá ver o resultado da operação que invocou.You should see the result of the operation you invoked. Neste caso, como a operação gera um resultado aleatório, verá Zero ou One impressos no ecrã.In this case, because your operation generates a random result, you will see either Zero or One printed on the screen. Se executar a célula repetidamente, deverá ver cada resultado aproximadamente metade do tempo.If you run the cell repeatedly, you should see each result approximately half the time.

Passos seguintesNext steps

Agora que instalou o QDK para o Q# Jupyter Notebook, pode escrever e executar o seu primeiro programa quântico ao escrever código Q# diretamente no ambiente do Jupyter Notebook.Now that you have installed the QDK for Q# Jupyter Notebooks, you can write and run your first quantum program by writing Q# code directly within the Jupyter Notebook environment.

Para obter mais exemplos do que pode fazer com o Q# Jupyter Notebook, veja:For more examples of what you can do with Q# Jupyter Notebooks, please take a look at:

  • Introdução ao Q# e ao Jupyter Notebook.Intro to Q# and Jupyter Notebook. Aqui, encontrará um Q# Jupyter Notebook que mostra mais detalhes sobre como utilizar o Q# no ambiente do Jupyter.There you will find a Q# Jupyter Notebook that provides more details on how to use Q# in the Jupyter environment.
  • Quantum Katas, uma coleção open-source de tutoriais ao seu ritmo e de conjuntos de exercícios de programação na forma de blocos de notas do Q# Jupyter Notebook.Quantum Katas, an open-source collection of self-paced tutorials and sets of programming exercises in the form of Q# Jupyter Notebooks. Os blocos de notas de tutoriais do Quantum Katas são um bom ponto de partida.The Quantum Katas tutorial notebooks are a good starting point. Os Quantum Katas têm como objetivo ensinar-lhe elementos de computação quântica e programação em Q# ao mesmo tempo.The Quantum Katas are aimed at teaching you elements of quantum computing and Q# programming at the same time. São um excelente exemplo dos tipos de conteúdos que pode criar com o Q# Jupyter Notebook.They're an excellent example of what kind of content you can create with Q# Jupyter Notebooks.