一、数据容器: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 """