Python入门笔记2 - 列表和元组

• 很久以前就像学python了，还写过一篇文章Python入门笔记1-基本数据类型，但是后来各种事情耽搁就没怎么看了，现在开始继续学习
• 参考书《Python基础教程（第三版）》—— Magnus Lie Hetland

---

一、序列

• Python中最基本的数据结构为序列（这是一个统称，包含列表/元组/字符串等多种结构），序列中每个元素都有索引编号，从0开始。Python也支持从队尾找起的负索引。

1. 序列概述

• 列表、元组、字符串都属于序列
• 列表是可以修改的，但元组不行。
• 列表/元组中可以放不同类型的变量，也可以包含其他列表/元组

>>> data1 = ['NO.1',1]		#列表
>>> data2 = ['NO.2',2]		#列表
>>> dataSet = [data1,data2]	#列表
>>> dataSet
[['NO.1', 1], ['NO.2', 2]]

2. 序列的通用操作

• 所有序列都支持以下操作：索引、切片、相加、相乘、成员资格检查、迭代。还有一些内置函数可以用来找出序列中的最大最小值、序列长度等

（1）索引

1. 序列中所有元素都有编号，左起第一个为0，右起第一个为-1

>>> data1=['NO.1',1]
>>> data1[0]
'NO.1'
>>> data1[-1]
1
>>> data1[1]
1
>>> data1[-2]
'NO.1'

2. 对于序列字面量，可以直接进行索引，不用把它赋给变量

>>> ['Hello',1,'World',2][-2]
'World'
>>> "World"[-1]
'd'

3. 如果函数返回一个序列，可以在调用的时候直接索引

>>> X = input("year:")[3]	# input读取键盘输入并返回一个字符串
year:2019					# 输入2019
>>> X
'9'

（2）切片

1. 切片用于访问特定范围内的元素，需要两个索引
2. 形式序列[begin,end,(step)]：序列，begin和end是两个索引，返回一个新序列，值为原序列下标[begin,end)区间。步长参数step可以不写，缺省步长为1

>>> num = "0123456789"
>>> num[2:5]
'234'
>>> num[-3:-1]
'78'

3. 要切片结束于末尾，省略第二个索引；要切片起始于开头，省略第一个索引

>>> num = "0123456789"
>>> num[2:]
'23456789'
>>> num[:3]
'012'
>>> num[:]
'0123456789'

4. 步长：切片时添加元素的间隔，默认为1，但也可以显式指定
   1. 也可以有负数步长，这时从右往左取数
   2. 注意步长不能是0，否则报错

>>> num = "0123456789"
>>> num[::2]
'02468'
>>> num[2:7:3]
'25'
>>> num[8:3:-1]	#可以有负数步长
'87654'
>>> num[1:5:-2]
''

（3）相加

1. 可以用加法拼接同型的序列，但是一般不能拼接不同型序列
2. 返回一个新列表，不是原地修改

>>> data1 = ['NO.1',1]
>>> data2 = ['NO.2',2]
>>> data1 + data2		#拼接两个列表
['NO.1', 1, 'NO.2', 2]

（4）乘法

1. 序列与数字x相乘，表示重复这个序列x次
2. 返回一个新列表，不是原地修改

>>> data1 = ['NO.1',1]
>>> data1*3
['NO.1', 1, 'NO.1', 1, 'NO.1', 1]
>>> [32]*10
[32, 32, 32, 32, 32, 32, 32, 32, 32, 32]

2. 可以用乘法来初始化列表。Python中用none表示“什么都没有”，因此可按如下方法把列表长度初始化为10

>>> sequence = [None]*5	#sequence长度为5
>>> sequence
[None, None, None, None, None]

（5）成员资格

1. 要检查特定的值是否在序列中，可以使用运算符in，返回bool值True/False

>>> num = '0123456789'
>>> '1'in num
True
>>> 'a'in num
False
>>> input('Enter a number: ')in num
Enter a number: 3
True

二、列表（list）

• 列表是序列的一种，这里主要讨论列表不同于元组和字符串的地方
  1. 列表是可变的，可以修改其内容
  2. 列表有很多特有方法

1. 创建列表

1. 将元素用‘,’分割，加个方括号

>>> lst = [1,2,'A','string']
>>> lst
[1,2,'A','string']

2. 序列转换为列表list(x)

1. List(x)：List函数可以把任何序列x转换为列表。（list实际是一个类，这个其实是列表的构造函数之一）

>>> list("1234567890")
['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
>>> list([1,"10"])
[1, '10']

2. 可以用''.join(list)把字符列表list还原为字符串
   • list中的元素必须都是char
   • 这个join方法其实是把list中每个char放到str前面重复，这里放了一个空串，所以看起来是把list中字符拼成字符串了

>>> ''.join(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'])
'1234567890'

>>> string = 'ABC'.join(['1','2','3','4','5'])
>>> string
'1ABC2ABC3ABC4ABC5'

3. 列表基本操作

（1）给元素赋值

1. 使用[]索引找到列表中一个元素并重新赋值（注意不要越界）

（2）删除元素

1. 删除元素：使用del list[n]来删除列表list中第n个元素（字典类型也支持这个）

>>> list = [1,2,3]
>>> list[1] = 103	#赋值
>>> list
[1, 103, 3]

>>> del list[1]		#删除
>>> list
[1, 3]

（3）切片赋值

1. 通过给切片赋值，可以将切片替换为长度不同的序列
2. 可以在不删除原有元素的情况下插入新元素
3. 可以用来删除元素

>>> name = list("12345")	#切片赋值
>>> name[2:4]="abcd"
>>> name
['1', '2', 'a', 'b', 'c', 'd', '5']

>>> name = [1,5]			#插入元素（本质是切片赋值）
>>> name[1:1] = [2,3,4]
>>> name
[1, 2, 3, 4, 5]

>>> name = [1,5]			#删除元素（本质是切片赋值）
>>> name[0:1] = []
>>> name
[5]

4. 列表方法

• 列表list本身是一个类，这个类提供了若干方法。调用方法类似C/C++语言

（1）append(x): None方法

1. 添加一个对象到列表末尾
2. append方法就地修改列表，不会返回新列表

>>> num = list("12345")
>>> num
['1', '2', '3', '4', '5']
>>> num.append(6)
>>> num.append(“ABC”)
>>> num
['1', '2', '3', '4', '5', 6,'ABC']

#下面这个程序不好，因为list是一个内置函数，如果用list起名，会导致list函数不能使用
>>> list = ["a",1]
>>> list.append("Hello")
>>> list
['a', 1, 'Hello']

（2）clear(): None方法

1. 方法clear就地清空列表，类似切片语句lst[:]=[]

>>> lst = list("Hello")
>>> lst
['H', 'e', 'l', 'l', 'o']
>>> lst.clear()
>>> lst
[]

（3）copy(): list方法

1. 常规赋值（如下）只是将另一个名字关联到列表（类似C中typedef别名）

>>> lst_A = []
>>> lst_B = lst_A
>>> lst_B
[]
>>> lst_B.append("abc")
>>> lst_A
['abc']

2. 方法copy复制列表，返回一个新列表，它是原列表的副本，这样就能把新列表变量关联到新列表，从而让列表副本和原本独立

>>> lst = []
>>> lst_ = lst.copy()
>>> lst_.append("123")
>>> lst_
['123']
>>> lst
[]

（4）count(x): integer方法

1. 方法count统计指定元素再列表中出现了几次

>>> [1,2,3,3,3,4,5,6].count(3)
3

（5）extend(x): None方法

1. 方法extend同时添加多个值到列表末尾也就是说在列表末尾添加另一个列表
2. extend类似列表拼接”+”，区别在于extend是在原表上修改，”+”返回了新列表
3. a = a + b比a.extend(b)效率低
4. 还可以用切片实现extend效果，但是可读性差

#extend方法
>>> lst = [1,2,3,4]
>>> lst.extend(list("abcde"))
>>> lst
[1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

#用切片实现
>>> lst = [1,2,3,4]
>>> lst[len(lst):] = list("abcde")
>>> lst
[1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

#用+运算实现
>>> lst = [1,2,3,4]
>>> lst += list("abcde")
>>> lst
[1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

（6）index(x): integer方法

1. index查找列表中指定值第一次出现的索引，如果不存在指定值会报错

>>> [1,2,3,4].index(1)
0

（7）insert(n,object): None方法

1. list.insert(n,object)用于将一个对象插入列表，位置为n
2. 用切片也可以实现类似效果，但可读性不好

#insert
>>> a = [1,2,3]
>>> a.insert(2,"a")
>>> a
[1, 2, 'a', 3]

#切片实现
>>> a = [1,2,3]
>>> a[2:2]="a"
>>> a
[1, 2, 'a', 3]

（8）pop(): object方法

1. pop从列表末尾删除一个元素，并把它返回
2. pop是唯一一个即修改原列表，又返回非none值的方法

>>> a = [1,2,3]
>>> b = a.pop()
>>> a
[1, 2]
>>> b
3

（9）remove(obj): None方法

1. list.remove(obj)删除列表中第一个为obj的元素，如果表中不存在此元素会报错
2. 就地修改列表且无返回

>>> a = [1,2,3,4,5]
>>> a.remove(3)
>>> a
[1, 2, 4, 5]

（10）reverse(): None方法

• 就地修改列表且不返回值，将列表就地反向排列

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

（11）sort(): None方法

1. 对列表就地排序（默认从小到大），不返回值。从python2.7开始这个是稳定的排序算法

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

#不要这样做，这样只会对a排序，b为none
>>> a = [1,3,2,5,4]
>>> b = a.sort()

#先把b关联（=）到a的副本，再sort
>>> a = [1,3,2,5,4]
>>> b = a.copy()
>>> b.sort()
>>> b
[1, 2, 3, 4, 5]

2. 还可以使用内置函数sorted(object):list达到类似的效果。 Sorted函数可以用于任何序列（实际上，适用于任何可迭代对象），总是返回一个列表

>>> a = [1,3,2,5,4]
>>> b = sorted(a)
>>> b
[1, 2, 3, 4, 5]

#sorted函数可用于任何可迭代对象
>>>sorted(“Python”)
>>>[‘P’, ’h’ , ’n’ , ’o’ , ’t’ , ’y’]

（12）高级排序

1. sort方法和sorted函数都可以接受两个可选参数：key和reverse，它们是按名称指定的，称为关键字参数

   1. Key指定排序的标准，类似C++中sort函数的cmp参数，区别在于，cmp函数直接判断元素相对大小，Key参数则是用来对每个元素创建一个键，再根据这些键排序。Key可以设置为自定义函数（后面再讲）

   2. Reverse指定从小到大还是从大到小，只需将其指定为True或False，代表要不要按相反的顺序进行排序

#Key参数
>>> X = [‘123’ , ‘12’ , ‘1’ ]
>>> X.sort(Key = len)  #假设Key的函数已经写好了
>>> X
[‘1’ , ‘12’ , ‘123’]

#reverse参数
>>> X = [1,2,3,4]
>>> X.sort(reverse = True)
>>> X
[4,3,2,1] 

（13）小结

1. 无返回值的方法：
   append / clear / extend / insert / remove / reverse / sort
2. 有返回值的方法：
   copy：返回副本列表
   count：返回指定元素出现次数
   index：返回指定元素首次出现的索引
   pop：返回表中最后一个元素
3. 对列表进行就地修改的方法：
   append / clear / extend / pop / remove / reverse / sort

三、元组（tuple）

• 元组和列表一样都是序列，区别在于元组不可以修改

1、创建一个元组

1. 将元素用‘,’分割即可，也可以加个圆括号

>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)

2. 空元组：用空括号表示

>>> ()

3. 只有一个元素的元组：在值后加一个逗号

#注意不能(1)这样，要加括号只能写成(1,)
>>> 1,	
(1,) 

>>>(42)			#一个值直接加括号是没用的
>>>42
>>> 3*(40+2)	#这样不能创建元组
126
>>> 3*(40+2,)	#创建了元组，逗号至关重要
(42, 42, 42)

2、序列转换为元组

1. 类似list类，tuple类可以把序列转为元组

#字符串 -> 元组
>>> a = tuple("Hello")
>>> a
('H', 'e', 'l', 'l', 'o')

#列表 -> 元组
>>> a = list("1234")
>>> a
['1', '2', '3', '4']
>>> b = tuple(a)
>>> b
('1', '2', '3', '4')

3、元组相关操作

1. 元组的创建和访问方法和列表完全类似
2. 因为元组不可修改，其他没有什么可以对元组进行的操作了

4、元组的作用

1. 用作映射中的键（以及集合的成员）
2. 有些内置函数返回元组
3. 一般而言只用列表就可以满足要求了，几乎所有情况下都可以用列表代替元组（除非元组用作字典键，这是不可以修改的）