[数据结构与算法]python常用数据结构

列表

python中可以通过组合一些值得到多种复合数据类型
列表是其中最常用的数据结构
列表通过方括号括起来，逗号分隔的一组值
一个列表可以包含不同类型的元素，但通常使用时各个元素类型相同

"""
list.append(x)
在列表的末尾添加一个元素。相当于a[len(a):] = [x]
"""
list_a = [1, "a", 2]
list_a.append(3)
list_a.append(4)
list_a.append(5)
print(list_a)
[1, 'a', 2, 3, 4, 5]

"""
list.insert(i,x)
在给定的位置插入一个元素
第一个参数是要插入的元素的索引
a.insert(0,x)插入列表头部，a.insert(len(a),x)  等于 a.append(x)
"""
list_b = [1, 2, 3]
list_b.insert(1, 0)
print(list_b)

"""
list.remove(x)
移除列表中第一个值为x的元素
如果没有这样的元素，则抛出valueerror异常
"""
list_a = [1, 2, 3]
list_a.remove(2)
print(list_a)
[1, 3]

"""
list.pop([i])
删除列表中给定位置的元素并返回它，索引，指定返回值
如果没有给定位置，a.pop（）将会删除并返回列表中的最后一个"""
list_a = [1, 2, 3]
a = list_a.pop(0)
print(list_a)
print(a)
[2, 3]
1

"""
list.sort(key=None,reverse=False):
对列表中的元素进行排序
"""
list_a = [1, 4, 5, 0]
list_a.sort()
print(list_a)
[0, 1, 4, 5]

list_a = [1, 4, 5, 0]
list_a.sort(reverse=True) # 降序
print(list_a)
[5, 4, 1, 0]

"""
list.reverse()
反转列表中的元素
"""
list_a = [1, 2, 3, 4]
list_a.reverse()
print(list_a)
[4, 3, 2, 1]


"""
list.clear()	删除列表中所有的元素
list.count(x)返回元素x在列表中出现的次数
list.copy()返回列表的一个浅拷贝 
注意：
insert，remove，sort
只修改列表，没有打印出返回值
返回值为none，这是python中所有可变数据结构的设计原则
"""



"""
列表推导式
生成一个平方列表 【1，4，9...】
"""
list_a = []
for i in range(1, 4):
    list_a.append(i**2)

print(list_a)
[1, 4, 9]

list_a = []
list_a = [i**2 for i in range(1, 4)]
# 循环后执行i**2
print(list_a)

list_a = []
for i in range(1, 4):
    if i != 1:
        list_a.append(i**2)

print(list_a)

list_a = [i**2 for i in range(1, 4) if i != 1]
print(list_a)


# 嵌套循环
list_a = []
for i in range(1, 4):
    for j in range(1, 4):
        list_a.append(i*j)

print(list_a)

list_a = [i*j for i in range(1, 4) for j in range(1, 4)]
print(list_a)

元组

"""
元组使用（）进行定义
"""
tuple_a = (1, 2, 3)
tuple_b = 1, 2, 3
print(tuple_a, type(tuple_a))
print(tuple_b, type(tuple_b))

"""
元组不可变特性,列表可变
"""
list_a = [1, 2, 3]
list_a[0] = "a"
print(list_a)
# ['a', 2, 3]

tuple_a = (1, 2, 3)
tuple_a[0] = "a"
print(tuple_a)
# TypeError: 'tuple' object does not support item assignment

# 元组嵌套列表
list_a = [1, 2, 3]
tuple_a = (1, 2, list_a)
print(id(tuple_a))
tuple_a[2][0] = "a"
print(tuple_a)
# (1, 2, ['a', 2, 3])
print(id(tuple_a))

# 元组的内置函数
a = (1, 2, 3, "a", "a")
# print(a.count("a"))   # 元组的个数
print(a.index(3))       # 元组的索引位置

集合

"""
集合
集合是由不重复元素组成的无序的集
基本用法包括成员检测和消除重复元素
可以使用{} 或者 set() 函数创建集合
创建一个空集合只能使用set() 而不能用{}
"""
set_a = {1}
set_b = set()
print(len(set_b))  # 0 空集合
print(type(set_a), type(set_b))

a = {1, 2, 3}
b = {1, 4, 5}
print(a.union(b))   # {1, 2, 3, 4, 5} 并集
print(a.intersection(b))    # {1} 交集
print(a.difference(b))      # {2, 3} 差集
a.add("a")
print(a)    # {1, 2, 3, 'a'}

"""推导式"""
print({i for i in "aaaaaasdasdasdqe"})  # {'e', 's', 'a', 'd', 'q'}

c = "aaaaaaaaaaaasdwwdczxc"
print(set(c))
"""
去重
{'x', 'w', 'a', 'c', 'd', 's', 'z'}
"""

字典

"""
字典
字典是以【关键字】为索引
关键字可以是任意不可变类型
通常是字符串或者数字
如果一个元组只包含字符串，数字或者元组，那么这个元组可以用作关键字
"""

dict_a = {"a": 1, "b": 2}
dict_b = dict(a=1, b=2)
print(dict_a, type(dict_a))
print(dict_b, type(dict_b))
# {'a': 1, 'b': 2} <class 'dict'>
# {'a': 1, 'b': 2} <class 'dict'>

# keys 不可变
print(dict_a.keys(), dict_a.values())
# dict_keys(['a', 'b']) dict_values([1, 2])

print(dict_a.pop("a"))
print(dict_a)
# 1
# {'b': 2}    # pop 删除并返回剩下的数据

print(dict_a.popitem())     # 随机删除一个键值对（剩下）
print(dict_a)

a = {}
b = a.fromkeys([1, 2, 3])   # k值创建
print(b)
# {1: None, 2: None, 3: None}

a = {}
b = a.fromkeys((1, 2, 3), "a")
print(b)
# {1: 'a', 2: 'a', 3: 'a'}

# 推导式
print({i: i * 2 for i in range(1, 3)})
# {1: 2, 2: 4}