一、数据容器入门
1. Python中的数据容器:一种可以容纳多份数据的数据类型,容纳的每一份数据称之为一个元素,每一个元素可以是任意类型的数据,如字符串、数字、布尔等
2.根据特点的不同分为五类,列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
二、列表...
1.基本语法
# 字面量
[元素1,元素2,元素3……]
# 定义变量
变量名称=[元素1,元素2,元素3……]
# 定义空列表
变量名称=[]
变量名称=list()
2.列表中的每一个数据称之为元素
以[]作为标识
列表内每一个元素之间用,逗号隔开
3.列表可以一次存储多个数据,且可以为不同的数据类型,支持嵌套
4.元素的数据类型没有任何限制,甚至元素也可以是列表,这样就定义了嵌套列表
"""
演示数据容器之:list列表语法:[元票,元素.....J
"""
#定义一个列表 list
my_list = ["itheima", "itcast","python"]
print(my_list)
print(type(my_list))
my_list = ["itheima",666,True]
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list = [ [1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))
三、列表的下标索引
1.列表的每一个元素,都有编号,称之为下标索引
从前向后的方向,编号从零开始递增
从后向前的方向,编号从-1开始递减
2.如何通过下标索引取出对应位置的元素
列表[下标]即可取出
3.要注意下标索引的取值范围,超出范围无法取出元素,并且会报错
# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引],从前向后从0开始,每次+1, 从后向前从-1开始,每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范:通过下标索引取数据,一定不要超出范围
# print(my_list[3])
# 通过下标索引取出数据(倒序取出)
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
#取出嵌套列表的元素
my_list = [ [1,2,3],[4,5,6]]
print(my_list[1][1])
四、列表的常用操作
1.列表的查询功能(方法)
在Python中,如果将函数定义为class(类)的成员,那么函数会称之为:方法
2.查找某元素的下标
功能:查找指定元素在列表的下标,如果找不到报错valueError
语法:列表.index(元素)
index就是列表对象(变量)内置的方法(函数)
3.修改特定位置(索引)的元素值
语法:列表[下标]=值
4.插入元素
语法:列表.insert(下标,元素),在指定的下标位置,插入指定的元素
5.追加元素:
语法:列表.append
编号 | 使用方式 | 作用 |
1 | 列表.append(元素) | 向列表中追加一个元素 |
2 | 列表.extend(容器) | 将数据容器的类型依次取出,追加到列表尾部 |
3 | 列表.insert(下标,元素) | 在指定下标处,插入指定的元素 |
4 | del列表[下标] | 删除列表指定下标元素 |
5 | 列表.pop(下标) | 删除列表指定下标元素 |
6 | 列表.remove(元素) | 从前向后,删除此元素第一个匹配项 |
7 | 列表.clear() | 清空列表 |
8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
9 | 列表.index(元素) | 查找指定元素在列表的下标找不到报错ValueError |
10 | len(列表) | 统计元素内有多少元素 |
演示数据容器之:list列表的常用操作
mylist = ["itcast", "itheina", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是:{index}")
# 1.2如果被查找的元素不存在,会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是:{index}")
# 2.修改特定下标索引的值
mylist[0]="传智教育”
print(f"列表被修改元素值后,结果是:{mylist}")
# 3.在指定下标位置插入新元素
mylist.insert(1,"best")
print(f"列表插入元素后,结果是:{mylist}")
# 4.在列表的尾部追加 新元素
mylist.appehd("黑马程序员")
print(f"列表在追加了元素后,结果是{mylist}")
# 5.在列表的尾部追加一批```新元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后,结果是:{mylist}")
# 6.删除指定下标索引的元素(2种方式)
mylist = ["itcast","itheima", "python"]
# 6.1 方式1:del列表[下标]
del mylist[2] 3
print(f"列表删除元素后结果是:{mylist}")
# 6.2 方式2:列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容:{mylist},取出的元素是:{element}")
# 7.删除某元素在列表中的第一个匹配项
mylist = ["itcast","itheima", "itcast","itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后,列表的结果是:{mylist}")
# 8. 清空列表
mylist.clear()
print(f"列表被清空了,结果是:{mylist}")
# 9.统计列表内某元素薇数
mylist = ["itcast", "itheima", "itcast","itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是:{count}")
# 10.统计列表中全部的元素数量
mylist = ["itcast","itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有:{count}个")
五、列表的循环遍历
1.将容器内的元素依次取出进行处理的行为,称之为遍历、迭代
2.通过While和fo r循环
语法:
for 临时变量 in 数据容器:
对临时变量进行处理
表示从容器内依次取出元素并赋值到临时变量,尚在每一次的循环中,我们可以对临时变量(元素)进行处理
3.while循环和for循环都是循环语句,细节不同
在循环控制上:
while循环可以自定循环条件,并自行控制
for循环不可以自定循环条件,只可以一个个从容器内取出数据
在无限循环上:
while循环可以通过条件控制做到无限循环
for循环理论不可以,因为被遍历的容器容量不是无限的
在使用场景上:
while循环适用于任何想要循环的场景
for循环适用于遍历数据容器的场景或简单的固定次数循环场景
"""
演示对list列表的循环,使用while和for循环2种方式
"""
def list_while_func():
"""
使用while循环遍历列表的演示函数
:return: None
"""
my_list = ["传智教育","黑马程序员","Python"]
# 循环控制变量通过下标索引来控制,0
# 每一次循环将下标索引变量+1
# 循环条件:下标索引变量<列表的元素数量
#定义一个变量用来标记列表的下标
index=0 # 初始值为0
while index < len(my_list):
#通过index变量取出对应下标的元素
element = my_list[index]
print(f"列表的元素:{element}")
# 至关重要 将循环变量(index)每一次循环都+1 index += 1
def list_for_func():
"""
使用for循环遍历列表的演示函数
:return: None
"""
list_while_func()
六、元组
1.元组一旦定义完成,就不可修改,所以当我们需要在程序内封装数据,又不希望封装的数据被篡改,那么元组就非常合适
2.定义:定义元组使用小括号,且使用逗号隔开各个数据,数据可以是不同的数据类型
3.注意:元组只有一个数据,这个数据后面要添加
不可以修改元组的内容,否则会直接报错
可以修改元组内的list的内容(元组、增加、删除、反转等)
4.元组的特点
可以容纳多个数据
可以容纳不同类型的数据(混装)
数据是有序存储的(下标索引)
允许重复数据存在
不可以修改
支持for循环
"""
演示tuple元组的定义和操作
"""
#定义元组
t1 = (1,"Hello", True)
t2=()
t3= tuple()
print(f"t1的类型是:{type(t1)},内容是:{t1}")
print(f"t2的类型是:{type(t2)},内容是:{t2}")
print(f"t3的类型是:{type(t3)},内容是:{t3}")
# 定义单个元素的元素 t4 =("hello")
print(f"t4的类型是:{type(t4)},t4的内容是: {t4}")
#元组的嵌套
t5 =((1,2, 3),(4,5,6))
print(f"t5的类 型是:{type(t5)},内容是:{t5}")
# 下标索引去取出内容 num = t5[1][2]
print(f"从嵌套元组中取出的数据是:{num}")
#元组的操作:index直找方法
t6 = ("传智教育","黑马程序员","Python")
index= t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员,的下标是:{ len(元组)
#元组的操作:count统计方法
t7 =("传智教育”,“黑马程序员","黑马程序员",“黑马程序员","python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有:{num}个")
#元组的操作:len函数统计元组元素数分
t8=("传智教育","黑马程序员","黑马程序员","黑马程序员","python")
num = len(t8)
print(f"t8元组中的元素有:{num}个")
# 元组的遍历:while index =0
while index < len(t8):
print(f"元组的元素有:{t8[index]}")
# 至关重要 index += 1
# 元组的遍历:for
for element in t8:
print(f"2元组的元素有:{element}")
# 修改元组内容
# t8[0] = "itcast"
# 定义一个元组
t9 = (1, 2,["itheima", "itcast"l) print(f"t9的内容是:{t9}") t9
七、字符串
1.字符串的替换
语法:字符串.replace(字符串1,字符串2)
功能:将字符串内的全部:字符串1,替换为字符串2
注意:不是修改字符串本身,而是得到了一个新的字符串
2.字符串的分割
语法:字符串.split(分隔符字符串)
功能:按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中
注意:字符串本身不变,而是得到了一个列表对象
3.字符串的规整操作(去前后空格)
语法:字符串.strip()
字符串的规整操作(去前后指定字符串)
语法:字符串.strip(字符串)
4.字符串的特点
只可以存储字符串
"""
演示以数据容器的角色,学习字符串的相关操作
"""
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素,。值是:{value},取下标为-16的元素。值是:{value2}")
my_str[2]="H"
# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and,其起始下标是:{value}")
# replace方法
new_my_str = my_str.replace("it","程序")
print(f"将字符串{my_str},进行替换后得到:{new_my_str}")
# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split("")
print(f"将字符串{my_str}进行split切分后得到:{my_str_list},类型是:{type(my_str_list)}")
# 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(12)后,结果:{new_my_str}")
统计字符串中某字符串的出现次数,count
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是:{count}")
# 统计字符串的长度,
len() num = len(my_str)
print(f"字符串{my_str}的长度是:{num}")
允许重复字符串存在
支持下标索引
不可以修改
支持for循环
5.字符串可以看作是字符的容器,支持下标索引等特性
八、数据容器的切片操作
1.序列是指:内容连续有序,可使用下标索引的一类数据容器
2.列表、元组、字符串均可以视为序列
3.序列支持切片,即列表、元组、字符串均支持进行切片操作
4.切片:从一个序列中,取出一个子序列
5.语法:序列[起始下标:结束下标:步长]
表示从序列中,从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
"""
演示对序列进行切片操作
"""
# 对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 = (d,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6:{result6}")
九、集合
1.和列表、元组、字符串的定义基本相同
列表使用:[]
元组使用:()
字符串使用:" "
集合使用:{}
2.因为集合是无序的,所以集合不支持下标索引访问
3.添加新元素
语法:集合.add(元素)
4.取出两个集合的差集
语法:集合1.difference(集合2)
功能:取出集合1和集合2的差集
5.消除两个集合的差集
语法:集合1.difference_ update(集合2)
功能:对比集合1和集合2,在集合1内,删除集合2相同的元素
6.两个集合合并
语法:集合1.union(集合2)
功能:将集合1和集合2组合成新集合
结果:得到新集合,集合1和集合2不变
7.集合的特点
可以容纳多个数据
可以容纳不同类型的数据(混装)
数据是无序存储的(不支持下标索引)
不允许重复数据存在
可以修改
支持for循环
"""
演示数据容器集合的使用
"""
# 定义集合
my_set = {"传智教育","黑马程序员","itheima","传智教育 "黑马程序员","itheima","传智教育","黑马程序员","itheima"}
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)}")
# 添加新元素
my_set.add("Python")
my_set.add("传智教育") #
print(f"my_set添加元素后结果是:{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后,结果是:{my_set}")#随机取出一个元素
my_set = {"传智教育","黑马程序员","itheima"}
element = my_set.pop()
print(f"集合被取出元素是:{element},取出元素后:{my_set}")
# 清空集合
my_set.clear()
print(f"集合被清空啦,结果是:{my_set}")
# 取2个集合的差集
set1 = {1,2,3}
set2 = {1,5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是:{set3}")
print(f"取差集后,原有set1的内容:{set1}")
print(f"取差集后,原有set2的内容:{set2}")
# 2个集合合并为1个
set1 = {1, 2,3}
set2 = {1,5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果:{set3}")
print(f"合并后集合1:{set1}")
print(f"合并后集合2:{set2}")
# 统计集合元素数量len()
set1 = {1, 2, 3, 4,5,1,2,3,4,5}
num = len(set1)
print(f"集合内有:{num}个")
# 集合的遍历
# 集合不支持下标索引 不能用while循坏
# 可以用for循环
set1 = {1,2,3,4,5}
for element in set1:
print(f"集合的元素有:{element}")
十、字典
1.可以使用字典,实现用key取出Value的操作
2.字典的定义,同样使用{},不过存储的元素是一个个的:键值对
3.字典同集合一样,不可以使用下标索引,但是字典可以通过key值来取得对应的Value
4.字典内key不允许重复,重复添加等同于覆盖原有数据
5.键指对的key和Value可以是任意类型(key不可为字典)
"""
演示数据容器字典的定义
"""
# 定义字典
my_dict1 = {"王力鸿": 99,"周杰轮":88,"林俊节":77}
# 定义空字典
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_dict1 = {"王力鸿": 99,"王力鸿":88,"林俊节":77}
print(f"重复key的字典的内容是:{my_dict1}
# 从字典中基于Key获取Value
my_dict1 = {"王力鸿":99,"周杰轮":88}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是:{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是:{score}")
#定义嵌套字典
stu_score_dict ={
"王力鸿": {
"语文": 77,
"数学":66,
"英语":33},
}, "周杰轮":{
"语文": 88,
"数学":86,
"英语":55"
{, "林俊节":{
"语文":99,
"数学":96,
"英语":66
}
}
print(f"学生的考试信息是:{stu_score_dict}")
# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是:{score}")
score = stu_score_dict["林俊节”]["英语"]
print(f"林俊节的英语分数是:{score}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素,结果:{my_dict},周杰轮的考试分数是:{score}")
# 清空元素clear
my_dict.clear()
print(f"字典被清空了,内容是,{my_dict}")
# 获取全部的key
my_dict = {"周杰轮":99,"林俊节":88,“张学油":77}
keys = my_dict.keys()
print(f"字典的全部keys是:{keys}")
# 遍历字典
# 方式1:通过获取到全部的key来完成遍历
for key in keys:
print(f"字典的key是:{key}")
print(f"字典的value是:{my_dict[key]}")
# 方式2:直接对字典进行for循环,每一次循环都是直接得到key
for key in my_dict:
print(f"2字典的key是:{key}")
print(f"2字典的value是:{my_dict[key]}")
# 统计字典内的元素数 len()函数
num = len(my_dict)
print(f"字典中的元素数量有:{num}个")
十一、字典的常用操作
1.新增元素
2.更新元素(字典key不可以重复,所以对已存在的key执行上述操作,就是更新Value值)
3.删除元素
4.清空字典
5.获取全部的key
6.特点
可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以修改
支持for循环,不支持while循环
7.新增和更新元素的语法一致,如果Key不存在即新增,如果Key存在即更新
操作 | 说明 |
字典[key]=value | 添加或更新键值对 |
字典[key] | 获取指定key对应的Value值 |
字典.pop(key) | 取出key对应的Value并在字典内删除此key的键值对 |
字典.clear() | 清空字典 |
字典.keys() | 获取字典的全部key,可用于for循环遍历字典 |
len(字典) | 计算字典内的元素数量 |
十二、五类数据容器对比总结
1.是否支持下标索引
支持:列表、元组、字符串—序列类型
不支持:集合、字典—非序列类型
2.是否支持重复元素
支持:列表、元组、字符串—序列类型
不支持:集合、字典—非序列类型
3.是否可以修改
支持:列表、集合、字典
不支持:元组、字符串
十三、数据容器的通用操作
1.遍历
2.len(容器):统计容器的元素个数
max(容器):统计容器的最大元素
min(容器):统计容器的最小元素
3.
tuple(容器) :将给定容器转换为元组
set(容器):将给定容器转换为集合
list(容器):将给定容器转化为列表
str(容器):将给定容器换为字符串
4.通用排序功能:
sorted(容器,[reverse=True])
将给定容器进行排序
"""
演示数据容器的通用功能
"""
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元素个数
pridt(f"列表元素个数有:{len(my_list)}")
print(f"元组 元素个数有:{len(my_tuple)}")
print(f"字符串元素个数有:{len(my_str)}")
print(f"集合 元素个数有:{len(my_set)}")
print(f"字典元素个数有:{len(my_dict)}")
功能 | 描述 |
通用for循环 | 遍历容器(字典是遍历key) |
max | 容器内最大元素 |
min() | 容器内最小元素 |
len() | 容器元素个数 |
list() | 转换为列表 |
tuple() | 转换为元组 |
str() | 转换为字符串 |
set() | 转换为集合 |
sorted(序列,[reverse=True]) | 排序,reverse=True表示降序 |