Python基础教程（第三版）读书笔记（2）

列表和元组

当我们处理一系列数据时，我们可能需要对某个特定数据进行操作。那么我们我们如何去找到这个特定数据呢？用n个变量来保存n个数吗？这样显然是不现实的。首先在数据量大的时候，你可能想不到这么多变量名。另外如何记忆这些变量名也是一个大问题！ 那么我们有没有一个“装置”，像水杯一样将无数的水分子装起来呢？如果有的话，我们如何去寻找水杯里面的每一个水分子呢？
python为我们提供了一种数据结构的基本概念，名为容器。

容器即可包含其他对象的对象。两种主要的容器是序列(如列表和元组）和映射 (如字典）。在序列中每个元素都有编号,在映射中每个元素都有名称(也叫键）。另外还有一种不是序列也不是映射的容器叫做集合

这里主要讨论序列，即列表和元组

通用的序列的操作

为了方便的处理数据，有几种操作适用于所有序列，包括索引，切片，相加，相乘，成员资格检查 下面我们依次介绍每种操作

索引

python提供了正索引和负索引。对于n个数据。正索引从第一个元素到最后一个元素索引分别是0, 1, 2, 3,… , n-1 。负索引从最后一个元素到第一个元素索引分别是 -1, -2, -3, … , -n

>>> greeting = 'Hello'
>>> greeting[0]
'H'
>>> greeting[-1]
'o'

对于字符串字面量（或者其他的序列字面量），可直接对其执行索引操作。

>>> 'Hello'[0]
'H'

另外如果函数调用返回一个序列，可直接对其进行索引操作。

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

切片

除了使用索引来访问单个元素外，还可使用切片来访问特定范围的元素。为此可以使用两个索引（开始，结束的后一个），并用冒号分割。

>>> # 切片
>>> tag ='<a href="http://www.python.org">Python web site</a>'
>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'
>>> tag[9]
'h'
>>> tag[30]
'"'

绝妙的简写

切片中第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6]  # 访问数字列表中索引为3到索引为5的元素
[4, 5, 6]
>>> numbers[0:1]
[1]

如果切片操作时，第一个索引指定的位置位于第二个索引指定的元素后面，结果就为空序列[]。另外如果切片结束于序列末尾，第二个索引可不写，同样，如果切片始于序列开头，第一个索引可不写

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

如果要复制整个序列，可将两个索引都省略

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

更大的步长

通过上面的描述，我们可以感觉到切片是一种很有用的操作。上面的例子中，我们可以访问指定范围内连续的元素，这样很好。但是如果我们，不想访问连续的元素，我们想要隔几个元素访问一个元素。那么这样应该怎么办呢？切片中，除了可以使用指定开始或结束的位置外，还可以指定步长。在之前我们的切片中，步长为1，意味着从一个元素移到下一个元素。我们可以将步长显式的定义为我们想要的间隔。

>>> numbers[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> # 当步长变大时将跳过一些元素，步长为二时，将从起点和终点之间隔一个元素
>>> numbers[1:10:2]
[2, 4, 6, 8, 10]
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> # 另外步长不能为零，步长可为负数，即从右向左提取元素
>>> numbers[1:10:-1]
[]
>>> numbers[10:1:-1]
[10, 9, 8, 7, 6, 5, 4, 3]

这就是序列的切片操作，切片是序列中一种很重要的操作。

序列相加

当我们想要拼接多个序列时，我们可以使用 “+” 将多个序列拼接。需要注意的是不可拼接不同类型的序列。

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> "hello" + "world"
'helloworld'

乘法

将序列与数x相乘时，将重复这个序列x次来创建一个新序列。

>>> 'Python' * 5
'PythonPythonPythonPythonPython'
>>> [20] * 5
[20, 20, 20, 20, 20]

如果想要创建一个可包含10个元素的列表。但是表中的元素未知。python提供了‘None’表示什么都没有，我们可以用None来设置空列表或者初始化列表。

>>> [None] * 10
[None, None, None, None, None, None, None, None, None, None]
>>> a = [None] * 10
>>> a
[None, None, None, None, None, None, None, None, None, None]
>>> a[3:5] = numbers[3:5]
>>> a
[None, None, None, 4, 5, None, None, None, None, None]

成员资格

要检查特定的值是否包含在序列中，可使用运算符in。 满足返回True, 不满足时返回False

>>> permissions = 'IW'
>>> 'w' in permissions
False
>>> 'W' in permissions
True

成员资格在一些地方用的很多，比如资格审查等。看一个检查用户名和PIN码示例

>>> database= [
	['albert', '1234'],
	['dilbert', '4567'],
	['smith', '7524']
	]
>>> username = input('User name:')
User name:albert
>>> pin = input('PIN code: ')
PIN code: 1234
>>> if [username, pin] in database:
	print('Access granted')

Access granted

基本操作大致就是这些啦，说一些内置函数关于长度，最大值，最小值

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

列表：Python的主力

函数list

>>> # 可使用list将字符串（任何序列）转化成列表
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
>>> a = list('Hello')
>>> a
['H', 'e', 'l', 'l', 'o']
>>> ''.join(a)
'Hello'
>>> # 使用 ''.join(somelist) 将列表转换成字符串。

基本的列表操作

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

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

2. 删除元素

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']
>>> # 使用del语句删除元素

3. 给切片赋值

切片本就是一种很强大的功能。通过给切片赋值，可以使这项功能显得更强大，完成插入或者删除 功能。下面让我们来看看具体是怎么用的吧！
首先看一下基本的赋值方式。

>>> 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, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]
>>> # 给numbers[1:1]赋值， 相当于给一个空切片赋值，等于插入了一个序列。
>>> # 同样，也可以使用这种方式来删除切片。
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]

列表方法

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

列表包含多个可用来查看或修改其内容的方法。

方法	描述
append(object)	将一个对象附加到列表末尾。
clear()	就地清空列表的内容。
copy()	复制列表。
count(data)	计算指定的元素在列表中出现了多少次。
extend(object)	同时将多个值附加到列表末尾。
index(data)	在列表中查找指定值第一次出现的索引。
insert(index, object)	将一个对象插入列表指定位置
pop()	从列表中删除一个元素（默认为最后一个元素），并返回这一元素。
remove(data)	删除第一个为指定值的元素。
reverse()	按相反的顺序排列列表中的元素。
sort()	对列表就地排序。
sort(key, reverse=T/F)	高级排序，key为排序规则（可自定义），reverse选择T/F表示是否为逆序。

使用方法如下，请细看！！！

>>> # append : 用于将一个对象添加到列表末尾
>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]
>>> # append 是直接修改旧列表，不返回修改后的新列表
>>> a = lst.append(5)
>>> a
>>> lst
[1, 2, 3, 4, 5]
>>> # clear 就地清空列表内容。
>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst
[]
>>> a
>>> # 常规复制： 只是将另一个名称关联到列表。通过其中一个名称修改列表时，其余名称列表的值都会改变。
>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4
>>> a
[1, 4, 3]
>>> b
[1, 4, 3]
>>> # copy : 复制列表，将b关联到a的副本
>>> a = [1, 2,, 3]
SyntaxError: invalid syntax
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> b
[1, 4, 3]
>>> a
[1, 2, 3]
>>> # 类似的还有a[:]或者list(a).
>>> b = a{:]
SyntaxError: invalid syntax
>>> b = a[:]
>>> b[1] = 4
>>> b
[1, 4, 3]
>>> a
[1, 2, 3]
>>> b = list(a)
>>> b[1] = 4
>>> b
[1, 4, 3]
>>> a
[1, 2, 3]
>>> # count : 计算指定的元素在列表中出现了多少次
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1
>>> y = x[3]
>>> y
[2, 1, [1, 2]]
>>> y.count(1)
1
>>> y.count([1, 2])
1
>>> y.count(4)
0
>>> 
>>> 
>>> 
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.append(b)
>>> a
[1, 2, 3, [4, 5, 6]]
>>> # extend 可同时将多个值附加到列表末尾。即可使用一个列表来扩展另一个列表。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
>>> c = a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, 4, 5, 6]
>>> c
>>> # extend 是在原有的列表后面拼接，不返回新的列表
>>> # 常规拼接是返回一个全新的序列
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]
>>> c = a+b
>>> c
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]
>>> b
[4, 5, 6]
>>> # 上面说错了，extend类似于拼接，但是是扩展。
>>> # index : 在列表中查找指定值第一次出现的索引
>>> knights = ['We', 'are', 'hero', '!']
>>> knights.index('We')
0
>>> knights.index('are')
1
>>> knights.index('jk')
Traceback (most recent call last):
  File "<pyshell#235>", line 1, in <module>
    knights.index('jk')
ValueError: 'jk' is not in list
>>> # 查找列表中没有的词，会产生异常。
>>> 
>>> # insert : 用于将一个对象插入列表
>>> a = [1, 2, 3, 4,5]
>>> a.insert(3, 'four')
>>> a
[1, 2, 3, 'four', 4, 5]
>>> # 和切片赋值的插入效果相同，但是可读性强。
>>> # pop : 出栈
>>> # pop 是唯一一个即修改列表，又返回一个非None值的列表方法
>>> a = [1, 2, 3]
>>> a.pop()
3
>>> a
[1, 2]
>>> b = a.pop()
>>> a
[1]
>>> b
2
>>> # pop 删除的是最后一个元素，可将append看成push()
>>> # remove ： 用于删除第一个为指定值的元素。
>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('to')
>>> x
['be', 'or', 'not', 'to', 'be']
>>> a = x.remove('be')
>>> a
>>> x
['or', 'not', 'to', 'be']
>>> # reverse : 按相反顺序排列列表中的元素
>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]
>>> # sort : 用于对列表就地排序。（不返回排序后的副本）
>>> x = [6, 4, 2, 1, 3, 5]
>>> x.sort()
>>> x
[1, 2, 3, 4, 5, 6]
>>> # 若想不就地排序，方式一是先将y关联到x的副本，然后对y进行排序
>>> x = [6, 4, 2, 1, 3, 5]
>>> y = x.copy()
>>> y.sort()
>>> y
[1, 2, 3, 4, 5, 6]
>>> a
>>> x
[6, 4, 2, 1, 3, 5]
>>> # 第二种方式是使用函数sorted
>>> # 函数sorted 对任何序列进行排序，总是返回一个列表。
>>> x = [6, 4, 2, 1, 3, 5]
>>> y = x.sorted()
Traceback (most recent call last):
  File "<pyshell#277>", line 1, in <module>
    y = x.sorted()
AttributeError: 'list' object has no attribute 'sorted'
>>> y = sorted(x)
>>> y
[1, 2, 3, 4, 5, 6]
>>> x
[6, 4, 2, 1, 3, 5]
>>> sorted('Python')
['P', 'h', 'n', 'o', 't', 'y']
>>> # 高级排序，sort有两个可选参数，key(类似于参数cmp)和reverse(需指定真值True 或 False 以指出是否要逆序）
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key = len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse = True)
>>> x
[9, 7, 6, 4, 2, 1]
>>> # 通常key被设置为一个自定义函数。

元组：不可修改的序列

元组和列表类似，最大的区别在于元组是不可修改的。元组创建简单，通常使用圆括号括起。大致就是这样。具体的细节看下面代码注释。

>>> 1, 2, 3
(1, 2, 3)
>>> # 元组用圆括号（）括起
>>> (1, 2, 3)
(1, 2, 3)
>>> ()
()
>>> # () 空元组
>>> # 只包含一个值的元组，需要在值后面加上逗号
>>> 42
42
>>> 42，
SyntaxError: invalid character in identifier
>>> 42,
(42,)
>>> (42)
42
>>> (42,)
(42,)
>>> 3 * (40 +2)
126
>>> 3 * (40 + 2,)
(42, 42, 42)
>>> # 函数tuple： 将一个序列作为参数，并将其转换成元组。如果参数已经是元组，就原封不动地返回它。
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((a,))
(None,)
>>> tuple((1, 2, 3))
(1, 2, 3)
>>>  ('a',)
 
SyntaxError: unexpected indent
>>> tuple(('a',))
('a',)
>>> # 元组通常做映射中的键，并且有些内置函数和方法也返回元组。

小结

• 序列
  一种数据结构，其中的元素带编号（从0开始）。列表，元组，字符串都属于序列。列表可变，元组和字符串不可变（一旦创建，内容就是固定的）。访问序列的一部分，可使用切片操作：提供两个指定切片起始和结束位置的索引。要修改列表，可给其元素赋值，也可使用赋值语句给切片赋值。
• 成员资格
  要确定特定的值，是否包含在序列中（或其他容器），可使用运算符in。将运算符in用于字符串时情况比较特殊——这样可以查找子串。
• 方法
  一些内置类型（如列表和字符串，但不包括元组）提供了很多有用的方法。方法有点像函数，只是与特定的值像关联。目前还没学到具体和函数的差别，以后再说。

本章学习的新函数

函数	描述
len(seq)	返回序列的长度。
list(seq)	将序列转换成列表。
max(args)	返回序列或一组参数中的最大值。
min(args)	返回序列和一组参数中的最小值。
reverse(seq)	让你能够反向迭代序列。
sorted(seq)	返回一个有序列表，其中包含指定序列中的所有元素。
tuple(seq)	将序列转换为元组。

这样列表和元组就学完了，加油！！！继续冲啊。嘿嘿♫