5种内置数据结构：列表、元组、字典、集合、字符串。列表、字典、字符串三种被称为线性结构。针对线性结构的操作有：切片、封包和解包、成员运算符、迭代。

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

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

基本框架如下：

一、列表：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 "", line 1, in

TypeError: 'tuple' object does not support item assignment #元素不可变

>>> t[1] = 'TEST'

Traceback (most recent call last):

File "", line 1, in

TypeError: 'tuple' object does not support item assignment #元素不可变

2. 元组元素是数字、列表时>>>t = (1, [2, 3], 4)

>>> t[1] = [4, 5]

Traceback (most recent call last):

File "", line 1, in

TypeError: 'tuple' object does not support item assignment #元组元素不可变

>>> t[1][1] = 5

>>> t

(1, [2, 5], 4) #列表仍然可变

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

本周的主要知识点如下：列表的初始化、基本的增删改查方法；

列表的分片处理

元组的初始化和基本方法