数据容器

CM Lv3
  2023-07-16 11:13:15 2023-07-16 11:13 Created   2023-07-21 20:04:45 2023-07-21 20:04 Updated    

数据容器

1. 数据容器是什么？

程序中如果要记录多个信息，如果一个个去定义变量会非常麻烦。数据容器就是用一个变量，记录多份数据。也就是可以批量存储和批量使用多份数据，类似于数组！

  • Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素可以是任意类型的数据，比如字符串，数字，bool等等。

  • 数据容器根据特点的不同，比如：

    • 是否支持重复元素
    • 是否可以修改
    • 是否有序
    • 等等

可以分为五类：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）。

2. list（列表）

2.1

基本语法：

1
2
3
4
5
6
7
8
9
#字面量
[元素1，元素2，元素3，……]

#定义变量
变量名称 = [元素1，元素2，元素3，……]

#定义空列表
变量名称 = []
变量名称 = list()
  • 列表中的每一个数据，称之为元素。元素类型可以为不同的数据类型，而且支持嵌套。
  • 以[]作为标识。
  • 列表内每一个元素之间用逗号隔开。

2.2列表的下标索引

通过下标索引取出列表里面特定位置的数据。

语法：

1
列表[下标索引]

与c语言不同，列表的下标可以反向索引。比如最后一个元素的下标标记为-1，倒数第二的下标就是-2，以此类推。（就是你直接引用下标是-1的元素，结果就是最后一个元素。）

总之就是说，想取第一个元素，下标就给0，想取最后一个元素，如果在c语言不知道数组长度的话很麻烦，但是Python里面直接下标是-1取出来就是最后一个元素。

列表嵌套的下标索引：

举个例子：

列表[1][0]

意思就是指有一个列表，第二个元素也是列表，先取出这个列表的第二个元素也就是嵌套的列表，然后再取这个内层列表的第一个元素。写法类似于二维数组，但是含义是不一样的。

  • 如果下标超出列表本身的大小范围就会报错。

2.3列表的常用操作方式

列表的方法（写在类（class）里面的函数就是方法）：

  1. 插入元素
  2. 删除元素
  3. 清空列表
  4. 修改元素
  5. 统计元素个数

列表的查询功能（方法）

  • 查找某个元素的下标。

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：

1
列表.index（元素）

index就是列表对象（变量）内置的方法。

列表的修改功能（方法）

  • 修改列表中的元素
    语法：

    1
    列表频[下标] = 值

  • 向列表中指定位置插入元素
    语法：

    1
    列表.insert(下标，元素)

追加元素

  • 将指定元素，追加到列表的尾部

语法：

1
列表.append(元素)

如果要追加一批元素：

1
列表。extend(其他数据容器)
  • 将其他数据容器的内容取出，依次追加到列表尾部

删除元素

语法1：

1
del 列表[下标]

语法2：

1
列表.pop(下标)

pop这个方法实际上是取出这个元素，并且返回，所以可以定义一个变量去接收这个被取出来的元素。

语法3：

  • 不指定下标，而是指定元素的内容进行删除
  • 从前到后去找这个元素，并且找到的第一个被删掉
    1
    列表.remove(元素)

清空列表

语法:

1
列表.clear()

统计某个元素在列表内的数量

语法：

1
count = 列表.count(元素)

统计列表中总共有多少个元素

语法：

1
count = len(列表)

2.4 列表的特点

  • 列表可以容纳多个元素(上限为2*63-1个)
  • 可以容纳不同类型的元素(混装)
  • 数据是有序存储的(有下标序号)
  • 允许重复数据存在
  • 可以修改(增加或删除元素等等)

2.5 列表的遍历

  • 将容器内的元素依次取出进行处理的行为，称之为：遍历，迭代。

  • 通过while、for循环来遍历列表的元素。

循环条件如何控制？

  • 定义一个变量表示下标，这个变量从0开始。
  • 循环的条件就是 下标值 < 列表的元素数量

for与while的区别：

  1. 循环控制上
  • while循环可以自定义循环条件，自行控制。
  • for不可以自定义循环条件，只可以一个个从容器内取出数据。
  1. 无限循环上
  • while循环可以通过条件控制做到无限循环。
  • for理论上是不可以实现无限循环，因为遍历的容器容量不是无限的。
  1. 在使用场景上：
  • while循环适用于任何想要循环的场景。
  • for循环适用于遍历数据容器的场景或者简单的固定次数循环的场景。

3.元组

3.1 元组的基本概念与定义

有了列表，为什么还需要元组？

  • 因为列表是可以修改的，但是如果响应传递的信息，不被修改，列表就不合适了。

元组一旦定义完成，就不可修改。可以认为元组就是一个只读的list

所以元组应用于我们需要在程序内封装数据，但是又不希望数据被篡改。

定义语法：

1
2
3
4
5
6
7
8
9
10
11
12
# 定义元组字面量
(元素，元素，元素，……)

# 定义元组变量

变量名称 = (元素，元素，元素，……)

# 定义空元组

变量名称= ()

变量名称 = tuple()

注意事项：

  • 如果元组只有一个数据，这个数据后面也要添加括号。否则就不是元组类型了。
  • 元组也可以嵌套(用法参考列表的嵌套)
  • 如果print直接输出元组或者列表的话幂级数把里面的元素都打印出来。（加一个小括号或者中括号。反正就是元组或者列表怎么定义，就怎么打印）

3.2 元组的相关操作

由于元组的不可修改的特性，所以元组的相关操作没有列表那么多。

只有下面三种操作：

  1. index()方法：查找某个数据，如果数据存在就返回对应的下标，否则报错。

  2. count()方法，统计某个数据在当前元组出现的次数。

  3. len(元组)：统计元组内的元素个数。

特别注意：

元组不可以修改，但是如果元组里面嵌套一个list，这个list是可以修改的！

3.3元组的特点

  1. 可以容纳多个数据

  2. 可以容纳不同类型的数据(混装)

  3. 数据是有序存储的(下标索引)

  4. 允许重复数据存在

  5. 不可以修改（除非嵌套了list）

  6. 支持for循环

（多数特点和list一致。不同点在于不可修改的特性）

4. 再识字符串

字符串看上去并不像列表元组那样一看就是存放很多数据的容器。但是不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。

  • 字符串的下标索引和list、元组是一样的。
  • 和元组一样，字符串是一个不可修改的数据容器。

字符串的方法：

  1. index()方法

  2. 字符串.replace(字符串1，字符串2)。功能：将字符串内的全部：字符串1替换为字符串2。注意这里不是修改字符串本身，老的字符串不变，而是得到一个新的字符串，！

  3. 字符串.split(分隔符字符串)。功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象。注意：字符串本身不变，而是得到一个列表对象的。这里的分隔符字符串是你自己定义的，可以是空格，也可以是每一个字符串片段。

  4. 字符串.strip。功能：字符串的规整操作，可以去掉前后空格。strip还可以再传入一个字符串作为参数，就可以去掉前后指定的字符串了。注意：如果参数写的是“12”，并不是只找12的字符串去删掉，而是，只要满足其中一个，也就是满足1或者满足2的我都去掉。

  5. 字符串.count(“指定的字符串”)方法，功能：统计字符串中指定字符串的出现次数。

  6. len(字符串)。功能：统计字符串的字符个数。

字符串特点：

  1. 只可以存储字符串
  2. 长度任意
  3. 支持下标索引
  4. 允许重复字符串存在
  5. 不可以修改！
  6. 支持for循环

5.数据容器(序列)的切片操作

什么是序列？

  • 序列是指：内容连续，有序，可以使用下标索引的一类数据容器。列表，元组，字符串均可以视为序列。

序列支持切片，也就是：列表，元组，字符串支持切片操作。

切片：从一个序列中，取出一个子序列。

语法：

1
序列[起始下标：结束下标：步长]

表示：从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。

  • 起始下标表示从何处开始，可以留空，留空视作从头开始。

  • 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。

  • 步长表示，依次取元素间隔。（步长1表示一个个取元素，步长2表示每次跳过一个元素取，步长N表示，每次跳过N-1个元素取。步长为负数表示，反向取（注意，起始下标和结束下标也要方向标记）

注意：

  • 切片操作并不会影响序列本身，而是会得到新的序列。（因为元组和字符串都不能修改）

写法可以这样子：

1.先倒序字符串再切片取出：

result = my_strp[::-1][9:14]

  1. 先切片取出再倒序：

result = my_strp[5:10][::-1]

这个字符串的操作可以一连串写下来的。

举个例子：

result = my_str(“,”)[1].replace(“来”，””)[::1]

6. set(集合)

为什么还要集合？
列表、元组、字符串都支持元素重复并且有序。

集合最主要的特点就是不支持重复的元素内容，也就是自带去重功能。而且内容是无序的。

定义语法：

  1. 定义集合字面量
    {元素，元素，……}
  2. 定义集合变量
    变量名称 = {变量，变量，……}
  3. 定义空集合
    变量名称 = set()

注意：

  • 定义集合的时候，元素如果有重复的话，运行的话，程序并不会报错，但是重复的内容会自动去重，结果里面就不会重复了。

  • 最后输出显示的时候并不会是定义时候的顺序，所以是乱序的。

因为集合是无序的，所以集合并不支持下标索引访问，集合的下标是没有意义的。所以集合不是序列！

但是集合和列表是一样的，是允许修改的。

集合的常用操作：

  1. 添加新的元素 ： 集合.add(元素)。将指定元素，添加到集合内。

  2. 移除元素 : 集合.remove(元素)，将指定元素，从集合内移除。

  3. 从集合中随机取出元素 ： 集合.pop ，会得到一个元素的结果，同时集合本身被修改，元素被移除。

  4. 清空集合 ： 集合.clear() 。

  5. 取出两个集合的差集 ： 集合1.difference(集合2) 。功能：取出集合1有但是集合2没有的，得到一个新的集合，集合1和集合2不变。

  6. 消除两个集合的差集 ： 集合1.difference_update(集合2) ，功能：在集合1内，删除和集合2相同的元素。结果：集合1被修改，集合2不变。

  7. 两个集合合并 ， 集合1.union(集合2) ，功能：将集合1和集合2组合得到新的集合。 结果： 得到新集合，集合1和集合2不变。

  8. 统计集合元素数量 ， len(集合)。如果元素重复了，按去重以后的数量计算得到结果。

  9. 因为集合不支持下标索引，所以不能用while循环！只能用for循环。

7.dict(字典)

类比于生活中的字典，生活中的字典通过’字’找到对应的‘含义’。

Python通过Key找到对应的Value

字典的定义：

  1. 定义字典字面量

{key:value,key:value,……}

  1. 定义字典变量
    my_dick = {key：value,key:value,……}

  2. 定义空字典
    my_dick = {}
    my_dick = dick()

字典的定义同样**使用{}**，不过存储的元素是一个个的： 键值对

  • Key肯定是不能重复的！因为要通过Key找到value，如果有两个一样的Key，那么用的是哪个value就不知道了。如果两个Key一样，代码不会报错，而是后面的Key的value会覆盖前面那个相同的key的value。

  • 字典是通过key取得对应的value，所以，字典和集合一样，不可以使用下标索引。

使用上来说：

1
字典[key]

就可以得到对应的value

  • 字典的key和value可以是任意的数据类型，除了key不能是字典！

  • 字典也是可以嵌套的。比如姓名作为key，考试成绩作为value，但是考试成绩有好几个科目啊，所以value也是可以作为字典。然后value作为字典，里面的key是语文数学等等科目，然后value是成绩。

  • 从嵌套的字典里面取出value的写法也是类似于二维数组那个样子的。比如：字典[“陈鸣”][“语文”]，取出来就是陈鸣的语文成绩。

字典的常用操作

  1. 新增元素:字典[key] = Value ,结果：字典被修改，新增了元素

  2. 更新元素： 字典[key] = value ，结果：字典被修改，元素被更新。

注意 ：

  • 字典的key不可以重复，所以对已经存在的key执行上述操作，就是更新value值。
  • 如果是嵌套字典，可以直接把第一层的字典所包含的内容先赋值给一个新字典（相当于复制一份新的字典）。然后在这个新的字典上修改信息，最后再反向新的字典直接赋值给第一层字典。（虽然绕了点，但是告诉我们可以直接拿字典作为一个整体直接赋值过去）。
    具体可以看黑马的Python

  1. 删除元素：字典pop(key) ，结果：会返回这个value，然后字典中的这个key和value都会被删除。

  2. 清空元素 ：字典.clear

  3. 获取全部key ：字典.keys() ,结果：获取字典中的全部key

  4. 统计字典的元素数量 ： len(字典)

  5. 获取了全部的key有什么用呢？拿来遍历字典。或者也可以直接对字典进行for循环，每一次循环但是直接得到key。

  6. 字典不支持下标索引，所以不能用while循环。

8. 数据容器对比总结

简单的分类：

  • 是否支持下标索引：

    • 支持：列表，元组，字符串 —序列类型
    • 不支持：集合，字典 —非序列类型

  • 是否支持重复元素：

    • 支持：列表，元组，字符串 —序列类型
    • 不支持：集合，字典 —非序列类型

  • 是否可以修改

    • 支持：列表，集合，字典
      不支持：元组，字符串

Alt text

Alt text

9. 数据容器的通用操作

数据容器尽管各有各的特点，但是它们也有通用的操作：

  1. 遍历：
  • 5类数据容器都支持for循环遍历。
  • 列表，元组，字符串支持while循环。集合，字典不支持(无法下标索引)

尽管遍历的形式各有不同，但是，他们都支持遍历。

  1. 通用的功能方法：
  • len(容器) 统计容器的元素个数
  • max(容器) 统计容器的最大元素
  • min(容器) 统计容器的最新元素

（快捷键： shift + alt + 拖动鼠标 ，可以按列选中）

  1. 容器的通用转换功能：

转换的格式个之前学的数据类型的转换格式是一样的。

比如:

1
list(容器)

将给定的容器转换为列表。注意字符串转列表，是把字符串的每一个字符拿出来当做列表的每一个元素。字典转列表，列表中只存放字典的key。转元组同理。

其他类型转字符串的话，所有元素都可以保留。

转集合的话，记住会乱序并且去重。
字典转集合同样也是舍去了value，只留下了key。

能不能转字典？有这个转换函数，但是字典要的是键值对，所以有函数，但是你转不了。

  1. 容器通用排序功能：
    1
    sorted(容器，[reverse=True])
    reverse默认是false,如果想要想要排序进行反转，那就第二个参数写一个reverse = True进去进行了。否则就不写就是默认参数。

注意：

  • 排序以后的结果都是列表对象！实际上就是对内容进行排序然后放到列表中。所以对字典进行排序，结果只有key，没有value了

10. 拓展：字符串比大小

字符串比较是基于数字的码值大小进行比较的(码值就是ASCII码表里面对应的值)

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

  • Title: 数据容器
  • Author: CM
  • Created at: 2023-07-16 11:13:15
  • Updated at: 2023-07-21 20:04:45
  • Link: https://redefine.ohevan.com/2023/07/16/数据容器/
  • License: This work is licensed under CC BY-NC-SA 4.0.
 Comments
On this page
数据容器
  1. 数据容器
    1. 1. 数据容器是什么？
    2. 2. list（列表）
      1. 2.1
      2. 2.2列表的下标索引
      3. 2.3列表的常用操作方式
      4. 列表的修改功能（方法）
      5. 追加元素
      6. 删除元素
      7. 清空列表
      8. 统计某个元素在列表内的数量
      9. 统计列表中总共有多少个元素
    3. 2.4 列表的特点
    4. 2.5 列表的遍历
    5. 3.元组
      1. 3.1 元组的基本概念与定义
      2. 3.2 元组的相关操作
      3. 3.3元组的特点
    6. 4. 再识字符串
    7. 5.数据容器(序列)的切片操作
    8. 6. set(集合)
      1. 集合的常用操作：
    9. 7.dict(字典)
      1. 字典的常用操作
    10. 8. 数据容器对比总结
    11. 9. 数据容器的通用操作
    12. 10. 拓展：字符串比大小