第07讲 Python的数据容器.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python的数据容器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python的基础(内置)数据容器\n",
    "\n",
    "* 元组tuple： (1,2,3)\n",
    "* 列表list:  [1,2,3]\n",
    "* 字典dict:  {'name':'张三','age':20}\n",
    "* 集合set:   {1,2,3,3} \n",
    "* 字符str:  \"string'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Python数组模块引进了array数组容器\n",
    "\n",
    "Python标准模块array定义了一个数组(array)对象类型.\n",
    "array与list,tuple非常相似，不同之处在于，array的元素的类型必须指定，全部元素类型必须相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array('q', [1000, 1001, 1002]) array('i', [12, 34, 56]) array('u', 'Python程序设计')\n"
     ]
    }
   ],
   "source": [
    "from array import array as ay\n",
    "x=ay('q',range(1000,1003))\n",
    "y=ay('i',[12,34,56])\n",
    "zw=ay('u','Python程序设计')\n",
    "print(x,y,zw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  numpy引进N维数组容器( Ndarray)\n",
    " ```\n",
    "import numpy as np \n",
    "a = np.array([1,2,3])  \n",
    "print (a)\n",
    " ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[2.5 3.5 4.5]\n",
      "[0.81649658 0.81649658]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x=np.array([[1,2,3],[4,5,6]])\n",
    "print(x)\n",
    "print(x.mean(axis=0))\n",
    "print(x.std(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元组tuple\n",
    "\n",
    "多个相同或不同类型的数据用逗号分隔，就是一个元组。也可以将元组数据放入一对圆括号中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 34, 135, 'JW', 56.6, True, 123.9, False)\n",
      "Variable   Type      Data/Info\n",
      "------------------------------\n",
      "ay         type      <class 'array.array'>\n",
      "np         module    <module 'numpy' from 'C:\\<...>ges\\\\numpy\\\\__init__.py'>\n",
      "x          tuple     n=8\n",
      "y          int       12\n",
      "z          tuple     n=1\n",
      "zw         array     array('u', 'Python程序设计')\n",
      "34\n",
      "False\n",
      "('lsm', 'lyt', 'lkr', 12.5, 17.6, 10)\n"
     ]
    }
   ],
   "source": [
    "x=12,34,56+79,\"JW\",56.6,True,123.9,False\n",
    "print(x)\n",
    "y=12   #不是元组\n",
    "z=12,  #加逗号，为元组\n",
    "%whos\n",
    "print(x[1])\n",
    "print(x[-1])\n",
    "y=(\"lsm\",\"\"\"lyt\"\"\",'lkr',12.5,17.6,10)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x.count(v)用来统计v在元组x中出现的次数。\n",
    "x.index(v)给出v值在 x中第一次出现的索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(x.count(135))\n",
    "print(x.index(12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable   Type      Data/Info\n",
      "------------------------------\n",
      "ay         type      <class 'array.array'>\n",
      "np         module    <module 'numpy' from 'C:\\<...>ges\\\\numpy\\\\__init__.py'>\n",
      "x          tuple     n=8\n",
      "y          tuple     n=6\n",
      "z          tuple     n=1\n",
      "zw         array     array('u', 'Python程序设计')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(12,\n",
       " 34,\n",
       " 135,\n",
       " 'JW',\n",
       " 56.6,\n",
       " True,\n",
       " 123.9,\n",
       " False,\n",
       " 'lsm',\n",
       " 'lyt',\n",
       " 'lkr',\n",
       " 12.5,\n",
       " 17.6,\n",
       " 10)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%whos\n",
    "x+y  #元组加法：元组链接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 元组的巧妙利用!\n",
    "\n",
    "元组容器应用举例：\n",
    "def mul(x,y,z):return x\\*y\\*z\n",
    "\n",
    "1. 调用方法一：\n",
    "mul(10,20,30)  ==>6000\n",
    "\n",
    "2. 调用方法二：\n",
    "a,b,c=10,20,30;mul(a,b,c)==>6000\n",
    "\n",
    "3. 调用方法三：\n",
    "x=10,20,30;mul(*x)==>6000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6000\n",
      "6000\n",
      "6000\n"
     ]
    }
   ],
   "source": [
    "def mul(x,y,z):\n",
    "    return x*y*z\n",
    "\n",
    "print(mul(10,20,30))\n",
    "\n",
    "a,b,c=10,20,30;\n",
    "print(mul(a,b,c))\n",
    "\n",
    "x=10,20,30;\n",
    "print(mul(*x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**修改函数mul的定义，可以支持任意参数个数——任意的参数列表**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mul2(*x):\n",
    "    n=len(x)\n",
    "    p=1\n",
    "    for i in x:\n",
    "         p*=i\n",
    "    return p\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "240000\n"
     ]
    }
   ],
   "source": [
    "y=10,20,30,40\n",
    "print(mul2(*y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List列表容器及其函数和方法\n",
    "\n",
    "多个相同或不同类型数据用逗号分隔并放入一对方括号内，就是一个列表。也可以将元组用 list()转换为列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 'lyt', 34, 18.8, 1927.8000000000002, 540]\n"
     ]
    }
   ],
   "source": [
    "y=12,'lyt',34, 18.8,34*56.7,540;\n",
    "z=list(y);\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
      "[1, 5, 8, 4, 2]\n",
      "[1, 2, 4, 5, 8]\n",
      "Help on int object:\n",
      "\n",
      "class int(object)\n",
      " |  int([x]) -> integer\n",
      " |  int(x, base=10) -> integer\n",
      " |  \n",
      " |  Convert a number or string to an integer, or return 0 if no arguments\n",
      " |  are given.  If x is a number, return x.__int__().  For floating point\n",
      " |  numbers, this truncates towards zero.\n",
      " |  \n",
      " |  If x is not a number or if base is given, then x must be a string,\n",
      " |  bytes, or bytearray instance representing an integer literal in the\n",
      " |  given base.  The literal can be preceded by '+' or '-' and be surrounded\n",
      " |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\n",
      " |  Base 0 means to interpret the base from the string as an integer literal.\n",
      " |  >>> int('0b100', base=0)\n",
      " |  4\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __and__(self, value, /)\n",
      " |      Return self&value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __ceil__(...)\n",
      " |      Ceiling of an Integral returns itself.\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floor__(...)\n",
      " |      Flooring an Integral returns itself.\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getnewargs__(self, /)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __index__(self, /)\n",
      " |      Return self converted to an integer, if self is suitable for use as an index into a list.\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __invert__(self, /)\n",
      " |      ~self\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lshift__(self, value, /)\n",
      " |      Return self<<value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rand__(self, value, /)\n",
      " |      Return value&self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rlshift__(self, value, /)\n",
      " |      Return value<<self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __round__(...)\n",
      " |      Rounding an Integral returns itself.\n",
      " |      Rounding with an ndigits argument also returns an integer.\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rrshift__(self, value, /)\n",
      " |      Return value>>self.\n",
      " |  \n",
      " |  __rshift__(self, value, /)\n",
      " |      Return self>>value.\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __rxor__(self, value, /)\n",
      " |      Return value^self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Returns size in memory, in bytes.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __trunc__(...)\n",
      " |      Truncating an Integral returns itself.\n",
      " |  \n",
      " |  __xor__(self, value, /)\n",
      " |      Return self^value.\n",
      " |  \n",
      " |  bit_length(self, /)\n",
      " |      Number of bits necessary to represent self in binary.\n",
      " |      \n",
      " |      >>> bin(37)\n",
      " |      '0b100101'\n",
      " |      >>> (37).bit_length()\n",
      " |      6\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      Returns self, the complex conjugate of any int.\n",
      " |  \n",
      " |  to_bytes(self, /, length, byteorder, *, signed=False)\n",
      " |      Return an array of bytes representing an integer.\n",
      " |      \n",
      " |      length\n",
      " |        Length of bytes object to use.  An OverflowError is raised if the\n",
      " |        integer is not representable with the given number of bytes.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.\n",
      " |      signed\n",
      " |        Determines whether two's complement is used to represent the integer.\n",
      " |        If signed is False and a negative integer is given, an OverflowError\n",
      " |        is raised.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  from_bytes(bytes, byteorder, *, signed=False) from builtins.type\n",
      " |      Return the integer represented by the given array of bytes.\n",
      " |      \n",
      " |      bytes\n",
      " |        Holds the array of bytes to convert.  The argument must either\n",
      " |        support the buffer protocol or be an iterable object producing bytes.\n",
      " |        Bytes and bytearray are examples of built-in objects that support the\n",
      " |        buffer protocol.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.\n",
      " |      signed\n",
      " |        Indicates whether two's complement is used to represent the integer.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  denominator\n",
      " |      the denominator of a rational number in lowest terms\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  numerator\n",
      " |      the numerator of a rational number in lowest terms\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print([1,2,3]+[4,5,6])\n",
    "print([1,2,3]*3)\n",
    "z=[1,5,8,4,2]\n",
    "print(z)\n",
    "z.sort()\n",
    "print(z)\n",
    "help(z.pop())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python的字典容器及其函数方法\n",
    "\n",
    "多个赋值语句或多对键:值用逗号分隔并放入一对花括号中，就是一个字典容器。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'lsm': 64, 'lsw': 46} {'lsm': 64, 'lsw': 46}\n"
     ]
    }
   ],
   "source": [
    "d={'lsm':64,'lsw':46};\n",
    "g=dict(lsm=64,lsw=46);\n",
    "print(d,g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义函数的形参变量或调用函数的实参命令如果是字典类型，则变量名前总是带**标记。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典变量的引用\n",
    "用d.keys()引用所有键，用 d.values()引用所有值，例如"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dict_keys(['lsm', 'lsw']), dict_values([64, 46]))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys(),d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': '张三', 'age': 20, 5: 50}\n",
      "张三 50\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "d= {'name':'张三','age':20,5:50}\n",
    "print(d)\n",
    "print(d['name'],d[5])\n",
    "d.clear()\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字典容器实例的应用\n",
    "matplotlib中plot函数\n",
    "\n",
    "##### 字典实例应用举例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# coding=UTF-8\n",
    "\n",
    "from matplotlib import pyplot as plt  #从matplotlib导入子包pyplot昵称plt\n",
    "from scipy.special import jn         #从 scipy导入子包bessel函数jn\n",
    "\n",
    "plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签\n",
    "plt.rcParams['axes.unicode_minus']=False #用来正常显示负号\n",
    "\n",
    "x=plt.np.linspace(0,30,50)  #导入子包pyplot时自动导入了数组包numpy昵称np\n",
    "y=jn(0,x),jn(1,x),jn(2,x),jn(3,x) #元组容器实例y含4个成员\n",
    "\n",
    "dt0=dict(color='r',marker='o',linestyle='-', linewidth=1.5, markersize=6)\n",
    "dt1=dict(color='g',marker='s',linestyle='-.',linewidth=2,   markersize=8)\n",
    "dt2=dict(color='b',marker='v',linestyle='--',linewidth=2.5, markersize=10)\n",
    "dt3=dict(color='m',marker='d',linestyle=':', linewidth=3,   markersize=12)\n",
    "dt=dt0,dt1,dt2,dt3  #定义0~3阶bessel函数曲线特征字典值成员组成的元组变量\n",
    "\n",
    "for i in range(4):\n",
    "    plt.plot(x,y[i],**dt[i])\n",
    "    \n",
    "plt.xlabel('X-轴')\n",
    "plt.ylabel('Y-轴  Basselj(0:3,X)')\n",
    "plt.title(u'贝瑟尔函数曲线')\n",
    "plt.legend(['besselj(0,x)','besselj(1,x)','besselj(2,x)','besselj(3,x)'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### matplotlib.pyplot中的numpy使用说明\n",
    "\n",
    ">对于导入matplotlib.pyplot时自动导入了数组包numpy昵称np,通过下面的程序可以验证与import numpy as np导入的numpy是同一个对象（ID值相同），实质是同一个对象，不会重复导入。如果程序主要是绘图，可以使用plt.np.\\*，但我更倾向于二则同时导入，让写代码时分清楚是使用numpy进行数据处理还是使用pyplot绘图。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2080139141832\n",
      "2080139141832\n"
     ]
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "print(id(np))\n",
    "print(id(plt.np))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python的集合容器及其函数方法\n",
    "\n",
    "多个同类型或不同类型的数据用逗号分隔并放入一对花括号中，就是一个集合容器。\n",
    "\n",
    "其他非字典命令都可以调用集合容器函数名set()转换为集合。集合无重复元数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, '龙姝明', 'python', 1, 2, 3, 4, 5, '龙姝明', 'python'] {1, 2, 3, 4, 5, 'python', '龙姝明'}\n"
     ]
    }
   ],
   "source": [
    "p= [1, 2, 3, 4, 5, '龙姝明', 'python', 1, 2, 3, 4, 5, '龙姝明', 'python'] \n",
    "q=set(p)\n",
    "print(p,q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 集合的函数\n",
    "       集合实例.《TAB》将给出 add()   clear()    copy()    difference()   difference_update()   discard()  intersection()  intersection_update()，分别是加、清理、拷贝、求差、更新求差、抛弃、求交集、更新求交集。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy N维数组容器(Ndarray)\n",
    "The N-dimensional array (ndarray)\n",
    "\n",
    "ndarray是同构多维数组，它是一个元素表（通常是数字），所有类型都相同，由非负整数元组索引。在NumPy维度中称为 轴 。\n",
    "\n",
    "一个 ndarray是具有相同类型和大小的项目的（通常是固定大小的）多维容器。 尺寸和数组中的项目的数量是由它的shape定义， 它是由N个非负整数组成的tuple（元组），用于指定每个维度的大小。 数组中项目的类型由单独的data-type object (dtype)指定， 其中一个与每个ndarray相关联。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# dir(np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub data rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_data_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  25   67 -120  117   81]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([  25,   67, -120,  117,   81])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "a=np.array([25,67,-120,117,81])\n",
    "print(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [10 22 31]]\n"
     ]
    }
   ],
   "source": [
    "x=np.array([[1,2,3],[4,5,6],[10,22,31]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  8, 15, 22, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 99])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.arange(1,100,7);a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=np.linspace(0,2,11);b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "c=np.ones((2,5));print(c)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PythonLearn",
   "language": "python",
   "name": "pythonlearn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}