旅游型网站的建设背景,怎样创建快捷方式,网站开发安全性分析,互联网网站名字python基础专栏 python基础#xff08;第五期#xff09; 文章目录 python基础#xff08;第五期#xff09;数据容器一、列表1、列表的定义2、列表的下标索引 3、列表的(添加)方法3.1 列表的查询方法3.2 修改特定下标索引的值3.3 列表指定位置插入元素3.3 列表指定元素的追… python基础专栏 python基础第五期 文章目录 python基础第五期数据容器一、列表1、列表的定义2、列表的下标索引 3、列表的(添加)方法3.1 列表的查询方法3.2 修改特定下标索引的值3.3 列表指定位置插入元素3.3 列表指定元素的追加尾部添加3.4 列表尾部追加指定的容器 4、列表的(删除)方法4.1 删除列表元素4.2 删除列表的第一个匹配项4.3 清空整个列表 5、 统计列表元素5.1 统计列表指定元素个数5.2 统计列表元素的总数量 6、列表小结 二、列表遍历三、元组的定义和使用1、元组的定义2、元组的相关操作3、元组的注意事项 四、元组的遍历五、字符串5.1 index方法5.2 replace字符串替换5.3 split 字符串分隔切片5.4 strip 字符串规整操作 去首尾空格5.5 count方法统计字符串出现的个数5.6 len方法统计长度 六、序列容器的切片操作七、集合的定义和使用7.1 基本语法定义7.2 添加指定元素add7.3 移除指定元素remove7.4 随机取元素pop7.5 清空集合 clear 八、集合的差集8.1 取集合的差集difference8.2 消除集合的差集 (difference_update)8.3 合并集合union8.4 统计集合元素方法 len8.5 集合的遍历(for )8.6 集合总结 九、字典定义9.1 字典的定义9.2 获取字典9.3 字典的嵌套9.4 字典的注意事项 十、字典的操作10.1 新增元素10.2 更新元素10.3 删除字典元素pop10.4 清空字典clear 2、获取全部的 key3、 遍历字典统计字典中元素的个数字典小结字典练习 数据容器
在Python中常见的数据容器有以下几种
列表List列表是最常用的数据容器之一可以存储任意类型的数据并且允许重复的元素。列表使用方括号 [] 来表示各个元素之间用逗号分隔。元组Tuple元组也是一种常见的数据容器与列表相似可以存储任意类型的数据。但不同的是元组使用圆括号 () 来表示且元素不能修改。字典Dictionary字典是一种键值对Key-Value的数据容器可以根据键Key来快速检索对应的值Value。字典使用花括号 {} 来表示每个键值对之间用冒号 : 分隔键和值之间用逗号分隔。集合Set集合是一种无序且不重复的数据容器可以进行交集、并集、差集等基本操作。集合使用花括号 {} 来表示各个元素之间用逗号分隔。
这些数据容器在处理数据时具有不同的特点和用途可以根据实际需求选择使用
一、列表
1、列表的定义
以 [] 作为标识列表内每一个元素之间用逗号隔开
基本语法
列表名 [元素1 元素2 元素3 ....]
列表名 [[列表元素1], [列表元素2], [列表元素3], [列表元素4]]注意点
列表中元素存储的类型可以是不同的。里面的元素也可以是变量。元素可以是嵌套列表哦里面的子列表就是父列表的一个元素。
容器 列表list
# 定义一个列表list
my_list [liujintao, python, hello world]
print(my_list)
print(type(my_list))my_list [helloPython, 999, True, A]
print(my_list)
print(type(my_list))# 定义一个嵌套列表
my_list [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))2、列表的下标索引
想要从列表中找到特定位置的数据就得用 “下标索引”。
书写格式my_list[0] 或者my_list[-1] → 嵌套写法先取子列表在取子列表里面的索引号哦
正向默认索引从 0 开始反向默认从 -1 开始。还需注意列表索引不能超出范围哦
# 通过下标索引取出对应位置的数据
my_list [liu, jin, tao]
print(my_list[0]) # 输出结果liu
print(my_list[-1]) # 输出结果tao
# print(my_list[3]) # 报错下标超出范围# 取出嵌套列表的元素
my_list [[1, 2, 3], [4, 5, 6]]
print(my_list[1][-1]) # 输出结果 6方法表
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
3、列表的(添加)方法
之前我么学过函数就知道函数就是封装的一个代码单元完成特定的功能 在python中如果将函数定义为 class类的成员那么函数就会称为 方法。 函数和方法就是一样的就是调用方法有些差异
3.1 列表的查询方法
查找某元素的下标 查找某元素在列表中的下标找到则返回索引号否则报错
语法格式
列表.index(元素)# 定义一个列表
my_list [liu, jin, tao]# 1、查找列表中某元素下标索引号
index my_list.index(jin)
print(fjin的下标索引号是{index}) # jin的下标索引号是1# 2、查找元素不存在报错
index my_list(hello)
# print(fhello的下标索引号是{index}) # 报错因为不在列表中
3.2 修改特定下标索引的值
语法格式
my_list[索引号] 新值# 1、修改特定下标索引的值
my_list[0] Yu
print(my_list) # [Yu, jin, tao]3.3 列表指定位置插入元素
语法格式
my_list.insert(下标 插入的元素)# 1、 在列表指定下标插入元素
my_list.insert(1, Xin)
print(my_list) # [Yu, Xin, jin, tao]3.3 列表指定元素的追加尾部添加
语法格式
my_list.append(追加的元素)# 1、列表指定元素的追加尾部添加
my_list.append(like)
print(my_list) # [Yu, Xin, jin, tao, like]3.4 列表尾部追加指定的容器
my_list.extend(追加的容器)# 1、尾部追加一批元素(容器)
my_list2 [Y, a, o]
my_list.extend(my_list2)
print(my_list) # [Yu, Xin, jin, tao, like, Y, a, o]4、列表的(删除)方法
4.1 删除列表元素
语法格式
方法一 del 列表名[下标]
方法二列表名.pop(下标)my_list [liu, jin, tao]# 1、方法一删除指定下标元素
del my_list[0]
print(my_list) # [jin, tao]# 2、方法二列表.pop(下标)
my_list.pop(0)
print(my_list) # [tao]4.2 删除列表的第一个匹配项
语法格式
列表名.remove(元素)# 3、删除列表的第一个匹配项
my_list [1, 3, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list)) # 10
# 删除元素 3
mylist my_list.remove(3)
print(my_list) # [1, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list)) # 94.3 清空整个列表
语法格式
列表名.clear()# 4、 清空列表
my_list.clear()
print(my_list) # []5、 统计列表元素
5.1 统计列表指定元素个数
my_list2 [Y, a, o]语法格式
列表.count(元素)# 1、统计列表指定元素个数
count my_list2.count(Y)
print(count) # Y 的数量为 15.2 统计列表元素的总数量
语法格式
len(列表名)num len(my_list2)
print(num) # 36、列表小结
列表可以存放多个元素也是有限的只不过正常情况下我们是用不完的混装列表中的元素可以不同类型下标列表中的元素存放是有序的重复列表中允许数据重复可操作允许我们对列表中的数据进行操作 二、列表遍历
语法请看下面示例注意看函数说明文档
list:遍历迭代
# 用 while循环实现
def list_while_func():这个函数的作用是使用while遍历列表:return: None:index: 是列表的索引号:len(my_list): 是while循环的终止条件:my_list[index]: 根据列表的索引号访问列表达到遍历的效果my_list [liu, jin, tao]index 0while index len(my_list):print(my_list[index])index 1list_while_func()
返回结果liujintao
# 用for循环实现def list_for_func():使用for循环遍历列表:return: None:range: 同样的是循环的条件:len(my_list): 是列表的长度只要 条件变量 i 还在 长度数值范围内循环执行my_list [liu, jin, tao]for i in range(len(my_list)):print(my_list[i])list_for_func()
返回结果liujintao使用场景
while 适用于任何想要的循环
for 遍历数据容器的场景或简单的固定次数的循环场景
三、元组的定义和使用
想想看列表里面的元素是不是可以被修改
那么元组定义后它里面的元素就不能被修改哦
列表是可读写的而元组只能读不能写。
也就是说我们希望数据不被修改此时使用元组是最好不过了。
1、元组的定义
和列表一样就是将[] 换成 即可
# 元组字面量
(元素1 元素2 元素3.......)
# 元组变量
变量名称 元素 元素 元素 .....
# 空的元组
变量名称
变量名称 tuple演示 tuple 元组的定义使用
# 定义元组
t1 (1, hello, True)
t2 ()
t3 tuple()
print(ft1的类型是{type(t1)},内容是:{t1}) # t1的类型是class tuple,内容是:(1, hello, True)
print(ft2的类型是{type(t2)},内容是:{t2}) # t2的类型是class tuple,内容是:()
print(ft3的类型是{type(t3)},内容是:{t3}) # t3的类型是class tuple,内容是:()# 定义单个元素
t4 (1,)
print(ft4的类型是{type(t4)},内容是:{t4}) # t4的类型是class tuple,内容是:(1,)# 嵌套元组
t5 ((1, 2, 3), (4, 5, 6))
print(ft5的类型是{type(t5)},内容是:{t5}) # t5的类型是class tuple,内容是:((1, 2, 3), (4, 5, 6))# t5里面取出第 6 个元素
print(t5[1][2]) # 输出结果 6
2、元组的相关操作
编号方法作用1index查找某个数据有返回下标没有则报错2count统计某个数据在当前元组出现的次数3len元组统计元组内的元素个数
# 1、index方法
t6 (liu, jin, tao)
index t6.index(jin)
print(f在元组t6中查找 jin 的下标为{index}) # 在元组t6中查找 jin 的下标为1# 2、count方法
t7 (liu, jin, jin, jin, tao)
count t7.count(jin)
print(f在元组t7中元素个数为{count}) # 在元组t7中元素个数为3# 3、len方法
t8 (liu, jin, jin, jin, tao)
print(f元组t8的长度为{len(t8)}) # 元组t8的长度为53、元组的注意事项
1、 元组是不可以被修改的
2、我们再元组中嵌套了 列表list 这样我们是可以修改里面列表的元素哦。
唯一可修改的地方内部列表
t11 (1, 2, 3, [liu, jin, tao])
print(ft11元组的内容是{t11}) # t1元组的内容是(1, 2, 3, [liu, jin, tao])
t11[3][0] LIU
print(f修改后的值为{t11}) # 修改后的值为(1, 2, 3, [LIU, jin, tao])四、元组的遍历
和列表一样既然可以操作小标那么遍历也是一样的。
# 1、元组的遍历while
t9 (liu, jin, jin, jin, tao)
i 0
while i len(t9):print(t9[i])i 1# 2、元组的遍历for
t10 (liu, jin, jin, jin, tao)
for i in range(len(t10)):print(t10[i])五、字符串
字符串也是容器一个字符串可以存放多个字符。
字符串是只读的并不支持修改哦长度任意取决于内存大小支持下标索引允许重复字符支持for循环
5.1 index方法
# index方法
my_srt hello world
print(my_srt.index(l)) # 2
print(my_srt.index(o)) # 4
print(my_srt.index(w)) # 6
print(my_srt.index(d)) # 10
# print(my_srt.index(z)) # 报错5.2 replace字符串替换
语法字符串.replace(字符串1字符串2) 功能将字符串内的全部 字符串1替换为字符串2 注意不是修改字符串本身而是返回新的字符串注意接收返回的新值哦
new_my_str my_str.replace(world, python)
print(new_my_str) # hello python5.3 split 字符串分隔切片
语法字符串.split(分隔符字符串) 功能按照指定的分隔符字符串将字符串划分为多个字符串并存入到列表对象中 注意字符串本身不变而是得到一个新的列表对象
my_str liu jin tao
my_str_list my_str.split( )
print(my_str_list) # [liu, jin, tao]5.4 strip 字符串规整操作 去首尾空格
语法1字符串.strip() 语法2字符串.strip(字符串)
new_my_str my_str.strip()
print(new_my_str) # liujintao like code 99
# 用法2
new_my_str my_str.strip(99)
print(new_my_str) # liujintao like code5.5 count方法统计字符串出现的个数
count my_str.count(l)
print(count) # 25.6 len方法统计长度
lens len(my_str)
print(lens) # 34六、序列容器的切片操作
上面学习的 列表、元组、字符串都是序列哦。
语法格式
序列[起始下标 结束下标 步长]表示从序列中从指定位置开始一次取出元素到指定位置结束得到一个新的序列。
省略的话默认从头或到尾。
注意点切片操作不会影响到序列本身因为操作后会得到一个新的序列。
序列切片
# 对List进行切片从 1开始4结束 步长为1
my_list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[1:4]) # [2, 3, 4]
print(my_list[1:4:1]) # [2, 3, 4]# 对tuple进行切片从头开始到最后步长为1
my_tuple (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[0:]) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[:]) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::]) # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)# 对str进行切片从头开始到最后结束步长为2
my_str 0123456789
print(my_str[0::2]) # 02468
print(my_str[::2]) # 02468# 倒序: 对列表进行切片, 从 3 开始 1 结束 步长 -1
my_list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[3:1:-1]) # [4, 3]# 倒序: 对tuple进行切片, 从头开始 尾结束 步长 -2
my_tuple (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::-2]) # (10, 8, 6, 4, 2)
七、集合的定义和使用
我们学习了列表、元组、字符三个数据容器其实基本上能够满足大多数场景为何还需要学习集合类型 列表可修改支持重复元素且有序 元组、字符串不可修改、支持重复元素且有序 由此发现都是有序的啊有什么方法可以乱序啊
此时就得使用集合了。
注意
首先因为集合是无序的所以集合不支持下标索引访问。但是集合和列表一样是允许修改的所以我们来看看集合的修改方法。
7.1 基本语法定义
列表、元组、字符串等定义的语法基本相同
# 定义集合字面量
{元素 元素 .....}
# 定义集合变量
变量名称 {元素 元素 .....}
# 定义空集合
变量名称 set()集合的几把呢使用
# 定义集合
my_set {liu, jin, tao}
my_set_empty set()
print(fmy_set的内容是{my_set}, 类型是{type(my_set)}) # my_set的内容是{liu, jin, tao}, 类型是class set
print(fmy_set的内容是{my_set_empty}, 类型是{type(my_set_empty)}) # my_set的内容是set(), 类型是class set
7.2 添加指定元素add
set.add(元素):将指定元素添加到集合内。
集合本身被修改添加了新元素
my_set.add(python)
my_set.add(java)
print(fmy_set添加元素结果为{my_set}) # my_set添加元素结果为{python, liu, tao, jin}由于集合是去重的不能有重复的如果我们添加的元素集合里面有那么就不会再次进行添加。
7.3 移除指定元素remove
set.remove(元素)将指定元素从集合内移除。
集合本身被修改移除了元素
my_set.remove(tao)
print(fmy_set移除元素结果为{my_set}) # my_set移除元素结果为{python, java, liu, jin}7.4 随机取元素pop
my_set.pop()
print(fmy_set随机取元素结果为{my_set}) # {liu, jin, python}7.5 清空集合 clear
my_set.clear()
print(fmy_set清空集合结果为{my_set}) # set()八、集合的差集
8.1 取集合的差集difference
set1 {1, 2, 3}
set2 {1, 5, 6}
set3 set1.difference(set2)
print(f取差集后的结果是{set3}, 元素有的集合为{set1, set2}) # 取差集后的结果是{2, 3}, 元素有的集合为({1, 2, 3}, {1, 5, 6})去除元素相同的得到新的集合原来的集合不变
8.2 消除集合的差集 (difference_update)
set1 {1, 2, 3}
set2 {1, 5, 6}
set1.difference_update(set2)
print(f消除差集后的集合1为{set1}, 集合2为{set2}) # 消除差集后的集合1为{2, 3}, 集合2为{1, 5, 6}消除两个集合中相同的元素此时集合1就会发生变化
8.3 合并集合union
set1 {1, 2, 3}
set2 {1, 5, 6}
set3 set1.union(set2)
print(f两集合合并后结果为{set3}) # 两集合合并后结果为{1, 2, 3, 5, 6}将两个集合合并起来但是重复的只保留一个得到新的集合
8.4 统计集合元素方法 len
set1 {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num len(set1)
print(num) # 5 因为集合去重8.5 集合的遍历(for )
集合没有下标不能使用while只能用for处理
for i in set1:print(i) # 1 2 3 4 5集合练习
信息去重
my_list [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, liu, jin, liu, jin, tao]
my_set set()
for i in my_list: # 将列表中的元素一个一个拿出来添加到集合中my_set.add(i)
print(my_set) # {1, 2, 3, 4, 5, 6, 7, 8, 9, jin, tao, liu}8.6 集合总结
集合总结 1、可以容纳多个数据 2、可以容纳不同数据类型的数据 3、数据时无序的不支持下标索引 4、不允许重复数据存在 5、可以修改增加或删除元素 6、支持for循环遍历
九、字典定义
生活中的字典就是字含义
字典的定义同样使用{}不过存储的元素是一个个的键值对如下所示
# 定义字典字面量
{key: value, key: value, .....}
# 定义字典字面量
my_dict {key: value, key: value,......}
# 定义空字典
my_dict {}
my_dict dict()9.1 字典的定义
my_dict {name: 张三, age: 18}
print(type(my_dict)) # class dict
print(my_dict) # {name: 张三, age: 18}# 定义空的字典
empty_dict {}
my_dict1 dict()
print(empty_dict) # {}
print(my_dict1) # {}9.2 获取字典
my_dict {name: 张三, age: 18}
age my_dict[age]
print(age) # 189.3 字典的嵌套
stu_score_dict {liu: {语文: 90,数学: 99,英语: 66,},jin: {语文: 80,数学: 89,英语: 76,},tao: {语文: 95,数学: 99,英语: 76,}
}print(stu_score_dict) # {周杰轮: {语文: 90, 数学: 99, 英语: 66}, jin: {语文: 80, 数学: 89, 英语: 76}, tao: {语文: 95, 数学: 99, 英语: 76}}
print(stu_score_dict[tao][数学]) # 99
print(stu_score_dict[liu][英语]) # 669.4 字典的注意事项
键值对的 key 和 value 可以是任意类型key不可为字典
字典内 key 不允许重复重复添加等同于覆盖原有数据
字典没有下标用的是key来检索 value值
十、字典的操作
以下面字典操作为例
my_dict {liu: 99, jin: 88, tao: 77}10.1 新增元素
my_dict[yxy] 100
print(f字典经过新增元素后结果为{my_dict}) # 字典经过新增元素后结果为{liu: 99, jin: 88, tao: 77, yxy: 100}
10.2 更新元素
有则跟新无则添加
my_dict[liu] 100
print(f修改元素后的结果为{my_dict}) # 修改元素后的结果为{liu: 100, jin: 88, tao: 77, yxy: 100}
10.3 删除字典元素pop
有新的返回值 score my_dict.pop(yxy)
print(f删除字典元素后的结果为{my_dict}) # 删除字典元素后的结果为{liu: 100, jin: 88, tao: 77}
print(score) # 10010.4 清空字典clear
my_dict.clear()
print(my_dict) # {}2、获取全部的 key
注意有返回值哦可以使用遍历去操作字典的 key 和 value
语法
字典.keys() # 得到所有的keymy_dicts {liu: yu,jin: xin,tao: yao
}keys my_dicts.keys()
print(keys) # dict_keys([liu, jin, tao])3、 遍历字典
重点是keys使我们通过keys方法获取到的一个key列表然后我们使用for循环依次遍历列表。这样i就是keys这个列表迭代器里面的每一个元素。
最后我们每次循环都对字典key进行访问器结果值。
# keys拿到的结果我用for循环拿到key 然后 在获取到value
for i in keys:print(my_dicts[i])运行结果yuxinyao方法2
for key in my_dicts:print(key) # 得到所有的 keyprint(my_dicts[key]) # 得到所有的value值效果是一样的。
注意字典是不能使用while的因为他不允许下标索引。
统计字典中元素的个数
使用len方法实现
number len(my_dicts)
print(number) # 3用变量计数器
count 0
for key in my_dicts:count 1print(f字典中共有, count)
字典中共有 1字典中共有 2字典中共有 3字典小结
可以容纳多个数据可以容纳不同类型的数据每一份数据是key value键值对可以通过key获取到valuekey不可重复重复会覆盖掉不支持下标索引因此不能使用while遍历可以修改增删或更新只能for循环遍历
字典练习
完成数据的存储通过遍历一级员工升级并 1000
def main():is_dict {王力宏: {部门: 科技部,工资: 3000,级别: 1},周杰轮: {部门: 市场部,工资: 5000,级别: 2},林俊杰: {部门: 市场部,工资: 7000,级别: 3},张学友: {部门: 科技部,工资: 4000,级别: 1},刘德华: {部门: 市场部,工资: 6000,级别: 2}}# 遍历判断等级for key in is_dict.keys():if is_dict[key][级别] 1:is_dict[key][级别] 2is_dict[key][工资] 1000print(is_dict[key])
main()
