[Python]第二章 列表和元组

数据结构：数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。
序列：基本数据结构，序列中的每个元素都有编号，即位置或索引，第一个元素的索引为0。

• 序列–列表和元组
• 映射-- 字典(详见第四章)
• 集合-- set(详见第十章)

2.1 序列概述（列表和元组）

不同在于，列表是可以修改的，而元组不可以。
序列 列表名=[元素1，元素2… …] 元组名=(元素1，元素2… …)

>>> edward = ['Edward Gumby', 42]
>>> type(a)
<class ‘list’>

序列还可包含其他序列

>>> john = ['John Smith', 50]
>>> database = [edward, john]
>>> database
[['Edward Gumby', 42], ['John Smith', 50]]

2.2 通用的序列操作

2.2.1 索引 序列名[索引号] 访问单个元素

字符串就是由字符组成的序列。序列中的所有元素都有编号——从0开始递增。

>>> greeting = 'Hello'
>>> greeting[0]
'H'

-1是最后一个元素的位置

>>> greeting[-1]
'o'

对于字符串字面量（以及其他序列字面量），可直接对其执行索引操作，无需先将其赋变量。

>>> 'Hello'[1]
'e'
>>> fourth = input('Year: ')[3]
Year: 2005
>>> fourth
'5'

列表相加+相乘*（见下文）

>>>Fruits=['apple','peach']+5*['pear']+['orange']
>>>Fruits
['apple','peach','pear','pear','pear', 'pear','pear','orange']

CASE:输出英文格式的日期

2.2.2 切片——列表名[起始位置含:结束位置不含]

访问特定范围内的元素

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6]
[4, 5, 6]

索引负数-n代表倒着数第n位数

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:-4]
[4, 5, 6]

1、绝妙的简写

从起始位置到最尾——列表名[起始位置含:]

>>> numbers[7:]
[8, 9, 10]

倒着数方法

>>> numbers[-3:]
[8, 9, 10]

从头到截止位置——列表名[:结束位置不含]

>>> numbers[:3]  
[1, 2, 3]

复制整个序列

>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

CASE：截取字段

2、 更大的步长——列表名[起始位置含:结束位置不含:步长]

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[::4]
[1, 5, 9]

步长是负数，表示从右往左提取

>>> numbers[::-2]
[10, 8, 6, 4, 2]

2.2.3 序列相加

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello,world!'
>>> [1, 2, 3] +[‘world’]
[1, 2, 3, ‘world’]

但是，不同的类型序列不能拼接

>>> [1, 2, 3] + 'world!'   #报错
>>> [1, 2, 3] + (1,2,3)   # 报错

2.2.4 乘法

>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

None、空列表和初始化

>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

CASE：打印方框

2.2.5 成员资格

要检查特定的值是否包含在序列中，可使用运算符in。布尔运算符，返回布尔值。

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
>>> users = ['mlh', 'foo', 'bar']
>>> input('Enter your user name: ') in users
Enter your user name: mlh
True
>>>A=[['as',12],['d',14]]
>>>s=['as',12]
>>>s in A
True

现在可使用运算符in来检查指定的字符串是否为另一个字符串的子串。

>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True

CASE:输入验证

长度len、最小值min和最大值max

>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> min([100, 34, 678])
34

以下调用max和min时指定的实参并不是序列，而直接将数作为实参。

>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
2

2.3 列表：Python 的主力

2.3.1 函数list

使用字符串来创建列表（也可以将元组转化成列表）

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
>>> ‘’.join(['H', 'e', 'l', 'l', 'o'])
'Hello'

2.3.2 基本的列表操作

1.修改列表 给元素赋值 =

>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]

2.删除元素 del 列表名【索引号】

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']

3.给切片赋值（替换，插入、删除）

>>> X=[1,2,3,4,5,6]
>>> X[:2]=[11,22]
>>> X
[11,22,3,4,5,6]

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']

通过使用切片赋值，可将切片替换为长度与其不同的序列

>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']

使用切片赋值还可在不替换原有元素的情况下插入新元素——用空切片器替换
这里的空切片器是numbers[1:1]，numbers[4:0]也是

>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]

取相反的措施来删除切片——替换成空切片

>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]

2.3.3 列表方法

方法是与对象（列表、数、字符串等）联系紧密的函数。像下面这样调用方法：
object.method(arguments)

1.append(X) 用于将一个对象附加到列表末尾。

>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

Notice:每次只能追加一个元素或者序列,如果添加的是序列，原序列也是多一个子序列，注意与extend()的区别

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.append(b)
>>> a
[1, 2, 3, [4, 5, 6]]

2.clear() 就地清空列表的内容

>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst
[ ]

这类似于切片赋值语句lst[:] = []

3.copy() 复制列表

如果是以赋值的方式"复制"，新旧列表其实质是指向同一个列表，其中一个修改，另一个也变，并未建立副本

>>> a = [1, 2, 3]
>>> b = a              #  b=a[:]   b=list(a)  才是复制，见下文
>>> b[1] = 4
>>> a
[1, 4, 3]

用copy函数才能建立一个副本，指向两个不同的列表

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

这类似于使用a[:]或list(a)，它们也都复制a

>>> a = [1, 2, 3]
>>> c = list(a)
>>> c[1] = 4
>>> a
[1, 2, 3]

>>> a = [1, 2, 3]
>>> d = a[:]
>>> d[1] = 4
>>> a
[1, 2, 3]

4.count(X) 计算指定的元素在列表中出现了多少次。

>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2

>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1

5.extend(X) 同时将多个值附加到列表末尾

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

Notice：注意与append()的区别
与拼接不同，拼接会返回一个新序列,并不是在原序列的基础上修改

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b    //extend效果：a=a+b  或者列表赋值给空切片 a[len(a):]=b
[1, 2, 3, 4, 5, 6] ///////////////////////////////////////////////////////////
>>> a
[1, 2, 3]       //[1, 2, 3, 1, 2, 3]

extend（）等效方法：a=a+b 或者 列表赋值给空切片 a[len(a):]=b

6.index(X.n) 在列表中查找指定值X第n次出现的索引

>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
>>> knights.index('who')
4

查找第2次的位置

>>> happy= ['h', 'a', 'p', 'p', 'y']
>>> happy.index('p',2)
3

7.insert(n,X) 将一个对象插入列表。

方法insert(n,X) 用于将一个对象X插入列表n位置

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

也可使用切片赋值来插入，但插入的元素一定是列表形式

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers[3:3] = ['four']
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

8.pop(n) 从列表删除一个元素（默认最后一个元素），并返回这一元素

>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]

Notice: pop是唯一既修改列表又返回一个非None值的列表方法
栈（stack）后进先出 ，push(append)和pop是两种昂栈操作， 方法pop和append的效果相反

>>> x = [1, 2, 3]
>>> x.append(x.pop())
>>> x
[1, 2, 3]

创建先进先出队列: Insert(0,…) pop(0)

9.remove(X) 删除第一个为指定值的元素

>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

10.reverse() 按相反的顺序排列列表中的元素

>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]

reversed不返回列表，而是返回一个迭代器

>>> x = [1, 2, 3]
>>> list(reversed(x))
[3, 2, 1]

11.sort() 对列表就地排序 修改列表而不返回任何值

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]

修改列表而不返回任何值 所以y是NONE

>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.sort() # Don't do this!
>>> print(y)
None

sorted函数可用于任何序列，但总是返回一个列表

>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

实际上sorted函数还可以对集合set,字典视图dict_keys排序，最终都会返回列表

12.高级排序 sort的参数key（排序依据） 和reverse（是否倒序）

>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

Notice:排序关键字也要根据列表元素类型，如果里面是数字，没有len属性

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len,reverse=True)
>>> x
['aardvark', 'abalone', 'aerate', 'acme', 'add']

函数sorted也接受参数key和reverse

2.4 元组：不可修改的序列

用逗号分隔还可用圆括号括起,

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

空元组用两个不包含任何内容的圆括号表示

>>> ()
()

只有一个值，也必须在它后面加上逗号.

>>> 42
42
>>> 42,
(42,)
>>> (42,)
(42,)

逗号至关重要，仅将值用圆括号括起不管用

>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2,)
(42, 42, 42)

Tuple()类似list()，可以将一个序列作为参数转化成元组

>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)

Notice:list()也可以将元组转化成列表

>>> list((1, 2, 3))
[1, 2, 3]

元组的主要操作是创建和访问其元素，且方式与其他序列相同

>>> x = 1, 2, 3
>>> x[1]
2
>>> x[0:2]
(1, 2)

Notice：元组访问元素后面还是中括号

元组的必要性：
它们用作映射中的键（以及集合的成员），而列表不行
有些内置函数和方法返回元组，这意味着必须跟它们打交道。