5种内置数据结构：列表、元组、字典、集合、字符串。列表、字典、字符串三种被称为线性结构。

  • 针对线性结构的操作有：切片、封包和解包、成员运算符、迭代。

  • 针对数据结构的操作有解析式：解析式分为列表解析、生成器解析、集合解析和字典解析。

后面三种是Python3.x特有的。

基本框架如下：

wKiom1hPZYyjPAdMAABQd-R_pqE050.png

一、列表：Python中最具灵活性的有序集合对象类型

列表可包含任何种类的对象：数字、字符串、字典、集合甚至其他列表，这个特性称为异构。还具有可变长度和任意嵌套的特性，属于可变长度序列。

（1）列表的初始化，有两种方式，第一种使用list()函数，第二种直接使用空列表赋值：

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

（2）列表元素的访问，主要通过列表的下标和索引。元素的下标从0开始。如果给出的下标超出下标范围，会给出IndexError错误。也支持逆向访问列表内部元素，下标从-1开始，同时支持序列的分片操作。

>>>lst[0]  访问第一个元素
1
>>>lst[-1]        访问最后一个元素，逆序访问
3
>>>lst[2]          访问最后一个元素
3
>>>lst[0:] 访问第一个到最后一个元素
[1,2,3]

（3）列表的方法：

增

append(object)     #给列表添加一个对象object，返回值是None

insert(index,object) #给列表添加一个对象object，但是可以根据index确定插入位置，返回值None

extend(iterable) #从迭代器中添加元素到列表中

下面是几个示例：

lst=[5,2,10]

索引是在列表索引范围内，正常插入：

>>>lst.insert(0,7)
>>>lst
[7,5,2,10]

索引超出列表的范围，在最后插入：

>>>lst.insert(100,13)
>>>lst
[7,5,2,10,13]

索引使用负值且在正常索引范围内，从后往前插入：

>>>lst.insert(-1,12)
>>>lst
[7,5,2,10,12,13]

索引使用负值但是超出索引范围，从最开始插入：

>>> lst.insert(-100,20)
>>> lst
[20, 7, 5.2, 10, 12, 13]

从迭代器中添加元素

>>>lst.extend([1,2,3])
>>>lst
[20, 7, 5.2, 10, 12, 13,1,2,3]

删

pop(index)  #根据索引index将列表中的某个元素移除并返回这个元素，如果没有给出index，返回最后一个元素。如果列表为空或者索引超出范围，则给出IndexError错误。

lst=[5,2,10]
>>>lst.pop()
10
>>lst
[5,2]
>>>lst.pop(0)
5
>>>lst
[2]
>>>lst.pop(-1)
2
>>>lst
[]

remove(value) #根据value值删除list中的一个元素value，如果value不存在，会提示ValueError，返回值None

>>>lst=[5,2,10]
>>>lst.remove[10]
>>>lst
[5,2]

clear() #清除list中所有的元素，返回值None。

>>>lst.clear()
>>>lst
[]

del L[k]

del L[i:j] 根据索引删除指定值或者删除某个范围内的值

>>> lst=[1,2,3,4,5,6]
>>> del lst[2]
>>> lst
[1, 2, 4, 5, 6]
>>> del lst[0:2]
>>> lst
[4, 5, 6]

改

reverse() #将list中的元素反转

sort(key=None, reverse=False) #将list中的元素有序排列，reverse为True时，将list逆序排列，key是个函数对象，使用该函数对list进行排序。排序后返回None。

L[k] = n   #根据列表索引来修改对应位置的值

示例如下：

>>>lst= [5, 2, 10]
>>>sort(lst)#排序
>>>lst
[2,5,10]
>>>reverse(lst)   #倒转
>>>lst
[10,5,2]
>>>lst[0] = 100#索引改值
>>>lst
[100, 2, 10]

查

index(value,[start,[stop]])   #根据value值，返回start和stop索引范围内第一次出现value的索引，value不存在时返回ValueError。

>>>lst= ['a','b','c','d','e']
>>>lst.index('a')
0
>>>lst.append('b')
>>>lst.index('b',0,4)
1

count(value) #根据value值返回列表中value的个数，返回值是整数

>>>lst.count('b')
2

len(object,/)   #返回列表中的元素个数

>>>len(lst)
6

其他方法

copy()  #返回list的一个副本。


切片操作

基本格式：seq[start:stop:step]，输出的内容是[start,stop)，step指的是隔几个数取一个值，看下面示例。

>>>lst=[1,2,3,4,5,6,7,8]
>>>lst[0:8]
[1,2,3,4,5,6,7,8]
>>>lst[0:8:2]
[1,3,5,7]

因为一般情况下切片操作是从左往右，因此start一定要小于stop，否则只能得到一个空数组。

>>>lst[7:5]
[]

特殊情况下，例如step<0时，例如：

当start>stop时，step=-1，输出(stop,start]

>>>lst[5:1:-1]
[6,5,4,3]

当start或stop超出索引范围时（step>0），分为4种情况：

1. start超出索引，stop没有超过索引，同时start的绝对值大于列表长度时，从索引0开始输出一直到索引stop-1

>>>lst=[1,2,3,4,5,6,7,8]   #列表长度为8
>>>lst[-10:5]
[1,2,3,4,5]

2. start超过索引，stop没有超过索引，同时start的绝对值小于列表长度时，取值范围是[len(lst)+start, stop]

>>>lst[-5:5]             #取值范围是[8-5,5]，即[3,5]
[4,5]

2. stop超出索引，start没有超过索引从start开始输出，直到最后一个元素停止

>>>lst[3,100]
[4,5,6,7,8]

3. 当start和stop同时超出索引时，start绝对值大于数组长度，输出seq第一个到最后一个元素。

>>> lst[-100:100]
[1, 2, 3, 4, 5, 6, 7, 8]

4. 当start和stop同时超出索引时，start绝对值小于数组长度时，取值范围是[len(lst)+start:]

>>>lst[-5:100]
[4,5,6,7,8]


切片操作支持省略start或stop：

当start省略时，从索引0开始输出，到stop-1停止

>>>lst[:5]
[1,2,3,4]

当stop省略时，从start开始，到最后一个元素停止

>>>lst[3:]
[4,5,6,7,8]

当start和stop都省略时，输出seq所有元素。

lst[:]
[1, 2, 3, 4, 5, 6, 7, 8]


元组（tuple）：不可变的数据结构，位置有序的对象的集合。

通常写成圆括号中的一系列项，虽然元组不支持任何方法调用，但具有列表的大多数属性。

  • 通过偏移和索引存取

  • 属于不可不序列类型

  • 固定长度，不能伸长或缩短，异构，可以包含其他复合对象，支持嵌套。

  • 对象引用的数组，对元组进行索引操作的速度相对较快。

1. 元组的定义

t=()   #空元组
t=tuple()  #空元组
t=（1，2，3）#3个元素的元组，索引只能用来访问元素
t=（1，） #定义单个元素的元组时，需要在元素后面加个逗号，否则t就是一个数字。


2. 元组的方法

t.count(value)                    #返回元组内某个元素个数
t.index(value,[start,[stop]])     #返回元素value第一次出现的索引
t[i]、t[i:j]                      #根据索引来访问元素，根据分片和长度来访问元素
t1+t2、t * 3                      #合并和重复

*元组的不可变性只有一层，即元组的元素是单层或不可变元素时，例如数字、字符，元组元素不可变，但元组的元素是多层可变元素时，该元素自身不能被改变，而元素内部值可变，例如列表，下面请看示例：

1. 元组元素是数字和字符串时

>>>t = ( 1, 'test', 4)
>>> t[0] = 'a'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment    #元素不可变
>>> t[1] = 'TEST'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment   #元素不可变

2. 元组元素是数字、列表时

>>>t = (1, [2, 3], 4)
>>> t[1] = [4, 5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment   #元组元素不可变
>>> t[1][1] = 5
>>> t
(1, [2, 5], 4)       #列表仍然可变

元组通常用于处理具有固定关系的情况，在某些要求不可变内容的情形下应用。


本周的主要知识点如下：

  1. 列表的初始化、基本的增删改查方法；

  2. 列表的分片处理

  3. 元组的初始化和基本方法