python系列5—列表、元组、集合、字典

组合数据类型

当基本的数据类型不能完全表示所有的数据时,这时候就会用到组合数据类型。学习组合数据类型之前,需要知道python的两个内置神级函数dir()help()

  • dir():查看某个对象支持的操作方法,示例:dir(list)
  • help():查看某个方法的使用方式,示例:help(print)

一、列表list

列表是组合数据类型中的一种,可以按照有位置顺序的方式、存储不同数据类型、重复的多个数据。列表和变量的使用方式一样,都需要先声明,再使用。

  1. 列表的声明

    • 声明空列表
      """
      声明一个空列表
      
      Version: 0.1
      Author: 柚子
      """
      # 1、使用python中的关键字声明【推荐方式】
      names = list()
      
      # 2、直接使用[]声明
      ages = []
      
      
    • 声明非空列表
      """
      声明一个非空列表
      
      Version: 0.1
      Author: 柚子
      """
      # 1、直接声明【推荐方式】
      names = ["柚子","西瓜","香蕉"]
      
      # 2、使用list()转换
      s = "hello"
      s2 = list(s) # 类型转换~将其他类型转换成列表数据
      print(s2); #["h", "e", "l", "l","o"]
      
      
  2. 列表的操作

    列表的操作主要分为四种:增加、修改、查询、删除。除此之外还有一些其他的操作需要了解。

    • 增加
      """
      列表增加操作主要有:
          append(object):         在列表末尾添加数据
          insert(index,object)     在列表某个位置插入数据,超出列表长度不报错    
          extend(iterable)         添加一个可迭代对象
      Version: 0.1
      Author: youzi
      """
      names = ["柚子", "西瓜"]
      names.append("榴莲")
      print(names)    #['柚子', '西瓜', '榴莲']
      
      names.insert(10, "桃子")
      print(names)    #['柚子', '西瓜', '榴莲', '桃子']
      names.extend("苹果")
      print(names)    #['柚子', '西瓜', '榴莲', '桃子', '苹', '果']
      
    • 修改

      修改列表中的数据直接使用L[下标]的方式进行修改,下标从0开始。

      names = ["柚子", "西瓜"]
      names[0] = "哈密瓜"
      print(names)    #['哈密瓜', '西瓜',]
      
    • 查询

      查询数据有:查看所有数据,查看某个数据的位置,查看某个数据的次数三种。

      """
      index和count的用法
      """
      names = ["柚子", "西瓜"]
      # 通过循环查看列表中的每一个数据
      for name in names:
          print(name)
      
      # 查看某个位置的数据
      print(names[0])  
      
      # 查看某个数据的第一次出现的位置,找不到会报错
      print(names.index("西瓜"))  #1
      
      # 查看某个数据出现的次数
      print(names.count("西瓜"))  #1
      
    • 删除

      删除操作也有两种,remove,pop,

      """
      remove(object)	删除某个数据,数据不在时会报错
      pop(index)		按下标删除,不写时默认删除最后一个,超出列表下表会报错
      del L[index]	使用python的del删除
      clear()			清空列表
      """
      names = ['哈密瓜', '西瓜', '榴莲', '桃子',"柚子", "核桃"]
      names.remove("西瓜")
      print(names)
      
      names.pop()
      print(names)
      names.pop(0)
      print(names)
      
      del names[0]
      print(names)
      
      names.clear()
      print(names)
      
    • 其它操作
      操作 描述
      L.sort() 在原列表的基础上进行排序
      L.reverse() 对列表进行反转
      L.copy() 生成一个浅拷贝对象
      len(L) 获取列表中数据的个数
      max(L) 获取列表中的最大值
      min(L) 获取列表中的最小值
      L[m:n:x] 列表的切片
      从m位置开始,切到n,间隔为x
      示例:
      L[:]:切取整个列表数据
      L[1:]:从1开始切到最后一位
      L[1:3:2]:从1开始切到3,间隔为2
      切片时支持负索引,最后一位为-1

    案例:蜃楼用户管理系统

    """
    用户信息录入系统
        开发步骤
        1、定义一个首页界面[告诉我们要做什么] 
        2、通过列表保存数据
        3、通过用户输入的选项,执行判断
        4、实现各项的功能
        5、测试功能运行是否正确
        6、BUG 完善
    """
    
    # 保存所有伙伴的列表
    sheng_lou = list()
    while True: # 首页
        print("欢迎来到蜃楼用户管理系统")
        print("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~")
        print(" 1、查看所有小伙伴")
        print(" 2、录入个人信息")
        print(" 3、查看个人信息")
        print(" 4、退出系统")
        print("~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~ * ~") # 用户输入选项
        c = input("请输入您的选项:")
        if c == "1":  # 遍历所有小伙伴
            for stu in sheng_lou:
                print("小伙伴:", stu)
            print("~~~~~~~~~~~~~~~~~~~~~~~~~")
            input("查看完成按任意键返回首页.")
        elif c == "2":  # 提示用户输入姓名
            name = input("请输入昵称:")
            if name in sheng_lou:
                input("该昵称已经存在,请使用其他昵称录入")
                continue
            # 保存昵称:列表的末尾追加
            sheng_lou.append(name)
            input("录入完成,按任意键返回首页...")
        elif c == "3":  # 提示用户输入要查看的昵称
            nickname = input("请输入要查看的昵称:")  
            if nickname in sheng_lou: # 成员成员运算符,判断昵称是否包含在列表中[True/False]
                print("该成员已经在大厅中.")
            else:
                print("该昵称代表的成员没有在大厅中.")
                input("查看个人信息,正在升级中...")
        elif c == "4":
            input("退出系统,保存好个人数据,按任意键退出")
            exit(1)
    

二、元组tuple

元组也是组合数据类型中的一种,可以有顺序的存放可重复的数据、可以是不同类型的多个数据,数据一旦保存之后,不允许改动,可以使用for循环遍历,跟列表相同。

  1. 元组的声明

    • 声明空元组

      因为元组不能修改,声明空元组没有任何意义。

      t = tuple() # 声明了一个元组[空] - 推荐
      t2 = () # 声明了一个元组[空] - 很容易和四则运算的小括号混淆
      
    • 声明一个元素的元组
      t = tuple([“a”]) # 这是包含一个数据的元素,不推荐的语法~ 类型转换
      t2 = (“a”, ) # 声明了只包含一个元素的元组~一定要那个逗号
      print(type(t2))	# tuple
      t3 = (“a”) 	# 这不是元组,括号~就是四则运算的括号~t3=”a”
      print(type(t3))	# str
      
    • 声明多个元素的元组
      t = (“春”, “夏”, “秋”, “冬”) # 声明了一个包含四个数据的元组,推荐
      t2 = tuple([“春”, “夏”, “秋”, “冬”]) # 使用tuple()转换-不推荐,繁琐
      
  2. 元组的操作

    #-*-coding:utf-8 -*-
    """
    count(object):某个数据出现的次数
    index(object):某个数据第一次出现的下标
    len(T):元组的长度
    T[下标]:查看某个下标的数据
    """
    t = ("春", "夏", "秋", "冬")
    
    print(t.count("春"))
    print(t.index("春"))
    print(len(t))
    
  3. 使用场景

    元组因为不能修改,经常存储固定不变的数据,比如一年的四季,一年的12个月份等。

三、集合set

集合set是组合类型中的一种,集合中可以存放没有顺序的、不能重复的、任意数据类型的数据,多个数据之间用逗号隔开,不能使用for循环遍历。

  1. 集合的声明

    • 声明空集合

      """
      只能使用set()声明
      """
      s1 = set()
      
    • 声明非空集合

      # 推荐的非空集合的声明方式
      s1 = {“A”, “b”, “C”, “d"}
      # 另一种声明方式~繁琐~ 列表做了数据类型转换,得到了一个集合! 
      s2 = set([“a”, “b”, “c”, “d”])
      

      **说明:**集合具有自动去重功能,如果其中的数据有重复的,集合会自动去重。

  2. 集合的操作

    集合中已经存放了一些数据,那么对于集合的操作都有哪些处理方式呢?

    集合的特点~没有顺序的,不可以重复,不同数据类型(可以),多个数据 。

    """
    单个集合操作:
        'add'    增加,
        'clear  '清空集合, 
        'copy'   复制一个集合,
        'pop',   随机删除一个集合中的数据[集合中的数据没有顺序]
        'remove', 删除一个指定的数据,如果数据不存在就会报错
        'discard', 删除一个指定的数据,如果数据不存在什么都不做
    两个集合操作
        'isdisjoint', 检验两个集合是否有交集,如果没有就返回True
        'issubset', s1 集合中的数据是不是包含在 s2 集合中,等价于 s1 < s2
        'issuperset', s1 集合是不是包含了 s2 集合中的数据,等价于 s1 > s2
    
        'difference', 获取 s1 集合和 s2 集合的差集
        'difference_update', 获取 s1 和 s2 的差集并将结果数据更新到 s1 中
        'intersection', 获取 s1 集合和 s2 集合的交集
        'intersection_update', 获取 s1 和 s2 的交集并将结果更新到 s1 中
    
        'symmetric_difference', 获取 s1 和 s2 共同的差集
        'symmetric_difference_update', 获取共同的差集并更新到 s1 中
    
        'union', 获取 s1 和 s2 的并集
        'update' 获取 s1 和 s2 的并集,并将数据更新给 s1
    """
    s1 = {1}
    s1.add(2)
    print(s1)
    
    
  3. 使用场景

    集合主要用户去重操作和求两组数据的交集或者并集之类的操作。

四、字典dict

字典的概念类似日常使用的《中华字典》,通过前边的页码找到后边对应的数据。前边的页码在python中对应字典的key,后边的页码对应python中的value。字典中的数据都是以键值对的形式存在。

  1. 字典的特点

    字典的格式为{key1:value1,key2:value2},其中key不能重复,且不能是可以修改的数据类型,value可以重复,数据类型没有限制。

  2. 字典的声明

    python中使用dict表示字典。

    • 空字典
      # 1、使用dict(),推荐使用
      dict1 = dict()
      
      # 2、使用{}声明
      dict2 = {}
      
    • 非空字典
      user = {“username”: “admin”, “password”:123456} #推荐使用 可读性强
      user2 = dict([(“username”, “admin”), (“password”,123456)])
      
  3. 字典的使用

    'clear', 清空字典
    'copy', 复制字典
    'fromkeys', 根据给定的 数据作为 key 初始化一个字典
    'get', 根据一个 key 获取对应的 value 数据,key不存在时得到None
    'items', 获取字典中的所有键值对数据
    'keys', 获取字典中的所有 key 数据
    'pop', 根据 key 删除指定的一个键值对
    'popitem', 随机删除一个键值对
    'setdefault', 如果 key 不存在增加一个数据,如果 key 存在什么都不做
    'update', 如果 key 不存在增加一个数据,如果 key 存在更新这个数据
    'values' 获取字典中的所有的 value 数据
    
    • 查看数据
      dct={'username': 'waltz', 'nickname': '柚子'}
      print(dct.items())  # dict_items([('username', 'waltz'), ('nickname', '柚子')])
      print(dct.keys())  	# dict_keys(['username', 'nickname'])
      print(dct.values()) #dict_values(['waltz', '柚子'])
      print(dct.get("nickname")) 	#'柚子'
      print(dct.get("age"))   	# None
      print(dct.get("age","西瓜")) # 西瓜
      print(dct["nickname"])		#'柚子'
      
    • 修改数据
      dct={'username': 'waltz', 'nickname': '柚子'}
      # 修改数据
      dct["nickname"] = "桃子"
      dct.update({"username":"youzi"})
      print(dct)
      dct.setdefault("username", "xigua")
      dct.setdefault("age", 24)
      print(dct)
      
    • 增加数据
      D.setdefault(key, value)
      只有 key 在字典中不存在的情况下,新增一个键值对数据
      D.update({key:value})
      只有 key 在字典中不存在的情况下,新增一个/多个键值对数据
      D[key] = value
       只有 key 在字典中不存在的情况下,新增一个键值对数据
      
    • 删除数据
      """
      pop()      通过key删除值,可以接收返回值,,key不存在时会报错
      popitem()  随机删除一个键值对,可以接收元组形式的返回值
      clear()	   清空字典	
      """
      
      # 删除数据
      dct={'username': 'waltz', 'nickname': '柚子', "age":24}
      value = dct.pop("username")
      print(value)  # waltz
      print(dct)
      result = dct.popitem()
      print(result)  #('age', 24)
      
      r = dct.clear()
      print(r)
      print(dct)
      
  4. 遍历字典

    字典在使用循环遍历时,默认遍历字典中的key。

    dct={'username': 'waltz', 'nickname': '柚子', "age":24}
    for key in dct:
        print(key,dct[key])
    
    for value in dct.values():
        print(value)
    
    for key,value in dct.items():
        print(key,value)
    

猜你喜欢

转载自blog.csdn.net/qq_42486675/article/details/106595043