Python学习笔记之列表与元组

Python 内置了多种序列，下面我们来介绍最常用的两种：列表和元组，另一种也同样十分常用的序列——字符串，我们将留在下一篇文章中详细讲述

一、列表

1. 创建列表

列表的特征符号是 [ ]，创建空列表有两种常见的方式

>>> # 创建空列表
>>> li = [] # 使用特征符号
>>> li = list() # 使用内置函数

列表中可以存放各种类型的元素，包括 int、float 等基本数据类型，也包括 Dictionary、Set、String、Tuple 等标准数据类型，甚至还可以是列表

>>> # 创建带有元素的列表
>>> li = [27, 3.7, {'Python':'Beautiful'}, 'Hello', (0, 2), [0, 3]]
>>> type(li)
<class 'list'>

2. 添加元素

（1）append() 方法：将元素添加到列表末尾，一次只允许添加一个元素

（2）extend() 方法：将新列表元素添加到列表末尾

（3）insert() 方法：将元素插入到列表指定位置，一次只允许插入一个元素

>>> li = ['one'] # ['one']
>>> li.append('two') # ['one', 'two']
>>> li.extend(['three','five']) # ['one', 'two', 'three','five']
>>> li.insert(3,'four') # ['one', 'two', 'three', 'four','five']
>>> li
['one', 'two', 'three', 'four','five']

3. 删除元素

（1）pop() 方法：默认删除并返回列表最后一个元素，可以通过参数指定删除元素的索引

（2）remove() 方法：删除指定元素值的元素，不返回元素

（3）clear() 方法：删除整个列表内容，不返回内容

>>> li = ['one', 'two', 'three', 'four','five']
>>> lastVal = li.pop() # ['one', 'two', 'three', 'four']
>>> firstVal = li.pop(0) # ['two', 'three', 'four']
>>> li.remove('three') # ['two', 'four']
>>> li.clear() #[]
[]

4. 访问元素

可以通过 list[index] 的方式对元素进行索引

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[0]
'one'

5. 列表切片

除了通过索引来访问单个元素之外，还可以使用切片来访问特定范围内的元素，为此，我们使用两个索引指定切片的范围，即起始索引和结束索引

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[1:3]
['two', 'three']

注意：你可以使用的两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内

• 省略

当未指定起始索引时，其默认为 0；当未指定结束索引时，其默认为列表最后一个元素

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[1:] # 取列表中除第一个元素外的其余元素
['two', 'three', 'four', 'five']

当前后索引都省略时，意味着创建一份原列表的副本

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[:]
['one', 'two', 'three', 'four', 'five']

• 负数索引

Python 除了支持使用正整数进行索引外，还支持使用负整数进行索引，其意味着索引从后往前开始计数

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[-1]
'five'
>>> li[:-1] # 取列表中除最后一个元素外的其余元素
['one', 'two', 'three', 'four']

• 步长

上述操作都是对列表中每一个元素进行操作的，有没有一种可能允许我们跳跃性的选取元素呢？答案是肯定的，这时就要用到切片操作中的第三个参数用于指定步长了，若没有指定时，其默认为1

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[::2]
['one', 'three', 'five']

利用这个特性，我们可以做出一些有趣的操作，例如反转列表

>>> li = ['one', 'two', 'three', 'four','five']
>>> li[::-1]
['five', 'four', 'three', 'two', 'one']

注意：切片是创建原列表的一份副本，而非对其本身进行操作

>>> li = ['one', 'two', 'three', 'four','five']
>>> li_slice = li[:]
>>> li_copy = li.copy()
>>> li_slice.append('six')
>>> li_slice
['one', 'two', 'three', 'four', 'five', 'six']
>>> li
['one', 'two', 'three', 'four', 'five']

6. 列表操作符

对于用于基本数据类型的算术运算符也可以运用在列表上，但是其含义可以有所不同

（1）连接操作符（+）：将两个列表连接起来

其实，连接操作符还可以运用在其他数据类型，只要连接操作符两边的类型要一致即可

>>> ['one', 'two'] + [ 'three', 'four']
['one', 'two', 'three', 'four']
>>> ['one', 'two'] + 'three' # 左右类型不一致时会报错
TypeError: can only concatenate list (not "str") to list

（2）重复操作符（*）：将列表中的元素复制指定次数

>>> ['one', 'two'] * 2
['one', 'two', 'one', 'two']

通过重复操作符我们可以很轻松地初始化一个列表

>>> [0] * 10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

（3）成员资格操作符（in、not in）：判断元素是否属于列表

>>> 'one' in ['one','two']
True
>>> 'one' not in ['one','two']
False

7. 列表方法

（1）count() ：统计指定值在列表中出现的次数

>>> li = [1,5,9,3,5,7,2,5,8]
>>> li.count(5)
3

（2）index() ：查找指定值在列表中第一次出现的索引

>>> li = [1,5,9,3,5,7,2,5,8]
>>> li.index(5)
1

（3）reverse() ：按相反的顺序排列列表中的元素（对原列表进行操作，不返回值）

>>> li = [1,2,3,4,5]
>>> li.reverse()
>>> li
[5, 4, 3, 2, 1]

（4）sort() ：对列表进行排序（对原列表进行操作，不返回值）

>>> li = [1,5,2,4,3]
>>> li.sort()
>>> li
[1, 2, 3, 4, 5]

注意：sort 方法不返回任何值，要想返回排序后的列表可以使用 sorted() 方法，事实上， sorted() 方法还可以应用于任何序列，但总是返回一个列表

>>> li = [1,5,2,4,3]
>>> sorted_li = sorted(li)
>>> sorted_li
[1, 2, 3, 4, 5]

• sort() 方法还可以接受两个可选参数，分别为 key 和 reverse，参数 key 类似于参数 cmp，可以将其设置为用于排序的函数，例如，如果要根据长度对列表进行排序，可以将参数 key 设置成 len

>>> li = ['apple','banana','orange','dog']
>>> li.sort(key=len)
>>> li
['dog', 'apple', 'banana', 'orange']

对于另一个参数 reverse，可以将其指定为一个 bool，False（默认） 表示顺序排列，True 表示反序排列，与 reverse() 方法类似

>>> li = [1,5,2,4,3]
>>> li.sort(reverse=True)
>>> li
[5, 4, 3, 2, 1]

二、元组

元组与列表类似，都是属于序列中的一种，唯一的差别就是元组是不能修改的，另外，除了在创建上与列表有所不同外，在使用上可以说是和列表十分类似了，所以这里我们只会主要讲讲如何创建元组，至于具体如何使用，我想还是留给各位读者自己摸索吧

元组的特征符号是 ( )，创建空元组也有两种常见的方式

>>> # 创建空元组
>>> tup = () # 使用特征符号
>>> tup = tuple() # 使用内置函数>>> tup = () 

可能与你想象中的不同，创建带有一个元素的元组可以不使用下面的语法

>>> tup = (1)
>>> type(tup)
<class 'int'> # 可以看到这里的类型显示的是 int，而非 tuple

事实上，元组的特征符号是 ( ) 这句话从某种层面上说也许并不准确，因为当创建带有一个元素的元组时不能使用类似上面的语法创建，而创建一个带有多个元素的元组时也可以不使用 ( )

>>> tup = 1,2,3,4,5
>>> type(tup)
<class 'tuple'>

不过，出于常用性等各方面因素的考虑，这里还是认为元组的特征符号是 () 吧，不过在处理的时候要注意上面提及的问题就好了