深入解析Python数据容器

业界资讯 2025-04-09 20:42
0 阅读

Python数据容器

1，数据容器介绍

  • Python中，数据容器是一种可以容纳多份数据的Python数据类型；
  • 容纳的每一份数据称之为1个元素；
  • 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等；

2，数据容器的分类

数据容器根据特点的不同可分为五类 ，分别是：
列表（list)、元组（tuple）、字符串（str）、集合（set）、字典（dict）；

五种数据容器各有特点，但都可以满足容纳多个元素的特性，接下来将对其进行一一介绍。

3，数据容器：list（列表）

3.1，列表的定义

  • 以[]作为标识；
  • 列表内每一个元素之间使用“,（逗号）”隔开；
  • 列表内的每一个数据，称之为元素；
  • 列表可以一次存储多个数据，多个数据可以为不同的数据类型；
  • 列表允许重复数据存在
  • 列表是有序存储（有下标序号）
  • 列表是可以修改的
  • 列表支持嵌套。

案例演示：

# 定义列表1
name_list1 = ['John','Bob','Alice']
# 定义列表2（列表2中元素数据类型不一致）
name_list2 = ['John',666,True]
# 定义列表3（嵌套列表）
name_list3 = [[1,2,3],[4,5,6]]

# 打印输出列表：['John', 'Bob', 'Alice']
print(name_list1)
# 打印输出列表：['John', 'Bob', 'Alice']
print(name_list2)

# 打印输出变量类型：<class 'list'>
print(type(name_list1))
# 打印输出变量类型：<class 'list'>
print(type(name_list2))
# 打印输出变量类型：<class 'list'>
print(type(name_list3))

3.2，列表的下标索引

学习了列表的定义，思考如何从列表中取出特定位置的数据？

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增，我们只需要按照下标索引，即可取得对应位置的元素。

在这里插入图片描述

案例演示：

# 语法：列表[下标索引]
name_list = ['John','Bob','Alice']
print(name_list[0])  # 结果：John
print(name_list[1])  # 结果：Bob
print(name_list[2])  # 结果：Alice

另外一种索引方式是反向索引，也就是从后往前：从-1（代表最后一个元素）开始依次递减。

  • -1代表倒数第一个元素；
  • -2代表倒数第二个元素；
  • -3代表代数第三个元素；
  • …
    在这里插入图片描述

案例演示：

# 语法：列表[下标索引]
name_list = ['John','Bob','Alice']
print(name_list[-1])  # 结果：Alice
print(name_list[-2])  # 结果：Bob
print(name_list[-3])  # 结果：John

如果列表是嵌套的列表，同样支持下标索引。

在这里插入图片描述

案例演示：

# 两层嵌套list
my_list = [[1,2,3],[4,5,6]]

# 获取内层第一个list
print(my_list[0])  # 结果：[1, 2, 3]
# 获取内层第一个list的第一个元素
print(my_list[0][0])   # 结果：1
print(my_list[1][1])   # 结果：5

3.3，列表的常用操作

列表提供了一系列内置的功能，如插入元素、删除元素、清空列表、统计元素个数…
这些功能我们都称之为：列表的方法。

首先我们需要知道什么是方法

上节学习了函数，我们知道函数是一个封装的代码单元，可以提供特定的功能。
在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法。

在这里插入图片描述
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：

  • 函数的使用：num = add(1,2)
  • 方法的使用： 先创建一个Student实例，然后：num=student.add(1,2)（通过一个具体的类调用）

总览列表的常用方法

在这里插入图片描述

3.3.1，查找指定元素下标

语法：列表.index(元素)
功能：查找指定元素在列表的下标，如果找不到，报错ValueError

案例演示：

mylist = ['John','Bob','Alice']

index = mylist.index("Bob")
print(f"Bob在列表中的下标索引值是：{
      
      index}")

运行结果是：Bob在列表中的下标索引值是：1

3.3.2，修改元素值

语法：列表[下标] = 值
功能：修改特定索引处的元素值

案例演示：

mylist = ['John','Bob','Alice']

mylist[0] = "Blank"
print(f"列表元素值被修改后，变为：{
      
      mylist}")

运行结果是：列表元素值被修改后，变为：['Blank', 'Bob', 'Alice']

3.3.3，插入元素

语法：列表.insert(下标，元素)
功能：在指定的下标位，插入指定的元素

案例演示：

# 在John和Bob之间插入一个Rose
mylist = ['John','Bob','Alice']

mylist.insert(1,"Rose")
print(f"插入新元素后，变为：{
      
      mylist}")

运行结果是：插入新元素后，变为：['John', 'Rose', 'Bob', 'Alice']

3.3.4，追加元素

语法：列表.append(元素)
功能：将指定元素，追加到列表的尾部

案例演示：

mylist = ['John','Bob','Alice']

mylist.append(3)
print(f"追加新元素后，变为：{
      
      mylist}")

运行结果是：追加新元素后，变为：['John', 'Bob', 'Alice', 3]

3.3.5，批量追加元素

语法：列表.extend(其他数据容器)
功能：将其他数据容器的内容取出，依次追加到列表尾部

案例演示：

mylist = ['John','Bob','Alice']
mylist2 = ['JD','TB']

mylist.extend([4,5,6])
print(f"批量追加元素后，变为：{
      
      mylist}")
mylist.extend(mylist2)
print(f"批量追加元素后，变为：{
      
      mylist}")

运行结果是：
批量追加元素后，变为：['John', 'Bob', 'Alice', 4, 5, 6]
批量追加元素后，变为：['John', 'Bob', 'Alice', 4, 5, 6, 'JD', 'TB']

3.3.6，元素的删除

元素删除语法1：del 列表[下标]。删除指定索引处的元素
元素删除语法2：列表.pop(下标)。弹出指定元素

案例演示：

# 删除元素方式一
mylist = ['John','Bob','Alice']
del mylist[2]
print(f"删除元素后，变为：{
      
      mylist}")    # 输出：删除元素后，变为：['John', 'Bob']

# 删除元素方式二
mylist = ['John','Bob','Alice']
element = mylist.pop(2)

# 运行结果：删除元素后，变为：['John', 'Bob']，取出的元素是：Alice
print(f"删除元素后，变为：{
      
      mylist}，取出的元素是：{
      
      element}")

以上两种删除都是根据下标删除元素，还有一种删除方式是根据元素内容删除。

语法：列表.remove(元素)
功能：删除指定元素在列表中的第一个匹配项

案例演示：

mylist = [1,2,3,2,3]
mylist.remove(2)  # 从前往后搜索，删除第一个2

print(f"按元素内容删除元素后，变为：{
      
      mylist}")

注意：上述代码只会删除第一个2，如果想删除两个需要调用两次 remove()。

3.3.7，清空列表

语法：列表.clear()
功能：清空列表内容

案例演示：

mylist = [1,2,3,2,3]
mylist.clear()

print(f"列表清空后，变为：{
      
      mylist}")

运行结果是：列表清空后，变为：[]

3.3.8，统计某元素数量

语法：列表.count(元素)
功能：统计某元素在列表内的数量

案例演示：

mylist = [1,2,3,2,3,2]
print(f"列表内该元素数量为：{
      
      mylist.count(2)}")

运行结果是：列表内该元素数量为：3

3.3.9，统计列表元素总数

语法：len(列表)
功能：可以得到一个int型数字，表示列表内的元素数量

案例演示：

mylist = [1,2,3,2,3,2]
print(f"列表内元素数量为：{
      
      len(mylist)}")

运行结果是：列表内元素数量为：6

3.4，列表的遍历

既然数据容器可以存储多个元素，那么就会有需求从容器内依次取出元素进行操作。将容器内元素依次取出进行处理的行为，称之为：遍历、迭代。

3.4.1，while循环遍历列表

案例演示：

mylist = [1,2,3,2,3,2]

index =0
# while循环遍历打印列表元素
while index < len(mylist):
    element = mylist[index]
    print(f"列表的元素：{
      
      element}")

    # index加1，至关重要
    index += 1

运行结果如下：
在这里插入图片描述

3.4.2，for循环遍历链表

语法： for 临时变量 in 数据容器：然后在循环体内对临时变量进行处理

案例演示：

mylist = [1,2,3,2,3,2]

# for循环打印列表元素
for i in mylist:
    print(f"列表的元素：{
      
      i}")

运行结果如下：
在这里插入图片描述

4，数据容器：tuple（元组）

通过之前的学习我们了解到，列表是可以修改的。但如果想要传递的信息不能被篡改，列表就不再合适了。

因此引入了元组。

元组一旦定义完成，就不可修改。
当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。

4.1，元组的定义

  • 以（）作为标识
  • 元组内每一个元素之间使用“,（逗号）”隔开
  • 元组可以一次存储多个数据，多个数据可以为不同的数据类型
  • 元组支持嵌套
  • 元组也可以通过下标索引取出相应值（用法和列表相同 ）
  • 元组内数据是有序存储的（有下标索引 ）
  • 元组不可修改，强行修改会报错
  • 元组允许重复数据存在
  • 但是如果元组内部嵌套了一个list，可以修改元组内list的内容

案例演示：

t1 = (1,"Hello",True)

# 定义空元组方式一
t2 = ()
# 定义空元组方式二
t3 = tuple()

# 元组的嵌套
t4 = ((1,2,3),(4,5,6))

# 通过下标索引取出元素6
element = t4[1][2]
print(element)

print(f"t1的类型是：{
      
      type(t1)}，内容是{
      
      t1}")
print(f"t2的类型是：{
      
      type(t2)}，内容是{
      
      t2}")
print(f"t3的类型是：{
      
      type(t3)}，内容是{
      
      t3}")
print(f"t4的类型是：{
      
      type(t4)}，内容是{
      
      t4}")

运行结果：
在这里插入图片描述

注意特殊情况：定义一个数据的元组，这个数据后面需要添加逗号。 否则不是元组类型。

# 定义元组
t1 = (1)
t2 = (1,)
print(f"t1的类型是{
      
      type(t1)}")
print(f"t2的类型是{
      
      type(t2)}")

运行结果：
在这里插入图片描述

4.2，元组的常用操作

由于元组不可修改，因此元组的相关操作较少。
在这里插入图片描述

案例演示：

t1 = (1,"Hello",True,"IT","Test","Hello")

# 查找某元素索引
num1 = t1.index("IT")
print(f"在元组t1中查找IT，下标是：{
      
      num1}")

# 统计某元素数量
num2 = t1.count("Hello")
print(f"在元组t1中统计元素Hello数量为：{
      
      num2}")

# 计算元组长度
num3 = len(t1)
print(f"元组t1中元素个数为：{
      
      num3}")

t2 = (1,2,[3,4,5])
t2[2][0] = 7
print(f"修改元组内的列表，结果为：{
      
      t2}")   # 修改元组内的列表，结果为：(1, 2, [7, 4, 5])

# 元组的遍历，while循环方式
index = 0
while index < len(t1):
    print(f"while循环遍历，元组的元素有：{
      
      t1[index]}")
    index += 1

# 元组的遍历：for循环方式
for element in t1:
    print(f"for循环遍历，元组中的元素有{
      
      element}")

运行结果：
在这里插入图片描述

5，数据容器：str（字符串）

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

5.1，字符串的定义

  • 字符串同样支持使用while循环或for循环进行遍历

  • 字符串数据容器只能存储字符串

  • 允许重复字符串存在

  • 和列表、元组一样，字符串也可以通过下标进行访问

  • 字符串和元组一样，属于不可修改的数据容器

  • 如果必须修改，只能得到一个新字符串，原字符串无法修改

案例演示：

my_str = "Hello World"

# index()：通过下标索引取值
value = my_str.index("World")
print(f"在字符串my_str中查找World，其起始下标是：{
      
      value}")

运行结果为：在字符串my_str中查找World，其起始下标是：6

5.2，字符串的常用操作

在这里插入图片描述

5.2.1，字符串的替换

语法：字符串.replace(字符串1,字符串2)
功能：将字符串内的全部字符串1替换为字符串2
注意：此函数不是修改的字符串本身，而是得到一个新字符串

案例演示：

my_str = "Hello World"

new_my_str = my_str.replace("Hello", "NIHAO")
print(f"字符串替换后，my_str为：{
      
      my_str}")   # 注意字符串不可修改，此处不会导致原字符串发生变化
print(f"字符串替换后，返回的new_my_str为：{
      
      new_my_str}") # 输出：字符串替换后，返回的new_my_str为：NIHAO World

运行结果为：
在这里插入图片描述

5.2.2，字符串的分割

语法：字符串.split（分割符字符串）
功能：按照指定的分隔字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象

my_str = "Hello World learn python"

my_str_list = my_str.split(" ")
print(f"将字符串my_str进行分割后得到：{
      
      my_str_list}，其类型是：{
      
      type(my_str_list)}")

运行结果为：
在这里插入图片描述

5.2.3，字符串的规整操作

方式一：

语法：字符串.strip()
功能：去除前后空格

my_str = "  12Hello World learn python21       "

new_str = my_str.strip()
print(f"将字符串my_str进行strip后，原字符串为：{
      
      my_str}")
print(f"将字符串my_str进行strip后得到：{
      
      new_str}")

运行结果为：
在这里插入图片描述

方式二

语法：字符串.strip(指定字符串)
功能：去除前后指定字符串

my_str1 = "12Hello World learn python1"
my_str2 = "12Hello World learn python2"
my_str3 = "12Hello World learn python12"

new_str1 = my_str1.strip("12")
new_str2 = my_str2.strip("12")
new_str3 = my_str2.strip("12")
print(f"将字符串my_str1进行strip后得到：{
      
      new_str1}")
print(f"将字符串my_str2进行strip后得到：{
      
      new_str2}")
print(f"将字符串my_str3进行strip后得到：{
      
      new_str3}")

运行结果为：
在这里插入图片描述

注意：

  • strip之后原字符串不变，得到的是新字符串
  • strip(1,2) 将（1，2）划分为两个小子串，只要存在满足任意一个就会被去掉

5.2.4，统计字符串出现的次数

语法：字符串.count(指定字符串)
功能：统计字符串中某指定字符串的出现次数

my_str = "Hello World or learn python"

num = my_str.count("or")
print(f"字符串my_str中or出现的次数为：{
      
      num}")

案例演示：

运行结果为：
在这里插入图片描述

5.2.5，统计字符串长度

语法：len(字符串)
功能：统计字符串长度

案例演示：

my_str = "Hello World"

num = len(my_str)
print(f"字符串my_str长度为：{
      
      num}")

在这里插入图片描述

6，序列

序列是指内容连续、有序、可使用下标索引的一类数据容器。

列表、元组、字符串均可以视为序列。

在这里插入图片描述

6.1，序列的切片

切片是指从一个序列中取出一个子序列。序列支持切片，即：列表、元组、字符串，均支持进行切片操作。

语法：序列[起始下标:结束下标 :步长]
功能：表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。

  • 起始下标可以留空，留空表示从头开始
  • 结束下标可以留空，留空视作截取到结尾
  • 切片操作不会影响原序列本身，而是会得到一个新序列
  • 步长可省略，默认为1
  • 步长表示依次取元素的间隔，步长为负数表示反向取
  • 步长为2表示每次跳过一个元素取，步长N表示每次跳过N-1个元素取

案例演示：

mylist = [1,2,3,4,5,6]

# 对list进行切片，从1开始，4结束（不含4），步长1
result1 = mylist[1:4]
print(f"结果1：{
      
      result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1（原封不动取下来）
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]   # 或my_tuple[::1]
print(f"结果2：{
      
      result2}")

# 对str进行切片，从头开始，到尾结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{
      
      result3}")
# 对str进行切片，从头到尾，步长-1
result4 = my_str[::-1]
print(f"结果4：{
      
      result4}")   # -1表示从后向前取1.相当于逆置

# 对列表进行切片，从3开始到1结束，步长-1
mylist = [1,2,3,4,5,6]
result5 = mylist[3:1:-1]
print(f"结果5：{
      
      result5}")

# 对元组进行切片，从头到尾，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6：{
      
      result6}")

运行结果如下：
在这里插入图片描述

7，数据容器：set（集合）

目前已经学习到的几种数据容器基本已经满足大多数应用场景。但不难发现仍然存在一些局限。

  • 列表可修改、支持重复元素且有序
  • 元组、字符串不可修改，支持重复元素且有序

列表、元组、字符串都支持重复元素。如果场景需要对内容进行去重处理，列表、元组、字符串就不方便了。

因此，我们本节引入集合。集合最主要的特点就是不支持元素的重复。并且集合内容无序。

7.1，集合的定义

  • 集合通过{}定义，多个元素之间使用,隔开
  • 集合可以容纳不同数据类型
  • 集合无序且不重复
  • 集合不支持下标索引访问。（因此集合不是序列）
  • 集合允许修改

案例演示：

# 定义集合
my_set = {
    
    "Hello","Python","World","Hello","Python","World","Hello","Python","World"}
print(f"my_set的内容是：{
      
      my_set}，类型是：{
      
      type(my_set)}")   # 集合不重复且无序

# 定义空集合
my_set_empty = set()

运行结果如下：
在这里插入图片描述

7.2，集合的常用操作

在这里插入图片描述

案例演示：

my_set = {
    
    "Hello","Python","World"}

# 查看集合的元素数量（去重后的）
print(f"集合的长度为：{
      
      len(my_set)}")

# 集合的添加元素操作
my_set.add("IT")
print(f"my_set添加元素后变为： {
      
      my_set}")

# 集合的移除元素操作
my_set.remove("Hello")
print(f"my_set移除元素后变为： {
      
      my_set}")

# 集合的随机取出元素操作
element = my_set.pop()
print(f"my_set随机取出元素后变为： {
      
      my_set}")

# 集合的清空集合操作
my_set.clear()
print(f"my_set集合清空后变为： {
      
      my_set}"

运行结果如下：
在这里插入图片描述

接下来重点介绍集合的一些特殊操作。

取出两个集合的差集

语法：集合1.difference(集合2)
功能 ：取出集合1和集合 2的差集（集合1有而集合2没有的）
结果：得到新集合，集合1和集合2不变

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

# set1和set2本身不变
print(f"set1：{
      
      set1}")
print(f"set2：{
      
      set2}")

print(f"set3：{
      
      set3}")

运行结果如下：
在这里插入图片描述

消除两集合的差集

语法：集合1.difference_update(集合2)
功能：对比集合1和集合 2，在集合1中删除和集合2相同的元素
结果：集合1被修改，集合2不变

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

print(f"set1：{
      
      set1}")
print(f"set2：{
      
      set2}")

运行结果如下：
在这里插入图片描述

两个集合合并

语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

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

print(f"set1：{
      
      set1}")
print(f"set2：{
      
      set2}")
print(f"set3：{
      
      set3}")

运行结果如下：
在这里插入图片描述

集合的遍历

由于集合不支持下标索引，因此一般通过for循环遍历

set1 = {
    
    1,2,6,4,5}
for i in set1:
    print(f"集合的元素有：{
      
      i}")

运行结果如下：
在这里插入图片描述

8，数据容器：dict（字典）

生活中的字典是通过字找到对应的含义，Python中的字典也是一样的道理，可以通过key找到与之对应的value。

在这里插入图片描述

8.1，字典的定义

  • 字典和集合一样，使用{}定义
  • 字典同集合一样，不支持使用下标索引。可通过key找对应的value
  • 字典存储的元素是一个个的键值对
  • 字典可以修改
  • 键值对内key和value通过:分隔
  • 键值对之间使用，分隔
  • key不可重复，重复会对原有数据覆盖
  • key和value可以是任意类型数据（但key不可为字典类型）
# 定义空字典方式一
my_dict2 = {
    
    }
# 定义空字典方式二
my_dict3 = dict()

# 字典定义
my_dict1 = {
    
    "小明":99,"小王":88,"小张":77}
print(f"字典1的内容是：{
      
      my_dict1}。类型是：{
      
      type(my_dict1)}")

# 通过Key找到value
score = my_dict1["小明"]
print(f"小明的考试成绩为：{
      
      score}")

运行结果如下：
在这里插入图片描述

由于key和value可以是任意类型数据（但key不可为字典类型），因此字典可以嵌套。

可将如下表格表达为字典：
在这里插入图片描述

案例演示：

# 定义嵌套字典
stu_score_dict = {
    
    
    "王力鸿":{
    
    
        "语文":77,
        "数学":66,
        "英语":33
    },
    "周杰轮":{
    
    
        "语文":88,
        "数学":86,
        "英语":55
    },
    "林俊节":{
    
    
        "语文":99,
        "数学":96,
        "英语":66
    }
}

print(f"学生的考试信息是 :{
      
      stu_score_dict}")

# 查询嵌套字典信息
score1 = stu_score_dict["周杰轮"]["语文"]
score2 = stu_score_dict["林俊节"]["英语"]
print(f"周杰轮的语文分数是：{
      
      score1}")
print(f"林俊节的英语分数是：{
      
      score2}")

运行结果是：
在这里插入图片描述

8.2，字典的常用操作

在这里插入图片描述

案例演示：

# 演示字典的常用操作
my_dict = {
    
    "a":1, "b":2, "c":3}

# 新增元素
my_dict["d"] = 4
print(f"字典新增元素后，结果是：{
      
      my_dict}")

# 更新元素和新增元素操作一致（无则新增，有则更新）
my_dict["d"] = 5
print(f"字典更新元素后，结果是：{
      
      my_dict}")

# 删除元素
my_dict.pop("a")
print(f"字典删除元素后，结果是：{
      
      my_dict}")

# 清空元素
my_dict.clear()
print(f"字典清空后，结果是：{
      
      my_dict}")

my_dict = {
    
    "a":1, "b":2, "c":3}

# 获取全部的key（可用于字典遍历）
keys = my_dict.keys()
print(f"字典的全部keys是：{
      
      keys}")  # 输出结果字典的全部keys是：dict_keys(['a', 'b', 'c'])

# 字典遍历方式一
for key in my_dict.keys():
    print(f"遍历方式一：key是：{
      
      key}，value是：{
      
      my_dict[key]}")

# 字典遍历方式二（直接对字典进行for循环，每次循环都是直接得到key）
for key in my_dict:
    print(f"遍历方式二：key是：{
      
      key}，value是：{
      
      my_dict[key]}")

# 统计字典内元素数量
num = len(my_dict)
print(f"字典内元素数量为：{
      
      num}个")

运行结果如下：
在这里插入图片描述

9，总结与拓展

9.1，数据容器总结对比

以上几种数据容器可以从如下角度进行简单分类。

是否支持下标索引 ：

  • 支持：列表、元组、字符串（序列类型）
  • 不支持：集合、字典（非序列类型）

是否支持重复元素：

  • 支持：列表、元组、字符串（序列类型）
  • 不支持：集合、字典（非序列类型）

是否可以修改

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

针对各类数据容器的特点，其应用场景如下：

  • 列表：一组数据，可修改，可重复的存储场景；
  • 元组：一组数据，不可修改，可重复的存储场景；
  • 字符串：一串字符串的存储场景；
  • 集合：一组数据，去重的存储场景；
  • 字典：一组数据，可用key检索value的存储场景

9.2，数据容器的通用操作

  • 五类数据容器都支持for循环遍历
  • len()函数：统计容器内元素个数
  • max()函数：统计容器内最大元素
  • min()函数：统计容器的最小元素
  • 字符串的排序和比较实际是按照相应字符的ASCII码值

案例演示：

my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {
    
    1,2,3,4,5}
my_dict = {
    
    "key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

# len()统计元素个数
print(f"列表内元素个数有：{
      
      len(my_list)}")
print(f"元组内元素个数有：{
      
      len(my_tuple)}")
print(f"字符串内元素个数有：{
      
      len(my_str)}")
print(f"集合内元素个数有：{
      
      len(my_set)}")
print(f"字典元素个数有：{
      
      len(my_dict)}")
print("******************************")

# max()最大元素
print(f"列表内最大元素：{
      
      max(my_list)}")
print(f"元组内最大元素：{
      
      max(my_tuple)}")
print(f"字符串内最大元素：{
      
      max(my_str)}")
print(f"集合内最大元素：{
      
      max(my_set)}")
print(f"字典内最大元素：{
      
      max(my_dict)}")
print("******************************")

# min()最小元素
print(f"列表内最小元素：{
      
      min(my_list)}")
print(f"元组内最小元素：{
      
      min(my_tuple)}")
print(f"字符串内最小元素：{
      
      min(my_str)}")
print(f"集合内最小元素：{
      
      min(my_set)}")
print(f"字典内最小元素：{
      
      min(my_dict)}")
print("******************************")

运行结果如下：
在这里插入图片描述

  • list(容器)：将给定容器转换为列表
  • str(容器)：将给定容器转换为字符串
  • tuple(容器)：将给定容器转换为元组
  • set(容器)：将给定容器转换为集合

案例演示：

my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {
    
    1,2,3,4,5}
my_dict = {
    
    "key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

# 容器转列表
print(f"元组转列表，结果为：{
      
      list(my_tuple)}")
print(f"字符串转列表，结果为：{
      
      list(my_str)}")
print(f"集合转列表，结果为：{
      
      list(my_set)}")
print(f"字典转列表，结果为：{
      
      list(my_dict)}")
print("****************")

# 容器转元组
print(f"列表转元组，结果为：{
      
      tuple(my_list)}")
print(f"字符串转元组，结果为：{
      
      tuple(my_str)}")
print(f"集合转元组，结果为：{
      
      tuple(my_set)}")
print(f"字典转元组，结果为：{
      
      tuple(my_dict)}")
print("****************")

# 容器转字符串
print(f"列表转字符串，结果为：{
      
      str(my_list)}")   # 实际上变成了字符串："[1, 2, 3, 4, 5]"
print(f"元组转字符串，结果为：{
      
      str(my_tuple)}")   # 实际上变成了字符串："(1, 2, 3, 4, 5)"
print(f"集合转字符串，结果为：{
      
      str(my_set)}")   # 实际上变成了："{1, 2, 3, 4, 5}"
print(f"字典转字符串，结果为：{
      
      str(my_dict)}")  # 实际上变成："{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}"
print("****************")

# 容器转为集合（集合数据无序）
print(f"列表转集合，结果为：{
      
      set(my_list)}")
print(f"元组转集合，结果为：{
      
      set(my_tuple)}")
print(f"字符串转集合，结果为：{
      
      set(my_str)}")
print(f"字典转集合，结果为：{
      
      set(my_dict)}")
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {
    
    1,2,3,4,5}
my_dict = {
    
    "key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

# 容器转列表
print(f"元组转列表，结果为：{
      
      list(my_tuple)}")
print(f"字符串转列表，结果为：{
      
      list(my_str)}")
print(f"集合转列表，结果为：{
      
      list(my_set)}")
print(f"字典转列表，结果为：{
      
      list(my_dict)}")

运行结果如下：
在这里插入图片描述

注意：dict类型转成str类型会保留value，dict类型转为list、tuple和set时不保留value。

容器的排序操作

语法：sorted(容器,[reverse=True])
功能：将给定容器排序（reverse是反转，默认为False）
结果：排序完成得到一个列表对象

my_list = [5,3,8,7,1]
my_tuple = (7,5,9,3,8)
my_str = "qwerty"
my_set = {
    
    4,9,6,5,8}
my_dict = {
    
    "key3":1,"key5":2,"key1":3,"key2":4,"key4":5}

# 容器排序操作
print(f"列表对象的排序结果为：{
      
      sorted(my_list,reverse=True)}")
print(f"元组对象的排序结果为：{
      
      sorted(my_tuple)}")
print(f"字符串对象的排序结果为：{
      
      sorted(my_str)}")
print(f"字典对象的排序结果为：{
      
      sorted(my_dict)}")

运行结果如下：
在这里插入图片描述

猜你喜欢

目录

热门文章