Python数据结构之基础数据结构

2.列表索引、查询、修改、扩展
列表list:
连续、有序、适合查询
链表：有序、适合增删
queue：先进先出
栈：后进先出
2.1 列表初始化

l1 = []
l2 = [1,2,'1,b,c']
l3 = list()
l4 = list(range(1,5))

列表中的元素可以是任何合法的元素，包括它自己

2.2 列表的索引

l6 = list(range(1,10))
l6
[1, 2, 3, 4, 5, 6, 7, 8, 9]
正索引：
l6[0]-》0
l6[8]-》9
负索引：
l6[-1]-》9
l6[-9]-》1

l6[9]
IndexError                                Traceback (most recent call last)
C:UsersXIANNI~1AppDataLocalTemp/ipykernel_520/4070285574.py in <module>
----> 1 l6[9]

IndexError: list index out of range


---------------------------------------------------------------------------
l6[-10]
IndexError                                Traceback (most recent call last)
C:UsersXIANNI~1AppDataLocalTemp/ipykernel_520/1548850741.py in <module>
----> 1 l6[-10]

IndexError: list index out of range

以上说明：索引下标越界

2.3 列表赋值操作

l6[-1] = l6[-1] +10
l6
[1, 2, 3, 4, 5, 6, 7, 8, 19]

以上赋值操作：将l6[-1]的数拿出来加上10，然后再赋值给l6[-1]
赋值操作不会引起数值的移动

2.4 通过数值找索引

l6.index(19) ->8
l6.index(1) -> 0
l6.index(30)
ValueError                                Traceback (most recent call last)
C:UsersXIANNI~1AppDataLocalTemp/ipykernel_520/3145308472.py in <module>
----> 1 l6.index(30)

ValueError: 30 is not in list

以上错误是没有找到这个值

l7 = [1,2,3,1]
l7.index(1) ->0 -》时间复杂度O(n)

以上说明，通过索引找值是从左往右找

2.5 统计

l7 = [1,2,3,1]
l7.count(1) ->2

时间复杂度为O(n) ->非常低效的

2.6 长度

len(l7) #list长度属性，加元素+1，减元素-1 ，时间复杂度：O(1)
4

2.6 追加
append()
尾部追加，一次在尾部追加一个
返回值是None，意味着没有新的列表产生，即就地修改
时间复杂度：O(1)
元素的个数是可变的

l7.append(10) # 尾部追加，返回值是None
l7
[1, 2, 3, 1, 3, 10]

insert()
在指定的索引index插入元素object
返回值是None，意味着没有新的列表产生，即就地修改
时间复杂度O(n)
超越上界，尾部追加
超越下界，头部追加

l7.insert(1,89)
l7
[1, 89, 2, 3, 1, 3, 10, 10]
l7.insert(100,1000)
l7
[1, 89, 2, 3, 1, 3, 10, 10, 1000]
l7.insert(-100,1000)
l7
[1000, 1, 89, 2, 3, 1, 3, 10, 10, 1000]

2.6 扩展
extend(可迭代对象)
返回值是None，意味着没有新的列表产生，即就地修改
将可迭代对象追加进来，目前可迭代对象只有range()和列表本省

l7.extend(range(100,105))
l7
[1000, 1, 89, 2, 3, 1, 3, 10, 10, 1000, 100, 101, 102, 103, 104]
l7.extend([301,302,303])
l7
[1000, 1, 89, 2, 3, 1, 3, 10, 10, 1000, 100, 101, 102, 103, 104, 301, 302, 303]

**2.6 列表 + **
列表 + ——> 返回list
连接操作，将两个列表

 l7 + [1,2,3] ->生成一个新的列表
 l7本身没有改变

**2.7 列表 * **
列表 * ——>返回list
将本列表元素重复n次，返回新的列表连接起来
产生新的列表，原列表不变

l9 = [0,1,2] *3
l9
[0, 1, 2, 0, 1, 2, 0, 1, 2]

——列表和字典是最常用的
列表相乘就是将列表中元素拿出来重复多少次生成一个新的列表，新的列表可以用一个变量赋值一下，不用变量就临时生成一下

la = [1,[2,3],4]
lb = la.copy()
la
[1, [2, 3], 4]
lb
[1, [2, 3], 4]
la[0] = 1
la == lb
True
la[1][1] = 200 #改引用类型中的元素

简单类型：copy()
引用类型：cpoy()的是地址
浅拷贝，只拷贝第一层
即
la = [1,[2,3],4,‘abc’] #引用，表示地址 [1,101房间号码，4，‘abc’]
lb = la.copy() #生成一个新的列表[1,101房间号码，4，‘abc’]

列表复制
shadow copy ：影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已，浅拷贝指向的是同一个地址

lc = [[1,2,3]] *3 #浅拷贝
lc, len(lc)
([[1, 2, 3], [1, 2, 3], [1, 2, 3]], 3)
lc[2][2] = 300
lc
[[1, 2, 300], [1, 2, 300], [1, 2, 300]]

深拷贝：copy模块提供了deepcopy，深拷贝就是在内存中又创建了一个地址，会深入到列表里面去，将里面的元素复制一份

import copy
la = [1,[2,3],4]    #引用，表示地址[1,101房间号码，4，'abc'] 
lb = copy.deepcopy(la)      #深复制[1, 502房间的号码，4，'abc']
la
[1, [2, 3], 4]
lb
[1, [2, 3], 4]
la[1][1] = 200
la == lb  #元素相等？
False

2.8 列表删除元素
remove(value) -> value
从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改
remove使用通过值来查找，没有找到就抛出值异常

l4 = [1, 2, 3, 4, 3, 2, 1]
l4.remove(2) #时间复杂度为O(n) 后面数据的挪动，除非你正好是最后一个
l4
[1, 3, 4, 3, 2, 1]
l4.remove(5) #拿值来匹配

ValueError                                Traceback (most recent call last)
C:UsersXIANNI~1AppDataLocalTemp/ipykernel_14656/3719114338.py in <module>
----> 1 l4.remove(5)

ValueError: list.remove(x): x not in list

pop([index]) ->item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误

l4.pop(3) #使用索引来匹配
3
l4.pop()
1
l4.pop(5)
IndexError                                Traceback (most recent call last)
C:UsersXIANNI~1AppDataLocalTemp/ipykernel_14656/2394347312.py in <module>
----> 1 l4.pop(5)

IndexError: pop index out of range

clear() ->None
清除列表所有元素，剩下一个空列表

l4.clear() #这些元素不要了，引用计数都减1
l4
[]

清理对象使用JC（垃圾回收）

reverse() ->None
将列表元素反转，返回None
就地排序

l4 = [1, 2, 3, [1]]
l4.reverse()
l4
[[1], 3, 2, 1]

sort(key =None, reverse = False) ->None
sort在比较大小时，不同类型的数据是不能进行比较的
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序

l4
[3, 2, 1, 4, 5, 6, 7, '8']
l4.sort()
TypeError                                 Traceback (most recent call last)
C:UsersXIANNI~1AppDataLocalTemp/ipykernel_14656/1892640535.py in <module>
----> 1 l4.sort()

TypeError: '<' not supported between instances of 'str' and 'int'
l4.sort(key = int) #将列表中所有元素用int转换成整型
l4.sort(key = int, reverse = True)  #key仅仅用在比较时，并不影响元素本身，默认升序（False），如果要降序则将revser = True
l4
['8', 7, 6, 5, 4, 3, 2, 1]

in
[3, 4] in [1, 2, [3, 4]]
for x in [1,2,3,4]

4.随机数、元组、元组命名
首先要导入import random
随机获取一个数random.randint(1,2)
从一个列表中随机选择一个数出来

lst = list(range(1,10))
for i in range(10):
    print(random.choice(lst))

最后

以上就是忧伤煎蛋为你收集整理的Python数据结构之基础数据结构的全部内容，希望文章能够帮你解决Python数据结构之基础数据结构所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。