OpenQASM 2 dan Qiskit SDK

Versi pakej

Kod di halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan menggunakan versi ini atau lebih baharu.

qiskit[all]~=2.3.0

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit

Qiskit SDK menyediakan beberapa alat untuk menukar antara representasi OpenQASM program kuantum, dan kelas QuantumCircuit.

Import program OpenQASM 2 ke dalam Qiskit

Dua fungsi mengimport program OpenQASM 2 ke dalam Qiskit. Ini ialah qasm2.load(), yang mengambil nama fail, dan qasm2.loads(), yang mengambil program OpenQASM 2 sebagai rentetan.

import qiskit.qasm2

qiskit.qasm2.load(filename, include_path=('.',), include_input_directory='append', custom_instructions=(), custom_classical=(), strict=False)
qiskit.qasm2.loads(program, include_path=('.',), custom_instructions=(), custom_classical=(), strict=False)

Lihat OpenQASM 2 Qiskit API untuk maklumat lanjut.

Import program mudah

Untuk kebanyakan program OpenQASM 2, anda boleh menggunakan qasm2.load dan qasm2.loads dengan hujah tunggal.

Contoh: import program OpenQASM 2 sebagai rentetan

Gunakan qasm2.loads() untuk mengimport program OpenQASM 2 sebagai rentetan ke dalam QuantumCircuit:

import qiskit.qasm2

program = """
    OPENQASM 2.0;
    include "qelib1.inc";
    qreg q[2];
    creg c[2];

    h q[0];
    cx q[0], q[1];

    measure q -> c;
"""
circuit = qiskit.qasm2.loads(program)
circuit.draw()

┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1

Contoh: import program OpenQASM 2 dari fail

Gunakan load() untuk mengimport program OpenQASM 2 dari fail ke dalam QuantumCircuit:

import qiskit.qasm2
circuit = qiskit.qasm2.load("myfile.qasm")

Hubungkan Gate OpenQASM 2 dengan Gate Qiskit

Secara lalai, pengimport OpenQASM 2 Qiskit menganggap fail include "qelib1.inc" sebagai pustaka standard de facto. Pengimport menganggap fail ini mengandungi tepat gate yang diterangkan dalam kertas asal yang mentakrifkan OpenQASM 2. Qiskit akan menggunakan gate terbina dalam di pustaka circuit untuk mewakili gate dalam "qelib1.inc". Gate yang ditakrifkan dalam program dengan pernyataan gate OpenQASM 2 manual akan, secara lalai, dibina sebagai subkelas Gate Qiskit tersuai.

Anda boleh memberitahu pengimport untuk menggunakan kelas Gate tertentu untuk pernyataan gate yang ditemuinya. Anda juga boleh menggunakan mekanisme ini untuk menganggap nama gate tambahan sebagai "terbina dalam", iaitu, tidak memerlukan definisi yang eksplisit. Jika anda menentukan kelas gate yang hendak digunakan untuk pernyataan gate di luar "qelib1.inc", Circuit yang dihasilkan biasanya lebih cekap untuk digunakan.

amaran

Mulai Qiskit SDK v1.0, pengeksport OpenQASM 2 Qiskit (lihat Eksport Circuit Qiskit ke OpenQASM 2) masih berkelakuan seolah-olah "qelib1.inc" mempunyai lebih banyak gate daripada yang sebenarnya. Ini bermakna tetapan lalai pengimport mungkin tidak dapat mengimport program yang dieksport oleh pengeksport kami. Lihat contoh khusus tentang bekerja dengan pengeksport warisan untuk menyelesaikan masalah ini.

Perbezaan ini ialah tingkah laku warisan Qiskit, dan ia akan diselesaikan dalam keluaran Qiskit kemudian.

Untuk menghantar maklumat tentang arahan tersuai kepada pengimport OpenQASM 2, gunakan kelas qasm2.CustomInstruction. Ini mempunyai empat maklumat yang diperlukan, mengikut urutan:

Nama gate, digunakan dalam program OpenQASM 2
Bilangan parameter sudut yang diambil oleh gate
Bilangan Qubit yang digunakan oleh gate
Kelas konstruktor Python atau fungsi untuk gate, yang mengambil parameter gate (tetapi bukan Qubit) sebagai hujah individu

Jika pengimport menemui definisi gate yang sepadan dengan arahan tersuai yang diberikan, ia akan menggunakan maklumat tersuai itu untuk membina semula objek gate. Jika pernyataan gate ditemui yang sepadan dengan name arahan tersuai, tetapi tidak sepadan dengan bilangan parameter dan bilangan Qubit, pengimport akan menimbulkan QASM2ParseError, untuk menunjukkan ketidakpadanan antara maklumat yang diberikan dan program.

Selain itu, hujah kelima builtin boleh secara pilihan ditetapkan kepada True untuk menjadikan gate tersedia secara automatik dalam program OpenQASM 2, walaupun ia tidak ditakrifkan secara eksplisit. Jika pengimport menemui definisi gate eksplisit untuk arahan tersuai terbina dalam, ia akan menerimanya secara senyap. Seperti sebelumnya, jika definisi eksplisit dengan nama yang sama tidak serasi dengan arahan tersuai yang diberikan, QASM2ParseError akan ditimbulkan. Ini berguna untuk keserasian dengan pengeksport OpenQASM 2 yang lebih lama, dan dengan platform kuantum tertentu lain yang menganggap "gate asas" perkakasan mereka sebagai arahan terbina dalam.

Qiskit menyediakan atribut data untuk bekerja dengan program OpenQASM 2 yang dihasilkan oleh versi warisan keupayaan mengeksport OpenQASM 2 Qiskit. Ini ialah qasm2.LEGACY_CUSTOM_INSTRUCTIONS, yang boleh diberikan sebagai hujah custom_instructions kepada qasm2.load() dan qasm2.loads().

Contoh: import program yang dicipta oleh pengeksport warisan Qiskit

Program OpenQASM 2 ini menggunakan gate yang tidak ada dalam versi asal "qelib1.inc" tanpa mendeklarasikannya, tetapi merupakan gate standard dalam pustaka Qiskit. Anda boleh menggunakan qasm2.LEGACY_CUSTOM_INSTRUCTIONS untuk memberitahu pengimport dengan mudah menggunakan set gate yang sama yang pernah digunakan oleh pengeksport OpenQASM 2 Qiskit.

from qiskit import qasm2

program = """
    OPENQASM 2.0;
    include "qelib1.inc";

    qreg q[4];
    creg c[4];

    h q[0];
    cx q[0], q[1];

    // 'rxx' is not actually in `qelib1.inc`,
    // but Qiskit used to behave as if it were.
    rxx(0.75) q[2], q[3];

    measure q -> c;
"""
circuit = qasm2.loads(
    program,
    custom_instructions=qasm2.LEGACY_CUSTOM_INSTRUCTIONS,
)

Contoh: gunakan kelas gate tertentu semasa mengimport program OpenQASM 2

Qiskit tidak boleh, secara umum, mengesahkan sama ada definisi dalam pernyataan gate OpenQASM 2 sepadan tepat dengan gate pustaka standard Qiskit. Sebaliknya, Qiskit memilih gate tersuai menggunakan definisi tepat yang diberikan. Ini boleh kurang cekap berbanding menggunakan salah satu gate standard terbina dalam, atau gate tersuai yang ditentukan pengguna. Anda boleh menentukan pernyataan gate secara manual dengan kelas tertentu.

from qiskit import qasm2
from qiskit.circuit import Gate
from qiskit.circuit.library import RZXGate

# Define a custom gate that takes one qubit and two angles.
class MyGate(Gate):
    def __init__(self, theta, phi):
        super().__init__("my", 1, [theta, phi])

custom_instructions = [
    # Link the OpenQASM 2 name 'my' with our custom gate.
    qasm2.CustomInstruction("my", 2, 1, MyGate),
    # Link the OpenQASM 2 name 'rzx' with Qiskit's
    # built-in RZXGate.
    qasm2.CustomInstruction("rzx", 1, 2, RZXGate),
]

program = """
    OPENQASM 2.0;

    gate my(theta, phi) q {
        U(theta / 2, phi, -theta / 2) q;
    }
    gate rzx(theta) a, b {
        // It doesn't matter what definition is
        // supplied, if the parameters match;
        // Qiskit will still use `RZXGate`.
    }

    qreg q[2];
    my(0.25, 0.125) q[0];
    rzx(pi) q[0], q[1];
"""

circuit = qasm2.loads(
    program,
    custom_instructions=custom_instructions,
)

Contoh: takrifkan gate terbina dalam baharu dalam program OpenQASM 2

Jika hujah builtin=True ditetapkan, gate tersuai tidak perlu mempunyai definisi yang berkaitan.

from qiskit import qasm2
from qiskit.circuit import Gate

# Define a custom gate that takes one qubit and two angles.
class MyGate(Gate):
    def __init__(self, theta, phi):
        super().__init__("my", 1, [theta, phi])

custom_instructions = [
    qasm2.CustomInstruction("my", 2, 1, MyGate, builtin=True),
]

program = """
    OPENQASM 2.0;
    qreg q[1];

    my(0.25, 0.125) q[0];
"""

circuit = qasm2.loads(
    program,
    custom_instructions=custom_instructions,
)

Takrifkan fungsi klasik tersuai

OpenQASM 2 menyertakan beberapa fungsi klasik terbina dalam untuk digunakan dalam hujah gate. Anda boleh melanjutkan bahasa dengan lebih banyak fungsi menggunakan hujah custom_classical kepada qasm2.load() dan qasm2.loads(), dengan kelas qasm2.CustomClassical.

Untuk menakrifkan fungsi klasik tersuai, anda mesti memberikan:

Nama fungsi seperti yang muncul dalam program OpenQASM 2
Bilangan hujah titik terapung yang diterimanya
Objek Python yang boleh dipanggil yang menilai fungsi

Semua fungsi klasik tersuai yang ditakrifkan dianggap terbina dalam bahasa OpenQASM 2 oleh pengimport. Tiada cara rasmi dalam bahasa OpenQASM 2 untuk menakrifkan fungsi baharu; ini ialah sambungan Qiskit.

Contoh: gunakan arahan klasik tersuai

Di sini kami menyediakan dua fungsi klasik tersuai. Yang pertama mudah, dan hanya menambah satu kepada inputnya. Yang kedua ialah fungsi math.atan2, yang mewakili operasi matematik $\arctan(y/x)$ dengan cara yang sedar kuadran.

import math
from qiskit import qasm2

program = """
    include "qelib1.inc";
    qreg q[2];
    rx(arctan(pi, 3 + add_one(0.2))) q[0];
    cx q[0], q[1];
"""

def add_one(x):
    return x + 1

customs = [
    # Our `add_one` takes only one parameter.
    qasm2.CustomClassical("add_one", 1, add_one),
    # `arctan` takes two parameters, and `math.atan2` implements it.
    qasm2.CustomClassical("arctan", 2, math.atan2),
]
circuit = qasm2.loads(program, custom_classical=customs)

Mod ketat

Secara lalai, penghurai ini lebih santai daripada spesifikasi rasmi. Ia membenarkan koma pelacak dalam senarai parameter; titik koma yang tidak perlu (pernyataan kosong); pengabaian pernyataan versi OPENQASM 2.0;; dan beberapa peningkatan kualiti kehidupan lain tanpa mengeluarkan sebarang ralat. Walau bagaimanapun, anda boleh menggunakan mod "mengikut huruf spesifikasi" dengan strict=True.

Eksport Circuit Qiskit ke OpenQASM 2

Qiskit juga boleh mengeksport QuantumCircuit ke OpenQASM 2. Anda menggunakan fungsi qasm2.dump() untuk menulis ke fail, dan qasm2.dumps() untuk menulis ke rentetan. Fungsi-fungsi ini pada masa ini mempunyai antara muka yang sangat mudah: ia menerima circuit dan, hanya dalam kes qasm2.dump(), lokasi untuk menulis output.

amaran

Pengeksport OpenQASM 2 Qiskit masih menganggap versi warisan, bukan standard fail include "qelib1.inc". Ini akan diselesaikan dalam keluaran Qiskit kemudian, tetapi sementara itu, jika anda perlu mengimport semula program OpenQASM 2 yang dicipta dengan Qiskit, gunakan contoh di atas tentang cara memberitahu pengimport tentang gate warisan.

Contoh: eksport circuit ke OpenQASM 2

from qiskit import QuantumCircuit, qasm2

# Define any circuit.
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0, 1], [0, 1])

# Export to a string.
program = qasm2.dumps(circuit)

# Export to a file.
qasm2.dump(circuit, "my_file.qasm")

Langkah seterusnya

Cadangan

Ketahui cara menjana kod OpenQASM dalam panduan IBM Quantum Composer.
Lihat rujukan OpenQASM 2 Qiskit API.
Semak topik Sahkan program anda.
Lawati Spesifikasi Langsung OpenQASM.

Source: IBM Quantum docs — updated 27 Apr 2026

English version on doQumentation — updated 7 Mei 2026

This translation based on the English version of 11 Mac 2026

Import program OpenQASM 2 ke dalam Qiskit​

Import program mudah​

Contoh: import program OpenQASM 2 sebagai rentetan​

Contoh: import program OpenQASM 2 dari fail​

Hubungkan Gate OpenQASM 2 dengan Gate Qiskit​

Contoh: import program yang dicipta oleh pengeksport warisan Qiskit​

Contoh: gunakan kelas gate tertentu semasa mengimport program OpenQASM 2​

Contoh: takrifkan gate terbina dalam baharu dalam program OpenQASM 2​

Takrifkan fungsi klasik tersuai​

Contoh: gunakan arahan klasik tersuai​

Mod ketat​

Eksport Circuit Qiskit ke OpenQASM 2​

Contoh: eksport circuit ke OpenQASM 2​

Langkah seterusnya​