和其它容器如:列表、元组一样，字符串也可以通过下标进行访问

从前向后，下标从0开始

从后向前，下标从-1开始
# 通过下标蔡取特定位置字符
name ="itheima"
print(name[0]) # 结果i
print(name[-11]) # 结果a
示例：
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，值是：{value}，取下标为-16的元素，值是：{value2}")

2）无法修改性

同元组一样，字符串是一个: 无法修改的数据容器。

所以:

修改指定下标的宇符 (如:字符串[0]=“a”)
移除特定下标的宁符 (如: del 宇符串[0]、宇符串.remove()、宇符串,pop()等)

追加字符等 (如:字符串.append())

均无法完成如果必须要做，只能得到一个新的字符串

3）字符串的常用操作

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

语法: 字符串.index(字符串)
my_str = "itcast and itheima"
print(my_str.index("and")) # 结果7
示例：
# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")

字符串的替换

语法: 字符串,replace(字符串1，字符串2)

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

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

示例：
# replace方法
new_my_str  = my_str.replace("it", "程序")
print(f"将字符串{my_str}进行替换后得到：{new_my_str}")

字符串的分割

语法: 字符串.split(分隔符字符串)

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

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

示例：
# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}分割后，得到一个新的列表对象为:{my_str_list}")

字符串的规整操作(去前后空格)

语法: 字符串.strip()
my_str =" itheima and itcast "
print(my_str.strip())    # 结果:"itheima and itcast"
字符串的规整操作(去前后指定字符串)

语法: 字符串.strip(字符串)
my_str = "12itheima and itcast21"
print(my_str.strip("12"))  # 结果:"itheima and itcast"
注意，传入的是“12”其实就是:”1”和”2”都会移除，是按照单个字符，将12划分为两个小子串

示例：
# strip方法
my_str = " itheima and itcast "
new_my_str = my_str.strip()  # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果为：{new_my_str}")
 
my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip后，结果为：{new_my_str}")
注意：不传入参数，去除首尾空格

统计字符串中某字符中出现次数
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"结果是：{count}")

统计字符串的长度


my_str = "itheima and itcast"
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

4）字符串常用操作汇总

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串index(字符串)	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1,字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个熟

5）字符串的遍历：

同列表、元组一样，字符串也支持while循环和for循环进行遍历

6）字符串的特点：

作为数据容器，字符串有如下特点:

只可以存储字符串

长度任意 (取决于内存大小)

支持下标索引

允许重复字符串存在

不可以修改(增加或删除元素等)

支持for循环

7）练习案例：


# 练习案例：
my_str = "itheima itcast boxuegu"
count = my_str.count("it")
print(f"字符串{my_str}中一个有{count}个it字符")
 
new_my_str = my_str.replace(" ", "|")
print(f"字符串{my_str}被替换后的结果为：{new_my_str}")
 
my_str_list = new_my_str.split("|")
print(f"字符串{my_str}，按照|进行字符串分割后，得到：{my_str_list}")

以上就是这次小小练习案例的代码

六、数据容器(序列)的切片

1）什么是序列？

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

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

2）序列的常用操作-切片

序列支持切片，即:列表、元组、字符串，均支持进行切片操作

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

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

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

起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾

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

步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)

注意，此操作不会影响序列本身，而是会得到一个新的序列(列表、元组、字符串)

序列 [起始:结束:步长]

起始可以皆略，省骆从头开始

结束可以省略，省略到尾结束

步长可以省略，省骆步长为1(可以为负数，表示倒序执行)

示例操作：


# 对list进行切片， 从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4] #步长默认为1，且取值为前开后闭
print(f"结果1：{result1}")
 
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]  # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")
 
# str进行切片，从头开始，到最后结索，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
 
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]  # 等同于将序列反转了
print(f"结果4：{result4}")
 
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[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}")

3）练习案例


# 练习作业
my_str = "万过薪月,员序程马黑来,nohtyP学"
# 第一种方法 先整体倒序，再切片取出
result1 = my_str[::-1]
result2 = result1[9:14:]
print(result2)
 
# 第二种方法 先切片 再倒序
result3 = my_str[5:10:]
result4 = result3[::-1]
print(result4)
 
# 第三种方法 用spilt分割，再用replace替换来，再倒序
my_str_list = my_str.split(",")
new_my_str_list = str(my_str_list).replace("来", "")
result5 = new_my_str_list[14:9:-1]
print(result5)

运行效果：

想要选择哪一种方法都可以，只要自己用的顺手就好

最后一种方法的简洁写法：


# 第三种方法的简便写法
result6 = my_str.split(",")[1].replace("来", "")[::-1]
print(result6)

七、数据容器: set(集合)

我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。
为何又需要学习新的集合类型呢?

通过特性来分析:

列表可修改、支持重复元素且有序

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

局限就在于:它们都支持重复元素

如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。

1）集合的定义


# 基础语法：
# 定义集合字面量
{元素，元素，......，元素}
# 定义集合变量
变量名称 = {元素，元案，......，元素》
# 定义空集合
变量名称 = set()

和列表、元组、字符串等定义基本相同:

列表使用:[] 有序、可重复、可被修改

元组使用:() 有序、可重复、不可被修改

字符串使用:" " 有序、可重复、可被修改

集合使用:{} 无序、不重复、可被修改

需要注意的是：

集合不支持重复的元素

并且集合是无序的

2）集合的常用操作 - 修改

首先，因为集合是无序的，所以集合不支持: 下标索引访问

但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法：

添加新元素

语法:集合.add(元素)。将指定元素，添加到集合内

结果:集合本身被修改，添加了新元素


my_set = {"He11o"，"world"}
my_set. add("itheima")
print(my_set) # 结果{'He11o"，"itheima，"world'}

示例：


# 定义集合
my_set = {"happy", "itheima", "python", "happy", "itheima", "python"}
my_set_empty = set()    # 定义空集合
print(f"my_set的内容是：{my_set}，类型是{type(my_set)}")
print(f"my_set的内容是：{my_set_empty}，类型是{type(my_set_empty)}")
 
# 添加新元素
my_set.add("learn")
print(f"添加元素后的结果是：{my_set}")

移除元素

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

结果:集合本身被修改，移除了元素

示例：
# 移除元素
my_set.remove("itheima")
print(f"移除元素后的结果是：{my_set}")

从集合中随机取出元素

语法:集合.pop()，功能，从集合中随机取出一个元素

结果:会得到一个元素的结果。同时集合本身被修改，元素被移除3
my_set = {"Hello"，"world"，"itheima"}
element = my_set.pop()
print(myset)   # 结果 {'world"，"itheima'}
print(element)  # 结果'He11o'
示例：
# 随机取出一个元素
my_set = {"happy", "itheima", "python", "learn"}
element = my_set.pop()
print(f"随机取出一个元素{element}后的集合为：{my_set}")

清空集合


# 清空集合
my_set.clear()
print(f"清空集合后，结果是{my_set}")

下面注意：这个在学习之前的数据容器中都没有接触到噢：

取出2个集合的差集

语法:集合1.difference(集合2)，功能: 取出集合1和集合2的差集(集合1有而集合2没有的)

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

去异留同
setl = {1，2，3}
set2 = {1，5，6}
set3 = set1.difference(set2)
print(set3)  # 结果:{2，3}    #得到的新集合
print(set1)  # 结果:{1，2，3}  不变
print(set2)  # 结果.{1，5，6} 不变

消除2个集合的差集

语法:集合1.difference(集合2)，功能: 取出集合1和集合2的差集(集合1有而集合2没有的)

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

去同存异
setl = {1，2，3}
set2 = {1，5，6}
set3 = set1.difference(set2)
print(set3)    # 结果:{2，3}
print(set1)    # 结果:{1，2，3} 不变
 print(set2)   # 结果.{1，5，6} 不变

2个集合合并

语法:集合1.union(集合2)
功能:将集合1和集合2组合成新集合
结果:得到新集合，集合1和集合2不变
setl = {1，2，3}
set2 = {1，5，6}
set3 = set1.union(set2)
print(set3)  # 结果:{1，2，3，5，6}，新集合
print(set1)  # 结果，{1，2，3}，set1不变
print(set2)  # 结果:{1，5，6}，set2不变

统计集合元素数量


# 统计集合元素数量
set1 = {1, 2, 3, 4, 5, 6}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

集合的遍历

集合不支持下标索引，不能用while循环

可以用for循环
# 集合的遍历
set1 = {1, 2, 3, 4, 5, 6}
for i in set1:
    print(f"集合的元素是：{i}")

3）集合常用功能总结

编号	操作	说明
1	集合,add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear0)	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的2个集合内容不变
6	集合1.difference update(集合2)	在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变
8	len集合)	得到一个整数，记录了集合的元素数量

4）集合的特点

可以容纳多个数据

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

数据是无序存储的(不支持下标索引)

不允许重复数据存在

可以修改(增加或删除元素等 )

支持for循环

5）练习案例


# 练习案例
my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast']
# 定义一个空集合
my_set = set()
# 遍历列表
for element in my_list:
    my_set.add(element)
 
print(f"集合为：{my_set}")

八、数据容器: dict(字典、映射)

1）字典的定义

为什么要使用字典？

字典的定义，同样使用 {} ,不过存储的元素是一个个的: 键值对 如下语法：


# 定义字典字面量
{key: value, key: value,  ...., key: value}
# 定义字典变量
my_dict = {key: value, key: value,......,key: value}
# 定义空字典 
my_dict = {}    #空字典定义方式1
my_dict = dict()   #空宇典定义方式2

2）字典的常用操作

字典数据的获取

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value
# 语法，字典[Key]可以取到对应的value
stu_score = {"王力鸿": 99，"周杰轮": 88，"林俊节": 77}
print(stu_score["王力鸿"])   # 结果99
print(stu_score["周杰轮"])   # 结果88
print(stu_score["林俊节"])   # 结果77

字典的嵌套

字典的Key和Value可以是任意数据类型(Key不可为字典)

那么，就表明，字典是可以嵌套的

需求如下:记录学生各科的考试信息


# 定义嵌套字典
stu_score_dict = {
    "lxl": {
        "语文": 100,
        "数学": 100,
        "英语": 100
    }, "asd":{
        "语文": 90,
        "数学": 90,
        "英语": 90
    }, "sdf":{
        "语文": 80,
        "数学": 80,
        "英语": 80
    }
}
print(f"学生的考试信息是：{stu_score_dict}")
# 从嵌套字典中获取数据
chinese_score = stu_score_dict["asd"]["语文"]
print(f"asd的语文成绩是：{chinese_score}")

新增元素

语法: 字典[Key]= Value，结果: 字典被修改，新增了元素
my_dict = {"zhoujielun": 99, "linjunjie": 88, "zhangxueyou": 77}
my_dict["zhangxinzhe"] = 66
print(f"字典经过新增元素后，结果为：{my_dict}")

更新元素

语法:字典[Key]= Value，结果: 字典被修改，元素被更新

注意: 字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
my_dict = {"zhoujielun": 99, "linjunjie": 88, "zhangxueyou": 77}
my_dict["zhangxinzhe"] = 66
print(f"字典经过新增元素后，结果为：{my_dict}")
# 更新字典
my_dict["zhoujielun"] = 33
print(f"字典经过更新后，结果为：{my_dict}")

删除元素


# 删除元素
score = my_dict.pop("zhoujielun")
print(f"字典删除元素后，结果为：{my_dict}")

清空元素


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

获取全部的key


# 获取全部的key
my_dict = {"zhoujielun": 99, "linjunjie": 88, "zhangxueyou": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")

遍历字典


for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

3）字典的常用操作总结

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key]=Value	添加或更新键值对
3	宇典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

4）字典的特点

经过上述对字典的学习，可以总结出字典有如下特点:

可以容纳多个数据

可以容纳不同类型的数据

每一份数据是KevValue键值对

可以通过Key获取到Value，Key不可重复 (重复会覆盖)

不支持下标索引

可以修改(增加或删除更新元素等)

支持for循环，不支持while循环

5）练习案例


# 练习案例
staff_info_dict = {
    "王力宏": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    }, "周杰伦": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
 
    }, "林俊杰": {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
 
    }, "张学友": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
 
    }, "刘德华": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}
print(f"全体员工当前信息如下：{staff_info_dict}")
for name in staff_info_dict:
    new_info_dict = staff_info_dict[name]
    for level in new_info_dict:
        if new_info_dict[level] == 1:
            new_info_dict["级别"] = 2
            new_info_dict["工资"] += 1000
 
print(f"完成加薪操作后，信息为：{staff_info_dict}")


# 另一种版本
    if staff_info_dict[name]["级别"] == 1:
        employee_info_dict = staff_info_dict[name]
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 1000
        staff_info_dict[name] = employee_info_dict

# 个人觉得两层循环更好理解一些

ok，以上就是今天学习的部分数据容器的知识啦

还有剩下一部分是关于所有数据容器的总结比较，今天先更新到这里咯

一起愉快的学习python吧lol

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/426073