深度学习python基础(第四节) 元组、字符串、集合和字典-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_55383558/article/details/145304274

本节主要介绍元组,字符串,集合,字典的基本语法定义,以及相关的操作.

元组的定义和操作

元组一旦定义完成就不可修改.

"""
# 定义元组字面量
(元素，元素，....,元素) # 元素可以不同的数据类型

# 定义元组变量
变量名称 = (元素，元素，....,元素)

# 定义空元组
变量名称 = ()方式1
变量名称 = tuple()方式2

"""

# 定义元组
t1 = (1,"love",True)
t2 = ()
t3 = tuple()

print(f"t1的类型是:{type(t1)},内容为:{t1}")
print(f"t2的类型是:{type(t2)},内容为:{t2}")
print(f"t3的类型是:{type(t3)},内容为:{t3}")

#t1的类型是:<class 'tuple'>,内容为:(1, 'love', True)
#t2的类型是:<class 'tuple'>,内容为:()
#t3的类型是:<class 'tuple'>,内容为:()

定义单个元素的元组

# 定义单个元素的元组(一定要在单个元素后面加一个逗号,否者类型是字符串)
t4 = ("love")
print(f"t4的类型是:{type(t4)},内容为:{t4}")
t4 = ("love",)
print(f"t4的类型是:{type(t4)},内容为:{t4}")
#t4的类型是:<class 'str'>,内容为:love
#t4的类型是:<class 'tuple'>,内容为:('love',)

元组的嵌套

# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是:{type(t5)},内容为:{t5}")
#t5的类型是:<class 'tuple'>,内容为:((1, 2, 3), (4, 5, 6))

下标索引取出元组中的内容

# 下标取元组内容
t5[1][2] # 6

元组的相关操作

index查找方法

t6 = ("xiaoming","xiaohong","xiaogang","xiaoqiang")
index = t6.index("xiaoqiang")
print(index) # 3

count统计方法

t7 = (1,2,3,4,5,6,1,2,3,3,3,3)
num = t7.count(3)
print(num) # 5

len函数统计元组中的元素数量

t7 = (1,2,3,4,5,6,1,2,3,3,3,3)
num = len(t7)
print(num) # 12

元组的遍历

index = 0
while index < len(t7):
    print(t7[index],end = '\t')
    index += 1
print()

for x in t7:
    print(x , end = '\t')
#1	2	3	4	5	6	1	2	3	3	3	3	
#1	2	3	4	5	6	1	2	3	3	3	3

元组只是可读的,不可以修改

t8 = (1,2,["You","love","you"]) # 可以修改元组里嵌套的列表，列表里面的元素是可以修改的
t8[2][0]= "I"
print(t8) # (1, 2, ['I', 'love', 'you'])

字符串

my_str = "we are friend!"
print(my_str[7])
print(my_str[-7])

字符串是一个无法修改的数据容器

"""
查找特定字符串下标索引值
语法:字符串.index(字符串)
"""
my_str = "we are friend!"
print(my_str.index("are")) # 3

字符串的替换

"""
字符串的替换
语法:字符串.replace(字符串1,字符串2)
注意:不是修改字符串本身而是得到了一个新的字符串
"""
my_str = "we are friend!"
my_str2 = my_str.replace("are","are not")
print(my_str2)
print(my_str)

字符串的分割

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

my_str = "we are friend!"
result = my_str.split(" ")
print(f"{result}类型为:{type(result)}")

字符串的规整操作

"""
字符串的规整操作(去前后空格)
语法:字符串.strip()

字符串的规整操作(去前后指定字符串)
语法:字符串.strip(字符串)

"""

my_str = "     we are friend!    "
result = my_str.strip()
print(result) # we are friend!
my_str = "1212we are friend!2121"
result = my_str.strip("12") # we are friend!
print(result)

字符串的count方法

"""
字符串的count方法
统计字符串中的某字符串出现的次数

"""
my_str = "we are friend!"
num = my_str.count("e")
print(num) # 3

统计字符串长度

"""
统计字符串的长度
"""
my_str = "we are friend!"
num = len(my_str)
print(num) # 14

案例:分隔字符串

"""
给定一个字符串"itheima itcast boxuegu"
1.统计字符串内有多少个"it"字符
2.将字符串内的空格,全部替换为字符:"|"
3.并按照"|"进行字符串分割,得到列表
"""


str1 = "itheima itcast boxuegu"
num = str1.count("it")
print(f"字符串{str1}中有:{num}个it字符")
str2 = str1.replace(" ","|")
print(f"字符串{str1},被替换空格后,结果:{str2}")
result = str2.split("|")
print(f"字符串{str2},按照|分隔后,得到:{result}")


#字符串itheima itcast boxuegu中有:2个it字符
#字符串itheima itcast boxuegu,被替换空格后,结果:itheima|itcast|boxuegu
#字符串itheima|itcast|boxuegu,按照|分隔后,得到:['itheima', 'itcast', 'boxuegu']

数据容器的切片操作

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

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

"""
切片的语法格式：
语法:序列[起始下标:结束下标:步长] 左闭又开
此操作不会影响序列本身,而是会得到一个新的序列
"""
# 对list进行切片,从1开始,4结束,步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4]
print(f"结果1:{result1}")
# 对tuple进行切片,从头开始,到最后结束,步长为1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]
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}")


"""
结果1:[1, 2, 3]
结果2:(0, 1, 2, 3, 4, 5, 6)
结果3:0246
结果4:76543210
结果5:[3, 2]
结果6:(6, 4, 2, 0)

"""

字符串的逆置

my_str = "I love you!" 
print(my_str[::-1]) # 字符串逆置

集合

去重处理.

"""
基本语法:
# 定义集合字面量
{元素,元素,...,元素} # 大括号
# 定义集合变量
变量名称 = {元素,元素,.....,元素}
# 定义空集合
变量名称 = set()
"""

# 定义集合
my_set = {1,2,3,4,5,1,2,3,4,5}
my_set_empty = set()
print(f"my_set的内容是:{my_set},类型是:{type(my_set)}") # 不允许重复,无序的
print(f"my_set_empty的内容是:{my_set_empty},类型是:{type(my_set_empty)}")

因为集合是无序的所以不支持下标索引访问.

但是集合和列表一样,是允许修改的.

集合中元素的数据类型可以不同，但集合中不能嵌套列表、元组、集合、字典

添加元素

"""
添加新元素
语法:集合.add(元素)
"""

my_set = {"小明","小红"}
my_set.add("小强")
print(my_set) # {'小红', '小明', '小强'}

移除元素

"""
移除元素
语法:集合.remove(元素)
"""
my_set = {'小红', '小明', '小强'}
my_set.remove("小强")
print(my_set) # {'小红', '小明'}

删除并返回元素

"""
从集合中随机取出元素,删除并返回
语法:元素.pop()
"""
my_set = {'小红', '小明', '小强'}
element = my_set.pop()
print(my_set)
print(element)

清空集合

"""
清空集合
语法:集合.clear()
"""
my_set = {'小红', '小明', '小强'}
my_set.clear()
print(my_set)

取两个集合的差集

"""
取两个集合的差集
语法:集合1.difference(集合2)  ->集合1 - 集合2
得到一个新的集合,原来的集合不变
"""

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

消两个集合的差集

"""
消两个集合的差集
语法:集合1.difference_updata(集合2)
功能: 在集合1内删除集合2有的
结果:集合1被修改,集合2bubian
"""
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1) # {2, 3}
print(set2) # {1, 5, 6}

将两个集合合并

"""
将两个集合合并
语法:集合1.union(集合2)
功能:将集合1和集合2合并成一个集合
结果:得到一个新的集合原来的集合不变
"""
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set1) # {1, 2, 3}
print(set2) # {1, 5, 6}
print(set3) # {1, 2, 3, 5, 6}

统计集合元素数量

"""
统计集合元素数量
语法:集合.count()
"""
set1 = {1,2,3}
print(f"set1中元素的个数为:{len(set1)}")

集合的遍历

"""
集合的遍历
集合不支持下标索引所以不能用while循环来遍历集合
"""
set1 = {1,2,3,4,5}
for x in set1:
    print(x,end = '\t')

字典

字典的定义,同样使用{},不过存储的元素是一个个的键值对.

"""
# 定义字典字面量
{key:value,key:value,..,key:value}

# 定义字典变量
my_dict = {key:value,key:value,..,key:value}

# 定义空字典
my_dict ={}
my_dict = dict()
"""
# 定义字典
my_dict = {"小红":100,"小强":99,"小明":98}

# 定义空字典
my_dict_empty1 = {} # set(),{}被字典占用了
my_dict_empty2 = dict()
print(f"my_dict中的内容为:{my_dict},数据类型为:{type(my_dict)}")
print(f"my_dict_empty1中的内容为:{my_dict_empty1},数据类型为:{type(my_dict_empty1)}")
print(f"my_dict_empty2中的内容为:{my_dict_empty2},数据类型为:{type(my_dict_empty2)}")
# my_dict中的内容为:{'小红': 100, '小强': 99, '小明': 98},数据类型为:<class 'dict'>
# my_dict_empty1中的内容为:{},数据类型为:<class 'dict'>
# my_dict_empty2中的内容为:{},数据类型为:<class 'dict'>

字典的字是不可以重复的

新的会把老的覆盖掉.

字典数据的获取

"""
字典数据的获取
字典同集合一样,不可以使用下标索引
但字典可以通过key值来取得对应的value值
"""
my_dict = {"小红":100,"小强":99,"小明":98}
print(my_dict["小红"])
print(my_dict["小强"])
print(my_dict["小明"])

字典的嵌套

# 定义一个嵌套的字典 key不可以为字典
stu_score = {"小红":{"语文":98,"数学":100,"英语":90}
             ,"小明":{"语文":80,"数学":90,"英语":98}
             ,"小王":{"语文":70,"数学":100,"英语":70}}
print(stu_score)
# 从嵌套的字典中获取信息
score_yuwen = stu_score["小红"]["语文"]
print(f"小红的语文成绩为:{score_yuwen}")

字典的常用操作

"""
新增元素(不存在)
语法:字典[key] = value,结果字典被修改,新增了元素

更新元素(存在)
语法:字典[key] = value,结果字典被修改,修改了元素

删除元素
语法:字典.pop(key) 结果:获得指定key的value,同时字典被修改,指定key的数据被删除

清空元素
clear方法

"""
# 新增元素
my_dict = {"小红":100,"小强":99,"小明":98}
my_dict["小王"] = 80
print(my_dict)

# 更新元素
my_dict["小王"] = 90
print(my_dict)

# 删除元素
score =my_dict.pop("小王")
print(my_dict,score)

my_dict.clear()
print(my_dict)

"""
获取字典中全部key的操作
语法:字典.keys(),结果:得到字典中的全部key
"""
my_dict = {"小红":100,"小强":99,"小明":98}
print(my_dict.keys(),type(my_dict.keys())) # dict_keys(['小红', '小强', '小明'])

字典的遍历

for key in my_dict.keys():
    print(my_dict[key],end = "\t")
print()
for key in my_dict:
    print(my_dict[key],end = "\t")

统计字典内元素的个数

# len()
num = len(my_dict)
print(f"字典中的元素个数为:{num}个")

案例:升职加薪

"""
有如下员工信息,请使用字典完成数据的记录
并通过for循环对所有级别为1级的员工,级别上升1级,薪水增加1000元
m_dict = {"王力鸿":{"部门":"科技部","工资":3000,"级别":1}
          ,"周杰轮":{"部门":"市场部","工资":5000,"级别":2}
          ,"林俊节":{"部门":"市场部","工资":7000,"级别":3}
          ,"张学右":{"部门":"科技部","工资":4000,"级别":1}
          ,"刘德话":{"部门":"市场部","工资":6000,"级别":2}
          }

"""
m_dict = {"王力鸿":{"部门":"科技部","工资":3000,"级别":1}
          ,"周杰轮":{"部门":"市场部","工资":5000,"级别":2}
          ,"林俊节":{"部门":"市场部","工资":7000,"级别":3}
          ,"张学右":{"部门":"科技部","工资":4000,"级别":1}
          ,"刘德话":{"部门":"市场部","工资":6000,"级别":2}
          }
print(m_dict)
for key1 in m_dict:
    if m_dict[key1]["级别"] == 1:
        m_dict[key1]["级别"] = 2
        m_dict[key1]["工资"] += 1000
print(m_dict)

数据容器的对比总结

"""
是否支持下标索引
支持:列表、元组、字符串 -序列类型
不支持:集合、字典 -非序列类型

是否支持重复元素
支持:列表,元组,字符串 - 序列类型
不支持:集合,字典 -非序列类型

是否可以修改
支持:列表,集合,字典
不支持:字符串,元组

"""

"""
列表:一批数据,可修改,可重复的存储场景
元组:一批数据,不可修改,可重复的存储场景
字符串:一串字符串的存储场景
集合:一批数据,去重存储场景
字典:一批数据,可用key去检索对应的value值存储场景

"""

数据容器的通用操作

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()
# 类型转换转换成列表
print(f"列表转列表的结果是:{list(my_list)}")
print(f"列表转列表的结果是:{list(my_tuple)}")
print(f"列表转列表的结果是:{list(my_str)}")
print(f"列表转列表的结果是:{list(my_set)}")
print(f"列表转列表的结果是:{list(my_dict)}") # 字典转列表只有key
print()

# 类型转元组
print(f"列表转元组的结果是:{tuple(my_list)}")
print(f"列表转元组的结果是:{tuple(my_tuple)}")
print(f"列表转元组的结果是:{tuple(my_str)}")
print(f"列表转元组的结果是:{tuple(my_set)}")
print(f"列表转元组的结果是:{tuple(my_dict)}") # 字典转列表只有key
print()

# 类型转字符串
print(f"列表转字符串的结果是:{str(my_list)}")
print(f"列表转字符串的结果是:{str(my_tuple)}")
print(f"列表转字符串的结果是:{str(my_str)}")
print(f"列表转字符串的结果是:{str(my_set)}")
print(f"列表转字符串的结果是:{str(my_dict)}") # 字典转列表只有key
print()

# 类型转集合
print(f"列表转集合的结果是:{set(my_list)}")
print(f"列表转集合的结果是:{set(my_tuple)}")
print(f"列表转集合的结果是:{set(my_str)}")
print(f"列表转集合的结果是:{set(my_set)}")
print(f"列表转集合的结果是:{set(my_dict)}") # 字典转列表只有key
print()

通用排序功能

"""
通用排序功能
sorted(容器,[reverse=True])
排序结果存到列表当中
"""
my_list = [3,2,1,5,4]
my_tuple = (5,2,3,1,4)
my_str = "abgdefc"
my_set = {5,2,3,4,1}
my_dict = {"key5":1,"key2":2,"key3":3,"key4":4,"key1":5}
# 正序
print(sorted(my_list))
print(sorted(my_tuple))
print(sorted(my_str))
print(sorted(my_set))
print(sorted(my_dict))
print()
# 逆序
print(sorted(my_list,reverse = True))
print(sorted(my_tuple,reverse = True))
print(sorted(my_str,reverse = True))
print(sorted(my_set,reverse = True))
print(sorted(my_dict,reverse = True))