diff --git a/qiskit/providers/baseprovider.py b/qiskit/providers/baseprovider.py
index ee9401959dc5..05bd43bd5ea1 100644
--- a/qiskit/providers/baseprovider.py
+++ b/qiskit/providers/baseprovider.py
@@ -14,6 +14,8 @@
 
 """Base class for a backend provider."""
 
+import warnings
+
 from abc import ABC, abstractmethod
 
 from .exceptions import QiskitBackendNotFoundError
diff --git a/qiskit/qasm/qasm.py b/qiskit/qasm/qasm.py
index 48c6340e5678..c7895b0d4569 100644
--- a/qiskit/qasm/qasm.py
+++ b/qiskit/qasm/qasm.py
@@ -18,6 +18,7 @@
 from .exceptions import QasmError
 from .qasmparser import QasmParser
 
+import warnings
 
 class Qasm:
     """OPENQASM circuit object."""
@@ -32,18 +33,31 @@ def __init__(self, filename=None, data=None):
         self._filename = filename
         self._data = data
 
-    def get_filename(self):
+    def return_filename(self):
         """Return the filename."""
         return self._filename
 
     def get_tokens(self):
+        """Deprecated. Use generate_tokens()."""
+        warnings.warn('The method get_tokens() is being replaced by generate_tokens()',
+                      DeprecationWarning, 2)
+
+        """Returns a generator of the tokens."""
+        if self._filename:
+            with open(self._filename) as ifile:
+                self._data = ifile.read()
+
+        with QasmParser(self._filename) as qasm_p:
+            return qasm_p.read_tokens()
+
+    def generate_tokens(self):
         """Returns a generator of the tokens."""
         if self._filename:
             with open(self._filename) as ifile:
                 self._data = ifile.read()
 
         with QasmParser(self._filename) as qasm_p:
-            return qasm_p.get_tokens()
+            return qasm_p.read_tokens()
 
     def parse(self):
         """Parse the data."""
diff --git a/qiskit/qasm/qasmparser.py b/qiskit/qasm/qasmparser.py
index 568c6d53534b..84eed5da1fe5 100644
--- a/qiskit/qasm/qasmparser.py
+++ b/qiskit/qasm/qasmparser.py
@@ -1046,7 +1046,22 @@ def find_column(self, input_, token):
         return column
 
     def get_tokens(self):
-        """Returns a generator of the tokens."""
+        """Deprecated. Use read_tokens()."""
+        warnings.warn('The method get_tokens() is being replaced by read_tokens()',
+                      DeprecationWarning, 2)
+        try:
+            while True:
+                token = self.lexer.token()
+
+                if not token:
+                    break
+
+                yield token
+        except QasmError as e:
+            print('Exception tokenizing qasm file:', e.msg)
+
+    def read_tokens(self):
+        """finds and reads the tokens."""
         try:
             while True:
                 token = self.lexer.token()
diff --git a/qiskit/result/result.py b/qiskit/result/result.py
index 3456fa88a25b..c1c97fe999ce 100644
--- a/qiskit/result/result.py
+++ b/qiskit/result/result.py
@@ -22,6 +22,7 @@
 from qiskit.result import postprocess
 from .models import ResultSchema
 
+import warnings
 
 @bind_schema(ResultSchema)
 class Result(BaseModel):
@@ -154,6 +155,23 @@ def get_memory(self, experiment=None):
             raise QiskitError('No memory for experiment "{0}".'.format(experiment))
 
     def get_counts(self, experiment=None):
+        """Deprecated. Use histogram_data()."""
+        warnings.warn('The method get_counts() is being replaced by histogram_data()',
+                      DeprecationWarning, 2)
+
+        try:
+            exp = self._get_experiment(experiment)
+            try:
+                header = exp.header.to_dict()
+            except (AttributeError, QiskitError):  # header is not available
+                header = None
+
+            return postprocess.format_counts(self.data(experiment)['counts'],
+                                             header)
+        except KeyError:
+            raise QiskitError('No counts for experiment "{0}"'.format(experiment))
+
+    def histogram_data(self, experiment=None):
         """Get the histogram data of an experiment.
 
         Args:
@@ -182,6 +200,19 @@ def get_counts(self, experiment=None):
             raise QiskitError('No counts for experiment "{0}"'.format(experiment))
 
     def get_statevector(self, experiment=None, decimals=None):
+        """Deprecated. Use return_statevector()."""
+        warnings.warn('The method get_statevector() is being replaced by return_statevector()',
+                      DeprecationWarning, 2)
+
+        try:
+            return postprocess.format_statevector(self.data(experiment)['statevector'],
+                                                  decimals=decimals)
+        except KeyError:
+            raise QiskitError('No statevector for experiment "{0}"'.format(experiment))
+
+
+
+    def return_statevector(self, experiment=None, decimals=None):
         """Get the final statevector of an experiment.
 
         Args:
@@ -203,6 +234,18 @@ def get_statevector(self, experiment=None, decimals=None):
             raise QiskitError('No statevector for experiment "{0}"'.format(experiment))
 
     def get_unitary(self, experiment=None, decimals=None):
+        """Deprecated. Use return_unitary()."""
+        warnings.warn('The method get_unitary() is being replaced by return_unitary()',
+                      DeprecationWarning, 2)
+
+        try:
+            return postprocess.format_unitary(self.data(experiment)['unitary'],
+                                              decimals=decimals)
+        except KeyError:
+            raise QiskitError('No unitary for experiment "{0}"'.format(experiment))
+
+
+    def return_unitary(self, experiment=None, decimals=None):
         """Get the final unitary of an experiment.
 
         Args:
diff --git a/test/performance/state_tomography.py b/test/performance/state_tomography.py
index 7d4c61697547..c8ee469c0c34 100644
--- a/test/performance/state_tomography.py
+++ b/test/performance/state_tomography.py
@@ -92,7 +92,7 @@ def state_tomography(state, n_qubits, shots):
     # Prepared target state and assess quality
     prep_circ = target_prep(state, target)
     prep_result = execute(prep_circ, backend='statevector_simulator').result()
-    prep_state = prep_result.get_statevector(prep_circ)
+    prep_state = prep_result.return_statevector(prep_circ)
     F_prep = state_fidelity(prep_state, target)
     print('Prepared state fidelity =', F_prep)
 
diff --git a/test/python/basicaer/test_multi_registers_convention.py b/test/python/basicaer/test_multi_registers_convention.py
index 69b9683c4aac..a76e3793cc94 100644
--- a/test/python/basicaer/test_multi_registers_convention.py
+++ b/test/python/basicaer/test_multi_registers_convention.py
@@ -48,11 +48,11 @@ def test_circuit_multi(self):
 
         backend_sim = BasicAer.get_backend('statevector_simulator')
         result = execute(circ, backend_sim, seed_transpiler=3438).result()
-        state = result.get_statevector(circ)
+        state = result.return_statevector(circ)
 
         backend_sim = BasicAer.get_backend('unitary_simulator')
         result = execute(circ, backend_sim, seed_transpiler=3438).result()
-        unitary = result.get_unitary(circ)
+        unitary = result.return_unitary(circ)
 
         self.assertEqual(counts, target)
         self.assertAlmostEqual(state_fidelity(basis_state('0110', 4), state), 1.0, places=7)
diff --git a/test/python/basicaer/test_statevector_simulator.py b/test/python/basicaer/test_statevector_simulator.py
index c2fa081cb1f5..fa162f07cf00 100644
--- a/test/python/basicaer/test_statevector_simulator.py
+++ b/test/python/basicaer/test_statevector_simulator.py
@@ -34,7 +34,7 @@ def test_run_circuit(self):
         self.circuit = ReferenceCircuits.bell_no_measure()
         # Execute
         result = super().test_run_circuit()
-        actual = result.get_statevector(self.circuit)
+        actual = result.return_statevector(self.circuit)
 
         # state is 1/sqrt(2)|00> + 1/sqrt(2)|11>, up to a global phase
         self.assertAlmostEqual((abs(actual[0]))**2, 1 / 2)
@@ -48,7 +48,7 @@ def test_measure_collapse(self):
         self.circuit = ReferenceCircuits.bell()
         # Execute
         result = super().test_run_circuit()
-        actual = result.get_statevector(self.circuit)
+        actual = result.return_statevector(self.circuit)
 
         # The final state should be EITHER |00> OR |11>
         diff_00 = np.linalg.norm(np.array([1, 0, 0, 0]) - actual)**2
diff --git a/test/python/basicaer/test_unitary_simulator.py b/test/python/basicaer/test_unitary_simulator.py
index 272a0ba51a04..4268b4a6f73e 100644
--- a/test/python/basicaer/test_unitary_simulator.py
+++ b/test/python/basicaer/test_unitary_simulator.py
@@ -35,7 +35,7 @@ def test_basicaer_unitary_simulator_py(self):
         """Test unitary simulator."""
         circuits = self._test_circuits()
         job = execute(circuits, backend=self.backend)
-        sim_unitaries = [job.result().get_unitary(circ) for circ in circuits]
+        sim_unitaries = [job.result().return_unitary(circ) for circ in circuits]
         reference_unitaries = self._reference_unitaries()
         norms = [np.trace(np.dot(np.transpose(np.conj(target)), actual))
                  for target, actual in zip(reference_unitaries, sim_unitaries)]
diff --git a/test/python/circuit/test_initializer.py b/test/python/circuit/test_initializer.py
index 49a3d77602b0..c375d08cfa64 100644
--- a/test/python/circuit/test_initializer.py
+++ b/test/python/circuit/test_initializer.py
@@ -42,7 +42,7 @@ def test_uniform_superposition(self):
         qc.initialize(desired_vector, [qr[0], qr[1]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -56,7 +56,7 @@ def test_deterministic_state(self):
         qc.initialize(desired_vector, [qr[0], qr[1]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -70,7 +70,7 @@ def test_bell_state(self):
         qc.initialize(desired_vector, [qr[0], qr[1]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -84,7 +84,7 @@ def test_ghz_state(self):
         qc.initialize(desired_vector, [qr[0], qr[1], qr[2]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -99,7 +99,7 @@ def test_initialize_register(self):
         qc.initialize(desired_vector, qr)
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, np.kron([1, 0, 0, 0], desired_vector))
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -119,8 +119,8 @@ def test_initialize_one_by_one(self):
 
         job = execute([qc_a, qc_b], BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector_a = result.get_statevector(0)
-        statevector_b = result.get_statevector(1)
+        statevector_a = result.return_statevector(0)
+        statevector_b = result.return_statevector(1)
         fidelity = state_fidelity(statevector_a, statevector_b)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -134,7 +134,7 @@ def test_single_qubit(self):
         qc.initialize(desired_vector, [qr[0]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -156,7 +156,7 @@ def test_random_3qubit(self):
         qc.initialize(desired_vector, [qr[0], qr[1], qr[2]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -186,7 +186,7 @@ def test_random_4qubit(self):
         qc.initialize(desired_vector, [qr[0], qr[1], qr[2], qr[3]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -256,7 +256,7 @@ def test_math_amplitudes(self):
         qc.initialize(desired_vector, [qr[0], qr[1], qr[2], qr[3]])
         job = execute(qc, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        statevector = result.get_statevector()
+        statevector = result.return_statevector()
         fidelity = state_fidelity(statevector, desired_vector)
         self.assertGreater(
             fidelity, self._desired_fidelity,
@@ -276,7 +276,7 @@ def test_combiner(self):
 
         job = execute(qc1 + qc2, BasicAer.get_backend('statevector_simulator'))
         result = job.result()
-        quantum_state = result.get_statevector()
+        quantum_state = result.return_statevector()
         fidelity = state_fidelity(quantum_state, desired_vector_2)
         self.assertGreater(
             fidelity, self._desired_fidelity,
diff --git a/test/python/quantum_info/test_states.py b/test/python/quantum_info/test_states.py
index 132a1c35e11d..710d30d2d828 100644
--- a/test/python/quantum_info/test_states.py
+++ b/test/python/quantum_info/test_states.py
@@ -82,7 +82,7 @@ def test_basis_state_circuit(self):
         qc = QuantumCircuit(q)
         qc.initialize(state, [q[0], q[1], q[2]])
         backend = BasicAer.get_backend('statevector_simulator')
-        qc_state = execute(qc, backend).result().get_statevector(qc)
+        qc_state = execute(qc, backend).result().return_statevector(qc)
         self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
 
     def test_random_state(self):
@@ -101,7 +101,7 @@ def test_random_state_circuit(self):
         qc = QuantumCircuit(q)
         qc.initialize(state, [q[0], q[1], q[2]])
         backend = BasicAer.get_backend('statevector_simulator')
-        qc_state = execute(qc, backend).result().get_statevector(qc)
+        qc_state = execute(qc, backend).result().return_statevector(qc)
         self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
 
     def test_purity_list_input(self):
diff --git a/test/python/quantum_info/test_synthesis.py b/test/python/quantum_info/test_synthesis.py
index 0699792cbf20..d2f3c990ed82 100644
--- a/test/python/quantum_info/test_synthesis.py
+++ b/test/python/quantum_info/test_synthesis.py
@@ -84,7 +84,7 @@ def check_one_qubit_euler_angles(self, operator, tolerance=1e-14):
             decomp_circuit = QuantumCircuit(1)
             decomp_circuit.u3(*angles, 0)
             result = execute(decomp_circuit, UnitarySimulatorPy()).result()
-            decomp_unitary = result.get_unitary()
+            decomp_unitary = result.return_unitary()
             target_unitary *= la.det(target_unitary)**(-0.5)
             decomp_unitary *= la.det(decomp_unitary)**(-0.5)
             maxdist = np.max(np.abs(target_unitary - decomp_unitary))
@@ -129,7 +129,7 @@ def check_two_qubit_weyl_decomposition(self, target_unitary, tolerance=1.e-7):
             decomp_circuit.append(UnitaryGate(decomp.K1r), [q[0]])
             decomp_circuit.append(UnitaryGate(decomp.K1l), [q[1]])
             result = execute(decomp_circuit, UnitarySimulatorPy()).result()
-            decomp_unitary = result.get_unitary()
+            decomp_unitary = result.return_unitary()
             target_unitary *= la.det(target_unitary)**(-0.25)
             decomp_unitary *= la.det(decomp_unitary)**(-0.25)
             maxdists = [np.max(np.abs(target_unitary + phase*decomp_unitary))
@@ -284,9 +284,9 @@ def check_exact_decomposition(self, target_unitary, decomposer, tolerance=1.e-7)
         with self.subTest(unitary=target_unitary, decomposer=decomposer):
             decomp_circuit = decomposer(target_unitary)
             result = execute(decomp_circuit, UnitarySimulatorPy()).result()
-            decomp_unitary = Operator(result.get_unitary())
+            decomp_unitary = Operator(result.return_unitary())
             result = execute(decomp_circuit, UnitarySimulatorPy()).result()
-            decomp_unitary = result.get_unitary()
+            decomp_unitary = result.return_unitary()
             target_unitary *= la.det(target_unitary)**(-0.25)
             decomp_unitary *= la.det(decomp_unitary)**(-0.25)
             maxdists = [np.max(np.abs(target_unitary + phase*decomp_unitary))
diff --git a/test/python/transpiler/test_consolidate_blocks.py b/test/python/transpiler/test_consolidate_blocks.py
index bb1b1f2f845f..388ce276c241 100644
--- a/test/python/transpiler/test_consolidate_blocks.py
+++ b/test/python/transpiler/test_consolidate_blocks.py
@@ -49,7 +49,7 @@ def test_consolidate_small_block(self):
 
         sim = UnitarySimulatorPy()
         result = execute(qc, sim).result()
-        unitary = UnitaryGate(result.get_unitary())
+        unitary = UnitaryGate(result.return_unitary())
         self.assertEqual(len(new_dag.op_nodes()), 1)
         fidelity = process_fidelity(new_dag.op_nodes()[0].op.to_matrix(), unitary.to_matrix())
         self.assertAlmostEqual(fidelity, 1.0, places=7)
@@ -120,7 +120,7 @@ def test_3q_blocks(self):
 
         sim = UnitarySimulatorPy()
         result = execute(qc, sim).result()
-        unitary = UnitaryGate(result.get_unitary())
+        unitary = UnitaryGate(result.return_unitary())
         self.assertEqual(len(new_dag.op_nodes()), 1)
         fidelity = process_fidelity(new_dag.op_nodes()[0].op.to_matrix(), unitary.to_matrix())
         self.assertAlmostEqual(fidelity, 1.0, places=7)
@@ -141,7 +141,7 @@ def test_block_spanning_two_regs(self):
 
         sim = UnitarySimulatorPy()
         result = execute(qc, sim).result()
-        unitary = UnitaryGate(result.get_unitary())
+        unitary = UnitaryGate(result.return_unitary())
         self.assertEqual(len(new_dag.op_nodes()), 1)
         fidelity = process_fidelity(new_dag.op_nodes()[0].op.to_matrix(), unitary.to_matrix())
         self.assertAlmostEqual(fidelity, 1.0, places=7)