用python写一个“KDJ+DMI”的量化策略，数据从askshare获取，需要注明入场条件，离场条件，购买规模，止盈条件，止损条件，并用backtrader进行回测。

KDJ+DMI量化策略是一种基于技术指标的交易策略，结合了KDJ指标和DMI指标的信号，来进行买卖决策。在这里，我们使用Python和backtrader进行回测，数据从askshare获取。

入场条件：

1. 当K线的K值大于D值，即K线向上突破D线时，为买入信号。

2. 当DMI指标中的+DI线上穿-DI线，即上升趋势中的多头力量增强时，为买入信号。

离场条件：

1. 当K线的K值小于D值，即K线向下跌破D线时，为卖出信号。

2. 当DMI指标中的-DI线上穿+DI线，即下降趋势中的空头力量增强时，为卖出信号。

购买规模：

1. 固定手数买入：在买入时，固定买入一定数量的股票。

2. 固定比例买入：在买入时，买入资金的一定比例，如买入总资金的50%。

止盈条件：

1. 固定百分比止盈：当盈利达到一定比例时，自动卖出。

2. 移动止盈：根据股票价格的变化，不断调整止盈价位。

止损条件：

1. 固定百分比止损：当亏损达到一定比例时，自动卖出。

2. 移动止损：根据股票价格的变化，不断调整止损价位。

接下来是代码实现：

import backtrader as bt
import requests
import pandas as pd

# 下载数据
symbol = "AAPL"
url = f"https://stockdataapi.askpython.com/api/v1/history?symbol={symbol}"
response = requests.get(url)
data = response.json()["data"]
df = pd.DataFrame.from_dict(data)
df = df.set_index("date")
df = df.sort_index()

# 计算KDJ指标
def compute_kdj(df):
    high = df["high"].rolling(window=9).max()
    low = df["low"].rolling(window=9).min()
    rsv = (df["close"] - low) / (high - low) * 100
    df["K"] = rsv.ewm(com=2).mean()
    df["D"] = df["K"].ewm(com=2).mean()
    df["J"] = 3 * df["K"] - 2 * df["D"]
    return df

# 计算DMI指标
def compute_dmi(df):
    df["TR"] = pd.DataFrame([df["high"] - df["low"], abs(df["high"] - df["close"].shift(1)), abs(df["low"] - df["close"].shift(1))]).T.max(axis=1)
    df["+DM"] = np.where((df["high"] - df["high"].shift(1)) > (df["low"].shift(1) - df["low"]), df["high"] - df["high"].shift(1), 0)
    df["+DM"] = np.where(df["+DM"] < 0, 0, df["+DM"])
    df["-DM"] = np.where((df["low"].shift(1) - df["low"]) > (df["high"] - df["high"].shift(1)), df["low"].shift(1) - df["low"], 0)
    df["-DM"] = np.where(df["-DM"] < 0, 0, df["-DM"])
    df["+DI"] = df["+DM"].rolling(window=14).sum() / df["TR"].rolling(window=14).sum() * 100
    df["-DI"] = df["-DM"].rolling(window=14).sum() / df["TR"].rolling(window=14).sum() * 100
    df["ADX"] = df["TR"].rolling(window=14).sum() / 14
    df["ADX"] = df["ADX"].rolling(window=14).apply(lambda x: x[13], raw=True)
    df["ADX"] = np.where(df["ADX"] > 0, df["ADX"], 0)
    return df

class KDJDMI(bt.Strategy):
    params = (
        ("stop_loss", 0.05),
        ("take_profit", 0.10),
        ("size", 100),
    )

    def __init__(self):
        self.buy_signal = bt.indicators.CrossOver(self.data.K, self.data.D)
        self.sell_signal = bt.indicators.CrossDown(self.data.K, self.data.D)
        self.buy_signal_dmi = bt.indicators.CrossOver(self.data["+DI"], self.data["-DI"])
        self.sell_signal_dmi = bt.indicators.CrossDown(self.data["-DI"], self.data["+DI"])
        self.position = None

    def next(self):
        if self.position is None:
            if self.buy_signal[0] == 1 and self.buy_signal_dmi[0] == 1:
                self.position = self.buy(size=self.params.size)
        else:
            if self.sell_signal[0] == 1 and self.sell_signal_dmi[0] == 1:
                self.sell(size=self.params.size)
                self.position = None
            else:
                stop_loss_price = self.position.price * (1 - self.params.stop_loss)
                take_profit_price = self.position.price * (1 + self.params.take_profit)
                if self.position.size > 0:
                    if self.data.close[0] <= stop_loss_price:
                        self.sell(size=self.position.size)
                        self.position = None
                    elif self.data.close[0] >= take_profit_price:
                        self.sell(size=self.position.size)
                        self.position = None
                elif self.position.size < 0:
                    if self.data.close[0] >= stop_loss_price:
                        self.buy(size=self.params.size)
                        self.position = None
                    elif self.data.close[0] <= take_profit_price:
                        self.buy(size=self.params.size)
                        self.position = None

cerebro = bt.Cerebro()

# 添加数据
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)

# 添加策略
cerebro.addstrategy(KDJDMI)

# 设置初始资金
cerebro.broker.setcash(100000)

# 设置手续费
cerebro.broker.setcommission(commission=0.002)

# 运行回测
cerebro.run()

# 打印回测结果
print(f"Final Portfolio Value: {cerebro.broker.getvalue():,.2f}")

在上面的代码中，我们定义了一个名为KDJDMI的策略类，其中包括了入场条件、离场条件、购买规模、止盈条件和止损条件等。在回测时，我们使用backtrader框架，将数据添加进去，添加策略，并设置初始资金和手续费等参数，然后运行回测并输出结果。

需要注意的是，这里的策略仅供参考，实际使用时需要根据具体的需求进行调整和优化。同时，股票投资有风险，切勿盲目跟进策略，需谨慎考虑后再做决策。