python函数j解释.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# divmod()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "divmod()函数(使用在两数相加得情况下)：divmod(divident, divisor)参数：divident被除数。divisor除数。显示 5 除以 2 的商和余数：x = divmod(5, 2)  --输出x--(2, 1)返回(a//b, a%b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "m, n = divmod(5, 2)\n",
    "# print(m, n)\n",
    "m = divmod(5, 2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 万能lambda()函数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda函数也被称为匿名(没有名称)函数，它直接接受参数的数量以及使用该参数执行的条件或操作，该参数以冒号分隔，并返回最终结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#结合使用"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# map()函数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "map()函数会根据提供的函数对指定的序列进行映射\n",
    "比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 4, 9, 16, 25]\n",
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "list1 = '1,2,3,4,5'\n",
    "def square(x):\n",
    "    return x**2\n",
    "print(list(map(int, list1.split(','))))#将字符串中的数字放到列表中输出\n",
    "print(list(map(square, list(map(int, list1.split(','))))))#将字符串中的数字进行平方处理，以列表输出\n",
    "print(list(map(lambda x:x**2,list(map(int, list1.split(','))))))#将字符串中的数字进行平方处理，以列表输出"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# format函数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.format函数：字符串的格式化输出，使用{}或者{:}作为占位符，可以代替之前版本的%  \n",
    "2.{:d}、{:06d} 代表输出的是十进制数值，接收的数字是int类型的。如果变量是其他类型的，会报错  \n",
    "3.{:f}、 {:.2f}输出为浮点数。接受的是float类型的。f前加数字，则表示需要保留的位数。如果接收的是其他数据类型，则会报错。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "变量与占位符对应:  \n",
    "a.占位符内，没有任何内容时，则按照变量的顺序，一一对应占位符。  \n",
    "b.占位符内，使用数字，调整变量填充顺序。{}中的数字，代表的是变量的索引。需要注意，变量的索引是从0开始的。{}中输入数字时，不要大于索引，否则会报错。  \n",
    "c.可以进行关键字进行变量对应填充。使用这个方法，需要注意，{}中的关键字一定要和format函数中的关键字一样。  \n",
    "d.如果是列表，还可以使用列表形式的索引。  \n",
    "e.format函数中，还可以使用字典，在{}中输入字典的key，取出对应的值。但是在format函数中，字典需要加上**    \n",
    "\n",
    "3.需要注意的点：占位符可以比变量值少，但不能比变量值多，否则会报错。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = '张三'\n",
    "age = 18\n",
    "address = '北京市'\n",
    "sex = '男'\n",
    "float_num = '123.123456'\n",
    "print('名字是:{}'.format(name))#1\n",
    "print('名字是:{:}'.format(name))#1\n",
    "print('年龄是:{:d}'.format(age))#2\n",
    "print('年龄是:{:03d}'.format(age))#2\n",
    "print('输出一个浮点的数字:{:f}'.format(float_num))\n",
    "print('输出浮点数字,保留3位小数:{:.3f}'.format(float_num))\n",
    "\n",
    "# a.有多个值时，{}没有值，则按顺序一一对应填充\n",
    "print(\"姓名：{:s} \\n年龄:{} \\n地址:{} \\n\".format(name, age, address))\n",
    "# b.当{}中存在数字时，数字对应变量的索引，会按照数字取format函数中的值进行填充。需要注意，索引的值是从0开始。{}中的数字，不能超过变量的索引，否则会报错。\n",
    "print(\"姓名：{1} \\n年龄:{2} \\n地址:{0} \\n\".format(name, age, address))\n",
    "#c.注意关键词要一致\n",
    "print(\"我的名字是{name},年龄是：{age}\".format(name='张三', age=18))\n",
    "#d.定义一个列表\n",
    "list1 = ['张三', 18]\n",
    "print('我的名字是{0[0]}, 年龄是{0[1]}'.format(list1))\n",
    "#e.定义一个字典\n",
    "dict1 = {\"name\": \"张三\", \"age\": 18}\n",
    "print(\"我的名字是：{name}，年龄是：{age}\".format(**dict1))\n",
    "\n",
    "# {}占位符，要比format函数的变量少。否则会报错\n",
    "print(\"姓名：{} \\n年龄:{} \\n地址:{} \\n性别:{}\".format(name, age, address))  # 有4个占位符，三个变量，则报错\n",
    "\n",
    "print(\"姓名：{} \\n年龄:{} \\n地址:{} \\n\".format(name, age, address, sex))  # 有3个占位符，4个变量，则不会报错\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 去掉字符串前后空格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str1 = ' Hello World '\n",
    "print(str1.rstrip())#去除字符串前面的空格\n",
    "print(str1.lstrip())#去除字符串后面的空格\n",
    "print(str1.strip())#去除字符串前后面的空格\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 列表list()函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['Tom', 'Allen']\n",
    "list1.remove('Tom')#列表元素的删除\n",
    "list1.append('John')#列表元素的增加"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdf\n"
     ]
    }
   ],
   "source": [
    "str1 = 'asdf'\n",
    "print(str1*100)#不用循环输出一个字符串多遍"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 大小写字母转换"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "upper()和lower()函数只能让其整体大小写转换\n",
    "\n",
    "capitalize()函数可以将字符串的首字母的开头转换为大写，其他为小写\n",
    "\n",
    "title()函数使字符串的所有单词转为首字母转换为大写，其他为小写"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NIU\n",
      "niu\n",
      "Niu niu\n",
      "Niu Niu\n"
     ]
    }
   ],
   "source": [
    "str_1 = 'niu'\n",
    "str_2 = 'NIU'\n",
    "str_3 = 'niu niu'\n",
    "print(str_1.upper())\n",
    "print(str_2.lower())\n",
    "print(str_3.capitalize())\n",
    "print(str_3.title())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 字符串分割"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "str.split()分割会得到一个列表，后面中可以确定按照什么分割，比如str.split(';')就是按照分号分割，还可以限定最大分割次数，比如str.split(';',1)，即分割一次，后面的会不分割"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['niu', 'niu', 'niu']\n"
     ]
    }
   ],
   "source": [
    "str_1 = 'niu niu niu'\n",
    "print(str_1.split())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可以使用re库的分割来，可以使用正则化来进行多种多样的分割，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n",
      "['a', '123', 'b', '456', 'c', '789', 'd']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "s = 'a123b456c789d'\n",
    "print(re.split(r'\\d+',s))#这个是使用正则表达式让一个或多个连续的数字作为分隔符\n",
    "print(re.split(r'(\\d+)',s))#可以分割一个包含数字和字母的字符串，并保留数字，但是这个是数字串是数字串，字母是字母\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# input() 和 raw_input()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "raw_input()用来获取控制台的输入，该函数会将所有输入作为字符串看待，返回 string 类型，已被弃用\n",
    "\n",
    "input()接受一个标准输入数据，返回为 string 类型，对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a = raw_input(\"input:\")\n",
    "#type(a)\n",
    "#print(a)\n",
    "b = input(\"input:\")\n",
    "type(b)\n",
    "print(b)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# float中的数变为两位小数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "方法一：'%',输出四舍五入的结果\n",
    "方法二：round,输出四舍五入的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 2.3456789\n",
    "print('%.2f'%num)\n",
    "print('%.3f'%num)\n",
    "print('%.4f'%num)\n",
    "print(round(2.25,1))\n",
    "print(round(2.125,2))\n",
    "print(round(2.8756,3))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 浮点数的字符串转换为整数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不能直接转换为int，应该先转换为float再转成int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 123465.416546\n",
    "print(int(float(i)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# int()函数的其他用法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43793\n"
     ]
    }
   ],
   "source": [
    "#int()方法的语法是int(x,base)，这里的base指的是进制数，默认10进制,返回的是一个整数类型\n",
    "#16进制数字转换为10进制就可以写成：\n",
    "num16 = 'AB11'\n",
    "print(int(num16, 16))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 格式并不同"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出print()中逗号，会自动空格，不能像下面这个一样，如果想换行应该重新其一行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_26216\\3159616214.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'\\n'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;31m#这样会使得输出结果a后面自带一个空格\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "print(a,'\\n',b)#这样会使得输出结果a后面自带一个空格"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# range()函数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "range()函数返回的结果并不是列表，而是一个range类型的整数序列的对象 \n",
    "\n",
    "<class 'range'>,但是可以利用list函数返回\n",
    "\n",
    "range本身也是一个迭代器类似于zip\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(10)#从0到10------[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "range(1,11)#从1到11------[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "range(0,30,5)#步长为5从0到30------[0, 5, 10, 15, 20, 25]\n",
    "range(0,-10,-1)#负数------[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n",
    "range(0)#------[]\n",
    "range(1,0)#------[]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy函数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "创建数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用array创建：\n",
    "list01 = [1,2,3,4]\n",
    "array01 = np.array(list01)\n",
    "#使用array创建二维数组：\n",
    "list02 = [[1,2,3,4],[5,6,7,8]]\n",
    "array02 = np.array(list02)\n",
    "#使用array创建三维数组\n",
    "list03 = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]]]\n",
    "array03 = np.array(list03)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用arange创建：arange(start,stop,step,dtype) \n",
    "'''\n",
    "1.不写start，默认从0开始\n",
    "2.左开右闭\n",
    "3.step步长，不写默认是1\n",
    "'''\n",
    "#创建一维数组：\n",
    "a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]\n",
    "a = np.arange(2,10) #[2 3 4 5 6 7 8 9]\n",
    "a = np.arange(1,10,2) #[1 3 5 7 9]\n",
    "a = np.arange(1,10,2,dtype = float)\n",
    "#创建二维数组：\n",
    "b = np.arange(12).reshape(3, 4)#后面的shape模型必须符合前面的大小"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用random创建数组\n",
    "np.random.random(size)#生成0到1之间的随机数\n",
    "np.random.randint(low, high = None, size = None, dtype = \"l\")#生成随机的整数np.random.randint(2, size=10)，dype可选int64等\n",
    "np.random.randn(d0,d1,d2,d3...)#生成标准正态的随机数(期望为0，方差为1)\n",
    "np.random.normal(locscale,size)#生成正态分布（指定期望和方差）\n",
    "np.random.uniform(low,high,size)#生成均匀分布的随机数\n",
    "np.random.shuffle()#随机打乱顺序\n",
    "np.random.seed()#设置随机数种子\n",
    "np.random.sample(size)#生成随机的浮点数\n",
    "#创建一维数组\n",
    "array01 = np.random.random(size = 4)#[0.13475357 0.8088961  0.52055803 0.49706622]\n",
    "#创建二维数组\n",
    "array02 = np.random.random((3,4))\n",
    "#创建三维数组\n",
    "array03 = np.random.random((2,3,4))\n",
    "\n",
    "#创建一维数组\n",
    "array01 = np.random.randint(1,11,10)#1-10\n",
    "#创建二维数组\n",
    "array02 = np.random.randint(1,11,(3,4))#(3，4)为形状\n",
    "#创建三维数组\n",
    "array03 = np.random.randint(1,11,(2,3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#生成均匀分布的随机数\n",
    "np.random.uniform(low,high,size)\n",
    "#四个数据几乎不会相差太多比较均匀\n",
    "array01 = np.random.uniform(size= 4)\n",
    "array02 = np.random.uniform(size= (2,4))\n",
    "array03 = np.random.uniform(high=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#随机打乱顺序\n",
    "np.random.shuffle(array)\n",
    "array01 = np.array([2,5,6,7,3])\n",
    "np.random.shuffle(array01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#设置随机数种子\n",
    "np.random.seed()\n",
    "#从每堆种子里选出来的数都是不会变的，从不同的堆里选随机种子每次都不一样，若想每次都能得到相同的随机数，每次产生随机数之前，都需要调用一次seed()\n",
    "np.random.seed(1)\n",
    "array01 = np.random.randint(1,10,size= 5)\n",
    "np.random.seed(1)\n",
    "array02 = np.random.randint(1,10,size = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#生成随机的浮点数，返回半开区间 [0.0, 1.0) 之间随机的浮点数。\n",
    "np.random.sample(size) #注意，这个np.random.sample和random库里的random.sample不同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#创建指定大小的数组，数组以0填充，下面的order是使其按行或者按列\n",
    "np.zeros(shaps,dtype=float,order=\"C\") \n",
    "array01 = np.zeros(5) #[0. 0. 0. 0. 0.]\n",
    "array02 = np.zeros(5,dtype=\"int32\")  #[0 0 0 0 0]\n",
    "array03 = np.zeros((2,5),dtype=\"int32\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用linscpace是用于创建等差数列，常看到的一般是三个参数，分别是：起始值、终止值（默认包含自身）、数列个数\n",
    "#另外有一个参数endpoint，用于决定是否包含终止值，如果不设置这个参数，默认为是True\n",
    "array01 = np.linspace(1,10,5)#从1-10，生成5个数据\n",
    "array02 = np.linspace(1,10,5,endpoint=True)#把10包含进去\n",
    "array03 = np.linspace(1,10,5,endpoint=False)#把10不包含进去\n",
    "array04 = np.linspace(1,10,5,retstep=True)#显示间距\n",
    "array05 = np.linspace(1,10,5,dtype=\"int32\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "np.stack()函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#stack为堆叠，这个函数主要有两个参数。np.stack([arrays1,array2,array3],axis=0)。\n",
    "#第一个是需要堆叠的多个数组，采用列表的形式输入，\n",
    "#第二个参数是axis，这个参数表示从哪一个维度进行堆叠以及堆叠的内容，这个维度是相对于堆叠的数组来说的。整个函数的输出为一个新数组。\n",
    "array01 = np.array([i for i in range(12)]).reshape(3,4)\n",
    "array02 = np.array([i for i in range(12,24)]).reshape(3,4)\n",
    "array03 = np.array([i for i in range(24,36)]).reshape(3,4)\n",
    "'''\n",
    "a= [[ 0  1  2  3]\n",
    "    [ 4  5  6  7]\n",
    "    [ 8  9 10 11]]\n",
    "b= [[12 13 14 15]\n",
    "    [16 17 18 19]\n",
    "    [20 21 22 23]]\n",
    "c= [[24 25 26 27]\n",
    "    [28 29 30 31]\n",
    "    [32 33 34 35]]\n",
    "'''\n",
    "\n",
    "'''\n",
    "axis = 0:  表示它堆叠方向为第0维,堆叠的内容为数组第0维的数据.前面说了第0维是相对于堆叠的数组而言的,\n",
    "而这里数组的第0维其实就是整个3x4的数组(其中第1维为行,第2维为某一行中的一个值,\n",
    "这里有一个层层深入的感觉),所以就是以整个3x4的数组为堆叠内容在第0维上进行堆叠,\n",
    "等到的结果就是一个3x3x4的新数组。再通俗一点,就是将array01,array02,array03分别作为堆叠内容进行堆叠得到3x3x4的输出。\n",
    "'''\n",
    "new_array = np.stack([array01,array02,array03],axis=0)\n",
    "'''\n",
    "[[[ 0  1  2  3]\n",
    "  [ 4  5  6  7]\n",
    "  [ 8  9 10 11]]\n",
    " [[12 13 14 15]\n",
    "  [16 17 18 19]\n",
    "  [20 21 22 23]]\n",
    " [[24 25 26 27]\n",
    "  [28 29 30 31]\n",
    "  [32 33 34 35]]]\n",
    "'''\n",
    "\n",
    "'''\n",
    "axis = 1:  和刚才的解释一样,axis为1表示堆叠的方向为3x4数组的第1维(行),堆叠内容也为3x4数组的第1维的数据。\n",
    "而3x4的数组的第1维就是它的行,以数组a为例,它的堆叠数据分别是[0 1 2 3],[ 4 5 6 7],[ 8 9 10 11]。\n",
    "所以array01,array02,array03三个数组在第1维上堆叠后的结果就是上面的输出结果。\n",
    "'''\n",
    "new_array = np.stack([array01,array02,array03],axis=1)\n",
    "'''\n",
    "[[[ 0  1  2  3]\n",
    "  [12 13 14 15]\n",
    "  [24 25 26 27]]\n",
    " [[ 4  5  6  7]\n",
    "  [16 17 18 19]\n",
    "  [28 29 30 31]]\n",
    " [[ 8  9 10 11]\n",
    "  [20 21 22 23]\n",
    "  [32 33 34 35]]]\n",
    "'''\n",
    "\n",
    "'''\n",
    "当axis=2时,表示堆叠内容是3x4数组的第二维的数据(数组中某一行的某个值),堆叠方向为第二维(也就是先补全某一行)。\n",
    "对于数组a,第2维的第一个值为0,b为12,c为24,所这三个值组成堆叠后的新数组的一行,以此类推,最终可以得到下面的输出结果。\n",
    "'''\n",
    "new_array = np.stack([array01,array02,array03],axis=2)\n",
    "'''\n",
    "[[[ 0 12 24]\n",
    "  [ 1 13 25]\n",
    "  [ 2 14 26]\n",
    "  [ 3 15 27]]\n",
    " [[ 4 16 28]\n",
    "  [ 5 17 29]\n",
    "  [ 6 18 30]\n",
    "  [ 7 19 31]]\n",
    " [[ 8 20 32]\n",
    "  [ 9 21 33]\n",
    "  [10 22 34]\n",
    "  [11 23 35]]]\n",
    "'''"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.9.1"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c50e4ed3d9da4806a91f113fcb0e907d35733a64e9a7c40b7bb86316e10eca23"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}