数据结构

1. list(列表)

有序的可变序列 列表用于存储任意大小的数据集合, 可以是不同数据类型, 包括列表(嵌套)

关于初始化

copy
list=list("like u") #构造函数字符串创建列表
list1=[1,23,4,"i","forever",True] #方括号
list2=[x for x in range(1,11) if x>2] #列表推导式
# ['l', 'i', 'k', 'e', ' ', 'u']
# [1, 23, 4, 'i', 'forever', True]
# [3, 4, 5, 6, 7, 8, 9, 10]

#构造函数初始化list
_list = list((1, 2, 3)) #元组创建列表 [1, 2, 3]
_list = list({1, 2, 3}) # [1, 2, 3]集合创建列表
_list = list({"a" : 1, "b" : 2}) # ['a', 'b'] 字典创建列表
_list = list(x for x in range(1,10) if(x > 5)) # 列表推导式创建列表 [6, 7, 8, 9]

关于列表的访问

copy
a = list(x for x in range(1,11))
a.append(11)
a.insert(1, 'x') #下标为1的位置加入'x'
b = list(t for t in range(111,114))
a.extend(b)
#[1, 'x', 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 111, 112, 113]
a.remove('x')
a.pop(len(a) - 1)
del a[a.index(112)]
#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 111]
print(a.count(1)) #统计元素出现个数 1
a.reverse() #反转
a.sort() #默认正排序
a.sort(reverse=True) #逆排序

print(sorted(a)) #函数返回排序后的对象, 不改变操作对象, 也是默认正排序
print(sorted(a, reverse=True))
a.clear()


#sort函数补充
b = [["a", 15], ["b", 12], ["c", 10]] #拥有子列表的列表

def cmp(x):
    return x[1]
b.sort(key=cmp, reverse = True) #通过对比索引为1的元素进行sort, key为指定排序的依据
#[['a', 15], ['b', 12], ['c', 10]]
b.sort(key = lambda y: y[1]) #接受一个参数y 并返回y[1]
#[['c', 10], ['b', 12], ['a', 15]]

c = ['apple','dasdasdas','h1']
c.sort(key = len) #依据len进行排序
# ['h1', 'apple', 'dasdasdas']

k=[1,2,5,3,2,4]
k.sort(key=lambda x:x) #sort函数默认接受返回布尔类型的函数作为参数
k.sort(key=lambda x:-x)
# [1, 2, 2, 3, 4, 5]
# [5, 4, 3, 2, 2, 1]

2. tuple(元组)

有序的不可变序列 元组用于存储任意大小的数据集合, 可以是不同数据类型, 包括元组(嵌套)

关于元组的初始化

copy
a=(1) 
b=(1,) #加了逗号, 括号才被理解为元组的()
print(type(a)) #<class 'int'>
print(type(b)) #<class 'tuple'>

t1 = ("aa", )
t1 = tuple("aa")
t1 = (x for x in range(1, 10)) #默认为生成器对象<class 'generator'>
t1 = tuple(x for x in range(1,10))

元组的访问和遍历

简单的for遍历, 可以访问, 但是无法修改和删除, 这也是和列表最大的区别 因此其常用的成员函数较少

• .count(x)
• .index(x)
• .len()

ps: 当元组内放置一个列表, 该子列表可以进行修改

copy
m=(1,2,3,[4,5,6])
m[3][0]=5

3. 序列

序列是基本的数据结构, 常见的序列有, 字符串, 元组, 列表

序列的通用操作

切片

copy
str="0123456789"
# 切片[i:j:k] 操作并不会改变原来的序列, 只是返回一个新序列
# i 表示切片的开始, j 表示切片的结束, k 表示步长, 即打印每隔k步打印一次
print(str[0:len(str)]) # 等价于 
print(str[::])

print(str[1:5]) # 1234
print(type(str[1:3])) # <class 'str'>
print(str[4:1:-1])  # i > j 返回一个空序列, 若 k<0 即可配合倒序
str = str[::-1] #因此可以通过这种方式,将序列倒序
str = str[::-1][::-1] #get

连接和复制

copy
a = tuple(x for x in range(1,3))
b = tuple(x for x in range(4,6))
c = a + b #(1, 2, 4, 5) 
d = a * 3 #(1, 2, 1, 2, 1, 2)

成员检查

copy
d=tuple(x for x in range(1,6))
print(3 in d)
print(11 not in d)

内置函数

copy
d=tuple(x for x in range(1,7))
print(len(d)) # 6
print(max(d)) # 6
print(min(d)) # 1

序列的相互转换

copy
str="hi"
list_ = list(str)
tuple_ = tuple(str)
tuple_ = list(tuple_) #元组转列表
list_ = tuple(list_) #列表转元组

f = ['h','i',"nine","tse"]
e = ''
print(e.join(f)) # hininetse
print(str(f)) #['h', 'i', 'nine', 'tse']

关于str()函数

copy
print(str(10))  # 将整数转换为字符串 '10'
print(str(3.14) ) # 将浮点数转换为字符串 '3.14'
print(str([1, 2, 3]))  # 将列表转换为字符串 '[1, 2, 3]'
print(str(('a', 'b', 'c')))  # 将元组转换为字符串 "('a', 'b', 'c')"
print(str({'name': 'John', 'age': 25}))  # 将字典转换为字符串 "{'name': 'John', 'age': 25}"

4. dict(字典)

字典的创建

copy
#花括号创建字典
a = {"key1" : 1, "key2" : 2} # {'key1': 1, 'key2': 2}  
a["key1"] = 2 # {'key1': 2, 'key2': 2}


#函数创建字典
b = [("red",1),("green",3)]
c = dict(b) # {'red': 1, 'green': 3}
c = dict(red = 1, blue = 2) # {'red': 1, 'blue': 2}


#推导式创建字典
p = {x : x * 2 for x in range(1, 6)} # {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}
l = [("red", 1),("green", 3)]
p = {x : j for x, j in l} # {'red': 1, 'green': 3}

字典的更新

copy
map = {"sewerperson" : {"music" : 700, "sex" : "man"}, "nientail" : {"music" : 200, "sex" : "women"}}
map["ninetse"] = {"music" : 0, "sex" : "manman"} 

print(map.keys()) #dict_keys(['sewerperson', 'nientail', 'ninetse'])
print(map.values()) #dict_values([{'music': 700, 'sex': 'man'}, {'music': 200, 'sex': 'women'}, {'music': 0, 'sex': 'manman'}])
print(map.items()) #dict_items([('sewerperson', {'music': 700, 'sex': 'man'}), ('nientail', {'music': 200, 'sex': 'women'}), ('ninetse', {'music': 0, 'sex': 'manman'})])

for key in map: #直接遍历key
    print(f"key is {key}, value is {map[key]}")
#key is sewerperson, value is {'music': 700, 'sex': 'man'}
#key is nientail, value is {'music': 200, 'sex': 'women'}
#key is ninetse, value is {'music': 0, 'sex': 'manman'}

map.pop("ninetse") #直接清除key and value
del map["nientail"]
#{'sewerperson': {'music': 700, 'sex': 'man'}}

字典的复制和查询函数

copy
a = {"k1":1,"k2":9}
print(a.get("k1","404"))  # 1
print(a.get("k3"))        # None
print(a.get("k3","404"))  # 404


a = {"k1":1,"k2":9}
b = a
c = a.copy()
a["k1"] = 2
print(a) # {'k1': 2, 'k2': 9}
print(b) # {'k1': 2, 'k2': 9}
print(c) #{'k1': 1, 'k2': 9}

ps: 字典转为 list , tuple , set 都会只保留 key

5. set(集合)

可容纳不同类型 集合的特点是, 无序(元素位置和创建时不一), 不会出现重复元素

集合的创建

copy
s1 = {'black', "white", "blue", "blue", 1} # 花括号创建集合 {1, 'blue', 'white', 'black'}
s1 = set("ninetse") # set()函数创建 {'i', 't', 'n', 'e', 's'}

m1 = ['1', 2, 3, 4]
m2 = (1, 2, 3, "2")
s1 = set(m1) # {2, 3, 4, '1'}
s1 = set(m2) # {1, 2, 3, '2'}
s1 = set()   # set()

s1 = {i for i in range(1,11)} # 推导式创建 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

集合的访问: 由于set是无序的, 所以无法用下标访问, 但还是可以用for访问

集合的常用方法

copy
a = {1, 3, 3, 4}
a.add(9) # 添加
a.remove(9) # 移除, 不存在就报错
a.discard(5) # 移除, 不存在返回None
a.pop() #随即移除

b = {2, 9, 5, 3}
print(a.union(b)) #并集 {2, 3, 4, 5, 9}

print(a.difference(b)) # {4}
print(b.difference(a)) # {9, 2, 5}

print(9 in b) # True
print(10 not in b) # True

a.clear() # set()
del a   # 直接全删, 若再次调用会直接报错

ps : 在集合中, 还重载了 各类运算符, 如 <=, ==, !=, &(交集), |(并集), -(差集), ^(差集)