Místní proměnnéLocal Variables

Hodnotu libovolného typu v Q # lze přiřadit proměnné pro opětovné použití v rámci operace nebo funkce pomocí klíčového slova let.A value of any type in Q# can be assigned to a variable for reuse within an operation or function by using the let keyword. Např.:For instance:

let measurementOperator = [PauliX, PauliZ, PauliZ, PauliX, PauliI];

To přiřadí konkrétní pole operátorů Pauli proměnné s názvem measurementOperator.This assigns a particular array of Pauli operators to a variable called measurementOperator.

Tip

Všimněte si, že nepotřebujeme explicitně zadat typ naší nové proměnné, protože výraz na pravé straně příkazu let je nejednoznačný a tento typ je odvozený kompilátorem.Note that we did not need to explicitly specify the type of our new variable, as the expression on the right-hand side of the let statement is unambiguous and the type is inferred by the compiler.

Proměnné v Q # jsou neměnné, což znamená, že jakmile je proměnná definována tímto způsobem, nelze ji již žádným způsobem změnit.Variables in Q# are immutable, meaning that once a variable has been defined in this way, it can no longer be changed in any way. To umožňuje několik užitečných optimalizací, včetně optimalizace klasické logiky, která působí na proměnné, aby bylo možné použít Adjoint variantu operace.This allows for several beneficial optimizations, including optimization of the classical logic acting on variables to be reordered for applying the Adjoint variant of an operation.

Proměnné definované pomocí vazby let, jak je uvedeno výše, jsou místní pro určitý rozsah, jako je například tělo operace nebo obsah for smyčky.Variables defined using the let binding as above are local to a particular scope, such as the body of an operation or the contents of a for loop.

ProměnlivostMutability

Jako alternativu k vytvoření proměnné pomocí letklíčové slovo mutable vytvoří speciální proměnlivou proměnnou, která může být po prvním vytvoření pomocí klíčového slova set znovu svázána.As an alternative to creating a variable with let, the mutable keyword will create a special mutable variable that can be re-bound after it is initially created by using the set keyword.

operation RandomInts(maxInt : Int, nrSamples : Int) : Int[] {
    mutable samples = new Int[0];
    for (i in 1 .. nrSamples) {
        set samples += [RandomInt(maxInt)];
    }
    return samples;
}

Všechny typy v Q #, včetně polí, dodržují sémantiku hodnot.All types in Q#, including arrays, follow value semantics. Konkrétně není možné aktualizovat položky pole.In particular, it is not possible to update array items. Chcete-li upravit existující pole, je nutné využívat mechanismus kopírování a aktualizace podobně jako u záznamů v F#nástroji.To modify an existing array requires leveraging a copy-and-update mechanism much like the one for records in F#. Pomocí nástrojů knihovny pro pole, která jsou k dispozici v Microsoft.Quantum.Arrays, můžeme například snadno definovat funkci, která vrací pole Paul, kde Pauli na indexu i přebírá danou hodnotu a všechny ostatní položky jsou identity:Using the library tools for arrays provided in Microsoft.Quantum.Arrays, we can e.g. easily define a function that returns an array of Paulis where the Pauli at index i takes the given value and all other entries are the identity:

function EmbedPauli (pauli : Pauli, i : Int, n : Int) : Pauli[] {
    
    let arr = ConstantArray(n, PauliI); // creates an array of filled with PauliI
    return arr w/ i <- pauli; // constructs a new array based on arr except that entry i is set to pauli
}

Podíváme se na to, jak pracovat s poli při diskuzi o příkazech a výrazech Q #.We will elaborate more on how to work with arrays when discussing Q# statements and expressions.

Proměnlivost v rámci Q # je koncept, který se vztahuje na symbol , nikoli na typ nebo hodnotu.Mutability within Q# is a concept that applies to a symbol rather than a type or value. Konkrétně neobsahuje reprezentace v systému typů, implicitně nebo explicitně a zda je vazba proměnlivá (jak je uvedeno v klíčovém slovu mutable) nebo neměnných (jak je uvedeno v let) nemění typ vázaných proměnných.Specifically, it does not have a representation in the type system, implicitly or explicitly, and whether or not a binding is mutable (as indicated by the mutable keyword) or immutable (as indicated by let) does not change the type of the bound variable(s). To poskytuje důležitý způsob, jak izolovat proměnlivost uvnitř specializovaných funkcí a operací.This provides an important way to isolate mutability inside specialized functions and operations. Zejména i v případě, že se v rámci operace, která používá proměnlivou proměnnou, nemůže automaticky generovat automaticky generovaná specializace typu, může automatická generace fungovat pro operaci, která volá funkci, která používá proměnlivost.In particular, even though an adjoint specialization for an operation which uses a mutable variable cannot be auto-generated, auto-generation works fine for an operation calling a function which uses mutability. Z tohoto důvodu je vhodné provádět funkce a operace, které používají proměnlivost co nejkratší a kompaktní, aby zbytek programu pro práci s více operačními systémem mohl být napsán pomocí běžných neměnných proměnných.For this reason, it is a good practice to make functions and operations which use mutability as short and compact as possible, so that the rest of the quantum program can be written using ordinary immutable variables.

DekonstrukceDeconstruction

Kromě přiřazování jedné proměnné, klíčová slova let a mutable – nebo ve skutečnosti jakékoliv jiné konstrukce vazby – umožňují také rozbalení obsahu typu řazené kolekce členů.In addition to assigning a single variable, the let and mutable keywords - or in fact any other binding construct - also allow for unpacking the contents of a tuple type. Přiřazení tohoto formuláře se říká k dekonstrukci prvků této řazené kolekce členů.An assignment of this form is said to deconstruct the elements of that tuple. Například pokud budeme modelovat pojem v Hamiltonian podle řazené kolekce členů, můžeme použít dekonstrukci k přístupu k různým datům, ke kterým musíme simulovat za tento termín:For instance, if we model a term in a Hamiltonian by a tuple, then we can use deconstruction to access the different data that we need to simulate under that term:

// Represents H = 3.1 X_0 Z_1.
let (_, (paulis, idxQubits)) = ((3.1, 1.0), ([PauliX, PauliZ], [0, 1])); // paulis and idxQubits are both immutable variables
mutable ((c1, c2), _) = ((3.1, 1.0), ([PauliX, PauliZ], [0, 1])); // c1 and c2 are both mutable variables