目录
Python如何删除包含在元组(tuple)中的列表(list)中的某个元素
1.列表:
(1)列表的下标索引:
(注意:要注意下标索引的取值范围,超出范围无法取出元素,并且会报错)
①从前向后的方向,从 0 开始,依次递增。#语法:列表[下标索引]
②反向索引,从后向前:从-1开始,依次递减( -1、-2、-3...... ) #语法:列表[标号]
③嵌套列表下标索引
a_list = [[2,4,6,8,0,3],["num","sum","max","min"]]
print(a_list[1][3]) #输出是min
(2)列表的常用操作(方法):
功能 | 使用方法 | 作用 | |
查找 | 列表[下标索引] | 使用下标索引获取值 | |
列表 .index( 元素 ) | 查找指定元素在列表的下标,找不到报错 ValueError | ||
修改 | 赋值 | 列表 [ 下标 ] = 值 | 重新赋值 |
插入 | 列表 .insert( 下标 , 元素 ) | 在指定的下标位置,插入指定的元素 | |
追加 | 列表 .append( 元素 ) | 将指定元素,追加到列表的尾部 | |
列表 .extend( 其它数据容器 ) | 将其它数据容器的内容取出,依次追加到列表尾部 | ||
删除 | del 列表 [ 下标 ] | 仅删除列表指定下标元素 | |
列表 .pop( 下标 ) | 删除并可取出元素作为返回值得到 | ||
列表 .remove( 元素 ) | 从前向后,删除此元素第一个匹配项 | ||
清空 | 列表 .clear() | 清空列表 | |
统计 | 列表 .count( 元素 ) | 统计此元素在列表中出现的次数 | |
len( 列表 ) | 统计容器内有多少元素 |
(3)列表的特点:
• 可以容纳多个元素(上限为 2**63-1 、 9223372036854775807 个)
• 可以容纳不同类型的元素(混装)
• 数据是有序存储的(有下标序号)
• 允许重复数据存在
• 可以修改(增加或删除元素等)
2.元组
如果需要在程序内封装数据,又不希望封装的数据被篡改,那么元组就非常合适了,因为元组一旦定义完成,就不可修改。
(1)元组的常用操作(方法):
元组由于不可修改的特性,所以其操作方法非常少
功能 | 方法 | 作用 |
查找 | 元组.index() | 查找某个数据,如果数据存在返回对应的下标,否则报错 |
统计 | 元组.count() | 统计某个数据在当前元组出现的次数 |
len( 元组 ) | 统计元组内的元素个数 |
Python如何删除包含在元组(tuple)中的列表(list)中的某个元素
a_tuple = ('十个勤天',10,['farmer','crop'])
print(a_tuple.index(10))
print(a_tuple[0])
element = a_tuple[2].pop(1) #删除元组中的列表的元素
print(f"删除的元素是{element},目前的元组为{a_tuple}")
a_tuple[2].append("learning")#在元组中的列表中增加元素
print(f"目前的元组为{a_tuple}")
(2)元组的相关操作 - 注意事项
- 不可以修改元组的内容,否则会直接报错
- 可以修改元组内的 list 的内容(修改元素、增加、删除、反转等)
- 但不可以替换 list 为其它 list 或其它类型
(3)元组的特点:
• 可以容纳多个数据
• 可以容纳不同类型的数据(混装)
• 数据是有序存储的(下标索引)
• 允许重复数据存在
• 不可以修改(增加或删除元素等)
• 支持 for 循环多数特性和 list 一致,不同点在于不可修改的特性(但可以修改内部 list 的内部元素)
3.字符串
字符串是字符的容器,一个字符串可以存放任意数量的字符
如,字符串: "itheima"
字符串是一个无法修改的数据容器,如果必须做修改,只能得到一个新的字符串,旧的字符串是无法修改。
(1)字符串的常用操作(方法):
功能 | 用法 | 作用 |
索引 | 字符串[下标] | 根据下标索引取出特定位置字符 |
字符串 .index( 字符串 ) | 查找给定字符的第一个匹配项的下标 | |
替换 | 字符串 .replace( 字符串 1 ,字符串 2 ) | 将字符串内的全部:字符串 1 ,替换为字符串 2(不是修改字符串本身,而是得到了一个新字符串) |
分割 | 字符串 .split( 分隔符字符串) | 按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中(字符串本身不变,而是得到了一个列表对象) |
规整 | 字符串 .strip() | (不传参)移除首尾的空格和换行符 |
规整 | 字符串 .strip(字符串) | (传参)移除指定字符串 |
统计 | 字符串 .count( 字符串 ) | 统计字符串中某字符串的出现次数 |
统计 | len( 字符串 ) | 统计字符串的长度(各种数字、单个字母、符号(空格、 ! 、 @ 、 # 、 $ 等)、中文均算作 1 个字符) |
注意:查找特定字符串的下标时,查找的是一个单词,显示的下标时单词第一个字母的下标
a_str = "Hope every day counts !"
print(a_str.index("counts"))
(2)字符串的特点:
• 只可以存储字符串
• 长度任意(取决于内存大小)
• 支持下标索引
• 允许重复字符串存在
• 不可以修改(增加或删除元素等)
• 支持 for 循环
(3)小试牛刀练习——分割字符串
要求
①给一个字符串②统计字符串内有多少个某个字符
③将字符串内的空格,全部替换为字符: "|"
④并按照 "|" 进行字符串分割,得到列表
my_str ="Hope I every is happy,active,hardworking,to make every day count,to become best"
print(my_str.count("to"))
replace_my_str =my_str.replace(" ","|")
print(replace_my_str)
replace_my_str_2 =replace_my_str.split("|")
print(replace_my_str_2)
补充拓展:序列的切片
序列:内容连续、有序,可使用下标索引的一类数据容器列表、元组、字符串,均可以可以视为序列。
切片:从一个序列中,取出一个子序列。
语法:序列 [ 起始下标 : 结束下标 : 步长 ]
(左闭右开,从0开始)
• 起始可以省略,省略从头开始
• 结束可以省略,省略到尾结束
• 步长可以省略,省略步长为 1 (可以为负数,表示倒序执行)此操作不影响序列本身,而是生成一个新的序列(列表、元组、字符串)
小试牛刀练习——切片和倒序的用法
#(1)倒序字符串,切片取出
a_str ="’人农新‘的样一不做争,强做大做,地种力努,天勤个十"
result1 = a_str[::-1][:4]
print(result1)
#切片取出,然后倒序
result2 =a_str[22:26][::-1]
print(result2)
# #split分隔",",倒序字符串
result3 =a_str.split(",")[3][::-1]
print(result3)
4.集合:
(1)集合的常用操作:
功能 | 用法 | 作用 | |
修改 | 添加新元素 | 集合 .add( 元素 ) | 将指定元素,添加到集合内(集合本身被修改,添加了新元素) |
移除元素 | 集合 .remove( 元素 ) | 将指定元素,从集合内移除(集合本身被修改,移除了元素) | |
取出元素 | 集合 .pop() | 从集合中随机取出一个元素(会得到一个元素的结果。同时集合本身被修改,元素被移除) | |
清空集合 | 集合 .clear() | 集合本身被清空 | |
取出 2 个集合的差集 | 集合 1.difference( 集合 2) | 取出集合 1 和集合 2 的差集(集合 1 有而集合 2 没有的),得到一个新集合,集合 1 和集合 2 不变 | |
消除 2 个集合的差集 | 集合 1.difference_update( 集合 2) | 对比集合 1 和集合 2 ,在集合 1 内,删除和集合 2 相同的元素。集合 1 被修改,集合 2 不变 | |
2 个集合合并 | 集合 1.union( 集合 2) | 将集合 1 和集合 2 组合成新集合,得到新集合,集合 1 和集合 2 不变 | |
统计 | len( 集合 ) | 统计集合内有多少元素 |
(2)集合的特点:
去重且无序,不支持:下标索引访问,可修改
• 可以容纳多个数据
• 可以容纳不同类型的数据(混装)
• 数据是无序存储的(不支持下标索引)
• 不允许重复数据存在
• 可以修改(增加或删除元素等)
• 支持 for 循环
(3)小试牛刀练习——信息去重
定义一个列表对象,里面的元素值有重复,要求:
• 定义一个空集合
• 通过 for 循环遍历列表
• 在 for 循环中将列表的元素添加至集合
• 最终得到元素去重后的集合对象,并打印输出
my_list = ['good',' cool ', 'nice',' nice ', ' good ', ' well ','good', 'best']
empty_set = set()
for x in my_list:
print(x)
empty_set.add(x)
print(empty_set)
5.字典:
字典的定义,同样使用 {} ,不过存储的元素是一个个的:键值对。字典可以实现用 key 取出 Value 的操作。
字典数据的获取:
字典同集合一样,不可用下标索引,但字典可通过 Key 值来取得对应的 Value
a_dict = {"今年":"2024","明年":"2025"}
print(a_dict["今年"]) #用的是[key]
字典的嵌套
a_dict = {
"张三":{"语文":77,"数学":66,"英语":33},
"李四":{"语文":88,"数学":86,"英语":55},
"老六":{"语文":99,"数学":96,"英语":66}
}
#嵌套字典的内容获取
print(a_dict)
person_score =a_dict["老六"]
print(person_score)
score =a_dict["老六"]["语文"]
print(score)
(1)字典的常用操作:
功能 | 用法 | 作用 |
新增元素 | 字典 [Key] = Value | 字典被修改,新增了元素 |
更新元素 | 字典 Key 不可以重复,所以对已存在的 Key 执行操作,就是更新 Value 值 | |
删除元素 | 字典 .pop(Key) | 获得指定 Key 的 Value ,同时字典被修改,指定 Key 的数据被删除 |
清空字典 | 字典 .clear() | 字典被修改,元素被清空 |
获取全部的 key | 字典 .keys() | 得到字典中的全部 Key |
遍历字典 | for key in 字典 .keys() | 字典不支持下标索引,所以同样不可以用 while 循环遍历 |
计算字典内的元素数量 | len( 字典 ) | 计算字典内的全部元素(键值对)数量 |
(2)字典的特点:
• 可以容纳多个数据
• 键值对的 Key 和 Value 可以是任意类型( Key 不可为字典)
• 每一份数据是 KeyValue 键值对
• 可以通过 Key 获取到 Value , Key 不可重复(重复会覆盖)
• 不支持下标索引,而是通过 Key 检索 Value
• 可以修改(增加或删除更新元素等)
• 支持 for 循环,不支持 while 循环
(3)小试牛刀练习——升职加薪
使用字典完成数据的记录。并通过 for 循环,对所有级别为 13级的员工,级别上升 1 级,薪水增加 1000 元
a_dict = {
"大哥":{"部门":"管理部","工资":10000,"级别":1},
"二哥":{"部门":"科技部","工资":9000,"级别":2},
"三哥":{"部门":"科技部","工资":9000,"级别":2},
"四哥":{"部门":"市场部","工资":8000,"级别":3},
"五哥":{"部门":"市场部","工资":8000,"级别":3},
}
print(a_dict)
for name in a_dict:
if a_dict[name]["级别"] != 3: #获取name里面的key的value
a_dict[name]["级别"] = 2
a_dict[name]["工资"] +=1000
print(a_dict)