Python基础编程（二）列表和元组

2.1序列概览

列表和元的主要区别在于，列表可以修改，元组则不能。

也就是说如果要根据要求来添加元素，那么列表可能会更好用；出于某些原因，列表不能修改的时候，使用元组则更为合适。

2.2 通用序列操作

所用序列类型都可以进行某些特定的操作。这些操作包括：索引、分片、加、乘以及检查某个元素是否属于序列的成员（成员资格）。除此之外，Python还有计算序列长度、找出最殴打元素和最小元素的内建函数。

2.2.1 索引

使用负数索引时，Python会从右边，也就是从最后1个元素开始计数。最后1个元素的位置编号是-1（不是-0.以为那会和第1个元素重合）：

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

如果一个函数调用返回一个序列，那么可以直接对返回结果进行索引操作。

>>>fourth = raw_input("year: ")[3]
year: 2005
>>>fourth
'5'

2.2.2 分片

使用分片操作来访问一定范围内的元素。分片通过冒号相隔的两个索引来实现：

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

第1个索引是需要提取部分的第1个元素的编号，而最后的索引则是分片之后剩下部分的第1个元素的编号。

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

1. 优雅的捷径

假设需要访问最后3个元素：

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

索引10指向的是第11个元素——这个元素并不存在，确是在最后一个元素之后。

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

如果分片所得部分包括序列结尾的元素，只需置空最后一个索引即可。

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

2. 更大的步长

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

步长不能为0，那不会向下执行。但步长可以是负数，及从右到左提取元素：

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

2.2.3 序列相加

通过使用加号可以进行序列的连接操作：

列表和字符串是无法连接在一起的，尽管他们都是序列。简单来说，两种相同类型的序列才能进行连接操作。

2.2.4 乘法

>>>'Python'*5
'PythonPythonPythonPythonPython'
>>>[42]*10
[42,42,42,42,42,42,42,42,42,42]

None、空列表和初始化

None是一个Python的内建值，它的确切含义是：”这里什么也没有“。用于初始化空列表。

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

2.2.5 成员资格

为了检查一个值是否在序列中，可以使用in运算符。

这个运算符检查某个条件是否为真，然后返回相应的值：真True，假False。这样的运算符叫布尔运算符，而真值则叫做布尔值。

>>>permissions = 'rw'
>>>'w' in permissions
True
>>>'x' in permissions
False

2.2.6 长度、最小值和最大值

内建函len、min和max非常有用。len函数返回序列中所包含元素的数量，min函数和max函数分别返回序列中最大和最小的元素。

2.3 列表

2.3.1 list函数

因为字符串不能像列表一样被修改，所以有时根据字符串创建列表会很有用。list函数可以实现这个操作：

>>>list('Hello')
['H','e','l','l','o']

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. 分片赋值

在使用分片赋值是，可以使用与原序列不等长的序列将分片替换：

>>>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]

通过分片赋值来删除元素：

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

2.3.3 列表方法

一般来说，方法可以这样进行调用：

对象.方法（参数）

1.append

append方法用于在列表末尾追加新的对象：

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

apppend和其他方法类似，只是在恰当的位置修改原来的列表。这意味着，他不是简单的返回一个修改过的新列表——而是直接修改原来的列表。

2. count

count方法统计某个元素在列表中出现的次数：

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

3. extend

extend方法可以在列表的末尾一次性追加另一个序列中的多个值。换句话说，可以用新列表扩展原有的列表：

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

这个操作看起来很像连接操作，两者最主要的区别在于：extend方法修改了被扩展的序列。而原始的连接操作则不然，他会返回一个全新的列表：

4. index

index方法用于从列表中找出某个值第一个匹配项的索引位置：

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

5. insert

insert方法用于将对象插入到列表中：

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

与extend方法一样，insert方法的操作也可以用分片赋值来实现，但他的可读性绝对不如insert方法。

6.pop

pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值：

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

pop方法是唯一一个既能修改列表又返回元素值（除了None）的列表方法。

使用pop方法可以实现一种常见的数据结构——栈。栈的基本操作为入栈（push）和出栈（pop）。

Python没有入栈的方法，饭可以使用append方法来代替。pop方法和append方法的操作结果恰好相反，如果入栈（或者追加）刚刚出栈的值，最后得到的结果还是原来的栈。 

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

7. remove

remove方法用于移除列表中某个值的第一个匹配项：

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

remove是一个没有返回值的原位置改变方法。他修改了列表却没有返回值，这与pop方法相反。

8. reverse

reverse方法将列表中的元素反向存放(无返回值)：

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

9. sort

sort方法用于在原位置对列表进行排序。

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

在”原位置排序“意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单的返回一个已排序的列表副本。

当用户需要一个排好序的列表副本，同时又保留原有列表不变的时候，问题就出现了。因为sort的返回值为None。

实现这个功能的正确方法是，首先把x的副本赋值给y，然后对y进行排序：

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

再次调用x[:]得到的是包含了x所有元素的分片，这是一种很有效率的复制整个了列表的方法，只是简单地把x赋值给y是没用的，因为这样做就让x和y都指向同一个列表了：

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

另一种获取已排序的列表副本的方法时，使用sorted函数：

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

10.高级排序

如果希望元素能按照特定的方式进行排序，可以通过compare（x,y）的形式自定义比较函数。

>>>cmp(42,43)
1
>>>cmp(99,100)
-1
>>>cmp(10,10)
0

定义好函数后，就可以提供给sort方法作为参数了。内建函数cmp提供了比较函数的默认实现方式：

>>>numbers = [5,2,9,7]
>>>numbers.sort(cmp)
>>>numbers
[2,5,7,9]

关键字参数ley，参数key与参数cmp类似，必须提供一个在排序过程中使用的函数。该函数并不是直接用来确定对象的大小，而是为每个元素创建一个键，然后所有元素根据键来排序。

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

关键字reverse是简单的布尔值，用来指明列表是否要进行反向排序。

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

2.4 元组：不可变序列

元组与列表一样，也是一种序列。唯一的不同是元组不能修改。

创建元组的语法很简单：如果你用逗号分隔了一些值，那么你就自动创建了元组。

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

如果是一个只包括一个值的元组，必须加个逗号，即使只有一个值。

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

2.4.1 tuple函数

tuple函数的功能与list函数基本上是一样的：以一个序列作为参数并把它转化为元组。如果参数就是元组，那么该函数就会被原样返回：

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

2.4.3元组的意义

元组可以在映射（和集合的成员）中当做键使用，而列表则不行。

元组作为很多内建函数和方法的返回值存在，也就是说你必须对元组进行处理。只要不尝试修改元组，那么”处理“元组在绝大多数情况下就是把它们当做列表来进行操作。

一般来说，列表可能更满足对序列的所有需求。

 

转载于:https://www.cnblogs.com/cj942132427/p/3843371.html