您的位置:首页 > 理论基础 > 数据结构算法

python课程第二周 内置数据结构——列表和元组

2016-12-13 12:44 405 查看
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 "<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)       #列表仍然可变
元组通常用于处理具有固定关系的情况,在某些要求不可变内容的情形下应用。

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

列表的分片处理

元组的初始化和基本方法
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签:  list python tuple