无权限

Derrick博客站
  1. 文章博客
  2. Python

编辑

评论

收藏

点赞

分享

Python数据容器

Python 更新：2025-08-06 浏览：129 收藏：0 点赞：0

1、什么是数据容器

（1）一种可以用来存储多个元素的Python数据类型
（2）共有5种数据容器：list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

2、列表的定义

列表中，每个元素的数据类型可以是不一样的
# 定义变量
变量名称 = [元素1,元素2,元素3 ]
# 定义空列表
变量名称 = []

  • 列表定义的实例

    # 定义列表
name_list = ["zhangsan","lisi","wangwu"]
print(name_list)   # ['zhangsan', 'lisi', 'wangwu']
print(type(name_list))   # <class 'list'>


# 嵌套列表
my_list = [[1,2,3,],[4,9]]
print(my_list)   # [[1, 2, 3], [4, 9]]
print(type(my_list))    # <class 'list'>

3、列表的下标索引

通过下标索引取出相应位置的数据，语法：列表[索引位置]
从前往后取数据，从0开始，每次+1
从后往前取数据，从-1开始，每次-1

list =[1,5,9,7,15,3]

# 从前往后读取第一个、第二个数据
print(list[0])   # 1
print(list[1])   # 5

# 从后往前读取第一个、第二个数据
print(list[-1])   # 3
print(list[-2])   # 15

# 读取嵌套数据
my_list = [[1,2,3,],[4,9]]
print(my_list[1][1])   # 9

4、列表的操作

（1）查询操作

  • 查找某元素下标

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

    • 语法：列表.index(元素)

      name_list = ["zhangsan","lisi","wangwu"]
index = name_list.index("zhangsan")
print(index)   # 0

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

    • 语法：列表.count(元素)

      list=[1,2,3,4,1,3,4,3,1]
num = list.count(1)
print(f"在这个列表中一共有{num}个1")   # 在这个列表中一共有3个1

  • 统计列表内，有多少元素

    • 语法：len(列表)

      list=[1,2,3,4,1,3,4,3,1]
num = len(list)
print(f"在这个列表中一共有{num}个元素")   # 在这个列表中一共有9个元素

（2）增加操作

  • 插入元素

    • 功能：在指定的下标位置，插入指定的元素

    • 语法：列表.insert(下标, 元素)

      name_list = ["zhangsan","lisi","wangwu"]
name_list.insert(1,"lihua")
print(name_list)   # ['zhangsan', 'lihua', 'lisi', 'wangwu']

  • 追加元素

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

    • 语法：列表.append(元素)

      name_list = ["zhangsan","lisi","wangwu"]
name_list.append("lihua")
print(name_list)   # ['zhangsan', 'lisi', 'wangwu', 'lihua']

  • 追加数据容器

    • 功能：将指定数据容器，追加到列表的尾部

    • 语法：列表.extend(数据容器)

      name_list = ["zhangsan","lisi","wangwu"]
name_list.extend(["lihua","liliu"])
print(name_list)   # ['zhangsan', 'lis', 'wangwu', 'lihua', 'liliu']

（3）删除操作

  • 删除元素（无返回值），根据下标

    • 语法：del 列表[下标]

      name_list = ["zhangsan","lisi","wangwu"]
del name_list[1]
print(name_list)   # ['zhangsan', 'wangwu']

  • 删除元素（有返回值），根据下标

    • 语法：列表.pop(下标)

      name_list = ["zhangsan","lisi","wangwu"]
name = name_list.pop(1)
print(f"{name}被删除了，删除后的列表为{name_list}")   # lisi被删除了，删除后的列表为['zhangsan', 'wangwu']

  • 删除元素，根据元素内容

    • 语法：列表.remove(元素)

      name_list = ["zhangsan","lisi","wangwu"]
name_list.remove("zhangsan")
print(name_list)   # [&#039;lisi&#039;, &#039;wangwu&#039;]

  • 清空列表

    • 语法：语法：列表.clear()

      name_list = ["zhangsan","lisi","wangwu"]
name_list.clear()
print(name_list)   # []

（4）修改操作

  • 修改特定位置（索引）的元素值：

    • 语法：列表[下标] = 值

      # 正向修改
name_list = ["zhangsan","lisi","wangwu"]
name_list[1]="lihua"
print(name_list)   # ['zhangsan', 'lihua', 'wangwu']

#反向修改
name_list = ["zhangsan","lisi","wangwu"]
name_list[-3]="lihua"
print(name_list)   # ['lihua', 'lisi', 'wangwu']

（5）sort()和sorted()

  • sort()是应用在 list 上的方法，sorted()可以对所有可迭代的对象进行排序操作。

  • list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，

  • 而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

    • sort语法：列表.sort() 括号为空默认升序，列表.sort(reverse=True)为降序

    • sorted语法：sorted(对象)

      num = [1,10,15,2,4,2,7,9]

print(sorted(num))  # 有返回值，不改变本身，默认升序排序
                    # [1, 2, 2, 4, 7, 9, 10, 15]

print(sorted(num,reverse=True))  # 有返回值，不改变本身，降序排序
                    # [15, 10, 9, 7, 4, 2, 2, 1]

num.sort()  # 无返回值，改变本身，默认升序排序
print(num)  # [1, 2, 2, 4, 7, 9, 10, 15]

num.sort(reverse=True)  # 无返回值，改变本身，降序排序
print(num)  # [15, 10, 9, 7, 4, 2, 2, 1]

 

5、元组的定义

元组和列表一样，都是可以存储多个不同数据类型的元素在内
但是元组一旦定义完成，就不可以修改了
而列表定义完成，可以修改
# 元组的定义
变量名称 = ( 元素1,元素2,元素3 )
# 定义空列表
变量名称 = ()

  • 实例展示
    【注】：元组只有一个数据，这个数据后面要添加逗号

    # 定义3个元素的元组
t1 = ("zhangsan",11,True)

# 定义1个元素的元组
t2 = ("zhangsan",)

# 定义嵌套元组
t3 = ((1,2,3),(4,5))

6、元组的操作

（1）查找某个数据所在位置 - index()

t1 = ("zhangsan",11,True)
print(t1.index(11))  # 1

（2）统计某个数据出现次数 - count()

t2 = (1,2,3,4,7,1,2,3,1)
print(t2.count(1))  # 3

（3）统计一共有几个元素 - len()

t2 = (1,2,3,4,7,1,2,3,1)
print(len(t2))

 

7、字符串

字符串和元组一样，是一个不可以修改的，所以说和元组一样没有增加、删除、修改操作

  • 查找特定字符串的下标索引值

    str = "weclome to this it times"
print(str.index("o"))

  • 字符串的替换

    • 语法：字符串.replace(字符串1，字符串2）

    • 功能：将字符串内的全部：字符串1，替换为字符串2

    • 注意：不是修改字符串本身，而是得到了一个新字符串哦

      str = "weclome to this it times"
new_str = str.replace("it","happy")
print(new_str)   # weclome to this happy times

  • 字符串的分割

    • 语法：字符串.split(分隔符字符串）

    • 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

    • 注意：字符串本身不变，而是得到了一个列表对象

      str = "weclome to this it times"
new_str = str.split(" ")
print(new_str)   # ['weclome', 'to', 'this', 'it', 'times']

  • 字符串的规整操作

    • 去前后空格语法：字符串.strip()

    • 去前后指定字符串语法：字符串.strip(字符串)
      如果传入一大串字符串，是按照单个字符去除

    • 还是一样，不是修改字符串本身，而是得到了新的字符串

      # 去前后空格
str = "   weclome to this it times  "
new_str = str.strip()
print(new_str)   # weclome to this it times

# 去前后指定字符串
str = "12weclome to this it times2w1"
new_str = str.strip("12w")
print(new_str)   # eclome to this it times

  • 统计字符串中某字符串的出现次数

    • 语法：字符串.count(字符串)

      str = "bea abf xvd bea scx"
print(str.count("bea"))   # 2

  • 统计字符串的长度

    • 语法：len(字符串)

      str = "bea abf xvd bea scx"
print(len(str))

8、序列的切片操作

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
切片：从一个序列中，取出一个子序列

  • 切片操作

    • 语法：序列[起始下标:结束下标:步长]

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

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

    • 步长表示，依次取元素的间隔

# 从头到尾切片，步长默认1
list = [1,5,7,2,10,41,1]
new_list = list[:]
print(new_list)   # [1, 5, 7, 2, 10, 41, 1]

# 从头到尾切片，步长2
list = [1,5,7,2,10,41,1]
new_list = list[::2]
print(new_list)   # [1, 7, 10, 1]

# 从第1个到第4个切片，步长默认1
list = [1,5,7,2,10,41,1]
new_list = list[0:4]
print(new_list)   # [1, 5, 7, 2]

# 从尾到头切片，步长默认1
list = [1,5,7,2,10,41,1]
new_list = list[::-1]
print(new_list)   # [1, 41, 10, 2, 7, 5, 1]

# 从倒数第一到第2个切片，步长默认1
list = [1,5,7,2,10,41,1]
new_list = list[6:0:-1]
print(new_list)   # [1, 41, 10, 2, 7, 5]

9、集合

列表可修改、支持重复元素且有序
元组、字符串不可修改、支持重复元素且有序
如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。
而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
因此因为集合是无序的，所以集合不支持：下标索引访问
# 定义集合
name = {"zhangsan","lihua","wangwu"}

# 定义空集合
name = set()

  • 添加新元素

    • 语法：集合.add(元素)

    • 功能：将指定元素，添加到集合内

      name = {"zhangsan","lihua","wangwu"}
name.add("liming")
print(name)   # {'liming', 'lihua', 'zhangsan', 'wangwu'}

  • 移除元素

    • 语法：集合.remove(元素)

    • 功能：将指定元素，从集合内移除

      name = {"zhangsan","lihua","wangwu"}
name.remove("lihua")
print(name)   # {'wangwu', 'zhangsan'}

  • 从集合中随机取出元素

    • 语法：集合.pop()

    • 功能：从集合中随机取出一个元素

      name = {"zhangsan","lihua","wangwu"}
name.pop()
print(name)   # {'zhangsan', 'wangwu'}

  • 清空集合

    • 语法：集合.clear()

    • 功能：清空集合

      name = {"zhangsan","lihua","wangwu"}
name.clear()
print(name)   # set()

  • 取出2个集合的差集

    • 语法：集合1.difference(集合2)

    • 功能：取出集合1和集合2的差集（集合1有而集合2没有的）

    • 结果：得到一个新集合，集合1和集合2不变

      set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set3)   # {2, 3}

  • 移除两个集合中都存在的元素。

    • 语法：集合1.difference_update(集合2)

    • 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

    • 结果：集合1被修改，集合2不变

      set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1)   # {2, 3}

  • 2个集合合并

    • 语法：集合1.union(集合2)

    • 功能：将集合1和集合2组合成新集合

    • 结果：得到新集合，集合1和集合2不变

      set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3)    # {1, 2, 3, 5, 6}

  • 查看集合的元素数量

    • 语法：len(集合)

    • 功能：统计集合内有多少元素

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

10、字典

字典和集合一样不允许有重复的元素

 

评论

快捷导航

把好文章收藏到微信

打开微信，扫码查看

关闭
×
  • 微信支付
  • 支付宝支付
微信支付二维码

￥{{ payArticleData.total_amount }}

请使用手机微信扫一扫
扫描二维码支付

支付宝支付二维码

￥{{ payArticleData.total_amount }}

请使用手机支付宝扫一扫
扫描二维码支付

请先勾选协议再支付哦

还没有账号？立即注册