Windows Defender完全移除技术指南：三种模式深度解析与性能优化实战
2026/7/24 20:20:13
ps：主包是Java转python，所以主包的文章重点在于python和Java在语法上的区别
数据容器：可以一次容纳多个数据的容器，每个元素可以是任意类型
本篇从，列表（list）、字符串（str）、元组（tuple）、集合（set）、字典（dict）
一、列表（list）
1、定义：列表名称 = [元素1，元素2，元素3.....]，下标可以正着从0开始也可以倒着从-1开始（索引一旦是负数，就意味着是倒着数的），可以重复，可以不同类型，元素有序，可以修改
#列表的类型 s = [1,2,3,4,True,"wang"] print(type(s)) #输出:list print(s) #输出[1,2,3,4,True,"wang"] #列表的元素访问(超出范围将会报错) print(s[0]) #正向索引,输出s的第一个元素:1 print(s[-2]) #反向索引,输出s的倒数第二个元素:True #修改列表中的元素(超出范围将会报错) s[2] = "Li" print(s[2]) #修改后第3个元素的值为"Li" #删除元素(超出范围将会报错) del s[2] print(s) #删除第3个元素后列表为[1,2,4,True,"wang"] #顺序取出元素 for x in s: print(x,end="")#输出124Turewang2、切片：对操作的数据截取一部分的数据。序列数据 [ 开始索引：结束索引：步长 ]（不包含结束索引的数据，开始索引不指定默认为0，结束索引不指定默认为列表长度，步长不指定默认为1，入伙开始索引为负数，步长必须为负数，意为从后截取）
s = [1,2,3,4,True,"wang"] s = s[0:3:1] #截取原本s索引从0到2，步长为1的数据 print(s) #输出[1,2,3] s = [1,2,3,4,True,"wang"] print(s[0:5:2]) #截取索引从0到4，步长为2 输出[1,3,True] print(s[:5:2]) #省略了开始索引，开始索引默认从0开始3、列表的方法
| 方法 | 解释 | 样例 |
| append() | 在列表尾部增加元素 | s.append(4) |
| insert() | 在指定索引之前插入元素 | s.insert(0,9) |
| remove() | 移除列表中第一个匹配到的值的元素 | s.remove(7) |
| pop() | 删除列表中指定索引的元素（未指定索引，默认删除最后一个） | s.pop(2)/s.pop() |
| sort() | 对列表进行排序（前提是数据类型一样 ，默认从小到大） | s.sort() |
| reverse() | 反转列表元素 | s.reverse() |
s = [12,2,3,4,5,6,78,2] #在列表尾部追加元素 s.append(8) print(s) #[12,2,3,4,5,6,78,2,8] #在指定索引位置的前面增加元素 s.insert(3,8) print(s) #[12,2,3,8,4,5,6,78,2,8] #删除第一个匹配到的值的元素 s.remove(2) print(s) #[12,3,8,4,5,6,78,2,8] #删除指定索引位置的元素 s.pop(5) print(s) #[12,3,8,4,5,78,2,8] #排序 s.sort() print(s) #[2,3,4,5,8,8,12,78] #反转 s.reverse() print(s) #[78,12,8,8,5,4,3,2]4、列表案例
案例1：让用户输入10个数字，存储到一个列表中，输出它们的最大值最小值和平均值
引入：min（）获取最小值、max（）获取最大值、len（）获取长度、sum（）求和
s = [] for i in range(0,10): num = int(input(f"请输入第{i}个数字：")) s.append(num) print(f"你输入的列表是[{s}]") s.sort() print(s) print(f"排序后的列表是[{s}]") print(f"10个数字的最小值是：{min(s)}") print(f"10个数字的最大值是：{max(s)}") print(f"10个数字的平均值是：{sum(s)/len(s)}")案例2：合并2个列表中的元素 num_list1 = [2,3,7,8,4,5]，num_list2 = [8,9,10,2,5,7]，并进行去重处理（除去两个列表中相同的元素）
引入:in判断元素是否在数列中，如果存在返回True进行循环，如果不存在返回False;
not in反之，返回结果为bool
解包，列表容器拆开为一个一个元素，写法“*列表名”
组包，将多个值组合到一个容器
num_list1 = [2,3,7,8,4,5] num_list2 = [8,9,10,2,5,7] #合并列表 num_list3 = [*num_list1,*num_list2] #另一种合并方法直接相加 num_list4 =num_list1 + num_list2 print(num_list3) #[8, 9, 10, 2, 5, 7, 2, 3, 7, 8, 4, 5] print(num_list4) #去重 new_list = [] #去重后的列表 for num in num_list2: if num not in new_list: new_list.append(num) print(new_list) #[8, 9, 10, 2, 5, 7, 3, 4]案例3：在列表中输入1~20的平方；从下面列表中找出偶数，并计算它们的平方，组成新的列表
引入：列表推导式（可以把for + if（可选）和要插入的值结合起来）：
[要插入的值 for 变量 in 迭代对象 if 条件]
2层for：[要插入的值 for 变量 in 迭代对象 for 变量 in 迭代对象]
#求出1~20的平方，并存放到新容器中 a = [i**2 for i in range(1,21)] print(a) #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400] #从下面列表中找出偶数，并计算它们的平方，组成新的列表 b = [1,2,3,4,5,6] c = [num**2 for num in b if num %2 == 0] print(c) #[4, 16, 36]二、字符串（str）
1、介绍
可以存放任意字符，“Python” 'Python' """Python""",无法修改，有序可迭代，索引的表示和列表一样，正向索引从0开始，反向索引从-1开始。字符串名 = "' / '' /""""""
切片语法和列表的切片一样：序列对象[开始索引：结束索引：步长]
基本除了不能修改其他都和列表一样，直接看实际例子，不过多解释
#表示 s = "Python" print(s[-1]) #n print(s[3]) #h #字符串不能修改修改会报错 #eg：s[2] = x就会报错 #迭代 for i in range(len(s)): print(s[i],end="") #或者 for i in s: print(i,end="") #切片 print(s[0:4:2]) #输出Pt print(s[-1:-4:-2]) #输出nh2、字符串的常用方法
| 方法 | 作用 | 实例 |
| find() | 在字符串中查找字符串，返回第一次出现的索引位置，找不到返回-1 | s.find('Python') |
| count() | 统计字串在字符串中出现的次数 | s.count('H') |
| upper() | 将字符串中所有字母转化成大写 | s.upper() |
| lower() | 将字符串中所有字母转化成小写 | s.lower() |
| split() | 将字符串按指定分隔符分割成列表 | s.split(' ') |
| strip() | 去除字符串两端的空白字符(默认)或指定字符 | s.strip()/s.strip('*') |
| replace() | 将字符串中的指定字串替换成新的字串 | s.replace('H'，'C') |
| startswitch() | 检查字符串是否以指定字串开头，返回bool | s.startswitch('P') |
s = "*Hello -- Python -- How are you doing?*" print(s.find('Python')) #10 print(s.count('H')) #2 print(s.upper()) #*HELLO -- PYTHON -- HOW ARE YOU DOING?* print(s.lower()) #*HELLO -- PYTHON -- HOW ARE YOU DOING?* #按照‘--’切割成列表 slist = s.split('--') print(slist) #['*Hello ', ' Python ', ' How are you doing?*'] #去除字符串两端的* s1 = s.strip('*') print(s1) #['*Hello ', ' Python ', ' How are you doing?*'] print(s.replace('Python', 'Java')) #*Hello -- Java -- How are you doing?* print(s.startswith('*Hello')) #True3、案例
邮箱验证：用户输入一个邮箱，验证邮箱格式是否正确（至少包含一个 . 和只有一个@），若格式正确，则输出邮箱格式正确，若错误，则输出邮箱格式错误
user = input("Enter your username: ") if '.' in user and user.count('@') == 1: print("邮箱格式正确") else: print("格式输入错误")三、元组（tuple）
1、介绍
元组和列表相似，可以存储不同类型，有序可重复支持索引访问切片，但是不可以修改(增删改)
定义：元组名称 = （元素1，元素2，.......）或元素名称 = 元素1，元素2 ，......
空元组 ：元素名称 = （）或 元素名称 =tuple（）（tuple是个函数，后面详细说明）
如果定义单元组：元组名称 = （元素1，），直接元素名称 = （元素）会被识别为元素类型而不是元组
2、方法（只有2个）
| 方法 | 介绍 | 实例 |
| count（） | 统计某元素在元组中出现的次数 | s.count(2) |
| index（） | 查找某个元素第一次出现在索引中的位置 | s.index(True) |
#定义 t = (2,3,5,56,6,True,"H","P","H") print(t[0],t[-1]) #2 H #如果 t[1] = 9则报错因为元组不支持修改 #切片 print(t[2:7:2]) #(5,6,'H') #count() print(t.count("H")) #2 #index() print(t.index("H")) #6 #单元素元组 t1 = (200,) print(type(t1)) #<class 'tuple'> t2 = (200) print(type(t2)) #<class 'tuple'>3、组包和解包
组包：将多个值合并到一个容器（元组、列表）
解包：将容器（元组、列表）解开成独立的元素，分别赋值给多个变量
元组解包时，*表示收集剩余的所有元素，允许我们处理不确定数量的元素（生成列表，以便于可以进一步的处理）
#定义元组，组包 t = (2,3,True,"H") #定义元组，组包 t1 = 2,3,True,"H" #基础解包（变量数量与容器的元素个数一致） a,b,c,d = t #(*)扩展解包 x,*y,z =t #x为2，y为[3,True]，z为‘H’ s,*o = t #s为2，o为[3,True,"H"] *f,e = t #f为2,3,True，e为"H" #案例：交换a = 20,b = 20 a = 10 b = 20 print(a , b) # 10 20 a,b = b,a # 此处相当于做了一个组包和解包的操作 # 组包 # t =b,a # 解包 # a,b =t #合并后的效果a,b = b,a print(a,b) # 20 104、案例
案例1：根据提供的学生成绩单，完成如下需求：（1）计算每个学生的总分、各科平均分，然后一并输出；（2）统计各科成绩单额最低分、最高分、平均分，并输出；（3）查找成绩优秀（平均分大于90 ）的学生，并输出
| 学号 | 姓名 | 语文 | 数学 | 英语 |
| A01 | 王五 | 80 | 99 | 89 |
| A02 | 张三 | 92 | 80 | 100 |
| A03 | 李四 | 78 | 100 | 79 |
| A04 | 嘉豪 | 96 | 72 | 88 |
| A05 | 嘉欣 | 89 | 91 | 94 |
| A06 | 子涵 | 89 | 70 | 91 |
| A07 | 十三 | 79 | 77 | 84 |
| A08 | 张冠 | 88 | 92 | 89 |
| A09 | 李戴 | 86 | 85 | 98 |
| A10 | 黑子 | 90 | 66 | 78 |
#元组内嵌小元组 students = ( ("王五",80,99,89), ("张三",92,80,100), ("李四",78,100,79), ("嘉豪",96,72,88), ("嘉欣",89,91,94), ("子涵",89,70,91), ("十三",79,77,84), ("张冠",88,92,89), ("李戴",86,85,98), ("黑子",90,66,78) ) #第一种方法 #计算每个学生的总分、各科平均分并输出 Youxiu = [] for s in students: total_students = s[1]+s[2]+s[3] avg = total_students/3 print(f"{s[0]}同学的总分是：{total_students} 平均分是：{avg:.1f}") #.1f是保留一位小数 if avg > 90: Youxiu.append(s[0]) print(f"成绩优秀的学生有：{Youxiu}") #各科成绩单最低分，最高分，平均分并输出 Yuwen = [s[1] for s in students] Shuxue = [s[2] for s in students] YinYu = [s[3] for s in students] print(f"语文的最高分是:{max(Yuwen)} 语文的最低分是:{min(Yuwen)} 平均分是:{sum(Yuwen)/len(Yuwen):.2f}") print(f"数学的最高分是:{max(Shuxue)} 数学的最低分是:{min(Shuxue)} 平均分是:{sum(Shuxue)/len(Shuxue):.2f}") print(f"英语的最高分是:{max(YinYu)} 英语的最低分是:{min(YinYu)} 平均分是:{sum(YinYu)/len(YinYu):.2f}") #第二种方法（组包解包） for name,Yu_Wen,Shu_Xue,Yin_YU in students: total_students = Yu_Wen + Shu_Xue + Yin_YU avg = total_students/3 print(f"{name}同学的总分是：{total_students} 平均分是：{avg:.1f}") #.1f是保留一位小数 if avg > 90: Youxiu.append(name) print(f"优秀的同学有{Youxiu}")四、集合（set）
1、介绍
集合是一种无序，不重复（可以自动去重），可修改的数据容器
定义：集合名称 = {元素1，元素2，......}，集合名称 = set（）（空集合）
ps：空集合不能用{}定义，{}定义出来的是字典，且集合是无序的所以不支持索引检索
2、方法
| 方法 | 含义 | 实例 |
| add(...) | 添加元素到集合中 | s.add('t') |
| remove(...) | 移除集合中的指定元素（若不存在将报错） | s.remove('t') |
| pop() | 随机删除集合中的一个元素并返回 | e = s.pop() |
| clear() | 清空集合 | s.clear() |
| difference() | 求取两个集合的差集（包含第一个集合但不包含在第二个集合的元素） | s.difference(s1) |
| union()或“|” | 求取两个集合的并集 | s.union(s1) |
| intersection()或“&” | 求取两个集合的交集 | s.intersection(s1) |
#定义 s1 = {0,1,2,3,4,5,6,7,8,9,0} s2 = {11,'t',0,9,5} print(s1) #输出{0,1,2,3,4,5,6,7,8,9}自动去重了一个0 s1.add(10) print(s1) #{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} s1.remove(10) print(s1) #{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} print(s1.pop()) #0 print(s1.difference(s2)) #{1, 2, 3, 4, 6, 7, 8} print(s1.union(s2)) #{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 't'} print(s1.intersection(s2)) #{9, 5} s1.clear() print(s1) #空集set()3、案例
根据提供的学生课程情况，完成以下要求：（1）同时选修了法语和艺术的学生（2）同时选修了所有四门课的学生（3）选修了足球但是没有选修篮球的学生（4）输出每个学生所选修课程的数量
football_set = {"王五","李四","张冠","李代","嘉豪","嘉欣","子涵","黑子"} Basketball_set = {"张三","王林","王俊凯","杨洋","嘉豪","嘉欣","子涵"} french_set = {"十三","水娘","大炮","王俊凯","杨洋","黑子"} art_set = {"杨洋","王俊凯","迪丽热巴","杨紫","张一山"} print(f"同时选修了法语和艺术的同学有：{french_set.intersection(art_set)}") print(f"同时选修了法语和艺术的同学有：{french_set & art_set}") print(f"同时选修了所有四门课的学生有：{football_set & Basketball_set & french_set & art_set}") print(f"选修了足球，但是没有选修篮球的学生有：{football_set.difference(Basketball_set)}") print(f"选修了足球，但是没有选修篮球的学生有：{football_set - Basketball_set}") fb = {s for s in football_set if s not in Basketball_set} print(f"选修了足球，但是没有选修篮球的学生有：{fb}") # student = football_set.union(Basketball_set).union(french_set).union(art_set)或 student = football_set | Basketball_set | french_set | art_set student_list = [*football_set,*Basketball_set,*french_set,*art_set] for s in student: print(f"{s}同学选修的课程数量是：{student_list.count(s)}")五、字典（dict）
1、介绍
存储的是键值对（key:value）类型的数据，可以根据key找到对应的数据，键（key）不可以重复，可以修改
定义：字典名称 = {key：value，key：value，.......}
空字典：字典名称 = {} 或 字典名称 = dict（）
根据key获取value：值 = 字典名称[key]
ps：字典中的value可以是任何类型的值，而key不可以是可变类型（如list，tuple，set，dict）
2、方法
| 方法 | 解释 | 实例 |
| 字典名称[key] = value | 往指定字典中添加/修改键值对 | dict1["嘉豪"] = 400 |
| 字典名称.pop(key) | 删除指定的key，并返回key对应的value | sorce = dict1.pop(”张三“) |
| del 字典名称[key] | 删除字典中指定的键值对 | del dict1["嘉豪"] |
字典名称[key] 或 字典名称.get(key) | 获取值 | dict1["嘉豪"] |
| 字典名称.keys() | 获取所有的key | dict1.keys() |
| 字典名称.values() | 获取所有的values | dict1.values() |
| 字典名称.items() | 获取所有的key - values键值对,每个对以元组形式存储 | dict1.items() |
#定义字典 dict1 = {"张三":605,"李四":700,"王五":497,1:20,2.5:30}#key除了数据容器，其他都可以 #查询值 print(dict1) #{'张三': 605, '李四': 700, '王五': 497, 1: 20, 2.5: 30} print(dict1.keys()) #查询所有的key dict_keys(['张三', '李四', '王五', 1, 2.5]) print(dict1.values()) #查询所有的value dict_values([605, 700, 497, 20, 30]) print(dict1.items()) #查询所有的键值对 dict_items([('张三', 605), ('李四', 700), ('王五', 497), (1, 20), (2.5, 30)]) print(dict1["张三"],dict1.get("张三")) #查询指定key所对应的值：605 605 #添加值/修改值 dict1["嘉豪"] = 400 dict1["张三"] = 800 print(f"张三的值为：”{dict1['张三']}，添加的值为{dict1['嘉豪']}") #张三的值为：”800，添加的值为400 #删除值 sorce1 = dict1.pop("张三") print(sorce1,dict1) #800 {'李四': 700, '王五': 497, 1: 20, 2.5: 30, '嘉豪': 400} del dict1["嘉豪"] print(dict1) #{'李四': 700, '王五': 497, 1: 20, 2.5: 30} #遍历 for k in dict1.keys(): print(f"{k}: {dict1[k]}") print("--------------------------") for i in dict1.items(): print(f"{i[0]}: {i[1]}")3、案例
开发一个购物车管理系统，实现商品信息的添加、修改、删除、查询功能。系统是由字典结果存储商品数据，通过控制台菜单与用户交互，具体功能如下：
1、添加购物车：用户更具提示录入商品名称、以及该商品的价格、数量，保存该商品信息到购物车
2、修改购物车：要求用户输入要修改的购物车商品名称，然后再提示输入该商品的价格、数量、输入完成后修改该商品的信息
3、删除购物车：要求用户输入要删除的购物车名称，根据名称删除购物车中的商品
4、查询购物车：将购物车中的商品信息展示出来，格式为：“商品名称：×××”，“商品价格：×××”，“商品数量：×××”、
5、退出购物车
#用字典包字典的方法 #eg:Shopping = {"洗发水"：{"数量":12,"价格":13.4}} #则Shopping的key就是洗发水，我们给它起个名字叫name #value就是一个新集合{"数量":12,"价格":13.4}，里面的主键只有数量和价格，就表示为num和pir #则Shopping["name"] == {"num": , "pir": } print("1、添加购物车\n2、修改购物车\n3、删除购物车\n4、查询购物车\n5、退出购物车") Shopping = {} while True : s = int(input("请输入要执行的操作：")) match s : #添加商品 case 1: name = input("请输入商品的名称：") pir = float(input(f"请输入{name}的单价：")) num = int(input(f"请输入{name}的数量：")) Shopping[name] = {"数量":num,"单价":pir} print(f"添加{name}成功\t数量：{num}\t单价：{pir}",) #修改商品 case 2: name_1 = input("请输入要修改的商品名称：") if name_1 not in Shopping: print("你输入的商品不存在") else: pir_1 = float(input(f"请输入{name_1}的新单格：")) num_1 = int(input(f"请输入{name_1}的新数量：")) Shopping[name_1] = {"数量": num_1,"单价":pir_1} #删除商品 case 3: num_3 = input("请输入要删除的商品名称：") if num_3 not in Shopping: print("你输入的商品不存在") else: del Shopping[num_3] print("商品成功删除") #查询商品 case 4: if Shopping: for i in Shopping.keys(): j = Shopping[i] #把内嵌字典用j表示 print(f"商品名：{i} \t商品单价：{j['单价']}\t商品数量：{j['数量']}") else: print("没有商品") #退出购物 case 5: print("退出购物车") break case _: print("非法操作，不支持")