c2.py

# -*- encoding:utf-8 -*-
from __future__ import print_function

import logging
import warnings
from abc import ABCMeta, abstractmethod
from collections import OrderedDict
from collections import namedtuple
import itertools
# noinspection PyCompatibility
from concurrent.futures import ProcessPoolExecutor
# noinspection PyCompatibility
from concurrent.futures import ThreadPoolExecutor

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

# noinspection PyUnresolvedReferences
import abu_local_env
import abupy
from abupy import six, xrange, range, reduce, map, filter, partial
from abupy import ABuSymbolPd

warnings.filterwarnings('ignore')
sns.set_context(rc={'figure.figsize': (14, 7)})
# 使用沙盒数据，目的是和书中一样的数据环境
abupy.env.enable_example_env_ipython()


"""
    第二章 量化语言——Python

    abu量化系统github地址：https://github.com/bbfamily/abu (您的star是我的动力！)
    abu量化文档教程ipython notebook：https://github.com/bbfamily/abu/tree/master/abupy_lecture
"""


def sample_211():
    """
    量化语言-Python
    :return:
    """
    price_str = '30.14, 29.58, 26.36, 32.56, 32.82'
    print('type(price_str):', type(price_str))

    if not isinstance(price_str, str):
        # not代表逻辑‘非’， 如果不是字符串，转换为字符串
        price_str = str(price_str)
    if isinstance(price_str, int) and price_str > 0:
        # and 代表逻辑‘与’，如果是int类型且是正数
        price_str += 1
    elif isinstance(price_str, float) or float(price_str[:4]) < 0:
        # or 代表逻辑‘或’，如果是float或者小于0
        price_str += 1.0
    else:
        try:
            raise TypeError('price_str is str type!')
        except TypeError:
            print('raise, try except')


def sample_212(show=True):
    """
    2.1.2 字符串和容器
    :return:
    """
    show_func = print if show else lambda a: a
    price_str = '30.14, 29.58, 26.36, 32.56, 32.82'
    show_func('旧的price_str id= {}'.format(id(price_str)))
    price_str = price_str.replace(' ', '')
    show_func('新的price_str id= {}'.format(id(price_str)))
    show_func(price_str)
    # split以逗号分割字符串，返回数组price_array
    price_array = price_str.split(',')
    show_func(price_array)
    # price_array尾部append一个重复的32.82
    price_array.append('32.82')
    show_func(price_array)
    show_func(set(price_array))
    price_array.remove('32.82')
    show_func(price_array)

    date_array = []
    date_base = 20170118
    # 这里用for只是为了计数，无用的变量python建议使用'_'声明
    for _ in xrange(0, len(price_array)):
        date_array.append(str(date_base))
        # 本节只是简单示例，不考虑日期的进位
        date_base += 1
    show_func(date_array)

    date_base = 20170118
    date_array = [str(date_base + ind) for ind, _ in enumerate(price_array)]
    show_func(date_array)

    stock_tuple_list = [(date, price) for date, price in zip(date_array, price_array)]
    # tuple访问使用索引
    show_func('20170119日价格：{}'.format(stock_tuple_list[1][1]))
    show_func(stock_tuple_list)

    stock_namedtuple = namedtuple('stock', ('date', 'price'))
    stock_namedtuple_list = [stock_namedtuple(date, price) for date, price in zip(date_array, price_array)]
    # namedtuple访问使用price
    show_func('20170119日价格：{}'.format(stock_namedtuple_list[1].price))
    show_func(stock_namedtuple_list)

    # 字典推导式：{key: value for in}
    stock_dict = {date: price for date, price in zip(date_array, price_array)}
    show_func('20170119日价格：{}'.format(stock_dict['20170119']))
    show_func(stock_dict)

    show_func(stock_dict.keys())

    stock_dict = OrderedDict((date, price) for date, price in zip(date_array, price_array))
    show_func(stock_dict.keys())
    return stock_dict


def sample_221():
    """
    2.2.1 函数的使用和定义
    :return:
    """
    stock_dict = sample_212(show=False)
    print('min(stock_dict):', min(stock_dict))
    print('min(zip(stock_dict.values(), stock_dict.keys())):', min(zip(stock_dict.values(), stock_dict.keys())))

    def find_second_max(dict_array):
        # 对传入的dict sorted排序
        stock_prices_sorted = sorted(zip(dict_array.values(), dict_array.keys()))
        # 第二大的也就是倒数第二个
        return stock_prices_sorted[-2]

    # 系统函数callable验证是否为一个可call的函数
    if callable(find_second_max):
        print('find_second_max(stock_dict):', find_second_max(stock_dict))


def sample_222():
    """
    2.2.2 lambda函数
    :return:
    """
    stock_dict = sample_212(show=False)

    find_second_max_lambda = lambda dict_array: sorted(zip(dict_array.values(), dict_array.keys()))[-2]
    print('find_second_max_lambda(stock_dict):', find_second_max_lambda(stock_dict))

    def find_max_and_min(dict_array):
        # 对传入的dict sorted排序R
        stock_prices_sorted = sorted(zip(dict_array.values(), dict_array.keys()))
        return stock_prices_sorted[0], stock_prices_sorted[-1]

    print('find_max_and_min(stock_dict):', find_max_and_min(stock_dict))


def sample_223(show=True):
    """
    2.2.3 高阶函数
    :return:
    """
    stock_dict = sample_212(show=False)

    show_func = print if show else lambda a: a

    # 将字符串的的价格通过列表推导式显示转换为float类型
    # 由于stock_dict是OrderedDict所以才可以直接
    # 使用stock_dict.values()获取有序日期的收盘价格
    price_float_array = [float(price_str) for price_str in stock_dict.values()]
    # 通过将时间平移形成两个错开的收盘价序列，通过zip打包成为一个新的序列，
    # 通过[:-1]:从第0个到倒数第二个，[1:]：从第一个到最后一个 错开形成相邻
    # 组成的序列每个元素为相邻的两个收盘价格
    pp_array = [(price1, price2) for price1, price2 in zip(price_float_array[:-1], price_float_array[1:])]
    show_func(pp_array)
    # list for python3
    change_array = list(map(lambda pp: reduce(lambda a, b: round((b - a) / a, 3), pp), pp_array))
    # list insert插入数据，将第一天的涨跌幅设置为0
    change_array.insert(0, 0)
    show_func(change_array)

    price_str = '30.14, 29.58, 26.36, 32.56, 32.82'
    price_str = price_str.replace(' ', '')
    price_array = price_str.split(',')

    date_base = 20170118
    date_array = [str(date_base + ind) for ind, _ in enumerate(price_array)]

    # 使用namedtuple重新构建数据结构
    stock_namedtuple = namedtuple('stock', ('date', 'price', 'change'))
    # 通过zip分别从date_array，price_array，change_array拿数据组成
    # stock_namedtuple然后以date做为key组成OrderedDict
    stock_dict = OrderedDict((date, stock_namedtuple(date, price, change)) for date, price, change in
                             zip(date_array, price_array, change_array))
    show_func(stock_dict)
    # list for python3
    up_days = list(filter(lambda day: day.change > 0, stock_dict.values()))
    show_func(up_days)

    def filter_stock(stock_array_dict, want_up=True, want_calc_sum=False):
        if not isinstance(stock_array_dict, OrderedDict):
            raise TypeError('stock_array_dict must be OrderedDict!')

        # python中的三目表达式的写法
        filter_func = (lambda p_day: p_day.change > 0) if want_up else (lambda p_day: p_day.change < 0)
        # 使用filter_func做筛选函数
        want_days = list(filter(filter_func, stock_array_dict.values()))

        if not want_calc_sum:
            return want_days

        # 需要计算涨跌幅和
        change_sum = 0.0
        for day in want_days:
            change_sum += day.change
        return change_sum

    # 全部使用默认参数
    show_func('所有上涨的交易日：{}'.format(filter_stock(stock_dict)))
    # want_up=False
    show_func('所有下跌的交易日：{}'.format(filter_stock(stock_dict, want_up=False)))
    # 计算所有上涨的总会
    show_func('所有上涨交易日的涨幅和：{}'.format(filter_stock(stock_dict, want_calc_sum=True)))
    # 计算所有下跌的总会
    show_func('所有下跌交易日的跌幅和：{}'.format(filter_stock(stock_dict, want_up=False, want_calc_sum=True)))
    return stock_dict


def sample_224():
    """
    2.2.4 偏函数
    :return:
    """
    stock_dict = sample_223(show=False)

    def filter_stock(stock_array_dict, want_up=True, want_calc_sum=False):
        if not isinstance(stock_array_dict, OrderedDict):
            raise TypeError('stock_array_dict must be OrderedDict!')

        # python中的三目表达式的写法
        filter_func = (lambda p_day: p_day.change > 0) if want_up else (lambda p_day: p_day.change < 0)
        # 使用filter_func做筛选函数
        want_days = list(filter(filter_func, stock_array_dict.values()))

        if not want_calc_sum:
            return want_days

        # 需要计算涨跌幅和
        change_sum = 0.0
        for day in want_days:
            change_sum += day.change
        return change_sum

    filter_stock_up_days = partial(filter_stock, want_up=True, want_calc_sum=False)
    filter_stock_down_days = partial(filter_stock, want_up=False, want_calc_sum=False)
    filter_stock_up_sums = partial(filter_stock, want_up=True, want_calc_sum=True)
    filter_stock_down_sums = partial(filter_stock, want_up=False, want_calc_sum=True)

    print('所有上涨的交易日：{}'.format(filter_stock_up_days(stock_dict)))
    print('所有下跌的交易日：{}'.format(filter_stock_down_days(stock_dict)))
    print('所有上涨交易日的涨幅和：{}'.format(filter_stock_up_sums(stock_dict)))
    print('所有下跌交易日的跌幅和：{}'.format(filter_stock_down_sums(stock_dict)))


"""
    2.3 面向对象
"""


class StockTradeDays(object):
    def __init__(self, price_array, start_date, date_array=None):
        # 私有价格序列
        self.__price_array = price_array
        # 私有日期序列
        self.__date_array = self._init_days(start_date, date_array)
        # 私有涨跌幅序列
        self.__change_array = self.__init_change()
        # 进行OrderedDict的组装
        self.stock_dict = self._init_stock_dict()

    def __init_change(self):
        """
        从price_array生成change_array
        :return:
        """
        price_float_array = [float(price_str) for price_str in
                             self.__price_array]
        # 通过将时间平移形成两个错开的收盘价序列，通过zip打包成为一个新的序列
        # 每个元素为相邻的两个收盘价格
        pp_array = [(price1, price2) for price1, price2 in
                    zip(price_float_array[:-1], price_float_array[1:])]
        # list for python3
        change_array = list(map(lambda pp: reduce(lambda a, b: round((b - a) / a, 3), pp), pp_array))
        # list insert插入数据，将第一天的涨跌幅设置为0
        change_array.insert(0, 0)
        return change_array

    def _init_days(self, start_date, date_array):
        """
        protect方法，
        :param start_date: 初始日期
        :param date_array: 给定日期序列
        :return:
        """
        if date_array is None:
            # 由start_date和self.__price_array来确定日期序列
            date_array = [str(start_date + ind) for ind, _ in
                          enumerate(self.__price_array)]
        else:
            # 稍后的内容会使用外部直接设置的方式
            # 如果外面设置了date_array，就直接转换str类型组成新date_array
            date_array = [str(date) for date in date_array]
        return date_array

    def _init_stock_dict(self):
        """
        使用namedtuple，OrderedDict将结果合并
        :return:
        """
        stock_namedtuple = namedtuple('stock',
                                      ('date', 'price', 'change'))

        # 使用以被赋值的__date_array等进行OrderedDict的组装
        stock_dict = OrderedDict(
            (date, stock_namedtuple(date, price, change))
            for date, price, change in
            zip(self.__date_array, self.__price_array,
                self.__change_array))
        return stock_dict

    def filter_stock(self, want_up=True, want_calc_sum=False):
        """
        筛选结果子集
        :param want_up: 是否筛选上涨
        :param want_calc_sum: 是否计算涨跌和
        :return:
        """
        # Python中的三目表达式的写法
        filter_func = (lambda p_day: p_day.change > 0) if want_up else (
            lambda p_day: p_day.change < 0)
        # 使用filter_func做筛选函数
        want_days = list(filter(filter_func, self.stock_dict.values()))

        if not want_calc_sum:
            return want_days

        # 需要计算涨跌幅和
        change_sum = 0.0
        for day in want_days:
            change_sum += day.change
        return change_sum

    """
        下面的__str__，__iter__， __getitem__， __len__稍后会详细讲解作
    """

    def __str__(self):
        return str(self.stock_dict)

    __repr__ = __str__

    def __iter__(self):
        """
        通过代理stock_dict的跌倒，yield元素
        :return:
        """
        for key in self.stock_dict:
            yield self.stock_dict[key]

    def __getitem__(self, ind):
        date_key = self.__date_array[ind]
        return self.stock_dict[date_key]

    def __len__(self):
        return len(self.stock_dict)


def sample_231():
    """
    2.3.1 类的封装
    :return:
    """
    price_array = '30.14,29.58,26.36,32.56,32.82'.split(',')
    date_base = 20170118
    # 从StockTradeDays类初始化一个实例对象trade_days，内部会调用__init__
    trade_days = StockTradeDays(price_array, date_base)
    # 打印对象信息
    print('trade_days:', trade_days)
    print('trade_days对象长度为: {}'.format(len(trade_days)))

    from collections import Iterable
    # 如果是trade_days是可迭代对象，依次打印出
    if isinstance(trade_days, Iterable):
        for day in trade_days:
            print(day)

    print(trade_days.filter_stock())

    # 两年的TSLA收盘数据 to list
    price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
    # 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
    date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
    print('price_array[:5], date_array[:5]:', price_array[:5], date_array[:5])
    trade_days = StockTradeDays(price_array, date_base, date_array)
    print('trade_days对象长度为: {}'.format(len(trade_days)))
    print('最后一天交易数据为：{}'.format(trade_days[-1]))


"""
    2.3.2 继承和多态
"""


class TradeStrategyBase(six.with_metaclass(ABCMeta, object)):
    """
        交易策略抽象基类
    """

    @abstractmethod
    def buy_strategy(self, *args, **kwargs):
        # 买入策略基类
        pass

    @abstractmethod
    def sell_strategy(self, *args, **kwargs):
        # 卖出策略基类
        pass


class TradeStrategy1(TradeStrategyBase):
    """
        交易策略1: 追涨策略，当股价上涨一个阀值默认为7%时
        买入股票并持有s_keep_stock_threshold（20）天
    """
    s_keep_stock_threshold = 20

    def __init__(self):
        self.keep_stock_day = 0
        # 7%上涨幅度作为买入策略阀值
        self.__buy_change_threshold = 0.07

    def buy_strategy(self, trade_ind, trade_day, trade_days):
        if self.keep_stock_day == 0 and \
                        trade_day.change > self.__buy_change_threshold:

            # 当没有持有股票的时候self.keep_stock_day == 0 并且
            # 符合买入条件上涨一个阀值，买入
            self.keep_stock_day += 1
        elif self.keep_stock_day > 0:
            # self.keep_stock_day > 0代表持有股票，持有股票天数递增
            self.keep_stock_day += 1

    def sell_strategy(self, trade_ind, trade_day, trade_days):
        if self.keep_stock_day >= \
                TradeStrategy1.s_keep_stock_threshold:
            # 当持有股票天数超过阀值s_keep_stock_threshold，卖出股票
            self.keep_stock_day = 0

    """
        property属性稍后会讲到
    """

    @property
    def buy_change_threshold(self):
        return self.__buy_change_threshold

    @buy_change_threshold.setter
    def buy_change_threshold(self, buy_change_threshold):
        if not isinstance(buy_change_threshold, float):
            """
                上涨阀值需要为float类型
            """
            raise TypeError('buy_change_threshold must be float!')
        # 上涨阀值只取小数点后两位
        self.__buy_change_threshold = round(buy_change_threshold, 2)


class TradeLoopBack(object):
    """
        交易回测系统
    """

    def __init__(self, trade_days, trade_strategy):
        """
        使用上一节封装的StockTradeDays类和本节编写的交易策略类
        TradeStrategyBase类初始化交易系统
        :param trade_days: StockTradeDays交易数据序列
        :param trade_strategy: TradeStrategyBase交易策略
        """
        self.trade_days = trade_days
        self.trade_strategy = trade_strategy
        # 交易盈亏结果序列
        self.profit_array = []

    def execute_trade(self):
        """
        执行交易回测
        :return:
        """
        for ind, day in enumerate(self.trade_days):
            """
                以时间驱动，完成交易回测
            """
            if self.trade_strategy.keep_stock_day > 0:
                # 如果有持有股票，加入交易盈亏结果序列
                self.profit_array.append(day.change)

            # hasattr: 用来查询对象有没有实现某个方法
            if hasattr(self.trade_strategy, 'buy_strategy'):
                # 买入策略执行
                self.trade_strategy.buy_strategy(ind, day,
                                                 self.trade_days)

            if hasattr(self.trade_strategy, 'sell_strategy'):
                # 卖出策略执行
                self.trade_strategy.sell_strategy(ind, day,
                                                  self.trade_days)


def sample_232():
    """
    2.3.2 继承和多态
    :return:
    """
    # 两年的TSLA收盘数据 to list
    price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
    # 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
    date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
    trade_days = StockTradeDays(price_array, 0, date_array)

    trade_loop_back = TradeLoopBack(trade_days, TradeStrategy1())
    trade_loop_back.execute_trade()
    print('回测策略1 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))

    plt.plot(np.array(trade_loop_back.profit_array).cumsum())
    plt.show()


"""
    2.3.3 静态方法，类方法与property属性
"""


def sample_233_1():
    """
    2.3.3_1 property属性
    :return:
    """
    trade_strategy1 = TradeStrategy1()
    # 买入阀值从0.07上升到0.1
    trade_strategy1.buy_change_threshold = 0.1

    # 两年的TSLA收盘数据 to list
    price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
    # 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
    date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
    trade_days = StockTradeDays(price_array, 0, date_array)

    trade_loop_back = TradeLoopBack(trade_days, trade_strategy1)
    trade_loop_back.execute_trade()
    print('回测策略1 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
    # 可视化profit_array
    plt.plot(np.array(trade_loop_back.profit_array).cumsum())
    plt.show()


class TradeStrategy2(TradeStrategyBase):
    """
        交易策略2: 均值回复策略，当股价连续两个交易日下跌，
        且下跌幅度超过阀值默认s_buy_change_threshold(-10%)，
        买入股票并持有s_keep_stock_threshold（10）天
    """
    # 买入后持有天数
    s_keep_stock_threshold = 10
    # 下跌买入阀值
    s_buy_change_threshold = -0.10

    def __init__(self):
        self.keep_stock_day = 0

    def buy_strategy(self, trade_ind, trade_day, trade_days):
        if self.keep_stock_day == 0 and trade_ind >= 1:
            """
                当没有持有股票的时候self.keep_stock_day == 0 并且
                trade_ind >= 1, 不是交易开始的第一天，因为需要yesterday数据
            """
            # trade_day.change < 0 bool：今天是否股价下跌
            today_down = trade_day.change < 0
            # 昨天是否股价下跌
            yesterday_down = trade_days[trade_ind - 1].change < 0
            # 两天总跌幅
            down_rate = trade_day.change + trade_days[trade_ind - 1].change
            if today_down and yesterday_down and down_rate < \
                    TradeStrategy2.s_buy_change_threshold:
                # 买入条件成立：连跌两天，跌幅超过s_buy_change_threshold
                self.keep_stock_day += 1
        elif self.keep_stock_day > 0:
            # self.keep_stock_day > 0代表持有股票，持有股票天数递增
            self.keep_stock_day += 1

    def sell_strategy(self, trade_ind, trade_day, trade_days):
        if self.keep_stock_day >= \
                TradeStrategy2.s_keep_stock_threshold:
            # 当持有股票天数超过阀值s_keep_stock_threshold，卖出股票
            self.keep_stock_day = 0

    """
        稍后会详细讲解classmethod，staticmethod
    """

    @classmethod
    def set_keep_stock_threshold(cls, keep_stock_threshold):
        cls.s_keep_stock_threshold = keep_stock_threshold

    @staticmethod
    def set_buy_change_threshold(buy_change_threshold):
        TradeStrategy2.s_buy_change_threshold = buy_change_threshold


def sample_233_2():
    """
    2.3.3_2 静态类方法@classmethod与@staticmethod
    :return:
    """
    # 两年的TSLA收盘数据 to list
    price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
    # 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
    date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
    trade_days = StockTradeDays(price_array, 0, date_array)

    trade_strategy2 = TradeStrategy2()
    trade_loop_back = TradeLoopBack(trade_days, trade_strategy2)
    trade_loop_back.execute_trade()
    print('回测策略2 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
    plt.plot(np.array(trade_loop_back.profit_array).cumsum())
    plt.show()

    # 实例化一个新的TradeStrategy2类对象
    trade_strategy2 = TradeStrategy2()
    # 修改为买入后持有股票20天，默认为10天
    TradeStrategy2.set_keep_stock_threshold(20)
    # 修改股价下跌买入阀值为-0.08（下跌8%），默认为-0.10（下跌10%）
    TradeStrategy2.set_buy_change_threshold(-0.08)
    # 实例化新的回测对象trade_loop_back
    trade_loop_back = TradeLoopBack(trade_days, trade_strategy2)
    # 执行回测
    trade_loop_back.execute_trade()
    print('回测策略2 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
    # 可视化回测结果
    plt.plot(np.array(trade_loop_back.profit_array).cumsum())
    plt.show()


"""
    2.4 性能效率
"""


def sample_241_1():
    """
    2.4.1_1 itertools的使用
    :return:
    """
    items = [1, 2, 3]
    for item in itertools.permutations(items):
        print(item)

    for item in itertools.combinations(items, 2):
        print(item)

    for item in itertools.combinations_with_replacement(items, 2):
        print(item)

    ab = ['a', 'b']
    cd = ['c', 'd']
    # 针对ab，cd两个集合进行排列组合
    for item in itertools.product(ab, cd):
        print(item)


# 两年的TSLA收盘数据 to list
g_price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
g_date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
g_trade_days = StockTradeDays(g_price_array, 0, g_date_array)


def calc(keep_stock_threshold, buy_change_threshold):
    """
    :param keep_stock_threshold: 持股天数
    :param buy_change_threshold: 下跌买入阀值
    :return: 盈亏情况，输入的持股天数, 输入的下跌买入阀值
    """
    # 实例化TradeStrategy2
    trade_strategy2 = TradeStrategy2()
    # 通过类方法设置买入后持股天数
    TradeStrategy2.set_keep_stock_threshold(keep_stock_threshold)
    # 通过类方法设置下跌买入阀值
    TradeStrategy2.set_buy_change_threshold(buy_change_threshold)

    # 进行回测
    trade_loop_back = TradeLoopBack(g_trade_days, trade_strategy2)
    trade_loop_back.execute_trade()
    # 计算回测结果的最终盈亏值profit
    profit = 0.0 if len(trade_loop_back.profit_array) == 0 else \
        reduce(lambda a, b: a + b, trade_loop_back.profit_array)
    # 返回值profit和函数的两个输入参数
    return profit, keep_stock_threshold, buy_change_threshold


def sample_241_2():
    """
    2.4.1_2 笛卡尔积最优参数
    :return:
    """
    # range集合：买入后持股天数从2天－30天，间隔两天
    keep_stock_list = list(range(2, 30, 2))
    print('持股天数参数组：{}'.format(keep_stock_list))
    # 下跌买入阀值从-0.05到-0.15，即从下跌5%到15%
    buy_change_list = [buy_change / 100.0 for buy_change in xrange(-5, -16, -1)]
    print('下跌阀值参数组：{}'.format(buy_change_list))

    result = []
    for keep_stock_threshold, buy_change_threshold in itertools.product(
            keep_stock_list, buy_change_list):
        # 使用calc计算参数对应的最终盈利，结果加入result序列
        result.append(calc(keep_stock_threshold, buy_change_threshold))
    print('笛卡尔积参数集合总共结果为：{}个'.format(len(result)))

    # [::-1]将整个排序结果反转，反转后盈亏收益从最高向低排序
    # [:10]取出收益最高的前10个组合查看
    print(sorted(result)[::-1][:10])


def sample_242():
    """
    2.4.2 多进程 vs 多线程
    :return:
    """
    # range集合：买入后持股天数从2天－30天，间隔两天
    keep_stock_list = list(range(2, 30, 2))
    print('持股天数参数组：{}'.format(keep_stock_list))
    # 下跌买入阀值从-0.05到-0.15，即从下跌5%到15%
    buy_change_list = [buy_change / 100.0 for buy_change in xrange(-1, -100, -1)]

    print('下跌阀值参数组：{}'.format(buy_change_list))

    result = []

    # 回调函数，通过add_done_callback任务完成后调用
    def when_done(r):
        # when_done在主进程中运行
        result.append(r.result())

    """
        with class_a() as a: 上下文管理器：稍后会具体讲解
    """
    with ProcessPoolExecutor() as pool:
        for keep_stock_threshold, buy_change_threshold in \
                itertools.product(keep_stock_list, buy_change_list):
            """
                submit提交任务：使用calc函数和的参数通过submit提交到独立进程
                提交的任务必须是简单函数，进程并行不支持类方法、闭包等
                函数参数和返回值必须兼容pickle序列化，进程间的通信需要
            """
            future_result = pool.submit(calc, keep_stock_threshold,
                                        buy_change_threshold)
            # 当进程完成任务即calc运行结束后的回调函数
            future_result.add_done_callback(when_done)
    print('Process sorted(result)[::-1][:10]:\n', sorted(result)[::-1][:10])

    result = []

    def when_done(r):
        result.append(r.result())

    with ThreadPoolExecutor(max_workers=8) as pool:
        for keep_stock_threshold, buy_change_threshold in \
                itertools.product(keep_stock_list, buy_change_list):
            future_result = pool.submit(calc, keep_stock_threshold,
                                        buy_change_threshold)
            future_result.add_done_callback(when_done)

    print('Thread sorted(result)[::-1][:10]:\n', sorted(result)[::-1][:10])


def sample_243():
    """
    2.4.3 使用编译库提高性能
    :return:
    """
    # 买入后持股天数放大寻找范围 1 - 503 天, 间隔1天
    keep_stock_list = list(range(1, 504, 1))
    # 下跌买入阀值寻找范围 -0.01 - -0.99 共99个

    buy_change_list = [buy_change / 100.0 for buy_change in xrange(-1, -100, -1)]

    def do_single_task():
        task_list = list(itertools.product(keep_stock_list, buy_change_list))
        print('笛卡尔积参数集合总共结果为：{}个'.format(len(task_list)))
        for keep_stock_threshold, buy_change_threshold in task_list:
            calc(keep_stock_threshold, buy_change_threshold)

    import time

    start_time = time.time()
    do_single_task()
    end_time = time.time()

    print('{} cost {}s'.format(do_single_task.__name__, round(end_time - start_time, 3)))

    import numba as nb
    do_single_task_nb = nb.jit(do_single_task)

    start_time = time.time()
    do_single_task_nb()
    end_time = time.time()
    print('{} cost {}s'.format(do_single_task_nb.__name__, round(end_time - start_time, 3)))


def sample_25():
    """
    2.5 代码调试
    书中本示例针对python3不适用，因为python3默认的除法就是小数
    :return:
    """

    # noinspection PyAugmentAssignment,PyUnusedLocal
    def gen_buy_change_list():
        buy_change_list = []
        # 下跌买入阀值从-0.05到-0.15，即从下跌5%到15%
        for buy_change in xrange(-5, -16, -1):
            buy_change = buy_change / 100
            buy_change_list.append(buy_change)
        return buy_change_list

    # noinspection PyAugmentAssignment,PyRedeclaration
    def gen_buy_change_list():
        buy_change_list = []
        for buy_change in xrange(-5, -16, -1):
            # 1. 原始buy_change
            print(buy_change)
            buy_change = buy_change / 100
            # 2. buy_change/100
            print(buy_change)
            buy_change_list.append(buy_change)
        return buy_change_list

    print(gen_buy_change_list())

    # 2. 导入future库的division`from __future__ import division`
    # from __future__ import division

    # noinspection PyAugmentAssignment
    def gen_buy_change_list():
        buy_change_list = []
        for buy_change in xrange(-5, -16, -1):
            # 1. 除数或者被除数其中一个是float类型
            buy_change = buy_change / 100.0
            buy_change_list.append(buy_change)
        return buy_change_list

    print(gen_buy_change_list())

    logging.basicConfig(level=logging.INFO)

    # noinspection PyAugmentAssignment
    def gen_buy_change_list():
        # 会打印出来，因为info >= level=logging.INFO
        logging.info("gen_buy_change_list begin")

        buy_change_list = []
        for buy_change in xrange(-5, -16, -1):
            # 不会打印出来，debug < level=logging.INFO
            logging.debug(buy_change)
            buy_change = buy_change / 100
            # 不会打印出来，debug < level=logging.INFO
            logging.debug(buy_change)
            buy_change_list.append(buy_change)
        # 会打印出来，因为info >= level=logging.INFO
        logging.info("gen_buy_change_list end")
        return buy_change_list

    _ = gen_buy_change_list()

    import pdb

    # noinspection PyAugmentAssignment
    def gen_buy_change_list():
        buy_change_list = []
        for buy_change in xrange(-5, -16, -1):
            # 只针对循环执行到buy_change == -10，中断开始调试
            if buy_change == -10:
                # 打断点，通过set_trace
                pdb.set_trace()

            buy_change = buy_change / 100
            buy_change_list.append(buy_change)
        # 故意向外抛出异常
        raise RuntimeError('debug for pdb')

    try:
        _ = gen_buy_change_list()
    except Exception:
        # 从捕获异常的地方开始调试，经常使用的调试技巧
        pdb.set_trace()

if __name__ == "__main__":
    sample_211()
    # sample_212()
    # sample_221()
    # sample_222()
    # sample_223()
    # sample_224()
    # sample_231()
    # sample_232()
    # sample_233_1()
    # sample_233_2()
    # sample_241_1()
    # sample_241_2()
    # sample_242()
    # sample_243()
    # sample_25()