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

文章目录

• 一、列表（List）
• • 1. 基本概念
  • 2. 常用方法总结
  • 3. 遍历列表
  • 二、元组(Tuple)
  • • 1. 基本概念
    • 2. 常用方法总结
    • 三、集合(Set)
    • • 1. 基本概念
      • 2. 常用方法总结
      • 四、字典(Dictonary)
      • • 1. 基本概念
        • 2. 常用方法总结

          一、列表（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  
              二、元组(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的类型是：

                    2. 常用方法总结

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

                      my_set.add("python")print(f"my_set的内容是：{my_set},my_set的类型是：{type(my_set)}")my_set的内容是：{'python', '鸡你太美', '坤坤', '爱坤'},my_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的类型是：

                        • 消除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的类型是：set2的内容是：{1, 5, 6},set2的类型是：

                          • 集合合并：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的类型是：

                            • 统计集合元素的数量：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)