沉吟放拨插弦中，整顿衣裳起敛容——python组合数据

沉吟放拨插弦中，整顿衣裳起敛容。 自言本是京城女，家在虾蟆陵下住。 十三学得琵琶成，名属教坊第一部。 曲罢曾教善才服，妆成每被秋娘妒。 五陵年少争缠头，一曲红绡不知数。 钿头银篦击节碎，血色罗裙翻酒污。 今年欢笑复明年，秋月春风等闲度。 弟走从军阿姨死，暮去朝来颜色故。 门前冷落鞍马稀，老大嫁作商人妇。 商人重利轻别离，前月浮梁买茶去。 去来江口守空船，绕船月明江水寒。 夜深忽梦少年事，梦啼妆泪红阑干。 我闻琵琶已叹息，又闻此语重唧唧。

1.列表

1.1 列表的特点

列表可存储多个可重复、不同类型类型的数据，是有顺序的存储

1.2 列表的声明

# 声明空列表
lst1 = list()

# 声明非空列表
lst2 = ["沉吟放拨插弦中", "整顿衣裳起敛容"]

1.3 列表的常用操作

组合数据类型的操作方法，可以借助dir()和help()进行查询，dir()用与查询操作方法，help()用于查询操作方式。dir()和help()的使用不限于组合数据，也可查询其他语句。

# 查询列表的操作方法
dir(list)  # 括号可写列表名

# 查询列表中remove操作的使用方法
help(list.remove)

1.3.1 增加数据

# append() 列表末尾追加数据
lst1 = ["沉吟放拨插弦中"]
lst1.append("整顿衣裳起敛容")
print(lst1)

# insert(索引， 内容) 列表中指定索引的前面，可以使负索引，超过索引在末尾插入
lst2 = ["沉吟放拨插弦中", "自言本是京城女", "家在虾蟆陵下住"]
lst2.insert(1, "整顿衣裳起敛容")
print(lst2)

# extend() 列表末尾增加一组数据
lst3 = ["沉吟放拨插弦中", "整顿衣裳起敛容"]
lst4 = ["自言本是京城女", "家在虾蟆陵下住"]
lst3.extend(lst4)  # 等价于lst3 += lst4
print(lst3)

1.3.2 修改数据

# L[编号] = 新数据  根据索引修改数据, 索引都是从0开始
lst1 = ["自言本是京城女", "家在虾蟆陵下住", "十三学得琵琶成", "名属教坊第一部", "曲罢曾教善才服", "妆成每被秋娘妒", "五陵年少争缠头", "一曲红绡不知数"]
sentence = lst1[3]
print(sentence)

# L.reverse()  逆序输出列表
#   注意与倒序排列区分
lst1.reverse()
print(lst1)

# L.sort()  排列操作, 同一种类型数据才能排列
# 默认从小到大，如果为字符串，按照ascii码操作
lst2 = [13, 1, 5, 1]
lst2.sort()  # [1, 1, 5, 13]
print(lst2)
# 倒序排列(从大到小)
lst2.sort(reverse=True)
print(lst2)  # [13, 5, 1, 1]

# L.sorted() 不改变原列表，返回一个已排好序的列表（从小到大）
#   字符串元素：默认是对字符串中每个字符元素按照ascii码进行比较
lst3 = sorted(lst2)
print(lst3)  # [1, 1, 5, 13]
# 倒序（从大到小）
lst4 = sorted(lst3, reverse=True)
print(lst4)  # [13, 5, 1, 1]

1.3.3 查询数据

lst1 = ["自言本是京城女", "家在虾蟆陵下住", "十三学得琵琶成", "名属教坊第一部", "曲罢曾教善才服", "妆成每被秋娘妒", "五陵年少争缠头", "一曲红绡不知数"]
# 查询所有数据 通过for循环遍历输出
for i in lst1:
    print(i)

# L.index(数据) 查询从左到右找到的第一个数据的索引
index = lst1.index("一曲红绡不知数")
print(index)  # 结果：7

# L[索引] 通过索引查询数据，索引可以为负，-1对应最后一个元素
s = lst1[5]
print(s)

# L.count(数据) 查询数据出现的次数
lst2 = [13, 1, 5, 1]
times = lst2.count(1)
print(times)  # 2lst1 = ["自言本是京城女", "家在虾蟆陵下住", "十三学得琵琶成", "名属教坊第一部", "曲罢曾教善才服", "妆成每被秋娘妒", "五陵年少争缠头", "一曲红绡不知数"]
# 查询所有数据 通过for循环遍历输出
# for i in lst1:
#     print(i)

# L.index(数据) 查询从左到右找到的第一个数据的索引
index = lst1.index("一曲红绡不知数")
print(index)  # 结果：7

# L[索引] 通过索引查询数据，索引可以为负，-1对应最后一个元素
s = lst1[5]
print(s)

# L.count(数据) 查询数据出现的次数
lst2 = [13, 1, 5, 1]
times = lst2.count(1)
print(times)  # 2

1.3.4 删除数据

lst1 = ["自言本是京城女", "家在虾蟆陵下住", "十三学得琵琶成", "名属教坊第一部", "曲罢曾教善才服", "妆成每被秋娘妒", "五陵年少争缠头", "一曲红绡不知数"]
print(lst1)
# L.pop(索引) 删除指定索引的数据并返回值, 默认删除末尾数据，括号内加索引可删除指定数据
s = lst1.pop(5)
print(s)

# del L[索引]： 删除指定索引的数据
# del 列表：删除列表
# del是python内置功能，对其他数据删除操作也可使用
del lst1[4]
print(lst1)

# remove(数据) 删除从左到右找到的第一个数据
lst1.remove("家在虾蟆陵下住")
print(lst1)

# clear() 清空列表
lst1.clear()
print(lst1)

1.3.5 其他操作

lst1 = [13, 1, 5, 1]
# len(L) 获取列表中数据的个数
v1 = len(lst1)
print(v1)
# max(L) 获取列表中最大值, 需要同一种类型数据
v2 = max(lst1)
print(v2)
# min(L) 获取列表中最小值 同一种类型数据
v3 = min(lst1)
print(v3)
# 列表重复 L * 重复次数
lst2 = lst1 * 3
print(lst2)

2.元组

2.1 元组的特点

元组用于存储可重复，不同类型的数据，是有顺序的存储，不能被修改（不能进行增删改）
但如果元素本身是一个可变数据类型的列表，那么其嵌套项可以被改变

2.2 元组的声明

# 声明空元组
t1 = tuple()

# 一个元素元组
t2 = ("钿头银篦击节碎",)  # 要加逗号，不加则认为是四则运算括号
print(t2)

# 多个元素元组
t3 = ("钿头银篦击节碎", "血色罗裙翻酒污")
print(t3)

2.3 元组的常用操作

t1 = ("钿头银篦击节碎", "血色罗裙翻酒污", "今年欢笑复明年", "秋月春风等闲度")
t2 = (13, 1, 5, 1)

# T.count() 查询一个元素出现次数
v1 = t2.count(1)
print(v1)  # 2

# T.index() 查询一个元素出现的位置
v2 = t1.index("秋月春风等闲度")
print(v2)  # 3

# T[索引] 查询指定索引位置元素
v3 = t1[2]
print(v3)

# len(T) 查询元素个数
v4 = len(t1)
print(v4)  # 4

# 元组合并
t3 = ("钿头银篦击节碎", "血色罗裙翻酒污")
t4 = ("今年欢笑复明年", "秋月春风等闲度")
t5 = t3 + t4
print(t5)  # ('钿头银篦击节碎', '血色罗裙翻酒污', '今年欢笑复明年', '秋月春风等闲度')
# 元组重复
t6 = t4 * 2
print(t6)  # ('今年欢笑复明年', '秋月春风等闲度', '今年欢笑复明年', '秋月春风等闲度')

3.集合

3.1 集合的特点

集合中的数据不可重复，可以是不同类型数据（只能是不可变类型数据），是无序的存储

3.2 集合的声明

# 声明空集合
s1 = set()

# 声明非空集合
s2 = {"弟走从军阿姨死", "暮去朝来颜色故"}

3.3 集合的常用操作

3.3.1 单集合操作

s1 = {"弟走从军阿姨死", "暮去朝来颜色故"}

# add 增加
s1.add("门前冷落鞍马稀")
s1.add("老大嫁作商人妇")
print(s1)

# copy 复制一个集合
s2 = s1.copy()
print(s2)

# pop 随机删除一个数据
s1.pop()
print(s1)

# remove 删除指定数据，数据不存在则报错
s2.remove("窗前明月光")
print(s2)  # 报错 KeyError

# diascard 删除指定数据，数据不存在则什么都不做
s2.discard("老大嫁作商人妇")
print(s2)

# clear 清空集合
s2.clear()
print(s2)  # set()

3.3.2 两个集合操作

s1 = {"弟走从军阿姨死", "暮去朝来颜色故", "门前冷落鞍马稀", "老大嫁作商人妇"}
s2 = {"门前冷落鞍马稀", "老大嫁作商人妇"}
s3 = {"门前冷落鞍马稀", "老大嫁作商人妇", "商人重利轻别离", "前月浮梁买茶去"}
s4 = {"商人重利轻别离", "前月浮梁买茶去", "去来江口守空船", "绕船月明江水寒"}


# isdisjoint 判断两个集合是否包含相同的元素，如果没有返回 True
v1 = s1.isdisjoint(s3)
v2 = s1.isdisjoint(s4)
print(v1)  # False
print(v2)  # True

# issubset s1 集合中的数据是不是包含在 s2 集合中，等价于 s1 < s2
v3 = s1.issubset(s2)
v4 = s2.issubset(s1)
print(v3)  # False
print(v4)  # True

# issuperset s1 集合是不是包含了 s2 集合中的数据，等价于 s1 > s2
v5 = s1.issuperset(s2)
v6 = s2.issuperset(s1)
print(v5)  # True
print(v6)  # False

# difference 获取 s1 集合和 s2 集合的差集 {x∣x∈A,且x∉B}
s5 = s1.difference(s2)
print(s5)  # {'弟走从军阿姨死', '暮去朝来颜色故'}
# 若要直接将数据结果更新到s1, 则使用difference_update, 使用方法相同

# intersection 获取 s1 集合和 s2 集合的交集
s6 = s1.intersection(s3)
print(s6)  # {'门前冷落鞍马稀', '老大嫁作商人妇'}
# 若要直接将数据结果更新到s1, 则使用intersection_update, 使用方法相同

# symmetric_difference 获取 s1 和 s2 共同的差集
s7 = s1.symmetric_difference(s3)
print(s7)  # {'商人重利轻别离', '暮去朝来颜色故', '弟走从军阿姨死', '前月浮梁买茶去'}
# 若要直接将数据结果更新到s1, 则使用symmetric_difference_update, 使用方法相同

# union 获取 s1 和 s2 的并集
s8 = s1.union(s3)  # {'商人重利轻别离', '门前冷落鞍马稀', '弟走从军阿姨死', '老大嫁作商人妇', '前月浮梁买茶去', '暮去朝来颜色故'}
print(s8)
# 若要直接将数据结果更新到s1, 则使用update, 使用方法相同

4.字典

4.1 字典的特点

存放键值对（key：value）数据，key不能重复，value可以重复，如果key重复会覆盖前面的value，key必须是不可变数据类型，python3.6版本前字典是无序的，3.7版本后是有序的

4.2 字典的声明

# 声明空字典
d1 = dict()

# 声明非空字典
d2 = {"1": "夜深忽梦少年事", "2": "梦啼妆泪红阑干"}

4.3 字典的常用操作

4.3.1 增加、修改数据

d = {"1": "夜深忽梦少年事", "2": "梦啼妆泪红阑干"}

# D.setdefault(key, value) 如果 key 不存在，增加 key: value 到字典中，如果 k 存在，无任何操作
d.setdefault("3", "我闻琵琶已叹息")
print(d)  # {'1': '夜深忽梦少年事', '2': '梦啼妆泪红阑干', '3': '我闻琵琶已叹息'}

# D[key] = value 如果 key 不存在，新增一个键值对数据，key存在会更新相应的value
# D.update({key: value}) 如果 key 不存在，增加 key: value 到字典中，如果 k 存在更新对应的value，等价于 D[key] = value
d.update({"4": "又闻此语重唧唧"})
print(d)  # {'1': '夜深忽梦少年事', '2': '梦啼妆泪红阑干', '3': '我闻琵琶已叹息', '4': '又闻此语重唧唧'}
d.update({"2": "窗前明月光"})
print(d)  # {'1': '夜深忽梦少年事', '2': '窗前明月光', '3': '我闻琵琶已叹息', '4': '又闻此语重唧唧'}
d["2"] = "梦啼妆泪红阑干"
print(d)  # {'1': '夜深忽梦少年事', '2': '梦啼妆泪红阑干', '3': '我闻琵琶已叹息', '4': '又闻此语重唧唧'}

4.3.2 查询数据

d = {'1': '我闻琵琶已叹息', '2': '又闻此语重唧唧'}

# D.items() 获取所有的键值对 key:value
v1 = d.items()
print(list(v1))  # [('1', '我闻琵琶已叹息'), ('2', '又闻此语重唧唧')]

# D.keys() 获取所有的 key 数据
v2 = d.keys()
print(list(v2))  # ['1', '2']

# D.values() 获取所有的 value 数据
v3 = d.values()
print(list(v3))  # ['我闻琵琶已叹息', '又闻此语重唧唧']

# D.get(key) 获取 k 对应的 value 数据 存在值时等价于 D[key]
# get方法值不存在默认返回None，也可指定返回值：get(key, 返回值)， D[key]值不存在会报错
v4 = d.get("1")
v5 = d["2"]
print(v4)  # 我闻琵琶已叹息
print(v5)  # 又闻此语重唧唧

4.3.3 删除数据

d = {'1': '夜深忽梦少年事', '2': '梦啼妆泪红阑干', '3': '我闻琵琶已叹息', '4': '又闻此语重唧唧'}

# D.pop(key) 删除 key 对应的value，并返回value
# del D[key] 删除 key 对应的value
# del D 删除整个字典
v1 = d.pop("1")
print(v1)  # 夜深忽梦少年事
del d["2"]
print(d)  # {'3': '我闻琵琶已叹息', '4': '又闻此语重唧唧'}

# D.popitem() 删除最后一个键值对（python3.7版本），随机删除一个键值对并返回键值对（python3.6版本前）
v2 = d.popitem()
print(v2)  # ('4', '又闻此语重唧唧')
print(d)  # {'3': '我闻琵琶已叹息'}

4.3.4 其他操作

d1 = {'1': '我闻琵琶已叹息', '2': '又闻此语重唧唧'}

# copy 复制字典
d2 = d1.copy()
print(d2)  # {'1': '我闻琵琶已叹息', '2': '又闻此语重唧唧'}

# clear 清空字典
d2.clear()
print(d2)