python中列表、元组、集合、字典的用法总结

一、列表（List）

1. 基本概念

• 定义：有序的可变序列(可以修改)。
• 基本语法：变量名称 = [元素1，元素2，元素3，元素4 …]， 举例： gege1_list = [“鸡”, “xu”, “2.5” ] （元素类型可以不一样）
• 空列表：变量名称 = [ ]、变量名称 = list()    举例： list=[ ] 、list = list()
• 嵌套列表：gege2_list =[ [ “鸡”，“你”，“太”，“美”],[ “2.5”，“xu”，“kun”，“lianxisheng” ] ]
• 下标索引：从前往后从0开始，每次+1，从后往前从-1开始，每次-1。
    举例： print(gege1_list ([1])    输出 ：xu
    举例： print(gege1_list ([-1])    输出 ：2.5
    举例： print(gege2_list ([0][1])    输出 ：鸡

2. 常用方法总结

定义一个列表： gege1_list = [“鸡”, “xu”, “2.5” ]  方便后续演示…

• 查找某元素的下标:list.index()  举例：index=gege1_list.index(“xu”)   输出：1
• 修改特定下标索引的值：gege1_list.index[0] = “蔡某坤”   输出 ：gege1_list = [“蔡某坤”, “xu”, “2.5” ]
• 在指定下标位置插入新元素：list.insert(下标，元素)  
                  举例：gege1_list.insert(1，“中分”)  输出 ：gege1_list = [“鸡”，“蔡某坤”,“中分” “xu”, “2.5” ]
• 追加元素：list.append(元素)，将指定元素追加到列表的尾部。
                  举例：gege1_list.append(“中分”)  输出 ：gege1_list = [“蔡某坤”,“xu”, “2.5”，“中分” ]
• 批量追加元素：list.extend(其他数据容器)
              举例：list2 = [“1”,“2”,“3”]  gege1_list.extend(list2)  输出 ：gege1_list = [“鸡”,“xu”, “2.5”，“1” ，“2” ，“3” ]
• 删除元素：1.del list[下标]  2.list.pop(下标)（可以把删掉的元素当成返回值）
              举例：del gege1_list(0)  输出 ：gege1_list = [ “xu”, “2.5” ]
              举例：gege1_list.pop(0)  输出 ：gege1_list = [ “xu”, “2.5” ]  取出元素：element = gege1_list.pop(0) =鸡
• 删除某元素在列表中的第一个匹配项：list.remove(元素)
• 清空列表：list.clear()
• 统计某元素在列表内的数量：list.count(元素)
• 统计列表的总共有多少元素：n = len(list)

3. 遍历列表

list = ['1','2', '3', '4','5']

def while_list():
    index = 0
    while index < len(list):
        print(list[index])
        index+=1

def for_list():
    for element in list:
        print(element)

二、元组(Tuple)

1. 基本概念

• 定义：有序的不可变序列（不可以修改）。
• 与列表的类似：可以封装多个、不同类型的元素在内。
• 与列表的区别：元组一旦定义完成，不允许修改。
• 基本语法：tuple = (元素，元素，元素，元素…),元素可以不同类型
• 定义空元组:t1= ()、t2= tuple()
• 定义单个元素的元组：t1 = (“坤坤”，)，必须加 ， 不加 ， 输出就是字符串。
• 元组嵌套：t2 = ((1,2,3), (4,5,6)) num = t2[1][2]    输出:num=6
• 元组内的列表可以修改：t3 = （0，1，[“坤坤”,“太美” ] ）列表可以修改

2. 常用方法总结

• 查找某元素的下标:tuple.index()
• 统计某元素在列表内的数量：tuple.count(元素)
• 统计列表的总共有多少元素：n = len(tuple)

三、集合(Set)

1. 基本概念

• 定义：无序不重复的集合，集合里面的元素没有重复的，而且没有顺序。
• 基本语法：变量名称 = {元素，元素，元素，元素，元素，…}
• 定义空集合：变量名称 = set()不支持{}去定义空集合，因为{}是空字典
• 集合不支持while循环，下标随机

定义集合输出

my_set = {"坤坤", "爱坤", "爱坤", "爱坤","坤坤", "鸡你太美"}
my_set2 = {}
print(f"my_set的内容是：{my_set},my_set的类型是：{type(my_set)}")

输出结果：可以看到内容无序且唯一：

my_set的内容是：{'坤坤', '鸡你太美', '爱坤'},my_set的类型是：<class 'set'>

2. 常用方法总结

• 集合无序，不支持下标索引访问。
• 添加元素：my_set.add(元素)

my_set.add("python")
print(f"my_set的内容是：{my_set},my_set的类型是：{type(my_set)}")
my_set的内容是：{'python', '鸡你太美', '坤坤', '爱坤'},my_set的类型是：<class 'set'>

• 移除元素：my_set.remove(元素)
• 从集合中随机取元素：my_set.pop()
• 清空集合：my_set.clear()
• 取两个集合的差集：set3 = set1.difference(set2)，集合1有而集合2没有的

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"set3的内容是：{set3},set3的类型是：{type(set3)}")

set3的内容是：{2, 3},set3的类型是：<class 'set'>

• 消除2个集合的差集：set1.difference_update(set2)，集合1和集合2相同的元素删除了，集合2不发生变化

set1 = {1,2,3}
set2 = {1,5,6}
#set3 = set1.difference(set2)
set1.difference_update(set2)
print(f"set1的内容是：{set1},set1的类型是：{type(set1)}")
print(f"set2的内容是：{set2},set2的类型是：{type(set2)}")

输出：

set1的内容是：{2, 3},set1的类型是：<class 'set'>
set2的内容是：{1, 5, 6},set2的类型是：<class 'set'>

• 集合合并：set3 = set1.union(set2)。合并后的集合无序且唯一

set1 = {1,2,3,7}
set2 = {2,1,5,6}
set3 = set1.union(set2)
print(f"set3的内容是：{set3},set3的类型是：{type(set3)}")

输出结果：

set3的内容是：{1, 2, 3, 5, 6, 7},set3的类型是：<class 'set'>

• 统计集合元素的数量：len(set1)

set1 = {1,1,1,1,2,3,7}
print(len(set1))

输出结果：

4

四、字典(Dictonary)

1. 基本概念

定义：无序Key-Vaule集合，不可以重复，用Key取出Vaule，不可以使用下标索引。
基本语法：my_dict = {key:vaule，key:vaule，key:vaule， key:vaule, … }
空字典：my_dict = {}、my_dict =dict()
定义嵌套字典：

my_dict = {
   "坤坤": {"语文":10,"数学":20,"英语":30},
    "鸡哥":{"语文":10,"数学":20,"英语":30},
    "咯咯哒":{"语文":10,"数学":20,"英语":30}
}
#print(my_dict)
score = my_dict["鸡哥"]["语文"]
print(score)

从嵌套字典中获取数据：

score = my_dict["鸡哥"]["语文"]
print(score)
10

2. 常用方法总结

增加：my_dict[“篮球”]=100
修改：my_dict[“篮球”]=60，Key不可以重复，对已存在的Key修改,就是更新。
删除：score = my_dict.pop[“坤坤”]字典被移除了一个元素
清空：my_dic.clear()
获取全部的Keys:my_dic.keys()

my_dict = {
   "坤坤": {"语文":10,"数学":20,"英语":30},
    "鸡哥":{"语文":10,"数学":20,"英语":30},
    "咯咯哒":{"语文":10,"数学":20,"英语":30}
}

number = my_dict.keys()
print(number)

dict_keys(['坤坤', '鸡哥', '咯咯哒'])

遍历字典：

my_dict = {
   "坤坤": {"语文":10,"数学":20,"英语":30},
    "鸡哥":{"语文":10,"数学":20,"英语":30},
    "咯咯哒":{"语文":10,"数学":20,"英语":30}
}

keys = my_dict.keys()
# 第一种遍历
for key in keys:
    print(f"字典中的key是:{key}")
    print(f"字典中的vaule是:{my_dict[key]}")
# 第二种遍历
for key in my_dict:
    print(f"字典中的key是:{key}")
    print(f"字典中的vaule是:{my_dict[key]}")

统计字典内的元素个数：num = len(my_dict)