diff --git a/qiskit/circuit/library/generalized_gates/gms.py b/qiskit/circuit/library/generalized_gates/gms.py
index d1653c872ffb..3e111fa4930d 100644
--- a/qiskit/circuit/library/generalized_gates/gms.py
+++ b/qiskit/circuit/library/generalized_gates/gms.py
@@ -19,7 +19,6 @@
 
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.library.standard_gates import RXXGate
 from qiskit.circuit.gate import Gate
 
@@ -113,10 +112,9 @@ def __init__(self, num_qubits, theta, label=None):
 
     def _define(self):
         theta = self.params[0]
-        q = QuantumRegister(self.num_qubits, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
         for i in range(self.num_qubits):
             for j in range(i + 1, self.num_qubits):
-                qc._append(RXXGate(theta), [q[i], q[j]], [])
+                qc.append(RXXGate(theta), [i, j], [])
 
         self.definition = qc
diff --git a/qiskit/circuit/library/generalized_gates/pauli.py b/qiskit/circuit/library/generalized_gates/pauli.py
index fe9396190a7e..21172fb65cb6 100644
--- a/qiskit/circuit/library/generalized_gates/pauli.py
+++ b/qiskit/circuit/library/generalized_gates/pauli.py
@@ -13,7 +13,6 @@
 """
 Simulator command to perform multiple pauli gates in a single pass
 """
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.library.standard_gates.i import IGate
 from qiskit.circuit.library.standard_gates.x import XGate
 from qiskit.circuit.library.standard_gates.y import YGate
@@ -46,10 +45,9 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
         gates = {"I": IGate, "X": XGate, "Y": YGate, "Z": ZGate}
-        q = QuantumRegister(len(self.params[0]), "q")
-        qc = QuantumCircuit(q, name=f"{self.name}({self.params[0]})")
+        qc = QuantumCircuit(len(self.params[0]), name=f"{self.name}({self.params[0]})")
 
-        rules = [(gates[p](), [q[i]], []) for (i, p) in enumerate(reversed(self.params[0]))]
+        rules = [(gates[p](), [qc.qubits[i]], []) for (i, p) in enumerate(reversed(self.params[0]))]
         qc._data = rules
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/dcx.py b/qiskit/circuit/library/standard_gates/dcx.py
index a2804cb1ca27..8e9a454c0c30 100644
--- a/qiskit/circuit/library/standard_gates/dcx.py
+++ b/qiskit/circuit/library/standard_gates/dcx.py
@@ -14,7 +14,6 @@
 
 import numpy as np
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class DCXGate(Gate):
@@ -56,11 +55,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], [])]
+        qc = QuantumCircuit(2, name=self.name)
+        rules = [(CXGate(), [0, 1], []), (CXGate(), [1, 0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/ecr.py b/qiskit/circuit/library/standard_gates/ecr.py
index bfe7594660d4..a44cf25c2445 100644
--- a/qiskit/circuit/library/standard_gates/ecr.py
+++ b/qiskit/circuit/library/standard_gates/ecr.py
@@ -15,7 +15,6 @@
 import numpy as np
 
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from .rzx import RZXGate
 from .x import XGate
 
@@ -87,15 +86,14 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (RZXGate(np.pi / 4), [q[0], q[1]], []),
-            (XGate(), [q[0]], []),
-            (RZXGate(-np.pi / 4), [q[0], q[1]], []),
+            (RZXGate(np.pi / 4), [0, 1], []),
+            (XGate(), [0], []),
+            (RZXGate(-np.pi / 4), [0, 1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/equivalence_library.py b/qiskit/circuit/library/standard_gates/equivalence_library.py
index 96c651d3cd45..1800fb13dfe0 100644
--- a/qiskit/circuit/library/standard_gates/equivalence_library.py
+++ b/qiskit/circuit/library/standard_gates/equivalence_library.py
@@ -15,7 +15,7 @@
 
 import warnings
 from qiskit.qasm import pi
-from qiskit.circuit import EquivalenceLibrary, Parameter, QuantumCircuit, QuantumRegister
+from qiskit.circuit import EquivalenceLibrary, Parameter, QuantumCircuit
 
 from qiskit.quantum_info.synthesis.ion_decompose import cnot_rxx_decompose
 
@@ -73,23 +73,21 @@
 
 # HGate
 
-q = QuantumRegister(1, "q")
-def_h = QuantumCircuit(q)
-def_h.append(U2Gate(0, pi), [q[0]], [])
+def_h = QuantumCircuit(1)
+def_h.append(U2Gate(0, pi), [0], [])
 _sel.add_equivalence(HGate(), def_h)
 
 # CHGate
 
-q = QuantumRegister(2, "q")
-def_ch = QuantumCircuit(q)
+def_ch = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (SGate(), [q[1]], []),
-    (HGate(), [q[1]], []),
-    (TGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (TdgGate(), [q[1]], []),
-    (HGate(), [q[1]], []),
-    (SdgGate(), [q[1]], []),
+    (SGate(), [1], []),
+    (HGate(), [1], []),
+    (TGate(), [1], []),
+    (CXGate(), [0, 1], []),
+    (TdgGate(), [1], []),
+    (HGate(), [1], []),
+    (SdgGate(), [1], []),
 ]:
     def_ch.append(inst, qargs, cargs)
 _sel.add_equivalence(CHGate(), def_ch)
@@ -97,35 +95,31 @@
 # MSGate
 
 for num_qubits in range(2, 20):
-    q = QuantumRegister(num_qubits, "q")
     theta = Parameter("theta")
-    def_ms = QuantumCircuit(q)
+    def_ms = QuantumCircuit(num_qubits)
     for i in range(num_qubits):
         for j in range(i + 1, num_qubits):
-            def_ms.append(RXXGate(theta), [q[i], q[j]])
+            def_ms.append(RXXGate(theta), [i, j])
     with warnings.catch_warnings():
         warnings.filterwarnings("ignore", category=DeprecationWarning)
         _sel.add_equivalence(MSGate(num_qubits, theta), def_ms)
 
 # PhaseGate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-phase_to_u1 = QuantumCircuit(q)
+phase_to_u1 = QuantumCircuit(1)
 phase_to_u1.append(U1Gate(theta), [0])
 _sel.add_equivalence(PhaseGate(theta), phase_to_u1)
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-phase_to_u = QuantumCircuit(q)
+phase_to_u = QuantumCircuit(1)
 phase_to_u.u(0, 0, theta, 0)
 _sel.add_equivalence(PhaseGate(theta), phase_to_u)
 
 # CPhaseGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_cphase = QuantumCircuit(q)
+def_cphase = QuantumCircuit(2)
 def_cphase.p(theta / 2, 0)
 def_cphase.cx(0, 1)
 def_cphase.p(-theta / 2, 1)
@@ -133,104 +127,96 @@
 def_cphase.p(theta / 2, 1)
 _sel.add_equivalence(CPhaseGate(theta), def_cphase)
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-cphase_to_cu1 = QuantumCircuit(q)
+cphase_to_cu1 = QuantumCircuit(2)
 cphase_to_cu1.append(CU1Gate(theta), [0, 1])
 _sel.add_equivalence(CPhaseGate(theta), cphase_to_cu1)
 
 # RGate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
-def_r = QuantumCircuit(q)
-def_r.append(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [q[0]])
+def_r = QuantumCircuit(1)
+def_r.append(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [0])
 _sel.add_equivalence(RGate(theta, phi), def_r)
 
 # RCCXGate
 
-q = QuantumRegister(3, "q")
-def_rccx = QuantumCircuit(q)
+def_rccx = QuantumCircuit(3)
 for inst, qargs, cargs in [
-    (HGate(), [q[2]], []),
-    (TGate(), [q[2]], []),
-    (CXGate(), [q[1], q[2]], []),
-    (TdgGate(), [q[2]], []),
-    (CXGate(), [q[0], q[2]], []),
-    (TGate(), [q[2]], []),
-    (CXGate(), [q[1], q[2]], []),
-    (TdgGate(), [q[2]], []),
-    (HGate(), [q[2]], []),
+    (HGate(), [2], []),
+    (TGate(), [2], []),
+    (CXGate(), [1, 2], []),
+    (TdgGate(), [2], []),
+    (CXGate(), [0, 2], []),
+    (TGate(), [2], []),
+    (CXGate(), [1, 2], []),
+    (TdgGate(), [2], []),
+    (HGate(), [2], []),
 ]:
     def_rccx.append(inst, qargs, cargs)
 _sel.add_equivalence(RCCXGate(), def_rccx)
 
 # RXGate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-def_rx = QuantumCircuit(q)
-def_rx.append(RGate(theta, 0), [q[0]], [])
+def_rx = QuantumCircuit(1)
+def_rx.append(RGate(theta, 0), [0], [])
 _sel.add_equivalence(RXGate(theta), def_rx)
 
 # CRXGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_crx = QuantumCircuit(q)
+def_crx = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (U1Gate(pi / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (U3Gate(-theta / 2, 0, 0), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (U3Gate(theta / 2, -pi / 2, 0), [q[1]], []),
+    (U1Gate(pi / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (U3Gate(-theta / 2, 0, 0), [1], []),
+    (CXGate(), [0, 1], []),
+    (U3Gate(theta / 2, -pi / 2, 0), [1], []),
 ]:
     def_crx.append(inst, qargs, cargs)
 _sel.add_equivalence(CRXGate(theta), def_crx)
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-crx_to_srycx = QuantumCircuit(q)
+crx_to_srycx = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (SGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RYGate(-theta / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RYGate(theta / 2), [q[1]], []),
-    (SdgGate(), [q[1]], []),
+    (SGate(), [1], []),
+    (CXGate(), [0, 1], []),
+    (RYGate(-theta / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (RYGate(theta / 2), [1], []),
+    (SdgGate(), [1], []),
 ]:
     crx_to_srycx.append(inst, qargs, cargs)
 _sel.add_equivalence(CRXGate(theta), crx_to_srycx)
 
 # RXXGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_rxx = QuantumCircuit(q)
+def_rxx = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (HGate(), [q[0]], []),
-    (HGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RZGate(theta), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
-    (HGate(), [q[0]], []),
+    (HGate(), [0], []),
+    (HGate(), [1], []),
+    (CXGate(), [0, 1], []),
+    (RZGate(theta), [1], []),
+    (CXGate(), [0, 1], []),
+    (HGate(), [1], []),
+    (HGate(), [0], []),
 ]:
     def_rxx.append(inst, qargs, cargs)
 _sel.add_equivalence(RXXGate(theta), def_rxx)
 
 # RZXGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_rzx = QuantumCircuit(q)
+def_rzx = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (HGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RZGate(theta), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
+    (HGate(), [1], []),
+    (CXGate(), [0, 1], []),
+    (RZGate(theta), [1], []),
+    (CXGate(), [0, 1], []),
+    (HGate(), [1], []),
 ]:
     def_rzx.append(inst, qargs, cargs)
 _sel.add_equivalence(RZXGate(theta), def_rzx)
@@ -238,53 +224,48 @@
 
 # RYGate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-def_ry = QuantumCircuit(q)
-def_ry.append(RGate(theta, pi / 2), [q[0]], [])
+def_ry = QuantumCircuit(1)
+def_ry.append(RGate(theta, pi / 2), [0], [])
 _sel.add_equivalence(RYGate(theta), def_ry)
 
 # CRYGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_cry = QuantumCircuit(q)
+def_cry = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (RYGate(theta / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RYGate(-theta / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
+    (RYGate(theta / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (RYGate(-theta / 2), [1], []),
+    (CXGate(), [0, 1], []),
 ]:
     def_cry.append(inst, qargs, cargs)
 _sel.add_equivalence(CRYGate(theta), def_cry)
 
 # RYYGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_ryy = QuantumCircuit(q)
+def_ryy = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (RXGate(pi / 2), [q[0]], []),
-    (RXGate(pi / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RZGate(theta), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RXGate(-pi / 2), [q[0]], []),
-    (RXGate(-pi / 2), [q[1]], []),
+    (RXGate(pi / 2), [0], []),
+    (RXGate(pi / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (RZGate(theta), [1], []),
+    (CXGate(), [0, 1], []),
+    (RXGate(-pi / 2), [0], []),
+    (RXGate(-pi / 2), [1], []),
 ]:
     def_ryy.append(inst, qargs, cargs)
 _sel.add_equivalence(RYYGate(theta), def_ryy)
 
 # RZGate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-def_rz = QuantumCircuit(q, global_phase=-theta / 2)
-def_rz.append(U1Gate(theta), [q[0]], [])
+def_rz = QuantumCircuit(1, global_phase=-theta / 2)
+def_rz.append(U1Gate(theta), [0], [])
 _sel.add_equivalence(RZGate(theta), def_rz)
 
-q = QuantumRegister(1, "q")
-rz_to_sxry = QuantumCircuit(q)
+rz_to_sxry = QuantumCircuit(1)
 rz_to_sxry.sx(0)
 rz_to_sxry.ry(-theta, 0)
 rz_to_sxry.sxdg(0)
@@ -292,201 +273,173 @@
 
 # CRZGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_crz = QuantumCircuit(q)
+def_crz = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (RZGate(theta / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RZGate(-theta / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
+    (RZGate(theta / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (RZGate(-theta / 2), [1], []),
+    (CXGate(), [0, 1], []),
 ]:
     def_crz.append(inst, qargs, cargs)
 _sel.add_equivalence(CRZGate(theta), def_crz)
 
 # RZZGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_rzz = QuantumCircuit(q)
+def_rzz = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (CXGate(), [q[0], q[1]], []),
-    (RZGate(theta), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
+    (CXGate(), [0, 1], []),
+    (RZGate(theta), [1], []),
+    (CXGate(), [0, 1], []),
 ]:
     def_rzz.append(inst, qargs, cargs)
 _sel.add_equivalence(RZZGate(theta), def_rzz)
 
 # RZXGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_rzx = QuantumCircuit(q)
+def_rzx = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (HGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (RZGate(theta), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
+    (HGate(), [1], []),
+    (CXGate(), [0, 1], []),
+    (RZGate(theta), [1], []),
+    (CXGate(), [0, 1], []),
+    (HGate(), [1], []),
 ]:
     def_rzx.append(inst, qargs, cargs)
 _sel.add_equivalence(RZXGate(theta), def_rzx)
 
 # ECRGate
 
-q = QuantumRegister(2, "q")
-def_ecr = QuantumCircuit(q)
+def_ecr = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (RZXGate(pi / 4), [q[0], q[1]], []),
-    (XGate(), [q[0]], []),
-    (RZXGate(-pi / 4), [q[0], q[1]], []),
+    (RZXGate(pi / 4), [0, 1], []),
+    (XGate(), [0], []),
+    (RZXGate(-pi / 4), [0, 1], []),
 ]:
     def_ecr.append(inst, qargs, cargs)
 _sel.add_equivalence(ECRGate(), def_ecr)
 
 # SGate
 
-q = QuantumRegister(1, "q")
-def_s = QuantumCircuit(q)
-def_s.append(U1Gate(pi / 2), [q[0]], [])
+def_s = QuantumCircuit(1)
+def_s.append(U1Gate(pi / 2), [0], [])
 _sel.add_equivalence(SGate(), def_s)
 
 # SdgGate
 
-q = QuantumRegister(1, "q")
-def_sdg = QuantumCircuit(q)
-def_sdg.append(U1Gate(-pi / 2), [q[0]], [])
+def_sdg = QuantumCircuit(1)
+def_sdg.append(U1Gate(-pi / 2), [0], [])
 _sel.add_equivalence(SdgGate(), def_sdg)
 
 # SwapGate
 
-q = QuantumRegister(2, "q")
-def_swap = QuantumCircuit(q)
-for inst, qargs, cargs in [
-    (CXGate(), [q[0], q[1]], []),
-    (CXGate(), [q[1], q[0]], []),
-    (CXGate(), [q[0], q[1]], []),
-]:
+def_swap = QuantumCircuit(2)
+for inst, qargs, cargs in [(CXGate(), [0, 1], []), (CXGate(), [1, 0], []), (CXGate(), [0, 1], [])]:
     def_swap.append(inst, qargs, cargs)
 _sel.add_equivalence(SwapGate(), def_swap)
 
 # iSwapGate
 
-q = QuantumRegister(2, "q")
-def_iswap = QuantumCircuit(q)
+def_iswap = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (SGate(), [q[0]], []),
-    (SGate(), [q[1]], []),
-    (HGate(), [q[0]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (CXGate(), [q[1], q[0]], []),
-    (HGate(), [q[1]], []),
+    (SGate(), [0], []),
+    (SGate(), [1], []),
+    (HGate(), [0], []),
+    (CXGate(), [0, 1], []),
+    (CXGate(), [1, 0], []),
+    (HGate(), [1], []),
 ]:
     def_iswap.append(inst, qargs, cargs)
 _sel.add_equivalence(iSwapGate(), def_iswap)
 
 # SXGate
 
-q = QuantumRegister(1, "q")
-def_sx = QuantumCircuit(q, global_phase=pi / 4)
-for inst, qargs, cargs in [(SdgGate(), [q[0]], []), (HGate(), [q[0]], []), (SdgGate(), [q[0]], [])]:
+def_sx = QuantumCircuit(1, global_phase=pi / 4)
+for inst, qargs, cargs in [(SdgGate(), [0], []), (HGate(), [0], []), (SdgGate(), [0], [])]:
     def_sx.append(inst, qargs, cargs)
 _sel.add_equivalence(SXGate(), def_sx)
 
-q = QuantumRegister(1, "q")
-sx_to_rx = QuantumCircuit(q, global_phase=pi / 4)
+sx_to_rx = QuantumCircuit(1, global_phase=pi / 4)
 sx_to_rx.rx(pi / 2, 0)
 _sel.add_equivalence(SXGate(), sx_to_rx)
 
 # SXdgGate
 
-q = QuantumRegister(1, "q")
-def_sxdg = QuantumCircuit(q, global_phase=-pi / 4)
-for inst, qargs, cargs in [(SGate(), [q[0]], []), (HGate(), [q[0]], []), (SGate(), [q[0]], [])]:
+def_sxdg = QuantumCircuit(1, global_phase=-pi / 4)
+for inst, qargs, cargs in [(SGate(), [0], []), (HGate(), [0], []), (SGate(), [0], [])]:
     def_sxdg.append(inst, qargs, cargs)
 _sel.add_equivalence(SXdgGate(), def_sxdg)
 
-q = QuantumRegister(1, "q")
-sxdg_to_rx = QuantumCircuit(q, global_phase=-pi / 4)
+sxdg_to_rx = QuantumCircuit(1, global_phase=-pi / 4)
 sxdg_to_rx.rx(-pi / 2, 0)
 _sel.add_equivalence(SXdgGate(), sxdg_to_rx)
 
 # CSXGate
 
-q = QuantumRegister(2, "q")
-def_csx = QuantumCircuit(q)
-for inst, qargs, cargs in [
-    (HGate(), [q[1]], []),
-    (CU1Gate(pi / 2), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
-]:
+def_csx = QuantumCircuit(2)
+for inst, qargs, cargs in [(HGate(), [1], []), (CU1Gate(pi / 2), [0, 1], []), (HGate(), [1], [])]:
     def_csx.append(inst, qargs, cargs)
 _sel.add_equivalence(CSXGate(), def_csx)
 
 # DCXGate
 
-q = QuantumRegister(2, "q")
-def_dcx = QuantumCircuit(q)
-for inst, qargs, cargs in [(CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], [])]:
+def_dcx = QuantumCircuit(2)
+for inst, qargs, cargs in [(CXGate(), [0, 1], []), (CXGate(), [1, 0], [])]:
     def_dcx.append(inst, qargs, cargs)
 _sel.add_equivalence(DCXGate(), def_dcx)
 
-q = QuantumRegister(2, "q")
-dcx_to_iswap = QuantumCircuit(q)
+dcx_to_iswap = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (HGate(), [q[0]], []),
-    (SdgGate(), [q[0]], []),
-    (SdgGate(), [q[1]], []),
-    (iSwapGate(), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
+    (HGate(), [0], []),
+    (SdgGate(), [0], []),
+    (SdgGate(), [1], []),
+    (iSwapGate(), [0, 1], []),
+    (HGate(), [1], []),
 ]:
     dcx_to_iswap.append(inst, qargs, cargs)
 _sel.add_equivalence(DCXGate(), dcx_to_iswap)
 
 # CSwapGate
 
-q = QuantumRegister(3, "q")
-def_cswap = QuantumCircuit(q)
+def_cswap = QuantumCircuit(3)
 for inst, qargs, cargs in [
-    (CXGate(), [q[2], q[1]], []),
-    (CCXGate(), [q[0], q[1], q[2]], []),
-    (CXGate(), [q[2], q[1]], []),
+    (CXGate(), [2, 1], []),
+    (CCXGate(), [0, 1, 2], []),
+    (CXGate(), [2, 1], []),
 ]:
     def_cswap.append(inst, qargs, cargs)
 _sel.add_equivalence(CSwapGate(), def_cswap)
 
 # TGate
 
-q = QuantumRegister(1, "q")
-def_t = QuantumCircuit(q)
-def_t.append(U1Gate(pi / 4), [q[0]], [])
+def_t = QuantumCircuit(1)
+def_t.append(U1Gate(pi / 4), [0], [])
 _sel.add_equivalence(TGate(), def_t)
 
 # TdgGate
 
-q = QuantumRegister(1, "q")
-def_tdg = QuantumCircuit(q)
-def_tdg.append(U1Gate(-pi / 4), [q[0]], [])
+def_tdg = QuantumCircuit(1)
+def_tdg.append(U1Gate(-pi / 4), [0], [])
 _sel.add_equivalence(TdgGate(), def_tdg)
 
 # UGate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
-u_to_u3 = QuantumCircuit(q)
+u_to_u3 = QuantumCircuit(1)
 u_to_u3.append(U3Gate(theta, phi, lam), [0])
 _sel.add_equivalence(UGate(theta, phi, lam), u_to_u3)
 
 # CUGate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
 gamma = Parameter("gamma")
-def_cu = QuantumCircuit(q)
+def_cu = QuantumCircuit(2)
 def_cu.p(gamma, 0)
 def_cu.p((lam + phi) / 2, 0)
 def_cu.p((lam - phi) / 2, 1)
@@ -496,68 +449,61 @@
 def_cu.u(theta / 2, phi, 0, 1)
 _sel.add_equivalence(CUGate(theta, phi, lam, gamma), def_cu)
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
 gamma = Parameter("gamma")
-cu_to_cu3 = QuantumCircuit(q)
+cu_to_cu3 = QuantumCircuit(2)
 cu_to_cu3.p(gamma, 0)
 cu_to_cu3.append(CU3Gate(theta, phi, lam), [0, 1])
 _sel.add_equivalence(CUGate(theta, phi, lam, gamma), cu_to_cu3)
 
 # U1Gate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-def_u1 = QuantumCircuit(q)
-def_u1.append(U3Gate(0, 0, theta), [q[0]], [])
+def_u1 = QuantumCircuit(1)
+def_u1.append(U3Gate(0, 0, theta), [0], [])
 _sel.add_equivalence(U1Gate(theta), def_u1)
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-u1_to_phase = QuantumCircuit(q)
+u1_to_phase = QuantumCircuit(1)
 u1_to_phase.p(theta, 0)
 _sel.add_equivalence(U1Gate(theta), u1_to_phase)
 
 # U1Gate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
-u1_to_rz = QuantumCircuit(q, global_phase=theta / 2)
-u1_to_rz.append(RZGate(theta), [q[0]], [])
+u1_to_rz = QuantumCircuit(1, global_phase=theta / 2)
+u1_to_rz.append(RZGate(theta), [0], [])
 _sel.add_equivalence(U1Gate(theta), u1_to_rz)
 
 # CU1Gate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
-def_cu1 = QuantumCircuit(q)
+def_cu1 = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (U1Gate(theta / 2), [q[0]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (U1Gate(-theta / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (U1Gate(theta / 2), [q[1]], []),
+    (U1Gate(theta / 2), [0], []),
+    (CXGate(), [0, 1], []),
+    (U1Gate(-theta / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (U1Gate(theta / 2), [1], []),
 ]:
     def_cu1.append(inst, qargs, cargs)
 _sel.add_equivalence(CU1Gate(theta), def_cu1)
 
 # U1Gate
 
-q = QuantumRegister(1, "q")
 phi = Parameter("phi")
 lam = Parameter("lam")
-def_u2 = QuantumCircuit(q)
-def_u2.append(U3Gate(pi / 2, phi, lam), [q[0]], [])
+def_u2 = QuantumCircuit(1)
+def_u2.append(U3Gate(pi / 2, phi, lam), [0], [])
 _sel.add_equivalence(U2Gate(phi, lam), def_u2)
 
 # U2Gate
 
-q = QuantumRegister(1, "q")
 phi = Parameter("phi")
 lam = Parameter("lam")
-u2_to_u1sx = QuantumCircuit(q, global_phase=-pi / 4)
+u2_to_u1sx = QuantumCircuit(1, global_phase=-pi / 4)
 u2_to_u1sx.append(U1Gate(lam - pi / 2), [0])
 u2_to_u1sx.sx(0)
 u2_to_u1sx.append(U1Gate(phi + pi / 2), [0])
@@ -565,11 +511,10 @@
 
 # U3Gate
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
-u3_qasm_def = QuantumCircuit(q, global_phase=(lam + phi - pi) / 2)
+u3_qasm_def = QuantumCircuit(1, global_phase=(lam + phi - pi) / 2)
 u3_qasm_def.rz(lam, 0)
 u3_qasm_def.sx(0)
 u3_qasm_def.rz(theta + pi, 0)
@@ -577,44 +522,40 @@
 u3_qasm_def.rz(phi + 3 * pi, 0)
 _sel.add_equivalence(U3Gate(theta, phi, lam), u3_qasm_def)
 
-q = QuantumRegister(1, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
-u3_to_u = QuantumCircuit(q)
+u3_to_u = QuantumCircuit(1)
 u3_to_u.u(theta, phi, lam, 0)
 _sel.add_equivalence(U3Gate(theta, phi, lam), u3_to_u)
 
 # CU3Gate
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
-def_cu3 = QuantumCircuit(q)
+def_cu3 = QuantumCircuit(2)
 for inst, qargs, cargs in [
-    (U1Gate((lam + phi) / 2), [q[0]], []),
-    (U1Gate((lam - phi) / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (U3Gate(-theta / 2, 0, -(phi + lam) / 2), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (U3Gate(theta / 2, phi, 0), [q[1]], []),
+    (U1Gate((lam + phi) / 2), [0], []),
+    (U1Gate((lam - phi) / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (U3Gate(-theta / 2, 0, -(phi + lam) / 2), [1], []),
+    (CXGate(), [0, 1], []),
+    (U3Gate(theta / 2, phi, 0), [1], []),
 ]:
     def_cu3.append(inst, qargs, cargs)
 _sel.add_equivalence(CU3Gate(theta, phi, lam), def_cu3)
 
-q = QuantumRegister(2, "q")
 theta = Parameter("theta")
 phi = Parameter("phi")
 lam = Parameter("lam")
-cu3_to_cu = QuantumCircuit(q)
+cu3_to_cu = QuantumCircuit(2)
 cu3_to_cu.cu(theta, phi, lam, 0, 0, 1)
 
 # XGate
 
-q = QuantumRegister(1, "q")
-def_x = QuantumCircuit(q)
-def_x.append(U3Gate(pi, 0, pi), [q[0]], [])
+def_x = QuantumCircuit(1)
+def_x.append(U3Gate(pi, 0, pi), [0], [])
 _sel.add_equivalence(XGate(), def_x)
 
 # CXGate
@@ -624,140 +565,116 @@
         cx_to_rxx = cnot_rxx_decompose(plus_ry, plus_rxx)
         _sel.add_equivalence(CXGate(), cx_to_rxx)
 
-q = QuantumRegister(2, "q")
-cx_to_cz = QuantumCircuit(q)
-for inst, qargs, cargs in [
-    (HGate(), [q[1]], []),
-    (CZGate(), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
-]:
+cx_to_cz = QuantumCircuit(2)
+for inst, qargs, cargs in [(HGate(), [1], []), (CZGate(), [0, 1], []), (HGate(), [1], [])]:
     cx_to_cz.append(inst, qargs, cargs)
 _sel.add_equivalence(CXGate(), cx_to_cz)
 
-q = QuantumRegister(2, "q")
-cx_to_iswap = QuantumCircuit(q, global_phase=3 * pi / 4)
+cx_to_iswap = QuantumCircuit(2, global_phase=3 * pi / 4)
 for inst, qargs, cargs in [
-    (HGate(), [q[0]], []),
-    (XGate(), [q[1]], []),
-    (HGate(), [q[1]], []),
-    (iSwapGate(), [q[0], q[1]], []),
-    (XGate(), [q[0]], []),
-    (XGate(), [q[1]], []),
-    (HGate(), [q[1]], []),
-    (iSwapGate(), [q[0], q[1]], []),
-    (HGate(), [q[0]], []),
-    (SGate(), [q[0]], []),
-    (SGate(), [q[1]], []),
-    (XGate(), [q[1]], []),
-    (HGate(), [q[1]], []),
+    (HGate(), [0], []),
+    (XGate(), [1], []),
+    (HGate(), [1], []),
+    (iSwapGate(), [0, 1], []),
+    (XGate(), [0], []),
+    (XGate(), [1], []),
+    (HGate(), [1], []),
+    (iSwapGate(), [0, 1], []),
+    (HGate(), [0], []),
+    (SGate(), [0], []),
+    (SGate(), [1], []),
+    (XGate(), [1], []),
+    (HGate(), [1], []),
 ]:
     cx_to_iswap.append(inst, qargs, cargs)
 _sel.add_equivalence(CXGate(), cx_to_iswap)
 
-q = QuantumRegister(2, "q")
-cx_to_ecr = QuantumCircuit(q, global_phase=-pi / 4)
+cx_to_ecr = QuantumCircuit(2, global_phase=-pi / 4)
 for inst, qargs, cargs in [
-    (RZGate(-pi / 2), [q[0]], []),
-    (RYGate(pi), [q[0]], []),
-    (RXGate(pi / 2), [q[1]], []),
-    (ECRGate(), [q[0], q[1]], []),
+    (RZGate(-pi / 2), [0], []),
+    (RYGate(pi), [0], []),
+    (RXGate(pi / 2), [1], []),
+    (ECRGate(), [0, 1], []),
 ]:
     cx_to_ecr.append(inst, qargs, cargs)
 _sel.add_equivalence(CXGate(), cx_to_ecr)
 
 # CCXGate
 
-q = QuantumRegister(3, "q")
-def_ccx = QuantumCircuit(q)
+def_ccx = QuantumCircuit(3)
 for inst, qargs, cargs in [
-    (HGate(), [q[2]], []),
-    (CXGate(), [q[1], q[2]], []),
-    (TdgGate(), [q[2]], []),
-    (CXGate(), [q[0], q[2]], []),
-    (TGate(), [q[2]], []),
-    (CXGate(), [q[1], q[2]], []),
-    (TdgGate(), [q[2]], []),
-    (CXGate(), [q[0], q[2]], []),
-    (TGate(), [q[1]], []),
-    (TGate(), [q[2]], []),
-    (HGate(), [q[2]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (TGate(), [q[0]], []),
-    (TdgGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
+    (HGate(), [2], []),
+    (CXGate(), [1, 2], []),
+    (TdgGate(), [2], []),
+    (CXGate(), [0, 2], []),
+    (TGate(), [2], []),
+    (CXGate(), [1, 2], []),
+    (TdgGate(), [2], []),
+    (CXGate(), [0, 2], []),
+    (TGate(), [1], []),
+    (TGate(), [2], []),
+    (HGate(), [2], []),
+    (CXGate(), [0, 1], []),
+    (TGate(), [0], []),
+    (TdgGate(), [1], []),
+    (CXGate(), [0, 1], []),
 ]:
     def_ccx.append(inst, qargs, cargs)
 _sel.add_equivalence(CCXGate(), def_ccx)
 
 # YGate
 
-q = QuantumRegister(1, "q")
-def_y = QuantumCircuit(q)
-def_y.append(U3Gate(pi, pi / 2, pi / 2), [q[0]], [])
+def_y = QuantumCircuit(1)
+def_y.append(U3Gate(pi, pi / 2, pi / 2), [0], [])
 _sel.add_equivalence(YGate(), def_y)
 
 # CYGate
 
-q = QuantumRegister(2, "q")
-def_cy = QuantumCircuit(q)
-for inst, qargs, cargs in [
-    (SdgGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (SGate(), [q[1]], []),
-]:
+def_cy = QuantumCircuit(2)
+for inst, qargs, cargs in [(SdgGate(), [1], []), (CXGate(), [0, 1], []), (SGate(), [1], [])]:
     def_cy.append(inst, qargs, cargs)
 _sel.add_equivalence(CYGate(), def_cy)
 
 # ZGate
 
-q = QuantumRegister(1, "q")
-def_z = QuantumCircuit(q)
-def_z.append(U1Gate(pi), [q[0]], [])
+def_z = QuantumCircuit(1)
+def_z.append(U1Gate(pi), [0], [])
 _sel.add_equivalence(ZGate(), def_z)
 
 # CZGate
 
-q = QuantumRegister(2, "q")
-def_cz = QuantumCircuit(q)
-for inst, qargs, cargs in [
-    (HGate(), [q[1]], []),
-    (CXGate(), [q[0], q[1]], []),
-    (HGate(), [q[1]], []),
-]:
+def_cz = QuantumCircuit(2)
+for inst, qargs, cargs in [(HGate(), [1], []), (CXGate(), [0, 1], []), (HGate(), [1], [])]:
     def_cz.append(inst, qargs, cargs)
 _sel.add_equivalence(CZGate(), def_cz)
 
 # RXGate, XGate equivalence
 
-q = QuantumRegister(1, "q")
-x_to_rx = QuantumCircuit(q)
-x_to_rx.append(RXGate(theta=pi), [q[0]])
+x_to_rx = QuantumCircuit(1)
+x_to_rx.append(RXGate(theta=pi), [0])
 x_to_rx.global_phase = pi / 2
 _sel.add_equivalence(XGate(), x_to_rx)
 
 # RYGate, YGate equivalence
 
-q = QuantumRegister(1, "q")
-y_to_ry = QuantumCircuit(q)
-y_to_ry.append(RYGate(theta=pi), [q[0]])
+y_to_ry = QuantumCircuit(1)
+y_to_ry.append(RYGate(theta=pi), [0])
 y_to_ry.global_phase = pi / 2
 _sel.add_equivalence(YGate(), y_to_ry)
 
 
 # HGate, RXGate(pi).RYGate(pi/2) equivalence
 
-q = QuantumRegister(1, "q")
-h_to_rxry = QuantumCircuit(q)
-h_to_rxry.append(RYGate(theta=pi / 2), [q[0]])
-h_to_rxry.append(RXGate(theta=pi), [q[0]])
+h_to_rxry = QuantumCircuit(1)
+h_to_rxry.append(RYGate(theta=pi / 2), [0])
+h_to_rxry.append(RXGate(theta=pi), [0])
 h_to_rxry.global_phase = pi / 2
 _sel.add_equivalence(HGate(), h_to_rxry)
 
 # HGate, RGate(pi, 0).RGate(pi/2, pi/2) equivalence
 
-q = QuantumRegister(1, "q")
-h_to_rr = QuantumCircuit(q)
-h_to_rr.append(RGate(theta=pi / 2, phi=pi / 2), [q[0]])
-h_to_rr.append(RGate(theta=pi, phi=0), [q[0]])
+h_to_rr = QuantumCircuit(1)
+h_to_rr.append(RGate(theta=pi / 2, phi=pi / 2), [0])
+h_to_rr.append(RGate(theta=pi, phi=0), [0])
 h_to_rr.global_phase = pi / 2
 _sel.add_equivalence(HGate(), h_to_rr)
diff --git a/qiskit/circuit/library/standard_gates/h.py b/qiskit/circuit/library/standard_gates/h.py
index a4071aeed61a..71464d8ff8da 100644
--- a/qiskit/circuit/library/standard_gates/h.py
+++ b/qiskit/circuit/library/standard_gates/h.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.qasm import pi
 from .t import TGate, TdgGate
 from .s import SGate, SdgGate
@@ -59,11 +58,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u2 import U2Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U2Gate(0, pi), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U2Gate(0, pi), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -180,19 +178,18 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate  # pylint: disable=cyclic-import
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (SGate(), [q[1]], []),
-            (HGate(), [q[1]], []),
-            (TGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (TdgGate(), [q[1]], []),
-            (HGate(), [q[1]], []),
-            (SdgGate(), [q[1]], []),
+            (SGate(), [1], []),
+            (HGate(), [1], []),
+            (TGate(), [1], []),
+            (CXGate(), [0, 1], []),
+            (TdgGate(), [1], []),
+            (HGate(), [1], []),
+            (SdgGate(), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/iswap.py b/qiskit/circuit/library/standard_gates/iswap.py
index 6e21951b3e80..b945cc979de5 100644
--- a/qiskit/circuit/library/standard_gates/iswap.py
+++ b/qiskit/circuit/library/standard_gates/iswap.py
@@ -14,7 +14,6 @@
 
 import numpy as np
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class iSwapGate(Gate):
@@ -96,18 +95,17 @@ def _define(self):
         from .s import SGate
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (SGate(), [q[0]], []),
-            (SGate(), [q[1]], []),
-            (HGate(), [q[0]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (CXGate(), [q[1], q[0]], []),
-            (HGate(), [q[1]], []),
+            (SGate(), [0], []),
+            (SGate(), [1], []),
+            (HGate(), [0], []),
+            (CXGate(), [0, 1], []),
+            (CXGate(), [1, 0], []),
+            (HGate(), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/ms.py b/qiskit/circuit/library/standard_gates/ms.py
index 6681f02ea5ee..5452999a7965 100644
--- a/qiskit/circuit/library/standard_gates/ms.py
+++ b/qiskit/circuit/library/standard_gates/ms.py
@@ -14,7 +14,6 @@
 
 import warnings
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class MSGate(Gate):
@@ -48,10 +47,9 @@ def _define(self):
         from .rxx import RXXGate
 
         theta = self.params[0]
-        q = QuantumRegister(self.num_qubits, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
         for i in range(self.num_qubits):
             for j in range(i + 1, self.num_qubits):
-                qc._append(RXXGate(theta), [q[i], q[j]], [])
+                qc.append(RXXGate(theta), [i, j], [])
 
         self.definition = qc
diff --git a/qiskit/circuit/library/standard_gates/p.py b/qiskit/circuit/library/standard_gates/p.py
index 03388cba5555..5eca07a1ae0b 100644
--- a/qiskit/circuit/library/standard_gates/p.py
+++ b/qiskit/circuit/library/standard_gates/p.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class PhaseGate(Gate):
@@ -78,8 +77,7 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u import UGate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(1, name=self.name)
         qc.append(UGate(0, 0, self.params[0]), [0])
         self.definition = qc
 
@@ -176,8 +174,7 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         qc.p(self.params[0] / 2, 0)
         qc.cx(0, 1)
         qc.p(-self.params[0] / 2, 1)
@@ -257,8 +254,7 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(self.num_qubits, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
 
         if self.num_ctrl_qubits == 0:
             qc.p(self.params[0], 0)
@@ -269,7 +265,7 @@ def _define(self):
 
             scaled_lam = self.params[0] / (2 ** (self.num_ctrl_qubits - 1))
             bottom_gate = CPhaseGate(scaled_lam)
-            definition = _gray_code_chain(q, self.num_ctrl_qubits, bottom_gate)
+            definition = _gray_code_chain(qc.qubits[:], self.num_ctrl_qubits, bottom_gate)
             qc.data = definition
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/r.py b/qiskit/circuit/library/standard_gates/r.py
index 86adff2dfd99..4c4fea166cb2 100644
--- a/qiskit/circuit/library/standard_gates/r.py
+++ b/qiskit/circuit/library/standard_gates/r.py
@@ -16,7 +16,6 @@
 import numpy
 from qiskit.qasm import pi
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RGate(Gate):
@@ -55,13 +54,12 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u3 import U3Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(1, name=self.name)
         theta = self.params[0]
         phi = self.params[1]
-        rules = [(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [q[0]], [])]
+        rules = [(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/rx.py b/qiskit/circuit/library/standard_gates/rx.py
index 163484646527..e5b5e70d486f 100644
--- a/qiskit/circuit/library/standard_gates/rx.py
+++ b/qiskit/circuit/library/standard_gates/rx.py
@@ -17,7 +17,6 @@
 from qiskit.qasm import pi
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RXGate(Gate):
@@ -56,11 +55,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .r import RGate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(RGate(self.params[0], 0), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(RGate(self.params[0], 0), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -179,17 +177,16 @@ def _define(self):
         from .u3 import U3Gate
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (U1Gate(pi / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U3Gate(-self.params[0] / 2, 0, 0), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U3Gate(self.params[0] / 2, -pi / 2, 0), [q[1]], []),
+            (U1Gate(pi / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (U3Gate(-self.params[0] / 2, 0, 0), [1], []),
+            (CXGate(), [0, 1], []),
+            (U3Gate(self.params[0] / 2, -pi / 2, 0), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/rxx.py b/qiskit/circuit/library/standard_gates/rxx.py
index 7208a06cfe78..7d50ce1f5b3e 100644
--- a/qiskit/circuit/library/standard_gates/rxx.py
+++ b/qiskit/circuit/library/standard_gates/rxx.py
@@ -13,7 +13,6 @@
 """Two-qubit XX-rotation gate."""
 
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RXXGate(Gate):
@@ -79,19 +78,18 @@ def _define(self):
         from .rz import RZGate
 
         theta = self.params[0]
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (HGate(), [q[0]], []),
-            (HGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (HGate(), [q[1]], []),
-            (HGate(), [q[0]], []),
+            (HGate(), [0], []),
+            (HGate(), [1], []),
+            (CXGate(), [0, 1], []),
+            (RZGate(theta), [1], []),
+            (CXGate(), [0, 1], []),
+            (HGate(), [1], []),
+            (HGate(), [0], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/ry.py b/qiskit/circuit/library/standard_gates/ry.py
index 09055f347eb1..b316c0f27334 100644
--- a/qiskit/circuit/library/standard_gates/ry.py
+++ b/qiskit/circuit/library/standard_gates/ry.py
@@ -17,7 +17,6 @@
 from qiskit.qasm import pi
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RYGate(Gate):
@@ -56,11 +55,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .r import RGate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(RGate(self.params[0], pi / 2), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(RGate(self.params[0], pi / 2), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -174,16 +172,15 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (RYGate(self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RYGate(-self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
+            (RYGate(self.params[0] / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (RYGate(-self.params[0] / 2), [1], []),
+            (CXGate(), [0, 1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/ryy.py b/qiskit/circuit/library/standard_gates/ryy.py
index cdb284cee95d..7d8e761734b5 100644
--- a/qiskit/circuit/library/standard_gates/ryy.py
+++ b/qiskit/circuit/library/standard_gates/ryy.py
@@ -14,7 +14,6 @@
 
 import numpy as np
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RYYGate(Gate):
@@ -79,20 +78,19 @@ def _define(self):
         from .rx import RXGate
         from .rz import RZGate
 
-        q = QuantumRegister(2, "q")
         theta = self.params[0]
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (RXGate(np.pi / 2), [q[0]], []),
-            (RXGate(np.pi / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RXGate(-np.pi / 2), [q[0]], []),
-            (RXGate(-np.pi / 2), [q[1]], []),
+            (RXGate(np.pi / 2), [0], []),
+            (RXGate(np.pi / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (RZGate(theta), [1], []),
+            (CXGate(), [0, 1], []),
+            (RXGate(-np.pi / 2), [0], []),
+            (RXGate(-np.pi / 2), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/rz.py b/qiskit/circuit/library/standard_gates/rz.py
index 141b27f62172..d197a078d8b2 100644
--- a/qiskit/circuit/library/standard_gates/rz.py
+++ b/qiskit/circuit/library/standard_gates/rz.py
@@ -14,7 +14,6 @@
 
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.controlledgate import ControlledGate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RZGate(Gate):
@@ -66,12 +65,11 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import U1Gate
 
-        q = QuantumRegister(1, "q")
         theta = self.params[0]
-        qc = QuantumCircuit(q, name=self.name, global_phase=-theta / 2)
-        rules = [(U1Gate(theta), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name, global_phase=-theta / 2)
+        rules = [(U1Gate(theta), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -192,16 +190,15 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (RZGate(self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(-self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
+            (RZGate(self.params[0] / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (RZGate(-self.params[0] / 2), [1], []),
+            (CXGate(), [0, 1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/rzx.py b/qiskit/circuit/library/standard_gates/rzx.py
index bb03ab04cf28..3d1653f196d4 100644
--- a/qiskit/circuit/library/standard_gates/rzx.py
+++ b/qiskit/circuit/library/standard_gates/rzx.py
@@ -13,7 +13,6 @@
 """Two-qubit ZX-rotation gate."""
 
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RZXGate(Gate):
@@ -127,17 +126,16 @@ def _define(self):
         from .rz import RZGate
 
         theta = self.params[0]
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (HGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (HGate(), [q[1]], []),
+            (HGate(), [1], []),
+            (CXGate(), [0, 1], []),
+            (RZGate(theta), [1], []),
+            (CXGate(), [0, 1], []),
+            (HGate(), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/rzz.py b/qiskit/circuit/library/standard_gates/rzz.py
index 062c8f5e7d2f..12553ca97b7c 100644
--- a/qiskit/circuit/library/standard_gates/rzz.py
+++ b/qiskit/circuit/library/standard_gates/rzz.py
@@ -13,7 +13,6 @@
 """Two-qubit ZZ-rotation gate."""
 
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class RZZGate(Gate):
@@ -92,16 +91,11 @@ def _define(self):
         from .x import CXGate
         from .rz import RZGate
 
-        q = QuantumRegister(2, "q")
         theta = self.params[0]
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (CXGate(), [q[0], q[1]], []),
-            (RZGate(theta), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-        ]
+        qc = QuantumCircuit(2, name=self.name)
+        rules = [(CXGate(), [0, 1], []), (RZGate(theta), [1], []), (CXGate(), [0, 1], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/s.py b/qiskit/circuit/library/standard_gates/s.py
index d7890f27513f..fd0efc8d1691 100644
--- a/qiskit/circuit/library/standard_gates/s.py
+++ b/qiskit/circuit/library/standard_gates/s.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.qasm import pi
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class SGate(Gate):
@@ -57,11 +56,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import U1Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(pi / 2), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U1Gate(pi / 2), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -113,11 +111,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import U1Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(-pi / 2), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U1Gate(-pi / 2), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/swap.py b/qiskit/circuit/library/standard_gates/swap.py
index ce300040f438..b5d62a1669fb 100644
--- a/qiskit/circuit/library/standard_gates/swap.py
+++ b/qiskit/circuit/library/standard_gates/swap.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class SwapGate(Gate):
@@ -62,15 +61,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (CXGate(), [q[0], q[1]], []),
-            (CXGate(), [q[1], q[0]], []),
-            (CXGate(), [q[0], q[1]], []),
-        ]
+        qc = QuantumCircuit(2, name=self.name)
+        rules = [(CXGate(), [0, 1], []), (CXGate(), [1, 0], []), (CXGate(), [0, 1], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -225,15 +219,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate, CCXGate
 
-        q = QuantumRegister(3, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [
-            (CXGate(), [q[2], q[1]], []),
-            (CCXGate(), [q[0], q[1], q[2]], []),
-            (CXGate(), [q[2], q[1]], []),
-        ]
+        qc = QuantumCircuit(3, name=self.name)
+        rules = [(CXGate(), [2, 1], []), (CCXGate(), [0, 1, 2], []), (CXGate(), [2, 1], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/sx.py b/qiskit/circuit/library/standard_gates/sx.py
index f5242cb732a8..b90042a3ade6 100644
--- a/qiskit/circuit/library/standard_gates/sx.py
+++ b/qiskit/circuit/library/standard_gates/sx.py
@@ -16,7 +16,6 @@
 from qiskit.qasm import pi
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class SXGate(Gate):
@@ -67,9 +66,8 @@ def _define(self):
         from .s import SdgGate
         from .h import HGate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name, global_phase=pi / 4)
-        rules = [(SdgGate(), [q[0]], []), (HGate(), [q[0]], []), (SdgGate(), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name, global_phase=pi / 4)
+        rules = [(SdgGate(), [0], []), (HGate(), [0], []), (SdgGate(), [0], [])]
         qc.data = rules
         self.definition = qc
 
@@ -141,9 +139,8 @@ def _define(self):
         from .s import SGate
         from .h import HGate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name, global_phase=-pi / 4)
-        rules = [(SGate(), [q[0]], []), (HGate(), [q[0]], []), (SGate(), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name, global_phase=-pi / 4)
+        rules = [(SGate(), [0], []), (HGate(), [0], []), (SGate(), [0], [])]
         qc.data = rules
         self.definition = qc
 
@@ -241,9 +238,8 @@ def _define(self):
         from .h import HGate
         from .u1 import CU1Gate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(HGate(), [q[1]], []), (CU1Gate(pi / 2), [q[0], q[1]], []), (HGate(), [q[1]], [])]
+        qc = QuantumCircuit(2, name=self.name)
+        rules = [(HGate(), [1], []), (CU1Gate(pi / 2), [0, 1], []), (HGate(), [1], [])]
         qc.data = rules
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/t.py b/qiskit/circuit/library/standard_gates/t.py
index feee34cea7a5..22986c57f559 100644
--- a/qiskit/circuit/library/standard_gates/t.py
+++ b/qiskit/circuit/library/standard_gates/t.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.qasm import pi
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class TGate(Gate):
@@ -58,11 +57,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import U1Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(pi / 4), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U1Gate(pi / 4), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -114,11 +112,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import U1Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(-pi / 4), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U1Gate(-pi / 4), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/u.py b/qiskit/circuit/library/standard_gates/u.py
index 29d5e469dcc7..f297582729e0 100644
--- a/qiskit/circuit/library/standard_gates/u.py
+++ b/qiskit/circuit/library/standard_gates/u.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.exceptions import CircuitError
 
 
@@ -195,8 +194,7 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         qc.p(self.params[3], 0)
         qc.p((self.params[2] + self.params[1]) / 2, 0)
         qc.p((self.params[2] - self.params[1]) / 2, 1)
diff --git a/qiskit/circuit/library/standard_gates/u1.py b/qiskit/circuit/library/standard_gates/u1.py
index 7a303882dc6e..fda1226a9724 100644
--- a/qiskit/circuit/library/standard_gates/u1.py
+++ b/qiskit/circuit/library/standard_gates/u1.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import _ctrl_state_to_int
 
 
@@ -83,11 +82,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u3 import U3Gate  # pylint: disable=cyclic-import
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U3Gate(0, 0, self.params[0]), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U3Gate(0, 0, self.params[0]), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -185,17 +183,16 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .x import CXGate  # pylint: disable=cyclic-import
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (U1Gate(self.params[0] / 2), [q[0]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U1Gate(-self.params[0] / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U1Gate(self.params[0] / 2), [q[1]], []),
+            (U1Gate(self.params[0] / 2), [0], []),
+            (CXGate(), [0, 1], []),
+            (U1Gate(-self.params[0] / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (U1Gate(self.params[0] / 2), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -275,8 +272,7 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(self.num_qubits, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
 
         if self.num_ctrl_qubits == 0:
             definition = U1Gate(self.params[0]).definition
@@ -287,9 +283,9 @@ def _define(self):
 
             scaled_lam = self.params[0] / (2 ** (self.num_ctrl_qubits - 1))
             bottom_gate = CU1Gate(scaled_lam)
-            definition = _gray_code_chain(q, self.num_ctrl_qubits, bottom_gate)
+            definition = _gray_code_chain(qc.qubits, self.num_ctrl_qubits, bottom_gate)
         for instr, qargs, cargs in definition:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
         self.definition = qc
 
     def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
diff --git a/qiskit/circuit/library/standard_gates/u2.py b/qiskit/circuit/library/standard_gates/u2.py
index 4be1e3b86621..07369ff544ec 100644
--- a/qiskit/circuit/library/standard_gates/u2.py
+++ b/qiskit/circuit/library/standard_gates/u2.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.qasm import pi
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class U2Gate(Gate):
@@ -67,11 +66,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u3 import U3Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U3Gate(pi / 2, self.params[0], self.params[1]), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U3Gate(pi / 2, self.params[0], self.params[1]), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/u3.py b/qiskit/circuit/library/standard_gates/u3.py
index 9145978fc308..97fb5f23fefe 100644
--- a/qiskit/circuit/library/standard_gates/u3.py
+++ b/qiskit/circuit/library/standard_gates/u3.py
@@ -15,7 +15,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class U3Gate(Gate):
@@ -90,8 +89,7 @@ def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
     def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(1, name=self.name)
         qc.u(self.params[0], self.params[1], self.params[2], 0)
         self.definition = qc
 
@@ -197,18 +195,17 @@ def _define(self):
         from .u1 import U1Gate
         from .x import CXGate  # pylint: disable=cyclic-import
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(2, name=self.name)
         rules = [
-            (U1Gate((self.params[2] + self.params[1]) / 2), [q[0]], []),
-            (U1Gate((self.params[2] - self.params[1]) / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U3Gate(-self.params[0] / 2, 0, -(self.params[1] + self.params[2]) / 2), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (U3Gate(self.params[0] / 2, self.params[1], 0), [q[1]], []),
+            (U1Gate((self.params[2] + self.params[1]) / 2), [0], []),
+            (U1Gate((self.params[2] - self.params[1]) / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (U3Gate(-self.params[0] / 2, 0, -(self.params[1] + self.params[2]) / 2), [1], []),
+            (CXGate(), [0, 1], []),
+            (U3Gate(self.params[0] / 2, self.params[1], 0), [1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/x.py b/qiskit/circuit/library/standard_gates/x.py
index f312d29e87ad..dcc83c88fe63 100644
--- a/qiskit/circuit/library/standard_gates/x.py
+++ b/qiskit/circuit/library/standard_gates/x.py
@@ -17,7 +17,6 @@
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import _compute_control_matrix, _ctrl_state_to_int
 from qiskit.qasm import pi
 from .h import HGate
@@ -32,7 +31,7 @@ class XGate(Gate):
 
     **Matrix Representation:**
 
-    .. math::
+    .. Math::
 
         X = \begin{pmatrix}
                 0 & 1 \\
@@ -82,11 +81,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u3 import U3Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U3Gate(pi, 0, pi), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U3Gate(pi, 0, pi), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -298,27 +296,26 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(3, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(3, name=self.name)
         rules = [
-            (HGate(), [q[2]], []),
-            (CXGate(), [q[1], q[2]], []),
-            (TdgGate(), [q[2]], []),
-            (CXGate(), [q[0], q[2]], []),
-            (TGate(), [q[2]], []),
-            (CXGate(), [q[1], q[2]], []),
-            (TdgGate(), [q[2]], []),
-            (CXGate(), [q[0], q[2]], []),
-            (TGate(), [q[1]], []),
-            (TGate(), [q[2]], []),
-            (HGate(), [q[2]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (TGate(), [q[0]], []),
-            (TdgGate(), [q[1]], []),
-            (CXGate(), [q[0], q[1]], []),
+            (HGate(), [2], []),
+            (CXGate(), [1, 2], []),
+            (TdgGate(), [2], []),
+            (CXGate(), [0, 2], []),
+            (TGate(), [2], []),
+            (CXGate(), [1, 2], []),
+            (TdgGate(), [2], []),
+            (CXGate(), [0, 2], []),
+            (TGate(), [1], []),
+            (TGate(), [2], []),
+            (HGate(), [2], []),
+            (CXGate(), [0, 1], []),
+            (TGate(), [0], []),
+            (TdgGate(), [1], []),
+            (CXGate(), [0, 1], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -388,21 +385,20 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(3, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(3, name=self.name)
         rules = [
-            (U2Gate(0, pi), [q[2]], []),  # H gate
-            (U1Gate(pi / 4), [q[2]], []),  # T gate
-            (CXGate(), [q[1], q[2]], []),
-            (U1Gate(-pi / 4), [q[2]], []),  # inverse T gate
-            (CXGate(), [q[0], q[2]], []),
-            (U1Gate(pi / 4), [q[2]], []),
-            (CXGate(), [q[1], q[2]], []),
-            (U1Gate(-pi / 4), [q[2]], []),  # inverse T gate
-            (U2Gate(0, pi), [q[2]], []),  # H gate
+            (U2Gate(0, pi), [2], []),  # H gate
+            (U1Gate(pi / 4), [2], []),  # T gate
+            (CXGate(), [1, 2], []),
+            (U1Gate(-pi / 4), [2], []),  # inverse T gate
+            (CXGate(), [0, 2], []),
+            (U1Gate(pi / 4), [2], []),
+            (CXGate(), [1, 2], []),
+            (U1Gate(-pi / 4), [2], []),  # inverse T gate
+            (U2Gate(0, pi), [2], []),  # H gate
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -482,40 +478,39 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import CU1Gate
 
-        q = QuantumRegister(4, name="q")
         # pylint: disable=invalid-unary-operand-type
         rules = [
-            (HGate(), [q[3]], []),
-            (CU1Gate(-self._angle), [q[0], q[3]], []),
-            (HGate(), [q[3]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (HGate(), [q[3]], []),
-            (CU1Gate(self._angle), [q[1], q[3]], []),
-            (HGate(), [q[3]], []),
-            (CXGate(), [q[0], q[1]], []),
-            (HGate(), [q[3]], []),
-            (CU1Gate(-self._angle), [q[1], q[3]], []),
-            (HGate(), [q[3]], []),
-            (CXGate(), [q[1], q[2]], []),
-            (HGate(), [q[3]], []),
-            (CU1Gate(self._angle), [q[2], q[3]], []),
-            (HGate(), [q[3]], []),
-            (CXGate(), [q[0], q[2]], []),
-            (HGate(), [q[3]], []),
-            (CU1Gate(-self._angle), [q[2], q[3]], []),
-            (HGate(), [q[3]], []),
-            (CXGate(), [q[1], q[2]], []),
-            (HGate(), [q[3]], []),
-            (CU1Gate(self._angle), [q[2], q[3]], []),
-            (HGate(), [q[3]], []),
-            (CXGate(), [q[0], q[2]], []),
-            (HGate(), [q[3]], []),
-            (CU1Gate(-self._angle), [q[2], q[3]], []),
-            (HGate(), [q[3]], []),
+            (HGate(), [3], []),
+            (CU1Gate(-self._angle), [0, 3], []),
+            (HGate(), [3], []),
+            (CXGate(), [0, 1], []),
+            (HGate(), [3], []),
+            (CU1Gate(self._angle), [1, 3], []),
+            (HGate(), [3], []),
+            (CXGate(), [0, 1], []),
+            (HGate(), [3], []),
+            (CU1Gate(-self._angle), [1, 3], []),
+            (HGate(), [3], []),
+            (CXGate(), [1, 2], []),
+            (HGate(), [3], []),
+            (CU1Gate(self._angle), [2, 3], []),
+            (HGate(), [3], []),
+            (CXGate(), [0, 2], []),
+            (HGate(), [3], []),
+            (CU1Gate(-self._angle), [2, 3], []),
+            (HGate(), [3], []),
+            (CXGate(), [1, 2], []),
+            (HGate(), [3], []),
+            (CU1Gate(self._angle), [2, 3], []),
+            (HGate(), [3], []),
+            (CXGate(), [0, 2], []),
+            (HGate(), [3], []),
+            (CU1Gate(-self._angle), [2, 3], []),
+            (HGate(), [3], []),
         ]
-        qc = QuantumCircuit(q)
+        qc = QuantumCircuit(4)
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -591,8 +586,7 @@ def _define(self):
         """
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(4, name="q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(4, name=self.name)
         qc.h(3)
         qc.p(pi / 8, [0, 1, 2, 3])
         qc.cx(0, 1)
@@ -697,30 +691,29 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(4, "q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(4, name=self.name)
         rules = [
-            (U2Gate(0, pi), [q[3]], []),  # H gate
-            (U1Gate(pi / 4), [q[3]], []),  # T gate
-            (CXGate(), [q[2], q[3]], []),
-            (U1Gate(-pi / 4), [q[3]], []),  # inverse T gate
-            (U2Gate(0, pi), [q[3]], []),
-            (CXGate(), [q[0], q[3]], []),
-            (U1Gate(pi / 4), [q[3]], []),
-            (CXGate(), [q[1], q[3]], []),
-            (U1Gate(-pi / 4), [q[3]], []),
-            (CXGate(), [q[0], q[3]], []),
-            (U1Gate(pi / 4), [q[3]], []),
-            (CXGate(), [q[1], q[3]], []),
-            (U1Gate(-pi / 4), [q[3]], []),
-            (U2Gate(0, pi), [q[3]], []),
-            (U1Gate(pi / 4), [q[3]], []),
-            (CXGate(), [q[2], q[3]], []),
-            (U1Gate(-pi / 4), [q[3]], []),
-            (U2Gate(0, pi), [q[3]], []),
+            (U2Gate(0, pi), [3], []),  # H gate
+            (U1Gate(pi / 4), [3], []),  # T gate
+            (CXGate(), [2, 3], []),
+            (U1Gate(-pi / 4), [3], []),  # inverse T gate
+            (U2Gate(0, pi), [3], []),
+            (CXGate(), [0, 3], []),
+            (U1Gate(pi / 4), [3], []),
+            (CXGate(), [1, 3], []),
+            (U1Gate(-pi / 4), [3], []),
+            (CXGate(), [0, 3], []),
+            (U1Gate(pi / 4), [3], []),
+            (CXGate(), [1, 3], []),
+            (U1Gate(-pi / 4), [3], []),
+            (U2Gate(0, pi), [3], []),
+            (U1Gate(pi / 4), [3], []),
+            (CXGate(), [2, 3], []),
+            (U1Gate(-pi / 4), [3], []),
+            (U2Gate(0, pi), [3], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -798,21 +791,20 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import CU1Gate
 
-        q = QuantumRegister(5, name="q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(5, name=self.name)
         rules = [
-            (HGate(), [q[4]], []),
-            (CU1Gate(-numpy.pi / 2), [q[3], q[4]], []),
-            (HGate(), [q[4]], []),
-            (RC3XGate(), [q[0], q[1], q[2], q[3]], []),
-            (HGate(), [q[4]], []),
-            (CU1Gate(numpy.pi / 2), [q[3], q[4]], []),
-            (HGate(), [q[4]], []),
-            (RC3XGate().inverse(), [q[0], q[1], q[2], q[3]], []),
-            (C3SXGate(), [q[0], q[1], q[2], q[4]], []),
+            (HGate(), [4], []),
+            (CU1Gate(-numpy.pi / 2), [3, 4], []),
+            (HGate(), [4], []),
+            (RC3XGate(), [0, 1, 2, 3], []),
+            (HGate(), [4], []),
+            (CU1Gate(numpy.pi / 2), [3, 4], []),
+            (HGate(), [4], []),
+            (RC3XGate().inverse(), [0, 1, 2, 3], []),
+            (C3XGate(numpy.pi / 8), [0, 1, 2, 4], []),
         ]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -905,9 +897,8 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(self.num_qubits, name="q")
-        qc = QuantumCircuit(q)
-        qc._append(MCXGrayCode(self.num_ctrl_qubits), q[:], [])
+        qc = QuantumCircuit(self.num_qubits)
+        qc._append(MCXGrayCode(self.num_ctrl_qubits), qc.qubits[:], [])
         self.definition = qc
 
     @property
@@ -968,11 +959,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import MCU1Gate
 
-        q = QuantumRegister(self.num_qubits, name="q")
-        qc = QuantumCircuit(q, name=self.name)
-        qc._append(HGate(), [q[-1]], [])
-        qc._append(MCU1Gate(numpy.pi, num_ctrl_qubits=self.num_ctrl_qubits), q[:], [])
-        qc._append(HGate(), [q[-1]], [])
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
+        qc.append(HGate(), [-1], [])
+        qc._append(MCU1Gate(numpy.pi, num_ctrl_qubits=self.num_ctrl_qubits), qc.qubits, [])
+        qc.append(HGate(), [-1], [])
         self.definition = qc
 
 
@@ -1001,16 +991,15 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(self.num_qubits, name="q")
-        qc = QuantumCircuit(q, name=self.name)
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
         if self.num_qubits == 4:
-            qc._append(C3XGate(), q[:], [])
+            qc._append(C3XGate(), qc.qubits, [])
             self.definition = qc
         elif self.num_qubits == 5:
-            qc._append(C4XGate(), q[:], [])
+            qc._append(C4XGate(), qc.qubits, [])
             self.definition = qc
         else:
-            for instr, qargs, cargs in self._recurse(q[:-1], q_ancilla=q[-1]):
+            for instr, qargs, cargs in self._recurse(qc.qubits[:-1], q_ancilla=qc.qubits[-1]):
                 qc._append(instr, qargs, cargs)
             self.definition = qc
 
@@ -1076,11 +1065,10 @@ def _define(self):
         # pylint: disable=cyclic-import
         from qiskit.circuit.quantumcircuit import QuantumCircuit
 
-        q = QuantumRegister(self.num_qubits, name="q")
-        qc = QuantumCircuit(q, name=self.name)
-        q_controls = q[: self.num_ctrl_qubits]
-        q_target = q[self.num_ctrl_qubits]
-        q_ancillas = q[self.num_ctrl_qubits + 1 :]
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
+        q_controls = qc.qubits[: self.num_ctrl_qubits]
+        q_target = qc.qubits[self.num_ctrl_qubits]
+        q_ancillas = qc.qubits[self.num_ctrl_qubits + 1 :]
 
         definition = []
 
diff --git a/qiskit/circuit/library/standard_gates/y.py b/qiskit/circuit/library/standard_gates/y.py
index a08d3393a04e..e8ca745ae6c7 100644
--- a/qiskit/circuit/library/standard_gates/y.py
+++ b/qiskit/circuit/library/standard_gates/y.py
@@ -18,7 +18,6 @@
 # pylint: disable=cyclic-import
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class YGate(Gate):
@@ -73,11 +72,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u3 import U3Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U3Gate(pi, pi / 2, pi / 2), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U3Gate(pi, pi / 2, pi / 2), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -181,11 +179,10 @@ def _define(self):
         from .s import SGate, SdgGate
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(SdgGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (SGate(), [q[1]], [])]
+        qc = QuantumCircuit(2, name=self.name)
+        rules = [(SdgGate(), [1], []), (CXGate(), [0, 1], []), (SGate(), [1], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
diff --git a/qiskit/circuit/library/standard_gates/z.py b/qiskit/circuit/library/standard_gates/z.py
index 9c6d4475fdd9..4517b7d7aea0 100644
--- a/qiskit/circuit/library/standard_gates/z.py
+++ b/qiskit/circuit/library/standard_gates/z.py
@@ -16,7 +16,6 @@
 from qiskit.qasm import pi
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 
 
 class ZGate(Gate):
@@ -71,11 +70,10 @@ def _define(self):
         from qiskit.circuit.quantumcircuit import QuantumCircuit
         from .u1 import U1Gate
 
-        q = QuantumRegister(1, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(U1Gate(pi), [q[0]], [])]
+        qc = QuantumCircuit(1, name=self.name)
+        rules = [(U1Gate(pi), [0], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc
 
@@ -153,11 +151,10 @@ def _define(self):
         from .h import HGate
         from .x import CXGate
 
-        q = QuantumRegister(2, "q")
-        qc = QuantumCircuit(q, name=self.name)
-        rules = [(HGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (HGate(), [q[1]], [])]
+        qc = QuantumCircuit(2, name=self.name)
+        rules = [(HGate(), [1], []), (CXGate(), [0, 1], []), (HGate(), [1], [])]
         for instr, qargs, cargs in rules:
-            qc._append(instr, qargs, cargs)
+            qc.append(instr, qargs, cargs)
 
         self.definition = qc