Python入门——数据容器（list( 列表 ) 、 tuple( 元组 ) 、 str( 字符串 ) 、 set( 集合 ) 、 dict( 字典 )）

目录

1.列表：

列表的下标索引：

列表的常用操作（方法）：

列表的特点：

2.元组

元组的常用操作（方法）：

Python如何删除包含在元组（tuple）中的列表（list）中的某个元素

元组的相关操作 - 注意事项

元组的特点：

3.字符串 

字符串的常用操作（方法）：

字符串的特点：

小试牛刀练习——分割字符串

序列的切片

小试牛刀练习——切片和倒序的用法

4.集合：

集合的常用操作：

集合的特点：

小试牛刀练习——信息去重

5.字典：

字典的特点：

小试牛刀练习——升职加薪

---

1.列表：

(1)列表的下标索引：

（注意：要注意下标索引的取值范围，超出范围无法取出元素，并且会报错）

①从前向后的方向，从 0 开始，依次递增。#语法:列表[下标索引]

②反向索引，从后向前:从-1开始，依次递减( -1、-2、-3...... )  #语法:列表[标号]

③嵌套列表下标索引

a_list = [[2,4,6,8,0,3],["num","sum","max","min"]]

print(a_list[1][3])  #输出是min

(2)列表的常用操作（方法）：

功能		使用方法	作用
查找		列表[下标索引]	使用下标索引获取值
		列表 .index( 元素 )	查找指定元素在列表的下标，找不到报错 ValueError
修改	赋值	列表 [ 下标 ] = 值	重新赋值
	插入	列表 .insert( 下标 , 元素 )	在指定的下标位置，插入指定的元素
	追加	列表 .append( 元素 )	将指定元素，追加到列表的尾部
		列表 .extend( 其它数据容器 )	将其它数据容器的内容取出，依次追加到列表尾部
	删除	del 列表 [ 下标 ]	仅删除列表指定下标元素
		列表 .pop( 下标 )	删除并可取出元素作为返回值得到
		列表 .remove( 元素 )	从前向后，删除此元素第一个匹配项
	清空	列表 .clear()	清空列表
统计		列表 .count( 元素 )	统计此元素在列表中出现的次数
		len( 列表 )	统计容器内有多少元素

(3)列表的特点：

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

2.元组

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

(1)元组的常用操作（方法）：

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

功能	方法	作用
查找	元组.index()	查找某个数据，如果数据存在返回对应的下标，否则报错
统计	元组.count()	统计某个数据在当前元组出现的次数
	len( 元组 )	统计元组内的元素个数

Python如何删除包含在元组（tuple）中的列表（list）中的某个元素

a_tuple = ('十个勤天',10,['farmer','crop'])
print(a_tuple.index(10))
print(a_tuple[0])
element = a_tuple[2].pop(1) #删除元组中的列表的元素
print(f"删除的元素是{element}，目前的元组为{a_tuple}")

a_tuple[2].append("learning")#在元组中的列表中增加元素
print(f"目前的元组为{a_tuple}")

（2）元组的相关操作 - 注意事项

1. 不可以修改元组的内容，否则会直接报错
2. 可以修改元组内的 list 的内容（修改元素、增加、删除、反转等）
3. 但不可以替换 list 为其它 list 或其它类型

（3）元组的特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）
• 支持 for 循环

多数特性和 list 一致，不同点在于不可修改的特性（但可以修改内部 list 的内部元素）

3.字符串 

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

如，字符串： "itheima"

字符串是一个无法修改的数据容器，如果必须做修改，只能得到一个新的字符串，旧的字符串是无法修改。

（1）字符串的常用操作（方法）：

功能	用法	作用
索引	字符串[下标]	根据下标索引取出特定位置字符
	字符串 .index( 字符串 )	查找给定字符的第一个匹配项的下标
替换	字符串 .replace( 字符串 1 ，字符串 2 )	将字符串内的全部：字符串 1 ，替换为字符串 2(不是修改字符串本身，而是得到了一个新字符串）
分割	字符串 .split( 分隔符字符串）	按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中（字符串本身不变，而是得到了一个列表对象）
规整	字符串 .strip()	（不传参）移除首尾的空格和换行符
规整	字符串 .strip(字符串)	（传参）移除指定字符串
统计	字符串 .count( 字符串 )	统计字符串中某字符串的出现次数
统计	len( 字符串 )	统计字符串的长度（各种数字、单个字母、符号（空格、 ! 、 @ 、 # 、 $ 等）、中文均算作 1 个字符）

注意：查找特定字符串的下标时，查找的是一个单词，显示的下标时单词第一个字母的下标

a_str = "Hope every day counts !"
print(a_str.index("counts"))

（2）字符串的特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持 for 循环

（3）小试牛刀练习——分割字符串

要求
①给一个字符串

②统计字符串内有多少个某个字符
③将字符串内的空格，全部替换为字符： "|"
④并按照 "|" 进行字符串分割，得到列表 

my_str ="Hope I every is happy,active,hardworking,to make every day count,to become best"
print(my_str.count("to"))
replace_my_str =my_str.replace(" ","|")
print(replace_my_str)
replace_my_str_2 =replace_my_str.split("|")
print(replace_my_str_2)

补充拓展：序列的切片

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

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

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

（左闭右开，从0开始）

• 起始可以省略，省略从头开始
• 结束可以省略，省略到尾结束
• 步长可以省略，省略步长为 1 （可以为负数，表示倒序执行）

此操作不影响序列本身，而是生成一个新的序列（列表、元组、字符串）

小试牛刀练习——切片和倒序的用法

#（1）倒序字符串，切片取出
a_str ="’人农新‘的样一不做争，强做大做，地种力努，天勤个十"
result1 = a_str[::-1][:4]
print(result1)

#切片取出，然后倒序
result2 =a_str[22:26][::-1]
print(result2)

# #split分隔"，"，倒序字符串
result3 =a_str.split("，")[3][::-1]
print(result3)

4.集合：

（1）集合的常用操作：

功能		用法	作用
修改	添加新元素	集合 .add( 元素 )	将指定元素，添加到集合内（集合本身被修改，添加了新元素）
	移除元素	集合 .remove( 元素 )	将指定元素，从集合内移除（集合本身被修改，移除了元素）
	取出元素	集合 .pop()	从集合中随机取出一个元素（会得到一个元素的结果。同时集合本身被修改，元素被移除）
	清空集合	集合 .clear()	集合本身被清空
	取出 2 个集合的差集	集合 1.difference( 集合 2)	取出集合 1 和集合 2 的差集（集合 1 有而集合 2 没有的），得到一个新集合，集合 1 和集合 2 不变
	消除 2 个集合的差集	集合 1.difference_update( 集合 2)	对比集合 1 和集合 2 ，在集合 1 内，删除和集合 2 相同的元素。集合 1 被修改，集合 2 不变
	2 个集合合并	集合 1.union( 集合 2)	将集合 1 和集合 2 组合成新集合，得到新集合，集合 1 和集合 2 不变
统计		len( 集合 )	统计集合内有多少元素

（2）集合的特点：

去重且无序，不支持：下标索引访问，可修改

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

（3）小试牛刀练习——信息去重

定义一个列表对象，里面的元素值有重复，要求：
• 定义一个空集合
• 通过 for 循环遍历列表
• 在 for 循环中将列表的元素添加至集合
• 最终得到元素去重后的集合对象，并打印输出

my_list = ['good',' cool ', 'nice',' nice ', ' good ', ' well ','good', 'best']
empty_set = set()
for x in my_list:
    print(x)
    empty_set.add(x)

print(empty_set)

5.字典：

字典的定义，同样使用 {} ，不过存储的元素是一个个的：键值对。字典可以实现用 key 取出 Value 的操作。

字典数据的获取：

字典同集合一样，不可用下标索引，但字典可通过 Key 值来取得对应的 Value

a_dict = {"今年":"2024","明年":"2025"}
print(a_dict["今年"]) #用的是[key]

字典的嵌套

a_dict = {
    "张三":{"语文":77,"数学":66,"英语":33},
    "李四":{"语文":88,"数学":86,"英语":55},
    "老六":{"语文":99,"数学":96,"英语":66}
}

#嵌套字典的内容获取
print(a_dict)
person_score =a_dict["老六"]
print(person_score)

score =a_dict["老六"]["语文"]
print(score)

（1）字典的常用操作：

功能	用法	作用
新增元素	字典 [Key] = Value	字典被修改，新增了元素
更新元素		字典 Key 不可以重复，所以对已存在的 Key 执行操作，就是更新 Value 值
删除元素	字典 .pop(Key)	获得指定 Key 的 Value ，同时字典被修改，指定 Key 的数据被删除
清空字典	字典 .clear()	字典被修改，元素被清空
获取全部的 key	字典 .keys()	得到字典中的全部 Key
遍历字典	for key in 字典 .keys()	字典不支持下标索引，所以同样不可以用 while 循环遍历
计算字典内的元素数量	len( 字典 )	计算字典内的全部元素（键值对）数量

（2）字典的特点：

• 可以容纳多个数据
• 键值对的 Key 和 Value 可以是任意类型（ Key 不可为字典）
• 每一份数据是 KeyValue 键值对
• 可以通过 Key 获取到 Value ， Key 不可重复（重复会覆盖）
• 不支持下标索引，而是通过 Key 检索 Value
• 可以修改（增加或删除更新元素等）
• 支持 for 循环，不支持 while 循环

（3）小试牛刀练习——升职加薪

使用字典完成数据的记录。并通过 for 循环，对所有级别为 13级的员工，级别上升 1 级，薪水增加 1000 元

a_dict = {
    "大哥":{"部门":"管理部","工资":10000,"级别":1},
    "二哥":{"部门":"科技部","工资":9000,"级别":2},
    "三哥":{"部门":"科技部","工资":9000,"级别":2},
    "四哥":{"部门":"市场部","工资":8000,"级别":3},
    "五哥":{"部门":"市场部","工资":8000,"级别":3},
}
print(a_dict)

for name in a_dict:
    if a_dict[name]["级别"] != 3:  #获取name里面的key的value
        a_dict[name]["级别"] = 2
        a_dict[name]["工资"] +=1000
print(a_dict)