Python 学习第三章 之 列表和元组
前言
我是一个做java 编程的程序猿，程序猿中的语言不止一种，于是自学了python ,在我学习过程中记录一些笔记和心得，很荣幸你能看到我的博客，如果内容中有什么错误或意见，请下方留言。
学习过程中，我很容易带入java的语法和思想去学习python，虽然他们有共同之处，但是学习过程中我应该告诉自己，“不懂编程，从头开始”。
知识来源：
书本知识来源 ：《python 基础教程 第三版》
视频知识来源： 《北京图灵学院》 python 讲师 ——永远只有十八岁的刘大拿
以及带我入门的 微信公众号 《python小课》
如果觉得我在打广告的童靴，恭喜你们答对了，《python小课》 是我 花了 9.9元买的体验课，也是我的python 路上的第一个引路者。至于为什么不在那学习？那是因为我穷，穷，穷。
但我并不想放弃，然后就在网易课程上看到了课程齐全还免费的 python 课程《免费Python全系列教程全栈工程师 - 网易云课堂》，随后也买了一本python书。
之所以要说这些 尤其是视频学习，首先作为一个编程人员，一名学习者应该做到 "吃水不忘挖井人”，关键别人又不收费。所以我这样做，觉得过分的朋友，见谅。
数据结构
数据结构是以某种方式（通过序号）组合起来的数据元素（数字，字符以及其他数据结构）集合。在python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引。其中第一个元素的索引为0，第二个为1以此类推。
在java（其他语言没了解过，不敢妄下定义）语言中，集合的下标是从0开始的，但是在python中，下标索引可以为负数（后续做介绍），这也是我学习python过程中比较意外的地方之一。
Python中内置了多种序列，这里介绍其中两种 列表和元组。列表和元组主要不同之处在于，列表是可以修改的，元组则不可以。元组主要用于安全考虑情况下，禁止随意修改，这与python的内部工作原理相关。
列表和元组特点
共同之处：
- 都是序列
- 都可以存储任何数据类型
- 可以通过索引访问
不同之处：
- 列表可以对某个元素进行任意操作，而元组只能进行查看（元组的合并，作为保留，下面介绍）
- 列表是动态数组，它们不可变且可以重设长度（改变其内部元素的个数）
- 元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变
- 声明的方式不同（下面介绍）
- 元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存
列表
语法：变量名 =[ ]
案例：
list =['元素1','元素2','元素3','元素N'] print(list)
#结果
['元素1', '元素2', '元素3', '元素N']
在python中声明一个 列表 无需指定具体类型和长度，表示它可以存任何值。类似于 Java中 的 List<Object>
studentList =[10001,'张三','男',18,95.6] print('学号\t姓名\t性别 年龄 得分') print(studentList)
#运行结果
学号 姓名 性别 年龄 得分
[10001, '张三', '男', 18, 95.6]
是否怀疑过 是不是列表声明错了？我们就拿上面案例就验证一下该 类型是否为 列表
需要使用 python 内置函数 type（object）,运行结果为 <class 'list'> ，表示声明确实是一个列表。
studentList =[10001,'张三','男',18,95.6] print(type(studentList)) #运行结果 <class 'list'>
取值：%d，%s 只是用于格式化字符串，重点是通过下标获取列表中的元素。
这里有一篇关于 Python格式化输出%s和%d 的文章
studentList =[10001,'张三','男',18,95.6] print("学号：%d"%(studentList[0])) print("姓名：%s"%(studentList[1])) print("性别：%s"%(studentList[2])) print("年龄：%d"%(studentList[3])) print("得分：%d"%(studentList[4])) #运行结果 学号：10001 姓名：张三 性别：男 年龄：18 得分：95
元组
语法 ：变量名=()
案例：
tuple=() print(type(tuple)) #运行结果 <class 'tuple'>
tuple=(10001,'张三','男',18,95.6) print('学号\t姓名\t性别 年龄 得分') print(tuple) #运行结果 学号 姓名 性别 年龄 得分 (10001, '张三', '男', 18, 95.6)
也许发现 列表使用 [ ] 括起来的， 元组是用 ( ) 括起来的
索引取值：元组取值方式和 列表是一样的。
tuple=(10001,'张三','男',18,95.6) print("学号：%d"%(tuple[0])) print("姓名：%s"%(tuple[1])) print("性别：%s"%(tuple[2])) print("年龄：%d"%(tuple[3])) print("得分：%d"%(tuple[4])) #运行结果 学号：10001 姓名：张三 性别：男 年龄：18 得分：95
前调说明：即便 元组中只有一个元素，都必须以 逗号 结尾 ，为了消除歧义
不加 逗号的后果
tup1 = (50); print(type(tup1)) print(tup1) #运行结果 <class 'int'> 50
正常结果
tup1 = (50,); print(type(tup1)) print(tup1) #运行结果 <class 'tuple'> (50,)
切片
语法：list [ 开始索引 : 结束索引 :步长]
不知道这也是python 的特色？接下的案例 列表和元组都支持的。
# 定义一列数据 接下的案例拿他
numbers =[0,1,2,3,4,5,6,7,8,9]
值得注意的是，切片是算头不算尾
案例一：获取 1-5的数据
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[1:6]) #运行结果 [1, 2, 3, 4, 5]
案例二：获取5之后的数据
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[5:]) #运行结果 [5, 6, 7, 8, 9]
案例三：获取5前面的数据
开始说过分片是算头不算尾的，若要包含5 那么就得将 结束下标改为6
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[:5]) #运行结果 [0, 1, 2, 3, 4]
案例四：打印所有偶数
这样写肯定是不对的，之所以都是对的，那是列表中是有序的（0-9），这个案例只想说明分片支持 “跳跃”，可以进行隔一个或多下标输出。
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[0::2])
#运行结果
[0, 2, 4, 6, 8]
那么为啥 要将 步长 设置成 2？那是因为 python默认就是跳一个。
不信？那么设置为1 看看。
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[0::1]) #运行结果 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
案例五：倒着输出
默认情况下 是按照 从左到右的顺序打印，但是当步长设置为 负数 时，那么可以改变打印顺序（从右到左）
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[::-1])
#运行结果
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
案例六：倒着打印 6，5，4
因为 打印顺序已经改为 从右到左 ，所以开始下标 应该为 6，算头不算尾 ，结束下标 应该设置为3
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[6:3:-1]) #运行结果 [6, 5, 4]
案例七：正着打印 4，5，6 方式一
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[4:7]) #运行结果 [4, 5, 6]
案例八：正着打印 4，5，6 方式二
是不是发现居然支持负数？
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[-6:-3]) #运行结果 [4, 5, 6]
案例九：采用负数下标 倒着打印 6，5，4
numbers =[0,1,2,3,4,5,6,7,8,9] print(numbers[-4:-7:-1]) #运行结果 [6, 5, 4]
细说分片
分片不仅可以用于集合也可以用于 字符串操作
案例：将下面这句话倒着输出
conten ="人生苦短，非得学python" print(conten[::-1]) #运行结果 nohtyp学得非，短苦生人
分片中，步长 不能指定为 0，否则无法移动，但是可以为负数。
分片默认时结果时 从左到右，当时当 步长 设置为0时 将 从右到左。
序列相加：可以将两个序列集合进行相加，获取两个集合的总和
列表案例
list1 = [1,2,3,4] list2 = [5,6,7,8] list3 =list1+list2 print(list3) #运行结果 [1, 2, 3, 4, 5, 6, 7, 8]
元组案例
tuple1 = [1,2,3,4] tuple2 = [5,6,7,8] tuple3 =tuple1+tuple2 print(tuple3) #运行结果 (1, 2, 3, 4, 5, 6, 7, 8)
疑？元组不是不能改变吗？这是啥子情况？
那我来验证一下，看案例
# 列表 list1 =[1,2,3,4] list2 =[5,6,7,8] print('列表 相加前 id: %d'%(id(list1))) list1 +=list2 print('列表 相加后 id: %d'%(id(list1))) # 元组 tuple1 =(1,2,3,4) tuple2 =(5,6,7,8) # 相加前 打印 元组 id print('元组 相加前 id: %d'%(id(tuple1))) tuple1 +=tuple2 # 相加后 打印 元组 id print('元组 相加后 id: %d'%(id(tuple1))) # 最终结果 列表 相加前 id: 1643848426056 列表 相加后 id: 1643848426056 元组 相加前 id: 1643850335000 元组 相加后 id: 1643850487624
这里使用到了 id() python 内置函数，是当前对象的唯一标识（就相当于大家的身份证编号）。元组的添加 其实是创建一个新的元组，重新保存这两个元组的数据。
至于怎么验证，我除了证明id 不是原来的id 还真的没办法验证，这可能涉及到了python 底层，作为一个python小白 我也很想知道（大神求支援）
序列相加 ：这里的相乘 是将 某个序列 以倍数的方式相乘，并非两个序列相乘（会抛异常），并且倍数必须为整数。
列表案例
list =[1,2,3,4] print(list*3) #运行结果 [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
元组案例
tuple =(1,2,3,4) print(tuple*3) #运行结果 (1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)
None，空列表和初始化
空列表是使用不包含任何内容的两个方括号（[ ]）表示。如果要创建个一个可包含10个元素的列表，但没有任何有用的内容，可以使用 [0]*10
list=[0]*10 print(list) #运行结果 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
然后在很多情况下，你可能想使用表示“什么都没有”的值，那么可以用None(类似java 中的 null )
list=[None]*10 print(list) #运行结果 [None, None, None, None, None, None, None, None, None, None]
Python 内置函数 对 列表（元组）操作
len() 获取 长度
list =[854,42,69,712,10,5,48] print("list 长度%d"%(len(list))) #运行结果 list 长度7
max()获取最大值
list =[854,42,69,712,10,5,48] print("list 最大数为：%d"%(max(list))) #运行结果 list 最大数为：854
min()获取最小值
list =[854,42,69,712,10,5,48] print("list 最小数为：%d"%(min(list))) #运行结果 list 最小数为：5
del 删除某个元素
list = ['2','3','4'] del list[1] print(list) #运行结果 ['2', '4']
del 删除整个列表
list = ['2','3','4'] del list print(list) #运行结果 <class 'list'>
del 删除元组某个数据，测试是否可以？抛出了异常，一个类型异常 告诉我们 元组不支持删除
tuple = ('2','3','4') del tuple[1] print(tuple) #运行结果 Traceback (most recent call last): File "D:/develTools/PycharmProjects/project1/venv/Include/test3.py", line 3, in <module> del tuple[1] TypeError: 'tuple' object doesn't support item deletion
in 判断 元素是否在此列表中 boolean 类型 存在返回 True 否则 False
num=(1,2,3,4,5) print(3 in num) #运行结果 True
切片赋值：好像对列表不是很友好?
list =['大难','不死','必有','后福'] list[0:1]='小难' print(list) #运行结果 ['小', '难', '不死', '必有', '后福']
我原本的意思 将 ‘大难’ 改为 ‘小难’，没想到结果是将 两个字符分开存储。后来发现是我搞错了 。正常操作应该如下
list =['大难','不死','必有','后福'] list[0:1]=['小难'] print(list) #运行结果 ['小难', '不死', '必有', '后福']
如是多个下标修改，那么将 把这范围的元素全部进行覆盖
list =['大难','不死','必有','后福'] list[0:3]=['小难'] print(list) #运行结果 ['小难', '后福']
然后再看看 字符串列表操作，要先将 字符串 转为 list 集合
str='大难不死必有后福' str=list(str) str[0:2]='小难' print(str) #运行结果 ['小', '难', '不', '死', '必', '有', '后', '福']
函数 list
鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。可以使用list
content='人生苦短，我不学python' content = list(content) content[6]='要' print(content) #运行结果 ['人', '生', '苦', '短', '，', '我', '要', '学', 'p', 'y', 't', 'h', 'o', 'n']
若想把 ['人', '生', '苦', '短', '，', '我', '要', '学', 'p', 'y', 't', 'h', 'o', 'n'] 改为 人生苦短，我要学python，可以这么做。
使用 join 函数 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
语法：str.join(sequence)
content='人生苦短，我不学python' content = list(content) content[6]='要' print(''.join(content)) #运行结果 人生苦短，我要学python
list 其实是一个类 而并非函数 使用 help 帮助函数 第一句（ class list(object) ）告诉我们了
help(list) #运行结果 class list(object) ...... ...... ...... .......
基本的列表操作
这里之所以叫列表，之前提到过，元组是不允许被修改的，至为什么可以相加(开发者怎么想的，目前为止，我还不知道)，至于为什么这里不可以操作这些方法（我刚开始觉得像相加那样创建一个新的，但是我又思考了一下啊，如果这么做，完全属于神经病，性能肯定好不到哪去，迟早会被淘汰），作为现在为小白的我，以后我一定会明白元组的底层，以及他的核心思想。
使用列表时，也提供了很多方法，下面列举一下常见的
| 序号 | 方法名称 | 说明 |
| 1 | append | 用于将一个对象附加到列表的末尾 |
| 2 | clear | 就地清空列表的内容 |
| 3 | copy | 用于复制列表，前面说过，常规复制只是将另一个名称关联到列表 |
| 4 | count | 用于计算指定的元素在列表中出现的次数 |
| 5 | extend | 能够同时将多个值附加到列表的末尾 |
| 6 | index | 在列表中查找指定值第一次出现的索引 |
| 7 | insert | 用于将一个对象插入列表 |
| 8 | pop | 从列表中删除一个元素（末尾为最后一个元素），并返回这一元素 |
| 9 | remove | 用于删除第一个为指定的元素 |
| 10 | reverse | 按相反的顺序排列列表中的元素（reverse修改列表，但不返回任何值） |
| 11 | sort | 用于对列表就地排序 |
案例演示：基于一张学生列表 学号，姓名，年龄 ，班级
append:
anppend 属于就地(原列表)修改列表，这意味着他不会返回修改后的列表，而是直接修改旧列表。
stuList=["1001","张三","18"] stuList.append("三班") print(stuList) #打印结果 ['1001', '张三', '18', '三班']
由于是基于原表修改，有时候可能会引发一些问题 如案例....
这里涉及到作用域和 赋值于赋址 的问题。以后再说。
stuList=["1001","张三","18"] print("最开始结果："+str(stuList)) # 定义一个方法 def appendStuFilde(): stuList.append("三班") print("修改后的结果："+str(stuList)) return None #调用方法 appendStuFilde() appendStuFilde() print("再次打印list："+str(stuList)) #打印结果 最开始结果：['1001', '张三', '18'] 修改后的结果：['1001', '张三', '18', '三班'] 再次打印list：['1001', '张三', '18', '三班']
clear: 类似于 切片的赋值语句 stuList [ : ] =[ ] 。
stuList=["1001","张三","18"] stuList.clear() print(stuList) #打印结果 []
copy:
stuList=["1001","张三","18","三班"] stuList2=stuList.copy(); print("stuList列表的数据"+str(stuList)) stuList2[3]="四班" print("stuList2列表的数据"+str(stuList2)) #运行结果 stuList列表的数据['1001', '张三', '18', '三班'] stuList2列表的数据['1001', '张三', '18', '四班']
count:
list=[4,45,45,521,4,2,1,42,7,3,64,12,4] print("打印列表中 4 的个数："+str(list.count(4))) #打印结果 打印列表中 4 的个数：3
extend：
可以使用列表扩容另一个列表，
alist=[1,2,3,4,5] blist=[6,7,8,9,0] alist.extend(blist) print(alist) #运行结果 [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
这可能类似于拼接，但存在一个重要差别，那就是将更改后被扩列的序列。在常规拼接中，情况返回一个全新的序列
alist=[1,2,3,4,5] blist=[6,7,8,9,0] print("最开始alist 序列编号为"+str(id(alist))) print("常规拼接后的内容："+str(alist+blist)) print("常规拼接 后 alist 序列编号为"+str(id(alist+blist))) #运行结果 最开始alist 序列编号为2758662513224 常规拼接后的内容：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0] 常规拼接 后 alist 序列编号为2758692111880
alist=[1,2,3,4,5] blist=[6,7,8,9,0] print("最开始alist 序列编号为"+str(id(alist))) alist.extend(blist) print("extend拼接后的内容："+str(alist)) print("extend拼接 后 alist 序列编号为"+str(id(alist))) #运行结果 最开始alist 序列编号为1926846177864 extend拼接后的内容：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0] extend拼接 后 alist 序列编号为1926846177864
鉴于常规拼接必须使用两个列表的副本创建一个新的列表，因此如果你使用 下面的操作效率会比extend 地低。
alist=[1,2,3,4,5] blist=[6,7,8,9,0] print("alist 最开始id："+str(id(alist))) alist = alist + blist; print("alist 常规拼接后Id："+str(id(alist))) print(alist) #运行结果 alist 最开始id：2338500272712 alist 常规拼接后Id：2338529740296 [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
what ? id 不一样？那我之前推断是错的？列表常规操作 也是 要重新创建一个新的 集合? 然后我换了 一种方式 += 发现 id 又是一致的。
alist=[1,2,3,4,5] blist=[6,7,8,9,0] print("alist 最开始id："+str(id(alist))) alist += blist; print("alist 常规拼接后Id："+str(id(alist))) print(alist) #运行结果 alist 最开始id：1872840516168 alist 常规拼接后Id：1872840516168 [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
写到这里我晕了，啥子鬼哦？ 于是我用两种不同的常规方式 拼接 了 元组 。发现无论那种方式都 id 都是不一致的。 虽然变量名是原来，但是类型肯定 是 元组
********************第一种******************** alist=(1,2,3,4,5) blist=(6,7,8,9,0) print("alist 最开始id："+str(id(alist))) alist =alist + blist; print("alist 常规拼接后Id："+str(id(alist))) print(alist) #运行结果 alist 最开始id：2215354918608 alist 常规拼接后Id：2215354571592 (1, 2, 3, 4, 5, 6, 7, 8, 9, 0) ********************第二种 ******************** alist=(1,2,3,4,5) blist=(6,7,8,9,0) print("alist 最开始id："+str(id(alist))) alist +=blist; print("alist 常规拼接后Id："+str(id(alist))) print(alist) #运行结果 alist 最开始id：1927772661456 alist 常规拼接后Id：1927743871816 (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
为了弄懂这个我 特地去了解一下 += 和 + 有什么区别？ 请参考另一篇文章
index: 在列表中寻找元素第一次出现的索引
list=[41,25,45,88,22,1,22,2,2,22,74] print('22 第一次出现的索引位置为: %d'%(list.index(22))) #运行结果 22 第一次出现的索引位置为: 4
若 列表中 没有该元素时， index 会抛出异常
list=[41,25,45,88,22,1,22,2,2,22,74] print('77 第一次出现的索引位置为: %d'%(list.index(77))) #运行结果 Traceback (most recent call last): File "D:/develTools/PycharmProjects/project1/venv/Include/test3.py", line 3, in <module> print('77 第一次出现的索引位置为: %d'%(list.index(77))) ValueError: 77 is not in list
insert :指定下标插入一个元素
list =[1,2,3] list.insert(1,55) print(list) #运行结果 [1, 55, 2, 3]
除了 insert 还有另外一种实现方式 那就是分片
list =[1,2,3] list[1:1]=[66,55] print(list) #运行结果 [1, 66, 55, 2, 3]
两则有什么区别？
- 分片：可读性比 insert 差一点，
- insert：似乎只能插入一个？插入多个就是多维列表
list =[1,2,3] list.insert(1,[55,44]) print(list) #运行结果 [1, [55, 44], 2, 3]
- insert 若不要 [ ] 会产生异常
list =[1,2,3] list.insert(1,44,55) print(list) #运行结果 Traceback (most recent call last): File "D:/develTools/PycharmProjects/project1/venv/Include/test3.py", line 3, in <module> list.insert(1,44,55) TypeError: insert() takes exactly 2 arguments (3 given)
- 分片：支持的范围更宽一点，无论 是一维还是多维都可以。
list =[1,2,3] list[1:1]=[12,4,[44,22]] print(list) #运行结果 [1, 12, 4, [44, 22], 2, 3]
- 两种方式 结合实际情况来用吧。
注：学习过程中，瞎敲 敲出来的，有什么不对或意见下方留言。
pop：指定下标从列表中删除某个元素，并返回删除的元素值
list =[22,44,412] print('删除的元素为：%d'%(list.pop(1))) print('列表剩下的信息有: %s'%(str(list))) #运行结果 删除的元素为：44 列表剩下的信息有: [22, 412]
注意：pop 是唯一一个既能修改列表又返回一个非None值的列表方法
remove: 删除一个指定值的元素，若没有该元素将抛出异常
list =[22,44,412] list.remove(44) print('列表剩下的信息有: %s'%(str(list))) #运行结果 列表剩下的信息有: [22, 412]
reverse：将列表中数据进行反向输出
list =[1,2,3,4] print(id(list)) list.reverse() print(id(list)) print(list) #运行结果 2490151232072 2490151232072 [4, 3, 2, 1]
除了证明 reverse 是就地修改外，我还证明 他无论是数字 还是字符都有效（虽然别人说了，但是实践一下没有坏事）
list =["黄","河","之","水","天","上","来"]
print(id(list))
list.reverse()
print(id(list))
print(list)
#运行结果
2765313499720
2765313499720
['来', '上', '天', '水', '之', '河', '黄']
sort 就地排序
list =[88,5,44,31,54] list.sort() print(list) #运行结果 [5, 31, 44, 54, 88]
这时我在想可以 实现short 倒序吗？然后从书中了解到，sort 接手两个可选参数：key和reverse。
参数key 类似于参数cmp:可将其设置为一个用于排序的函数。然后不会直接使用这个函数来判断一个元素的大小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。
晕了.... 啥子鬼哦，说实话我也不懂，但是可以看书啊。
书上有个这样的案例根据长度进行排序 ，虽然我还是不太明白这个函数该怎么定义，但是这里我应该明白 这里 len 就是一个函数，我明白它是如何来的就行了啊。
strList =["apple","banana","pineapple","watermelon","peach"] strList.sort(key=len) print(strList) #运行结果 ['apple', 'peach', 'banana', 'pineapple', 'watermelon']
参数 reverse 就比较简单了， 是一个真值（True或Flase） 设置为True 为 降序 ，False 则为升序
num=[78,9,76,4,46,54,6] num.sort(reverse=True) print(num) #运行结果 [78, 76, 54, 46, 9, 6, 4] #--------------------------------------- num=[78,9,76,4,46,54,6] num.sort(reverse=False) print(num) #运行结果 [4, 6, 9, 46, 54, 76, 78]
若想了解 更多sort 知识， 请看官网
元组： 最后我们再聊聊元组（内容来自书本，作为小白的我，这些笔记都是我的学习笔记，所以不敢妄自菲薄，实事求是就好）
和列表一样，元组也是序列，唯一的差别在于元组是不能修改的（字符串也不能修改）。元组语法很简单，只要一些值用逗号分隔，就能自动创建一个元组。
num=1,2,3 print(num) #运行结果 (1, 2, 3)
也可以用括号（）将他们括起来（通常的做法）
num=(1,2,3) print(num) #运行结果 (1, 2, 3)
一个空括号 表示空的元组
num=() print(num) #运行结果 ()
若元组内容只有一条数据，这个就有点特殊，也需要在后面加一个逗号,(之所以这么做，那是因为用于标识他是元组，否则可能就是其他类型)
num=(1,) print(num)
tuple 和 list 一样，实际上并不是一个函数，而是一个类型。
num=() print(type(num)) #运行结果 <class 'tuple'>
元组分片之后还是元组
num=(1,2,3,4,5) print(num[1:3]) #运行结果 (2, 3)
元组的作用？
- 用于映射中的键（以及集合的成员），而列表不行（书中提出后续将讲到——第四章 映射）
- 有些内置函数和方法返回元组，这以为着必须跟它们打交道。
浙公网安备 33010602011771号