一般在创建元组时，分为创建空元组和非空元组，其创建方式如下：
从上面可以看到，我们只需要把元组的所有元素放在 小括号 () 里面，每个元素之间通过 逗号 , 间隔起来即可，当然和列表一样，元组中同样允许存放不同数据类型的元素。
元组中使用的 () 是常见的数学运算符，如果参考列表的创建，如下：
从上面可以看到，我们创建出来的压根就不是元组类型。那么我们想创建一个只包含一个元素的元组时，需要怎么创建呢？
很简单，只需要在元素后加上一个 逗号 , ，这样创建出来就是一个元组。
当我们需要访问元组中的元素，可以类似列表一样通过索引取值或切片取值。
如果访问的索引不存在，那么会报错： IndexError: tuple index out of range
在元组中，可以像列表一样使用切片，语法为： 元组[start:end:step] ，通过切片可以获取到元组中指定范围的元素，返回结果是一个新元组。在这里，需要注意切片的规则是左闭右开，也就是说包含头部 start，但不包含尾部 end ，而 step 则表示切片的步长，需要每间隔 step 个元素取一次。
在上面我们提到了元组是不可变的，这就意味着我们创建一个元组之后，不能再去改变其值了，比如下面这样就会出现报错：
假设元组中存在元素是一个可变对象，如果我们不改变元组，但改变了可变对象的值，又会得到怎么的结果呢？请看下面实例：
从上面可以看到，元组中的第 2 个元素似乎发生了变化，这岂不是和上面说的元组不可变自相矛盾了吗？
其实，我们说的元组不可变，指的是元组中各元素的指向永远保持不变。在上面操作中，元组中第 2 个元素指向的一直是 列表nums ，我们改变的其实不是元组的元素，而只是改变了 列表nums 中的元素。
元组是不可变的，因此我们就不能删除元组中的元素，但是，我们可以通过 del 语句删除整个元组。
通过关键字 in ，可检查当前元组中是否包含指定元素，返回结果为布尔值 True 或 False。
通过关键字 in ，还可以用于遍历当前元组。
↑↑↑点击上方蓝字，回复资料，10个G的惊喜
作者：陈tooyoung@阿里云Python训练营 博客地址： https://blog.csdn.net/weixin_43509371/article/details/108522941
Python 是一种通用编程语言，其在科学计算和机器学习领域具有广泛的应用。如果我们打算利用 Python 来执行机器学习，那么对 Python 有一些基本的了解就是至关重要的。本 Python 入门系列体验就是为这样的初学者精心准备的。
列表的定义
列表的创建
向列表中添加元素
删除列表中的元素
获取列表中的元素
列表的常用操作符
列表的其他方法
元组
创建和访问一个元组
更新和删除一个元组
元组相关的操作符
内置方法
解压元组
列表简单数据类型
整型
浮点型
布尔型
容器数据类型
列表
元组
字典
集合
字符串
列表的定义列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为[元素1, 元素2, ..., 元素n]。
关键点是「中括号 []」和「逗号 ,」
中括号 把所有元素绑在一起
逗号 将每个元素一一分开
列表的创建 创建一个普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7]
利用range()创建列表x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9]
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2]
利用推导式创建列表x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9]
x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2]
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
创建一个混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
# [1, 'lsgo', 3.14, [1, 2, 3]]
创建一个空列表empty = []
print(empty, type(empty)) # []
列表不像元组，列表内容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、删除 (remove,pop) 这些操作都可以用在它身上。
向列表中添加元素
list.append(obj)在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意append()和extend()的区别。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(x)) # 6
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x)) # 7
严格来说append是追加，把一个东西整体添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj)在编号index位置插入obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6
删除列表中的元素
list.remove(obj)移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del var1[, var2 ……]删除单个或多个对象。
如果知道要删除的元素在列表中的位置，可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
获取列表中的元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]print(x[0], type(x[0])) # Monday
print(x[-1], type(x[-1])) # ['Thursday', 'Friday']
print(x[-2], type(x[-2])) # Wednesday
切片的通用写法是start : stop : step
"start :"
以step为 1 (默认) 从编号start往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(x[3:]) # ['Thursday', 'Friday']
print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']
": stop"
以step为 1 (默认) 从列表头部往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
"start : stop"
以step为 1 (默认) 从编号start往编号stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
- "start : stop : step"
以具体的step从编号start往编号stop切片。注意最后把step设为 -1，相当于将列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']
print(week[1::2]) # ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
" : "
复制列表中的所有元素（浅拷贝）。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[:])
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
浅拷贝与深拷贝list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
列表的常用操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
前面三种方法（append,extend,insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
列表的其它方法
list.count(obj)统计某个元素在列表中出现的次数
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
list.index(x[, start[, end]])从列表中找出某个值第一个匹配项的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
list.reverse()反向列表中元素
x = [123, 456, 789]
x.reverse()
print(x) # [789, 456, 123]
list.sort(key=None, reverse=False)对原列表进行排序。
key-- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse-- 排序规则，reverse = True降序，reverse = False升序（默认）。
该方法没有返回值，但是会对列表的对象进行排序。
x = [123, 456, 789, 213]x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
元组
「元组」定义语法为：(元素1, 元素2, ..., 元素n)
小括号把所有元素绑在一起
逗号将每个元素一一分开
创建和访问一个元组Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
t1 = (1, 10.31, 'python')t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python')
print(t2, type(t2))
# (1, 10.31, 'python')
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)print(type(x)) #
x = 2, 3, 4, 5
print(type(x)) #
x = []
print(type(x)) #
x = ()
print(type(x)) #
x = (1,)
print(type(x)) #
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
创建二维元组。
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)
更新和删除一个元组week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
元组相关的操作符
等号操作符：==
连接操作符+
重复操作符*
成员关系操作符in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False
内置方法
元组大小和内容都不可更改，因此只有count和index两种方法。
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
count('python')是记录在元组t中该元素出现几次，显然是 1 次
index(10.31)是找到该元素在元组t的索引，显然是 1
解压元组解压（unpack）一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
解压二维元组（按照元组里的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了rest变量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2
所以这篇文章，我们先来回顾和总结Python数据结构里常用操作。Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。而扁平序列如str、bytes、bytearray、memoryview 和 array.array等不在这篇文章的讨论范围内。
在此，我们先从元组开始说起。
元组区别于列表的显著特征之一就是它不能被修改，但其另外一个作用就是 用于没有字段名的记录 [1] 。因为后者经常被忽略，我们先来看看元组作为记录的作用。
使用括号就可以定义一个元组。元组中的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。正是这个位置信息给数据赋予了意义。下面的例子中，元组就被当作记录加以利用：
输出为：
上述for循环中的操作提取了元组中的元素，也叫作拆包（unpacking）。平行赋值是对元组拆包很好的应用，示例如下：
还有一个经典而优雅的应用是交换变量的值：
用 * 运算符把一个可迭代对象拆开作为函数的参数，例如Python的内置函数pmod接收两个数字类型的参数，返回商和余数。以下范例将使用 * 将元组传入函数。
输出为：
有些函数有多个返回值，将其赋给一个变量时，变量类型即是元组：
输出为：
zip是Python的内置函数，能够接收两个或多个序列，并组成一个元组列表，在Python3中会返回一个迭代器，如下所示：
输出为：
元组当然也支持一些常规操作，如对于元组 a = (1, 'y', 5, 5, 'x') ：
上述内容不仅涵盖了元组的基本操作，同时也结合了实际工作中常搭配使用的其他函数、运算符等。在回顾这些知识时主要参考了两本经典的Python编程书籍：《流畅的Python》和《像计算机科学家一样思考Python》，有兴趣的朋友可以深入阅读！
希望这篇文章对你有帮助，下回将总结Python列表的使用技巧。
[1]《流畅的Python》:https://book.douban.com/subject/27028517/
