Python数据容器(五)

简介: 按顺序插入

数据容器

一.数据容器

一种可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素

  • 每一个元素,可以是任意类型的据数,如字符串、数字、布尔等
  • 根据特点的不同可分为5类:列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)


二.列表(list)

列表内的每一个数据,称之为元素

(1) 基本格式

# 定义列表
变量名称 = [元素1, 元素2, 元素3, 元素4, 元素5]
# 定义空列表
变量名称 = []
变量名称 = list()
  • 以中括号 [] 作为标识
  • 列表内每一个元素之间用, 逗号隔开
  • 列表可以一次存储多个数据,且可以为不同的数据类型,支持嵌套
  • 使用示例:
my_list_1 = ["观止", 20, True, ["guanzhi", 20]]
my_list_2 = ["观止", 20, True]
print(my_list_2)
print(type(my_list_1))
# 输出
# ['观止', 20, True]
# <class 'list'>

(2) 列表的下标(索引)

我们可以使用下标索引从列表中取出特定位置的数据

  • 列表中的每一个元素,都有其对应位置下标索引
  • 要注意下标索引的取值范围(有值的位置),超出范围(没值的位置)无法取出元素,并且会报错
  • 语法:变量 = 列表[下标索引]

(2.1) 正向索引

  • 从前向后的方向,从0开始,依次递增
  • 使用示例:
# 语法: 列表[下标索引]
my_list = ["李白", "章北海", "杜甫"]
print(my_list[0]) # 打印 李白
print(my_list[1]) # 打印 章北海
print(my_list[2]) # 打印 杜甫

(2.2) 反向索引

  • 从后向前:从-1开始,依次递减(-1、-2、-3......)
  • 使用示例:
my_list = ["李白", "章北海", "杜甫"]
print(my_list[-1]) # 打印 杜甫
print(my_list[-2]) # 打印 章北海
print(my_list[-3]) # 打印 李白

(2.3) 嵌套列表的索引

  • 如果列表是嵌套的列表,同样支持下标索引,且用法与上述类似
  • 使用示例:
# 语法: 列表[外层列表下标索引][内层列表下标索引]
my_list = [["李白", "章北海"], ["罗辑", "杜甫"]]
print(my_list[0][0]) # 打印 李白
print(my_list[0][1]) # 打印 章北海
print(my_list[1][0]) # 打印 罗辑
print(my_list[1][1]) # 打印 杜甫

(3) 列表的常用操作

列表提供了一系列方法:如果将函数定义为class(类)的成员,那么函数称之为:方法

使用方式

作用

列表.append(元素)

向列表中追加一个元素

列表.extend(容器)

将数据容器的内容依次取出,追加到列表尾部

列表.insert(下标, 元素)

在指定下标处,插入指定的元素

del 列表[下标]

删除列表指定下标元素

列表.pop(下标)

删除列表指定下标元素

列表.remove(元素)

从前向后,删除此元素第一个匹配项

列表.clear()

清空列表

列表.count(元素)

统计此元素在列表中出现的次数

列表.index(元素)

查找指定元素在列表的下标  找不到报错ValueError

len(列表)

统计容器内有多少元素

  • 不需要硬记下来,有一个模糊印象,知晓有这样的用法,需要的时候,随时查阅资料即可

(3.1) 查询元素

查找某元素的下标

  • 查找指定元素在列表的下标,如果找不到,报错ValueError
  • 语法:列表.index(元素)
my_list = ["李白", "章北海", "罗辑", "杜甫"]
print(my_list.index("罗辑")) # 打印 2
print(my_list.index("观止")) # 打印 ValueError: '观止' is not in list

(3.2) 修改元素

修改特定位置(索引)的元素值

  • 直接对指定下标(正向、反向下标均可)的值进行:重新赋值(修改)
  • 语法一:列表[下标] = 值
my_list = ["李白", "章北海", "罗辑", "杜甫"]
my_list[0] = "观止"
my_list[-1] = "study"
print(my_list) # 打印 ['观止', '章北海', '罗辑', 'study']

(3.3) 插入元素

在指定的下标位置,插入指定的元素

  • 语法:列表.insert(下标, 元素)
my_list = ["李白", "章北海", "罗辑"]
my_list.insert(1, "观止")
print(my_list) # 打印 ['李白', '观止', '章北海', '罗辑']

(3.4) 追加元素

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

  • 语法一:列表.append(元素)
my_list = ["李白", "章北海", "罗辑"]
my_list.append("观止")
print(my_list) # 打印 ['李白', '章北海', '罗辑', '观止']
  • 语法一:列表.extend(其它数据容器)
  • 将其它数据容器的内容取出,依次追加到列表尾部
my_list_1 = ["李白", "章北海"]
my_list_2 = ["罗辑", "观止"]
my_list_1.extend(my_list_2)
print(my_list_1) # 打印 ['李白', '章北海', '罗辑', '观止']

(3.5) 删除元素

  • 语法一:del 列表[下标]
my_list = ["李白", "章北海", "罗辑"]
del my_list[0]
print(my_list) # 打印 ['章北海', '罗辑']
  • 语法二:列表.pop(下标)
my_list = ["李白", "章北海", "罗辑"]
my_list.pop(0)
print(my_list) # 打印 ['章北海', '罗辑']
  • 语法三:列表.remove(元素)
  • 删除某元素在列表中的第一个匹配项
my_list = ["李白", "章北海", "罗辑", "李白"]
my_list.remove("李白")
print(my_list) # 打印 ['章北海', '罗辑', '李白']

(3.6) 清空列表内容

  • 语法:列表.clear()
my_list = ["李白", "章北海", "罗辑"]
my_list.clear()
print(my_list) # 打印 []

(3.7) 统计某元素在列表内的数量

  • 语法:列表.count(元素)
my_list = ["李白", "章北海", "罗辑", "李白"]
num = my_list.count("李白")
print(num) # 打印 2

(3.8) 统计列表内有多少元素

  • 语法:len(列表)
my_list = ["李白", "章北海", "罗辑", "李白"]
print(len(my_list)) # 打印 4

(4) 列表的遍历

将容器内的元素依次取出进行处理的行为,称之为:遍历、迭代。

  • 可以使用循环遍历列表的元素
  • 通过列表[下标]的方式在循环中取出列表的元素
  • 循环条件为 下标值 < 列表的元素数量

(4.1) while循环遍历

  • 基本格式
index = 0
while index < len(列表):
    元素 = 列表[index]
#    对元素进行处理
    index += 1
  • 使用示例:
my_list = [1,2,3,4]
index = 0
while index < len(my_list):
    num = my_list[index]
    print(num)
    index += 1 
# 输出
# 1
# 2
# 3
# 4

(4.2) for循环遍历

  • 依次取出元素并赋值到临时变量上,在每一次的循环中,可以对临时变量(元素)进行处理。
  • 基本格式:
for 临时变量 in 数据容器:
    对临时变量(元素)进行处理
  • 使用示例:
my_list = [1, 2, 3, 4]
for x in my_list:
    print(x)
# 输出
# 1
# 2
# 3
# 4

(4.3) for与while对比

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

(5) 列表小结

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

三.元组(tuple)

元组同列表一样,但一旦定义完成,就不可修改

(1) 基本格式

# 定义元组
变量名称 = (元素1, 元素2, 元素3, 元素4, 元素5)
# 定义只有一个元素的元组
变量名称 = (元素1,)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
  • 以小括号 () 作为标识
  • 列表内每一个元素之间用, 逗号隔开
  • 列表可以一次存储多个数据,且可以为不同的数据类型,支持嵌套
  • 使用示例:
my_tuple_1 = ("观止", 20, True, ("guanzhi", 20))
my_tuple_2 = ("观止", 20, True)
print(my_tuple_2)
print(type(my_tuple_1))
# 输出
# ('观止', 20, True)
# <class 'tuple'>
  • 元组只有一个数据,这个数据后面要添加逗号,否则不是元组
my_tuple = ("观止")
print(type(my_tuple)) # 打印 <class 'str'>
my_tuple = ("观止",)
print(type(my_tuple))  # 打印 <class 'tuple'>
  • 嵌套元组使用:
# 获取值方式与列表一致
my_tuple = ((1, 2, 3), (4, 5, 6))
print(my_tuple[0][0]) # 打印 1

(2) 元组的常用操作

元组由于不可修改的特性,所以其操作方法非常少。

方法

作用

元组.index(元素)

查找某个数据,如果数据存在返回对应的下标,否则报错

元组.count(元素)

统计某个数据在当前元组出现的次数

len(元组)

统计元组内的元素个数

(2.1) 查询元素

  • 根据下标(索引)取出数据
  • 语法:元组[下标索引]
my_tuple = ("观止", True, 20)
print(my_tuple[0])  # 打印 观止
  • 查找特定元素的第一个匹配项
  • 语法:元组.index(元素)
my_tuple = ("观止", True, "观止")
print(my_tuple.index("观止"))  # 打印 0

(2.2) 统计操作

  • 统计某个数据在元组内出现次数
  • 语法一:元组.count(元素)
my_tuple = ("观止", True, "观止")
print(my_tuple.count("观止"))  # 打印 2
  • 统计元组内元素个数
  • 语法二:len(元组)
my_tuple = ("观止", True, "观止")
print(len(my_tuple))  # 打印 3

(2.3) 注意事项

  • 不可以修改元组的内容,否则会直接报错
my_tuple = (1, True, "观止")
my_tuple[0] = 5 # 报错 'tuple' object does not support item assignment
  • 可以修改元组内的list的内容(修改元素、增加、删除、反转等)
my_tuple = (1, True, [2, 3, 4])
my_tuple[2][0] = 5
print(my_tuple) # 打印 (1, True, [5, 3, 4])
  • 不可以替换list为其它list或其它类型
my_tuple = (1, True, [2, 3, 4])
my_tuple[2] = [1, 2, 3] # 报错

(3) 元组小结

  • 可以与列表一样使用for与while循环遍历
  • 多数特性和list一致,不同点在于不可修改的特性
  • 可以容纳多个数据
  • 可以容纳不同类型的数据(混装)
  • 数据是有序存储的(下标索引)
  • 允许重复数据存在
  • 不可以修改(增加或删除元素等)

四.字符串(str)

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

  • 同元组一样,字符串是一个无法修改的数据容器

(1) 索引取值

  • 同列表、元组一样,字符串也可以通过下标进行访问
  • 从前向后,下标从0开始
  • 从后向前,下标从-1开始
name = "guanzhi"
print(name[0])  # 打印 g
print(name[-1])  # 打印 i

(2) 字符串的常用操作

操作

说明

字符串[下标]

根据下标索引取出特定位置字符

字符串.index(字符串)

查找给定字符的第一个匹配项的下标

字符串.replace(字符串1, 字符串2)

将字符串内的全部字符串1,替换为字符串2  不会修改原字符串,而是得到一个新的

字符串.split(字符串)

按照给定字符串,对字符串进行分隔  不会修改原字符串,而是得到一个新的列表

字符串.strip()  字符串.strip(字符串)

移除首尾的空格和换行符或指定字符串

字符串.count(字符串)

统计字符串内某字符串的出现次数

len(字符串)

统计字符串的字符个数

(2.1) 查找元素

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

  • 语法:字符串.index(字符串)
name = "guanzhi"
print(name.index("a"))  # 打印 2

(2.2) 替换元素

将字符串内的全部:字符串1,替换为字符串2

  • 语法:字符串.replace(字符串1,字符串2)
name = "guanzhi"
new_name = name_1.replace("guan", "study")
print(name)  # 打印 guanzhi
print(new_name)  # 打印 studyzhi
  • 不是修改字符串本身,而是得到了一个新字符串

(2.3) 分割元素

按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中

  • 语法:字符串.split(分隔符字符串)
name = "guanzhi,study,20"
new_list = name.split(",")
print(name)  # 打印 guanzhi,study,20
print(new_list)  # 打印 ['guanzhi', 'study', '20']
print(type(new_list))  # 打印 <class 'list'>
# 字符串按照给定的,进行了分割,变成多个子字符串,并存入一个列表对象中
  • 字符串本身不变,而是得到了一个列表对象

(2.4) 规整操作

  • 去前后空格
  • 语法一:字符串.strip()
name = "  guanzhi  "
new_name = name.strip()
print(new_name)  # 打印 guanzhi
  • 去前后指定字符串
  • 语法二:字符串.strip(字符串)
name = "20guanzhi20"
new_name = name.strip("20")
print(name)  # 打印 20guanzhi20
print(new_name)  # 打印 guanzhi
  • 字符串本身不变,而是得到了一个新字符串

(2.5) 统计操作

  • 统计字符串中某字符串的出现次数
  • 语法一:字符串.count(字符串)
name = "20guanzhi20"
print(name.count("20"))  # 打印 2
  • 统计字符串的长度
  • 语法二:len(字符串)
name = "20guanzhi 20"
print(len(name))  # 打印 12
  • 数字(1、2、3...),字母(abcd、ABCD等),符号(空格、!、@、#、$等),中文均算作1个字符

(3) 字符串小结

  • 同列表、元组一样,字符串也支持while循环和for循环进行遍历
  • 特点:
  • 只可以存储字符串
  • 长度任意(取决于内存大小)
  • 支持下标索引
  • 允许重复字符串存在
  • 不可以修改(增加或删除元素等)
  • 基本和列表、元组相同
  • 不同与列表和元组的在于:字符串容器可以容纳的类型是单一的,只能是字符串类型。
  • 不同于列表,相同于元组的在于:字符串不可修改

五.数据容器(序列)的切片

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


切片:从一个序列中,取出一个子序列

  • 序列的典型特征就是:有序并可用下标索引,字符串、元组、列表均满足这个要求
  • 序列支持切片,即:列表、元组、字符串,均支持进行切片操作

(1) 基本格式

  • 语法:序列[起始下标:结束下标:步长]
  • 表示从序列中,从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列:
  • 起始下标表示从何处开始,可以留空,留空视作从头开始
  • 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾
  • 步长表示,依次取元素的间隔
  • 步长1表示,一个个取元素
  • 步长2表示,每次跳过1个元素取
  • 步长N表示,每次跳过N-1个元素取
  • 步长为负数表示,反向取(注意,起始下标和结束下标也要反向标记)

(2) 基本用法

  • 用法
  • 起始下标可以省略,省略从头开始
  • 结束下标可以省略,省略到尾结束
  • 步长可以省略,省略步长为1(可以为负数,表示倒序执行)
  • 用法一:
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]  # 下标1开始,下标4(不含)结束,步长1
print(new_list)  # 结果:[2, 3, 4]
  • 用法二:
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]  # 从头开始,到最后结束,步长1
print(new_tuple)  # 结果:(1, 2, 3, 4, 5)
  • 用法三:
my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]       # 从头开始,到最后结束,步长2
print(new_list)       # 结果:[1, 3, 5]
  • 用法四:
my_str = "12345"
new_str = my_str[:4:2]  # 从头开始,到下标4(不含)结束,步长2
print(new_str)  # 结果:"13"
  • 用法五:
my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]  # 从下标3开始,到下标1(不含)结束,步长-1(倒序)
print(new_list)  # 打印 [4, 3]
  • 注:
  • 这个操作对列表、元组、字符串是通用的
  • 此操作不会影响序列本身,而是会得到一个新的序列(列表、元组、字符串)
  • 起始位置,结束位置,步长(正反序)都是可以自行控制的

六.集合(set)

不支持元素的重复(自带去重功能)、并且内容无序

(1) 基本格式

# 定义集合
变量名称 = {元素1, 元素2, 元素3, 元素4, 元素5}
# 定义空集合
变量名称 = set()
  • 以大括号 {} 作为标识
  • 集合内每一个元素之间用, 逗号隔开
  • 集合可以一次存储多个数据,且可以为不同的数据类型,支持嵌套
  • 使用示例:
my_set = {"观止", True, "观止"}
print(my_set)  # 打印 {True, '观止'}
  • 去重且无序

(2) 集合的遍历

集合不支持下标索引,所以也就不支持使用while。

  • 因为集合是无序的,所以集合不支持下标索引访问
my_set = {"观止", True, "观止"}
for i in my_set:
    print(i)
# 打印
# True
# 观止

(3) 集合的常用操作

操作

说明

集合.add(元素)

集合内添加一个元素

集合.remove(元素)

移除集合内指定的元素

集合.pop()

从集合中随机取出一个元素

集合.clear()

将集合清空

集合1.difference(集合2)

得到一个新集合,内含2个集合的差集  原有的2个集合内容不变

集合1.difference_update(集合2)

在集合1中,删除集合2中存在的元素  集合1被修改,集合2不变

集合1.union(集合2)

得到1个新集合,内含2个集合的全部元素  原有的2个集合内容不变

len(集合)

得到一个整数,记录了集合的元素数量

(3.1) 增加元素

  • 集合本身被修改,将指定元素,添加到集合内
  • 语法:集合.add(元素)
my_set = {"观止", True, "观止"}
my_set.add("study")
print(my_set)  # 打印 {'观止', True, 'study'}

(3.2) 移除元素

  • 集合本身被修改,将指定元素,从集合内移除
  • 语法一:集合.remove(元素)
my_set = {"观止", True, "观止"}
my_set.remove("观止")
print(my_set)  # 打印 {True}
  • 从集合中随机取出一个元素,同时集合本身被修改,元素被移除
  • 语法二:集合.pop()
my_set = {"观止", True}
num = my_set.pop()
print(my_set)  # 打印 {'观止'}
print(num)  # 打印 True


  • 清空集合,集合本身被清空
  • 语法三:集合.clear()
my_set = {"观止", True}
my_set.clear()
print(my_set)  # 打印 set()

(3.3) 两集合操作

  • 取出集合1和集合2的差集(集合1有而集合2没有的),得到一个新集合,集合1和集合2不变
  • 语法一:集合1.difference(集合2)
my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_3 = my_set_1.difference(my_set_2)
print(my_set_1)  # 打印 {1, 2}
print(my_set_2)  # 打印 {1, 3}
print(my_set_3)  # 打印 {2}
  • 对比集合1和集合2,在集合1内,删除和集合2相同的元素,集合1被修改,集合2不变
  • 语法二:集合1.difference_update(集合2)
my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_1.difference_update(my_set_2)
print(my_set_1)  # 打印 {2}
print(my_set_2)  # 打印 {1, 3}
  • 将集合1和集合2组合成新集合(去重),集合1和集合2不变
  • 语法三:集合1.union(集合2)
my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_3 = my_set_1.union(my_set_2)
print(my_set_1)  # 打印 {1, 2}
print(my_set_2)  # 打印 {1, 3}
print(my_set_3)  # 打印 {1, 2, 3}

(3.4) 集合长度

  • 查看集合的元素数量,统计集合内有多少元素
  • 语法四:len(集合)
my_set = {1, 3}
print(len(my_set))  # 打印 2

(4) 集合小结

  • 特点:
  • 可以容纳多个数据
  • 可以容纳不同类型的数据(混装)
  • 数据是无序存储的(不支持下标索引)
  • 不允许重复数据存在
  • 可以修改(增加或删除元素等)

七.字典、映射(dict)

Python中字典和生活中字典十分相像

(1) 基本格式

# 定义字典
变量名称 = {key:value, key:value, key:value}
# 定义空字典
变量名称 = {}
变量名称 = dict()
  • 使用{}存储原始,每一个元素是一个键值对
  • 每一个键值对包含Key和Value(用冒号分隔)
  • 键值对之间使用逗号分隔
  • Key和Value可以是任意类型的数据(key不可为字典)
  • Key不可重复,重复会对原有数据覆盖
  • 使用示例:
my_dict = {"观止": 99, "李白": 120, "观止": 110}
print(my_dict)  # 打印 {'观止': 110, '李白': 120}
print(type(my_dict))  # 打印  <class 'dict'>

(2) 数据的获取

  • 字典同集合一样,不可以使用下标索引取值
  • 字典可以通过Key值来取得对应的Value
my_dict = {"李白": 120, "观止": 110}
print(my_dict["李白"])  # 打印 120
  • 字典的Key和Value可以是任意数据类型(Key不可为字典),即字典是可以嵌套的
my_dict = {
    "李白": {"语文": 110, "数学": 100}, 
    "观止": {"语文": 90, "数学": 120}
}
print(my_dict["李白"])  # 打印 {'语文': 110, '数学': 100}
print(my_dict["李白"]["语文"])  # 打印 110
  • 字典不支持下标索引,同样不可以用while循环遍历
my_dict = {"李白": 120, "观止": 110}
for name in my_dict:
    print(f"key为:{name},value为:{my_dict[name]}")
# 打印
# key为:李白,value为:120
# key为:观止,value为:110

(3) 字典的常用操作

操作

说明

字典[Key]

获取指定Key对应的Value值

字典[Key] = Value

添加或更新键值对

字典.pop(Key)

取出Key对应的Value并在字典内删除此Key的键值对

字典.clear()

清空字典

字典.keys()

获取字典的全部Key,可用于for循环遍历字典

len(字典)

计算字典内的元素数量

(3.1) 新增元素

  • 字典被修改,新增了元素
  • 如果key不存在字典中执行上述操作,就是新增元素
  • 语法:字典[Key] = Value
my_dict = {"李白": 120, "观止": 110}
my_dict["罗辑"] = 115
print(my_dict)  # 打印 {'李白': 120, '观止': 110, '罗辑': 115}

(3.2) 更新元素

  • 字典被修改,元素被更新
  • 字典Key不可以重复,所以对已存在的Key执行上述操作,就是更新Value值
  • 语法:字典[Key] = Value
my_dict = {"李白": 120, "观止": 110}
my_dict["李白"] = 115
print(my_dict)  # 打印 {'李白': 115, '观止': 110}

(3.3) 删除元素

  • 获得指定Key的Value,同时字典被修改,指定Key的数据被删除
  • 语法:字典.pop(Key)
my_dict = {"李白": 120, "观止": 110}
name = my_dict.pop("李白")
print(name)  # 打印 120
print(my_dict)  # 打印 {'观止': 110}

(3.4) 清空字典

  • 字典被修改,元素被清空
  • 语法:字典.clear()
my_dict = {"李白": 120, "观止": 110}
my_dict.clear()
print(my_dict)  # 打印 {}

(3.5) 获取全部的key

  • 得到字典中的全部Key
  • 语法:字典.keys()
my_dict = {"李白": 120, "观止": 110}
my_keys = my_dict.keys()
print(my_keys)  # 打印 dict_keys(['李白', '观止'])

(3.6) 计算字典内键值对数量

  • 得到一个整数,表示字典内元素(键值对)的数量
  • 语法:len(字典)
my_dict = {"李白": 120, "观止": 110}
print(len(my_dict))  # 打印 2

(4) 字典小结

  • 特点:
  • 可以容纳多个数据
  • 可以容纳不同类型的数据
  • 每一份数据是Key-Value键值对
  • 可以通过Key获取到Value,Key不可重复(重复会覆盖)
  • 不支持下标索引
  • 可以修改(增加或删除更新元素等)

八.数据容器对比总结

(1) 简单分类

  • 是否支持下标索引
  • 支持:列表、元组、字符串 - 序列类型
  • 不支持:集合、字典 - 非序列类型
  • 是否支持重复元素:
  • 支持:列表、元组、字符串 - 序列类型
  • 不支持:集合、字典 - 非序列类型
  • 是否可以修改
  • 支持:列表、集合、字典
  • 不支持:元组、字符串

(2) 特点对比

列表

元组

字符串

集合

字典

元素数量

支持多个

支持多个

支持多个

支持多个

支持多个

元素类型

任意

任意

仅字符

任意

Key:Value  Key:除字典外任意类型  Value:任意类型

下标索引

支持

支持

支持

不支持

不支持

重复元素

支持

支持

支持

不支持

不支持

可修改性

支持

不支持

不支持

支持

支持

数据有序

使用场景

可修改、可重复的一批数据记录场景

不可修改、可重复的一批数据记录场景

一串字符的记录场景

不可重复的数据记录场景

以Key检索Value的数据记录场景

(3) 应用场景

  • 列表:一批数据,可修改、可重复的存储场景
  • 元组:一批数据,不可修改、可重复的存储场景
  • 字符串:一串字符串的存储场景
  • 集合:一批数据,去重存储场景
  • 字典:一批数据,可用Key检索Value的存储场景

功能

描述

通用for循环

遍历容器(字典是遍历key)

max

容器内最大元素

min()

容器内最小元素

len()

容器元素个数

list()

转换为列表

tuple()

转换为元组

str()

转换为字符串

set()

转换为集合

sorted(序列, [reverse=True])

排序,reverse=True表示降序  得到一个排好序的列表

(4) 通用操作-遍历

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

(5) 通用操作-统计

(5.1)统计容器的元素个数

  • 语法:len(容器)
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(len(my_list))  # 结果 3
print(len(my_tuple))  # 结果 5
print(len(my_str))  # 结果 7

(5.2) 统计容器的最大元素

  • 语法:max(容器)
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(max(my_list))  # 结果 3
print(max(my_tuple))  # 结果 5
print(max(my_str))  # 结果 z

(5.3) 统计容器的最小元素

  • 语法:min(容器)
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(min(my_list))  # 结果 1
print(min(my_tuple))  # 结果 1
print(min(my_str))  # 结果 a

(5.4) 字符串大小比较

  • ASCII码表:

  • 在程序中,字符串所用的所有字符如:大小写,英文单词,数字特殊符号(!、\、|、@、#、空格等),都有其对应的ASCII码表值
  • 每一个字符都能对应上一个:数字的码值,字符串进行比较就是基于数字的码值大小进行比较的。
  • 字符串是按位比较,也就是一位位进行对比,只要有一位大,那么整体就大:

(6) 通用操作-排序

  • 将给定容器进行排序,排序后都会得到列表(list)对象。
  • 语法:sorted(容器, [reverse=True])
my_list = [1, 4, 2]
my_list_asc = sorted(my_list)
print(my_list_asc)  # 结果 [1, 2, 4]
my_list_des = sorted(my_list, reverse=True)
print(my_list_des)  # 结果 [4, 2, 1]


(7) 通用操作-转换

  • 将给定容器转换为列表
  • 语法一:list(容器)
my_tuple = (1, 4, 2) 
print(type(my_tuple))  # 打印 <class 'tuple'>
my_list = list(my_tuple)
print(type(my_list))  # 打印 <class 'list'>
  • 将给定容器转换为字符串
  • 语法二:str(容器)
my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_str = str(my_tuple)
print(type(my_str))  # 打印 <class 'str'>
  • 将给定容器转换为集合
  • 语法三:set(容器)
my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_set = set(my_tuple)
print(type(my_set))  # 打印 <class 'set'>
  • 将给定容器转换为元组
  • 语法四:tuple(容器)
my_list = [1, 4, 2]
print(type(my_list))  # 打印 <class 'list'>
my_tuple = tuple(my_list)
print(type(my_tuple))  # 打印 <class 'tuple'>
目录
相关文章
|
8天前
|
数据挖掘 索引 Python
Python数据挖掘编程基础3
字典在数学上是一个映射,类似列表但使用自定义键而非数字索引,键在整个字典中必须唯一。可以通过直接赋值、`dict`函数或`dict.fromkeys`创建字典,并通过键访问元素。集合是一种不重复且无序的数据结构,可通过花括号或`set`函数创建,支持并集、交集、差集和对称差集等运算。
15 9
|
5天前
|
数据采集 数据挖掘 数据处理
Python中实现简单爬虫并处理数据
【9月更文挑战第31天】本文将引导读者理解如何通过Python创建一个简单的网络爬虫,并展示如何处理爬取的数据。我们将讨论爬虫的基本原理、使用requests和BeautifulSoup库进行网页抓取的方法,以及如何使用pandas对数据进行清洗和分析。文章旨在为初学者提供一个易于理解的实践指南,帮助他们快速掌握网络数据抓取的基本技能。
17 3
|
8天前
|
存储 索引 Python
python中的数据容器
python中的数据容器
|
7天前
|
数据采集 存储 监控
如何使用 Python 爬取京东商品数据
如何使用 Python 爬取京东商品数据
24 0
|
8天前
|
数据挖掘 Python
Python数据挖掘编程基础8
在Python中,默认环境下并不会加载所有功能,需要手动导入库以增强功能。Python内置了诸多强大库,例如`math`库可用于复杂数学运算。导入库不仅限于`import 库名`,还可以通过别名简化调用,如`import math as m`;也可指定导入库中的特定函数,如`from math import exp as e`;甚至直接导入库中所有函数`from math import *`。但需注意,后者可能引发命名冲突。读者可通过`help(&#39;modules&#39;)`查看已安装模块。
14 0
|
8天前
|
人工智能 数据挖掘 Serverless
Python数据挖掘编程基础
函数式编程中的`reduce`函数用于对可迭代对象中的元素进行累积计算,不同于逐一遍历的`map`函数。例如,在Python3中,计算n的阶乘可以使用`reduce`(需从`funtools`库导入)实现,也可用循环命令完成。另一方面,`filter`函数则像一个过滤器,用于筛选列表中符合条件的元素,同样地功能也可以通过列表解析来实现。使用这些函数不仅使代码更加简洁,而且由于其内部循环机制,执行效率通常高于普通的`for`或`while`循环。
14 0
|
8天前
|
分布式计算 数据挖掘 Serverless
Python数据挖掘编程基础6
函数式编程(Functional Programming)是一种编程范型,它将计算机运算视为数学函数计算,避免程序状态及易变对象的影响。在Python中,函数式编程主要通过`lambda`、`map`、`reduce`、`filter`等函数实现。例如,对于列表`a=[5,6,7]`,可通过列表解析`b=[i+3 for i in a]`或`map`函数`b=map(lambda x:x+3, a)`实现元素加3的操作,两者输出均为`[8,9,10]`。尽管列表解析代码简洁,但其本质仍是for循环,在Python中效率较低;而`map`函数不仅功能相同,且执行效率更高。
6 0
|
8天前
|
数据挖掘 Python
Python数据挖掘编程基础5
函数是Python中用于提高代码效率和减少冗余的基本数据结构,通过封装程序逻辑实现结构化编程。用户可通过自定义或函数式编程方式设计函数。在Python中,使用`def`关键字定义函数,如`def pea(x): return x+1`,且其返回值形式多样,可为列表或多个值。此外,Python还支持使用`lambda`定义简洁的行内函数,例如`c=lambda x:x+1`。
16 0
|
8天前
|
数据挖掘 Python
Python数据挖掘编程基础
判断与循环是编程的基础,Python中的`if`、`elif`、`else`结构通过条件句来执行不同的代码块,不使用花括号,依赖缩进区分代码层次。错误缩进会导致程序出错。Python支持`for`和`while`循环,`for`循环结合`range`生成序列,简洁直观。正确缩进不仅是Python的要求,也是一种良好的编程习惯。
17 0
|
16天前
|
Linux iOS开发 Docker
Docker:容器化技术的领航者 —— 从基础到实践的全面解析
在云计算与微服务架构日益盛行的今天,Docker作为容器化技术的佼佼者,正引领着一场软件开发与部署的革命。它不仅极大地提升了应用部署的灵活性与效率,还为持续集成/持续部署(CI/CD)提供了强有力的支撑。
198 69
下一篇
无影云桌面