internlm_summer_camp_python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2a9b37ad-dbbc-432b-afc0-099423fd5e71",
   "metadata": {},
   "source": [
    "# InternLM Python入门教程code\n",
    "Author：Charleson \n",
    "\n",
    "本notebook是为书生浦语大模型实战营编写的Python与Numpy入门教程的code部分。notebook可以交互式地编写和运行代码，方便运行教程中的示例与完成作业。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d2deec2-e070-4681-b547-2402d6258131",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Chapter2: Python基础"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8afb70a8-cc2b-42c9-8a21-631a009b2bd3",
   "metadata": {},
   "source": [
    "### 2.1 Python基础语法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac73e2f6-892f-41de-b2f4-a4ce50436b42",
   "metadata": {},
   "outputs": [],
   "source": [
    "#这是一个单行注释\n",
    "'''\n",
    "这是一个多行注释\n",
    "这是一个多行注释\n",
    "'''\n",
    "print(\"hello world\")#从hello world开始认识Python\n",
    "print(1+1)\n",
    "print(1+2)\n",
    "#print函数是Python中用于输出信息到控制台的内置函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e04d0e4-10da-4767-b43f-bcb0ee366ea2",
   "metadata": {},
   "source": [
    "在python中，代码块不使用{}来表示，而是通过行与缩进来表示，同一个代码块有着相同的缩进。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c76992b6-0ecd-4fa0-8bb1-07115df7be41",
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print('hello world!')\n",
    "    print('hello python!')\n",
    "else:\n",
    "    print('goodbye python!')\n",
    "    print('goodbye world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19b7d16b-d94c-4563-b1b1-d8304ad57903",
   "metadata": {},
   "source": [
    "python标识符(变量名，函数名)命名要求：\n",
    "* 标识符须要由字母，数字和下划线组成\n",
    "* 首字符必须是字母或者下划线_\n",
    "* 标识符对大小写敏感\n",
    "* 标识符不能与python关键字重名\n",
    "\n",
    "以下代码可以查看python的关键词（保留字符）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fd9b386-2a04-4f77-8f30-bdbb28c8a084",
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2123193d-a5c7-47f9-a116-69ca3510222c",
   "metadata": {},
   "source": [
    "### 2.2 基本数据类型\n",
    "\n",
    "python基本数据类型:\n",
    "* 数字Number\n",
    "    * int整数\n",
    "    * float浮点数\n",
    "    * complex复数\n",
    "* 布尔型bool\n",
    "* 列表list\n",
    "* 元组tuple\n",
    "* 集合set\n",
    "* 字典Dictionary\n",
    "\n",
    "可以修改的是：列表list，集合set，字典Dictionary\n",
    "\n",
    "不可以修改的是：数字Number，布尔型bool，元组tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c848f417-6503-483e-b474-a72745c2332e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#python中变量赋值的方式\n",
    "a = 1\n",
    "b = 2\n",
    "print(a+b)\n",
    "a,b = 1,2 #另一种单行赋值的方式\n",
    "print(1,2)\n",
    "\n",
    "#下面让我们来看看各种类型的数据长什么样\n",
    "t_int = 1 #整数\n",
    "t_float = 1.0 #浮点数\n",
    "t_complex = 1.2j #复数\n",
    "t_bool = True #布尔类型\n",
    "t_list = [1,1,3,3,5,5] #列表\n",
    "t_tuple = (1,1,3,3,5,5) #元组\n",
    "t_set = (1,3,5) #集合\n",
    "t_dict = {'day':18,'month':6,'year':2024} #字典\n",
    "\n",
    "print(\" t_int的类型是：\",type(t_int),' t_int的值是: ',t_int)\n",
    "print(\" t_float的类型是：\",type(t_float),' t_float的值是: ',t_float)\n",
    "print(\" t_complex的类型是：\",type(t_complex),' t_complex的值是: ',t_complex)\n",
    "print(\" t_bool的类型是：\",type(t_bool),' t_bool的值是: ',t_bool)\n",
    "print(\" t_list的类型是：\",type(t_list),' t_list的值是: ',t_list)\n",
    "print(\" t_tuple的类型是：\",type(t_tuple),' t_tuple的值是: ',t_tuple)\n",
    "print(\" t_set的类型是：\",type(t_set),' t_set的值是: ',t_set)\n",
    "print(\" t_dict的类型是：\",type(t_dict),' t_int的值是: ',t_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87a9b5eb-0fcc-4454-a9c9-5676434617c1",
   "metadata": {},
   "source": [
    "### 2.3 运算符\n",
    "#### 2.3.1 算数运算符\n",
    "| 运算符 | 描述 |\n",
    "| --- | --- |\n",
    "| `+` | 加 |\n",
    "| `-` | 减 |\n",
    "| `*` | 乘 |\n",
    "| `/` | 除 |\n",
    "| `//` | 整除,只保留整数 |\n",
    "| `%` | 模运算或者取余数除法,只保留余数 |\n",
    "| `**` | 幂运算 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83fae77b-8ecb-4208-916b-33969392ad05",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"1+1 =\",1+1)\n",
    "print(\"2-1 =\",2-1)\n",
    "print(\"2*4 =\",2*4)\n",
    "print(\"2*4 =\",2*4)\n",
    "print(\"8//3 =\",8//3)\n",
    "print(\"8%5 =\",8%5)\n",
    "print(\"2**3 =\",2**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7647a8cd-1719-4200-bf9e-c60a0561f284",
   "metadata": {},
   "source": [
    "#### 2.3.2 比较运算符\n",
    "| 运算符 | 描述 |\n",
    "| --- | --- |\n",
    "| `>` | 大于 |\n",
    "| `<` | 小于 |\n",
    "| `>=` | 大于等于 |\n",
    "| `<=` | 小于等于 |\n",
    "| `==` | 等于 |\n",
    "| `!=` | 不等于 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a38952-e4f4-43be-a9ce-bbf2751c423e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = 10,20\n",
    "print(\"a>b =\",a>b)\n",
    "print(\"a<b =\",a<b)\n",
    "print(\"a>=b =\",a>=b)\n",
    "print(\"a<=b =\",a<=b)\n",
    "print(\"a==b =\",a==b)\n",
    "print(\"a!=b =\",a!=b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5fae9c4-3854-4966-a58b-38239beaffb4",
   "metadata": {},
   "source": [
    "#### 2.3.3 赋值运算符\n",
    "| 运算符 | 描述 | 等价表达 |\n",
    "| --- | --- | --- |\n",
    "| `=` | 基础赋值 | |\n",
    "| `+=` | 加法赋值 | a+=b等价于 a=a+b |\n",
    "| `-=` | 减法赋值 | a-=b等价于 a=a-b |\n",
    "| `*=` | 小于等于 | a*=b等价于 a=a*b |\n",
    "| `/=` | 等于 | a/=b等价于 a=a/b |\n",
    "| `//=` | 等于 | a//=b等价于 a=a//b |\n",
    "| `%=` | 等于 | a%=b等价于 a=a%b |\n",
    "| `**=` | 等于 | a**=b等价于 a=a**b |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99c5f517-e20a-4f99-acfa-2764a051ae1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = 2,2\n",
    "a += 1\n",
    "b = b+1\n",
    "print(\"a+=1,a=\",a)\n",
    "print(\"b=b+1,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a -= 1\n",
    "b = b-1\n",
    "print(\"a-=1,a=\",a)\n",
    "print(\"b=b-1,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a *= 2\n",
    "b = b*2\n",
    "print(\"a*=2,a=\",a)\n",
    "print(\"b=b*2,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a /= 2\n",
    "b = b/2\n",
    "print(\"a/=2,a=\",a)\n",
    "print(\"b=b/2,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a //= 2\n",
    "b = b//2\n",
    "print(\"a//=2,a=\",a)\n",
    "print(\"b=b//2,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a %= 3\n",
    "b = b%3\n",
    "print(\"a%=3,a=\",a)\n",
    "print(\"b=b%3,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a %= 3\n",
    "b = b%3\n",
    "print(\"a%=3,a=\",a)\n",
    "print(\"b=b%3,b=\",b)\n",
    "\n",
    "print(\"-\"*20)\n",
    "a,b = 2,2\n",
    "a **= 3\n",
    "b = b**3\n",
    "print(\"a**=3,a=\",a)\n",
    "print(\"b=b**3,b=\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62dd57a9-286e-417c-97c5-69af934a8ea7",
   "metadata": {},
   "source": [
    "#### 2.3.4 逻辑运算符\n",
    "| 运算符 | 描述 |\n",
    "| --- | --- |\n",
    "| `and` | 逻辑与 |\n",
    "| `or` | 逻辑或 |\n",
    "| `not` | 逻辑非 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a135a654-00d1-4660-bf6c-c2e3d06f288b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = True,False\n",
    "print(\"a and b =\",a and b)\n",
    "print(\"a or b =\",a and b)\n",
    "print(\"not b =\",not a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31e779d0-7591-4a04-b419-28d7fe88b522",
   "metadata": {},
   "source": [
    "### 2.4 列表\n",
    "列表是一个有索引的序列，索引从0开始。\n",
    "\n",
    "列表式一个有序的可重复元素序列。列表是可变的，列表中的元素可以重复，可以是不同的类型。\n",
    "\n",
    "\n",
    "列表非常重要，他不仅是python开发中最常用的数据结构，同时也是python序列中最具代表性的一个。 当能够理解列表以后，剩下的其他序列学起来就没有那么困难。\n",
    "\n",
    "#### 2.4.1 列表的创建方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f846c097-623d-42f4-806a-4c6e8e9b4c86",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [1,2,3,4,5,6] #列表使用[]表示，每个元素之间用,隔开\n",
    "print('alist :',alist)\n",
    "blist = list(\"hello world!\") #列表也可以使用list()函数将其他可迭代的对象转换为列表，比如字符串。字符串的结构我们会在字符串小节里具体介绍\n",
    "print('blist :',blist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2318875c-9550-4749-8b4b-b7bc116216f9",
   "metadata": {},
   "source": [
    "#### 2.4.2 访问元素的方法，索引与切片 \n",
    "\n",
    "python中的序列均有正向索引与反向索引，正向索引从0开始表示序列第一个元素，反向索引从-1开始表示\n",
    "以alist为例子，我们打印出alist中每个元素对于的正向索引与反向索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f6a8d97-d4ce-41ab-bd66-68e12d535af7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('elements: ','   '.join([str(i) for i in alist]))\n",
    "print('正向索引:  ','   '.join([str(i) for i in range(0,len(alist))]))\n",
    "print('反向索引:  ','  '.join([str(i) for i in range(-len(alist),0)]))#这里的len函数是用来获取列表长度的，后面会具体介绍"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2f4ca2c-6e0b-4c2f-92cc-ba259360a6d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#取列表第一个元素的两种方式\n",
    "print('第一个元素: ',alist[0])\n",
    "print('第一个元素: ',alist[-6])\n",
    "\n",
    "#取列表最后一个元素的两种方式\n",
    "print('最后一个元素: ',alist[-1])\n",
    "print('最后一个元素: ',alist[5])\n",
    "\n",
    "#修改第二个元素\n",
    "print('alist[1]=0')\n",
    "alist[1]=0\n",
    "print(alist)\n",
    "\n",
    "#删除第二个元素\n",
    "del alist[1]\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faeb6594-2be1-4937-861b-5ba3740f6542",
   "metadata": {},
   "source": [
    "列表支持切片操作，即截取列表中的一部分长度的操作。\n",
    "\n",
    "具体语法为 list_name\\[start_index:end_index:step\\]。\n",
    "\n",
    "start_index为起点索引，end_index为终点索引，step为步长。要注意截取的部分为\\[start_index,end_index\\),也就是不包括end_index。\n",
    "\n",
    "其中step缺省时默认步长为1，start_index缺省时默认为第一个元素，end_index缺省时默认为最后一个元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95974b00-2bda-4822-96bb-128fdaa4ac43",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [1,2,3,4,5,6]\n",
    "print(alist)\n",
    "\n",
    "print('获取前三个元素')\n",
    "print('alist[0:3]: ',alist[0:3])\n",
    "print('alist[:3]: ',alist[:3])\n",
    "\n",
    "print('获取第二个到第四个元素（索引1至3）')\n",
    "print('alist[1:4]: ',alist[1:4])\n",
    "\n",
    "print('获取最后三个元素')\n",
    "print('alist[-3:]: ',alist[-3:])\n",
    "\n",
    "print('获取所有索引为奇数的元素')\n",
    "print('alist[1::2]: ',alist[1::2])\n",
    "\n",
    "print('获取所有索引为偶数的元素')\n",
    "print('alist[::2]: ',alist[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "540311e9-3348-44c7-b98e-3a217ae51d8c",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 2.4.3 列表运算符\n",
    "| 运算符 | 描述 |\n",
    "| --- | --- |\n",
    "| `+` | 拼接两个列表 |\n",
    "| `*` | 列表*整数，将列表重复 |\n",
    "| `in` | 元素是否在列表内|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdde5829-8a91-42be-8d01-3853b888af2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [1,2,3]\n",
    "blist = [4,5,6]\n",
    "print('alist+blist: ',alist+blist)\n",
    "print('alist*3: ',alist*3)\n",
    "print('3 in alist: ',3 in alist)\n",
    "print('4 in alist: ',4 in alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42156728-d4e5-4804-9026-894a6f649d43",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 2.4.3 列表函数与方法\n",
    "| 函数名 | 描述 |\n",
    "| --- | --- |\n",
    "| `len()` | 列表长度 |\n",
    "| `max()` | 列表中的最大值|\n",
    "| `min()` | 列表中的最小值|\n",
    "\n",
    "| 方法名 | 描述 |返回值|\n",
    "| --- | --- | --- |\n",
    "| `list.append(obj)` | 在列表末尾添加新元素 | 无，原地操作 |\n",
    "| `list.count(obj)` | 统计一个元素在列表中出现的次数 | 返回该元素出现的次数 |\n",
    "| `list.extend(seq)` | 将一个序列中的所有元素添加到列表末尾 | 无，原地操作 |\n",
    "| `list.index(obj)` | 从列表中找出某个值第一个匹配项的索引位置 | 返回索引 |\n",
    "| `list.insert(index, obj)` | 将元素插入列表中的指定位置 | 无，原地操作 |\n",
    "| `list.pop([index=-1])` | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 | 返回移除的元素值 |\n",
    "| `list.remove(obj)` | 移除列表中某个值第一个匹配项 | 无，原地操作 |\n",
    "| `list.reverse()` | 逆向排列列表中的所有元素 | 无，原地操作 |\n",
    "| `list.sort(key=None,reverse=False)` | 对列表内元素进行排序，默认为升序 | 无，原地操作 |\n",
    "| `list.clear()` | 清空列表 | 无，原地操作 |\n",
    "| `list.copy()` | 复制列表 | 复制后的列表 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6148fe46-7be5-40f2-8d07-fa333573eb07",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [0,1,1,2,3,4,5,6,7,8]\n",
    "print(len(alist))\n",
    "print(max(alist))\n",
    "print(min(alist))\n",
    "alist.sort(key=None,reverse=False)\n",
    "alist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7c4b970-c017-4444-9113-e64fb8c7984b",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist.append(10)#.append不会返回任何内容，直接在原列表上操作\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1532b8c-6269-4753-a040-94d5b9d2775b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('10出现的次数:',alist.count(10))#.count会返回该元素出现的次数平\n",
    "print('1出现的次数:',alist.count(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d945383-3f97-43b4-981c-025361efcdb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist.extend([11,12])#.extend不会返回任何内容，直接在原列表上操作\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7033451e-3a76-4180-83b1-d18335ff2ccc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('1出现的首个索引为',alist.index(1))#.index会返回匹配到的首个元素的索引,即1，而非2\n",
    "print('2出现的首个索引为',alist.index(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe165596-1c42-4b63-bdf5-653b05501ce1",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist.insert(1,0)#在索引为1的位置插入一个0，没有返回值\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85378b21-cd1f-4ab3-8bdf-2b4b0150636c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"移除最后一个元素: \",alist.pop())#移除最后元素，没有返回值\n",
    "print(alist)\n",
    "print(\"移除索引为6的元素: \",alist.pop(6))#移除索引为6的元素，没有返回值\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9447fbc-a7f0-4ac9-abc8-ad2ba392568c",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist.remove(11)#删除第一个等于11的元素，但没有返回值\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c40a49bd-e43d-41e2-8ef2-2145b10706ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist.reverse()#逆向排列列表中的所有元素\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "644762dd-114e-447b-8be3-96960a9e0b72",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist.sort()#将列表中的所有元素按升序排列，没有返回值\n",
    "print(alist)\n",
    "alist.sort(reverse=True)#将列表中的所有元素按降序排列，没有返回值\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "768c1835-b28e-4dee-8a98-4beb9d830d19",
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy和clear我们放到一起讲\n",
    "#如何备份一个alist?直接=和使用copy的区别？\n",
    "alist_copy = alist#\n",
    "print('alist_copy: ',alist_copy)\n",
    "alist_copy.clear()#清空alist_copy\n",
    "print('alist_copy: ',alist_copy)\n",
    "print('alist: ',alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6563be6-8223-45c7-9754-1f98e12bb1c8",
   "metadata": {},
   "source": [
    "alist_copy = alist时并没有新建一个对象，而只是单纯赋值了alist的地址给alist_copy。这会导致我们对变量alist_copy的所有操作本质上都是在操作alist。而当我们使用.copy()方法进行赋值时，会复制alist为一个新的对象，此时对新对象的修改不会影响到alist。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ea1de64-f9a9-4860-8404-355f812319f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [10, 8, 7, 6, 5, 3, 2, 1, 1, 0, 0]\n",
    "alist_copy = alist.copy()\n",
    "print('alist_copy: ',alist_copy)\n",
    "alist_copy.clear()#清空alist_copy\n",
    "print('alist_copy: ',alist_copy)\n",
    "print('alist: ',alist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e2b12d8-bdf9-4dd5-bb95-68594ea6291c",
   "metadata": {},
   "outputs": [],
   "source": [
    "33.6/100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cccb3a6b-0c34-4804-85a3-02c7b1119a9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "49.8/150"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6690720-e26d-48d8-b3c3-2244ef0d564b",
   "metadata": {},
   "source": [
    "### 2.6 元组\n",
    "\n",
    "元组和列表很相似，但是元组创建后不可修改。\n",
    "\n",
    "元组使用()来表示，创建元组和列表一样，只要在()内添加元素并用逗号隔开就行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29e44542-c027-4789-8239-61a8ce4235d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "atuple = (1,2,3)\n",
    "print(atuple[0])\n",
    "print(atuple[1:3])#元组的索引与切片与列表一致"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4db2496-d2c8-4d58-a32b-601ebcb6e038",
   "metadata": {},
   "outputs": [],
   "source": [
    "#当尝试修改元组内部的元素时，会报错\n",
    "atuple[1]=2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f2c573b-e180-447b-bc3a-ac5a2177d868",
   "metadata": {},
   "source": [
    "#### 2.6.1 元组的运算符\n",
    "元组的运算符与列表一模一样\n",
    "| 运算符 | 描述 |\n",
    "| --- | --- |\n",
    "| `+` | 拼接两个元组 |\n",
    "| `*` | 列表*整数，将元组重复 |\n",
    "| `in` | 元素是否在元组内|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00106b20-8d12-4ccf-be0c-13b9a8ae3146",
   "metadata": {},
   "outputs": [],
   "source": [
    "atuple = (1,2,3)\n",
    "btuple = (4,5,6)\n",
    "print('alist+blist: ',atuple+btuple)\n",
    "print('alist*3: ',atuple*3)\n",
    "print('3 in alist: ',3 in atuple)\n",
    "print('4 in alist: ',4 in atuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8f5c96b-358f-48fd-b94a-84cf2899dbd8",
   "metadata": {},
   "source": [
    "#### 2.6.2 元组的函数\n",
    "元组支持的函数也与列表一模一样\n",
    "| 函数名 | 描述 |\n",
    "| --- | --- |\n",
    "| `len()` | 列表长度 |\n",
    "| `max()` | 列表中的最大值|\n",
    "| `min()` | 列表中的最小值|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd7abb3e-0e88-45ad-8541-fe628a7a0eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "atuple = (1,2,3,4)\n",
    "print(len(atuple))\n",
    "print(max(atuple))\n",
    "print(min(atuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cecc00df-0441-49a0-a7a5-c5ddf4f7bf24",
   "metadata": {},
   "source": [
    "### 2.7 集合\n",
    "集合是无序的不重复的元素序列，支持交集、并集、差集等常见的集合操作。\n",
    "\n",
    "集合的创建使用{}表示，并用,隔开。注意如果需要创建一个空集合需要使用set()。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5813788-8998-4ec4-8917-2f95b9ce0f45",
   "metadata": {},
   "outputs": [],
   "source": [
    "#新建一个集合\n",
    "aset = {1,2,3,4,5}\n",
    "print('这是一个新集合: ',aset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d769326-4e35-473a-a939-53f46800b1f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#新建一个空集合\n",
    "aset = set()\n",
    "print('这是一个空集合: ',aset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "607c8e66-5804-4888-aee3-338cf5290c38",
   "metadata": {},
   "outputs": [],
   "source": [
    "#将其他序列转换成集合,注意观察转换前后的变化\n",
    "alist = [1,1,1,1,2,2,2,2,3,3,3]\n",
    "print('alist: ',alist)\n",
    "aset = set(alist)\n",
    "print('aset: ',aset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "868f9faa-536c-4c3b-8849-168b560d4d66",
   "metadata": {},
   "source": [
    "#### 2.7.1 集合的常用方法\n",
    "| 方法名称 | 描述 | 返回值 |\n",
    "| --- | --- | --- |\n",
    "| add() | 为集合添加元素 | 无返回值，原地操作 |\n",
    "|clear() |移除集合中的所有元素| 无返回值，原地操作 |\n",
    "| copy() |拷贝一个集合 | 返回拷贝后新创建的集合 |\n",
    "| difference() | 返回多个集合的差集 | 返回差集结果 |\n",
    "| intersection() | 返回集合的交集 |返回交集结果 |\n",
    "| union() | 返回两个集合的并集 | 返回并集结果 |\n",
    "| symmetric_difference() | 返回两个集合中不重复的元素集合 | 返回两个集合中不重复的元素集合 |\n",
    "| isdisjoint() | 判断两个集合是否包含相同的元素 | bool,如果没有返回 True，否则返回 False  |\n",
    "| issubset() | 判断指定集合是否为该方法参数集合的子集 | bool,如果没有返回 True，否则返回 False  |\n",
    "| issuperset() | 判断该方法的参数集合是否为指定集合的子集 | bool,如果没有返回 True，否则返回 False  |\n",
    "| update() | 合并两个集合，传入的参数必须是一个集合 | 无返回值，原地操作 |\n",
    "| pop() | 随机移除元素 | 返回被移除的元素 |\n",
    "| remove() | 移除指定元素 | 无返回值，原地操作 |\n",
    "| discard() | 删除集合中指定的元素 | 无返回值，原地操作 |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edefdda0-8dde-4198-a1d4-8ce52f91fd43",
   "metadata": {},
   "outputs": [],
   "source": [
    "aset = {1,2,3}\n",
    "bset = {3,4,5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb5f26b7-d6e1-4cd7-9ca0-67c22f63c1ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aset)\n",
    "aset.add(4)\n",
    "print(aset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb8388cc-29bb-4f9f-b1d1-a5a2e37917e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#计算差集\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.difference(bset) :',aset.difference(bset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aaa4939-bca8-4be2-a8d7-c88142e209ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "#计算交集\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.intersection(bset) :',aset.intersection(bset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c11523b3-3881-4b9a-80a8-133f548253b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#计算并集\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.union(bset) :',aset.union(bset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41db56c3-166f-4bba-9f69-ba3cbdf1a516",
   "metadata": {},
   "outputs": [],
   "source": [
    "#计算两个集合中不重复的元素集合\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.symmetric_difference(bset) :',aset.symmetric_difference(bset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e41b808-13da-4b78-8edc-af6cb46b3fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#判断两个集合是否包含相同的元素\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.isdisjoint(bset) :',aset.isdisjoint(bset))\n",
    "print('aset.isdisjoint({-1,0}) :',aset.isdisjoint({-1,0}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f6e34b8-efd1-4cb8-9d41-9fab76ceb995",
   "metadata": {},
   "outputs": [],
   "source": [
    "#判判断指定集合是否为该方法参数集合的子集\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.issubset(bset) :',aset.issubset(bset))\n",
    "print('aset.issubset(aset.union(bset)) :',aset.issubset(aset.union(bset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "212809f9-1261-4109-adc3-ac2e692fc18c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#判判断指定集合是否为该方法参数集合的超集\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "print('aset.issuperset(bset) :',aset.issuperset(bset))\n",
    "print('aset.issuperset(aset.union(bset)) :',aset.issuperset(aset.union(bset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12c427f8-c1a2-4e2f-829b-2bc1db3cc6ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "#合并两个集合\n",
    "print('aset: ',aset)\n",
    "print('bset: ',bset)\n",
    "aset.update(bset)\n",
    "print('aset.update(bset)后的aset :',aset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e73b24b-d5b4-4d11-b3f1-07a46ab63e7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用pop随机删除集合中的一个元素\n",
    "print('aset: ',aset)\n",
    "print('aset.pop() :',aset.pop())\n",
    "print('aset: ', aset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "062d6364-d0d7-477c-b293-eebb8c9c547b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用remove或discard删除集合中的指定的一个元素\n",
    "bset = {3,4,5}\n",
    "print('bset: ',bset)\n",
    "bset.remove(3)\n",
    "print('bset: ', bset)\n",
    "bset.discard(4)\n",
    "print('bset: ', bset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fc25493-0fdc-4fae-91d4-f510874495ab",
   "metadata": {},
   "source": [
    "### 2.8 字典\n",
    "字典是一个无序的可以修改的序列，每一个元素都由一对key与value组成，key为对应value的索引。\n",
    "\n",
    "key不可重复，且需要是不可变对象（可hash），可以是数字，字符串，元组等，但不能是列表。value可以重复\n",
    "\n",
    "字典的创建可以用dict()或者{key1:value1,key2:value2,...}来创建。还记得在集合中我们提过{}能用于创建空集合，是因为{}创建的是一个空字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f115302-14f2-4787-ad1d-8cab4379bbfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "adict = {\"list\" : [1,2,3],'list2':[1,2,3],'interLM': 'LLM', 1:'summer camp',2:'internLM'}\n",
    "#访问key为list的元素的值\n",
    "print(\"adict['list'] :\", adict['list'])\n",
    "#修改key为list的元素的值\n",
    "adict['list'] = [3]\n",
    "print(\"adict['list'] = [3]后的adict: \",adict)\n",
    "#删除字典中的元素\n",
    "del adict['list2']\n",
    "print(adict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6772a4d5-3fab-4b1f-8b85-ddbebd4ea70a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#再来看看{}和dict()创建的空字典\n",
    "print(\"dict() \",type(dict()))\n",
    "print(\"{} \",type({}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15c264e-262f-4b9b-8dbe-5709b79c7922",
   "metadata": {},
   "source": [
    "#### 2.8.1 字典的常用方法\n",
    "\n",
    "|方法名 | 描述 |\n",
    "| --- | --- |\n",
    "| dict.clear() | 删除字典内所有元素 | \n",
    "| dict.copy() | 返回一个字典的浅复制 |\n",
    "| dict.fromkeys() | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |\n",
    "| dict.get(key, default=None) | 返回指定键的值，如果键不在字典中返回 default 设置的默认值 |\n",
    "| dict.items() | 返回字典内所有的key value对|\n",
    "| dict.keys() | 返回所有的key |\n",
    "| dict.values() | 返回所有的values |\n",
    "| dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |\n",
    "| pop(key[,default]) | 删除字典 key（键）所对应的值，返回被删除的值。|\n",
    "\n",
    "示例代码只会展示字典与列表不同的方法，对于名称与功能与列表相同的方法不再做展"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66a65e40-623f-441f-be8d-b0f2de1c77fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用fromkeys创建key为[1,2,3,4]\n",
    "dict.fromkeys([1,2,3,4],0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91b015bb-ccdd-488f-9886-48b6bcddf253",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用get查询值，可以使用default参数设置当key不存在时的返回值\n",
    "print(adict.get(\"list\",1))\n",
    "print(adict.get(\"list3\"))\n",
    "print(adict.get('list3',1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3907abf-99bc-490d-a63a-1affd0fe7a14",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用items获取所有的key value对.是一个序列\n",
    "print(adict.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea1ee442-8108-45f5-b7bc-bb1295e751cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用items获取所有的key\n",
    "print(adict.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdfcaa55-74e5-43a3-80ec-63fc85392f62",
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用items获取所有的values\n",
    "print(adict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a1444d5-841a-49ea-9312-5cb57b4b6cf3",
   "metadata": {},
   "source": [
    "### 2.9 字符串\n",
    "学习LLM，必然逃不过对字符串的处理。\n",
    "\n",
    "Python中的字符串使用`\"`或者`'`来创建,两者等价，但是`\"`会高于`'`。\n",
    "\n",
    "此外，`'''`可以用来创建包含多行的字符串。\n",
    "\n",
    "字符串本质上是一个不可变的元素可重复的有序序列，这也是为什么本教程会把字符串放在序列内容的最后一节。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70455fc7-cefd-443f-ab59-f39a35834380",
   "metadata": {},
   "outputs": [],
   "source": [
    "astring = 'InternLM'\n",
    "bstring = \"Intern'LM'\"#当字符串内有'时，可以使用\"\n",
    "print(list(astring))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7271b53-1768-46d7-9048-178ee73857da",
   "metadata": {},
   "source": [
    "字符串，本质上就是由字符组成的序列，将其转换为list就能看到他的原始数据结构，所以除了不能修改外，他的索引与切片操作跟列表一模一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6658977-5616-4ddb-850d-e40ee3a02c0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#获取字符串中第3个元素\n",
    "print(astring[2])\n",
    "#获取字符串中倒数第二个元素\n",
    "print(astring[-2])\n",
    "#获取字符串中的第二个到第四个字符组成的子串\n",
    "print(astring[1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbe2b3d2-a6bf-4bbf-b370-f0a2f6ca8fdc",
   "metadata": {},
   "source": [
    "#### 2.9.1 字符串的运算符\n",
    "| 运算符 | 描述 | 例子 |\n",
    "| --- | --- | ---|\n",
    "|`+` | 字符串连接 ||\n",
    "|`*`| 重复输出字符串 | |\n",
    "|`in` | 成员运算符  如果字符串中包含给定的字符返回 True| |\n",
    "|`not in` | 成员运算符如果字符串中不包含给定的字符返回 True|'M' not in a 输出结果 True|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8a16e1f-fb49-4369-b5e1-a11aa4d05cd3",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### 2.9.2 字符串的方法\n",
    "\n",
    "| 方法名 | 功能描述 |\n",
    "| --- | --- |\n",
    "| capitalize() | 将字符串的第一个字符转换为大写 |\n",
    "| center(width, fillchar)|返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格|\n",
    "| count(str, beg= 0,end=len(string))|返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内str 出现的次数 |\n",
    "| endswith(suffix, beg=0, end=len(string))|检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。|\n",
    "|expandtabs(tabsize=8)|把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 |\n",
    "| find(str, beg=0, end=len(string)) |检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1|\n",
    "| index(str, beg=0, end=len(string))|跟find()方法一样，只不过如果str不在字符串中会报一个异常|\n",
    "| isalnum()|如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False|\n",
    "|isalpha()|如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False|\n",
    "|isdigit()|如果字符串只包含数字则返回 True 否则返回 False..|\n",
    "|islower()|如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False|\n",
    "|isnumeric()|如果字符串中只包含数字字符，则返回 True，否则返回 False|\n",
    "|isspace()|如果字符串中只包含空白，则返回 True，否则返回 False.|\n",
    "|istitle()|如果字符串是标题化的(见 title())则返回 True，否则返回 False|\n",
    "|isupper()|如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False|\n",
    "|join(seq)|以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串|\n",
    "| ljust(width[, fillchar])|返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。|\n",
    "|lower()|转换字符串中所有大写字符为小写|\n",
    "|lstrip()|截掉字符串左边的空格或指定字符|\n",
    "|maketrans()|创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。|\n",
    "|max(str)|返回字符串 str 中最大的字母|\n",
    "|min(str)|返回字符串 str 中最小的字母|\n",
    "|replace(old, new [, max])|将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次|\n",
    "|rfind(str, beg=0,end=len(string))|类似于 find()函数，不过是从右边开始查找.|\n",
    "|rindex( str, beg=0, end=len(string))|类似于 index()，不过是从右边开始|\n",
    "|rjust(width,[, fillchar])|返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串|\n",
    "|rstrip()|删除字符串末尾的空格或指定字符。|\n",
    "|split(str=\"\", num=string.count(str))|以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串|\n",
    "| splitlines([keepends])|按照行('\\r', '\\r\\n', \\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。|\n",
    "| startswith(substr, beg=0,end=len(string)) |检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。|\n",
    "| strip([chars]) | 在字符串上执行 lstrip()和 rstrip()|\n",
    "| swapcase() |将字符串中大写转换为小写，小写转换为大写 |\n",
    "| title() | 返回\"标题化\"的字符串,就是说所有单词都是以大写开始，其余字母均为小写 |\n",
    "| translate(table, deletechars=\"\") |根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中|\n",
    "|zfill (width)|返回长度为 width 的字符串，原字符串右对齐，前面填充0|\n",
    "| isdecimal()| 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false|\n",
    "\n",
    "要注意的是，因为字符串是不可修改的对象，所以每个修改字符串的方法都是将修改后的字符串作为一个新对象返回。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca3bd75b-8b12-4716-8bc1-6467204be17f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#字符串的方法实在太多，在在这里我们只取几个比较常用的方法作为示例。\n",
    "text = \"Success is not final, failure is not fatal: It is the courage to continue that counts.\"\n",
    "#首先我们把这句话中所有的字母都转换为小写\n",
    "text = text.lower()\n",
    "print(text)\n",
    "#再用replace把所有的标点符号去掉\n",
    "text = text.replace(',',\" \").replace(':',\" \").replace('.',\" \")\n",
    "print(text)\n",
    "#再用split把这句话拆成词组成的列表\n",
    "word_list = text.split(\" \")\n",
    "print(word_list)\n",
    "#再用join函数用，把这个列表拼会一个字符串\n",
    "print(','.join(word_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b38a75b-2d09-4d8e-856c-df263e53e3c1",
   "metadata": {},
   "source": [
    "#### 2.9.3 字符串的格式化输出\n",
    "\n",
    "在做LLM开发时避不开对字符串做格式化输出，即指定一个模板把变量放入模板中。接下来我们介绍两种常见的易于实现复杂格式化输出的方法。\n",
    "\n",
    "第一种为使用字符串的.format()方法，并在在字符串中需要插入值的地方用{}代替，{}也可以加入变量名，方便赋值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cea6dd4-e6db-4bd7-b35c-3c4f11e7b760",
   "metadata": {},
   "outputs": [],
   "source": [
    "#我们用字典存储一个学生的信息，假设小明是实战营第二期的\n",
    "#我们需要在输出的时候将他转化成一句话\n",
    "#小明在12岁的时候参加了书生浦语实战营第二期, 最终获得了优秀学员。\n",
    "student = {'name':'小明','age':12,'class':\"书生浦语实战营第二期\",'grade':'优秀学员'}\n",
    "string_templet = '{}在{}岁的时候参加了{}，获得了{}。'#做一个模板\n",
    "print(string_templet.format(student['name'],student['age'],student['class'],student['grade']))\n",
    "#在模板中没有指定变量名时, .format方法就按照顺序来填入值下面来演示一下加入变量名后会有什么不同\n",
    "string_templet2 = \"{name}在{age}岁的时候参加了{course}，获得了{grade}。\"#做一个模板\n",
    "print(string_templet2.format(grade=student['grade'],name=student['name'],age=student['age'],course=student['class']))\n",
    "#使用这种变量方法命名时, format就可以忽略format参数中的顺序了,对于一些特别长变量特变多的模板来说更清晰。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "172807a1-22d7-4bb6-a8a9-36144604f9ee",
   "metadata": {},
   "source": [
    "第二种方法我们使用python在3.6推出的f-sting功能，只需在字符串开头加上f，该字符串中的{}中的python代码就会被评估。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2343f8d-81bd-4653-9b86-00558ec96cad",
   "metadata": {},
   "outputs": [],
   "source": [
    "student = {'name':'小明','age':12,'class':\"书生浦语实战营第二期\",'grade':'优秀学员'}\n",
    "string_out = f\"{student['name']}在{student['age']}岁的时候参加了{student['class']}，获得了{student['grade']}。\"\n",
    "print(string_out)\n",
    "print(f\"{1+2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbd69f64-2fdf-4f50-a750-75834059dad0",
   "metadata": {},
   "source": [
    "### 2.10 控制结构"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb0b208b-fffc-401e-8f79-6486652578b8",
   "metadata": {},
   "source": [
    "python中的if语句为:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1217b9e6-b478-41af-a3a9-2a88061509a8",
   "metadata": {},
   "source": [
    "```python\n",
    "if condition_1:\n",
    "    statement_block_1\n",
    "elif condition_2:\n",
    "    statement_block_2\n",
    "else:\n",
    "    statement_block_3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a802a35-275f-4be1-b73c-30788d47dd77",
   "metadata": {},
   "source": [
    "* 如果 \"condition_1\" 为 True 将执行 \"statement_block_1\" 块语句\n",
    "* 如果 \"condition_1\" 为False，将判断 \"condition_2\"\n",
    "* 如果\"condition_2\" 为 True 将执行 \"statement_block_2\" 块语句\n",
    "* 如果 \"condition_2\" 为False，将执行\"statement_block_3\"块语句\n",
    "\n",
    "\n",
    "接下来我们用if语句完成一个成绩等级判定的功能:\n",
    "* [90,100] A\n",
    "* [80,90) B\n",
    "* [70,80) C\n",
    "* [60,70) D\n",
    "* [0,60) F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d3bb9cf-09ed-42b2-9825-6b4480ddb4a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "score = 80\n",
    "if score>=90:\n",
    "    print('A')\n",
    "elif score>=80:\n",
    "    print('B')\n",
    "elif score>=70:\n",
    "    print('C')\n",
    "elif score>=60:\n",
    "    print('D')\n",
    "else:\n",
    "    print('F')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce19dff1-4f86-46e4-a2a6-3ecb1417405a",
   "metadata": {},
   "source": [
    "### 2.11 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11e4b6c1-112c-4939-8cf0-184854925504",
   "metadata": {},
   "source": [
    "#### 2.11.1 while语句"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e50a2676-9e7c-4597-9e2e-1545bf3ac234",
   "metadata": {},
   "source": [
    "Python while循环语句语法\n",
    "```python\n",
    "while condition:\n",
    "    statement\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6f57376-e040-4267-9924-03beb4ec607f",
   "metadata": {},
   "source": [
    "以上是while语句的形式，当condition为True时，while会执行statement然后再判断condition，直至condition变为False才会结束循环"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7eaafef8-68c5-4d3b-8554-11df920e7e75",
   "metadata": {},
   "outputs": [],
   "source": [
    "#用while语句求100以内数字的和\n",
    "i=0\n",
    "res = 0\n",
    "while i<100:\n",
    "    res+=i\n",
    "    i+=1\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26570fa7-3fa0-4dcf-bb9e-1507eb71b991",
   "metadata": {},
   "source": [
    "#### 2.11.2 for 语句"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b9e82c-244b-4348-af3f-37232edfd1cf",
   "metadata": {},
   "source": [
    "Python中for语句的语法为\n",
    "```python\n",
    "for <variable> in <sequence>:\n",
    "    <statements>\n",
    "else:\n",
    "    <statements>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80acb596-676a-49eb-9127-0889c9045012",
   "metadata": {},
   "source": [
    "for循环可以遍历任何可迭代的对象，比如一个列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af07045e-231d-458c-b782-3274947bf8eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "for st in ['InternLM','LLM','transformer','Shanghai']:\n",
    "    print(st)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4326c689-5243-480b-bd48-eabb48d87b2f",
   "metadata": {},
   "source": [
    "提到for循环就不能不提经常与它一起出现的range(start,stop,step)函数，他会生成一个可迭代的对象，以step步长生成[start,stop)。可以只写一个stop，默认从0开始。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51adc278-7df0-4c72-938a-013babf7a403",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e099a4f7-ae1c-4ddc-b390-36e614951307",
   "metadata": {},
   "source": [
    "#### 2.11.3 列表推导式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae219e7e-f5a2-469b-ae0b-6fb7dfa4794d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#列表推导式是一种很方便的写法，但我们在这不作为重点，大家可以看着例子应该就能理解列表推导式的写法\n",
    "#找出1-100内能被3整除的数\n",
    "print([i for i in range(1,101) if i%3==0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70cb224a-b032-4661-8aa3-23fea334077d",
   "metadata": {},
   "source": [
    "### 2.12 函数\n",
    "#### 2.12.1 函数的定义方式\n",
    "python定义函数的关键字为def"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57cce203-d779-435b-8e22-4094c6553dde",
   "metadata": {},
   "source": [
    "```python\n",
    "def 函数名（参数列表）:\n",
    "    函数体\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66406e16-c220-42b5-af62-d92ee5d52e84",
   "metadata": {},
   "outputs": [],
   "source": [
    "#定义一个打招呼的函数,别忘了冒号\n",
    "def hello(name):\n",
    "    out = 'Hello '+name\n",
    "    print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90fe44a0-8f67-4026-bb33-36530b21e601",
   "metadata": {},
   "outputs": [],
   "source": [
    "hello('InternLM2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b78c5b73-48d2-4e1a-a969-75f71afcc463",
   "metadata": {},
   "outputs": [],
   "source": [
    "#注意，函数中定义的变量为局部变量，只有函数内能访问到，这就是变量的作用领域\n",
    "print(out)\n",
    "#当我们尝试使用变量out时就会报错，提示out没有被定义"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f71ec68-d601-453e-9d63-1f4e8907947d",
   "metadata": {},
   "source": [
    "### 2.12.2 函数的参数传递"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b79667d-38c0-46f7-9a90-49a3180d5beb",
   "metadata": {},
   "source": [
    "* 参数是可变对象时，传参时传递的是索引，在函数中修改该参数会作用于原对象\n",
    "* 参数是不可变对象时，传参时会自动复制，在函数中修改该参数不会作用于原对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de6c7683-e6a4-4db6-88cf-9b82f69ea599",
   "metadata": {},
   "outputs": [],
   "source": [
    "def update(number,alist):\n",
    "    number = 3\n",
    "    alist[1] = 3\n",
    "    print(\"number: \", number)\n",
    "    print(\"alist: \", alist)\n",
    "    print(\"id(number)\",id(number))\n",
    "    print(\"id(alist)\",id(alist))\n",
    "a = 2\n",
    "b = [1,1,1]\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "update(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc985f80-b07e-4e87-8694-41f55c4af770",
   "metadata": {},
   "source": [
    "可以看到在update函数内修改了number和alist，函数外面的整数a没有被修改，但是列表b被修改了。\n",
    "这就是python函数在传参时候的特征导致的。通过使用id()函数可以获取对象在内存中的地址。\n",
    "可以看到number与a的id不同，他们是两个对象了。但是alist与b的id相同，说明他们两在内存中指向的是同一个对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34d0f6bd-12bd-4c03-880d-8c6b59c1e529",
   "metadata": {},
   "source": [
    "## Chapter3: Numpy基础\n",
    "NumPy是Python中一个强大的科学计算库，它提供了高性能的多维数组对象及这些数组的操作工具。使用NumPy，你可以轻松地进行数学和科学计算，比如线性代数、矩阵运算以及统计分布等，是数据分析和机器学习等领域的基石。Numpy array的操作与Pytorch的Tensor十分相似，了解了array对以后学习pytorch帮助很大。\n",
    "\n",
    "numpy的安装可以在终端中输入:\n",
    "```shell\n",
    "pip install numpy\n",
    "```\n",
    "或者直接在notebook中运行\n",
    "```shell\n",
    "!pip install numpy\n",
    "```\n",
    "TIPS: notebook中加上！可以直接在终端中运行终端命令"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "915051d3-2338-48ca-b858-e3702451325a",
   "metadata": {},
   "source": [
    "### 3.1 numpy Ndarry和创建数组的方式"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e661cb51-490b-4e91-9f8f-6ca3ece20305",
   "metadata": {},
   "source": [
    "NumPy数组（ndarray）是NumPy库的核心数据结构，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。\n",
    "\n",
    "ndarray本质上是一个存放同类型元素的多维数组，其中的每个元素在内存中都有相同存储大小的区域。\n",
    "\n",
    "NumPy数组（ndarray）的特点：\n",
    "\n",
    "1. **高效的内存使用**：ndarray对象在内存中连续存储，这使得对数组的元素进行切片和迭代等操作非常快速，而不需要额外的内存开销。\n",
    "\n",
    "2. **快速执行**：NumPy数组的操作是在编译后的代码中执行的，这使得NumPy操作比纯Python代码快得多。\n",
    "\n",
    "3. **方便易用**：NumPy提供了大量数学和数值计算函数，使得数组操作非常方便。\n",
    "\n",
    "4. **灵活性**：NumPy数组可以在不同的数据类型之间灵活转换，支持整数、浮点数、复数等多种数据类型。\n",
    "\n",
    "python中导入第三方包的关键词为 import, 可以用as给包取别名。导入numpy的语句如下所示，numpy的简称一般为np。\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "```\n",
    "创建numpy数组最常见的方法就是将一个列表使用np.array()函数转成ndarray。\n",
    "\n",
    "TIPS:在notebook中将光标移动到函数的括号中间，按下shift+tab可以看到函数的提示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ab34ba4-68cc-446a-9384-3dfb45994ae6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "array1 = np.array([1,2,3,4,5])\n",
    "#np.array函数全部的参数有\n",
    "#np.array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,like=None)\n",
    "#具体可以尝试上面提到的查看函数提示的方法或者去看numpy的文档\n",
    "#dtype参数表示array中元素的类型，这个参数在numpy中很常见。\n",
    "print('array1: \\n',array1)\n",
    "array2 = np.array([[1,2],[3,4]])\n",
    "print('array2: \\n ',array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba126042-4caf-41be-b9a9-7f728cf7f809",
   "metadata": {},
   "outputs": [],
   "source": [
    "#array常用属性\n",
    "#查看array数据类型\n",
    "print(\"array1.dtype : \",array1.dtype)\n",
    "#查看数组的维度\n",
    "print(\"array1.ndim : \",array1.ndim)\n",
    "print(\"array2.ndim : \",array2.ndim)\n",
    "#查看array的形状\n",
    "print(\"array1.shape : \",array1.shape)\n",
    "print(\"array2.shape : \",array2.shape)\n",
    "#查看array中的元素总个数\n",
    "print(\"array2.size : \",array2.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d5988e-37a3-4004-adbf-aa4c56e29d5c",
   "metadata": {},
   "source": [
    "Numpy还有其他很方便的创建元素值相同的数组的函数：\n",
    "* np.empty(shape,dtype)创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组\n",
    "* np.zeros(shape,dtype)创建指定形状（shape），数组元素以 0 来填充\n",
    "* np.ones(shape,dtype)创建指定形状（shape），数组元素以 1 来填充\n",
    "* np.zeros_like(array,dtype)创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充\n",
    "* np.ones_like(array,dtype)创建一个与给定数组具有相同形状的数组，数组元素以 1 来填充\n",
    "\n",
    "TIPS: 所有dtypes都是可选参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c109b87-1e39-4b55-86bb-6c8b25458514",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"np.empty((2,2))\\n\",np.empty((2,2)))\n",
    "#empty创建的数组中所有元素都是未初始化的，但其对应的内存地址可能本来就有值\n",
    "#所以使用empty创建的数据里面有一些奇怪的数字是正常的\n",
    "print(\"np.zeros((2,2))\\n\",np.zeros((2,2)))\n",
    "array2 = np.array([[1,2],[3,4]])\n",
    "print('array2: \\n ',array2)\n",
    "print(\"np.ones_like(array2)\\n\",np.ones_like(array2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78090ccd-5d3e-4c64-9a5f-6da8843da7a8",
   "metadata": {},
   "source": [
    "#### 3.1.2 从数值范围创建数组\n",
    "也许你还记得在python for循环中我们提到的range(start,stop,step)函数，他能生成一个迭代器。Numpy也有类似的函数，能够直接生成一个数组。\n",
    "\n",
    "np.arange(start, stop, step, dtype)，他的使用方法与range()一模一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8263c709-cf2c-4d04-be5a-02502aed9700",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"np.arange(20)\\n\",np.arange(20))\n",
    "print(\"np.arange(1,20,2)\\n\",np.arange(1,20,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35feb77f-9a76-4988-8372-1ec94e61fdc1",
   "metadata": {},
   "source": [
    "此外，numpy还提供一个构建等差数列的函数，只需要设定start和stop，以及要生成的等步长样本数量Num。\n",
    "\n",
    "np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)\n",
    "\n",
    "* start\t序列的起始值\n",
    "* stop\t序列的终止值，如果endpoint为true，该值包含于数列中\n",
    "* num\t要生成的等步长的样本数量，默认为50\n",
    "* endpoint\t该值为 true 时，数列中包含stop值，反之不包含，默认是True。\n",
    "* retstep\t如果为 True 时，生成的数组中会显示间距，反之不显示。\n",
    "* dtype\tndarray 的数据类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d60d1b3f-b24f-40a3-bbfb-092046f931d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"np.linspace(1,100,50)\\n\",np.linspace(0,100,30))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4db0e74-9640-45b2-b12e-8a65f455e36c",
   "metadata": {},
   "source": [
    "### 3.2 数组操作"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61dd9c68-098a-4f9d-a547-8657de5929f8",
   "metadata": {},
   "source": [
    "#### 3.2.1 数组运算与广播机制\n",
    "\n",
    "numpy array之前的运算均为元素位置一一对应进行计算，需要两个数组维数相同，且各维度的长度也相同。此外，numpy的广播机制还可以把该条件放宽到两个数组在某个维度上的长度相同即。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5808ffce-2d30-4379-be17-8892586640a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6]])\n",
    "array2 = np.array([[2,4,6],[3,5,7]])\n",
    "print('array1 :\\n',array1)\n",
    "print('array2 :\\n', array2)\n",
    "print('array1+array2:\\n',array1+array2)\n",
    "print('array1*array2:\\n',array1*array2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5926b433-6a19-4317-9757-f0b9ef14d781",
   "metadata": {},
   "source": [
    "#### 3.2.2 广播机制\n",
    "\n",
    "NumPy的广播机制是NumPy库中一个非常强大的功能，它允许我们对形状不完全相同的数组进行算术运算。在广播过程中，NumPy会自动调整数组的形状，以便它们可以在元素级别上进行运算。这种机制使得NumPy在进行数组操作时更加灵活和高效。\n",
    "\n",
    "##### 广播的基本规则\n",
    "\n",
    "1. **规则一：维度对齐**\n",
    "   - 如果两个数组的维度数不同，较小的数组会在其前面补1，直到两个数组的维度数相同。\n",
    "   - 维度对齐后，从最后一个维度（也称为“后缘维度”）开始比较两个数组的形状。\n",
    "\n",
    "2. **规则二：兼容维度**\n",
    "   - 如果两个数组在某个维度上的大小相同，或者其中一个数组在该维度上的大小为1，则这两个数组在该维度上是兼容的。\n",
    "   - 如果两个数组在所有维度上都是兼容的，那么它们就可以进行广播。\n",
    "\n",
    "3. **规则三：输出形状**\n",
    "   - 广播后的输出数组的形状是输入数组形状在各个维度上的最大值。\n",
    "\n",
    "假设我们有两个数组`a`和`b`，我们想要对它们进行加法运算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9ffe383-15c1-40a8-81e1-21e1ecf57b05",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3])  # 形状为 (3,)\n",
    "b = np.array([[1], [2], [3]])  # 形状为 (3, 1)\n",
    "\n",
    "# 使用广播机制进行加法运算\n",
    "result = a + b\n",
    "print(result)  # 输出: [[2, 3, 4], [3, 4, 5], [4, 5, 6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "905713a0-7fb7-49ce-8bb6-92a8fdb8ff25",
   "metadata": {},
   "source": [
    "- 在这个例子中，`a`的形状是`(3,)`，而`b`的形状是`(3, 1)`。\n",
    "- 根据广播规则一，`a`的形状在逻辑上被扩展为`(1, 3)`，以便与`b`的形状`(3, 1)`对齐。\n",
    "- 然后，根据规则二，两个数组在所有维度上都是兼容的，因为`a`在第一个维度上的大小为1（逻辑上扩展的），而`b`在该维度上的大小为3；同时，在第二个维度上，两者的大小都是3（或1，对于`a`来说）。\n",
    "- 因此，可以进行广播，加法运算在元素级别上进行。\n",
    "- 结果数组`result`的形状是`(3, 3)`，这是两个输入数组形状在各个维度上的最大值。\n",
    "\n",
    "\n",
    "如果我们不使用NumPy的广播机制，而是手动模拟这一过程，我们可以这样做：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d26d0e94-57bf-4413-9898-40e2f7c2e89c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 手动模拟广播机制\n",
    "a = np.array([1, 2, 3])  # 形状为 (3,)\n",
    "b = np.array([[1], [2], [3]])  # 形状为 (3, 1)\n",
    "print('a\\n',a)\n",
    "print('b\\n',b)\n",
    "\n",
    "a = np.expand_dims(a,0)\n",
    "#先让两边维数相等\n",
    "print('\\na的形状在逻辑上被扩展为(1,3),a为\\n',a)\n",
    "print('此时a与b的形状为: a {},b {}'.format(a.shape,b.shape))\n",
    "#此时a与b的形状为: a (1, 3),b (3, 1)\n",
    "#a会在第0轴上重复三次变成(3,3)\n",
    "a_broadcast = np.repeat(a,3,0)\n",
    "#a会在第1轴上重复三次变成(3,3)\n",
    "b_broadcast =np.repeat(b,3,1)\n",
    "print('\\n广播后的a_broadcast为\\n',a_broadcast)\n",
    "print('广播后的b_broadcast为\\n',b_broadcast)\n",
    "print('\\na+b经过广播后就是a_broadcast+b_broadcast\\n',a_broadcast+b_broadcast)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac5af13a-5fa0-4336-a192-bd7c8f6843e2",
   "metadata": {},
   "source": [
    "#### 3.2.2 修改数组形状\n",
    "ndarray.reshape(newshape, order='C')不改变数据的条件下修改形状\n",
    "* newshape：整数或者整数数组，新的形状应当兼容原有形状\n",
    "* order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。\n",
    "\n",
    "返回修改好形状的数组，并不直接对原数组进行修改"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a90c5fb2-6a78-48c1-afca-0712c837ae71",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6]])\n",
    "print('array1 :\\n',array1)\n",
    "print('array1.reshape((3,2)) :\\n',array1.reshape((3,2)))\n",
    "print('array1.reshape((6,1)) :\\n',array1.reshape((6,1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80154579-d2e9-4cd4-bc1a-f94305ff2d00",
   "metadata": {},
   "source": [
    "ndarray.flatten(order='C')将数组展平成一维数组\n",
    "* order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "938c72f3-dddf-4a6c-9359-148f0c76e4b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print('array1 :\\n',array1)\n",
    "print('array1.flatten():\\n',array1.flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb3992c2-5a13-46ee-8bf6-6b6e83ecedb1",
   "metadata": {},
   "source": [
    "#### 3.2.3 翻转数组\n",
    "对于二维数组就是转置，但对于更高维的数组可以指定axes列表来确定维度的变化。原始数组的维度[0,1,2],可以指定axes为[0,2,1]从而将最后一维放到中间。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f8fac4c-11fb-45e9-a239-6cffc244bf54",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6]])\n",
    "print('arrayarray1)\n",
    "print('array1.traspose() 等价于array1.transpose([1,0]) \\n'\\\n",
    "        ,array1.transpose())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b3cd410-8d85-40f3-b8c5-12d5ab54e281",
   "metadata": {},
   "source": [
    "#### 3.2.4 修改数组的维度\n",
    "numpy有两个常用的修改数组维度的函数，一个用于增加维度一个用于减少维度。修改数组维度经常会在进行高维tesnor计算时用于对其维数用到，经过增加一维或者减少一维数来实现。\n",
    "numpy.expand_dims(arr, axis)通过在指定位置插入新的轴来扩展数组形状\n",
    "* arr：输入数组\n",
    "* axis：新轴插入的位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9df9b12-c810-466c-b02e-4b5e4f45bb19",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6]])\n",
    "print('array1\\n',array1)\n",
    "print('array1.shape\\n',array1.shape)\n",
    "array2 = np.expand_dims(array1,0)\n",
    "print('array2\\n',array2)\n",
    "print('array2.shape\\n',array2.shape)\n",
    "array3 = np.expand_dims(array1,1)\n",
    "print('array3\\n',array3)\n",
    "print('array3.shape\\n',array3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dcf7a29-6b81-4fb1-ba87-e3a466e19712",
   "metadata": {},
   "source": [
    "numpy.squeeze(arr, axis)从给定数组的形状中删除一维的条目\n",
    "* arr：输入数组\n",
    "* axis：整数或整数元组，用于选择形状中一维条目的子集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd213a36-7c52-47a7-b158-3fae65bf4a42",
   "metadata": {},
   "outputs": [],
   "source": [
    "array2 = np.expand_dims(array1,0)\n",
    "print('array2\\n',array2)\n",
    "print('array2.shape\\n',array2.shape)\n",
    "array4 = np.squeeze(array2)\n",
    "print('array4=np.squeeze(array2)\\n',array4)\n",
    "print('array4.shape\\n',array4.shape)\n",
    "\n",
    "array3 = np.expand_dims(array1,1)\n",
    "print('array3\\n',array3)\n",
    "print('array3.shape\\n',array3.shape)\n",
    "array5 = np.squeeze(array3)\n",
    "print('array5=np.squeeze(array3)\\n',array5)\n",
    "print('array5.shape\\n',array5.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18b9ae70-b523-461b-a645-19f9275a332a",
   "metadata": {},
   "source": [
    "#### 3.2.5 拼接数组\n",
    "numpy有四种拼接数组的函数:\n",
    "\n",
    "numpy.concatenate(arrays,axis)沿指定轴连接相同形状的两个或多个数组\n",
    "* arrays：(a1,a2,a3...)相同类型的数组\n",
    "* axis：沿着它连接数组的轴，默认为 0\n",
    "  \n",
    "numpy.stack(arrays, axis)沿新轴连接数组序列\n",
    "* arrays相同形状的数组序列\n",
    "* axis：返回数组中的轴，输入数组沿着它来堆叠\n",
    "  \n",
    "numpy.hstack(arrays) np.concatenate的特殊情况，相当于axis=1，通过水平堆叠来生成数组\n",
    "\n",
    "numpy.vstack(arrays) np.concatenate的特殊情况，相当于axis=0，通过垂直堆叠来生成数组\n",
    "\n",
    "所有用于拼接的数组在拼接的轴上长度必须相同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18d99b82-c993-4ded-8db7-1dad5aad9fb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6]])\n",
    "array2 = np.array([[2,4,6],[3,5,7]])\n",
    "print(\"np.concatenate((array1,array2),0)\\n\",np.concatenate((array1,array2),0))\n",
    "print(\"np.concatenate((array1,array2),1)\\n\",np.concatenate((array1,array2),1))\n",
    "\n",
    "print(\"np.stack((array1,array2),0)\\n\",np.stack((array1,array2),0))\n",
    "print(\"np.stack((array1,array2),1)\\n\",np.stack((array1,array2),1))\n",
    "\n",
    "print(\"np.hstack((array1,array2))\\n\",np.hstack((array1,array2)))\n",
    "print(\"np.vstack((array1,array2),1)\\n\",np.vstack((array1,array2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96a2af53-049e-434c-8559-af78c6cb9f37",
   "metadata": {},
   "source": [
    "#### 3.2.6 索引与切片\n",
    "numpy数据一样有索引与切片，只是其索引的写法与嵌套列表可能会有一点点不一样。\n",
    "\n",
    "numpy的索引用[]表示，用,隔开每个轴上的索引，比如对于一个二位数组要取第i行第j列的元素的索引就为[i,j]\n",
    "\n",
    "在索引切片上numpy数组依旧遵循start\\:stop:step格式，在每个轴上的切片用,隔开。:或者...可以表示取整个轴上的全部元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8e2b883-1709-48ed-8737-322e6fdd6041",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print()\n",
    "print(\"取array1第1行第3个元素，array1[0,2]=\",array1[0,2])\n",
    "print(\"取array1第1行前两个元素，array1[0,:2]=\",array1[0,:2])\n",
    "print(\"取array1每一行前两个元素，array1[0,:2]=\\n\",array1[...,:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d74080-5e55-4fd8-bcab-90de39fb2bfe",
   "metadata": {},
   "source": [
    "### 3.3 排序条件筛选"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d81a6974-8641-4219-9880-afaaf431501a",
   "metadata": {},
   "source": [
    "ndarray.sort(axis=-1, kind=None, order=None)\n",
    "* axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序\n",
    "* kind: 默认为'quicksort'（快速排序）\n",
    "* order: 如果数组包含字段，则是要排序的字段"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "130ced4c-6598-4e75-a46f-b9744838e37a",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.random.randint(1,10,(3,4))\n",
    "print('array1',array1)\n",
    "array1.sort(axis=0)\n",
    "print('对列内数字进行排序,array1.sort(axis=0)\\n',array1)\n",
    "array1.sort(axis=1)\n",
    "print('对行内数字进行排序,array1.sort(axis=1)\\n',array1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e8b0912-a535-4d4a-b749-453fb76f7adc",
   "metadata": {},
   "source": [
    "ndarray.argmax(axis)与ndarray.argmin(axis)是求数组对应轴上最大或者最小的元素的索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a3423b1-7907-4736-b6b6-a2f420f753d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.random.randint(1,10,(3,4))\n",
    "print('array1',array1)\n",
    "print('求每一列最大元素的索引,array1.argmax(axis=0)\\n',array1.argmax(axis=0))\n",
    "print('求每一行最大元素的索引,array1.argmax(axis=1)\\n',array1.argmax(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "443e23ab-0650-4e78-9654-46c1b3e35ca2",
   "metadata": {},
   "source": [
    "numpy数组也支持比较运算，运算结果为bool numpy数组。可以使用np.where()获取其中为ture的元素的索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca47e54f-4dfc-458f-ad2b-ce6e1d760051",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.random.randint(1,10,(3,4))\n",
    "print('array1',array1)\n",
    "np.where(array1>1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad3682fe-cc78-4b52-bf18-4a744d83d059",
   "metadata": {},
   "source": [
    "### 3.6 数学函数\n",
    "numpy内置了非常多的数学函数，可以直接应用于numpy数组对每一个元素做映射。\n",
    "\n",
    "常见的函数有np.sin(),np.cos(),np.tan(),np.log()等。\n",
    "\n",
    "此外，还有np.mean(),np.median(),np.std()等统计函数。\n",
    "\n",
    "对于取整函数，numpy有np.round()按小数位数四舍五入,np.ceil()向上取整,np.floor()向下取整"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60c8f8a-6a6a-47ec-b9dc-74ea784828c5",
   "metadata": {},
   "source": [
    "### 3.7 线性代数\n",
    "Numpy的核心就是高性能的矩阵运算，它还提供了线性代数计算包linalg。这里只展示二维数组常用的方法，numpy能做的远远不止这些。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f2d4871-9f45-4967-9e52-e153cbec6c94",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.random.randint(1,10,(3,4))\n",
    "array2 = np.random.randint(1,10,(3,4))\n",
    "print('array1 \\n',array1)\n",
    "print('array2 \\n',array2)\n",
    "#计算两个矩阵的乘法\n",
    "print(\"array1.dot(array2.transpose()):\",array1.dot(array2.transpose()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a29dc4-5e6d-44b6-b194-3d80f02d905d",
   "metadata": {},
   "source": [
    "常用线性代数计算函数\n",
    "* np.linalg.det() 数组的行列式\n",
    "* np.linalg.inv() 计算矩阵的乘法逆矩阵\n",
    "* np.linalg.solve() 求解线性方程\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a85b9d2-c984-457b-810b-f1085f47163b",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.random.randint(1,10,(3,3))\n",
    "print('array1 \\n',array1)\n",
    "print('array1的行列式: ',np.linalg.det(array1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dea8a3e5-d78d-4ac1-a9e4-adcf7c8c1a0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.random.randint(1,10,(3,3))\n",
    "print('array1 \\n',array1)\n",
    "array1_inv=np.linalg.inv(array1)\n",
    "print('array1的乘法逆矩阵array1_inv: ',array1_inv)\n",
    "print('array1.dot(array1_inv)\\n',array1.dot(array1_inv))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81a5a64a-8582-4494-b56f-9a27d11f13f7",
   "metadata": {},
   "source": [
    "求解方程组:\n",
    "\n",
    "$\\begin{cases}\n",
    "x + y = 5, \\\\\n",
    "2x - y = 1.\n",
    "\\end{cases}$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "182f0a73-29b3-488e-9fae-18981529b141",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 1],  \n",
    "              [2, -1]])  \n",
    "b = np.array([5, 1])  \n",
    "  \n",
    "x = np.linalg.solve(A, b)  \n",
    "  \n",
    "print(x)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.10"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}