diff --git a/examples/TurtleStrategy/.ipynb_checkpoints/run-checkpoint.ipynb b/examples/TurtleStrategy/.ipynb_checkpoints/run-checkpoint.ipynb index b17f25a5..438216aa 100644 --- a/examples/TurtleStrategy/.ipynb_checkpoints/run-checkpoint.ipynb +++ b/examples/TurtleStrategy/.ipynb_checkpoints/run-checkpoint.ipynb @@ -20,33 +20,29 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "coercing to Unicode: need string or buffer, int found", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mengine\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mBacktestingEngine\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mengine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msetPeriod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdatetime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2015\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2018\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m11\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m9\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mengine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minitPortfolio\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10000000\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'setting.csv'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mC:\\Github\\vnpy\\examples\\TurtleStrategy\\turtleEngine.py\u001b[0m in \u001b[0;36minitPortfolio\u001b[1;34m(self, filename, portfolioValue)\u001b[0m\n\u001b[0;32m 60\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0minitPortfolio\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfilename\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mportfolioValue\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m10000000\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 61\u001b[0m \u001b[1;34m\"\"\"\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 62\u001b[1;33m \u001b[1;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 63\u001b[0m \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDictReader\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 64\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0md\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: coercing to Unicode: need string or buffer, int found" - ] - } - ], + "outputs": [], "source": [ "engine = BacktestingEngine()\n", "engine.setPeriod(datetime(2015, 1, 1), datetime(2018, 11, 9))\n", - "engine.initPortfolio('setting.csv')" + "engine.initPortfolio('setting.csv', 10000000)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15:22:46.074000:000300.XSHG数据加载完成，总数据量：940\n", + "15:22:46.074000:全部数据加载完成\n" + ] + } + ], "source": [ "engine.loadData()\n", "engine.runBacktesting()\n", @@ -82,17 +78,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "l = [result.totalPnl for result in engine.resultList]\n", "equity = np.cumsum(l)\n", "plt.plot(equity)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/examples/TurtleStrategy/run.ipynb b/examples/TurtleStrategy/run.ipynb index a1862ccf..2f34f25b 100644 --- a/examples/TurtleStrategy/run.ipynb +++ b/examples/TurtleStrategy/run.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -29,11 +29,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15:23:05.294000:IF99数据加载完成，总数据量：940\n", + "15:23:05.323000:I99数据加载完成，总数据量：940\n", + "15:23:05.348000:CU99数据加载完成，总数据量：940\n", + "15:23:05.375000:TA99数据加载完成，总数据量：940\n", + "15:23:05.375000:全部数据加载完成\n" + ] + } + ], "source": [ "engine.loadData()\n", "engine.runBacktesting()\n", @@ -69,11 +81,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEDCAYAAAAhsS8XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3Xl8nFW9x/HPmez7njZtku77TkNLC4W27IssggoooILAFQRR8VLBqwgigopwQRQQFJHlAmWRAkJLabHQlpbudN/TLWnS7Hvm3D9mMk3apNlmy+T7fr3y6rM/Z55Ofzk9zzm/Y6y1iIhI6HAEugAiIuJdCuwiIiFGgV1EJMQosIuIhBgFdhGREKPALiISYgIW2I0xzxpjCowx6ztw7CPGmNXuny3GmBJ/lFFEpCcygerHbow5HagAnrfWju3EeT8AJllrv+uzwomI9GABq7FbaxcDxc23GWOGGGPeN8asNMZ8YowZ2cqpVwEv+aWQIiI9UHigC3CMp4CbrbVbjTFTgT8Bs5t2GmMGAIOAjwJUPhGRoBc0gd0YEw9MB141xjRtjjrmsCuB16y1jf4sm4hITxI0gR1Xs1CJtXbiCY65ErjFT+UREemRgqa7o7W2DNhpjPkagHGZ0LTfGDMCSAE+C1ARRUR6hEB2d3wJV5AeYYzJN8ZcD3wTuN4YswbYAFzS7JSrgJet0lGKiJxQwLo7ioiIbwRNU4yIiHhHQF6epqen24EDBwbi1iIiPdbKlSsPW2sz2jsuIIF94MCBrFixIhC3FhHpsYwxuztynJpiRERCjAK7iEiIUWAXEQkxCuwiIiFGgV1EJMQosIuIhBgFdhGREKPA7kXlNfW8tXpfoIshIr2cArtbQVkNS3cUUV5T3+Vr3PX6Om5/eTWbD5Z7sWQiIp0TTPnYA+qmF1ayao9rjuxdD17YpWvsPVIFQG2D5gERkcBRjd1tR2GlZ7mqrqFL12h0ujJlOo7OAEV1nYK8iPiXArtbcmyEZ3l3UVWXrtEU2J3uVMg7D1cy6n/e58Vle9hb3LVrioh0lgI7YK3lUFmNZ72rgb0ptX1dgxOAzQfLAPjZG+uY8dBClPteRPxBgR3419oD1NQ7ueOs4QDc/MLKLtWwG92Buymw7yupabH/hWV7ullSEZH2eSWwG2POM8ZsNsZsM8bc5Y1r+tNtL60CYHifeM+2GQ8t7PR1nO6mmFp3YC8sr22x/+dvrvccIyLiK90O7MaYMOAJ4HxgNHCVMWZ0d6/rT1HhDoZlxnPOmL488g3P/NmeNvOOaqqxNwX2sla6ThYcE+xFRLzNG90dpwDbrLU7AIwxL+OahPpLL1y7hZeX72Hx1kIMBmPAGIMB1zLudcPR/Z59BocDOGZ7bmos35w6gNoGJ189KZswh2HWiEzP/W76x0qeuS6vw+Vr+kVQ1+jkUFkNLzZrenn86knc+uIqdhVV0jcp2huPQ0SkVd4I7P2Bvc3W84Gpxx5kjLkRuBEgNze3SzcqKK9ly6EKrLVYCxbXi0/Xn67eKE3vJ5u2O1scC2BxWqitb6SyrpFx/ZMBSIuPBCAx+mjvmPkbD1FV10BsZMcek6cppr6RjQfKPNvPGpXJhGzXfXYXVXLK4LQufX4RkY7wRmA3rWw7rg3DWvsU8BRAXl5elxqabztzGLedOawrpx5n5e4jXP7kp1z19FIAhma62tcdDsPiO2fx5up9/OHDLby4bA83zBjcoWs2NcVU1jZQXnO0L/wz151MQ6OTiDDDLnePG2stxrT26EREuscbL0/zgZxm69nAfi9c16cmZCe16Lt+Um6KZzk3LZbbzhxGenwUGw90PD1AU5P8L//1Jb96x9USNSHHVVMPD3OQkxLL7qJK/nfBVgbNeZd31gb9YxKRHsgbgf1zYJgxZpAxJhK4EnjbC9f1qfAwB09+czIA38jLafWYkX0TmLduP1/uL2t1/7Eiw45/nK/dPM2zPCAtliXbivj9h1sAuPXFVSzeUtjZoouInFC3A7u1tgG4Ffg3sBH4P2vthu5e1x+mDUlj033n8evLxra6/67zR1JT7+TpT3Z06HrH5oi5aHwWEc2C/YScZEqrW/aUWbL9cCdLLSJyYl5JAmatfRd41xvX8rfoiLA2943tn8TlJ2Xz3voDXP+3zz3bTxqQwvdmDCYyvOXvxaa8MK7eNrlcMTm7xf5vTh3AH+dv5bwxffnzNZM54+GFHDhmEJOISHcpu2M7rpk2gG2FFRwqdwXgwvJaFmwq4LPtRTxzXZ7nF4O1lur6Rm6ZNYQfnT2CMMfxL0YzEqJYfOcs0hNcPXCykqLZX1JNUUUtafFR/vtQIhLSFNjbMTEnmbduOdWzbq3l3n99yd8+3cVv39/EL74yBnD1XXdaiI0MbzWoN8lNi/Us90uKYe6qfUy+fz6rfn42KXGRvvsgItJrKFdMJxlj+OXFYzhjeAb/+Gy3p129qXtjYnTHf1fGNzt2dX6JdwsqIr2WAnsXXTE5mwan5ZlPdgJQUuV6KZoU2/Fa97A+CZ7l7QUV3i2gl72//iD3vLlOk4iI9AAK7F00c0QGAP/70VastZRU1QGQHBNxotNauHpKLv/571lEhTtapA0ORs8u2ckLS/fw9OKO9RASkcBRG3sXJURHEO4w1NQ7eXfdQaLcPWSaD3pqT5jDkJ0SS5/EaA6VBXdysBj3S+L1+zrWp19EAkc19m54+lpXgrBbXvyCG55fAUBKJ5pimmQkRHG4IrgDe1P/+11Fle0cKSKBpsDeDbNGZh63rV9yTKevkxQT0WqK30Cz1jJv7QHqG52e8h07wEpEgo8CezfNOX9ki/UTdXVsS2J0OGXVXZtAG2DCvR9wxyurqalv5J/LdrPrsHdq1a+uzOeWF7/gxWV7KHMH9Op6vTwVCXYK7N100xlDyBvgSiD252+d1KVrJMVEdKsmXFpdzxur9vH++oPc/cZ6Zv7uY9bvK+3y9Zqsy3dd4xdvb/CUr2l07bFW7y3ht+9v6vY9RaT7FNi94NwxfQHISY1t58jWNVpLaXU9y3cWd/rc+kanZ3nJtqN5Z95dd6BLZWnO2Wzy7fpGS2S4g9oG53HT+x2prOPSJ5bw5Mfb1R1SJAgosHvBDTMGseDHZzCmX1KXzh/X33Xef7++ttPnNq/pv7oy37O8yAtZI5vnlAfom+ia+alp6r8mX+w50uY5IuJ/CuxeYIxhSEZ8+we24et5OfzwrGHsPFzJtgJX/veOTnr9j892t1gf4R70tL+kusvlaVJeU8/IvkcHUfVJdOWzqWnWzl5T30jzopbp5apIwKkfexAwxvCNk3P44/ytnPWHxZ7tC38yk0HpcSc899EFW1us/+sHp/GXRdv5/YdbqG1oJCq87eyV7SmvaWjRfTPTXWOvrm+kuqSafskxnHTfh1Q1a3dXjV0k8FRjDxJZSTF865RcmneqmTP3xE0z1lqGZMR58tMkx0YQGe4gy93l8mdz13erTGU19SQ0y2fT1BQz83cfM/3Bj9hbXNUiqDedIyKBpcAeRO6/dBw7fnMhO39zAQCN7TTHbDpYzvbCSn541nAW3zmLebfNAOC8sX3pmxjN61/kd6tJprymgYRmk3uPzkoEoM7dxr6vlWtvPRTcOW9EegMF9iBkjOErE/q1m2bgYKkrv8zE3GRy02Lp766px0eF86p7Sr7u9I4pr2kgMSbc085+2aT+nnsAx3WpzE6JYdnOoi7fT0S8Q4E9SGWnxLC/pPqEtfZCdxqCjFYm6chJjSU9PorNB088Gbe1FmuPv0ej01JR66qxv3LTNBbdOROHw/DXb+d5jrl/3sYW5wzLjGdvcfdf2opI9yiwB6n+yTE0OC0F5W1nfWzKL5PexuxLo/sl8urKfH759oYWwXvFrmKe+WQH1XWNDJrzLmf+fpFnX32jk/9bsdeTbTIxOpykmAgGpLle4g7LTGBSbnKLl7pPXTOZN285ldzUWLYcKqewPLjz3oiEOvWKCVLZKa4mj91FVWQltZ5/ZuuhCjITooiJbL3ny90XjGJ7QQV/+3QXX8/LYXQ/Vxv5FX/+DMDzYnTH4UrKa+pJiI5gztx1vLYyn0sn9mtxTJMwh+GN759KZW0D1z27nDvOHs6pQ9MBMMDfP9vNB18e5JtTB3TvAYhIl6nGHqSaXlQ2Des/Vl2Dk3nrDnBSbkqb1xjRN4E3bpmOMTB/4yGcTsvX3UEd4L9fX+dZvuOVNQCe0a9vrt4PQB93T5hjxUWF89p/TfcEdYDx2Un0SYziX2v2d+QjioiPqMYepDIToxnZN4EnF21nRN8ETh2a3iLB2GMLtlLX4GR8zolHu2YmRDM5N4XXv8inoLyG5btaT1swf+Mh3l6z3/NCFiAhKpzTh2V0uMzGGC6Z2J+//mcnTqfF0YWEaCLSfQrsQezhKyZwzbPLuPbZ5Z5tkWEO0uMjqWt0tZlfflJ2u9e56YwhfO/5Fewu2gPAhOwk1rj/J/DpXbPZcqicbz/3Obe9tAqAUVmJbDxQRmJMRKeDc//kGBqdluKqujbb/kXEt9QUE8TGZSexdM6Z3HvxGPolRZOTGkNdo5P9pTUcrqjl2mkD2mwqaW7miIwWA5/uvWQsAHGRYfRLjmHmiEweumK8Z/9lk1zt69OHpHW6zBkJrmCuF6gigaMae5CLjgjjuukDuW76QADW7C3hJ6+uYdqQNH52wagOXSMizEFWUgz7SqqJjnAwMSeZV248hdy0o9koL57Qj5++5hrpesXkHIZkxHPasPS2LtmmrCTXL5rdRVWMcr8nEBH/UmDvYSbkJPPhj87o9Hl3nD2cn7y6xjNqdOrglrXx6Igw/mvmEGrrnaTGRXLmqD5dKt+orEQiwgw3v7CSh64Yz/jsJB5bsJWx/ZP4/syhXbqmiHSOaW1wiq/l5eXZFStW+P2+vd3HmwvISIjqcnrhjnrl8z0tetw0+dUlY5g9MpPslK7lrRfp7YwxK621ee0ep8AuvrB6bwmXPrHkuO05qTF88tPZASiRSM/X0cCul6fiExNzkrlwXBYAj145kUz3S1WlHBDxPQV28ZnHr57Ejgcu4JKJ/XnhhqmMykrEGI6bPm9vcRXnP/rJCdMniEjHdSuwG2O+ZozZYIxxGmPa/e+B9C7GGE8/+OF9ErjhtEFYC/uOtKy1P7dkFxsPlPHWKo1YFfGG7tbY1wNfBRa3d6BI02TfGw+0zDjZNG+r0UBVEa/oVmC31m601m72VmEktA3OcGWEfOqTHZ5t1lpe/8I1CbfDGHYerqS4si4g5RMJFX5rYzfG3GiMWWGMWVFYWOiv20oQSY+P4vYzh7FmbwlPLd5ORW0Db6za59lfUdvA+Y8uds+jqrlTRbqq3e6Oxpj5QN9Wdt1trX3LfczHwE+stR3qw6jujr1XcWUdFzz6CQfLjn9ReunEfp6skgAPfnUcV07J9WfxRIKa17o7WmvPstaObeXnLe8UVXqT1LhIFv90Fo9eOZGEKNfA599/bQJDM+NZe0yK4rvmHj/ISUTap5QC4neR4Q4umdifr4zvx9KdRZwyKI131x1gwaaC4479cn+ZZ4IQEemY7nZ3vMwYkw9MA+YZY/7tnWJJb+BwGKYPScfhMC0Shr1966l8eMfpACzdocmxRTqru71i3rDWZltro6y1fay153qrYNK7nNIsKdnorESGZsYTGe5otS1eRE5MTTESFCYPcE3xN7Z/IuFhrvpGVlJ0ixmdRKRjFNglKMREhvHBHafTP/noxN3DMhP4aFMBCzYe6nIaYZHeSLliJGgM75NAXNTRusZ9l44B4HvPr2BHYUWgiiXS4yiwS9DKSorhxe9NxWlh9u8XsWrPkUAXSaRHUGCXoDY+O9nTPPPWaiUJE+kIBXYJeh/95AzG9Etku5pjRDpEgV2CXlR4GNkpMeohI9JBCuzSI/RJjGZrQQULNx8/OlVEWlJglx4h153L/TvPfc6+Ek2vJ3IiCuzSI4zom+BZvvXFL2h0+n8SdpGeQoFdeoQpg1L53oxBTB2Uyqo9JSzeqpz+Im1RYJceISo8jLsvHM2T35oMwJMfbweg0WmZM3cd768/EMjiiQQVpRSQHiU1LhKA5TuL+fZzy/l0exF1DU5eWr6HXQ9e2OHrFFfWkRwT4ZlsWySUqMYuPc7r/zUdgI83F1LX4PRsb282sCaLtxRy0n0f8vaa/Z7z6htd19ldVOnl0or4nwK79DiTB6Rw78VjPOtTB6UCUFJV36HzV+8tAWBrQTkAv3h7A8Pufo+Fmws44+GPeXedmnWkZ1Nglx7puukD2fmbC1jzi3O4+YwhANw/byM19Y3tnlt5zETZz3+2G4Avdrty0Xy0qcBTgxfpiRTYpccyxpAUE8GY/q7Zl17/Ip/73vmy3fNKKl01+6q6lr8EjlTVAfDaynx++fYGL5dWxH8U2KXHy0yI5p0fnMZXJ/Xnn8v28J3nllNe03azTFMAr6ptGdhfWLrHszx/4yHfFFbEDxTYJSSM7Z/EHWcPB2Dh5kLeXLWvzWObpturqm9ss8klIyHK+4UU8RMFdgkZOamxLL/7TAB+/tYGthW0zAa5em8JhytqWZtfCkBVbQOl1a3X7KPDw3xbWBEfUmCXkJKZEM1tZw4D4Kw/LKLa3Y5eUdvApU8sIe/++Z5jK2obKCyvbfU6jR3sOikSjBTYJeT8yN0kA/Dp9sMArM0vaXHMWaMyKamqZ+mOohbbH7piPACr9pSwp6jKxyUV8Q0FdglJr//XNAAOlblq5McG6YyEKIqr6thfUk10xNF/Bl/Py/Es7zisiT2kZ1Jgl5A0rn8yAIcraqltaOTRBVs9+6YMTCU5NpIjlXUUVdSRFhfF1VNzue/SsQD884apANTUqy+79EzKFSMhKTLcQXJsBJsPljP3i30caDb70i2zh7LlYDkNTsvOokpS4yJ54LJxnv1Nud9P1GVSJJgpsEvISo2LZN66A+w47Mr/8puvjiM2MozTh6V7csys2lPCGcMzWpyXEO36Z1Fe03KEqkhPoaYYCVl/+PpEADYeKGNwRhxXTcnlkon9McYwpl+i57g0d8bIJvFRrsBephq79FAK7BKyJuYke5b3HzOdXr/kGEb0cc3KlHpMYA8PcxAbGaYau/RYCuwS0r4yoR8A0RHHDzga7p5uL+WYwA6QGB2hNnbpsdTGLiHtj9+YyKlD0jhpQMpx+5zueVPT448P7AnR4aqxS4/VrcBujHkY+ApQB2wHvmOtLTnxWSL+E+YwXDklt9V9X8vLZsfhSs4Z3fe4fQrs0pN1tynmQ2CstXY8sAWY0/0iifjHzBGZvHf7jFabYhLUFCM9WLcCu7X2A2ttU7VmKZDd/SKJBF5STESbCcJEgp03X55+F3jPi9cTCZi+SdEcKK3p8DyqIsGk3TZ2Y8x84PhGSLjbWvuW+5i7gQbgnye4zo3AjQC5ua23eYoEi35J0dQ2OHlswbYWuWSyU2K5YFxfjDEBLJ3IibUb2K21Z51ovzHmOuAi4Ex7guqNtfYp4CmAvLw8VYMkqI3LTibMYXhk/pbj9j33nZOZNSIzAKUS6Zju9oo5D/hv4AxrrXKcSsiYPCCFL391Lo3Oo3WQsuoGTvnNArYeKldgl6DW3Tb2x4EE4ENjzGpjzJ+9UCaRoBAVHkZsZLjnp0+ia7q8jzcXBrhkIifWrRq7tXaotwoiEuya2tU/3V5ETX1jq6NZRYKBUgqIdMI5o/sAUFDW+pR6IsFAgV2kE66dNhCAPcVHXyltPFDGYwu2Ut+oiTkkOChXjEgnDMmMI9xheGzBVk4blg7AD19ezeZD5USGO+ibGM2lk/oHuJTS2ymwi3RCVlIMN50xmCcWbmfX4Upm/u5jz74H39sEwIC0WCblHp90TMRf1BQj0kmjslyTdPzqnS9b3T9n7rqgmqRjb3EVDWom6lUU2EU6aVB6HAAfbSo4bt+ZIzPZdLCccx9Z7O9itaqgrIYZDy3k4Q82B7oo4kcK7CKdNDorkX5J0QB89aT+XDapP7NGuOZNnXPBKICA55lZl1/KKQ8s4Jw/un7BLFLf+15FbewinWSM4e0fnMbuokomD0gFXJN27C6uYlB6HL++bCx3v7Ge++dt5J4LRwUkr8y6faUcLKvxrEeEqQ7Xm+hvW6QL0uOjPEEdwOEwniaai8b1wxj46392sr2wIiDlK6mua7GeGKM6XG+iwC7iZUmxESz88UwAbvrHyoA0yZRWtXx5W1N//MvTZz7Zwee7iv1VJPEj/RoX8YGB6XHERISxvbCSpTuKmTYkza/3L62uJzMhiqVzzuTmF1Z6BlRZa3n8o218ur2Iz3YUEeYwbH/gAr+WTXxPNXYRH5n7/ekAzJm71u/33ldSTWpcJA6HIS4qnKq6RgD+/ukufv/hFj7bUQRAo9NqMpEQpMAu4iOjshI5eWAKu4urKKqo5UBpNRv2l/r8vpW1DSzbWcz0Ia6RsbGRYVTVNbBsRxG//Jer7/0Dl43j0on9ACiurGvzWtIzKbCL+NC3pw/CWph8/3ym/eYjLnzsPwDsL6nm0flbvT5wqKC8hvkbD1HX4ORsd8KyuKhwDlfU8Y2nlnqOu3pqLl+Z4ArsTc00768/yB2vrGZbQWBe+Ir3qI1dxIdOG5rO6KxEvjxQ5tm2Zm8JlzyxBIB+ya4p+DbsL+W+S8ayYX8ZH3x5kJ+cM6JL3SSn/HoBAMmxEZw80JXWIDayZXrhlfe4JkUbkBYLuAJ7v+QYbn5hJQCbDpaTEhvBD88azpRBqUjPo8Au4kNJsRG8e/sMbnx+BR98eQjAE9QB7nztaPv77JF9+N7zKwC4akou2SmxnbpX89r/7JGZhLv7rsdFHv1n/u8fnk5avGvCkKbr3/7yagCMAWtd2SoBnHYzL984rVNlkOCgphgRP7j/0rF8c+qJJ3G/87U1nuX31x/s9D0qahsA18jYO88d4dnevEfOsMx4z3J0RBjfyMvxrP9g9rAW11u6o5iVu490uhwSeCYQb8Tz8vLsihUr/H5fkUCqb3Ry+8ureHfdQfomRnPnuSM4UlXH1VNzmf27RRwsq2FwehzGwKD0eJ65Lq9T199TVMXpDy/k4SvG87VmARtgd1ElOSmxOBzHN+/sPFxJRkIUcZFhLN1RTHlNPWvzS3l84TYAdj14Ydc/tHiVMWaltbbdL4aaYkT8JCLMwaNXTmLn4SVcf9ogLp+c7dk3ZVAqb6/Zz+h+iZRW13O4ovMzNDVllEyMiThu34C0uDbPaxoxC0dr9xNzkz2B3em0rf5CkOClphgRP4oIc/De7TO4ollQB7hu+kAGpMXyrVMGkB4fRWF55wP72nxXV8qkVgJ7Z2UmRPPAZeMAGPyzd9l8sLzb1xT/UWAXCQKTB6Sw6M5ZnDI4jYyEKAoranE6O95Mui6/lJ+9sQ44mi++u648+Whzzm/f3+SVa4p/KLCLBJkBabHUNThbzffeZHthBT/6v9Xc/86XFFXUel68fvfUQV6psYMrsVmfRFcPmo82FbQYoVpT3+iVe4hvKLCLBJnhfRIAuOH5FVTXtR5A73hlNXO/2Mcz/9nJ3W+sZ5O7qeRnF4z0alnevOVUEqNdr+IOV7hGqM79Ip+RP3+fvc0m9JbgosAuEmQm56ZwsXtU6Dtr9wOu5F1PLNzG1kOuAF7VLOC/v8HVNXJwRpyn77q3ZCXF8IevTwTg5F/P57EFW7l/3kYAZjy0kL9/usur9xPvUGAXCTIOh+GhK8YDRwcwLdlWxMP/3szZjyzG6bQ0ttL+3hSAvW1Yn6N93//w4ZYWuWV+8fYG5ZoJQgrsIkEoOiKMme7p9o5U1rFqz9GBQp/vKmbn4UpG9k3wbJt322lMzEn2SVlyU2OJCGu7u+OFj33ik/tK1ymwiwSp66YPBOCeN9ezem+JZ/ucua7eL/ddOpYEd/t3877o3maM4bM5Z7LpvvPITHC9TP3m1Fy2/fp8wDW/a1EX+t2L7yiwiwSpM4ZlMDorkXnrDrBgUwGj3d0YdxyuBODkgam8fOMp3HnuCGIjfTvWMD0+iuiIMM8AplkjXLloXr3ZlUvm5F/P52BpzYkuIX6kwC4SpBwOw1+umexZP3Xo0ZwvPzp7OABj+iVxy6yhfivTby8fz6qfn81Z7pTAJw9M5Z4LR+G08O3nllNQpuAeDBTYRYJYTmqsJ6HXhJxkXr7xFCbkJHPDjEEBKU90RBgpcZEttt0wYzA/mD2UTQfLmfLAAkqr69s4W/xFgV0kyN0wYxCPXz2JC8dlccrgNN665VSfN7101o/PGUGGu/39L4u2B7g00q3Aboy5zxiz1hiz2hjzgTGmn7cKJiIuUeFhXDS+X5cm3vCnf1w/BYAnF22ntkEjUwOpuzX2h6214621E4F3gP/xQplEpAca2TeR609zTQW4YGPb6RDE97oV2K21Zc1W4wBNdy7Si/34HNdLXc2bGljdbqgzxvwauBYoBWad4LgbgRsBcnNPPJOMiPRMsZHh5KTG8PmuYhoanV5PcSAd0+5TN8bMN8asb+XnEgBr7d3W2hzgn8CtbV3HWvuUtTbPWpuXkZHhvU8gIkHljOEZfLL1MDN/9zHlNeohEwhemxrPGDMAmGetHdvesZoaTyR0Vdc18vjCrTyxcDtJMa7JvFNjI2lwOkmIjuCFpbsprqzjB7OHBv0L4WDjl6nxjDHDrLVb3asXA8rGL9LLxUSGcee5IzlQUsPcVfv46p+WMCorkY83F7Lh3nO55831gCs98Xlj+wa4tKGpuw1gD7qbZdYC5wC3e6FMIhIC7nCPjj1UVsvHmwsBGPOLf3v2a7o93+lur5jLrbVj3V0ev2Kt3eetgolIz5aTGssHd5ze6r4wh+GZT3bgraZgaSm4hq+JSEgZmhHP6KxE4qLC+Pt3p/D7D7YQHmZYtbuE5buKKSyvJTMxOtDFDDkK7CLiMw6H4d3bZ3jWf37RaAA+3X6Yq59exuZD5QrsPqBOpiLidyPc87qqnd03FNhFxO/S4l0Jw+6ft7HVaf6kexTYRSQgZgxLB2Cne+IQ8R4FdhEJiKb29heW7g5wSUKPAruIBMTwPgmcPjyDv326iz1FVYEuTkhRYBeRgPn29AEAvL/hQIBLEloU2EUkYGZprDVoAAAN9ElEQVSP7EP/5Bg27C9r/2DpMAV2EQmovknRbC9U/nZvUmAXkYDaeKCM9fvKWLGrONBFCRkK7CISUCP6ugYrrd5bEuCShA4FdhEJqBeunwrAwdKaAJckdCiwi0hAxUWFM7JvggYqeZECu4gE3KD0OAV2L1JgF5GAy0qK4VCZmmK8RYFdRAIuNS6CyrpGahsaA12UkKDALiIBlxwbCUBJVX2ASxIaFNhFJOBS3IH9SFVdgEsSGhTYRSTgMhJc+dnb6vJYXdfIHa+s5o1V+Tz7n53+LFqPpKnxRCTghmbGA7CtoIKZIzKP279oSyFvrNrHG6v2AXDGiAyGZMT7tYw9iWrsIhJwqXGRDEyL5anFO3hn7f4W+xoandz8wsoW29bma5TqiSiwi0hQ+O3l44mPCufWF1exfl+pZ/vu4uNzta/LL6O6Tj1o2qLALiJBYergNN74/qmEOQwfbDjo2V5Z2wDAPReOIircFbKeXbKT2b//GGsDM19qfaMzIPftKAV2EQkaSbERDMuMZ1WzhGAV7sA+pl8SG+49l8V3zgLgQGkN2wr8m+73vXUHGHjXPIbd/R7z1gbv5CAK7CISVGYMS+fT7UUcKqthb3EVVz+9DID4qHDCwxzkpsUy9/vTAcg/Uu3Xsj2+cJtn+cMvD57gyMBSYBeRoHLF5BwanZZf/etLnv5kh2d7XFSYZzktztXvvajSv/3ex/ZL8iwnREf49d6doe6OIhJUhvdxdWOct65lU0d81NFwlRbv6vdeXFnrv4IBMZFHf7lEhAVvvTh4SyYivZIxhsHpccdtj2sW2OMiw4gMd1BU4b8a+67DlWw8UEafxCj6JkbzwtLd1NQHZ88c1dhFJOj883tT2VtczV8Wbee7pw3C0DKwG2NIj4v0W1NMVV0DM3/3MeBKMXywtIa6RievrtjLNdMG+qUMneGVwG6M+QnwMJBhrT3sjWuKSO+VlRRDVlIMUwaltnlManwkRRX+aYr5y6Kjbf1R4Q5euGEqlz/5qd9f3nZUt5tijDE5wNnAnu4XR0SkY8KMYeHmQr793HI+/PKQT+/V6DzaX76qrpHJA1IYlZXI5kPlPr1vV3mjjf0R4KdAYEYKiEivNLyPaxLsjzcX8r3nV3DZn5b47F71zqMDkqrcI15H9Iln88EQDOzGmIuBfdbaNR049kZjzApjzIrCwsLu3FZEhHsuGs1Zo/p41lftKeGIj9rcy6qP5omPDDMAZKfEcqisJmCjX0+k3TZ2Y8x8oG8ru+4Gfgac05EbWWufAp4CyMvLC74nISI9SlJMBE9dMxljYE1+KZc+sYQH39vEPReN8mofc6fT8tLyvZ71WPdL3NioMJwWahucREeEtXV6QLQb2K21Z7W23RgzDhgErDHGAGQDXxhjplhrg3dIloiEDIfDVXse3z+JyQNSeGXFXpZsP8zT1+YxKivRK/cobVZbT4gK52cXjAQgLtIVPitrG4IusHe5KcZau85am2mtHWitHQjkAycpqIuIvzkchlduPIWHrxhPaXU91/x1mdf6mDflqvnVJWNYd++5zB7pav6JdQ9WqgrCLJMaoCQiISE8zMHX8nJ4/OqTOFxRx3+2dr/ntbWWn762FoDMhOgW+5r61VfWNXT7Pt7mtcDurrmrD7uIBNTUQak4DKxtltO9qypqG/hsRxEACdEtW66bauyVtaqxi4j4VHREGEMz43lswVbeWr2vW9dq3r7efORr8/W9rUwEEmgK7CIScm4/c7jrz5dXU1heyy/f3sCpD35EQVnrk2W3pXlgP7Zb45h+ifRPjuGHr6zm5eXBNT5TgV1EQs6F47N49MqJAPzhwy387dNd7CupZsoDC1qMIm1PaZUrsE/ISWZ8dnKLfbGR4fziK6MB+Ptnu71Ucu9QYBeRkHTJxP5cflI2Lx1Tm954oKzD12iqsT9w2VjC3F0rmztnTF9umTWEjQfK+M/Ww0EzWEmBXURC1i8vHu1ZvmXWEKDlKNL2NM2Y1Dcxus1jbpk1lKhwB9/66zL+snhHm8f5kwK7iISshOgI7r14DKcNTee8MVnA0X7p7bn95VVs2O+q3ae6Z2xqTWxkOFdNyQXguSU7u1li71A+dhEJaddNH8h10wey83Al0PF+52+t3u9Zdo+ub9P/XDSa8poGFmw6hLW23eN9TTV2EekVmuZMrajp3ICit289td1jHA7D5AEplFTVs2BjQZfK500K7CLSKyREuRKDVTQbUPTge5u47aVVx7303FbgSsd77bQBx/WGacv4bNdE1zc8v8Ibxe0WBXYR6RWiIxw4jCtpV5M/L9rO22v2HzfF3iZ3nvWrp+Z2+Poj+iZ4lqsDnD9GgV1EegVjDHFR4VTUNpB/pIrrnl3u2Zd3/3xP//biyjpufXEVAGlxUR2+fkSYw9N3/p431+PsRH95b1NgF5FeI94d2L/6p09ZtKXlhD9N3SAXbDw6zV5ybOfyuo92pwp+/Yt8Ptzo2+n6TkSBXUR6jfiocCprGygoP34S7LKaehZuKmDJtqO5DCPCOhciB6bHERXuOuemf6ykpMo3Mzq1R4FdRHqNpqaY1sxbd4Dv/O1z3nR3c+xM+3qTiDAHm+8/37N+sJO5abxFgV1Eeo34qHA+aZan/aHLx9M/Oca1/P7mFsc9cNm4Lt/nxRumAlBUEZgauwYoiUivUdfg9Cyvv/dc4qPCmZCTzLl/XAy4kn3tKark2mkDu3WfjATXS9dje9v4iwK7iPQaI7MSWL6rGHDVygGGZcbzg9lD+WhTAY98fQID0uJaTfjVGU2zLeUfCUyudhOIbGR5eXl2xYrAd+IXkd6lpr6RN1ftY/aozOOmuvO26b9ZwP5SVxv7lvvPJzK8+y3fxpiV1tq89o5TG7uI9BrREWFcOSXX50H9WJvdA578RYFdRMQHLp3U37Ps7z7tCuwiIj7w43NGsHTOmZw+PKPbc692lgK7iIgPhDkMfZOiOX1YOruLqigo91+fdgV2EREfGt3PlWZgxa4j3PX6Wk/mSF9Sd0cRER8anB4PwPf/+QUAXz85x+f3VI1dRMSHmgYrAcREhDEpp2P53btDgV1ExIfCHMaTGOx/r5rkl2nz1BQjIuJjv7pkDAdLa5k9MtMv91NgFxHxsW+c3PlMkd2hphgRkRCjwC4iEmK6FdiNMb80xuwzxqx2/1zgrYKJiEjXeKON/RFr7e+8cB0REfECNcWIiIQYbwT2W40xa40xzxpjUto6yBhzozFmhTFmRWFhYVuHiYhIN7U70YYxZj7Qt5VddwNLgcOABe4Dsqy1323vpppoQ0Sk8zo60Ua7bezW2rM6eMOngXc6cqyIiPhOt16eGmOyrLUH3KuXAes7ct7KlSsPG2N2d/G26bj+l9Cb6RnoGYCeQW/8/AM6clC35jw1xvwDmIirKWYXcFOzQO8TxpgVHfmvSCjTM9AzAD2D3v75T6RbNXZr7TXeKoiIiHiHujuKiISYnhjYnwp0AYKAnoGeAegZ9PbP36ZutbGLiEjw6Yk1dhEROQEFdhGRENOjArsx5jxjzGZjzDZjzF2BLo8vGGNyjDELjTEbjTEbjDG3u7enGmM+NMZsdf+Z4t5ujDGPuZ/JWmPMSYH9BN5jjAkzxqwyxrzjXh9kjFnmfgavGGMi3duj3Ovb3PsHBrLc3mKMSTbGvGaM2eT+Pkzrbd8DY8wd7n8H640xLxljonvb96ArekxgN8aEAU8A5wOjgauMMaMDWyqfaAB+bK0dBZwC3OL+nHcBC6y1w4AF7nVwPY9h7p8bgSf9X2SfuR3Y2Gz9t7iyiQ4DjgDXu7dfDxyx1g4FHnEfFwoeBd631o4EJuB6Fr3me2CM6Q/cBuRZa8cCYcCV9L7vQedZa3vEDzAN+Hez9TnAnECXyw+f+y3gbGAzrlw8AFnAZvfyX4Crmh3vOa4n/wDZuALXbFypKgyuUYbhx34fgH8D09zL4e7jTKA/Qzc/fyKw89jP0Zu+B0B/YC+Q6v57fQc4tzd9D7r602Nq7Bz9S26S794Wstz/lZwELAP6WPeoXvefTbPihupz+SPwU8DpXk8DSqy1De715p/T8wzc+0vdx/dkg4FC4Dl3c9Qzxpg4etH3wFq7D/gdsAc4gOvvdSW963vQJT0psJtWtoVsX01jTDzwOvBDa23ZiQ5tZVuPfi7GmIuAAmvtyuabWznUdmBfTxUOnAQ8aa2dBFRytNmlNSH3DNzvDy4BBgH9gDhcTU7HCuXvQZf0pMCeD+Q0W88G9geoLD5ljInAFdT/aa2d6958yBiT5d6fBRS4t4ficzkVuNgYswt4GVdzzB+BZGNMUxqM5p/T8wzc+5OAYn8W2AfygXxr7TL3+mu4An1v+h6cBey01hZaa+uBucB0etf3oEt6UmD/HBjmfiMeieslytsBLpPXGWMM8Fdgo7X2D812vQ1c516+Dlfbe9P2a929Ik4BSq2PE7H5mrV2jrU221o7ENff80fW2m8CC4Er3Icd+wyans0V7uN7dE3NWnsQ2GuMGeHedCbwJb3oe4CrCeYUY0ys+99F0zPoNd+DLgt0I39nfoALgC3AduDuQJfHR5/xNFz/fVwLrHb/XICrrXABsNX9Z6r7eIOrt9B2YB2uHgQB/xxefB4zgXfcy4OB5cA24FUgyr092r2+zb1/cKDL7aXPPhFY4f4uvAmk9LbvAXAvsAlXSvB/AFG97XvQlR+lFBARCTE9qSlGREQ6QIFdRCTEKLCLiIQYBXYRkRCjwC4iEmIU2EVEQowCu4hIiPl/ug9zMY61xdEAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "l = [result.totalPnl for result in engine.resultList]\n", "equity = np.cumsum(l)\n", diff --git a/examples/TurtleStrategy/turtleStrategy.py b/examples/TurtleStrategy/turtleStrategy.py index 3d885eec..1b138a9c 100644 --- a/examples/TurtleStrategy/turtleStrategy.py +++ b/examples/TurtleStrategy/turtleStrategy.py @@ -18,7 +18,7 @@ class TurtleResult(object): #---------------------------------------------------------------------- def __init__(self): """Constructor""" - self.pos = 0 + self.unit = 0 self.entry = 0 # 开仓均价 self.exit = 0 # 平仓均价 self.pnl = 0 # 盈亏 @@ -26,16 +26,16 @@ class TurtleResult(object): #---------------------------------------------------------------------- def open(self, price, change): """开仓或者加仓""" - cost = self.pos * self.entry # 计算之前的开仓成本 + cost = self.unit * self.entry # 计算之前的开仓成本 cost += change * price # 加上新仓位的成本 - self.pos += change # 加上新仓位的数量 - self.entry = cost / self.pos # 计算新的平均开仓成本 + self.unit += change # 加上新仓位的数量 + self.entry = cost / self.unit # 计算新的平均开仓成本 #---------------------------------------------------------------------- def close(self, price): """平仓""" self.exit = price - self.pnl = self.pos * (self.exit - self.entry) + self.pnl = self.unit * (self.exit - self.entry) ######################################################################## @@ -75,7 +75,7 @@ class TurtleSignal(object): self.shortEntry4 = 0 self.shortStop = 0 # 空头止损位 - self.pos = 0 # 信号持仓 + self.unit = 0 # 信号持仓 self.result = None # 当前的交易 self.resultList = [] # 交易列表 self.bar = None # 最新K线 @@ -102,34 +102,34 @@ class TurtleSignal(object): return # 优先检查平仓 - if self.pos > 0: + if self.unit > 0: longExit = max(self.longStop, self.exitDown) if bar.low <= longExit: self.sell(longExit) return - elif self.pos < 0: + elif self.unit < 0: shortExit = min(self.shortStop, self.exitUp) if bar.high >= shortExit: self.cover(shortExit) return # 没有仓位或者持有多头仓位的时候，可以做多（加仓） - if self.pos >= 0: + if self.unit >= 0: trade = False - if bar.high >= self.longEntry1 and self.pos < 1: + if bar.high >= self.longEntry1 and self.unit < 1: self.buy(self.longEntry1, 1) trade = True - if bar.high >= self.longEntry2 and self.pos < 2: + if bar.high >= self.longEntry2 and self.unit < 2: self.buy(self.longEntry2, 1) trade = True - if bar.high >= self.longEntry3 and self.pos < 3: + if bar.high >= self.longEntry3 and self.unit < 3: self.buy(self.longEntry3, 1) trade = True - if bar.high >= self.longEntry4 and self.pos < 4: + if bar.high >= self.longEntry4 and self.unit < 4: self.buy(self.longEntry4, 1) trade = True @@ -137,17 +137,17 @@ class TurtleSignal(object): return # 没有仓位或者持有空头仓位的时候，可以做空（加仓） - if self.pos <= 0: - if bar.low <= self.shortEntry1 and self.pos > -1: + if self.unit <= 0: + if bar.low <= self.shortEntry1 and self.unit > -1: self.short(self.shortEntry1, 1) - if bar.low <= self.shortEntry2 and self.pos > -2: + if bar.low <= self.shortEntry2 and self.unit > -2: self.short(self.shortEntry2, 1) - if bar.low <= self.shortEntry3 and self.pos > -3: + if bar.low <= self.shortEntry3 and self.unit > -3: self.short(self.shortEntry3, 1) - if bar.low <= self.shortEntry4 and self.pos > -4: + if bar.low <= self.shortEntry4 and self.unit > -4: self.short(self.shortEntry4, 1) #---------------------------------------------------------------------- @@ -157,7 +157,7 @@ class TurtleSignal(object): self.exitUp, self.exitDown = self.am.donchian(self.exitWindow) # 有持仓后，ATR波动率和入场位等都不再变化 - if not self.pos: + if not self.unit: self.atrVolatility = self.am.atr(self.atrWindow) self.longEntry1 = self.entryUp @@ -190,7 +190,7 @@ class TurtleSignal(object): def sell(self, price): """卖出平仓""" price = self.calculateTradePrice(DIRECTION_SHORT, price) - volume = abs(self.pos) + volume = abs(self.unit) self.close(price) self.newSignal(DIRECTION_SHORT, OFFSET_CLOSE, price, volume) @@ -210,7 +210,7 @@ class TurtleSignal(object): def cover(self, price): """买入平仓""" price = self.calculateTradePrice(DIRECTION_LONG, price) - volume = abs(self.pos) + volume = abs(self.unit) self.close(price) self.newSignal(DIRECTION_LONG, OFFSET_CLOSE, price, volume) @@ -218,7 +218,7 @@ class TurtleSignal(object): #---------------------------------------------------------------------- def open(self, price, change): """开仓""" - self.pos += change + self.unit += change if not self.result: self.result = TurtleResult() @@ -227,7 +227,7 @@ class TurtleSignal(object): #---------------------------------------------------------------------- def close(self, price): """平仓""" - self.pos = 0 + self.unit = 0 self.result.close(price) self.resultList.append(self.result) @@ -266,14 +266,15 @@ class TurtlePortfolio(object): self.signalDict = defaultdict(list) - self.posDict = {} # 每个品种的持仓情况 + self.unitDict = {} # 每个品种的持仓情况 self.totalLong = 0 # 总的多头持仓 self.totalShort = 0 # 总的空头持仓 self.tradingDict = {} # 交易中的信号字典 self.sizeDict = {} # 合约大小字典 - self.unitDict = {} # 按照波动幅度计算的委托量单位字典 + self.multiplierDict = {} # 按照波动幅度计算的委托量单位字典 + self.posDict = {} # 真实持仓量字典 self.portfolioValue = 0 # 组合市值 @@ -291,6 +292,7 @@ class TurtlePortfolio(object): l.append(signal1) l.append(signal2) + self.unitDict[vtSymbol] = 0 self.posDict[vtSymbol] = 0 #---------------------------------------------------------------------- @@ -302,17 +304,17 @@ class TurtlePortfolio(object): #---------------------------------------------------------------------- def newSignal(self, signal, direction, offset, price, volume): """对交易信号进行过滤，符合条件的才发单执行""" - pos = self.posDict[signal.vtSymbol] + unit = self.unitDict[signal.vtSymbol] # 如果当前无仓位，则重新根据波动幅度计算委托量单位 - if not pos: + if not unit: size = self.sizeDict[signal.vtSymbol] riskValue = self.portfolioValue * 0.01 - unit = riskValue / (signal.atrVolatility * size) - unit = int(round(unit, 0)) - self.unitDict[signal.vtSymbol] = unit + multiplier = riskValue / (signal.atrVolatility * size) + multiplier = int(round(multiplier, 0)) + self.multiplierDict[signal.vtSymbol] = multiplier else: - unit = self.unitDict[signal.vtSymbol] + multiplier = self.multiplierDict[signal.vtSymbol] # 开仓 if offset == OFFSET_OPEN: @@ -329,29 +331,29 @@ class TurtlePortfolio(object): return # 单品种持仓不能超过上限 - if self.posDict[signal.vtSymbol] >= MAX_PRODUCT_POS: + if self.unitDict[signal.vtSymbol] >= MAX_PRODUCT_POS: return # 卖出 else: if self.totalShort <= -MAX_DIRECTION_POS: return - if self.posDict[signal.vtSymbol] <= -MAX_PRODUCT_POS: + if self.unitDict[signal.vtSymbol] <= -MAX_PRODUCT_POS: return # 平仓 else: if direction == DIRECTION_LONG: # 必须有空头持仓 - if pos >= 0: + if unit >= 0: return # 平仓数量不能超过空头持仓 - volume = min(volume, abs(pos)) + volume = min(volume, abs(unit)) else: - if pos <= 0: + if unit <= 0: return - volume = min(volume, abs(pos)) + volume = min(volume, abs(unit)) # 获取当前交易中的信号，如果不是本信号，则忽略 currentSignal = self.tradingDict.get(signal.vtSymbol, None) @@ -365,27 +367,29 @@ class TurtlePortfolio(object): else: self.tradingDict.pop(signal.vtSymbol) - self.sendOrder(signal.vtSymbol, direction, offset, price, volume, unit) + self.sendOrder(signal.vtSymbol, direction, offset, price, volume, multiplier) #---------------------------------------------------------------------- - def sendOrder(self, vtSymbol, direction, offset, price, volume, unit): + def sendOrder(self, vtSymbol, direction, offset, price, volume, multiplier): """""" # 计算合约持仓 if direction == DIRECTION_LONG: - self.posDict[vtSymbol] += volume + self.unitDict[vtSymbol] += volume + self.posDict[vtSymbol] += volume * multiplier else: - self.posDict[vtSymbol] -= volume + self.unitDict[vtSymbol] -= volume + self.posDict[vtSymbol] -= volume * multiplier # 计算总持仓 self.totalLong = 0 self.totalShort = 0 - for pos in self.posDict.values(): - if pos > 0: - self.totalLong += pos - elif pos < 0: - self.totalShort += pos + for unit in self.unitDict.values(): + if unit > 0: + self.totalLong += unit + elif unit < 0: + self.totalShort += unit # 向回测引擎中发单记录 - self.engine.sendOrder(vtSymbol, direction, offset, price, volume*unit) + self.engine.sendOrder(vtSymbol, direction, offset, price, volume*multiplier) \ No newline at end of file