numpy_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": "array([2, 5])"
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x=np.array([[1,2,3],[4,5,6]],np.int32)\n",
    "# x.shape\n",
    "# x.dtype\n",
    "# x[1,1]\n",
    "y=x[:,1]\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "data": {
      "text/plain": "array([7, 5])"
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[0] = 7\n",
    "y"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[1, 7, 3],\n       [4, 5, 6]])"
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "outputs": [],
   "source": [
    "# x.flags #获取内存布局信息\n",
    "# x.shape   #数组维度的元组\n",
    "# x.strides   #遍历数组时每个维度中的字节元组  (12, 4)\n",
    "# x.ndim   #数组维度\n",
    "# x.data   #Python缓存区对象指向数组的数据的开头\n",
    "# x.size   #数组中元素的个数\n",
    "# x.itemsize   #一个数组元素的长度，以字节为单位   4\n",
    "# x.nbytes   #数组元素消耗的总字节数\n",
    "x.base   #如果内存来自其他对象，则为基础对象"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[1, 7, 3],\n       [4, 5, 6]])"
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 其他属性\n",
    "# ndarray.T\t转置数组。\n",
    "x.T\n",
    "# ndarray.real\t数组的真实部分。\n",
    "x.real\n",
    "# ndarray.imag\t数组的虚部。\n",
    "x.imag\n",
    "# ndarray.flat\t数组上的一维迭代器。\n",
    "x.flat    #<numpy.flatiter at 0x2ba3c4b78d0>\n",
    "\n",
    "# ndarray.ctypes\t一个简化数组与ctypes模块交互的对象。\n",
    "x.ctypes     #<numpy.core._internal._ctypes at 0x2ba3fa5ca08>\n",
    "x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 7 3]\n",
      " [4 5 6]] 85\n"
     ]
    },
    {
     "data": {
      "text/plain": "array([[1, 7, 3],\n       [4, 5, 6]])"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"数组方法\"\"\"\n",
    "\"\"\"\n",
    "numpy：\n",
    "    all，any，argmax， argmin，argpartition，argsort，choose，\n",
    "    clip，compress，copy，cumprod， cumsum，diagonal，imag，max，\n",
    "    mean，min，nonzero，partition， prod，ptp，put，ravel，real，\n",
    "    repeat，reshape，round， searchsorted，sort，squeeze，std，\n",
    "    sum，swapaxes，take，trace， transpose，var\n",
    "\"\"\"\n",
    "#数组转换\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.item.html#numpy.ndarray.item\n",
    "#ndarray.item(*args)  将数组元素复制到标准的Python标量并返回它\n",
    "# x.item(1)\n",
    "# x.item(1,2)   #数字为一个，则代表数组下标，如果为两个数，则代表行列索引\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.tolist.html#numpy.ndarray.tolist\n",
    "# ndarray.tolist()  将数组作为a.ndim-levels深层嵌套的Python标量列表返回\n",
    "# x.tolist()\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.itemset.html#numpy.ndarray.itemset\n",
    "# ndarray.itemset(*args)  将标量插入数组（如果可能，将标量转化为数组的dtype类型）\n",
    "# x.itemset(x.shape[0],x.shape[1])\n",
    "# x.item(1,2)\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.tostring.html#numpy.ndarray.tostring\n",
    "# ndarray.tostring([order]）  构造包含数组中原始数据字节的Python字节\n",
    "# x.tostring(\"A\")   # order must be one of 'C', 'F', 'A', or 'K'\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.tobytes.html#numpy.ndarray.tobytes\n",
    "# ndarray.tobytes([order]）  构造包含数组中原始数据字节的Python字节\n",
    "# x.tobytes(\"A\")\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.tofile.html#numpy.ndarray.tofile\n",
    "# ndarray.tofile(fid[, sep, format]) 将数组作为文本或二进制写入文件（默认）。\n",
    "# x.tofile(\"numpy_data/array.txt\",sep=\",\",format=\"%.2f\")\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.dump.html#numpy.ndarray.dump\n",
    "# ndarray.dump(file)  将数组的pickle转储到指定的文件\n",
    "# x.dump(\"numpy_data/array_pickle.txt\")\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.astype.html#numpy.ndarray.astype\n",
    "# ndarray.astype(dtype[, order, casting, …])  数组的副本强制转换为指定类型\n",
    "# x.astype(np.float32)\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.byteswap.html#numpy.ndarray.byteswap\n",
    "# ndarray.byteswap([inplace])  交换数组元素的字节\n",
    "# x.byteswap(4)    #inplace：字节数\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.copy.html#numpy.ndarray.copy\n",
    "# ndarray.copy([order])  返回数组的副本。\n",
    "# x.copy()\n",
    "\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.view.html#numpy.ndarray.view\n",
    "# ndarray.view([dtype, type]) 具有相同数据的数组的新视图\n",
    "# x.view(int)\n",
    "# x.view(np.int32)\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.getfield.html#numpy.ndarray.getfield\n",
    "#ndarray.getfield(dtype[,offset]) 返回给定数组的字段作为特定的类型\n",
    "# x.getfield(np.int,0)\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.setflags.html#numpy.ndarray.setflags\n",
    "# ndarray.setflags([write, align, uic]) 分别设置数组标志 WRITEABLE、ALIGNED、WRITEBACKIFCOPY。\n",
    "\n",
    "# x.setflags()  #\n",
    "\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.fill.html#numpy.ndarray.fill\n",
    "# ndarray.fill(value)\t使用标量值填充数组。\n",
    "# x.fill(0)\n",
    "# x\n",
    "x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2 3]\n",
      "  [4 5 6]]\n",
      "\n",
      " [[0 0 0]\n",
      "  [3 2 1]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": "array([[0, 0, 0],\n       [3, 2, 1]])"
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 形状操作\n",
    "#参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.reshape.html#numpy.ndarray.reshape\n",
    "# ndarray.reshape(shape[, order])\t返回包含具有新形状的相同数据的数组。\n",
    "# x.reshape(1,6) #返回数组，对原数组不进行修改\n",
    "\n",
    "# 参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.resize.html#numpy.ndarray.resize\n",
    "# ndarray.resize(new_shape[, refcheck])\t就地更改数组的形状和大小。\n",
    "# x.resize(3,2)   #不返回数组，对原数组进行修改\n",
    "# x\n",
    "\n",
    "# 参考文档：https://numpy.org/devdocs/reference/generated/numpy.ndarray.transpose.html#numpy.ndarray.transpose\n",
    "# ndarray.transpose(*axes) 返回轴转置的数组视图\n",
    "# x.transpose()    #等于x.T\n",
    "\n",
    "\n",
    "# ndarray.swapaxes(axis1:int, axis2:int)    返回数组的视图，其中axis1轴和axis轴互换。\n",
    "# print(x)\n",
    "# x.swapaxes(0,1)\n",
    "\n",
    "# t=np.array([[[1,2,3],[4,5,6]],[[0,0,0],[3,2,1]]])\n",
    "# print(t)\n",
    "# t.swapaxes(0,1)\n",
    "# t"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    加载文件\n",
    "    直接读取该文件并且获取ndarray数组对象\n",
    "    返回值：\n",
    "        unpack = False              返回一个二维数组\n",
    "        unpack = False              多个一维数组\n",
    "    np.loadtxt(fname,delimiter,usecols,unpack,dtype,converters)\n",
    "        fname                   文件路径\n",
    "        delimiter               分隔符\n",
    "        usecols=(1,3)           读取1、3两列，下标从0开始\n",
    "        unpack                  是否按列拆包\n",
    "        dtype                   指定返回每一列数组中元素的类型\n",
    "        converters={1:func}     转换器函数字典\n",
    "\n",
    "\"\"\"\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "def dmy2ymd(dmy):\n",
    "    dmy = str(dmy,encoding=\"utf-8\")\n",
    "    time = datetime.strptime(dmy,\"%d-%m-%Y\").date()\n",
    "    t = time.strftime(\"%Y-%m-%d\")\n",
    "    return t\n",
    "dates,opening_prices,highest_prices,lowest_prices,close_prices=np.loadtxt(fname=\"da_data/aapl.csv\",delimiter=\",\",usecols=(1,3,4,5,6),dtype=\"M8[D],f8,f8,f8,f8\",unpack=True,converters={1:dmy2ymd})\n",
    "# print(res)\n",
    "#绘制直线图\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import dates as dts\n",
    "plt.figure(\"AAPL\",facecolor=\"lightgray\")\n",
    "plt.title(\"AAPL\",fontsize=20)\n",
    "plt.xlabel(\"Date\",fontsize=14)\n",
    "plt.ylabel(\"closing price\",fontsize = 14)\n",
    "plt.grid(linestyle=\":\")\n",
    "#拿到坐标轴\n",
    "ax = plt.gca()\n",
    "#设置主刻度定位器为周定位器（每周一显示主刻度文本）\n",
    "ax.xaxis.set_major_locator( dts.WeekdayLocator(byweekday=dts.MO) )\n",
    "ax.xaxis.set_major_formatter(dts.DateFormatter('%d %b %Y'))\n",
    "#设置次刻度定位器为日定位器\n",
    "ax.xaxis.set_minor_locator(dts.DayLocator())\n",
    "plt.tick_params(labelsize=8)\n",
    "dates = dates.astype(dts.datetime.datetime)\n",
    "plt.plot(dates, opening_prices, color='dodgerblue',\n",
    "\t\tlinestyle='-')\n",
    "plt.gcf().autofmt_xdate()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    k线图的绘制\n",
    "\"\"\"\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "def dmy2ymd(dmy):\n",
    "    dmy = str(dmy,encoding=\"utf-8\")\n",
    "    time = datetime.strptime(dmy,\"%d-%m-%Y\").date()\n",
    "    t = time.strftime(\"%Y-%m-%d\")\n",
    "    return t\n",
    "dates,opening_prices,highest_prices,lowest_prices,close_prices=np.loadtxt(fname=\"da_data/aapl.csv\",delimiter=\",\",usecols=(1,3,4,5,6),dtype=\"M8[D],f8,f8,f8,f8\",unpack=True,converters={1:dmy2ymd})\n",
    "# print(res)\n",
    "#绘制直线图\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import dates as dts\n",
    "plt.figure(\"AAPL\",facecolor=\"lightgray\")\n",
    "plt.title(\"AAPL\",fontsize=20)\n",
    "plt.xlabel(\"Date\",fontsize=14)\n",
    "plt.ylabel(\"closing price\",fontsize = 14)\n",
    "plt.grid(linestyle=\":\")\n",
    "#拿到坐标轴\n",
    "ax = plt.gca()\n",
    "#设置主刻度定位器为周定位器（每周一显示主刻度文本）\n",
    "ax.xaxis.set_major_locator( dts.WeekdayLocator(byweekday=dts.MO) )\n",
    "ax.xaxis.set_major_formatter(dts.DateFormatter('%d %b %Y'))\n",
    "#设置次刻度定位器为日定位器\n",
    "ax.xaxis.set_minor_locator(dts.DayLocator())\n",
    "plt.tick_params(labelsize=8)\n",
    "dates = dates.astype(dts.datetime.datetime)\n",
    "plt.plot(dates, close_prices, color='dodgerblue',\n",
    "\t\tlinestyle='--',linewidth=2,alpha=0.3)\n",
    "#整理颜色\n",
    "rise = close_prices > opening_prices\n",
    "# 第一种方法\n",
    "# color = [\"red\" if c else \"green\" for c in rise]\n",
    "# print(color)\n",
    "# 第二种利用掩码\n",
    "color = np.zeros(rise.size,dtype=\"U5\")\n",
    "color[:] = \"green\"\n",
    "color[rise] = \"white\"\n",
    "\n",
    "\n",
    "edgecolor = [\"red\" if c else \"green\" for c in rise]\n",
    "#绘制实体\n",
    "# plt.bar(dates,close_prices-opening_prices,color=color,linewidth=0.8,bottom=opening_prices,edgecolor=\"black\",zorder=3)\n",
    "plt.bar(dates,close_prices-opening_prices,linewidth=0.8,color=color,bottom=opening_prices,edgecolor=edgecolor,zorder=3)\n",
    "#绘制影线\n",
    "plt.vlines(dates,ymin=lowest_prices,ymax=highest_prices,color=edgecolor)\n",
    "\n",
    "plt.legend()\n",
    "plt.gcf().autofmt_xdate()\n",
    "plt.show()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}