Python学习笔记(一) 列表和元组

Python 内置了多种序列类型，本篇文章将介绍最常用的两种：列表和元组

另一种也同样十分常用的序列类型 —— 字符串，我们将留在下一篇文章中进行详细讲述

一、列表

1、创建列表

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

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

列表中可以存放各种类型的元素

包括 int、float 等基本数据类型，也包括 dict、str、tuple、list 等标准数据类型

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

2、添加元素

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

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

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

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

3、删除元素

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

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

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

>>> li = ['one', 'two', 'three', 'four','five']
>>> lastVal = li.pop()
>>> firstVal = li.pop(0)
>>> li.remove('three')
>>> 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_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 设置用于排序的函数，例如如果要根据长度对列表进行排序，可以将参数 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]

8、补充知识

（1）列表迭代

迭代列表中的元素值

>>> li = ['A','B','C']
>>> for item in li:
    	print(item)
# A
# B
# C

同时迭代列表中的索引值和元素值

>>> li = ['A','B','C']
>>> for index,value in enumerate(li):
    	print(index,value)
# 0 A
# 1 B
# 2 C

并行迭代：考虑这样一种情况，现在有两个序列，你想同时迭代它们，或许你能编写出这样的代码

>>> name = ['Andy','Bennett','Cathy']
>>> grade = [85,98,95]
>>> for i in range(3):
		print(name[i],grade[i])
# Andy 85
# Bennett 98
# Cathy 95

但是，Python有更优雅的解决方式，使用函数 zip()

它可以将两个序列"缝合"起来，返回一个由元组组成的适合迭代的序列

要查看其内容，可使用函数 list() 将其转换为列表

>>> name = ['Andy','Bennett','Cathy']
>>> grade = [85,98,95]
>>> for i,j in zip(name,grade):
	print(i,j)
# Andy 85
# Bennett 98
# Cathy 95

（2）列表推导式

列表推导式提供了一种创建列表的简便方法，其基本格式如下：

new_list = [expression(i) for i in old_list if condition(i)]

翻译成一般语句就是：

new_list = []
for i in old_list:
    if condition(i):
        new_list.append(expression(i))

实例：

① 处理元素：例如对每一个元素取幂

>>> old_list = list(range(10))
>>> new_list = [i**2 for i in old_list]
>>> new_list
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

② 过滤元素：例如过滤奇数元素

>>> old_list = list(range(10))
>>> new_list = [i for i in old_list if i % 2 == 0]
>>> new_list
# [0, 2, 4, 6, 8]

③ 矩阵转置

列表推导式嵌套格式如下：

new_list = [expression(i, j) for i in old_list_one for j in old_list_two]

翻译成一般语句就是：

new_list = []
for i in old_list_one:
    for j in old_list_two:
        new_list.append(expression(i, j))

列表推导式嵌套格式变体如下：

new_list = [[expression(i, j) for i in old_list_one] for j in old_list_two]

翻译成一般语句就是：

new_list = []
for i in old_list_one:
    temp = []
    for j in old_list_two:
        temp.append(expression(i, j))
    new_list.append(temp)

解决矩阵转置：

>>> old = [[1,2,3],[4,5,6],[7,8,9]]
>>> new = [[row[i] for row in old] for i in range(len(old))]
>>> new
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

二、元组

元组与列表类似，都是属于序列中的一种，唯一的差别就是元组是 不能修改 的

除创建元组的语法之外，元组和列表可以说是十分类似，所以我们下面只会简单讲解如何创建元组

与列表相对应，元组的特征符号是 ()，创建空元组也有两种常见的方式

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

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

>>> tup = (1)
>>> type(tup)
# <class 'int'>

事实上，元组的特征符号是 ()，这句话从某种层面上来说是不准确的

因为创建带有一个元素的元组时不能使用上面的语法，而创建带有多个元素的元组时也可以不使用 ()

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

【 阅读更多 Python 系列文章，请看 Python学习笔记 】