数据结构之列表

 

• 序列
• 序列的通用操作
• 列表的特性
• 列表的创建
• 列表的增删改查
• 列表的其他操作
• 列表的赋值，copy，深copy等

 

一：序列

---

 

 

在python中，序列（sequence）最基本的数据结构。序列中的每个元素都有编号，称为位置或索引，也有人称为下标。可以按照位置序号获取单个元素，也可以使用分片的方法获取多个连续的元素，这种特点，被称为有序性。python中的序列，第一个索引为0，第二个为1，以此类推。同时还支持负索引，用负数表示从序列末尾的元素位置，-1表示最后一个元素，-2表示倒数第二个元素。

 

python内置了几种序列，包括列表，元组和字符串等。

二：序列的通用操作

---

 

有几种操作，适用于所有的序列，包括：索引、切片、相加、乘法以及成员资格查询。另外python中提供了一些内置函数，可以对序列等元素进行操作，比如len,min,max等。

下面以字符串为例，介绍序列的常见操作

 

1.索引

 

序列中所有的元素都有编号--从0开始底递增，被称为索引(indexing)。可以通过索引直接访问序列中的某个指定元素。

 

>>> str='hello world'

>>> str[0]

'h'

>>> str[6]

'w'

 

字符串就是由字符字符组成的序列。所以可以通过索引访问到。用负数表示索引时，pythoh将从右向左开始数。

 

>>> str='hello world'

>>> str[-1]

'd'

 

 

2.切片

 

除了使用索引访问单个元素外，还可以使用切片（slicing)访问指定范围内的元素。其格式为使用两个索引，并且用冒号":"分割。

 

>>> str='hello world'

>>> str[0:4]

'hell'

 

也可以使用负索引指定切片位置

 

>>> str='hello world'

>>> str[3:-1]

'lo worl'

 

使用两个索引指定切片的边界，其中第一个索引的元素包含在切片内，但是第二个索引的元素不在切片内。俗称： 前包后不包。

 

然而，这样好像无法包含最后一个元素。切片中最后一个元素，可以通过元素索引值+1的方式得到，python提供了一种方式： 如果切片结束位于序列的末尾，省略第二个索引。

 

>>> str='hello world'

>>> str[-5:]

'world' '

 

 

同样的， 如果切片从索引0开始，可以省略切片的第一个索引。

 

>>> str='hello world'

>>> str[:5]

'hello'

 

 

如果切片第一个索引和第二个索引都省略了,得到的切片就是整个序列。

 

>>> str='hello world'

>>> str[:]

'hello world'

 

如果切片的第一个索引小于第二索引，会出现什么情况？事实上是得到一个空序列。

 

>>> str='hello world'

>>> str[-3:0]

''

 

在执行切片操作时，还有一个重要的参数：步长。一般来说，不指定步长表示步长为1，表示从一个元素偏移到下一个元素，因此，切片包含了所有指定的所有元素。

 

>>> str[1:6]

'bcdef'

 

若指定步长为2，从切片的起点到终点，每隔一个元素提取一个元素。

 

>>> str='abcdefg'

>>> str[1:6:2]

'bdf'

 

 

3.序列相加

 

可以使用加法运算拼接序列

 

>>> a = 'hello,'

>>> b = 'world!'

>>> a+b

'hello,world!'

 

 

4.乘法

 

将序列与数x相乘，将重复这个序列x次，返回一个新的序列。

 

>>> a = 'hello,world!'

>>> a * 5

'hello,world!hello,world!hello,world!hello,world!hello,world!'

 

 

5.成员检查

 

要检查指定的值是否包含在序列中，可使用运算符in.这是一个布尔运算符。返回Ture 或者 False。

 

>>> str = 'hello,world!'

>>>

>>>

>>> 'e' in str

True

>>> 'llo' in srt

True

>>> 'llox' in str

False

 

 

6.内置函数：长度、最小值和最大值

 

python内置函数len、min和max，可以用来返回序列的长度(元素数)、最小值和最大值。

 

>>> str = 'abcdefg'

>>> len(str)

7

>>> min(str)

'a'

>>> max(str)

'g'

 

 

min 和 max除了可以返回序列的最大值和最小值之外，还可以对几个数字进行比较

 

>>> min(1,3,4)

1

>>> max(2,4,5)

5

>>>

 

 

三：列表

---

 

 

python的列表是一个序列，用中括号表示，每个元素的值用逗号分开。

同时，列表是一个"容器"，列表内的每一个元素，可以是其他类型的对象，比如可以是数字，字符串或字典，可以在列表内嵌套列表。python中，“容器”的数据类型，除了列表之外，还有元组和字典等等。

相对于字符串和元组，列表还有一大特点，就是本地可修改。

 

总结一下，列表具备的三大特性：

 

• 有序性（序列）
• 异构性（容器）
• 本地可修改

 

 

1.列表的创建

    1）赋值

    2）list函数：list函数接收一个序列，生成一个包含序列中元素的列表

 

>>> lst=['a','b']

>>> lst2 = list('hello')

>>> lst

['a', 'b']

>>> lst2

['h', 'e', 'l', 'l', 'o']

 

2.列表特性之序列特性

 

列表作为一个序列，具备序列的特性，即：

•     索引
•     切片
•     相加
•     乘法
•     成员检查
•     长度、最大值和最小值

 

1)索引

通过索引，返回列表中索引指定的元素

 

>>> lst = [1,3,4]

>>> lst[0]

1

>>> lst[-1]

4

 

 

 

2)切片

列表的切片操作，返回一个包换指定元素的列表

 

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

>>> lst[2:5]

[3, 4, 5]

>>> lst[2:5:2]

[3, 5]

>>> lst[2:-1]

[3, 4, 5, 6, 7]

>>> lst[4:0]

[]

 

3)列表相加

两个列表相加，返回一个按照顺序包含两个列表所有元素的新列表

 

>>> lst_a=[1,2,3]

>>> lst_b=[4,5,6]

>>> lst_a+lst_b

[1, 2, 3, 4, 5, 6]

>>>

 

4)列表的乘法

将列表与数x相乘，将重复这个列表x次，返回一个新的列表。

 

>>> lst= [1,2,3]

>>> lst * 5

[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

 

 

5)成员检查

检查某个指定元素是否在列表中

 

>>> lst = ['hello','world']

>>> 'hell' in lst

False

>>> 'hello' in lst

True

 

 

6)列表的长度、最大值和最小值

 

>>> lst= [1,2,3]

>>> len(lst)

3

>>> min(lst)

1

>>> max(lst)

3

>>>

 

需要注意的是，python中的min和max，必须是同类型才可以

 

>>> lst = ['a','b',1,3]

>>> min(lst)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: '<' not supported between instances of 'int' and 'str'

 

 

可以通过内置函数的key=func传递参数，强制类型转换

 

>>> lst = ['a','b',1,3]

>>> min(lst,key=str)

1

 

 

3.列表特性之容器

    

列表内的每一个元素，可以是其他类型的对象，比如可以是数字，字符串或字典，可以在列表内嵌套列表

 

>>> lst = ['abc',1,2,['hello',{'key1':'value1','key2':'value2'},23]]

>>> lst

['abc', 1, 2, ['hello', {'key1': 'value1', 'key2': 'value2'}, 23]]

 

 

4.基本列表操作

 

1）通过索引修改列表

 

通过对列表索引的元素赋值，可以修改列表； 索引不能超界。

>>> lst = [1,2,3]

>>> lst[0]

1

>>> lst[0] = 100

>>> lst

[100, 2, 3]

 

 

2）通过对切片的赋值，可以同时对列表的多个元素赋值

 

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

>>> lst[0:3] = [11,12,13]

>>> lst

[11, 12, 13, 4, 5, 6]

>>>

 

 

切片赋值对象，必须为一个序列。

 

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

>>> lst[0:1]=[111]

>>> lst

[111, 2, 3, 4, 5, 6]

>>> lst[0:1]=1100

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: can only assign an iterable

>>> lst

[111, 2, 3, 4, 5, 6]

>>> lst[0:2]='xy'

>>> lst

['x', 'y', 3, 4, 5, 6]

 

 

 

对列表赋值这个过程可以理解为：将列表中切片所在的元素清空，将新的元素插入进列表；所以，新的元素数量可以与切片的元素数量不同。

以此可以实现更强大的功能，比如，对列表增加元素、删除元素

 

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

>>> lst[0:3] = [11,12]

>>> lst

[11, 12, 4, 5, 6]

>>> lst[0:4] = [11,12,13,14,15,16]

>>> lst

[11, 12, 13, 14, 15, 16, 4, 5, 6]

 

通过切片，对列表增加元素

>>> lst

[1, 2, 3, 4, 5, 6]

>>> lst[3:3] = [44]

>>> lst

[1, 2, 3, 44, 4, 5, 6]

 

 

通过切片，删除列表某个元素

 

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

>>> lst[0:1] = []

>>> lst

[2, 3, 4, 5, 6]

 

 

5：列表本地可修改特性

 

 

本地可修改，“本地”指的是内存地址，对列表中元素的增加、删除、修改等，不需要另外开辟新的内存空间， 而是 原来的内存地址上直接修改列表对象。这个叫“本地可修改 ” 。

序列类型中，字符串和元组，不可以被修改，列表可以。比如，可以通过索引或切片，对列表进行修改。另外列表也提供了很多方法，对列表进行修改。

在python中，创建一个字符串变量后，字符串就不可以被修改了；若需要修改字符串，需要对变量重新赋值，即字符串变量指向新的内存区域。

 

>>> string = 'Hello,world.'

>>> id(string)

4471588656

>>> string = 'hello,world.'

>>> id(string)

4471588768

 

 

在python中，id可以用来查看对象的内存地址；上面的代码可以看到，对string重新赋值，内存地址发生变化；

对修改列表而言，列表本身不需要开辟新的内存地址，而是在原来的地址上直接修改。

>>> lst = ['Hello','World']

>>> id(lst)

4471429024

>>> lst[0] = 'hello'

>>> id(lst)

4471429024

 

6.列表的方法

 

方法	说明	参数	返回值
append	列表尾部追加一个对象	(object)	None
extend	将对象迭代后，追加到列表尾部	(iterable)	None
insert	指定位置，插入对象	(index, object)	None
pop	弹出一个对象，不指定index，弹出最后一个对象	([index])	弹出对象
remove	删除列表中第一个出现的value元素	(value)	None
index	查找列表中第一个value元素的索引	(value, [start, [stop]])	index
count	查找列表中元素为value的个数	(value)	数字
reverse	将列表就地反转	()	None
sort	将列表就地排序,key指定函数，reverse是否反转	(key=None, reverse=False)	None
clear	清除列表	()	None
copy	copy一个列表，等效于list[:]	()	新列表

 

7.列表的其他操作

 

部分内置函数及其他方法，可以对列表进行操作

 

方法		参数	返回
sorted	对列表进行排序,返回新的列表，原列表不变	sorted(iterable, /, *, key=None, reverse=False)	新的对象
reversed	对列表进行反转，返回新的列表，原列表不变	reversed(self, /, *args, **kwargs)	新的对象
len	列表的长度	len(obj)	int
random.shuffle	将列表就地乱序	random.shuffle(list, random=None)	None

 

 

8.列表的copy

 

存在一个列表lst，若"copy"此列表，可以有以下几种方式：

• lst2 = lst
• lst2 = lst[:]
• lst2 = list(lst)
• lst2 = list.copy()

    

lst2 = lst1 这个方法，并不能算是copy一个列表。lst2 和 lst 其实是一个列表，所以对lst的修改，也会改变lst2.

下面三种，效果都一样，都是重新开辟并指向一个内存，并将lst的列表复制一份到新的内存地址中，所以，修改lst不会影响到lst2

需要注意的是，若列表lst1中的某个元素(lst1[2])是列表(方面描述，称呼为sublst)，其实并不是把subst的内存存在列表里，而是lst1存放的事sublst的内存指向，lst1[2] = sublst 。当进行list.copy()操作时，相当于是做了lst2[2] = lst1[2]的操作，，，所以，对于sublst而言，自身并没有被赋值，只是两个列表（lst1,和 lst2）的某个元素都指向了自己，所以，在lst1中，对sublst（lst1[2]）的操作会改变lst2[2]的值。

 

对于其他容器类型的数据结构而言，都是一样的情况。

 

python中有一个模块，可以对列表进行深度copy，即若凡是列表中的某个元素为列表，会将嵌套的列表复制一份。

 

 

 

>>> import copy

>>> lst2 = copy.deepcopy(lst1)

 

 

 

 

 

转载于:https://www.cnblogs.com/dingtianwei/p/9437893.html