Python数据容器（中）——tuple（元祖）、str（字符串）、数据容器的切片、set（集合）、dict（字典）

一、数据容器：tuple（元组）

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

#定义元组字面量
（元素，元素，。。。。。。，元素）
#定义元组变量
变量名称 = （元素，元素，。。。。。。，元素）
#定义空元组
变量名称 = （）         #方式1
变量名称 = tuple（）    #方式2

注意：定义单个元素的元组时候后边必须带一个逗号，否则不是元组类型，如：t = （'hello',）

元组也支持嵌套

#定义一个嵌套元组
t1 = ((1,2,3),(4,5,6))
print(t1[0][0])    # 结果：1

下表检索去取内容

t1 = ((1, 2, 3), (4, 5, 6))
#下标检索去取内容
print(t1[1][2]) 

元组的操作：index 查找方法

# 元组的操作：index查找方法
t2 = (1, 2, 3, 4, 5)
index_t2 = t2.index(3)
print(index_t2)

 元组的操作：count 统计方法

#元组的操作：count 统计方法
t3 = (1,2,3,1,2,1)
count_t3 = t3.count(1)
print(count_t3) 

元组的操作：len 函数统计元组元素数量

#元组的操作：len 函数统计元组元素数量
t4 = (1,2,3,4,5,6,7)
len_t4 = len(t4)
print(len_t4)

元组的遍历：while

t4 = (1,2,3,4,5,6,7)
#元组的遍历：while
index = 0
while index <= len_t4:
    print(t4[index])
    index += 1

元组的遍历：for

t4 = (1,2,3,4,5,6,7)

#元组的遍历：for
for element in t4:
    print(element)

二、数据容器：str（字符串）

字符串是字符的容器，一个字符串可以存放任意数量的字符（字符串也是不可修改的数据容器）

字符串的下标（索引）

· 从前往后，下标从0开始

· 从后往前，下标从-1开始

#通过下标获取的定位置字符
str1 = 'hello world'
print(str1[2])    #结果l
print(str1[6])    #结果w

index查找方法

str1 = 'hello world'
#index方法
index1 = str1.index("l")
print(index1)

字符串的替换

语法：字符串.replace（字符串1，字符串2）

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

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

str1 = 'hello world'
#字符串替换 replace
str2 = str1.replace("hello","hi")
print(f"字符串{str2}")

字符串的分割

语法：字符串.split（分隔字符串）

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

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

#字符串的分割
my_str = "hello world"
my_str_list = my_str.split(" ")
print(my_str_list)
print(f"其数据类型是{type(my_str_list)}")

字符串的规整操作（去前后空格）

语法：字符串.strip（）

#字符串去前后空格
my_str = "  hello world  "
print(my_str.strip() )    #结果：‘hello world’

字符串的规整操作（去前后指定字符串）

语法：字符串.strip（字符串）

#去前后指定字符串
my_str = "12hello world21"
print(my_str.strip("12")) #结果：“hello world”

注意，传入的是“12”，其实就是：“1” 和 “2” 都会移除，是按照单个字符。

统计字符串中某字符串的出现次数：count

#统计字符串中某字符串的出现次数：count
my_str = "hello world"
count = my_str.count("l")
print(count)

统计字符串长度len（）

#统计字符串长度len（）
my_str = "hello world"
print("my_str字符串的长度为：%d"%(len(my_str)))
#结果：my_str字符串的长度为：11

字符串的遍历

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

三、数据容器（序列）的切片

1、序列

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

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

2、序列的常用操作——切片

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

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

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

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

· 起始下标表示从何处开始，可以留空，留空视作从头开始

· 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

· 步长表示，依次取元素的间隔（注意：a.步长 N 表示，每次跳过 N -1 个元素取  b.步长为负数表示反向取，同时起始下标和结束下标也要反向标记） 

    

#序列的切片
#对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：{my_tuple}")
# 对str进行切片：从头开始，到最后结束，步长2
my_str = "0123456"
result3 = my_str[::2]
print(f"结果3：{result3 }")
#对str进行切片，从头开始，到最后结束，步长-1
result4 = my_str[::-1]
print(f"结果4：{result4}")
"""
结果1：[1, 2, 3]
结果2：(0, 1, 2, 3, 4, 5, 6)
结果3：0246
结果4：6543210

"""

四、数据容器：set（集合）

1、集合的定义

  · 集合内，数据是无序存储的（不支持下标索引）

  · 集合内不允许重复数据存在

基本语法：

#定义集合字面量
{元素，元素，......，元素}
#定义集合变量
变量名称 = {元素，元素，......，元素}}
#定义空集合
变量名称 = set（）

2、集合的常用操作——修改

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

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

a.添加新元素

    语法：集合.add（元素）。将指定元素，添加到集合内

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

b.移除元素

    语法：集合.remove（元素）。将指定元素，从集合内移除

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

c.从集合中随机取出元素

    语法：集合.pop（）。从集合中随机取出一个元素

    结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

#从集合中随机取出元素
my_set = {"python","java","C","C++"}
result_set = my_set.pop()
print(f"集合被取出了{result_set}")
print(f"my_set集合：{my_set}")
"""
集合被取出了C
my_set集合：{'C++', 'java', 'python'}
"""

d.清空集合

    语法：集合.clear()

e.取两个集合的差集

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

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

#取出两个集合的差集
set1 = {0,1,2,3}
set2 = {0,4,3}
result_set = set1.difference(set2)
print(result_set)    #结果：{1, 2}

f.消除2个集合的差集

    语法：集合1.difference_update（集合2）

    功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素

    结果：集合1被修改，集合2不变

g.2个集合合并

    语法：集合1.unior（集合2）

    功能：将集合1和集合2组成新集合

    结果：得到新集合，集合1和集合2不变

h.统计集合元素数量len（）

    语法：len(集合)

i.集合的遍历

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

    · 可以使用 for 循环

五、数据容器：dict（字典、映射）

1、字典的定义

  使用字典，实现 key 取出Value 的操作

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

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

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

#定义空字典
my_dict = {}                 #空字典定义方式1
my_dict = dict()             #空字典定义方式2

字典的 key 不可以重复

2、字典数据的获取

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

    但是字典可以通过 key 值来取得对应的 Value

    语法：字典 [key]

#字典数据的获取
stu_score = {"王二":59,"张三":61,"李四":72}
print(stu_score ["王二"])    #结果：59
print(stu_score ["张三"])    #结果：61
print(stu_score ["李四"])    #结果：72

3、字典的嵌套

    字典的 key 的 value 可以是任意数据类型（key不可为字典）

4、字典的常用操作

  · 新增元素

      语法：字典 [key]  = Value

      结果：字典被修改，新增了元素 

#字典新增元素：
stu_score = {"张三":61,"李四":72}
stu_score["王麻子"] = 66
print(stu_score)    #结果：{'张三': 61, '李四': 72, '王麻子': 66}

   · 更新元素

      语法：字典[key] = Value,结果：字典被修改，元素被更新

      注意：字典 key 不可以重复，所以对已存在的key执行上述操作，就是更新 Value 的值

  · 删除元素（取出被删除的元素）

      语法：字典.pop(key)

      结果：获得指定 key 的 Value ，同时字典被修改，指定 Key 的数据被删除

  · 清空字典

      语法：字典.clear()

      结果：字典被修改，元素被清空

  · 获取全部的 key 

      语法：字典.keys()

      结果：得到字典中的全部key 

#获取全部的key
stu_score = {"王二":59,"张三":61,"李四":72}
all_stu = stu_score.keys()
print(all_stu)    #结果：dict_keys(['王二', '张三', '李四'])

   · 遍历字典:（for循环）

    方式1：通过获取到全部的 key 来完成遍历

stu_score = {"王二":59,"张三":61,"李四":72}
#获取全部的key
all_stu = stu_score.keys()
#遍历字典
for key in all_stu:
    score = stu_score[key]
    print(f"{key}的成绩是:{score}")
"""
王二的成绩是:59
张三的成绩是:61
李四的成绩是:72
"""

    方式2：直接对字典进行 for 循环，每一次循环都是直接得到可以 key

#遍历字典2
stu_score = {"王二":59,"张三":61,"李四":72}
for key in stu_score :
    print(f"{key}的成绩是{stu_score[key]}")
"""
王二的成绩是59
张三的成绩是61
李四的成绩是72
"""

· 统计字典内的元素数量 ：len（）函数