python基础之容器类型：列表、元组、字典

# 一、列表 list（方括号[]）
#1、作用：可以按位置存放多个类型的值
#2、定义
list1=[1,2.1,'a']#列表里面可以存放多种类型的值 l=list([1,2.1,'a'])
#3、类型转换：但凡能够被for循环遍历的类型都可以当做参数传给list（）转成列表
str="hello"
l=list(str)  #l=list("hello") 字符串转换成列表

str=list({'k1':123,'k2':456,'k3':78957})
#4、内置方法（常用方法）
#优先掌握的操作：
# 1、按索引存取（正向取值+反向取值）：即可以取也可以改
list=[111,'hello','egon']
# 正向取值
print(list[0])
#反向取值
print(list[-1])


# 2、 添加元素("增"append, extend, insert)
# append：通过append可以向列表添加元素
# extend：通过extend可以将另一个集合中的元素逐一添加到列表中
# insert：insert(1, 3) 在指定位置index前插入元素object#在字符串下标为1的地方插入3
list = ["a", "hong", 123, "12ab"]
list.append("Hello")
print("append添加：",list)
list.insert(0, "World")  # 在指定元素下标位置插入
print("insert添加：",list)
list1 = ["xiao", "Xiaobao"]
list2 = [1111, "bbbbbbb"]
list1.extend(list2)  # list1连接list2
print("extend添加：",list1)

# 3、 修改元素("改")
# 通过下标的方式修改
#可以取值也可以改：索引存在则可以修改对应值
list[0]=222
#////无论取值还是赋值的情况，索引不存在则不可以赋值

# 4、查找元素("查"in, not in, index, count)
# python中查找的常用方法为：
# in（存在）,如果存在那么结果为true，否则为false
# not in（不存在），如果不存在那么结果为true，否则false
# index, count：index和count与字符串中的用法相同





list = ["xiao", "hong", 123, "12ab"]
print("打印字符串hong的索引",list.index("hong"))  # 打印hong的索引
print("12ab" in list)  # 判断12ab是不是在列表,返回True
print('aaa'in ['aaa',1,2])


# 5、删除元素(del, pop, remove)
# del：根据下标进行删除（通用的删除方法，只是单纯的删除，没有返回值）
# pop：删除最后一个元素（有返回值，返回删除的那个元素值）
# remove：根据元素的值进行删除，没有返回值None
list1 = ["xiao", "hello", 123,[1,2,3],"12ab"]
del list1[1]  #删除“hello”元素
print("del删除：",list1)

list1.remove(123)
print("remove删除：",list1)
list1.remove([1,2,3])#删除列表值，删除什么remove里面放什么
print("remove删除列表：",list1)

print(list1.pop())  # 打印列表中要删除的元素,即最后一个元素
print("pop删除：",list1)


# 6、排序(sort, reverse)
# sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
# reverse方法是将list逆置。
a=[1,4,2,3]
# a.sort()  # 元素升序排列
# a.reserve()  # 反转元素排列顺序
a.sort(reverse=True)#[4,3,2,1]  reverse=True
print("a逆置后",a)


# 7、列表取值方法
# 查看列表中的某个数据，可以通过下标来完成value=list[1]
# 查看列表中的某一个部分数据，可以通过切片来完成value=list[:2]
# 依次查看列表中的每一个数据，可以通过for循环来完成
list2 = [1, 'aaa', 'bbb']
for x in list2:  # for x in [1,'aaa','bbb']:
    print(x)  # x是列表中的元素
line = len(list2)  # 取列表长度
for x in range(line):
    print(list2[x])  # 通过下标取元素，x为列表下标值


# 补充：
# 列表嵌套：在一个列表里面再套一个列表
# 定义一个嵌套的列表
city_list=[["北京","沈阳"],["深圳","上海"]]
print(city_list)  #打印整个嵌套列表   [["北京","沈阳"],["深圳","上海"]]
# 一次性获取深圳这个数据
city_name=city_list[1][0]#下标为1的组里面的下标为0的数据
print(city_name)





# 二、元组 tuple （圆括号（））
#1、作用：元祖创建后不能再做任何修改，添加或者删除任何元素； 只可读不可改
#2、定义(元组是一个不可变的列表)
 # 元祖的创建
# tuple = (元素1, 元素2, ...)
tuple = ("apple", "banana", "grape", "orange")
tuple1 = ()  # 空元祖
tuple2 = ("apple",)  # 只包含一个元素的元祖，一定要加逗号分隔开！！
#3、类型转换：元祖由不同的元素组成，每个元素可以存储不同类型的数据，如字符串，数字甚至元祖；
#4、内置方法（常用方法）
# 元祖的访问通过索引访问，索引就是下标：
# print(tuple[1])
# print(tuple[-1])  # 访问最后一个元素
# print(tuple[0:2])
# print(tuple[2:-2])
#
# fruit1 = ("apple", "banana")  # 复合元祖
# fruit2 = ("grape", "orange")
# fruit = (fruit1, fruit2)
# print(fruit[0][1])
# print(fruit[1][1])
# # print(fruit[1][2])  # 错误
#
# '''
#     元祖的打包和解包(了解)
#     创建元祖就相当于打包；
#     解包可以把元祖中的各个元素分别赋值给多个变量
# '''
# a, b, c, d = tuple
# print(a, b, c, d)
#
# # 元祖的遍历
# tuple = (("apple", "banana"), ("grape", "orange"), ("watermelon",), ("grapefruit",))
# for i in range(len(tuple)):
#     print("tuple[%d] : " % i, " ", )
#     for j in range(len(tuple[i])):
#         print(tuple[i][j], " ")
#     print()
#
# for i in tuple:
#     for j in i:
#         print(j)
# #




#
# # 字典（花括号）
# # 字典由一系列的“键 - 值（key - value）”, 字典是“键 - 值“对组成的集合，字典中的值通过键来引用；
# # 字典的键是区分大小写的；
# # 创建字典时可以用数字作为索引；
# # 字典通过key值获取对于的value值，如果访问的key值不在字典的key列表中，字典会自动添加一条新的映射；
# # 字典没有remove操作，元素删除通过del()
# # 实现；
#
# # # 字典
# # dictionary = {key1: value1, key2: value2, ...}
# # dictionary = {}
#
# dict = {"a": "apple", "b": "Baoxin", "g": "grape", "d": "Doubi"}
# print(dict)
# print(dict["b"])
#
# dict1 = {1: "apple", 2: "Baoxin", 3: "grape", 4: "Doubi"}
# print(dict1)
# print(dict1[2])
#

#
# 字典的常见操作：
# 1、查看元素，修改元素->都是通过键值#字典中键值是唯一的
# 2、添加元素，添加的这个键值不存在时就是添加元素
# 3、删除元素，两种方式del可以删除指定元素、clear()清空整个字典
# 4、len()：测量字典中，键值对的个数
# 5、keys：返回一个包含字典所有KEY的列表
# 6、values：返回一个包含字典所有value的列表
# 7、 items：返回一个包含所有（键，值）元祖的列表
# 创建有序字典：python3.6以后的版本创建的都是有序字典，之前的版本是无序字典

# # 字典的添加，删除，修改
# dict = {"a": "apple", "b": "Baoxin", "g": "grape", "d": "Doubi"}
# dict["x"] = "Xiaobai"  # 添加
# del (dict["a"])  # 删除字典中键为a的元素
# dict["g"] = "grapefruit"  # 修改字典中键为g的值
#
# print(dict.pop("b"))  # 弹出字典中键为b的元素
# print(dict)
#
# dict.clear()  # 清除字典中所有元素
# print(dict)
#
# # 字典的遍历
# for i in dict:
#     print("dict[%s] = " % k, dict[k])
#
# print(dict.items())  # 使用items()遍历，返回若干个元祖组成的列表
#
# for (k, v) in dict.items():  # k,v分别对应key和value
#     print("dict[%s] = " % k, v)
#
# # 混合型字典
# dict = {"a": "apple", "b": {"ba": "Baoxin", "bo": "banana"}, "g": ["grape", "Xiaobai"]}
# print(dict["a"])
# print(dict["a"][0])
# print(dict["b"])
# print(dict["b"]["ba"])
# print(dict["g"][1])
#
# # 字典的方法
# dict = {"a": "apple", "b": "Baoxin", "g": "grape", "d": "Doubi"}
# print(dict.keys())  # 打印出字典的键，返回列表
# print(dict.values())
#
# print(dict)
# print(dict.get("c", "apple"))  # 使用get获取键为c的值，不存在就返回apple
#
# print(sorted(dict.items(), key=lambda d: d[0]))  # 按照key排序，lambda可以创建匿名函数，后面会介绍
# print(sorted(dict.items(), key=lambda d: d[1]))  # 按照value排序