python的数据结构及基础的使用

前言

python的基本数据结构

• 列表：有序可变的对象集合
• 字典：无序的键/值对集合
• 元组：有序的不可变对象集合
• 集合：无序的唯一对象集合

列表

如果有大量相关对象需要存在代码的某个位置，可以使用列表来存储；列表是有中括号包围，列表中的每个对象需要用逗号分隔。
列表的存储格式：

list_1 = [0,1,2,3] 
list_2 = [1.56,3.1415,8.88,5.20]
list_3 = ['liu','a','ge']
list_4 = [[123,1],[1.56,3.1415],['liu','a','ge']]
list_5 = [{'a':1,'c':3},{'b':2}]

列表的常用方法：

list_1 = [0,2,3,2,4]

# 1. append 在列表后面追加对象
list_1.append(5)
print(list_1)
>>> [0,2,3,2,4,5]

# 2. pop 根据对象索引从现有的列表中删除一个对应并返回被删除的对象,没传索引则默认删除和返回列表最后一个对象
print(list_1.pop())
print(list_1)
>>> 4
>>> [0,2,3,2]

# 3. remove 从列表中删除第一次出现的指定对象，列表没有指定对象则会报错
list_1.remove(2)
print(list_1)
>>> [0,3,2,4]

# 4. insert 将一个对象插入列表的指定索引前面
list_1.insert(0,6) # 参数：0-插入指定的索引 1-插入对象
print(list_1)
>>> [6,0,2,3,2,4]

# 5. extend 指定一个列表去吞并另一个列表
list_1.extend([6,9])
print(list_1)
>>> [0,2,3,2,4,6,9]

list_1 = [0,2,3,2,4]
# 6. 列表切片方法 list[开始索引(start):结束索引(stop):索引步长(step)]
print(list_1[1:])
>>> [2,3,2,4]
print(list_1[:-1])
>>> [0,2,3,2]
print(list_1[::2])
>>> [0,3,4]
print(list[2:4])
>>> [3,2]

字典

字典的存储格式：

dict_1 = {'liu':'age' , 1:2 , '哈':'呵'}
dict_2 = {
    'list_1':[1,2,3],
    'dict_2_1':{'liu':'age' , 1:2 , '哈':'呵'}
}

字典的常用方法：

dict_1 = {'liu':'age' , 1:2 , '哈':'呵'}

# 1. 读取指定key的values
print(dict_1['liu'])
>>> age

# 2. setdefault 动态扩展字典，当指定字典中没有这个key时会在字典后面创建一个新的key:values
dict_1.setdefault('liu',0)
print(dict_1)
>>> {'liu':'age' , 1:2 , '哈':'呵'}
#---------------------------------------------------------------
dict_1.setdefault('py','thon')
print(dict_1)
>>> {'liu':'age' , 1:2 , '哈':'呵' , 'py':'thon'}

# 3. 遍历key和values
for k,v in dict_1.items():
    print(k,'-->',v)
>>> liu-->age
>>> 1-->2
>>> 哈-->呵

dict_1 = {'liu':'age' , 1:2 , '哈':'呵'}
# 4. 将key转为列表
print(list(dict_1))
>>> ['liu', 1, '哈']

# 5. 将values转为列表
print(list(dict_1.values()))
>>> ['age',2,'呵']

dict_2 = {'liu':94 , 'li':83 , 'wang':98 , 'fang':85}
# sorted 将字典按values排序并返回一个列表
# 倒叙
dict_2_desc = sorted(dict_2.items(),key=lambda item:item[1],reverse=True)
print(dict_2_desc)
>>> [('wang', 98), ('liu', 94), ('fang', 85), ('li', 83)]
# ------------------------------------------------------------
# 正序
dict_2_ase = sorted(dict_2.items(),key=lambda item:item[1])
print(dict_2_ase)
>>> [('li', 83), ('fang', 85), ('liu', 94), ('wang', 98)]

元组

元组的存储格式：

tuple_1 = (1,2,3,4,5)
tuple_2 = (('ha','he'),('哈','呵'),(1,2),(3,4))

# 读取元组对象
print(tuple_1[0])
>>> 1
# ------------------------
print(tuple[1][0])
>>> 哈

# 合并元组
print(tuple_1 + tuple_2)
>>> (1,2,3,4,5,('ha','he'),('哈','呵'),(1,2),(3,4))

# 遍历元组
for i in tuple_1:
    print(i)
>>> 1
>>> 2
>>> 3
>>> 4
>>> 5

集合

集合的存储格式：

set_1 = {1,2,3,4,5,6,5,4,3,2,1}

# 打印元祖
print(set_1)
>>> {1,2,3,4,5,6}

# add() 往集合中添加单个对象
set_1.add(7)
print(set_1)
>>> {1,2,3,4,5,6,7}

# update() 往集合中添加多个对象
set_1.update([8,9])
print(set_1)
>>> {1,2,3,4,5,6,8,9}

# remove() 删除集合中指定对象，对象不在集合中会报错
set_1.remove(5)
print(set_1)
>>>  {1,2,3,4,6}

# discard() 删除集合中指定对象，对象不存在不会报错
set_1.discard(5)
set_1.discard(7)
>>>  {1,2,3,4,6}

# union()合并两个集合
set_2 = ((6,7,8))
print(set_1.union(set_2))
>>> {1, 2, 3, 4, 5, 6, 7, 8}