diff --git a/pyqpanda-algorithm/example/QAlgBase/QmRMR/testeg_QmRMR.py b/pyqpanda-algorithm/example/QAlgBase/QmRMR/testeg_QmRMR.py
index d5dcc675..7fe2fc69 100644
--- a/pyqpanda-algorithm/example/QAlgBase/QmRMR/testeg_QmRMR.py
+++ b/pyqpanda-algorithm/example/QAlgBase/QmRMR/testeg_QmRMR.py
@@ -1,9 +1,7 @@
-import sympy as sp
 import numpy as np
-import pyqpanda as pq
 import warnings
 
-from pyqpanda_alg.QFinance.QmRMR.all_code import plot_bar, plot_loss, Feature_Selection
+from pyqpanda_alg.QmRMR.QmRMR_core import plot_bar, plot_loss, Feature_Selection
 import os
 import matplotlib.pyplot as plt
 warnings.simplefilter("ignore")
diff --git a/pyqpanda-algorithm/example/QAlgBase/newtest.py b/pyqpanda-algorithm/example/QAlgBase/newtest.py
index c915b2c4..477eb96e 100644
--- a/pyqpanda-algorithm/example/QAlgBase/newtest.py
+++ b/pyqpanda-algorithm/example/QAlgBase/newtest.py
@@ -1,31 +1,18 @@
-import pyqpanda as pq
 import numpy as np
+from pyqpanda3.core import CPUQVM, QCircuit, QProg, RY, X
 
-#
-# def f(a=1, b=2):
-#     return a+b
-#
-# def f1(a):
-#     return f(a, b=2)
-#
-# def g(func):
-#     res = func(3)
-#     return res
-#
-#
-# print(g(f1))
 
 def create_cir(qlist):
-    cir = pq.QCircuit()
-    cir << pq.RY(qlist[0], np.pi / 3) << pq.X(qlist[1]).control(qlist[0])
+    cir = QCircuit()
+    cir << RY(qlist[0], np.pi / 3) << X(qlist[1]).control(qlist[0])
     return cir
 
 
-m = pq.CPUQVM()
-m.initQVM()
-q_state = m.qAlloc_many(2)
+if __name__ == '__main__':
+    m = CPUQVM()
+    q_state = QProg(2).qubits()
 
-prog = pq.QProg()
-prog << create_cir(q_state)
+    prog = QProg()
+    prog << create_cir(q_state)
 
-print(prog)
\ No newline at end of file
+    print(prog)
diff --git a/pyqpanda-algorithm/example/QAlgBase/testeg_QUBO.py b/pyqpanda-algorithm/example/QAlgBase/testeg_QUBO.py
index d7c3318e..6cad187e 100644
--- a/pyqpanda-algorithm/example/QAlgBase/testeg_QUBO.py
+++ b/pyqpanda-algorithm/example/QAlgBase/testeg_QUBO.py
@@ -1,7 +1,7 @@
-from pyqpanda_alg.QFinance import QUBO
 import sympy as sp
-import numpy as np
-import pyqpanda as pq
+from pyqpanda3.core import QProg
+
+from pyqpanda_alg import QUBO
 
 
 if __name__ == '__main__':
@@ -11,10 +11,9 @@
     n_key, n_res = test0.query_qnumber()
     print(n_key, n_res)
 
-    m = pq.CPUQVM()
-    m.initQVM()
-    q_key = m.qAlloc_many(n_key)
-    q_res = m.qAlloc_many(n_res)
+    q_all = QProg(n_key + n_res).qubits()
+    q_key = q_all[:n_key]
+    q_res = q_all[n_key:]
 
     print(test0.cir(q_key, q_res))
 
@@ -33,5 +32,5 @@
     # find the minimum function value using QAOA
     test2 = QUBO.QUBO_QAOA(function)
     res2 = test2.run(layer=5, optimizer='SLSQP',
-                     optimizer_option={'options':{'eps':1e-3}})
+                     optimizer_option={'options': {'eps': 1e-3}})
     print('result of QAOA: ', res2)
diff --git a/pyqpanda-algorithm/example/QAlgBase/testeg_QmRMR.py b/pyqpanda-algorithm/example/QAlgBase/testeg_QmRMR.py
index a20d6e7d..646d2c10 100644
--- a/pyqpanda-algorithm/example/QAlgBase/testeg_QmRMR.py
+++ b/pyqpanda-algorithm/example/QAlgBase/testeg_QmRMR.py
@@ -4,7 +4,7 @@
 
 matplotlib.use('Agg')  # 使用非交互式后端
 import matplotlib.pyplot as plt
-from pyqpanda_alg.QmRMR import all_code
+from pyqpanda_alg.QmRMR import QmRMR_core as all_code
 import warnings
 import os
 
diff --git a/pyqpanda-algorithm/example/QAlgBase/testeg_class_qsvr.py b/pyqpanda-algorithm/example/QAlgBase/testeg_class_qsvr.py
index aed2cf11..9f4af9fb 100644
--- a/pyqpanda-algorithm/example/QAlgBase/testeg_class_qsvr.py
+++ b/pyqpanda-algorithm/example/QAlgBase/testeg_class_qsvr.py
@@ -1,13 +1,12 @@
-from pyqpanda_alg.QFinance import class_qsvr
-import sympy as sp
 import numpy as np
-import pyqpanda as pq
+
+from pyqpanda_alg.QSVR import Quantum_SVR
+
 
 if __name__ == '__main__':
-    
     n_samples = 100
     n_features = 2
     X = np.random.rand(n_samples, n_features) * 10
     y = (2 * np.sin(X[:, 0]) +
          1.5 * np.cos(X[:, 1]))
-    class_qsvr.Quantum_SVR(X, y).show_res()
\ No newline at end of file
+    Quantum_SVR(X, y).show_res()
diff --git a/pyqpanda-algorithm/example/QAlgBase/testeg_comparator.py b/pyqpanda-algorithm/example/QAlgBase/testeg_comparator.py
index 2687e462..f887c9b7 100644
--- a/pyqpanda-algorithm/example/QAlgBase/testeg_comparator.py
+++ b/pyqpanda-algorithm/example/QAlgBase/testeg_comparator.py
@@ -1,44 +1,48 @@
-from pyqpanda_alg.QFinance import comparator
-import pyqpanda as pq
+from pyqpanda3.core import CPUQVM, QCircuit, QProg, H, X
+
+from pyqpanda_alg import QCmp
 
 
 if __name__ == '__main__':
     # 整数比较
     value = 3
-    m = pq.CPUQVM()
-    m.initQVM()
-    q_state = m.qAlloc_many(2)
-    q_anc_cmp = m.qAlloc_many(2)
-    prog = pq.QProg()
-    prog << pq.H(q_state)
-    cir = comparator.int_comparator(value, q_state, q_anc_cmp, function='g', reuse=True)
+    m = CPUQVM()
+    q_state = [0, 1]
+    q_anc_cmp = [2, 3]
+    prog = QProg()
+    cir = QCircuit()
+    for q in q_state:
+        cir << H(q)
+    cir << QCmp.int_comparator(value, q_state, q_anc_cmp, function='g', reuse=True)
     prog << cir
-    res = m.prob_run_dict(prog, [q_anc_cmp[-1]])
-    print(res)
+    m.run(prog, 1000)
+    print(m.result().get_prob_dict([q_anc_cmp[-1]]))
 
     # 插值方法
     value = 3.3
-    m = pq.CPUQVM()
-    m.initQVM()
-    q_state = m.qAlloc_many(3)
-    q_anc_cmp = m.qAlloc_many(3)
-    prog = pq.QProg()
-    prog << pq.X(q_state[:2])
-    cir = comparator.interpolation_comparator(value, q_state, q_anc_cmp, function='g', reuse=True)
+    m = CPUQVM()
+    q_state = [0, 1, 2]
+    q_anc_cmp = [3, 4, 5]
+    prog = QProg()
+    cir = QCircuit()
+    for q in q_state[:2]:
+        cir << X(q)
+    cir << QCmp.interpolation_comparator(value, q_state, q_anc_cmp, function='g', reuse=True)
     prog << cir
-    res = m.prob_run_dict(prog, [q_anc_cmp[-1]])
-    print(res)
+    m.run(prog, 1000)
+    print(m.result().get_prob_dict([q_anc_cmp[-1]]))
 
     # 两个态比较，示例中叠加态的0，1，2，3有0.5的概率大于态1
-    m = pq.CPUQVM()
-    m.initQVM()
-    q_state_1 = m.qAlloc_many(2)
-    q_state_2 = m.qAlloc_many(2)
-    q_anc_cmp = m.qAlloc_many(2)
-    prog = pq.QProg()
-    prog << pq.H(q_state_1)
-    prog << pq.X(q_state_2[0])
-    cir = comparator.qubit_comparator(q_state_1, q_state_2, q_anc_cmp, function='g')
+    m = CPUQVM()
+    q_state_1 = [0, 1]
+    q_state_2 = [2, 3]
+    q_anc_cmp = [4, 5]
+    prog = QProg()
+    cir = QCircuit()
+    for q in q_state_1:
+        cir << H(q)
+    cir << X(q_state_2[0])
+    cir << QCmp.qubit_comparator(q_state_1, q_state_2, q_anc_cmp, function='g')
     prog << cir
-    res = m.prob_run_dict(prog, [q_anc_cmp[-1]])
-    print(res)
\ No newline at end of file
+    m.run(prog, 1000)
+    print(m.result().get_prob_dict([q_anc_cmp[-1]]))
diff --git a/pyqpanda-algorithm/example/QAlgBase/testeg_grover_markdata.py b/pyqpanda-algorithm/example/QAlgBase/testeg_grover_markdata.py
index 716d8e87..c0566c02 100644
--- a/pyqpanda-algorithm/example/QAlgBase/testeg_grover_markdata.py
+++ b/pyqpanda-algorithm/example/QAlgBase/testeg_grover_markdata.py
@@ -1,24 +1,24 @@
-import pyqpanda as pq
-from pyqpanda_alg.QFinance import grover
+from pyqpanda3.core import CPUQVM, QProg
+
+from pyqpanda_alg.Grover import Grover, mark_data_reflection, iter_num, iter_analysis
 
 
 if __name__ == '__main__':
-    m = pq.CPUQVM()
-    m.initQVM()
-    q_state = m.qAlloc_many(3)
+    m = CPUQVM()
+    q_state = QProg(3).qubits()
 
     def mark(qubits):
-        return grover.mark_data_reflection(qubits=qubits, mark_data=['101', '001'])
-
+        return mark_data_reflection(qubits=qubits, mark_data=['101', '001'])
 
-    demo_search = grover.Grover(flip_operator=mark)
-    # iter_num = grover.iter_num(q_num=len(q_state), sol_num=2)
-    # print('best iter num: ', iter_num)
-    # prob, angle = grover.iter_analysis(q_num=len(q_state), sol_num=2, iternum=iter_num)
-    # print('prob for getting one of the solution with given iter num:', prob)
+    demo_search = Grover(flip_operator=mark)
+    best_iter = iter_num(q_num=len(q_state), sol_num=2)
+    print('best iter num: ', best_iter)
+    prob, angle = iter_analysis(q_num=len(q_state), sol_num=2, iternum=best_iter)
+    print('prob for getting one of the solution with given iter num:', prob)
 
-    prog = pq.QProg()
+    prog = QProg()
     prog << demo_search.cir(q_input=q_state)
 
-    res = m.prob_run_dict(prog, q_state)
-    print(res)
\ No newline at end of file
+    m.run(prog, 1000)
+    res = m.result().get_prob_dict(q_state)
+    print(res)
diff --git a/pyqpanda-algorithm/example/QAlgBase/testeg_t_spare.py b/pyqpanda-algorithm/example/QAlgBase/testeg_t_spare.py
index dc040b17..05f4aa9c 100644
--- a/pyqpanda-algorithm/example/QAlgBase/testeg_t_spare.py
+++ b/pyqpanda-algorithm/example/QAlgBase/testeg_t_spare.py
@@ -1,6 +1,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
-from pyqpanda_alg.QFinance.class_basic_sparecode import QSpare_Code
+from pyqpanda_alg.QSEncode import QSpare_Code
 def t01():
     mu = 0
     sigma = 1
diff --git a/pyqpanda-algorithm/pyqpanda_alg/Grover/Grover_core.py b/pyqpanda-algorithm/pyqpanda_alg/Grover/Grover_core.py
index 0d2c2b3c..adde333c 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/Grover/Grover_core.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/Grover/Grover_core.py
@@ -81,7 +81,7 @@ def cir(self, q_input=None, q_flip=None, q_zero=None, iternum: int = 1):
         Examples
             An example for implementing an Grover search for state where q_0 `and` q_1 is 1.
 
-        >>> from pyqpanda3.core import CPUQVM, QCircuit, Z, TOFFOLI
+        >>> from pyqpanda3.core import CPUQVM, QCircuit, QProg, Z, TOFFOLI
         >>> from pyqpanda_alg import Grover
         >>> m = CPUQVM()
         >>> q_state = list(range(3))
diff --git a/pyqpanda-algorithm/pyqpanda_alg/Grover/__init__.py b/pyqpanda-algorithm/pyqpanda_alg/Grover/__init__.py
index d7eaf56f..ddf10127 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/Grover/__init__.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/Grover/__init__.py
@@ -1,5 +1,6 @@
 '''
-The QFinance module provides tools related to comparator, Quantum amplitude estimation, Grover algorithm, Grover optimization algorithm and QUBO problem solver, which are used to solve problems such as option pricing and portfolio optimization.
+The Grover module provides Grover search, its amplitude amplification operator and
+Grover adaptive search, used for unstructured search and combinatorial optimization.
 '''
 
 from .Grover_core import Grover,amp_operator,GroverAdaptiveSearch,mark_data_reflection,iter_num,iter_analysis
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QAE/QAE.py b/pyqpanda-algorithm/pyqpanda_alg/QAE/QAE.py
index e126c0e6..9d163243 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QAE/QAE.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QAE/QAE.py
@@ -349,7 +349,6 @@ def run(self):
     def _measure(self, k: int, n_round: int) -> int:
         machine = self.machine
         qlist = self.qlist
-        clist = self.clist
 
         operator_g = amp_operator(in_operator=self.operatorA, q_input=qlist)
         prog = QProg()
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QAOA/qaoa.py b/pyqpanda-algorithm/pyqpanda_alg/QAOA/qaoa.py
index 688e01e3..210f4217 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QAOA/qaoa.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QAOA/qaoa.py
@@ -482,7 +482,6 @@ def run_qaoa_circuit(self, gammas, betas, shots=-1):
 
         .. code-block:: python
 
-            import pyqpanda as pq
             import sympy as sp
             from pyqpanda_alg.QAOA.qaoa import *
 
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QKmeans/QuantumKmeans.py b/pyqpanda-algorithm/pyqpanda_alg/QKmeans/QuantumKmeans.py
index 83d75d5f..577f836d 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QKmeans/QuantumKmeans.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QKmeans/QuantumKmeans.py
@@ -160,7 +160,6 @@ def fit(self, data):
 
 
         """
-        n = data.shape[0]
         c = data.shape[1]
 
         mean = np.mean(data, axis=0)
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QSVD/QSVD.py b/pyqpanda-algorithm/pyqpanda_alg/QSVD/QSVD.py
index d43f868e..e73df976 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QSVD/QSVD.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QSVD/QSVD.py
@@ -153,7 +153,6 @@ def return_diag(self, par):
         return abs(res)
 
     def max_eig(self, return_mat='0', par=None, max_index=0):
-        machine = CPUQVM()
         cir = QCircuit()
         ss = max_index % 2**self.q0
         bi0 = '{:b}'.format(ss).rjust(self.q0, '0')
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QSVM/quantum_kernel_svm.py b/pyqpanda-algorithm/pyqpanda_alg/QSVM/quantum_kernel_svm.py
index 562976b1..763c0f84 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QSVM/quantum_kernel_svm.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QSVM/quantum_kernel_svm.py
@@ -209,7 +209,6 @@ def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray:
 
                 import os
                 import numpy as np
-                import pyqpanda as pq
                 from sklearn.svm import SVC
                 import matplotlib
                 try:
@@ -350,8 +349,6 @@ def qsvm_classification():
             mus = np.asarray(mus.flat)
             nus = np.asarray(nus.flat)
 
-        is_statevector_sim = False
-        measurement = not is_statevector_sim
         measurement_basis = "0" * self._n_qbits
 
         for idx in range(0, len(mus), self._batch_size):
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QUBO/QUBO.py b/pyqpanda-algorithm/pyqpanda_alg/QUBO/QUBO.py
index 576f1034..841fa664 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QUBO/QUBO.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QUBO/QUBO.py
@@ -120,8 +120,6 @@ def query_qnumber(self) -> List[int]:
         """
         n_key = np.max([1, len(self.linear), len(self.quadratic)])
 
-        bounds = []
-
         def pos(x): return x > 0
         def neg(x): return x < 0
 
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QmRMR/__init__.py b/pyqpanda-algorithm/pyqpanda_alg/QmRMR/__init__.py
index f02afa3e..6979f503 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/QmRMR/__init__.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/QmRMR/__init__.py
@@ -1,8 +1,9 @@
 '''
-The QFinance module provides tools related to comparator, Quantum amplitude estimation, Grover algorithm, Grover optimization algorithm and QUBO problem solver, which are used to solve problems such as option pricing and portfolio optimization.
+The QmRMR module provides quantum minimum-redundancy maximum-relevance feature
+selection, used to select an informative and non-redundant feature subset.
 '''
 
 
 from .QmRMR_core import Feature_Selection 
 
-__all__ = [Feature_Selection]
+__all__ = ['Feature_Selection']
diff --git a/pyqpanda-algorithm/pyqpanda_alg/plugin.py b/pyqpanda-algorithm/pyqpanda_alg/plugin.py
index 7e862152..7edb06a6 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/plugin.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/plugin.py
@@ -185,10 +185,11 @@ def qft(qubit_list: list[int]) -> QCircuit:
         >>> # << H(0)
         >>> 
         >>> # 嵌入主程序执行
-        >>> qvm = pq.QMachine(pq.QMachineType.CPU)
-        >>> main_prog = pq.QProg()
+        >>> from pyqpanda3.core import CPUQVM, QProg
+        >>> qvm = CPUQVM()
+        >>> main_prog = QProg()
         >>> main_prog << qft_circuit  # 添加QFT电路
-        >>> qvm.run(main_prog)
+        >>> qvm.run(main_prog, 1000)
     """
     pi = 3.141592653589793238462643383279502884
     
@@ -260,9 +261,10 @@ def QFT(qubit_list: list[int]) -> QCircuit:
         >>> # 交换部分：SWAP(0,2)
         >>> 
         >>> # 嵌入主程序执行
-        >>> qvm = pq.QMachine(pq.QMachineType.CPU)
-        >>> main_prog = pq.QProg() << qft_circuit
-        >>> qvm.run(main_prog)
+        >>> from pyqpanda3.core import CPUQVM, QProg
+        >>> qvm = CPUQVM()
+        >>> main_prog = QProg() << qft_circuit
+        >>> qvm.run(main_prog, 1000)
     """
     pi = 3.141592653589793238462643383279502884
     
@@ -331,9 +333,10 @@ def bind_nonnegative_data(value: int, qubit_list: list[int]) -> QCircuit:
         >>> # 电路包含：X(0) << X(2)（对应二进制101，低位在前）
         >>> 
         >>> # 验证：量子比特0和2被翻转为|1⟩，1保持|0⟩
-        >>> qvm = pq.QMachine(pq.QMachineType.CPU)
-        >>> main_prog = pq.QProg() << circuit
-        >>> qvm.run(main_prog)
+        >>> from pyqpanda3.core import CPUQVM, QProg
+        >>> qvm = CPUQVM()
+        >>> main_prog = QProg() << circuit
+        >>> qvm.run(main_prog, 1000)
     """
     # 输入验证：value必须为非负整数
     if not isinstance(value, int):
@@ -407,16 +410,16 @@ def parse_quantum_result_dict(result: Dict[str, float], qubit_list: List[int], s
         >>> qubit_list = [0, 1, 2]
         >>> 
         >>> # 1. 返回所有结果
-        >>> parse_quantum_result(raw_result, qubit_list)
+        >>> parse_quantum_result_dict(raw_result, qubit_list)
         {'000': 0.1, '111': 0.8, '010': 0.1}
         >>> 
         >>> # 2. 返回概率最高的1个结果
-        >>> parse_quantum_result(raw_result, qubit_list, select_max=1)
+        >>> parse_quantum_result_dict(raw_result, qubit_list, select_max=1)
         {'111': 0.8}
         >>> 
         >>> # 3. 返回概率最高的2个结果
-        >>> parse_quantum_result(raw_result, qubit_list, select_max=2)
-        {'111': 0.8, '000': 0.1, '010': 0.1}  # 概率相同则保留原始顺序
+        >>> parse_quantum_result_dict(raw_result, qubit_list, select_max=2)
+        {'111': 0.8, '000': 0.1}  # 概率相同则保留原始顺序
     """
     # 输入类型验证
     if not isinstance(result, dict):