Python中5个常用的容器--各自的特点作用,相互之间的差异

容器

  • 知识点

    1. 容器的作用:统一存储、管理一系列数据

    2. 常用的容器:

      1. 有哪几种:列表、字典、元组、字符串、集合

      2. 内容:

        1. 定义:由什么组成、序列&散列、是否可变

        2. 适用性:根据需求,选择合适的容器

        3. 语法:创建,增删改查

      3. 对比不同的容器:比较特点,比较作用

      4. 定义 特点
        字符串 字符/不可变/序列 序列:有顺序,能索引、切片,获取元素更灵活
        列表 变量/可变/序列 可变:适用于需要修改元素个数和内容的情况,如录入学生信息 序列:有顺序,能索引、切片,获取元素更灵活
        元组 变量/不可变/序列 不可变:当元素个数固定且不需要改变,优先用元组,能够节省内存
        字典 键值对/可变/散列 键值对:哈希原理,查找速度很快,但相对列表占用更大的内存,键名唯一,代码可读性更好 散列:元素没有顺序,无法直接索引,无法切片
        集合 不重复变量/可变/散列 相对于只有键没有值得字典,主要用于数学运算
    3. 容器内存图

      1. 容器索引不会开辟新的内存

      2. 赋值号(=),将等号右边赋值到等号左边

        • 容器切片放在左边不会开辟新的内存,只起到定位的作用

        • 容器切片放在右边会开辟新的内存

通用操作

  • 数学运算符

    1. +=:用原容器与右侧容器拼接,并重新绑定变量
    2. *:重复生成容器元素
    3. *=:用原容器生成重复元素, 并重新绑定变量
    4. < <= > >= == !=:依次比较两个容器中元素的编码值大小,一但不同则返回比较结果。
  • 成员运算符

    • 语法:

      数据 in 序列

      数据 not in 序列

    • 作用:判断数据是否在序列中,返回bool值

  • 索引index

    • 语法:容器【整数】
    • 作用:根据索引值查找容器内的元素
    • 说明:
      • 正向索引:从0开始,第二个索引为1,最后一个为len(s)-1。
      • 反向索引:从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)
  • 切片slice

    • 作用:根据两个索引值获取容器内的元素块

    • 语法:容器[(索引值1):(索引值2)(:步长)]

    • 说明:

      • ()内的内容可以省略

      • 步长是每次获取元素往后的偏移量,默认为1

      • 起始索引值包含,不包含介绍索引值

  • 内建函数

    1. len(x) 返回序列的长度

    2. max(x) 返回序列的最大值元素

    3. min(x) 返回序列的最小值元素

    4. sum(x) 返回序列中所有元素的和(元素必须是数值类型)

字符串str

  • 定义:由一系列的字符组成__不可变__序列容器,存储的是字符的编码值

    • 字符不可变性:

      name = "悟空"
      # 修改的只是变量name存储的地址,字符没有改变
      # 为什么不可变?:
      # 如果将两个字,改变为三个字,很可能破坏其他对象的内存空间
      # 所以字符串不能改变
      name = "孙悟空"
      
  • 编码

    1. byte是最小的计算机存储单位,等于8个位bit

      • B KB MB G T 都是1024进制
    2. 字符:单个的数字、文字和符号

    3. 字符集(码表)

    4. 编码:将字符转换为对应的二进制序列的过程

    5. 解码:将二进制转换为对应的字符

    6. 编码方式:

      • ASCII编码:包含字母、数字等字符,每个字符占一个字节

      • GBK编码:国标拓展码,兼容ASCII编码,包含21003个中文,英文一个字节,中文两个字节

      • Unicode:国际统一编码(万国码),旧字符集每个占两个字节,新字符集占四个字节

      • UTF-8编码:Unicode编码的存储传输方式,英文占一个字节,中文占三个字节

  • 编码相关函数

    • bin(整数):将整数转换为二进制

    • ord(字符):将字符转换为对应的编码值

    • chr(编码值):将编码值装换为对应的字符

  • 字面值

    • 单引号和双引号的区别

      • 只支持一行

      • 单引号里的双引号不算结束符

      • 双引号里的单引号不算结束符

    • 三引号

      • 常用于文档字符串(注释),且不占用内存

      • 可见即所得:

      • 在三引号中换行时自动转换位/n

      • 三引号中可包含单双引号

    • 转义符:

      • 语法:\ 反斜杠 + 特定的字符

      • 意义:改变原始字符串的含义

      • 解决字符串冲突的问题

      • 常用转义符: \n \\ \t \0

      • 路径问题:

        原始字符串:取消转义

        path = r"C:\aid1904\bay02"

    • 字符串的格式化

      • 定义:生成一定格式的字符串

      • 语法:

        字符串%(变量)

        " 我的名字是%s,年龄是%s" % (name, age)

      • 类型码

        %s字符串 %d整数 %f浮点数

      • 格式: %[- + 0 宽度.精度]类型码

        -: 左对齐(默认是右对齐)

        +: 显示正号

        0 : 左侧空白位置补零

        宽度 : 整个数据输出的宽度

        精度 : 保留小数点后多少位

      • 案例

        print("我%d你"%(5))# 我5你
        print("我%-3d你"%(5))# 我5  你
        print("我%03d你"%(5))# 我005你
        print("%.2f"%(1.2355)) # 1.24
        

列表list

  • 定义:由一系列变量组成的可变序列容器

  • 作用:统一管理多个变量,存储和管理多个数据

  • 适用性:根据该技术的特点,得出适用的情况

    • 可变:适用于需要修改元素个数和内容的情况,如录入学生信息

    • 序列:有顺序,能索引、切片,获取元素更灵活

    • 一系列变量:可读性差,没有键值对可读性好

  • 基础语法:

    1. 创建列表:分成根据具体数据和可迭代对象创建

      列表名 = []

      列表名 = list(可迭代对象)

    2. 添加元素:往后添加和按索引添加

      列表名.append(元素)

      列表.insert(索引,元素)

    3. 定位元素:定位单个和定位多个

      索引、切片

    4. 遍历列表:直接遍历(简单)和通过索引间接遍历(灵活)

      正向:for 变量名 in 列表名:

      变量名(就是元素)

      反向: for 索引名 in range(len(列表名)-1,-1,-1):

      列表名[索引名](就是元素)

    5. 删除元素:根据元素名或索引删除元素

      列表名.remove(元素)

      del 列表名[索引或切片]

  • 深拷贝和浅拷贝

    1. 浅拷贝:是在拷贝过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。

    2. 深拷贝:复制整个依赖的变量。

    import copy
    
    list01 = ["张无忌",["赵敏","周芷若"]]
    list02 =copy.deepcopy(list01)  # 深拷贝
    list01[1][1] = "芷若"
    print(list02[1][1])# 周芷若
    
  • 内存图:浅拷贝和深拷贝的区别

  • 列表VS字符串

    1. 字符串是不可变,列表是可变。

    2. 字符串中每个元素只能存储字符,而列表可以存储任意类型。

    3. 列表和字符串都是可迭代对象。

    4. 转换函数:

      1. 将列表中的多个字符串拼接为一个。
      • result = “连接符”.join(列表) --------追加字符(不会每次产生新对象,造成垃圾)
      # 需求:根据某些逻辑,拼接字符串
      str_result = ""
      for item in range(10):
      # 缺点:每次+ ,都会产生新的字符串对象.
      # 替换str_result变量存储的地址,而之前的对象成为垃圾
          str_result =str_result + str(item)
      print(str_result)
      
      1. 将一个字符串拆分为多个,并放在一个列表中。
      • 列表 = “a-b-c-d”.split(“分隔符”) -----适用于有分隔符

      • 没有分隔符

        list_result = []
        for item in range(10):
         # 向列表追加字符(不会每次产生新对象,造成垃圾)
         list_result.append(str[item])
        # list --> str
        str_result = "".join(list_result)
        print(str_result)
        
  • 列表推导式

    1. 定义:使用简易方法,将可迭代对象转换为列表。
    2. 语法:
      1. 变量 = [表达式 for 变量 in 可迭代对象]
      2. 变量 = [表达式 for 变量 in 可迭代对象 if 条件]
      3. 说明:如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
  • 列表嵌入式

    1. 语法:变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2]
    # 传统写法:
    result = []
    for r in ["a", "b", "c"]:
    for c in ["A", "B", "C"]:
    result.append(r + c)
    #推导式写法:
    result = [r + c for r in list01 for c in list02]
    
  • 列表的扩容:可变容器的属性

    1. 开辟新的更大的空间

    2. 拷贝之前的数据

    3. 替换引用

元组 tuple

  • 定义

    1. 由一系列变量组成的不可变序列容器。

    2. 不可变是指一但创建,不可以再添加/删除/修改元素。

  • 适用性:当元素个数固定且不需要改变,优先用元组

    • 不可变:和列表唯一的不同,固定的空间,没有预留空间
  • 元组VS列表

    • 列表(读写):预留空间

    • 元组(只读):按需分配

  • 基础操作

    1. 创建空元组:根据具体对象或可迭代对象创建

      • 元组名 = ()

      • 元组名 = tuple()

    2. 创建非空元组:

      • 元组名 = (20,) // 一个元素时必须加一个逗号,元组名=(20)是整数不是元组

      • 元组名 = (1, 2, 3)

      • 元组名 = 100,200,300 // 括号可以省略

      • 元组名 = tuple(可迭代对象)

    3. 获取元素:

      • 索引、切片
    4. 遍历元组:用法和列表一致

      • 正向:

        for 变量名 in 列表名:

        变量名就是元素

      • 反向:

        for 索引名 in range(len(列表名)-1,-1,-1):

        元祖名[索引名]就是元素

  • 应用:

    变量交换的本质就是创建元组:x, y = y, x(x,y= (y,x))

    格式化字符串的本质就是创建元祖:“姓名:%s, 年龄:%d” % (“tarena”, 15)

字典 dict

  • 定义

    1. 由一系列键值对组成的可变散列容器。

    2. 散列:每条记录无序。

    3. 键必须惟一且不可变(字符串/数字/元组),值没有限制。

. 适用性:特点如下

. 键值对:哈希原理,查找速度很快,但相对列表占用更大的内存,键名唯一,代码可读性更好

. 散序:无序,只能通过键索引,且不能切片

. 可变:预留空间

  • 基础操作

    1. 创建字典:

      • 字典名 = {键1:值1,键2:值2}

      • 字典名 = dict (可迭代对象)

    2. 添加/修改元素:第一次放是添加,之后放是修改

      • 语法: 字典名[键] = 数据

      • 说明:

        • 键不存在,创建新记录。

        • 键存在,修改映射关系。

    3. 获取元素:

      • 变量 = 字典名[键] //没有键则错误
    4. 遍历字典:

      • 变量所有的键:for 键名 in 字典名:字典名[键名]

      • for 键名,值名 in 字典名.items(): 语句

      • 遍历所有的值: for 值名 in 字典名.value(): 值名

    5. 删除元素:del 字典名[键]

    6. 将两字典拼接:dict03 = {**dict01,**dict02}

  • 字典推导式

    • 定义:使用简易方法,将可迭代对象转换为字典。

    • 语法:{键:值 for 变量 in 可迭代对象} {键:值 for 变量 in 可迭代对象 if 条件}

      • 主要考虑变量和键、值之间的联系,怎么去实现转换
    • """
       (1)字典:键-列表的元素  值:元素的长度
       (2)将两个列表按顺序合并成字典
      """
      list_input = ["adf", "wer", "s", "sd"]
      dict_input = {item: len(item) for item in list_input}
      print(dict_input)
      
      list_input2 = [101, 102, 103, 104]
      dict_input = {list_input[i]: list_input2[i] for i in range(len(list_input))}
      print(dict_input)
      
  • 字典 VS 列表

    1. 都是可变容器。

    2. 获取元素方式不同,列表用索引,字典用键。

    3. 字典的插入,删除,修改的速度快于列表。

    4. 列表的存储是有序的,字典的存储是无序的。

  • 字典和列表的选择

    1,2获取学生信息,需要通过索引,代码可读性差.
    {
      "张三":["男",100,25],
      "李四":["男",100,25]
    }
    
    相比1,4,获取学生更灵活.
    [
      ["张三","男",100,25],
      ["李四","男",100,25],
    ]
    
    相比1,2内存占用过多
    [
      {"name":"张三","sex":"男","score":100,"age":25},
      {"name":"李四","sex":"男","score":100,"age":25},
    ]
    
    相比2,3查找人的速度快
    {
      "张三" :{"sex":"男","score":100,"age":25},
      "李四":{"sex":"男","score":100,"age":25},
    }
    
    序列:有序  灵活(索引/切片)
    散列:无序  速度快  可读性更高
    

集合 set

  • 定义

    1. 由一系列不重复的不可变类型变量组成的可变散列容器。

      • 不可变类型变量有:数,字符串,元组
    2. 相当于只有键没有值的字典(键则是集合的数据)

. 适用性:

. 不重复:

. 数学运算:

  • 基础操作

    • 创建空集合:

      • 集合名 = set()

      • 集合名 = set(可迭代对象)

    • 创建具有默认值集合:

      • 集合名 = {1, 2, 3}

      • 集合名 = set(可迭代对象) //会自动删除可迭代对象中的重复元素

    • 添加元素:集合名.add(元素)

    • 删除元素:集合名.discard(元素)

      • 集合名,remove(元素)
    • 查询元素:没有查询功能,只能间接转换位列表查询

    • 遍历元素:和列表相同

  • 运算

    1. 交集&:返回共同元素。

      s1 = {1, 2, 3}

      s2 = {2, 3, 4}

      s3 = s1 & s2 # {2, 3}

    2. 并集 |:返回不重复元素

      s1 = {1, 2, 3}

      s2 = {2, 3, 4}

      s3 = s1 | s2 # {1, 2, 3, 4}

    3. 补集 - :返回只属于其中之一的元素

      s1 = {1, 2, 3}

      s2 = {2, 3, 4}

      s1 - s2 # {1} 属于s1但不属于s2

      补集 ^ :返回不同的的元素

      s1 = {1, 2, 3}

      s2 = {2, 3, 4}

      s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)

    4. 子集<:判断一个集合的所有元素是否完全在另一个集合中,完全被包含

    5. 超集>:判断一个集合是否具有另一个集合的所有元素,完全包含

      s1 = {1, 2, 3}

      s2 = {2, 3}

      s2 < s1 # True

      s1 > s2 # True

    6. 相同或不同== !=:判断集合中的所有元素是否和另一个集合相同。

      s1 = {1, 2, 3}

      s2 = {3, 2, 1}

      s1 == s2 # True

      s1 != s2 # False

      子集或相同,超集或相同 <= >=

  • 集合推导式

    1. 定义:

      使用简易方法,将可迭代对象转换为集合。

    2. 语法:

      {表达式 for 变量 in 可迭代对象}

      {表达式 for 变量 in 可迭代对象 if 条件}

固定集合 frozenset

  • 定义: 不可变的集合。

  • 作用:固定集合可以作为字典的键,还可以作为集合的值。

  • 基础操作

    • 创建固定集合:frozenset(可迭代对象)
  • 运算: 等同于set

你可能感兴趣的:(python基础知识)