阿里云天池Python训练营-Part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c548172",
   "metadata": {},
   "source": [
    "本笔记为阿里云天池龙珠计划Python训练营的学习内容，链接为：https://tianchi.aliyun.com/specials/promotion/aicamppython\n",
    "# 阿里云天池 Python 训练营 [国际人学校 - 林肯老师 22 年情人节版本] - Part2\n",
    "\n",
    "![rhtKQR](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/rhtKQR.png)\n",
    "\n",
    "* 2022 年 02 月 14 日版本\n",
    "* 本文档是以 CC 开源的模式的发布，你能且将获得本文档的 PDF 版本已经 Jupyter Notebook 版本\n",
    "* 本文档并不申明自己的版权信息，为了更好的知识传播，我们授权你使用本文档，你可以使用它，进行二次创作，进行分发，进行修改，并可以以此为蓝本进行授课。\n",
    "* 请保留本文档的原始来源。\n",
    "* 本文档首先在国际人学校组织的“阿里云天池 Python 训练营课程”中使用。\n",
    "* 本文档由林肯老师首次组织和编辑。你可以通过网址 [数据大咖](https://www.shujudaka.com) 找到他。\n",
    "\n",
    "![TWy9b7](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/TWy9b7.jpg)\n",
    "\n",
    "![UEbMpS](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/UEbMpS.png)\n",
    "\n",
    "* 在塔尖，第一种学习方式——“听讲”，也就是老师在上面说，学生在下面听，这种我们最熟悉最常用的方式，学习效果却是最低的，两周以后学习的内容只能留下 5%。\n",
    "* 第二种，通过“阅读”方式学到的内容，可以保留 10%。\n",
    "* 第三种，用“声音、图片”的方式学习，可以达到 20%。\n",
    "* 第四种，是“示范”，采用这种学习方式，可以记住 30%。\n",
    "* 第五种，“小组讨论”，可以记住 50% 的内容。\n",
    "* 第六种，“做中学”或“实际演练”，可以达到 75%。\n",
    "* 最后一种在金字塔基座位置的学习方式，是“教别人”或者“马上应用”，可以记住 90% 的学习内容。\n",
    "\n",
    "爱德加·戴尔提出，学习效果在 30% 以下的几种传统方式，都是个人学习或被动学习；而学习效果在 50% 以上的，都是团队学习、主动学习和参与式学习。\n",
    "\n",
    "[费曼学习法和学习金字塔](https://www.bilibili.com/video/BV153411k7FE?from=search&seid=4978289883157276497&spm_id_from=333.337.0.0)\n",
    "\n",
    "## 13.  字符串处理\n",
    "\n",
    "### 13.1 字符串切片\n",
    "\n",
    "字符串是 Python 中常见的一种数据类型。字符串切片就是截取字符串。在 Python 中，可以利用字符串的切片特性进行提取、拆分、合并等操作，但不能对字符串进行修改。\n",
    "\n",
    "#### 13.1.1 单字符切片\n",
    "\n",
    "单字符切片是对字符串中指定位置的单个字符进行截取。语法结构为：字符串[索引位置], 索引位置的序号是从 0 开始的。关于索引位置，既能以开头为基准进行切片，也能以结尾为基准进行切片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ef6682d",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt='Python与Excel' #要做切片处理的字符串。\n",
    "print(txt[0],txt[1],txt[2]) #索引位置以开头为基准切片，返回值 'P y t'。\n",
    "print(txt[-1],txt[-2],txt[-3]) #索引位置以结尾为基准切片，返回值 'l e c'。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "400bef5c",
   "metadata": {},
   "source": [
    "#### 13.1.2 多字符切片\n",
    "\n",
    "如果截取的不是单个字符，而是多个字符，则切片的语法结构为：字符串[开始索引:结束索引:步长]。多字符截取有几种常见的切片方式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a13c8e10",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt='Python与Excel' #要做切片处理的字符串。\n",
    "print(txt[2:9]) #以开头为基准切片，返回值为 'thon 与 Ex'。\n",
    "print(txt[-10:-3])# 以结尾为基准切片，返回值为 'thon 与 Ex'。\n",
    "print(txt[:7]) #以开头为基准切片，返回值为 'Python 与'。\n",
    "print(txt[:-5])# 以结尾为基准切片，返回值为 'Python 与'。\n",
    "print(txt[7:]) #以开头为基准切片，返回值为 'Excel'。\n",
    "print(txt[-5:])# 以开头为基准切片，返回值为 'Excel'。\n",
    "print(txt[2:-5])# 开始索引以开头为基准，结束索引以结尾为基准，返回 'thon 与'。\n",
    "print(txt[-10:7])# 开始索引以结尾为基准，结束索引以开头为基准，返回 'thon 与'。\n",
    "print(txt[:])# 截取整个字符串切片，返回值为 'Python 与 Excel'。\n",
    "print(txt[::2])# 截取整个字符串切片，步长为 2，返回值为 'Pto 与 xe'。\n",
    "print(txt[::-1])# 截取整个字符串切片，步长为 -1，返回值为 'lecxE 与 nohtyP'。\n",
    "print(txt[::-2])# 截取整个字符串切片，步长为 -2，返回值为 'lcEnhy'。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b957a6c",
   "metadata": {},
   "source": [
    "#### 13.1.3 字符串切片应用案例：根据身份证号判断性别\n",
    "\n",
    "本案例对员工信息表中 B 列的身份证号进行性别判断。在 18 位身份证号中判断第 17 位数字，在 15 位身份证号中判断第 15 位数字。如果数字是奇数，则性别为男；如果数字是偶数，则性别为女。\n",
    "\n",
    "本案例的编程思路是，使用字符串切片从身份证号的第 15 位开始截取到第 17 位，再截取最后一位数字。这样不管身份证号是 15 位，还是 18 位，最终都截取到了要判断性别的数字，之后的数据处理就比较容易了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3126917",
   "metadata": {},
   "outputs": [],
   "source": [
    "import xlrd,xlwt #导入所需库。\n",
    "wb = xlrd.open_workbook('./6-ID-1.xls') #读取工作簿。\n",
    "ws = wb.sheet_by_name('员工信息表') #读取工作表。\n",
    "nwb = xlwt.Workbook('utf-8') #新建工作簿。\n",
    "nws = nwb.add_sheet('员工信息表-1') #新建工作表。\n",
    "nws.write(0,0,'姓名') #在表头写入 '姓名'。\n",
    "nws.write(0,1,'身份证号') #在表头写入 '身份证号'。\n",
    "nws.write(0,2,'性别') #在表头写入 '性别'。\n",
    "row_num = 0 #初始化 row_num 变量为 0。\n",
    "while row_num < ws.nrows-1: #当 row_num 小于 '员工信息表' 已用行数时，开始循环。\n",
    "    row_num += 1 #累加 row_num 变量。\n",
    "    card = ws.cell_value(row_num,1) #获取单元格的身份证号信息。\n",
    "    sex_num = int(card[14:17][-1]) #截取判断性别的数字。\n",
    "    sex = '男' if sex_num % 2 == 1 else '女' #根据数字判断性别。\n",
    "    name = ws.cell_value(row_num,0) #获取姓名。\n",
    "    nws.write(row_num,0,name) #将姓名写入新工作表中的 A 列单元格。\n",
    "    nws.write(row_num,1,card) #将身份证号写入新工作表中的 B 列单元格。\n",
    "    nws.write(row_num,2,sex) #将性别写入新工作表中的 C 列单元格。\n",
    "nwb.save('./6-ID-2.xls') #保存新建的工作簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aed1fa2",
   "metadata": {},
   "source": [
    "* 第 1～9 行代码都是在为数据的读取和写入做准备。\n",
    "* 第 13 行代码 sex_num=int(card[14:16][-1])是性别判断的关键语句。首先截取第 15～17 位数字，然后截取最右侧的数字。\n",
    "    - 比如，对 18 位身份证号进行截取，'230102\\*\\*\\*\\*\\*\\*\\*\\*7789[14:16]的截取结果为“778”，然后执行语句'778'[-1], 截取结果为“8”。\n",
    "    - 再比如，对 15 位身份证号进行截取，'632123\\*\\*\\*\\*\\*\\*051'[14:17]的截取结果为“1”，然后执行语句'1'[-1], 截取结果为“1”。这样对 18 位身份证号和 15 位身份证号都能截取到判断性别的数字，再使用 int 函数将其转换为整数。\n",
    "* 第 14 行代码 sex='男' if sex_num％2==1 else '女', 对存储性别数字的 sex_num 变量除以 2 求奇偶，然后根据奇偶做性别判断。\n",
    "* 第 16～18 行代码是将信息写入新工作簿中的新工作表。\n",
    "* 第 19 行代码是保存新工作簿。\n",
    "\n",
    "### 13.2 字符串统计 len/count\n",
    "\n",
    "有时需要统计字符串的一些信息，比如统计字符串长度、统计指定子字符串在父字符串中出现的次数等。\n",
    "\n",
    "#### 13.2.1 统计字符串长度 len\n",
    "\n",
    "统计字符串、列表、元组等对象的长度或项目个数，可以使用 **len** 函数。\n",
    "\n",
    "函数语法：**len(s)**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "s: 参数可以是序列，例如字符串、元组、列表、字典、集合等。\n",
    "\n",
    "例如，统计字符串 'Python' 的长度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bcbb49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Python',len('Python')) #返回 'Python 6'。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7bd7c8",
   "metadata": {},
   "source": [
    "#### 13.2.2 按条件统计字符串 count\n",
    "\n",
    "统计指定子字符串在父字符串中出现的次数，可以使用 **count** 函数。\n",
    "\n",
    "函数语法：**count(sub[,start[,end]])**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "* sub: 必选参数，搜索的子字符串。\n",
    "* start: 可选参数，字符串开始搜索的位置，默认从第 0 个字符开始搜索。\n",
    "* end: 可选参数，字符串结束搜索的位置，默认搜索到字符串最后。\n",
    "\n",
    "例如，在 '张三19, 李四, 张三9, 林林6, 张三12, 李四8' 字符串中搜索关键词“张三”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f49ae886",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt='张三19, 李四, 张三9, 林林6, 张三12, 李四8'# 被查找的字符串。\n",
    "print(txt.count('张三'))# 返回值为 3。\n",
    "print(txt.count('张三',4))# 返回值为 2。\n",
    "print(txt.count('张三',4,13))# 返回值为。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "224cb98f",
   "metadata": {},
   "source": [
    "* 第 2 行代码 print(txt.count('张三')), 是在整个字符串中搜索“张三”，该字符串中有 3 个“张三”，所以返回值为 3。\n",
    "* 第 3 行代码 print(txt.count('张三',4)), 是从字符串的第 4 个位置开始搜索到最后，也就是在字符串，'李四, 张三 9, 林林 6, 张三 12, 李四 8' 中搜索“张三”，该字符串中有 2 个“张三”，所以返回值为 2。\n",
    "* 第 4 行代码 print(txt.count('张三',4,13)), 是从字符串的第 4 个位置开始搜索到第 13 个位置，也就是在字符串，'李四, 张三9, 林' 中搜索“张三”，该字符串中只有 1 个“张三”，所以返回值为 1。\n",
    "\n",
    "#### 13.2.3 字符串统计应用案例：统计各等级出现的次数\n",
    "\n",
    "本案例统计分数表中每个人获得**优、良、中、差**的次数，将结果写入 C 列单元格，如图所示。\n",
    "\n",
    "本案例的编程思路是将 **4** 个等级作为搜索关键字在每个单元格中进行计数，然后将每个等级的计数结果写入 C 列。\n",
    "\n",
    "![ws02Kd](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/ws02Kd.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2d65533",
   "metadata": {},
   "outputs": [],
   "source": [
    "import xlrd #导入读取 xls 文件的库。\n",
    "from xlutils.copy import copy #导入复制工作簿的函数。\n",
    "wb = xlrd.open_workbook('./7-ScoreAnalists-1.xls') #读取工作簿。\n",
    "ws = wb.sheet_by_name('分数表') #读取工作表。\n",
    "nwb = copy(wb) #复制工作簿产生一个副本。\n",
    "nws = nwb.get_sheet('分数表') #读取副本工作簿中的工作表。\n",
    "row_num = 0 #初始化 row_num 变量为 0。\n",
    "txt = '' #初始化 txt 变量为空。\n",
    "while row_num<ws.nrows-1: #当 row_num 变量小于已使用单元格区域行数时。\n",
    "    row_num += 1 #则对 row_num 变量累加 1。\n",
    "    score = ws.cell_value(row_num,1) #获取 B 列单元格的值。\n",
    "    for level in '优良中差': #循环 '优良中差'4 个等级。\n",
    "        lev_sco = '{}:{}\\t'.format(level,score.count(level)) #统计每个级别的个数，并进行格式化。\n",
    "        txt += lev_sco #累积连接各等级数量。\n",
    "    nws.write(row_num,2,txt) #将统计结果写入 C 列单元格。\n",
    "    txt = '' #重新初始化 txt 变量，便于存储下个单元格各等级的统计结果。\n",
    "nws.write(0,2,'等级统计') #在 C 列写入表头。\n",
    "nwb.save('./7-ScoreAnalists-1.xls') #保存副本工作簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a1fd1f",
   "metadata": {},
   "source": [
    "* 第 1～8 行代码为读取工作表数据和写入工作表做准备。\n",
    "* 第 10 行和第 11 行代码用于获取单元格的值。\n",
    "* 第 12～14 行代码循环判断每个等级在单元格中出现的次数，关键语句是 score.count(level), 并且使用 txt+=lev_sco 来累计各等级出现的次数。\n",
    "* 第 15 行和第 16 行代码用来写入统计结果与重新初始化。nws.write(row_num,2,txt)是将 txt 变量中的统计结果写入副本工作簿中工作表的 C 列。txt='' 用于重新初始化 txt 变量。\n",
    "* 第 17 行和第 18 行代码用来在 C 列写入表头和保存工作簿。\n",
    "\n",
    "### 13.3 字符串搜索 index/find\n",
    "\n",
    "搜索指定子字符串在父字符串中第一次出现的位置，可以使用 **index** 函数或 **find** 函数。\n",
    "\n",
    "#### 13.3.1 使用 index 函数搜索字符串位置\n",
    "\n",
    "**index** 函数用于从字符串中找出子字符串第一个匹配项的索引位置，如果查找的字符串不存在，则返回错误提示。\n",
    "\n",
    "函数语法：**index(sub[,start[,end]])**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "* sub: 必选参数，搜索的子字符串。\n",
    "* start: 可选参数，字符串开始搜索的位置，默认从第 0 个字符开始搜索。\n",
    "* end: 可选参数，字符串结束搜索的位置，默认搜索到字符串最后。\n",
    "\n",
    "例如，在字符串 '张三 19, 李四, 张三 9, 林林 6, 张三 12, 张三 8' 中搜索关键词“张三”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b54764bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt='张三 19, 李四, 张三 9, 林林 6, 张三 12, 张三 8'# 被查找的字符串。\n",
    "print(txt.index('张三'))# 返回值为 0。\n",
    "print(txt.index('张三',18))# 返回值为 21。\n",
    "print(txt.index('张三',6,16))# 返回值为 8。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d5567d8",
   "metadata": {},
   "source": [
    "* 第 2 行代码 print(txt.index(' 张三)), 是在整个字符串中搜索“张三”第 1 次出现的位置，返回值为 3。\n",
    "* 第 3 行代码 print(txt.index('张三',18)), 是从字符串的第 18 个位置开始搜索“张三”第 1 次出现的位置，返回值为 21。\n",
    "* 第 4 行代码 print(txt.count('张三',6,16)), 是在字符串的第 6 个位置到第 16 个位置中搜索“张三”第 1 次出现的位置，返回值为 8。\n",
    "\n",
    "#### 13.3.2 使用 find 函数搜索字符串位置\n",
    "\n",
    "**find** 函数用于从父字符串中找出某个子字符串第一个匹配项的索引位置，该函数的功能与 index 函数的功能一样，只不过子字符串不在父字符串中时不会报异常，而是返回 -1。\n",
    "\n",
    "函数语法：**find(sub[,start[,end]])**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "* sub: 必选参数，搜索的子字符串。\n",
    "* start: 可选参数，字符串开始搜索的位置，默认从第 0 个字符开始搜索。\n",
    "* end: 可选参数，字符串结束搜索的位置，默认搜索到字符串最后。\n",
    "* \n",
    "例如，在字符串 'Python' 中搜索 'Excel'，分别使用 find 函数和 index 函数，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "691ed888",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Python'.find('Excel'))# 查找不到返回 -1。\n",
    "print('Python'.index('Excel'))# 查找不到返回错误提示。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fe79c27",
   "metadata": {},
   "source": [
    "* 第 1 行代码 print('Python'.find('Excel')), 当使用 find 函数搜索不到时，返回 -1。 \n",
    "* 第 2 行代码 print('Python'.index('Excel')), 当使用 index 函数搜索不到时，返回错误提示。提示错误为“**ValueError: substring not found”**，表示未找到子字符串\n",
    "\n",
    "#### 13.3.3 字符串搜索应用案例：提取指定位置的信息\n",
    "\n",
    "本案例截取信息表中 A 列的部门信息，将截取结果写入 B 列对应的单元格中，如图所示。\n",
    "\n",
    "本案例的编程思路是首先获取“(”和“）”的位置，然后使用字符串切片的方法截取两个位置之间的字符串。\n",
    "\n",
    "![q0sy0k](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/q0sy0k.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3dbb058",
   "metadata": {},
   "outputs": [],
   "source": [
    "import xlrd #导入读取 xls 文件的库。\n",
    "from xlutils.copy import copy #导入工作簿复制函数。\n",
    "wb = xlrd.open_workbook('./8-Departments-1.xls') #读取工作簿。\n",
    "ws = wb.sheet_by_name('信息表') #读取工作表。\n",
    "nwb = copy(wb) #复制工作簿产生一个副本。\n",
    "nws = nwb.get_sheet('信息表') #读取副本中的工作表。\n",
    "row_num = 0 #初始化 row_num 变量为 0。\n",
    "while True: #条件为 True，表示会一直循环，在循环中做终止循环处理。\n",
    "    row_num += 1 #对 row_num 变量累加 1。\n",
    "    if row_num > ws.nrows-1: #当 row_num 变量大于已使用单元格区域行数时。\n",
    "        break #则终止循环。\n",
    "    info = ws.cell_value(row_num, 0) #获取 A 列单元格的值。\n",
    "    strat = info.find('（')+1 #搜索 '（' 的位置，应该从 '（' 之后，所以最后要加 1。\n",
    "    end = info.find('）') #搜索 '）' 的位置。\n",
    "    dept = info[strat:end] #截取 A 列单元格 '（' 和 '）' 之间的部门信息。\n",
    "    nws.write(row_num,1,dept) #将截取到的部门信息写入 B 列单元格。\n",
    "nwb.save('./8-Departments-1.xls') #保存工作簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1d78724",
   "metadata": {},
   "source": [
    "* 第 1～7 行代码为读取工作表数据和写入工作表做准备。\n",
    "* 第 8 行代码开始循环读取单元格。\n",
    "* 第 9～16 行代码是循环体中的处理语句。\n",
    "* 第 10 行和第 11 行代码用来终止循环。\n",
    "* 第 12～16 行代码首先获取单元格的值，再获取“（”和“）”的索引位置，然后截取部门信息，最后将部门信息写入副本工作簿中工作表 B 列对应的单元格。\n",
    "* 第 17 行代码保存工作簿副本。\n",
    "\n",
    " ### 13.4 字符串替换 replace\n",
    " \n",
    "字符串替换的本质就是有条件地对字符串进行修改。前面不是说过字符串是只读属性，不能修改吗？实际上，替换后的字符串内存地址已经不是替换前的字符串内存地址，也就是说，并没有修改替换前的字符串，替换后生成了一个新的字符串。\n",
    "\n",
    "#### 13.4.1 字符串替换方法 replace\n",
    "\n",
    "**replace** 函数用于把字符串中指定的旧字符串替换成指定的新字符串，默认全部替换。\n",
    "\n",
    "函数语法：**replace(old,new[,count])**\n",
    "\n",
    "参数说明：\n",
    "* old: 必选参数，被替换的旧字符串。\n",
    "* new: 必选参数，新字符串，用于替换旧字符串。\n",
    "* count: 可选参数，替换的次数，默认替换所有出现的旧字符串。\n",
    "\n",
    "例如，将字符串 'A组-优秀；B组-良好；C组-优秀；D组-优秀' 中的“优秀”替换为“晋级”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be920dfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt='A组-优秀；B组-良好；C组-优秀；D组-优秀' #被替换的字符串。\n",
    "print(txt.replace('优秀','晋级')) #将所有 '优秀' 替换为 '晋级'。\n",
    "print(txt.replace('优秀','晋级',1)) #将前 1 个 '优秀' 替换为 '晋级'。\n",
    "print(txt.replace('优秀','晋级',2)) #将前 2 个 '优秀' 替换为 '晋级'。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7945b20",
   "metadata": {},
   "source": [
    "* 第 2 行代码 print(txt.replace('优秀','晋级')), 如果不指定第 3 个参数，则默认将所有的“优秀”替换为“晋级”，替换结果为 'A组-晋级；B组-良好；C组-晋级；D组-晋级'。\n",
    "* 第 3 行代码 print(txt.replace('优秀','晋级',1)), 如果指定第 3 个参数为 1，则表示将第 1 个“优秀”替换为“晋级”，替换结果为 'A组 - 晋级；B组-良好；C组-优秀；D组-优秀。\n",
    "* 第 4 行代码 print(txt.replace('优秀','晋级',2)), 如果指定第 3 个参数为 2，则表示将前两个“优秀”替换为“晋级”，替换结果为 'A组-晋级；B组-良好；C组-晋级；D组-优秀。\n",
    "\n",
    "### 13.5 字符串拆分与合并 split/join\n",
    "\n",
    "字符串的拆分与合并可以使用字符串切片的方法来完成，但字符太多就不方便了，表达也不够简洁、灵活。本小节讲解使用 **split** 函数和 **join** 函数来完成字符串的拆分与合并。\n",
    "\n",
    "#### 13.5.1 拆分字符串为列表 split\n",
    "\n",
    "**split** 函数用于拆分字符串，可以指定分隔符对字符串进行切片，并返回拆分后的字符串列表。\n",
    "\n",
    "函数语法：**split([sep] [,maxsplit])**\n",
    "\n",
    "参数说明：\n",
    "* sep: 可选参数，表示分隔符，默认为空格(''), 但是不能为空(＂) 。分隔符可以是单个字符，也可以是多个字符。如果是多个字符，则被看作一个整体。\n",
    "* maxsplit: 可选参数。表示要执行的最大拆分数。-1(默认值)表示无限制。例如，对字符串 '10 20 50' 和 '78|98|100' 进行拆分。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68cc2f18",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('10 20 50'.split()) #默认以 ' ' 进行拆分。\n",
    "print('10 20 50'.split('|')) #指定的拆分符号在字符串中不存在。\n",
    "print('78|98|100'.split('|')) #指定的拆分符号在字符串中存在。\n",
    "print('78|98|100'.split('|',1)) #指定拆分个数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ccde0ae",
   "metadata": {},
   "source": [
    "* 第 1 行代码 print('10 20 50'.split()), 对字符串'10 20 50'进行拆分，由于 split 函数中没有指定任何参数，所以默认以空格对整个字符串进行拆分，返回值为['10','20','50']。 \n",
    "* 第 2 行代码 print('10 20 50'.split('|')), 对字符串 '10 20 50' 按分隔符“I”进行拆分，由于字符串中并不存在“I”，因此返回的结果不是字符串，而是列表['102050']，列表中只有一个元素 '10 20 50'。\n",
    "* 第 3 行代码 print('78|98|100'.split('|')), 对字符串 '78|98|100' 按分隔符“I”进行拆分，返回值为['78','98','100']。\n",
    "* 第 4 行代码 print('78|98|100'.split('|',1)), 对字符串 '78|98|100' 按分隔符“I”进行拆，split 函数的第 2 个参数 **1** 表示只拆分到第 1 次出现的“I”，因此返回值为['78','98|100']。\n",
    "\n",
    "#### 13.5.2 合并列表为字符串 join\n",
    "\n",
    "前面通过 **split** 函数将字符串拆分成列表，列表中存储的是拆分出来的子字符串。现在要反向操作，将列表中的子字符串合并成一个大的字符串，可以使用 **join** 函数来完成。\n",
    "\n",
    "函数语法：**join(iterable)**\n",
    "\n",
    "参数说明：\n",
    "Iterable: 必选参数，可以是列表、元组等可迭代对象，但其中的值只能为字符串，不能是其他数据类型。\n",
    "\n",
    "例如，以“-”为分隔符对列表['张三',18',' 财务部]进行合并。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcc274cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('-'.join(['张三','18','财务部'])) #返回 '张三-18-财务部'。"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 对比 Python 中的列表、字典、集合和元组，包括可变性、重复元素、常见操作及其复杂度等方面。\n",
    "\n",
    "### 扩展对比表\n",
    "\n",
    "| 特性            | 列表 (List)            | 字典 (Dictionary)       | 集合 (Set)               | 元组 (Tuple)              |\n",
    "|-----------------|------------------------|-------------------------|--------------------------|---------------------------|\n",
    "| **有序性**      | 有序                   | 有序（Python 3.7+）     | 无序                     | 有序                      |\n",
    "| **可变性**      | 可变                   | 可变                    | 可变                     | 不可变                    |\n",
    "| **插入**        | 任意位置               | 通过键                  | 任意位置（无序）         | 不可插入                  |\n",
    "| **获取**        | 通过索引               | 通过键                  | 通过遍历                 | 通过索引                  |\n",
    "| **形式**        | `[]`                   | `{}`                    | `{}`                     | `()`                      |\n",
    "| **重复元素**    | 允许                   | 键不允许重复，值允许重复 | 不允许                   | 允许                      |\n",
    "| **成员测试**    | O(n)                   | O(1)                    | O(1)                     | O(n)                      |\n",
    "| **迭代**        | 是                     | 是                      | 是                       | 是                        |\n",
    "| **常见操作**    | append, extend, insert | get, keys, values, items| add, remove, union       | 无特定操作                |\n",
    "| **操作复杂度**  | append: O(1), insert: O(n) | get: O(1), set: O(1)    | add: O(1), remove: O(1)  | -                         |\n",
    "| **用例**        | 有序集合，随机访问     | 键值对存储              | 唯一元素集合             | 固定有序集合，避免修改    |\n",
    "| **内存效率**    | 相对高                 | 较高                    | 高                       | 最高                      |\n",
    "| **多维性**      | 支持多维               | 支持嵌套                | 不直接支持               | 支持嵌套                  |\n",
    "| **线程安全**    | 否                     | 否                      | 否                       | 否                        |\n",
    "| **初始化**      | `[]` 或 `list()`       | `{}` 或 `dict()`        | `{}` 或 `set()`          | `()` 或 `tuple()`         |\n",
    "| **典型应用场景**| 序列操作，随机存取     | 键值对快速查找          | 去重，集合运算           | 不变数据，常量集合        |\n",
    "\n",
    "### 详细解释\n",
    "\n",
    "- **有序性**：指元素是否按插入顺序排列。列表和元组是有序的；字典在 Python 3.7+ 版本中是有序的；集合无序。\n",
    "- **可变性**：指数据结构是否可以修改。列表、字典和集合是可变的，元组是不可变的。\n",
    "- **重复元素**：指数据结构是否允许包含重复元素。列表和元组允许重复，集合不允许重复，字典的键不允许重复但值允许。\n",
    "- **成员测试**：检查一个元素是否在数据结构中。列表和元组的成员测试复杂度为 O(n)，字典和集合为 O(1)。\n",
    "- **常见操作**：列表有 `append`、`extend` 和 `insert` 等操作；字典有 `get`、`keys`、`values` 和 `items`；集合有 `add`、`remove` 和 `union`；元组没有特定的操作。\n",
    "- **操作复杂度**：常见操作的时间复杂度。列表的 `append` 操作为 O(1)，`insert` 操作为 O(n)；字典的 `get` 和 `set` 操作为 O(1)；集合的 `add` 和 `remove` 操作为 O(1)。\n",
    "- **用例**：典型的使用场景。例如，列表用于有序集合和随机访问；字典用于键值对存储和快速查找；集合用于唯一元素集合和集合运算；元组用于固定有序集合和避免修改。\n",
    "- **内存效率**：内存使用效率，一般来说元组的效率最高，其次是集合，然后是字典，最后是列表。\n",
    "- **多维性**：指是否支持多维数据结构。列表和字典支持嵌套从而实现多维，集合不直接支持，元组支持嵌套。\n",
    "- **线程安全**：是否在多线程环境中安全。通常，以上数据结构都不是线程安全的，需要使用线程安全的包装或锁机制。\n",
    "- **初始化**：表示数据结构的初始化方式。\n",
    "- **典型应用场景**：常见的使用场景和用途。\n",
    "\n",
    "通过以上对比，能够更清晰地理解这四种数据结构的特点及其适用场景，从而在编程中选择合适的数据结构。"
   ],
   "id": "43ca9dffc8d94cdb"
  },
  {
   "cell_type": "markdown",
   "id": "578a828b",
   "metadata": {},
   "source": [
    "## 14. Python 有序对象--列表处理技术\n",
    "\n",
    "### 14.1 列表的创建与删除\n",
    "\n",
    "列表用中括号 ([]) 表示，列表里的元素用逗号分隔。下面介绍列表的创建和删除。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb18ee26",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst1 = [];print(lst1) #创建空列表方法 1。\n",
    "lst2 = list();print(lst2) #创建空列表方法 2。\n",
    "lst3 = [1,2,3];print(lst3) #创建多个元素的列表。\n",
    "lst3.clear();print(lst3)# 清空列表中的所有元素。\n",
    "del lst3 #删除列 lst3 列表。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dbf0265",
   "metadata": {},
   "source": [
    "* 第 1 行代码 lst1=[]，使用一对空的中括号创建空列表。运行 print(lst1)后，在屏幕上输出结果[]。\n",
    "* 第 2 行代码 lst2=list()，使用 list 类创建一个空列表，运行 print(lst2)后，在屏幕上输出结果[]。\n",
    "* 第 3 行代码 lst3=[1,2,3], 创建有多个元素的列表，运行 print(lst3)后，在屏幕上输出结果[1,2,3]。\n",
    "* 第 4 行代码 Ist3.clear()，清空 lst3 列表中的所有元素，运行 print(lst3)后，在屏幕上输出结果[]。\n",
    "* 第 5 行代码 del lst3，使用 del 语句删除指定的列表。删除后，lst3 列表就不存在了。\n",
    "\n",
    "###  14.2 列表切片\n",
    "\n",
    "列表、字符串和元组对象都支持以索引序号的方式进行切片。\n",
    "\n",
    "#### 14.2.1 单元素切片\n",
    "\n",
    "列表的切片方法与字符串的切片方法一样，语法结构为列表[索引位置], 索引位置的序号是从 0 开始的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1782bcb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst=['张三',19,[80,89,97]]# 要进行切片的列表。\n",
    "print(lst[0],lst[1],lst[2])# 以开头为基准切片，返回值：张三 19 [80, 89, 97]。\n",
    "print(lst[-1],lst[-2],lst[-3])# 以结尾为基准切片，返回值：[80, 89, 97] 19 张三。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe58cd83",
   "metadata": {},
   "source": [
    "#### 14.2.2 多元素切片\n",
    "\n",
    "在列表中可以截取一部分元素，语法结构为列表[开始索引: 结束索引: 步长]。注意，切片的结果中不包含结束索引位置的元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26e8d55e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst=[7,3,12,54,6,9,88,2,47,33,55] #要做切片处理的列表。\n",
    "print(lst[2:5]) #以开头为基准切片，返回[12,54,6]。\n",
    "print(lst[-9:-6]) #以结尾为基准切片，返回[12,54,6]。\n",
    "print(lst[:4]) #以开头为基准切片，返回[7,3,12,54]。\n",
    "print(lst[:-7])# 以结尾为基准切片，返回[7,3,12,54]。\n",
    "print(lst[6:]) #以开头为基准切片，返回[88,2,47,33,55]。\n",
    "print(lst[-5:]) #以开头为基准切片，返回[88,2,47,33,55]。\n",
    "print(lst[5:-2])# 开始索引以开头为基准，结束索引以结尾为基准，返回[9,88,2,47]。\n",
    "print(lst[-6:9])# 开始索引以结尾为基准，结束索引以开头为基准，返回[9,88,2,47]。\n",
    "print(lst[:]) #截取整个列表切片，返回[7,3,12,54,6,9,88,2,47,33,55]。\n",
    "print(lst[::2]) #截取整个列表切片，步长为 2，返回[7,12,6,88,47,55]。\n",
    "print(lst[::-1]) #截取整个列表切片，步长为 -1，返回[55,33,47,2,88,9,6,54,12,3,7]。\n",
    "print(lst[::-2]) #截取整个列表切片，步长为 -2，返回[55,47,88,6,12,7]。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28ee4ba8",
   "metadata": {},
   "source": [
    "| 切片要求                  | 以开头为基准           | 以结尾为基准            | 返回值                           |\n",
    "| --------------------- | ---------------- | ----------------- | ----------------------------- |\n",
    "| 从指定位置开始，截取到指定结束位置     | print(lst[2:5])  | print(lst[-9:-6]) | [12,54,6]                     |\n",
    "| 从最左侧开始，截取到指定结束位置      | print(lst[:4])   | print(lst[:-7])   | [7,3,12,54]                   |\n",
    "| 从指定位置开始，截取到最右侧        | print(lst[6:])   | print(lst[-5:])   | [88,2,47,33,55]               |\n",
    "| 开始索引以开头为基准，结束索引以结尾为基准 | print(lst[5:-2]) | print(lst[-6:9])  | [9,88,2,47]                   |\n",
    "| -------------         | -------------    | ---------------   | --------------------          |\n",
    "| 截取整个列表切片              | print(lst[:])    |                   | [7,3,12,54,6,9,88,2,47,33,55] |\n",
    "| 截取整个列表切片，步长为 2         | print(lst[::2])  |                   | [7,12,6,88,47,55]             |\n",
    "| 截取整个列表切片，步长为 -1        | print(lst[::-1]) |                   | [55,33,47,2,88,9,6,54,12,3,7] |\n",
    "| 截取整个列表切片，步长为 -2        | print(lst[::-2]) |                   | [55,47,88,6,12,7]             |\n",
    "\n",
    "### 14.3 列表元素的增加、删除和修改\n",
    "\n",
    "列表在 Python 中的操作非常灵活，除可以对列表做切片外，还可以对列表进行增加、删除和修改元素等操作。\n",
    "\n",
    "#### 14.3.1 列表元素的修改\n",
    "\n",
    "对列表中的元素进行修改，语法结构为列表 `[索引位置] = 修改的值 `。案例代码如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8102d394",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = ['张三',18,[100,90]] # 被修改的列表\n",
    "lst[0] = '小明' # 修改列表中的第 0 个元素。\n",
    "lst[1] = '18岁' # 修改列表中的第 1 个元素。\n",
    "lst[2] = 190 # 修改列表中的第 2 个元素。\n",
    "print(lst) # 在屏幕打印修改后的 lst 列表。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93e71308",
   "metadata": {},
   "source": [
    "#### 14.3.3 列表元素的增加\n",
    "\n",
    "在列表中增加元素可以使用加运算符 **(+)、append 函数、extend 函数、insert 函数**来完成，下表列出了不同的实现方法。\n",
    "\n",
    "| 名称 | 语法结构 | 注释 |\n",
    "| ------|------------- |------ |\n",
    "| +       | list += list                            | 使用加运算符的累积功能 | \n",
    "| append | append(object)     | 在列表末端增加一个元素 |\n",
    "| extend | extend(iterable)      | 在列表末端增加多个元素 |\n",
    "| insert | insert(index,object)| 在列表指定位置增加一个元素 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d08b052e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = ['张三'];print(lst)# 原始列表。\n",
    "lst += ['6年级'];print(lst) #使用积累方式增加。\n",
    "lst.append('9班');print(lst)# 使用 append 方法增加单个元素。\n",
    "lst.extend([85,96]);print(lst)# 使用 extend 方法增加多个元素。\n",
    "lst.insert(3,'12岁');print(lst)# 使用 insert 在列表指定位置插入。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f24ed6f3",
   "metadata": {},
   "source": [
    "上面代码的运行结果：\n",
    "['张三']\n",
    "['张三','6年级']\n",
    "['张三','6年级','9班']\n",
    "['张三','6年级','9班',85,96]\n",
    "['张三','6年级','9班','12岁',85,96]\n",
    "\n",
    "#### 14.3.3 列表元素的删除\n",
    "\n",
    "在列表中删除元素，可以使用 **remove 函数、del 函数、pop 函数**来完成，它们的语法结构及注释如表所示。\n",
    "\n",
    "删除列表元素的几种方法的语法结构及注释\n",
    "\n",
    "| 名称 | 语法结构 | 注释 |\n",
    "| -------| -----------|-----------------------|\n",
    "| remove | remove(object) | 从列表中删除指定的元素，不是指定元素的位置 |\n",
    "| pop        | pop()                         | 默认删除列表中的最后一个元素 | \n",
    "| pop        | pop(index)           | 删除列表中指定位置的元素 | \n",
    "| del         | del                               | 删除指定列表范围的元素 | \n",
    "\n",
    "下面看看使用不同方法的小案例，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2029457",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = ['张三', '6年级', '9班', '12岁', 85, 96];print(lst) #原始列表。\n",
    "lst.remove('12岁');print(lst) #使用 remove 方法删除列表元素。\n",
    "lst.pop();print(lst) #使用 pop 方法删除最列表最后一个元素。\n",
    "lst.pop(2);print(lst) #使用 pop 方法删除指定位置元素。\n",
    "del lst[1:];print(lst) #使用 del 语句删除指定列表区域元素。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "314d242a",
   "metadata": {},
   "source": [
    "上面的代码的运行效果：\n",
    "\n",
    "['张三','6 年级','9 班','12 岁',85,96]\n",
    "['张三','6 年级','9 班',85,96]\n",
    "['张三','6 年级','9 班',85]\n",
    "['张三','6 年级',85]\n",
    "['张三']\n",
    "\n",
    "### 14.4 列表操作符\n",
    "\n",
    "列表与列表之间可以进行连接、比较等操作，也可以对列表进行重复操作，还可以判断指定元素是否在列表中等，这些操作可能只需要使用一个符号就可以完成。\n",
    "\n",
    "#### 14.4.1 列表操作符基础\n",
    "\n",
    "列表操作符有 **+、*、in 和比较运算符**。下面列举几个小案例，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "7278b08c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:02:23.280615Z",
     "start_time": "2024-06-22T08:02:23.270890Z"
    }
   },
   "source": [
    "print([1,2,3]+[4,5])# 列表连接使用 + 运算符。\n",
    "print([1,2,3]*3)# 重复列表使用 * 运算符。\n",
    "print(2 in [1,2,3])# 判断某个值是否在列表中存在。\n",
    "print([1,2,3]==[1,2,3])# 列表比较运算。\n",
    "print([1,2,3]<[1,3,2])# 列表比较运算"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "id": "d15ce865",
   "metadata": {},
   "source": [
    "### 14.5 列表推导式\n",
    "\n",
    "列表推导式在逻辑上相当于一个 for 循环语句，只是形式上更加简洁。列表推导式执行完成后会创建新的列表。无论列表推导式的写法如何变化，最后都会返回列表对象。如果循环的目的是将数据写入指定单元格，那么最好用标准的循环语句，而不要用列表推导式。\n",
    "\n",
    "#### 14.5.1 标准列表推导式\n",
    "\n",
    "列表推导式的语法结构：**[表达式 for 变量 in 列表]**\n",
    "\n",
    "例如，将 **['89','96','100',72']** 中的文本型数字转换为标准整数，可以使用列表推导式或 for 循环语句，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caf46904",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 原始列表。\n",
    "lst = ['89','96','100','72']\n",
    "#使用列表推导。\n",
    "lst1 = [int(n) for n in lst]\n",
    "print(lst1)\n",
    "#使用循环方式。\n",
    "lst2 = []\n",
    "for n in lst:\n",
    "    lst2.append(int(n))\n",
    "print(lst2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5babdcf",
   "metadata": {},
   "source": [
    "#### 14.5.2 列表推导式变异\n",
    "\n",
    "如果推导列表中的元素不是单值，而是列表或其他可循环序列，则在使用列表推导式或 for 循环时，可以将要循环的元素拆分。比如列表 **[[1,2,5],[10,5,6],[8,5,3]]**, 此列表中的元素也是列表，假如求每个子列表的值的乘积，可以使用两种列表推导式和两种 for 循环语句完成，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7a0d8f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#原始列表\n",
    "lst = [[1,2,5],[10,5,6],[8,5,3]]\n",
    "#列表推导式 1\n",
    "lst1 = [l[0]*l[1]*l[2] for l in lst]\n",
    "print(lst1)\n",
    "#列表推导式 2\n",
    "lst2 = [x*y*z for x,y,z in lst]\n",
    "print(lst2)\n",
    "#循环方式 1\n",
    "lst3 = []\n",
    "for l in lst:\n",
    "    lst3 += [l[0]*l[1]*l[2]]\n",
    "print(lst3)\n",
    "#循环方式 2\n",
    "lst4 = []\n",
    "for x,y,z in lst:\n",
    "    lst4 += [x*y*z]\n",
    "print(lst4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fc4a52c",
   "metadata": {},
   "source": [
    "* 第 1 种列表推导式 (第 4 行和第 5 行代码)：首先看 **lst1=[l[0]\\*l[1]\\*l[2] for l in lst]** 部分，l 表示循环出来的每个子列表，**l[0]\\*l[1]\\*l[2]** 表示将子列表的第 0、1、2 个元素相乘。运行 print(lst1)，在屏幕上输出的结果为[10,300,120]。\n",
    "* 第 2 种列表推导式(第 7 行和第 8 行代码)：首先看 **lst2=[x\\*y\\*z for x,y,z in lst]** 部分，x、y、z 分别表示子列表的第 0、1、2 个元素，x*y*z 表示将它们相乘。运行 print(lst2)，在屏幕上输出的结果为[10,300,120]。\n",
    "    - 第 1 种 for 循环方式(第 10～13 行代码)与第 1 种列表推导式思路相同。\n",
    "    - 第 2 种 for 循环方式(第 15～18 行代码)与第 2 种列表推导式思路相同。\n",
    "\n",
    "> 注意，每个子列表的元素个数必须相同，否则会出错。例如 [[1,2],[3,4]] 符合要求，而 [[1,2],[3]] 不符合要求。\n",
    "\n",
    "#### 14.5.3 嵌套列表推导式\n",
    "\n",
    "嵌套列表推导式的语法结构：**[表达式 for 变量1 in 列表1 for 变量2 in 变量1 for 变量3 in 变量2...]**。可以多层嵌套，注意放在 in 后面的对象必须是可迭代对象。\n",
    "\n",
    "例如，在列表 **[[1,2],[3,4,5],[6,7]]** 中有 3 个元素，每个元素也是列表，下面将这些列表元素合并放在同一个列表中，并且每个数字还要乘以 10，结果为 **[10,20,30,40,50,60,70]**。\n",
    "\n",
    "可以使用嵌套列表推导式或嵌套 for 循环语句实现，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0bd55fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#原始列表。\n",
    "lst = [[1,2],[3,4,5],[6,7]]\n",
    "#使用嵌套列表推导。\n",
    "lst1 = [v*10 for l in lst for v in l]\n",
    "print(lst1)\n",
    "#使用嵌套循环方式。\n",
    "lst2 = []\n",
    "for l in lst:\n",
    "    for v in l:\n",
    "        lst2.append(v*10)\n",
    "print(lst2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be14bca8",
   "metadata": {},
   "source": [
    "* 在第 4 行和第 5 行代码中，代码 **lst1 =[v*10 for l in Ist for v in l]** 在执行时首先运行 **for l in lst**，l 分别循环出 **[1,2]、[3,4,5]、[6,7]** 3 个元素，再运行 for v in l，v 分别循环出 **[1,2]** 中的 1、2，**[3,4,5]** 中的 3、4、5，**[6,7]** 中的 6、7，并将这些循环出来的数字乘以 10。\n",
    "* 第 5 行代码运行 **print(lst1)**，在屏幕上输出的结果为 **[10,20,30,40,50,60,70]**。\n",
    " * 如果使用标准的 **for** 循环语句，则可以使用第 7～11 行代码来完成，最后 **lst2** 变量存储的就是转换后的数字。运行第 11 行代码 **print(lst2)**，在屏幕上输出的结果为 **[10,20, 30,40,50,60,70]**。\n",
    "\n",
    "#### 14.5.4 条件列表推导式\n",
    "\n",
    "条件列表推导式语法结构：**[表达式 for 变量 in 列表 if 条件判断]**\n",
    "\n",
    "例如，对列表 **[85,68,98,74,95,82,93,88,74]** 进行筛选，筛选出大于或等于 **90** 的值，生成新的列表。下面分别使用条件列表推导式和 for 循环语句来实现，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85143c73",
   "metadata": {},
   "outputs": [],
   "source": [
    "#原始列表。\n",
    "lst = [85,68,98,74,95,82,93,88,74]\n",
    "#使用条件列表推导。\n",
    "lst1 = [n for n in lst if n>=90]\n",
    "print(lst1)\n",
    "#使用条件循环方式。\n",
    "lst2 = []\n",
    "for n in lst:\n",
    "    if n>= 90:\n",
    "        lst2.append(n)\n",
    "print(lst2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d591ad7b",
   "metadata": {},
   "source": [
    "* 第 4 行代码 **lst1=[n for n in lst if n>=90]**, **for n in lst** 后面的 **if n>=90** 表示当条件成立时，n 变量保留。\n",
    "* 运行第 5 行代码 **print(lstl)**，屏幕上的输出结果为 **[98,95,93]**。\n",
    "* 第 7～10 行代码，是在 for 循环体中使用 if 语句完成判断。\n",
    "* 运行第 11 行代码 **print(lst2)**，屏幕上的输出结果为 **[98,95,93]**。\n",
    "\n",
    "#### 14.5.5  列表推导式应用案例 1: 自动汇总多工作表数据\n",
    "\n",
    "本案例对工作簿中“1 月”，“2 月”，“3 月”工作表的 B 列数据进行求和，然后写入新工作簿的新工作表，如图所示。\n",
    "\n",
    "![aqjspO](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/aqjspO.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "515724ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "import xlwt,xlrd #导入读取与写入 xls 文件的库。\n",
    "wb = xlrd.open_workbook('./14-Turnover123-1.xls') #读取工作簿。\n",
    "nwb = xlwt.Workbook('uft-8');nws=nwb.add_sheet('汇总表') #新建工作簿与工作表。\n",
    "lst = [[ws.name,sum(ws.col_values(1)[1:])] for ws in wb.sheets()] #求和工作表中 B 列的金额。\n",
    "row_num = 0 #初始化 row_num 变量为 0。\n",
    "for rows in [['月份','总营业额']] + lst: #将表头连接到 lst 列表前面，并开始循环。\n",
    "    nws.write(row_num,0,rows[0]) #将月份写入 A 列。\n",
    "    nws.write(row_num,1,rows[1]) #将每个月的总营业额写入 B 列。\n",
    "    row_num += 1 #累加 row_num 变量，并做为写入数据时的行号。\n",
    "nwb.save('./14-Turnover123-2.xls') #保存工作簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a10694f",
   "metadata": {},
   "source": [
    "* 第 1～3 行代码为读取和写入数据做准备。\n",
    "* 第 4 行代码 **lst = [[ws.name,sum(ws.col_values(1)[1:])] for ws in wb.sheets()]**\n",
    "    - 其中 **for ws in wb.sheets()]** 用来循环读取工作簿中的每个工作表，再赋值给 **ws** 变量。\n",
    "    - **ws.name** 用来获取工作表名称，\n",
    "    - **sum(ws.col_values(1)[1:])** 用来获取工作表 B 列的数据并进行求和。\n",
    "* 整个列表推导的处理要求是将工作表名称与总金额组成列表，整行代码运行的结果是将 **[['1月',702.0],['2月',549.0],['3月',547.0]]** 赋值给 **lst** 变量。\n",
    "* 第 5～9 行代码是将获取的 **lst** 列表中的值写入新工作表。\n",
    "* 第 10 行代码用来保存新建的工作簿。\n",
    "\n",
    "#### 14.5.6  列表推导式应用案例 2: 汇总多工作簿数据\n",
    "\n",
    "汇总指定文件夹中所有工作簿下所有工作表 B 列的数据，然后写入新工作簿的工作表，如图所示。\n",
    "\n",
    "![4021Ud](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/4021Ud.png)\n",
    "本案例的编程思路是循环读取每个工作簿中每个工作表 B 列的数据，然后进行求和。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64af3ea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os,xlwt,xlrd #导入操作系统接口模块，xls 读取与写入库。\n",
    "files = os.listdir('销售表') #获取销售表文件夹下的所有工作簿名称。\n",
    "lst = [[file.split('.')[0],ws.name,sum(ws.col_values(1)[1:])] for file in files for ws in xlrd.open_workbook('销售表 /'+file).sheets()] #对每个工作簿下每个工作表 B 列的数字求和。\n",
    "print(lst)\n",
    "lst = [['公司名','姓名','总营业额']]+lst #将表头连接到 lst 列表前面。\n",
    "nwb = xlwt.Workbook('utf-8');nws = nwb.add_sheet('汇总表') #新建工作簿与工作表。\n",
    "row_num = 0 #初始化 row_num 为 0。\n",
    "for l in lst: #循环 lst 列表中的每个元素。\n",
    "    nws.write(row_num,0,l[0]) #将公司名写入 A 列。\n",
    "    nws.write(row_num,1,l[1]) #将工作表名写入 B 列。\n",
    "    nws.write(row_num,2,l[2]) #将每个人的业绩写入 C 列。\n",
    "    row_num += 1 #累加 row_num 变量，并做为写入数据时的行号。\n",
    "nwb.save('./15-SalesReport.xls') #保存工作簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6ab2b0",
   "metadata": {},
   "source": [
    "* 第 1 行代码 **import os,xlwt,xlrd**，其中 os 表示导入操作系统接口模块，此模块是内置的，无须安装，主要是为了使用其中的 **listdir** 函数。\n",
    "* 第 2 行代码 **files = os.listdir('销售表')**，表示获取“销售表”文件夹中的所有文件名。当前“销售表”文件夹中只有工作簿，所以获取了所有工作簿名称。将工作簿名称赋值给 files 变量，files 变量中的值为 **['上海分公司.xls','广州分公司.xls','成都分公司.xls']** 。 \n",
    "* 第 3 行代码 **lst=[[file.split('.')[0],ws.name,sum(ws.col_values(1)[1:])]  for file in files for ws in xlrd.open_workbook('销售表 /'+file).sheets()]**，这行代码是嵌套列表推导式结构。"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "- 先看 **for file in files** 部分，它循环获得工作簿名称并赋值给 file 变量；\n",
    "- 再看 **for ws in xlrd.open_workbook('销售表/'+file).sheets()** 部分，它循环读取工作簿中所有工作表对象，然后赋值给 **ws** 变量；\n",
    "- 最后看 **[file.split('.')[0],ws.name,sum(ws.col_values(1)[1:])]** 部分，**file.split('.')[0]** 是获取的工作簿名称，不要扩展名，**ws.name** 是获取的工作表名称，**sum(ws.col_values(1)[1:])** 是求和工作表 B 列的营业额。\n",
    "- 最终 lst 变量获得的值为 **['上海分公司','小张',822.0],['上海分公司','小王',751.0],['上海分公司','小李',677.0],['广州分公司','小曾,702.0],[' 广州分公司 ',' 小虎 ',549.0],[广州分公司','小梁',547.0],['成都分公司','小林,1207.0],[' 成都分公司 ',' 小刘 ',1544.0]]**。\n",
    "* 第 5 行代码用来新建工作簿与工作表，目的是把 lst 变量中的值写入新工作簿的新工作表。\n",
    "* 从第 6 行代码开始都是将 Ist 变量中的数据写入工作表的操作，这里不再赘述。"
   ],
   "id": "9b20ac707d28fa34"
  },
  {
   "cell_type": "markdown",
   "id": "35a56ec3",
   "metadata": {},
   "source": [
    "### 14.6 列表的转换\n",
    "\n",
    "前面学习了列表的切片，以及列表元素的添加、删除、修改等操作，如果想将其他对象转换为列表，或者想对列表的位置、顺序等进行调整，又该如何操作呢？\n",
    "\n",
    "#### 14.6.1 类对象转换 list\n",
    "\n",
    "在处理数据时有时需要将其他对象转换为列表，比如将元组、集合、字典转换为列表，任何可迭代对象均可直接或间接地转换为列表。要完成这些转换可以使用 **list** 类，对类进行实例化可以创建对象，因此可以通过 list 类来创建列表对象。\n",
    "\n",
    "类语法：**list([iterable])**\n",
    "\n",
    "参数说明：\n",
    "iterable: 可选参数，可迭代对象。\n",
    "\n",
    "下面是其他常见对象转换为列表的例子，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3567f047",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list())#创建空列表。\n",
    "print(list('123'))#将字符串转换为单个字符的列表。\n",
    "print(list((1,2,3)))#将元组转换为列表。\n",
    "print(list({1,2,3}))#将集合转换为列表。\n",
    "print(list({'a':1,'b':2,'c':3}))#将字典中的键转换为列表。="
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbffdaac",
   "metadata": {},
   "source": [
    "* 第 1 行代码 print(list0)，创建空列表，结果为 [] 。\n",
    "* 第 2 行代码 print(list(123))，将字符串 '123'  转换为单个字符的列表，结果为 [1,2,3].\n",
    "* 第 3 行代码 print(list((1,2,3)))，将元组 (1,2,3) 转换为列表 [1,2,3] 。\n",
    "* 第 4 行代码 print(list((1,2,3)))，将集合(1,2,3｝转换为列表[1,2,3]。\n",
    "* 第 5 行代码 print(list({'a':1,'b':2,'c':3}))，将字典 {'a':1,'b':2,'c':13} 中的键转换为列表 ['a','b','c']。\n",
    "\n",
    "其中，元组、集合、字典这几种对象暂时还没有介绍到，它们也是Python中的重要对象，在这里暂时知道可以将它们转换为列表对象就可以了。\n",
    "\n",
    "#### 14.6.2 反转列表reverse\n",
    "\n",
    "要将列表中的元素反转，可以使用 reverse 函数。\n",
    "\n",
    "函数语法：**reverse()**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "该函数没有参数，可以对列表中的元素进行反向排序。\n",
    "\n",
    "例如，要将[1，2，3]转换为[3，2，1]，可以使用reverse函数，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b960cbb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4] #提供的列表。\n",
    "lst.reverse() #反转lst列表。\n",
    "print(lst) #在屏幕上打印lst列表。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6d56202",
   "metadata": {},
   "source": [
    "第 2 行代码 lst.reverse() 直接对lst列表使用 reverse 函数。注意，此函数没有任何参数，直接 reverse() 即可。\n",
    "\n",
    "#### 14.6.3 列表复制 copy\n",
    "\n",
    "列表的复制分为浅复制和深复制。浅复制只引用对象的内存地址，而深复制是重新开辟一个新的内存空间，得到完全独立的新对象。浅复制使用的是copy函数。\n",
    "\n",
    "函数语法：**copy()**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "该函数没有参数。\n",
    "\n",
    "copy 函数的案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ff68740",
   "metadata": {},
   "outputs": [],
   "source": [
    "#列表中元素是单值。\n",
    "lst1 = [1,2,3,4] #被复制的列表。\n",
    "lst2 = lst1.copy() #浅复制lst1列表，并赋值给lst2变量。\n",
    "lst1[3] = 100 #修改lst1中的元素。也可以修改lst2中的元素。\n",
    "print(lst1,lst2) #对浅复制前、后两个列表的数据。\n",
    "#列表中元素是容器型元素。\n",
    "lst3 = [1,[2,3],4] #被复制的列表，注意列表的第1个元素[2,3]也是列表。\n",
    "lst4 = lst3.copy() #浅复制lst3列表，并赋值给lst4变量。\n",
    "lst3[1][0] = 100 #修改lst3中的元素。也可以修改lst4中的元素。\n",
    "print(lst3,lst4) #对浅复制前、后两个列表的数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0e01e78",
   "metadata": {},
   "source": [
    "先看看当列表中的元素是单值时，在复制列表时的变化。\n",
    "\n",
    "* 第 2 行代码 **lst1 = [1,2,3,4]** 是准备要复制的列表。\n",
    "* 第 3 行代码 **lst2 = lst1.copy()**，表示对 **lst1** 列表进行复制，然后赋值给变量 **lst2**。\n",
    "* 第 4 行代码 **lst1[3] = 100**，对 lst1 列表中的第 3 个元素进行修改，将原来的 **4** 修改为 **100**。\n",
    "* 第 5 行代码 **print(lst1,lst2)** ，在屏幕上输出 lst1 和 lst2 两个列表，返回值为 **[1,2,3,100][1,2,3,4]**。\n",
    "    - 对比一下结果，**lst1** 的第 **3** 个元素与 **lst2** 的第 **3** 个元素不一致，原因是原来 **lst1[3]** 中对象4的内存地址换成了对象100的内存地址，\n",
    "    - 而 lst2[3] 还是引用原来对象4的内存地址，引用的内存地址没有跟着变化成对象100的内存地址。\n",
    "\n",
    "再看看当列表中的元素是容器型元素时，在复制列表时的变化。\n",
    "\n",
    "* 第 7 行代码 **lst3 = [1,[2,3],4]** 是准备要复制的列表。\n",
    "* 第 8 行代码 **lst4 = lst3.copy()**，对 **lst3** 列表进行复制，然后赋值给变量 **lst4**。\n",
    "* 第 9 行代码 **lst3[1][0] = 100**，对 **lst3** 列表中第 **1** 个元素的第 **0** 个元素进行修改，将原来的 **2** 修改为 **100**。\n",
    "* 第 10 行代码 **print(lst3,lst4)**，在屏幕上输出 **lst3** 和 **lst4** 两个列表，返回值为 **[1,[100,3],4][1,[100,3],4]**。对比一下结果，发现 **lst3** 和 **lst4** 的结果完全一样，原因是复制列表时引用的是列表元素的内存地址，比如 **lst3** 中的第 1 个元素 [2,3]，此元素也是一个列表，程序会在内存中给该列表分配一个内存地址。虽然使用 **lst3[1][0] = 100** 将其中的 **2** 修改为 **100**，但外层列表分配的内存地址没有变，所以最后返回的结果还是一样的。\n",
    "\n",
    "如果希望复制出的新列表与原来的列表没有任何关联，则可以使用深复制。深复制要先导入**copy**标准模块，然后使用中**copy**模块中的**deepcopy**函数。\n",
    "\n",
    "函数语法： **deepcopy(x)**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "x:必选参数，被深复制的对象。\n",
    "\n",
    "deepcopy 函数的案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d0b903c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#列表中元素是单值。\n",
    "import copy #导入复制模块。\n",
    "lst1 = [1,2,3,4]#准备要被复制的列表。\n",
    "lst2 = copy.deepcopy(lst1)#使用复制模块下的深复制方法来复制lst1，并赋值给lst2。\n",
    "lst1[3] = 100#修改lst1中的元素。也可以修改lst2中的元素。\n",
    "print(lst1,lst2)#对深复制前、后两个列表的数据。\n",
    "#列表中元素是容器型元素\n",
    "lst3 = [1,[2,3],4]#准备要被复制的列表。\n",
    "lst4 = copy.deepcopy(lst3)#使用复制模块下的深复制方法来复制lst3，并赋值给lst4。\n",
    "lst3[1][0]=100#修改lst3中的元素。也可以修改lst4中的元素。\n",
    "print(lst3,lst4)#对深复制前、后两个列表的数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f30777a7",
   "metadata": {},
   "source": [
    "以上代码与上段中的代码基本相同，只是在第 4 行和第 9 行代码中，将原来的浅复制函数修改成了深复制函数。复制后的新列表与原来的列表没有任何关联，因为深复制为新列表开辟了新的内存地址，而不是引用原来列表元素的内存地址。因此，无论是修改原列表中的元素，还是修改新列表中的元素，彼此都不会受影响。\n",
    "\n",
    "#### 14.6.4 列表组合 zip\n",
    "\n",
    "zip 函数是 Python 中的一个内建函数，它接收一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple(元组)，然后返回由这些元组组成的一个可迭代对象。\n",
    "\n",
    "函数语法：**zip(\\*iterables)**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "iterables:至少1个可迭代对象。\n",
    "\n",
    "下面是 zip 函数的使用案例，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fe8e468",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [['a','b','c'],[1,2,3]] #提供要重新组合的列表。\n",
    "lst1 = list(zip(l[0],l[1])) #将要转换的值分别放到zip的不同参数位置。\n",
    "print(lst1) #在屏幕打印重新组合后lst1的结果。\n",
    "lst2 = list(zip(*l)) #直接将整个l列表放到zip中。\n",
    "print(lst2) #在屏幕打印重新组合后lst2的结果。\n",
    "lst3 = list(zip(*lst2)) #再组合回原来的结构。\n",
    "print(lst3) #在屏幕打印重新组合后lst3的结果。\n",
    "print(list(zip(iter([1,2,3]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68b1887",
   "metadata": {},
   "source": [
    "* 第 2 行代码 **lst1=list(zip(l[0],l[1]))**,将l[0]和l[1]分别放入 zip 函数的第1个和第2个参数中,如果后面还有数据,可以继续放入第 3 个、第 4 个参数中。zip(l[0],l[1]) 转换出的是一个可迭代对象＜zip object at 0x00000247618012C8＞,这种可迭代对象的优势是不占用内存空间,在需要时才获取其中的数据,比如使用循环语句获取其中的元素,或者使用 list 类将其转换为列表,具体处理方式依据具体情况而定。\n",
    "\n",
    "* 第 3 行代码 print(lst1),在屏幕上输出的结果为 **[('a',1),('b',2),('c',3)]**。\n",
    "\n",
    "* 第 4 行代码 **lst2=list(zip(\\*l))** ,直接将 **l** 变量中的列表放到 zip 参数中,这种表达方式需要在列表前面加 *。最后 lst2 返回的结果与 lst1 返回的结果是一样的。\n",
    "\n",
    "* 第 5 行代码 **print(lst2)**,在屏幕上输出的结果为 **[('a',1),('b',2),('c',3)]**。\n",
    "\n",
    "* 第 6 行代码 **lst3=list(zip(\\*lst2))**,用同样的表达方式将 **lst1** 列表或 **lst3** 列表转换回去。返回的结果与l变量中的列表结构相同。\n",
    "\n",
    "* 第 7 行代码 **print(lst3)**,在屏幕上输出的结果为 **[('a','b','c),(1,2,3)]** ,与1变量中的[['a','b','c],[1,2,3]]结构相同,只不过列表中的元素由原来的列表类型变成了元组类型。\n",
    "\n",
    "### 14.7 列表常用统计方式\n",
    "\n",
    "用户经常会对列表进行各种汇总统计，本节就来讲解列表的求和、求平均值、计数等统计函数，以及按条件对列表元素进行计数、位置查找等。\n",
    "\n",
    "#### 14.7.1 常用统计函数 len/sum/max/min\n",
    "\n",
    "可以对列表进行一些常见的统计操作，比如计数、求和、求最大值、求最小值、求平均值。这些统计函数都比较简单，下面看看它们的应用，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44b3e206",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [100,99,81,86]#被处理的列表。\n",
    "print(len(lst))#计数处理。\n",
    "print(sum(lst))#求和处理。\n",
    "print(max(lst))#求最大值处理。\n",
    "print(min(lst))#求小值处理。\n",
    "print(sum(lst)/len(lst))#求平均值处理。\n",
    "print(len(list(zip(*[[1],[2]]))))\n",
    "print(len(list(iter(range(5)))))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "413ecda3",
   "metadata": {},
   "source": [
    "* 第 2 行代码 print(len(lst)) 是对 ls t列表计数。在统计字符串长度中讲解过 len函数，只不过这里对象为列表。\n",
    "* 第 3 行代码 print(sum(lst)) 是对 lst 列表求和，sum函数比较简单，在前面章节的一些案例中已经使用过了。\n",
    "* 第 4 行代码 print(max(lst) 是对 lst 列表求最大值。\n",
    "* 第 5 行代码 print(min(lst)) 是对 lst 列表求最小值。\n",
    "* 第 6 行代码 print(sum(lst)/len(lst) 是对 lst 列表求平均值。Python 没有内置的求平均值函数，只能用求和结果除以元素个数来获取平均值。\n",
    "\n",
    "实际上，**len、sum、max、min 函数**可以对所有可迭代的对象进行统计，比如后面将学习的元组、集合等都可以使用这些函数。\n",
    "\n",
    "#### 14.7.2  常用统计函数 count/index\n",
    "\n",
    "在列表中，要统计指定元素在列表中出现的次数，可以使用count函数；要统计指定元素在列表中出现的位置，可以使用index函数。这两个函数的案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e848b93",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = ['a','b','c','b','b']#被处理的列表。\n",
    "print(lst.count('b'))#统计'b'在列表中出现的次数。\n",
    "print(lst.index('b'))#统计'b'在列表中第1次出现的位置。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2718439c",
   "metadata": {},
   "source": [
    "* 第 2 行代码 print(Ist.count('b'))，统计 'b' 在lst列表中出现的次数，返回值为 3。\n",
    "* 第 3 行代码 print(Ist.index('b'))，统计 'b' 在列表中第 1 次出现的位置，返回值为 1。index函数的第2个和第3个参数可以用来指定起止位置。\n",
    "\n",
    "## 15. Python 有序对象--元组处理技术\n",
    "\n",
    "* 什么是元组？"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Python 中的元组与列表类似，同属序列类型，都可以按照特定顺序存放一组数据，数据类型不受限制，切片方式也相同。",
   "id": "e79885e8b3a50bb0"
  },
  {
   "cell_type": "markdown",
   "id": "2a57eec9",
   "metadata": {},
   "source": [
    "* 元组与列表的区别在于："
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "元组存储的数据不能被修改，比如不能对元组的元素进行添加、删除。可以将元组看作是只读属性的列表。",
   "id": "e0c5e68c0084456b"
  },
  {
   "cell_type": "markdown",
   "id": "58403170",
   "metadata": {},
   "source": [
    "* 为什么要使用元组？"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "虽然元组在操作上没有列表灵活，但元组占用的内存空间更小，存取速度更快。所以，某些内置函数的返回值是元组类型。比如，前面学习的zip函数，迭代出来的每个元素就是元组。",
   "id": "1c2991d10c88c954"
  },
  {
   "cell_type": "markdown",
   "id": "81cee2d3",
   "metadata": {},
   "source": [
    "### 15.1 元组的创建与删除\n",
    "\n",
    "元组用小括号 **()** 表示，元组里的元素用逗号分隔。下面介绍元组的创建和删除方法，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "578c8ebe",
   "metadata": {},
   "outputs": [],
   "source": [
    "tup1 = ();print(tup1) #创建空元组方法1。\n",
    "tup2 = tuple();print(tup2) #创建空元组方法2。\n",
    "tup3 = (1,2,3);print(tup3) #创建多个元素的元组。\n",
    "tup4 = (100,);print(tup4) #创建单个元素的元组。\n",
    "del tup3 #删除元组。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2840872",
   "metadata": {},
   "source": [
    "* 第 1 行代码 tupl = (),使用一对空小括号。运行 print(tup1) 后,屏幕上的输出结果为()。\n",
    "\n",
    "* 第 2 行代码 tup2 = tuple(),使用tuple类创建元组。运行 print(tup2) 后,屏幕上的输出结果为()。\n",
    "\n",
    "* 第 3 行代码 tup3 = (1,2,3),在小括号中输入元组的元素。运行 print(tup3) 后,屏幕上的输出结果为(1,2,3)。\n",
    "\n",
    "* 第 4 行代码 tup4 = (100,),在小括号中输入元组的元素。**注意,如果元组中的元素只有一个,则需要在这个元素的后面添加逗号,否则程序不能正确识别**。运行 print(tup4) 后,屏幕上的输出结果为(100,)。\n",
    "\n",
    "* 第 5 行代码 del tup3,使用 del 语句删除指定的元组。删除后,tup3 元组就不存在了。\n",
    "\n",
    "### 15.2 元组的基本操作\n",
    "\n",
    "元组虽然没有列表灵活,但一些基本的操作还是可以实现的,比如切片、合并、循环、推导、转换等。\n",
    "\n",
    "#### 15.2.1 元组的合并\n",
    "\n",
    "元组的合并非常简单。比如 **tup =(1,2,3)+(4,5,6)** ,输出结果为 **(1,2,3,4,5,6)**。这种合并方式是比较好理解的。而对于累积式合并,很多读者会有疑惑,下面举一个例子, 代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "c7f66fba",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:21:28.102300Z",
     "start_time": "2024-06-22T08:21:28.093211Z"
    }
   },
   "source": [
    "tup = (1,2,3) #元组。\n",
    "print(id(tup),tup) #合并前在屏幕打印元组内存地址和组。\n",
    "tup += (4,5,6) #将tup元组与(4,5,6)合并。\n",
    "print(id(tup),tup) #合并前在屏幕打印元组内存地址和组。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4573688064 (1, 2, 3)\n",
      "4573927936 (1, 2, 3, 4, 5, 6)\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "id": "53538f95",
   "metadata": {},
   "source": [
    "* 第 1 行代码 tup=(1,2,3)，这是最开始的元组。\n",
    "* 第 2 行代码 print(id(tup),tup)，输出 tup 元组的内存地址和tup元组的值，返回结 果为“2382958184472(1,2,3)”。\n",
    "* 第 3 行代码 tup+=(4,5,6)，将 tup 元组与(4,5,6) 合并，再赋值给tup。\n",
    "* 第 4 行代码 print(id(tup),tup)，再次输出 tup 元组的内存地址和 tup 元组的值，返回结果为“2382958104296(1,2,3,4,5,6)”。\n",
    "\n",
    "对比合并前后的输出结果，合并前tup的内存地址是2382958184472，合并后tup的内存地址是 2382958104296。这两个内存地址不同，说明 tup 变量标识符已经从2382958184472转换绑定到2382958104296。也就是说，用户看到的tup变量没有变化，但它绑定的内存地址已经变了。如果不明白其中的道理，就会觉得元组也是可以修改的。\n",
    "\n",
    "> 注意，代码中的 id 用于获取对象的内存地址，而且内存地址会动态变化。如果用户在计算机上测试上面的代码，则 id 可能与书上的 id 不同。这不重要，只要合并前后两个 id 的值不同就可以了。\n",
    "\n",
    "#### 15.2.2 元组的复制\n",
    "\n",
    "元组也可以进行深复制和浅复制，只不过浅复制只能使用copy模块中的浅复制。下面看看元组复制的一些特性，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88d0fc10",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy #导入复制模块。\n",
    "tup1 = (1,2,3) #准备要复制的元组。\n",
    "tup2 = copy.copy(tup1) #将浅复制tup1元组，并赋值给tup2变量。\n",
    "tup3 = copy.deepcopy(tup1)#将深复制tup1元组，并赋值给tup3变量。\n",
    "print(id(tup1),id(tup2),id(tup3)) #在屏幕打印tup1、tup2、tup3元组的内存地址。\n",
    "\n",
    "tup4 = (1,[2],3) #准备要复制的元组。\n",
    "tup5 = copy.copy(tup4) #将浅复制tup4元组，并赋值给tup5变量。\n",
    "tup6 = copy.deepcopy(tup4) #将深复制tup4元组，并赋值给tup6变量。\n",
    "print(id(tup4),id(tup5),id(tup6)) #在屏幕打印tup4、tup5、tup6元组的内存地址。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d54f2b",
   "metadata": {},
   "source": [
    "先看元组的元素为不可变类型的对象时的情况。\n",
    "\n",
    "* 第 2 行代码 tupl = (1,2,3)，元组中的每个元素都是不可变类型的对象，此元组是准备被复制的对象。\n",
    "\n",
    "* 第 3 行代码 tup2 = copy.copy(tup1)，此代码使用了copy模块中的浅复制copy函数，并且将复制结果赋值给tup2变量。\n",
    "\n",
    "* 第 4 行代码 tup3 = copy.deepcopy(tup1)，此代码使用了 copy 模块中的深复制 deepcopy 函数，并且将复制结果赋值给tup3变量。\n",
    "\n",
    "* 第 5 行代码 print(id(tupl),id(tup2),id(tup3))，在屏幕上输出 tupl、tup2、tup3的内存地址，结果为“2328759322728 2328759322728 2328759322728”。观察返回结果，可以发现3个元组的内存址相同。\n",
    "\n",
    "再看元组的元素为可变类型的对象时的情况。\n",
    "\n",
    "* 第 7 行代码 tup4 = (1,[2],3)，其中的 [2] 是可变类型的对象，此元组是准备被复制的对象。\n",
    "\n",
    "* 第 8 行代码 tup5 = copy.copy(tup4)，此代码使用了copy模块中的浅复制copy函数，并且将复制结果赋值给tup5变量。\n",
    "\n",
    "* 第 9 行代码 tup5 = copy.copy(tup4)，此代码使用了copy模块中的深复制 deepcopy 函数，并且将复制结果赋值给tup6变量。\n",
    "\n",
    "* 第 10 行代码 print(id(tup4),id(tup5),id(tup6))，在屏幕上输出tup4、tup5、tup6的内存地址，结果为“2328759323128 2328759323128 2328760171720。”观察返回结果，可以发现tup4和tup5的内存地址相同，而tup6的内存地址与其他两个内存地址不同。\n",
    "\n",
    "因此，当元组中有不可变类型的对象时，执行深复制和浅复制都不会再开辟内存空间，用的是同一个内存地址；当元组中有可变类型的对象时，执行深复制会重新开辟一块内存空间。\n",
    "\n",
    "#### 15.2.3 元组的循环\n",
    "\n",
    "元组也可以像列表一样做元组推导式和for循环，比如将元组(1，2，3)的每个元素乘 10，再返回一个新元组，可以分别使用元组推导式和 for 循环语句完成，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ced6eaf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = (1,2,3) #被循环的元组。\n",
    "tup1 = (t*10 for t in tup) #元组推导式。\n",
    "print(tup1) #在屏幕打印tup1元组。\n",
    "print(tuple(tup1)) #将tup1迭代器转换为元组。\n",
    "\n",
    "tup2 = () #创建空元组。\n",
    "for t in tup: #循环tup元组的元素。\n",
    "    tup2 += (t*10,) #将tup中的元素乘以10，再积累合并到tup2变量。\n",
    "print(tup2) #在屏幕打印tup2元组。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58c139fc",
   "metadata": {},
   "source": [
    "第 1 行代码 tup = (1,2,3) 是被循环的元组，也可以是其他可迭代对象。\n",
    "\n",
    "先看看使用元组推导式进行循环处理的情况。\n",
    "\n",
    "* 第 2 行代码 tup1=(t＊10 for t in tup)，用元组推导式循环出每个元素，再乘10，然后将推导结果赋值给tupl变量。\n",
    "\n",
    "* 第 3 行代码 print(tup1)，在屏幕上输出tup1元组，结果为“＜generator object＜genexpr＞at 0x000001F7BE98D5C8＞”。也就是说，元组推导式的结果不是元组，而是生成器，生成器也是可迭代对象。\n",
    "\n",
    "* 第4行代码 print(tuple(tupl))，使用tuple类对象将tupl转换为元组，返回结果为(10,20,30)。\n",
    "\n",
    "再看看使用for循环语句进行处理的情况。\n",
    "\n",
    "* 第 6 行代码 tup2=()，新建一个空元组。\n",
    "\n",
    "* 第 7 行代码 for t in tup:，循环tup元组中的每个元素。\n",
    "\n",
    "* 第 8 行代码 tup2 += (t*10，)，将循环出来的元素乘10，再积累并合并到tup2变量。第9行代码print(tup2)，在屏幕上输出tup2，返回结果为(10,20,30)。\n",
    "\n",
    "#### 15.2.4 类对象转换\n",
    "\n",
    "在Python中，可以使用tuple类对象创建或转换一个元组对象，比如创建空元组以及将字符串、列表、集合、字典这些可迭代对象转换为元组。\n",
    "\n",
    "类语法：**tuple([iterable])**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "iterable:可选参数，要转换为元组的可迭代序列。\n",
    "\n",
    "下面看几个转换的例子，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "697cbe85",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tuple('123')) #将字符串转换为单个字符的元组。\n",
    "print(tuple([1,2,3])) #将列表转换为元组。\n",
    "print(tuple({1,2,3})) #将集合转换为元组。\n",
    "print(tuple({'a':1,'b':2,'c':3})) #将字典中的键转换为元组。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad579dee",
   "metadata": {},
   "source": [
    "### 15.3 元组常用统计函数\n",
    "\n",
    "元组的统计函数与列表的统计函数相同，这里做一下简单介绍，案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18a829d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = (50,60,74,63,50,95,74,80,50) #被统计的元组。\n",
    "print(len(tup)) #计数\n",
    "print(max(tup)) #最大值\n",
    "print(min(tup)) #最小值\n",
    "print(sum(tup)) #求和\n",
    "print(tup.count(50)) #条件计数\n",
    "print(tup.index(80)) #条件定位\n",
    "format()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7b3f4a",
   "metadata": {},
   "source": [
    "## 16. Python 无序对象--字典处理技术\n",
    "\n",
    "Python中的字典是放在花括号中的，字和说明之间用冒号 **:** 分隔。\n",
    "\n",
    "Python 中字典的标准表示方法为｛key:value，······｝。\n",
    "\n",
    "* key(键)在字典中必须具有唯一性，且必须是不可变对象，如字符串、数字或元组。\n",
    "* value(值)可以重复，也可以是任何数据类型，如字符串、元组、列表、集合等。\n",
    "* 字典是无序的，只能通过键来存取对应的值，而不能像列表那样通过索引位置来存取对应的值。\n",
    "\n",
    "### 16.1 字典的基础操作\n",
    "\n",
    "本节将讲解创建字典及对字典进行存取操作的方法。通过一些相关的小案例，介绍在处理 Excel数据时如何应用字典。\n",
    "\n",
    "#### 16.1.1 字典的创建与删除\n",
    "\n",
    "下面介绍字典的创建与删除，案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8a497a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "dic1=dict();print(dic1)#使用dict类创建空字典。\n",
    "dic2=dict(王五=22,麻子=24);print(dic2)#使用dict类创建字典。\n",
    "dic3={};print(dic3)#直接使用{}创建空字典。\n",
    "dic4={'张三':18,'李四':20};print(dic4)#直接使用{}创建字典。\n",
    "del dic4#删除指定的字典。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba9977e6",
   "metadata": {},
   "source": [
    "#### 16.1.2 字典中键值的获取\n",
    "\n",
    "想获取字典中每个键对应的值，该怎么办？想获取字典中所有的键或所有的值，又该如何操作？案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc178dae",
   "metadata": {},
   "outputs": [],
   "source": [
    "dic={'张三': 18, '李四': 20}#准备的字典。\n",
    "print(dic['李四'])#获取指定键对应的值。\n",
    "print(dic.keys())#获取字典的所有键。\n",
    "print(dic.values())#获取字典的所有值。\n",
    "print(dic.items())#获取字典的所有键值。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56a99716",
   "metadata": {},
   "source": [
    "### 16.2 字典键值的修改、增加和删除\n",
    "\n",
    "字典键值的修改、增加、删除与前面讲解的列表、元组的相关操作类似，但是也有不同之处，下面分别讲解。\n",
    "\n",
    "#### 16.2.1 字典键值的增加\n",
    "\n",
    "向字典中增加更多的键值，一般使用update函数，也可以用修改键值的方式操作。\n",
    "\n",
    "看看下面的小例子，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "29fbeeed",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:30:22.599160Z",
     "start_time": "2024-06-22T08:30:22.590184Z"
    }
   },
   "source": [
    "dic = {} # 空字典\n",
    "dic.update(李四=88);print(dic) # 使用update函数向dic字典添加键值 方法1。\n",
    "dic.update({'麻子':96});print(dic) # 使用update函数dic字典添加键值 方法2。\n",
    "dic['张三']=99;print(dic) # 修改方法向dic字典添加键值。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'李四': 88}\n",
      "{'李四': 88, '麻子': 96}\n",
      "{'李四': 88, '麻子': 96, '张三': 99}\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "id": "951ad7ae",
   "metadata": {},
   "source": [
    "#### 16.2.2 字典键值的删除\n",
    "\n",
    "删除字典键值可以使用pop函数、clear函数和del语句。下面是删除字典键值的小例子，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "5adf3c66",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:32:06.027211Z",
     "start_time": "2024-06-22T08:32:06.024159Z"
    }
   },
   "source": [
    "dic={'张三':84,'李四':88,'王二':79,'麻子':99} # 准备的字典。\n",
    "print(dic.pop('张三'));print(dic) # 删除指定键值。\n",
    "del dic['李四'];print(dic) # 删除指定键值。\n",
    "dic.clear();print(dic) # 清空字典。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84\n",
      "{'李四': 88, '王二': 79, '麻子': 99}\n",
      "{'王二': 79, '麻子': 99}\n",
      "{}\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "id": "f639ced6",
   "metadata": {},
   "source": [
    "#### 16.2.3 字典键值的修改\n",
    "\n",
    "修改字典中键对应的值，表示方法为：字典名[键]=修改的值。如果是修改键呢？\n",
    "\n",
    "实际上没有直接修改键的方法，可以使用间接的方式，表示方法为：字典名[新键] = 字典名.pop(旧键)。案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "0889de40",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:32:41.556369Z",
     "start_time": "2024-06-22T08:32:41.551443Z"
    }
   },
   "source": [
    "dic={'张三':20,'李四':18,'麻子':35}#准备的字典。\n",
    "dic['张三']=100;print(dic)#修改键值中的值。\n",
    "dic['王五']=dic.pop('李四');print(dic)#修改键值中的键。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'张三': 100, '李四': 18, '麻子': 35}\n",
      "{'张三': 100, '麻子': 35, '王五': 18}\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "id": "eba2bc38",
   "metadata": {},
   "source": [
    "### 16.3 字典的转换\n",
    "\n",
    "字典的转换操作是指将列表、元组等可迭代对象的元素转换为对应的字典，本节使用dict类和 dict.fromkeys函数完成转换。\n",
    "\n",
    "#### 16.3.1 类对象转换dict\n",
    "\n",
    "在上节中使用dict类创建了字对象，实际上，dict类有三种不同的写法都可以生成字典对象。本节将详细介绍dict类的相关语法。\n",
    "\n",
    "类语法：\n",
    "dict(**kwargs)\n",
    "dict(mapping,**kwargs)\n",
    "cdict(iterable,**kwargs)\n",
    "\n",
    "参数说明：\n",
    "\n",
    "**kwargs:关键字，采用“键=值”的方式创建字典。\n",
    "mapping:元素的容器，采用映射函数的方式创建字典。\n",
    "iterable:可迭代对象，采用可迭代对象的方式创建字典。\n",
    "\n",
    "下面演示使用dict类创建字典的三种方式，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbe811b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "dic1=dict(a=1,b=2);print(dic1)\n",
    "dic2=dict(zip(('a','b'),(1,2)));print(dic2)\n",
    "dic3=dict([('a',1),('b',2)]);print(dic3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fc4d50c",
   "metadata": {},
   "source": [
    "* 第1行代码 dicl=dict(a=1,b=2)，使用＊＊kwargs关键字的方式，也就是“键=值”的方式创建字典，可以用这种方式添加任意多个键值对。执行 print(dic1)后，返回结果为｛'a:1,'b:2｝。\n",
    "* 第2行代码 dic2=dict(zip(('a','b'),(1,2)))，使用元素的容器方式，一般使用zip函数，比如 zip(('a',b'),(1,2))，表示将键放在一组，将值放在另一组。执行 print(dic2)后，返回结果为｛'a'：1,'b:2｝。\n",
    "* 第3行代码 dic3=dict([('a',1),('b',2)])，使用可迭代对象的方式，比如[('a',1),('b',2)]，将键与值放在同一个容器中，组织形式不定。元组、列表、字符串等可迭代对象只要结构正确均可以转换为字典。执行 print(dic3)后，返回结果为｛'a'：1,'b:2｝。\n",
    "\n",
    "#### 16.3.2 dict.fromkeys 转换法\n",
    "\n",
    "在Python中，除使用dict类创建字典外，还可以用 dict.fromkeys函数创建一个新字典，下面介绍该函数的语法。\n",
    "\n",
    "函数语法：\n",
    "\n",
    "dict.fromkeys(seq[,value])\n",
    "\n",
    "参数说明：\n",
    "seq:必选参数，字典的键，可以是元组、列表、字符串等可迭代对象。\n",
    "value:可选参数，设置键对应的值，默认值为None。\n",
    "\n",
    "下面是几个小例子，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "5a22fd18",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:36:21.604932Z",
     "start_time": "2024-06-22T08:36:21.599431Z"
    }
   },
   "source": [
    "dic1=dict.fromkeys(('a','b'),1);print(dic1)\n",
    "dic2=dict.fromkeys(['a','b'],1);print(dic2)\n",
    "dic3=dict.fromkeys('abc',1);print(dic3)\n",
    "dic4=dict.fromkeys(['a','a','b']);print(dic4)\n",
    "dic5=dict.fromkeys([('a',1),('a',1)]);print(dic5)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 1}\n",
      "{'a': 1, 'b': 1}\n",
      "{'a': 1, 'b': 1, 'c': 1}\n",
      "{'a': None, 'b': None}\n",
      "{('a', 1): None}\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "id": "e5f3967a",
   "metadata": {},
   "source": [
    "* 第1行代码 dicl=dict.fromkeys(('a','b'),1)，将元组('a','b')作为键，键的值统一为1。运行 print(dic1)后，返回字典｛'a:1,'b:1｝。\n",
    "* 第2行代码 dic2=dict.fromkeys(['a','b'],1)，将列表['a','b]作为键，键的值统一为1。运行print(dic2)后，返回字典｛'a:1,'b'：1｝。\n",
    "* 第3行代码 dict.fromkeys('abc',1)，将字符串'abc'的每个字符作为键，键的值统一为1。运行 print(dic3)后，返回字典｛'a'： 1,'b'：1,'c:1｝。\n",
    "* 第4行代码 dic4=dict.fromkeys(['a','a','b'])，将列表['a','a','b']作为键，列表中有相同的元素，只保留一个。所以运行 print(dic4)后，返回字典｛'a'： None, 'b'： None｝。\n",
    "* 第5行代码 dic5=dict.fromkeys([('a',1),('a',1)])，将列表[('a',1),('a',1)]作为键，字典的键是元组，而且两个元组相同，这时会去掉重复的，只保留一个。运行 print(dic5)后，返回字典｛('a',1)：None｝。\n",
    "\n",
    "再次提醒读者，字典的键可以为数字、字符串、元组等不可变类型的数据，不能为列表、集合等可变类型的数据。\n",
    "\n",
    "## 17. Python 无序对象 -- 集合处理技术\n",
    "\n",
    "在Python中，集合是一个无序的不重复元素序列，元素被放在 **{}** 中，是可迭代的，不支持任何索引或切片操作。与列表相比，集合的主要优点是具有高度优化的方法，可以检查集合中是否包含特定元素，也可以进行并集、交集、差集、比较等操作。\n",
    "\n",
    "### 17.1 集合的创建与删除\n",
    "\n",
    "集合与列表、元组、字典一样，可以创建和删除。集合创建与删除的案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "51638d24",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:37:22.685882Z",
     "start_time": "2024-06-22T08:37:22.680983Z"
    }
   },
   "source": [
    "set1 = set();print(set1) # 创建空集合。\n",
    "set2 = {1,2,3};print(set2) # 创建有元素的集合。\n",
    "set3 = frozenset(set2);print(set3) # 转换为不可变集合。\n",
    "del set1 # 删除指定集合。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n",
      "{1, 2, 3}\n",
      "frozenset({1, 2, 3})\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "markdown",
   "id": "66524be0",
   "metadata": {},
   "source": [
    "* 第 1 行代码 set1 = set()，使用set类创建空集合，运行 print(set1)后，返回结果为 set()。创建空集合必须使用set()，而不能用 {}，因为{}是创建空字典。\n",
    "\n",
    "* 第 2 行代码 set2 = {1，2，3}，将元素放在花括号中，运行print(set2)后，返回结果为 {1，2，3}，此种集合是可变集合，也就是可变对象，不能作为字典的键。\n",
    "\n",
    "* 第 3 行代码 set3 = frozenset(set2)，在set2集合外层套上 frozenset类，运行 print(set3)后，返回结果为frozenset({1，2，3})。frozenset函数的参数不一定是可变集合，可以是任何可迭代对象。不可变集合类似字符串、元组，可以作为字典的键，缺点是一旦创建便不能更改，除内容不能更改外，其他功能及操作与可变集合set一样。\n",
    "\n",
    "* 第 4 行代码 del set1，删除指定的集合，删除后集合将不存在。\n",
    "\n",
    "### 17.2 集合元素的添加与删除\n",
    "\n",
    "我们知道了集合可以分为可变集合和不可变集合，本节讲解集合元素的添加与删除，当然是针对可变集合而言的。\n",
    "\n",
    "#### 17.2.1 集合元素的添加\n",
    "\n",
    "向集合中添加单个元素或多个元素，可以使用add函数或 update函数，来看看它们的区别是什么。案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "8310ec81",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:38:15.769218Z",
     "start_time": "2024-06-22T08:38:15.760704Z"
    }
   },
   "source": [
    "set1 = {1,2,3} # 原集合\n",
    "set1.add(4);print(set1) # 向集合添加单个元素。\n",
    "set1.update({5,6,7});print(set1) # 向集合添加多个元素。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "id": "45d061c1",
   "metadata": {},
   "source": [
    "* 第 2 行代码 set1.add(4),表示向set1集合中添加元素4,运行 print(set1)后,返回的结果为{1,2,3,4}。\n",
    "\n",
    "* 第 3 行代码 set1.update({5,6,7}),表示向set1集合中添加另一个集合{5,6,7},运行print(set1)后,返回的结果为{1,2,3,4,5,6,7}。实际上,update函数的参数可以是任何可迭代对象,比如字符串、列表、元组等。\n",
    "\n",
    "> 注意，如果集合中的所有元素都是数字，则这些数字会按照从小到大的顺序排列，否则排列是混乱的。为了让读者看到演示效果，这里将数字作为集合的元素。\n",
    "\n",
    "#### 17.2.2 集合元素的删除\n",
    "\n",
    "删除集合中的元素可以用remove、discard、pop、clear函数，根据不同的要求用不同的函数。案例代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "b7b92eb3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:40:01.566041Z",
     "start_time": "2024-06-22T08:40:01.562150Z"
    }
   },
   "source": [
    "set1 = {'a','b','c','d'} # 原集合\n",
    "\n",
    "\n",
    "set1.remove('a');print(set1) # 删除集合中元素'a'。\n",
    "set1.discard('b');print(set1) # 删除集合中元素'b'。\n",
    "\n",
    "\n",
    "set1.pop();print(set1) # 随机删除集合中的一个元素。\n",
    "\n",
    "set1.clear();print(set1) # 清空集合中所有元素"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b', 'c', 'd'}\n",
      "{'c', 'd'}\n",
      "{'d'}\n",
      "set()\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "markdown",
   "id": "3a931cca",
   "metadata": {},
   "source": [
    "* 第 2 行代码 set1.remove('a')，表示删除集合中的指定元素'a'，如果元素不存在，则返回错误。运行print(set1)后，返回的结果为{'c'，'d'，'b'}。\n",
    "\n",
    "* 第 3 行代码 set1.discard('b')，表示删除集合中的指定元素b'，如果元素不存在，则忽略，不会返回错误。运行print(set1)后，返回的结果为{'d'，'c}。\n",
    "\n",
    "* 第 4 行代码 set1.pop()，表示随机删除集合中的一个元素。运行 print(set1)后，如果删除的是'd'，则返回{'c}；如果删除的是'c'，则返回{'d'}。\n",
    "\n",
    "* 第 5 行代码 set1.clear()，表示清空集合中的所有元素。运行print(setl)后，返回的结果为set()。\n",
    "\n",
    "> 注意，由于集合中的元素不是数字，所以每次运行第2、3、4行代码返回的结果的顺序会有所不同。\n",
    "\n",
    "### 17.3 集合之间的大小比较\n",
    "\n",
    "集合之间的大小比较就是判断某个集合是否完全包含另一个集合，可以使用大于（>）、小于（<）、大于或等于（>=）、小于或等于（<=）、等于（==）、不等于（!=）这些比较运算符来做判断。\n",
    "\n",
    "#### 17.3.1 集合的比较运算\n",
    "\n",
    "下面用几个小例子讲解集合之间是如何进行比较的，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbd8d4db",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 in {1,2,3})# 2 是否包含在集合中。\n",
    "print({1,2,3}=={3,2,1})# 两个集合是否相同。\n",
    "print({2,3}>{1,2,3})# 集合大于比较。\n",
    "print({2,3}<{1,2,3})# 集合小于比较。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f28b5d49",
   "metadata": {},
   "source": [
    "* 第1行代码print(2 in{1,2,3}),判断集合{1,2,3}中是否包含2,返回的结果为True。\n",
    "\n",
    "* 第2行代码 print({1,2,3}＝{3,2,1}),判断{1,2,3}与{3,2,1}是否相等,集合是无序的,只要两个集合中的数据相同就相等,返回的结果是True。\n",
    "\n",
    "* 第3行代码print({2,3}＞{1,2,3}),其本质是判断{1,2,3}中的元素是否被{2,3}包含,返回的结果为False。\n",
    "\n",
    "* 第4行代码print({2,3}＜{1,2,3}),其本质是判断{2,3}中的元素是否被{1,2,3}包含,返回的结果为True。\n",
    "\n",
    "#### 17.3.2 集合比较运算应用案例：判断指定的多个等级是否存在\n",
    "\n",
    "在“评级表”工作表中，1～4季度每个人有不同的等级，判断包含“优”和“良”两个等级的有哪些人，将结果写在F列，如图所示。\n",
    "\n",
    "![8jaB2B](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/8jaB2B.png)\n",
    "\n",
    "本案例的编程思路是将每个人4个季度的等级转换成集合，然后与集合｛＇优，良｝进行比较判断，如果包含｛＇优，良｝，则条件成立。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2649b6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import xlrd #导入xls文件读取库。\n",
    "from xlutils.copy import copy #导入函数\n",
    "wb = xlrd.open_workbook('./25-Scores-1.xls');ws=wb.sheet_by_name('评级表') #读取工作簿和工作表。\n",
    "nwb = copy(wb);nws=nwb.get_sheet('评级表') #复制工作簿及读取副本工作簿下的工作表。\n",
    "row_num = 0 #初始化row_num变量为0。\n",
    "for row in tuple(ws.get_rows())[1:]: #循环读取每行记录。\n",
    "   row_num += 1 #对row_num变量累加1。\n",
    "   if {'优','良'}<={v.value for v in row[1:-1]}: #判断每行的等级是否包含'优'和'良'。\n",
    "       nws.write(row_num,5,'√') #如果包含则写入'√'。\n",
    "   else: #否则\n",
    "       nws.write(row_num,5,'×') #如果不包含则写入'×'。\n",
    "nwb.save('./25-Scores-2.xls') #保存副本工作簿。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e50a9c",
   "metadata": {},
   "source": [
    "* 第1～5行代码为数据的读取和写入做准备。\n",
    "\n",
    "* 第6行代码 for row in tuple(ws.get_rows()[1:]:，将每行数据循环赋值给row变量。 \n",
    "\n",
    "* 第8行代码 if {＇优＇，＇良＇}＜＝{v.value for v in row[l:－1]}：， 其中，{v.value for v in row[1:－1]}将 row 元组中的元素使用集合推导式转换为集合，集合推导式也具有去重功能。然后判断集合是否大于或等于{＇优，＇良＇}，也就是{＇优，良＇}这个集合是否被包含或刚好与集合相等。\n",
    "\n",
    "* 第9行代码 nws.write(row_num，5，＇✓＇)，如果第8行代码的条件成立，则将 “✓” 写入F列。\n",
    "\n",
    "* 第11行代码 nws.write(row_num，5，＇x＇)，如果第8行代码的条件不成立，则将 “x” 写入F列。\n",
    "\n",
    "* 第12行代码 nwb.save(＇Chapter-8-6-1.xls＇)，保存副本工作簿。\n",
    "\n",
    "### 17.4 集合的转换\n",
    "\n",
    "将可迭代对象转换为集合，除使用集合推导式外，还可以使用set类，这种方式更直接、简单。\n",
    "\n",
    "#### 17.4.1 类对象转换set\n",
    "\n",
    "前面学习过使用set类创建空集合，实际上也可以使用set类将字符串、列表、元组等可迭代对象转换为集合。\n",
    "\n",
    "类语法：**set([iterable])**\n",
    "\n",
    "参数说明：\n",
    "\n",
    "iterable:可选参数，要转换为集合的可迭代序列。\n",
    "\n",
    "下面是使用set类进行转换的例子，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58c520c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = set('123');print(set1)#将字符串转换为集合。\n",
    "set2 = set([1,2,3]);print(set2)#将列表转换为集合。\n",
    "set3 = set((1,2,3));print(set3)#将元组转换为集合。\n",
    "set4 = set({'a':1,'b':2,'c':3});print(set4)#将字典转换为集合。\n",
    "set5 = set(range(1,4));print(set5)#将可迭代对象转换为集合。\n",
    "print(set('aadad'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2394a43f",
   "metadata": {},
   "source": [
    "* 第1行代码 set1＝set('123'),将字符串'123'转换为集合,运行print(set1)后,返回的结果为{'1','3','2'}。\n",
    "\n",
    "* 第2行代码 set2＝set(［1,2,3］),将列表［1,2,3］转换为集合,运行 print(set2)后,返回的结果为{1,2,3}。\n",
    "\n",
    "* 第3行代码 set3＝set(1,2,3)),将元组(1,2,3)转换为集合,运行 print(set3)后,返回的结果为{1,2,3}。\n",
    "\n",
    "* 第4行代码 set4＝set({'a'：1,b'：2,'c'：3}),将字典{'a'：1,'b:2,c:3}的键转换为集合,运行 print(set4)后,返回的结果为{'b','c','a'}。\n",
    "\n",
    "* 第5行代码set5＝set(range(1,4)),将可迭代对象range(1,4)换为集合,运行print(set5)后,返回的结果为{1,2,3}。\n",
    "\n",
    "\n",
    "### 17.5 集合的运算\n",
    "\n",
    "![5Codzl](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/5Codzl.png)\n",
    "\n",
    "在Python中，集合之间可以做关系运算，例如做并集、交集、差集及对称差集运算。本节将逐个讲解集合的运算，每种集合运算都有配图，图中用斜线填充的部分就是集合运算后得到的结果。\n",
    "\n",
    "#### 17.5.1 并集运算\n",
    "\n",
    "并集运算指两个或更多集合合并，结果中包含了所有集合的元素，重复的元素只会出现一次，可以参考图所示的效果。下面以set1和set2两个集合为例讲解并集运算的原理，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "5e6ae6c3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:45:13.394420Z",
     "start_time": "2024-06-22T08:45:13.387559Z"
    }
   },
   "source": [
    "set1 = {1,2,3,4,5,6} # 集合1。\n",
    "set2 = {4,5,6,7,8,9} # 集合2。\n",
    "print(set1.union(set2)) # 集合1与集合2做并集。\n",
    "print(set2.union(set1)) # 集合2与集合1做并集。\n",
    "print(set1|set2) # 集合1与集合2做并集。\n",
    "print(set2|set1) # 集合2与集合1做并集。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "markdown",
   "id": "cbd68f95",
   "metadata": {},
   "source": [
    "* 第3行和第4行代码将 set1 与 set2 两个集合进行合并,使用union函数完成,无论写法是 set1.union(set2),还是 set2.union(set1),结果都相同,返回的结果都是{1,2,3,4,5,6,7,8,9}。\n",
    "\n",
    "* 第5行和第6行代码使用 \"|\" 符号将 set1 和 set2 两个集合进行合并,set1|set2 与 set2|set1 两种写法的运算结果相同,都是{1,2,3,4,5,6,7,8,9}。\n",
    "\n",
    "![W88Dwv](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/W88Dwv.png)\n",
    "\n",
    "#### 17.5.2 交集运算\n",
    "\n",
    "交集运算求两个或更多集合中都包含的元素。下面以 set1 和 set2 两个集合为例讲解交集运算的原理，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "309c8250",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:47:16.476813Z",
     "start_time": "2024-06-22T08:47:16.470677Z"
    }
   },
   "source": [
    "set1 = {1,2,3,4,5,6} # 集合1。\n",
    "set2 = {4,5,6,7,8,9} # 集合2。\n",
    "set3 = set1.intersection(set2);print(set3)# 集合1与集合2交集，结果可以存储在新集合3。\n",
    "set3 = set2.intersection(set1);print(set3)# 集合2与集合1交集，结果可以存储在新集合3。\n",
    "set3 = set1&set2;print(set3)# 集合1与集合2交集，结果可以存储在新集合3。\n",
    "set3 = set2&set1;print(set3)# 集合2与集合1交集，结果可以存储在新集合3。\n",
    "\n",
    "\n",
    "\n",
    "set1.intersection_update(set2);print(set1)# 集合1与集合2交集，交集结果存储在集合1。\n",
    "set2.intersection_update(set1);print(set2)# 集合2与集合1交集，交集结果存储在集合2。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4, 5, 6}\n",
      "{4, 5, 6}\n",
      "{4, 5, 6}\n",
      "{4, 5, 6}\n",
      "{4, 5, 6}\n",
      "{4, 5, 6}\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "markdown",
   "id": "df537284",
   "metadata": {},
   "source": [
    "* 第3～6行代码表示 set1 和 set2 两个集合做交集运算，结果生成新的集合，如图所示。第3行和第4行代码使用intersection函数，而第5行和第6行代码使用＆符号。\n",
    "\n",
    "* 第3行代码 set1.intersection(set2)与第5行代码 set1＆set2 两种写法的结果是等价的。运行 print(set3)后，返回的结果是 {4，5，6}。\n",
    "\n",
    "* 第4行代码 set2.intersection(set1)与第6行代码 set2＆set1 两种写法的结果是等价的。运行 print(set3)后，返回的结果是 {4，5，6}。\n",
    "\n",
    "![eII0Cp](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/eII0Cp.png)\n",
    "\n",
    "* 第7行和第8行代码虽然也是 set1 和 set2 两个集合做交集运算，但返回结果的存储方式有所不同。\n",
    "\n",
    "* 第7行代码 set1.intersection_update(set2)，以 set1 为存储集合与 set2 集合做交集运算，也就是交集结果存储在 set1 中，如图(a)所示。运行 print(set1)后，返回的结果为 {4，5，6}。\n",
    "\n",
    "* 第8行代码 set2.intersection_update(set1)，以 set2 为存储集合与 set1 集合做交集运算，也就是交集结果存储在 set2 中，如图(b)所示。此行代码在运行时，set2 集合中的 {4，5，6，7，8，9} 与 set1 集合中的 {4，5，6}做交集运算，为什么set1集合变成了 {4，5，6}？原因是第7行代码在运行时，set1 中存储了交集的结果。运行 print(set2)后，返回的结果虽然也是 {4，5，6}，但要明白其中的变化。\n",
    "\n",
    "![UQrDZj](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/UQrDZj.png)\n",
    "\n",
    "#### 17.5.3差集运算\n",
    "\n",
    "差集运算就是两个集合相减，用一个集合中的元素减去另一个集合中的元素。下面以 set1 和 set2 两个集合为例讲解差集运算的原理，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "c85f0dce",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:48:33.704430Z",
     "start_time": "2024-06-22T08:48:33.699672Z"
    }
   },
   "source": [
    "set1 = {1,2,3,4,5,6} # 集合1。\n",
    "set2 = {4,5,6,7,8,9} # 集合2。\n",
    "set3 = set1.difference(set2);print(set3) # 集合1减去集合2，结果可以存储在新集合3。\n",
    "set3 = set2.difference(set1);print(set3) # 集合2减去集合1，结果可以存储在新集合3。\n",
    "set3 = set1-set2;print(set3) # 集合1减去集合2，结果可以存储在新集合3。\n",
    "set3 = set2-set1;print(set3) # 集合2减去集合1，结果可以存储在新集合3。\n",
    "\n",
    "\n",
    "\n",
    "set1.difference_update(set2);print(set1) # 集合1减去集合2，差集结果存储在集合1中。\n",
    "set2.difference_update(set1);print(set2) # 集合2减去集合1，差集结果存储在集合2中。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "{8, 9, 7}\n",
      "{1, 2, 3}\n",
      "{8, 9, 7}\n",
      "{1, 2, 3}\n",
      "{4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "markdown",
   "id": "36ff4acb",
   "metadata": {},
   "source": [
    "* 第3～6行代码是 set1 和set2两个集合做差集运算，结果生成新的集合。第3行和第4行代码使用difference函数，而第5行和第6行代码使用减号(－)。\n",
    "\n",
    "* 第3行代码 set1.difference(set2))与第5行代码setl-set2两种写法的结果是等价的，如图(a)所示。运行 print(set3)后，返回的结果是{1，2，3}。\n",
    "\n",
    "* 第4行代码set2.difference(set1)与第6行代码set2-setl两种写法的结果是等价的，如图(b)所示。运行 print(set3)后，返回的结果是{1，2，3}。\n",
    "\n",
    "![mhaMwn](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/mhaMwn.png)\n",
    "\n",
    "* 第7行代码 set1.difference_update(set2)，以set1为存储集合与set2 集合做差集运算，也就是差集结果存储在set1中，如图(a)所示。运行 print(set1)后，返回的结果为 {1，2，3}。\n",
    "\n",
    "* 第8行代码 set2.difference_update(set1)，以set2为存储集合与set1集合做差集运算，也就是差集结果存储在set2中，如图(b)所示。此行代码在运行时，set2集合中的 {4，5，6，7，8，9}与set1集合中的 {1，2，3}做差集运算，为什么set1集合变成了 {1，2，3}？原因是第7行代码在运行时，set1中存储了差集的结果。运行 print(set2)后，返回的结 果是 {4，5，6，7，8，9}。\n",
    "\n",
    "![sIjErK](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/sIjErK.png)\n",
    "\n",
    "#### 17.5.4对称差集运算\n",
    "\n",
    "对称差集运算返回两个集合中不重复的元素集合，即移除两个集合中都存在的元素。下面以 set1 和 set2 两个集合为例讲解对称差集运算的原理，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "id": "0eec6c3e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-22T08:50:39.297484Z",
     "start_time": "2024-06-22T08:50:39.288087Z"
    }
   },
   "source": [
    "set1 = {1,2,3,4,5,6} # 集合1。\n",
    "set2 = {4,5,6,7,8,9} # 集合2。\n",
    "\n",
    "set3 = set1.symmetric_difference(set2);print(set3)# 去掉集合1与集合2相同元素，结果存储在新集合3。\n",
    "set3 = set2.symmetric_difference(set1);print(set3)# 去掉集合2与集合1相同元素，结果存储在新集合3。\n",
    "\n",
    "set3 = set1^set2;print(set3)# 去掉集合1与集合2相同元素，结果存储在新集合3。\n",
    "set3 = set2^set1;print(set3)# 去掉集合2与集合1相同元素，结果存储在新集合3。\n",
    "\n",
    "\n",
    "set1.symmetric_difference_update(set2);print(set1)# 去掉集合1与集合2相同元素，结果可以存储在集合1。\n",
    "set2.symmetric_difference_update(set1);print(set2)# 去掉集合2与集合1相同元素，结果可以存储在集合2。"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 7, 8, 9}\n",
      "{1, 2, 3, 7, 8, 9}\n",
      "{1, 2, 3, 7, 8, 9}\n",
      "{1, 2, 3, 7, 8, 9}\n",
      "{1, 2, 3, 7, 8, 9}\n",
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "markdown",
   "id": "c8d40545",
   "metadata": {},
   "source": [
    "第 3～6 行代码是 set1 和 set2 两个集合做对称差集运算，结果生成新的集合。第3行和第4行代码使用 symmetric_difference函数，第5行和第6行代码使用＾符号。对称差集运算示意图如图所示。\n",
    "\n",
    "第3行代码 set1.symmetric_difference(set2) 与第5行代码 set1^set2 两种写法的结果是等价的。运行 print(set3) 后，返回的结果是｛1，2，3，7，8，9｝。\n",
    "\n",
    "第4行代码 set2.symmetric_difference(set1) 与第6行代码 set2＾set1 两种写法的结果是等价的。运行 print(set3) 后，返回的结果是｛1，2，3，7，8，9｝。\n",
    "\n",
    "![pmMcve](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/pmMcve.png)\n",
    "\n",
    "第7行代码 set1.symmetric_difference_update(set2)，以set1为存储集合与set2集合做对称差集运算，也就是对称差集结果存储在set1中，如图(a)所示。运行print(set1)后，返回的结果为｛1，2，3，7，8，9｝。\n",
    "\n",
    "第8行代码 set2.symmetric_difference_update(set1)，以set2为存储集合与setl集合做对称差集运算，也就是对称差集结果存储在set2中，如图(b)所示。此行代码在运行时，set2集合中的｛4，5，6，7，8，9｝与setl集合中的｛1，2，3，7，8，9｝做对称差集运算，为什么setl集合变成了｛1，2，3，7，8，9｝？原因是第7行代码在运行时，setl中存储了对称交集的结果。运行 print(set2)后，返回的结果是｛1，2，3，4，5，6｝。\n",
    "\n",
    "![ednAlN](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/ednAlN.png)\n",
    "\n",
    "#### 17.5.5 集合运算小结\n",
    "\n",
    "假如现在有setl和set2两个集合，可以将集合之间的运算用表格做一下总结，如表所示。\n",
    "\n",
    "![XdLl4a](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/XdLl4a.png)\n",
    "\n",
    "集合的运算可以用函数方法和符号方法来实现，它们之间的区别是什么呢？如果使用函数方法，则函数的参数不一定是集合类型，只要是可迭代对象即可。如果使用符号方法，则符号两侧必须是集合类型，否则会出错。\n",
    "在通过表格的方式总结集合之间的运算时，会发现一个问题，为什么并集中没有将运算结果存储在原集合中的方法？也就是说，为什么没有setl.union_update（set2）这种方法？虽然没有 union_update 函数来实现，但有另一种方式可以实现，方法为setl.update（set2），没错，就是利用集合的update函数来实现的。虽然 update函数是向指定集合中添加元素，但从另一个角度看，就是两个集合的并集，而且并集结果也没有生成新集合，是存储在原集合中的。\n",
    "\n",
    "\n",
    "\n",
    "总结：\n",
    "\n",
    "1. 列表是有序的，是可以重复的，是可以被遍历的，是可以改变的，copy 和 deepcopy 后的内存地址都不一样的\n",
    "2. 元组是有序的，是可以重复的，是可以被遍历的，是不可以改变的，copy 和 deepcopy 后的内存地址，要根据原来的元组中是否包含可改变对象来决定，如果包含了可变对象的，原id 和 copy 后的 id 一样，但是 deepcopy 不一样，如果原元组里包含的都是不可变，那么 3 个都一样。\n",
    "3. 字典是无序的，键是不可以重复的，值是可以重复的，是可以通过 keys 和 values 还有 items 进行遍历的，。。。\n",
    "4. 集合是无需的，是不可以重复的，是？，是可以改变的，。。。。"
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "63207519de3a36fc"
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}