python知识之列表和元组

1、列表（list）

1.1 列表的定义

列表：是一种有序的集合，可以随时添加和删除其中的元素，写在方括号之间、元素用逗号分隔开。列表内的元素不必全是相同的类型。

In [1]: list1 = ["age", 10, True]      # 列表内元素可以是不同类型
In [2]: len(list1)                     # 用len()函数可以获得列表的长度，即元素的个数
Out[2]: 3

1.2 索引和切片

1.2.1 索引（通过索引可取出一个元素）

索引：类似于编号的意思，我们可以根据索引找到它们所对应的元素。

正索引：从左边开始算起，从0开始

负索引：从右边开始算起，从-1开始

In [3]: list1 = ["age", 10, True]
In [4]: list1[1]         # 输出第2个元素
Out[4]: 10

In [5]: list1[-1]         # 输出右边算起的第一个元素(左边算起最后一个元素)
Out[5]: True

需要注意的是：当索引超出了范围时，会报错IndexError错误，所以，要确保索引不要越界。

如果是需要for循环遍历列表时，记得最后一个元素的索引是len(list1) - 1

In [6]: list1 = ["age", 10, True]
In [7]: list1[3]                    # 输出报错信息
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-8-2ff69b0ff8ea> in <module>
----> 1 print(list1[3])

IndexError: list index out of range

1.2.2 切片（通过切片可取出多个元素）

切片：对操作的对象截取其中一部分元素，字符串、列表、元组都支持切片操作。

切片的语法：[起始索引：结束索引：步长]，输出元素包含起始索引元素，不包含结束索引元素。

In [9]: list1 = ["age", 10, True]
In [10]: list1[0:2]                 # 输出第1、2个元素
Out[10]: ['age', 10]

In [11]: list1[0:3:1]
Out[11]: ['age', 10, True]

1.3 列表的常见操作

1.3.1 添加元素(append，extend，insert)

1.3.1.1 append

通过append可以向列表添加元素，添加位置在列表的最后面。

In [12]: list1 = ["age", 10, True]
In [13]: list1.append("append")

In [14]: list1
Out[14]: ['age', 10, True, 'append']

1.3.1.2 extend（注意和append的区别）

通过extend可以将另一个列表的元素逐一添加到原列表中，添加位置在列表的最后面。

In [15]: list1 = ["age", 10, True]
In [16]: list2 = ["append","hello"]
In [17]: list1.append(list2)               # 整体添加
In [18]: list1
Out[18]: ['age', 10, True, ['append', 'hello']]

In [19]: list1.extend(list2)                    # 逐一添加
In [20]: list1
Out[20]: ['age', 10, True, ['append', 'hello'], 'append', 'hello']

1.3.1.3 insert

通过insert可以在指定索引位置插入元素，添加位置根据指定索引来确定

In [21]: list1 = ["age", 10, True]
In [22]: list2 = ["append","hello"]

In [23]: list1.insert(2,list2)   # 在索引为2的位置添加
In [24]: list1
Out[24]: ['age', 10, ['append', 'hello'], True]

1.3.2 修改元素

修改元素的时候，要通过索引来确定要修改的是哪个元素，然后才能进行修改。

In [25]: list1 = ["age", 10, True]
In [26]: list1[0] = "name"        # 修改索引为0的元素

In [27]: list1
Out[27]: ['name', 10, True]

1.3.3 查找元素（in/not in，index，count）

1.3.3.1 in/not in

通过 in/not in 判断元素是否存在列表中，如果是in，存在则返回True，否则为False；如果是not in，不存在则返回True，否则为False。

In [28]: list1 = ["age", 10, True]
In [29]: if "age" in list1:
    ...:     print(True)
True

In [30]: if "name" not in list1:
    ...:     print(True)
True

1.3.3.2 index

与字符串中index用法相同

In [31]: list1 = ["age", 10, True]
In [32]: list1.index(10)
Out[32]: 1

1.3.3.3 count

与字符串中count用法相同

In [33]: list1 = ["age", 10, True]
In [34]: list1.count(10)
Out[34]: 1

1.3.4 删除元素（del，pop，remove）

1.3.4.1 del

del list1[index] ，删除指定索引的元素

In [35]: list1 = ["age", 10, True]
In [36]: del list1[1]

In [37]: list1
Out[37]: ['age', True]

1.3.4.2 pop

list1.pop(index)，没有index的话会默认删除最后一个元素，删除的元素可以用其它变量保存起来。

In [38]: list1 = ["age", 10, True]
In [39]: a = list1.pop(1)
In [40]: a
Out[40]: 10

In [41]: list1
Out[41]: ['age', True]

In [42]: b = list1.pop()
In [43]: b
Out[43]: True

1.3.4.3 remove

list1.remove(element)，删除指定元素，不是指定索引

In [44]: list1 = ["age", 10, True]
In [45]: list1.remove(10)

In [46]: list1
Out[46]: ['age', True]

1.3.5 排序（sort，reverse）

1.3.5.1 sort

sort方法是将list1按特定顺序重新排列，默认为从小到大，参数reverse=True时为倒序排列。
注意sort()是列表的一个排序方法，直接修改原列表，没有返回值，打印出来个None值。
sorted()使用范围更广，不局限于列表，能接受所有迭代器，返回排序好的列表。

In [47]: list1 = [2, 5, 10, 4]
In [48]: list1.sort()
In [49]: list1
Out[49]: [2, 4, 5, 10]

In [50]: list1.sort(reverse=True)
In [51]: list1
Out[51]: [10, 5, 4, 2]

1.3.5.2 reverse

reverse方法可将list1逆置，是将整个列表反过来排序（不是倒序）。

In [52]: list1 = [2, 5, 10, 4]
In [53]: list1.reverse()

In [54]: list1
Out[54]: [4, 10, 5, 2]

1.3.6 遍历

列表的遍历通常使用for循环和while循环完成

# 使用枚举法遍历列表，可同时输出索引和对应的值
In [55]: list1 = [2, 5, 10, 4]
In [56]: for index, ele in enumerate(list1):     
    ...:     print(index, ele)
0 2
1 5
2 10
3 4
    
......................................

In [57]: list1 = [2, 5, 10, 4]
In [58]: i = 0
    ...: while i < len(list1):
    ...: 	print(list1[i])
    ...: 	i += 1
2
5
10
4

2、元组（tuple）

2.1 元组的定义

元组：与列表类似，支持索引和切片，不同的是元组一旦初始化便不能修改。

列表使用方括号，而元组使用小括号，且只包含一个元素时， 需要在元素后面添加逗号 。

In [59]: tuple1 = (2, 5, 10, 4)
In [60]: tuple2 = (2,)           # 只包含一个元素时， 需要在元素后面添加逗号

In [61]: tuple1[2]
Out[61]: 10

In [62]: tuple1[1] = 3        # 输出报错信息，因为元组不能被修改
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-62-5fbcec7a99c3> in <module>
----> 1 tuple1[1] = 3

TypeError: 'tuple' object does not support item assignment

2.2 元组的使用场景

因为元组的不可修改的特性，它没有列表中append()、insert()等方法，使用起来不够灵活。但是因为不可变，所以代码会更安全。如果可能，能用元组代替列表就尽量用元组。

需要注意的是，所谓元组的不可变指的是元组所指向的内存中的内容不可变。

下面的例子，元组是“可变”的：

In [63]: tuple1 = (2, 5, [10, 4])
In [64]: id(tuple1[2])
Out[64]: 2394490996232

In [65]: id(tuple1[2][0])
Out[65]: 140720250000480

In [66]: tuple1[2][0] = 6
In [67]: id(tuple1[2])                 # 内存地址没变
Out[67]: 2394490996232

In [68]: id(tuple1[2][0])             #  内存地址已经改变了
Out[68]: 140720250000352

In [69]: tuple1                     # 改变的其实是列表
Out[69]: (2, 5, [6, 4])