数据容器入门
数据容器
python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器的特点不同，如：
- 是否支持重复元素
- 是否可以修改
- 是否有序，等
分为5类，分别是：
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
列表(list)
基本语法：
# 字面量
[元素1，元素2，元素3，元素4，...]
# 定义变量
变量名称 = [元素1，元素2，元素3，元素4，...]
# 定义空列表
变量名称 = []
变量名称 = list()
列表内的每一个数据，称之为元素
- 以[]作为标识
- 列表内每一个元素之间，用逗号隔开
注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
"""
演示数据容器：列表（list）
语法：[元素,元素,......]
"""
# 定义一个列表
my_list = ["gregory","ittest","python"]
print(my_list)
print(type(my_list))
my_list2 = ["gregory",666,True]
print(my_list2)
print(type(my_list2))
# 定义一个嵌套列表
my_list3 = [[1,2,3],["gregory","ittest","python"]]
print(my_list3)
print(type(my_list3))
列表的下标
"""
演示数据容器：列表（list）
语法：[元素,元素,......]
"""
# 定义一个列表
my_list = ["gregory","ittest","python"]
print(my_list)
print(type(my_list))
my_list2 = ["gregory",666,True]
print(my_list2)
print(type(my_list2))
# 定义一个嵌套列表
my_list3 = [[1,2,3],["gregory","ittest","python"]]
print(my_list3)
print(type(my_list3))
# 通过小索引取出对应位置的数据
print(my_list[0])
print(my_list[-3])
# print(my_list[3]) 列表索引超出范围
# 取出嵌套列表的元素
print(my_list3[0][1])# 取2
列表的常用方法
列表除了可以：
- 定义
- 使用下标索引获取值
此外，列表也提供了一系列功能：
- 插入元素
- 删除元素
- 清空列表
- 修改元素
- 统计元素个数
等等功能，这些功能我们称之为：列表的方法
查找某元素的下标：
语法：列表.index(元素)
my_list = ["Gregory","itheima","Python"]
index = my_list.index("itheima")
print(index)
修改特定位置下表的元素值：
列表[下标] = 元素值
# 修改指定下标索引位置的元素值
my_list[0] = "巩朕豪"
print(my_list)
插入元素：
列表.insert(下标，元素)：在指定位置插入指定元素
#插入元素
my_list.insert(1,"best")
print(my_list)
追加元素：
语法：列表.append(元素)，将指定元素，追加到列表的尾部
# 尾插元素
my_list.append("Gregory")
print(my_list)
my_list.extend([1,2,3])
print(my_list)
删除元素：
del 列表[下标]
列表.pop(下标)
# 删除元素
my_list = ["Gregory","itheima","Python"]
del my_list[2]
print(my_list)
my_list = ["Gregory","itheima","Python"]
delect = my_list.pop(2)
print(my_list)
print(delect)
删除某元素在列表中的第一个匹配项
列表.remove(元素)
# 删除元素2
my_list = ["Gregory","itheima","Python","itheima"]
my_list.remove("itheima")
print(my_list)
清空列表内容
列表.clear()
my_list.clear()
print(my_list)统计某元素在列表内的数量
列表.count(元素)
my_list = [1,1,1,2,3,5,1]
count = my_list.count(1)
print(count)
统计列表内，有多少元素
len(列表)
可以得到一个int数字，标识列表内的元素数量
print(len(my_list))
经过上述对列表的学习，可以总结出列表有如下几个特点：
可以容纳多个元素(上限为2**63-1、9223372036854775807个)
可以容纳不同的数据类型（混装）
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加或删除元素等）
my_list = [21,25,21,23,22,20]
# 追加一个数字31，到列表的尾部
my_list.append(31)
print(my_list)
# 追加一个新列表，到列表的尾部
my_list.extend([29,33,30])
print(my_list)
# 取出第一个元素
get = my_list[0]
print(get)
# 取出最后一个元素
get_back = my_list[-1]
print(get_back)
# 查找元素31在列表中的下标位置
back = my_list.index(31)
print(back)列表的遍历
列表的遍历-while循环
my_list = [1,2,3]
def list_while_func(my_list):
"""
my_list：列表
使用while循环遍历列表的函数
:return:None
"""
index = 0
while index < len(my_list):
element = my_list[index]
print(element)
index += 1
list_while_func(my_list)
列表的遍历-for循环
def for_while_func(my_list):
for i in my_list:
print(i)
for_while_func(my_list)
while循环和for循环，都是循环语句，但细节不同：
- 在循环控制上：
- while循环可以自定循环条件，并可以控制
- for循环不可以自定循环条件，只可以一个个从容器内取出数据
- 在无限循环上：
- while循环可以通过条件控制做到无限循环
- for循环理论上不可以，因为被遍历的容器容量不是无限的
- 在使用场景上：
- while循环适用于任何想要循环的场景
- for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
练习
my_list = [1,2,3,4,5,6,7,8,9,10]
change_list = []
def while_list_func(list):
index = 0
while index < len(list):
global change_list
element = list[index]
if element%2 == 0:
change_list.append(element)
index += 1
while_list_func(my_list)
print(change_list) 
def for_list_func(list):
for element in list:
if element%2 == 0:
global change_list
change_list.append(element)
for_list_func(my_list)
print(change_list)元组（tuple）——只读的列表
元组一旦定义完成，就不可修改
所以，当我们需要在程序内封装数据，又不希望封装的数据被串改，那么元组就非常合适了
元组定义：定义元组中使用了小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
# 定义元组字面量
(元素1，元素2，元素3，元素4，......，元素n)
# 定义元组变量
变量名称 = (元素1，元素2，元素3，元素4，......，元素n)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
"""
演示tuple元组的定义和操作
"""
# 定义元组
my_tuple = (1,"Hello",True)
my_tuple2 = ()
my_tuple3 = tuple()
print(f"{my_tuple},{type(my_tuple)}")
print(f"{my_tuple2},{type(my_tuple2)}")
print(f"{my_tuple3},{type(my_tuple3)}")
# 定义单个元素的元组
my_tuple4 = ("Hello",)
print(f"{my_tuple4},{type(my_tuple4)}")
# 嵌套元组
my_tuple5 = ((1,2,3),(4,5,6))
print(f"{my_tuple5},{type(my_tuple5)}")
# 取出元素
num = my_tuple5[1][2]
print(num)
"""
演示tuple元组的定义和操作
"""
# 定义元组
my_tuple = (1,"Hello",True)
my_tuple2 = ()
my_tuple3 = tuple()
print(f"{my_tuple},{type(my_tuple)}")
print(f"{my_tuple2},{type(my_tuple2)}")
print(f"{my_tuple3},{type(my_tuple3)}")
# 定义单个元素的元组
my_tuple4 = ("Hello",)
print(f"{my_tuple4},{type(my_tuple4)}")
# 嵌套元组
my_tuple5 = ((1,2,3),(4,5,6))
print(f"{my_tuple5},{type(my_tuple5)}")
# 取出元素
num = my_tuple5[1][2]
print(num)
print('****************************')
my_index = my_tuple.index(1)
print(my_index)
my_count = my_tuple.count(1)
print(my_count)
print(len(my_tuple))
print('****************************')
# 元组的循环
index = 0
while index < len(my_tuple):
element = my_tuple[index]
print(element)
index += 1
for element in my_tuple:
print(element)
元组中的列表是可以修改的
my_tuple6 = (1,2,[6,9])
my_tuple6[2][0] = "gregory"
print(my_tuple6)
案例：
my_tuple = ('Gregory',11,['football','music'])
# 查询其年龄所在的下标位置
index = my_tuple.index(11)
print(index)
# 查询学生姓名
print(my_tuple[0])
# 删除学生的爱好music
del my_tuple[2][1]
print(my_tuple)
# 增加爱好：coding增加到爱好list里面
my_tuple[2].append('coding')
print(my_tuple)
字符串
字符串的常用方法
字符串的替换
语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新的字符串哦
字符串的分割
语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将子字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
字符串的规整操作（去前后空格）
语法：字符串.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”都会移除，是按照单个字符
"""
演示以数据容器的角色使用字符串
"""
my_str = "itheima and gregogogo"
# 通过下标索引取值
value = my_str[2]
print(value)
value2 = my_str[-5]
print(value2)
# index方法
print(my_str.index('ma'))
# replace方法
new_my_str = my_str.replace('ma','gogo')
print(new_my_str)
# split方法
my_list = my_str.split(' ')
print(my_list)
# strip
my_str = " 12itheima and gregogogo21 "
new_my_str = my_str.strip()
print(new_my_str)# 不传参数，取出首位空格
new_my_str = my_str.strip(' 12')# 传参后取去除参数
print(new_my_str)
# 统计字符串中某字符串的出现次数：count
my_str = "itheima and gregogogo"
count = my_str.count('g')
print(count)
# 统计字符串的长度
num = len(my_str)
print(num)
字符串特点
- 只可以存储字符串
- 长度任意（取决于内存大小）
- 支持下标索引
- 允许重复字符串存在
- 不可以修改（增加或删除元素等）
- 支持for循环
序列和切片操作
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
- 起始下标表示从何处开始，可以留空，留空表示从头开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
# 对list进行切片，从1开始，4结束，步长为1
my_list = [0,1,3,5,8,7,9,6,4,3,1]
new_my_list = my_list[1:4]
print(new_my_list)
# 对tuple进行切片，从头开始，到最后结束，步长为1
my_tuple = (1,2,3,4,5,6,8,9,78,99,15,'Gregpory')
new_my_tuple = my_tuple[:]
print(new_my_tuple)
# 对str进行切片，从头开始，到最后结束，步长为2
my_str = 'itheima'
new_my_str = my_str[::2]
print(new_my_str)
# 对str进行切片，从头开始，到最后结束，步长为-1
my_str = '0123456'
new_my_str = my_str[::-1]
print(new_my_str)
# 对list进行切片，从3开始，1结束，步长为-1
my_list = [0,1,3,5,8,7,9,6,4,3,1]
new_my_list = my_list[3:1:-1]
print(new_my_list)
# 对tuple进行切片，从头开始，到最后结束，步长为-2
my_tuple = (1,2,3,4,5,6,8,9,78,99,15,'Gregpory')
new_my_tuple = my_tuple[::-2]
print(new_my_tuple) 
集合(set)
基本语法：
# 定义集合字面量
{元素，元素，......，元素}
# 定义集合变量
变量名称 = {元素，元素，...... ，元素}
# 定义空集合
变量名称 = set()
首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法
集合的常用方法
添加新元素
语法：集合.add(元素)。将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素
my_set = {"Hello","World"}
my_set.add("itheima")
print(my_set) # 结果{'Hello','itheima','World'}移除元素
语法：集合.remove(元素)，将指定元素，从集合内移除
结果：集合本身被修改，移除了元素
my_set = {'Hello','World','itheima'}
my_set.remove('Hello')
print(my_set) # 结果{'World','itheima'}从集合中随机取出元素
语法：集合.pop(),功能：从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
my_set = {'Hello','World','itheima'}
element = my_set.pop()
print(my_set) # 结果{'World','itheima'}
print(element) # 结果'Hello'取出两个集合的差集
语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
set1 = {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}不变消除两个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变
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组合成新集合
结果：得到新集合，集合1和集合2不变
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3) # 结果：{1,2,3,5,6}
print(set1) # 结果：{1，2，3}不变
print(set2) # 结果：{1，5，6}不变
# 集合的遍历
# 因为集合无法修改，所以无法用while遍历
for x in set3:
print(x,end='')案例
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
my_set = set()
for x in my_list:
my_set.add(x)
print(f"存入集合后的结果:{my_set}")字典(dict)
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：
# 定义字典字面量
{key:value,key:value,......,key:value}
# 定义字典变量
my_dict = {key:value,key:value,......,key:value}
# 定义空字典
my_dict = {}
my_dict = dict()字典同集合一样，不可以使用下标索引
但是字典可以通过key值来取得对应的Value
语法：字典[Key]
# 定义字典
my_dict1 = {"巩朕豪":99,"乔嘉玥":99,"momo":59}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1},类型是:{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2},类型是:{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3},类型是:{type(my_dict3)}")
# 字典中的key不能重复
my_dict4 = {"巩朕豪":99,"巩朕豪":95,"momo":59}
print(my_dict4)
# 从字典中基于key获取value
my_dict1 = {"巩朕豪":99,"乔嘉玥":99,"momo":59}
score = my_dict1["巩朕豪"]
print(f"巩朕豪的考试分数是：{score}")
# 字典的嵌套
my_dict5 = {
"巩朕豪":{
"语文":77,
"数学":66,
"英语":33
},"乔嘉玥":{
"语文":88,
"数学":86,
"英语":55
},"momo":{
"语文":99,
"数学":96,
"英语":66
}
}
print(my_dict5)
# 从嵌套的字典中获取数据
score = my_dict5["巩朕豪"]["语文"]
print(score)字典常用方法
新增元素
语法：字典[Key] = Value
结果：字典被修改，新增了元素
更新元素
语法：字典[Key] = Value
结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
删除元素
语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
my_dict1 = {"巩朕豪":99,"乔嘉玥":99,"momo":59}
# 新增元素
my_dict1["dudu"] = 100
print(f"字典经过新增后元素为：{my_dict1}")
# 修改元素
my_dict1["巩朕豪"] = 100
print(f"字典经过更新后：{my_dict1}")
# 删除元素
score = my_dict1.pop("巩朕豪")
print(score)
print(my_dict1)
# 清空元素
my_dict1.clear()
print(my_dict1)
# 获取全部的key
my_dict1 = {"巩朕豪":99,"乔嘉玥":99,"momo":59}
print(my_dict1.keys())
# 遍历字典
# 通过获取全部的key进行遍历
for i in my_dict1.keys():
print(i ,end='')
print(my_dict1[i])
# 直接遍历
for key in my_dict1:
print(key)
print(my_dict1[key])
# 统计字典的元素数量
print(len(my_dict1))
# 我写的
satff_dict = {
"王力宏":{
"部门":"科技部",
"工资":3000,
"级别":1
},
"周杰伦":{
"部门":"市场部",
"工资":5000,
"级别":2
},
"林俊杰":{
"部门":"市场部",
"工资":7000,
"级别":3
},
"张学友":{
"部门":"科技部",
"工资":4000,
"级别":1
},
"刘德华":{
"部门":"市场部",
"工资":6000,
"级别":2
}
}
print(f"全体员工当前信息如下：")
for staff in satff_dict:
print(f'{staff}:',end='')
print(satff_dict[staff])
for satff in satff_dict:
if satff_dict[satff]["级别"] == 1:
satff_dict[satff]['工资'] += 1000
satff_dict[satff]["级别"] += 1
print(f"全体员工级别为1的员工完成升职加薪操作后，信息如下：")
for staff in satff_dict:
print(f'{staff}:',end='')
print(satff_dict[staff]) 
数据容器对比总结
数据容器的通用操作
ASCII码
1055
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
