Customize this training

Get a certificate — $16.67$5

Quantum Programming with Qiskit

Quantum Programming with Qiskit

A hands-on course for people who know basic Python: set up Qiskit 2.x, build and sample your first circuits, learn the core gates, follow two small algorithms, run a circuit on real IBM hardware and understand noise, queues and honest limits. Five modules, each with a worked example, and a 10-question final quiz. Based on official documentation; APIs change, so check the current docs. Not an accredited qualification.

What you will learn

  • Explain and apply: Install Qiskit 2.x, build a Bell-state circuit and read sampled counts from a local simulator.
  • Explain and apply: Use the core gates, draw circuits and reason about amplitudes with statevector and estimator tools.
  • Explain and apply: Explain and run Bernstein–Vazirani and a two-qubit Grover search step by step.
  • Explain and apply: Transpile and run a circuit on IBM hardware with Qiskit 2.x, and interpret noisy results with queue awareness.
  • Explain and apply: Describe error mitigation, compare other SDKs neutrally and state the honest limits of current quantum computing.

Modules

  1. Set up and run your first circuit
  2. Gates, drawing and statevector intuition
  3. Small algorithms: Bernstein–Vazirani and Grover
  4. Running on real IBM hardware
  5. Next steps and honest limits

Course facts

Estimated study time
about 80 minutes
Final assessment
10 questions · Pass mark 80%
Available in
English, Français, العربية
Price
Free. Optional verifiable certificate: $5
Last updated
Published by
AMAADOR ACADEMY

Who this course is for

Learners, developers and analysts who know basic Python and want a first practical path into quantum programming.

Prerequisites

Basic Python (functions, loops, installing packages with pip) and comfort with a terminal or notebook. No physics degree is needed; school-level algebra helps.

Course content

1. Set up and run your first circuit

Qiskit is an open-source Python toolkit for writing quantum circuits and running them on simulators or on real devices. If you know basic Python, you already have most of what you need. Create a clean virtual environment, run pip install qiskit, and add pip install jupyter if you want notebooks. Install qiskit-ibm-runtime later, in module 4, when you reach real hardware. This course targets Qiskit 2.x. APIs change between releases, so when an older tutorial fails, check your installed version and the official docs and migration guide before debugging your own circuit. Functions such as execute and the old Aer imports from qiskit no longer work in 2.x.

A circuit is an ordered list of gates acting on qubits, followed by measurements that write results into classical bits. The classic first circuit is the Bell state. A Hadamard gate on qubit 0 puts it into an equal superposition of 0 and 1. A controlled-NOT (CX) gate then flips qubit 1 only when qubit 0 is 1. The two qubits end up entangled in the state (|00⟩ + |11⟩)/√2: each measurement gives 00 or 11, never 01 or 10, but which of the two is random.

2. Gates, drawing and statevector intuition

A small set of gates covers most beginner circuits. X flips 0 and 1, like a classical NOT. H creates or undoes an equal superposition. Z leaves 0 alone and changes the sign of 1, a phase that is invisible when you measure right away but matters after another H. CX flips a target qubit when the control is 1 and is the usual way to entangle. Rotation gates such as rx, ry and rz turn the qubit state by an angle you choose, and most other single-qubit gates are special cases of them.

A statevector holds one complex amplitude for each possible bit string, so n qubits need 2 to the power n numbers. The probability of an outcome is the squared size of its amplitude. A phase changes the sign or angle of an amplitude without changing that probability, but later gates can turn phase differences into real probability differences. That interference is the main resource behind quantum algorithms. A statevector simulator lets you inspect amplitudes directly, which real hardware never allows, and it grows exponentially with qubit count, so it only suits small circuits.

3. Small algorithms: Bernstein–Vazirani and Grover

Bernstein–Vazirani is a teaching algorithm with a clear classical comparison. A hidden n-bit string s defines a function, and an oracle computes the parity of the input bits selected by s. Classically you need n queries to learn s, one bit at a time. Quantumly one query is enough: prepare the helper qubit in the minus state, put the input qubits in superposition, apply the oracle, apply H again, and measure. Phases written by the oracle interfere so that the input register ends exactly in s. Our oracle is a CX from each input qubit where s has a 1, into the helper qubit. The speedup is real in query count, but the task is artificial; it teaches the pattern and does not solve a business problem.

Grover search looks for a marked item among N, and needs about the square root of N queries instead of about N. With two qubits there are four items, and one marked state, 11. Step 1: H on both qubits makes all four amplitudes equal. Step 2: the oracle, a CZ gate, flips the sign of only the 11 amplitude. Step 3: the diffusion operator, H then X then CZ then X then H, reflects every amplitude about their average, which makes the marked amplitude larger and the others smaller. For four items one round brings 11 to probability close to 1 in the ideal simulator. For larger sets the number of rounds matters, since too many rounds overshoot.

4. Running on real IBM hardware

To use real hardware you create an account on the IBM Quantum Platform, which gives you an API key and access to the devices your plan allows. Save the key once on your own machine and never paste it into a notebook you share or into a public repository. Then install qiskit-ibm-runtime and load the service. Access rules, plan limits and the exact way to save an account change over time, so follow the current documentation rather than a tutorial copy.

Real devices do not run arbitrary gates on arbitrary qubit pairs. Each device has a native gate set and a coupling map showing which qubits can interact. Transpiling rewrites your circuit into native gates, picks physical qubits and inserts swaps if required. In Qiskit 2.x you build a pass manager with generate_preset_pass_manager and run it on your circuit, producing what the docs call an ISA circuit. The result may be much deeper than what you drew, and depth matters because noise accumulates. Then SamplerV2 runs the circuit and returns counts as in the local case.

5. Next steps and honest limits

Today’s devices are noisy and small, so the field has a middle step between ideal circuits and full error correction. Error mitigation runs extra circuits or repeats runs under controlled changes, then post-processes the results to reduce the bias that noise adds to an estimate. One idea, zero-noise extrapolation, deliberately amplifies noise by known factors and extrapolates back toward no noise. Mitigation costs more shots, and it is not error correction: it improves estimates, usually of expectation values, and does not remove errors from each run. Runtime exposes options for such techniques, so check the current docs for names and defaults.

Qiskit is not the only SDK. Cirq, from Google Quantum AI, is another Python library for circuits. PennyLane focuses on differentiable programming and hybrid quantum-classical workflows. Their concepts, qubits, gates, measurements and shots, carry over, while the syntax and device access differ. Learning one SDK well makes others easy to pick up. Choose by the hardware you can reach, the community around you and the kind of problem you work on, not by popularity, and check each project’s own documentation.

The full lesson continues in the interactive course on this page.

Sources and references

Education only. It is not legal, financial or professional advice and not an accredited qualification. Software and platform pages are summarised as read on the access date; APIs, plans and access rules change, so check the current documentation. Figures in worked examples are illustrative. Hardware roadmaps are vendor targets, not facts.

All courses · AI & Data