1.列表小练兵
"""已知列表list1 = ['a','b','c'],使用系统功能完成下面操作a.在列表的末尾追加一个元素'd'b.在下标为1的位置插入一个元素'e'c.统计元素'a'出现的次数d.将列表元素反转e.将列表降序排序f.获取列表长度"""list1 = ['a','b','c']# a.list1.append("d") # append--->abc ---->["abc"]list1.extend("d") # extend---->abc---->['a','b','c']# blist1.insert(1,'e')# c# 法一list1.count('a')# 法二count = 0for ele in list1:if ele == 'a':count += 1# d：反转# 法一list1.reverse()# 法二list2 = list1[::-1]# 法三list3 = []i = len(list1) - 1while i >= 0:list3.append(list1[i])i -= 1# elist1.sort(reverse=True)# fl = len(list1)n = 0for _ in list1:n += 1# 1.将属于列表list1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]，# 但不属于列表list2 = ["Sun","Mon","Thu","Fri","Sat"]的所有元素定义为一个新列表list3list1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]list2 = ["Sun","Mon","Thu","Fri","Sat"]list3 = []for ele in list1:if ele not in list2:list3.append(ele)# 2.已知一个列表中保存的是学生的姓名，要求去掉重复的名字，# 例如：names = ['张三', '李四', '大黄', '张三'] -> names = ['张三', '李四', '大黄']# 法一：删除所有指定重复的元素names = ['张三', '李四', '大黄', '张三','张三','张三','张三','张三']for name in names[:]:if name == "张三":names.remove("张三")print(names) # ['李四', '大黄']#【注意】for name in names：直接这么写有问题，删除不干净#，因为他删除之后列表变短了，遍历的还是原来的列表，所以可能会问#题。但是for name in names[:]:之后就就会将指定的元素删除干净，#因为切片生成新的列表，遍历就是新的生成的列表，在遍历的话就是#遍历新的列表，源列表不受影响，所以会将指定的元素删除干净的# 法二names = ['张三', '李四', '大黄', '张三','张三','张三','张三','张三']name = "张三"count = names.count(name)for _ in range(count - 1):names.remove(name)print(names) # ['李四', '大黄', '张三']#法三：append# 思路：定义一个新的列表，遍历原列表，判断每个元素在新列表中是否存在，如果不存在，则添加，如果存在，则不操作new_names = []names = ['张三', '李四', '大黄', '张三','张三','张三','张三','张三']for name in names:if name not in new_names:new_names.append(name)print(new_names) # ['张三', '李四', '大黄']
2.深浅拷贝
"""copy.copy()表示浅拷贝，最外层的列表会被拷贝一个新的地址，但是内层列表的地址保持不变，所以当实现copy之后，两个列表的地址不相同，对于一维列表，一个列表的元素发生改变，另一个列表不会发生改变，对于二维列表，一个列表的内部元素发生改变，则另一个列表会随着改变copy.deepcopy()表示深拷贝，里外层的列表的地址都会被拷贝一个新的，所以当实现deepcopy之后，两个列表的地址不相同，对于任意列表，一个列表的内部元素发生改变，则另一个列表不会改变深浅拷贝（就是在计算机中看是占了一个地址还是占了两个地址的问题）变量在内存中的地址问题（也就是说的是变量的可变性与不可便行，可变数据类型与不可变类型的）【problem】可变数据和不可变数据的区别不可变的数据类型：int,float,bool,str,tuple,通过变量赋值的方式操作，一个变量的值发生改变，另一个变量不受影响可变的数据类型：list,dict,set,通过变量赋值的方式操作,一个变量内部的值发生改变，另一个变量会随着改变"""# 1不可变的演示示例：a = 10b = aprint(a is b)#Trueprint(id(a) == id(b)) # id获取一个变量在内存中的地址a = 20print(a is b)#falseprint(id(a) == id(b))#false因为b的不受a的改变而改变# 2可变类型的演示示例a = [10,20]b = aprint(a is b))#Trueprint(id(a) == id(b))#Truea[1] = 100print(a is b)#Trueprint(id(a) == id(b)))#True
3.列表推导式
列表推导式，就是指的轻量级循环创建列表，简单来说，使用一行代码实现简单的逻辑，创建一个新的列表
# 列表推导式/列表生成式# 语法：[新列表的元素的规律 for循环 if判断]，if判断可以省略# 执行顺序：for循环---》if语句----》新列表的元素的规律# 1.需求：生成一个列表[2,4,6,8,10]# 法一list11 = list(range(2,11,2))print(list11)# 法二list12 = []for i in range(1,6):list12.append(i * 2)print(list12)# 法三#列表的推导式工作原理：上面的工作list13 = [i * 2 for i in range(1,6)]print(list13)# 2.需求:生成一个列表[1,4,9,16,25]# 方式一list21 = []for i in range(1,6):list21.append(i ** 2)print(list21)# 法二list22 = [i ** 2 for i in range(1,6)]#省略了if语句print(list22)# 3.需求：生成一个列表[2,4,6,8,10]# 法一list31 = []for i in range(1,11):if i % 2 == 0:list31.append(i)print(list31)# 法二【列表推导式】list32 = [i for i in range(1,11) if i % 2 == 0]print(list32)# 练习：生成一个列表，其中的元素是1~50之间6的倍数list33 = [num for num in range(1,51) if num % 6 == 0]# 4.需求：已知两个字符串"xyz"和"123",生成一个列表，其中的元素x1,x2,x3,y1,y2,y3....# 书写多个for# 法一list41 = []for m in "xyz":for n in "123":list41.append(m + n)print(list41)# 法二list42 = [m + n for m in "xyz" for n in "123"]print(list42)# 5.需求：生成一个列表，其中的元素是1~100之间既能被3整除也能被6整除的数# 法一list51 = []for n in range(1,101):if n % 3 == 0 and n % 6 == 0:list51.append(n)print(list51)list51 = [n for n in range(1,101) if n % 3 == 0 and n % 6 == 0]print(list51)# 法二list51 = []for n in range(1,101):if n % 3 == 0:if n % 6 == 0:list51.append(n)print(list51)list51 = [n for n in range(1,101) if n % 3 == 0 if n % 6 == 0]print(list51)"""注意：在列表推导式中，for循环和if语句都可以根据具体的需求书写多个，但是，多个for或者多个if之间的关系从左往右是嵌套的关系"""# 6.已知列表["abc",34,65,6,"hello",35,"fff"]，将其中的数字挑出来，生成一个新的列表list1 = ["abc",34,65,6,"hello",35,"fff"]list61 = [ele for ele in list1 if type(ele) == int] # print(type(type(10))) # <class 'type'>print(list61)list62 = [ele for ele in list1 if isinstance(ele,int)]print(list62)# 7.生成一个列表，其中的元素为1-2,2-3,3-4,4-5list71 = [str(i) + "-" + str(i + 1) for i in range(1,5)]print(list71)# 8.已知如下列表，将其中的大写字母转成小写，将小写字母转成大写，生成一个新的列表list8 = ['a',"B","C","H",'n','m',"45"]# 法一：chr()和ord()list81 = []for ch in list8:if ch >= "a" and ch <= "z":list81.append(chr(ord(ch) - 32))elif ch >= "A" and ch <= "Z":list81.append(chr(ord(ch) + 32))print(list81)list81 = []for ch in list8:if "a" <= ch <= "z":list81.append(chr(ord(ch) - 32))elif "A" <= ch <= "Z":list81.append(chr(ord(ch) + 32))print(list81)# 法二：upper()和lower(),isupper()和islower()# 字符串.upper():小写转大写# 字符串.lower()：大写转小写list82 = []for ch in list8:if ch.islower():list82.append(ch.upper())elif ch.isupper():list82.append(ch.lower())print(list82)"""列表推导式：a.列表推导式，字典推导式以及三目运算符这些使用一行代码实现逻辑的操作并不是所有的场景都适用b.只适用于简单的逻辑c.如果逻辑复杂，则代码可读性会降低，代码的可维护性会降低"""
4.算法
4.1排序算法
#求最值# 1.自定义一个数字列表，求出其中的最大值numlist = [34,6,5,6,100,55,89,16]# 假设法：假设第0个元素为最大值max_value = numlist[0]for num in numlist:if num > max_value:max_value = numprint(max_value)# 2.自定义一个数字列表，求出其中的最大值以及索引numlist = [34,6,5,6,100,55,89,16]max_value = numlist[0]for i in range(1,len(numlist)):if numlist[i] > max_value:max_value = numlist[i]print(max_value)# 3.自定义一个数字列表，求出其中的第二大值以及索引#【personal think：就是电磁数据更新而已，将每次的最大值用一个变量接受出来，记录他之前的数据就行了# 法一：删除最大值，再找一次最大值[这样会改变源列表，所以要先备份一个]numlist = [34,6,5,6,100,55,100,89,100,16]# 备份new_list = numlist.copy()#备份，因为上面的是一维列表，所以可以这样写#寻找最大值max_value = numlist[0]for num in numlist:if num > max_value:max_value = numprint(max_value)# 统计最大值的个数，然后删除max_count = numlist.count(max_value)for _ in range(max_count):numlist.remove(max_value)print(numlist)#此时里面的100就被删除干净了# 寻找第二大值second_value = numlist[0]for num in numlist:if num > second_value:second_value = num# 在备份中寻找第二大值的下标【因为此时源列表已经被改变了，所以只能在备份中找】for i in range(len(new_list)):if new_list[i] == second_value:print(second_value,i)# 法二：排序numlist = [34,6,5,6,100,55,100,89,100,16]# 备份new_list = numlist.copy()# 排序【排序之后源列表会被改变，所以要进行源列表的备份】numlist.sort() # 冒泡排序和选择排序print(numlist)# 寻找最大值max_value = numlist[-1]# 寻找第二大值second_value = numlist[-(numlist.count(max_value) + 1)]# 寻找第二大值的下标for i in range(len(new_list)):if new_list[i] == second_value:print(second_value,i)"""#冒泡排序排序思路：比较两个相邻的下标对应的元素，如果符合条件就交换位置（最值出现在最后位）【自己添加: 核心：两个相邻的下标】使用嵌套循环：for循环外层循环控制比较的轮数，内层循环控制循每一轮参与比较的下标外层循环范围：0--len-2 range(len-1)#因为第len-1个索引娶不到内层循环：0--len()-2-i range(0,len-1-i)"""# 冒泡排序：以升序为例list1 = [34,100,45,28,6,499,47,5]# 外层循环：控制比较的轮数 【 range(len(list1) - 1) #0 到 n-2】for i in range(len(list1) - 1):#(次数确定的循环最好是用for循环)# 内层循环：控制每一轮比较的次数并且兼顾参与比较的下标for j in range(len(list1) - 1 - i):# 比较两个相邻元素的大小，如果符合条件则交换位置# 小的下标对应的元素 > 大的下标对应的元素if list1[j] > list1[j + 1]:list1[j],list1[j + 1] = list1[j + 1],list1[j]print(list1)"""【插入排序】：#思路：以升序为例：1.新列表中没有元素就直接添加2.先判断当前数值与新列表中的最后一个元素以及第一个元素的大小小于第一个元素直接插入到最前面大于最后一个元素直接插入到最后面3.遍历：从前往后比较：前一个《= 当前 《= 后一个"""numlist = [1,4,5,34,6,5,6,100,55,8,200,1]numlist1 = []while len(numlist):num = numlist.pop(-1)#新列表中没有元素时候添加元素if not len(numlist1):numlist1.append(num)# print("111111*"*30)# print(numlist1)elif num >= numlist1[-1]:numlist1.append(num)# print("2222222***"* 30)# print(numlist1)elif num <= numlist1[0]:numlist1.insert(0,num)# print("33333***" * 30)# print(numlist1)else:#此时numlist1中最少有两个元素for i in range(len(numlist1)-1):if numlist1[i] <= num <=numlist1[i+1]:numlist1.insert(i+1,num)# print("4444***" * 30)# print(numlist1)breakprint(numlist1)#运行结果#[1, 1, 4, 5, 5, 6, 6, 8, 34, 55, 100, 200]"""排序思路：固定一个下标，然后拿这个下标对应的值依次和后面的元素进行比较，最值出现在头角标位置上"""# 选择排序：以升序为例list1 = [34,100,45,28,6,499,47,5]# 外层循环：控制比较的轮数for i in range(len(list1) - 1):# 内层循环：控制每一轮比较的次数和兼顾参与比较的下标for j in range(i + 1,len(list1)):# 比较两个相邻元素的大小，如果符合条件则交换位置# 小的下标对应的元素 > 大的下标对应的元素if list1[i] > list1[j]:list1[i],list1[j] = list1[j],list1[i]print(list1)
5.查找
numlist = [34,6,5,6,100,55,100,89,100,16]# 1.顺序查找key = 100for i in range(len(numlist)):if key == numlist[i]:print("%d元素的下标为：%d" % (key,i))# 2.模拟列表的index功能# index:第一次查找到的元素的下标print(numlist.index(100))key = 100for i in range(len(numlist)):if key == numlist[i]:print("%d元素的下标为：%d" % (key,i))break"""#二分法查找局限性：你的列表必须是有序的，升序或者降序查找思路：升序的前提下，将待查找的元素与中间下标对应的元素比较，如果待查找元素大于中间下标对应的元素，则去右半部分查找注意：前提是列表是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率"""# 二分法查找：列表是排好序的【前提条件】# 以升序为例list1 = [34,100,45,28,6,100,100,499,47,5]#排序for i in range(len(list1) - 1):# 内层循环：控制每一轮比较的次数和参与比较的下标for j in range(len(list1) - 1 - i):# 比较两个相邻元素的大小，如果符合条件则交换位置# 小的下标对应的元素 > 大的下标对应的元素if list1[j] > list1[j + 1]:list1[j],list1[j + 1] = list1[j + 1],list1[j]print(list1)# 带查找元素key = 66# 定义两个变量，分别表示下标的最大值和最小值left = 0right = len(list1) - 1while left <= right:# 定义一个变量，表示中间的下标middle = (left + right) // 2# 比较if key > list1[middle]:# 在升序的前提下，如果带查找元素 > 中间下标对应的元素，则需要给left重新赋值left = middle + 1elif key < list1[middle]:# 给right重新赋值right = middle - 1else:print("待查找元素%d的下标为：%d" % (key, middle))#下标是在排序之后的索引，而不是在源列表中的索引# 如果循环还未结束，但是查找结束，则可以提前结束循环breakelse:# 如果while分支中的break有机会执行，如果待查找元素存在，则else分支将没有执行的机会# 如果while分支中的break没有机会执行，则else会被执行print("待查找元素%d在列表中不存在" % (key))
6.元组
列表的本质：列表是一种有序的，可变的，可以存储重复元素的集合
元组的本质：元组是一种有序的，不可变的，可以存储重复元素的集合
元组和列表的不同之处：
a.列表:[] 元组：()
b.列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】
创建列表:
创建空列表：list1 = []创建有元素的列表：list1 = [元素1，元素2，......]
创建元组
创建空元组：tuple1 = ()创建有的元组：tuple1 = (元素1，元素2，.......)
# 1.二者的定义# 元组：tuple 列表：list# 注意：命名的时候尽量不要使用tuple和list直接命名list1 = [3,5,6]tuple1 = (3,5,6)print(type(list1),type(tuple1))# 注意1：二者中都可以存储不同类型的数据l1 = ["aaa",True,10]t1 = ("aaa",True,10)print(l1,t1)# 注意2：二者中都可以存储重复元素l2 = [4,4,4,4,6]t2 = (4,4,4,4,6)print(l2,t2)# 注意3：当二者中只有一个元素的时候,当元组中只有一个元素的时候，一定要添加逗号l3 = [10]t2 = (9)#9 会当成普通的数据类型t3 = (10,)print(l3,t3)# 2.可变和不可变# a.获取l1 = ["aaa",True,10]t1 = ("aaa",True,10)print(l1[1],t1[1])# b.修改l1[1] = 100print(l1)# t1[1] = 100 #TypeError: 'tuple' object does not support item项目 assignment赋值# 3.删除l1 = ["aaa",True,10]t1 = ("aaa",True,10)# del l1# del t1#支持del l1[1]# del t1[1] #TypeError: 'tuple' object doesn't support item deletion#若非要修改元组中的元素，那么就给他转化成列表，之后修改了再给他转化回去就行# 4.列表和元组的相互转化# a.list(元组)：将元组转换为列表t1 = ("aaa",True,10)print(type(t1))l1 = list(t1)print(type(l1))# b.tuple(列表)：将列表转换为元组l1 = ["aaa",True,10]print(type(l1))t1 = tuple(l1)print(type(t1))#####################元组操作# 1.+ * in/not int1 = (1,2,3)t2 = (4,5,6)print(t1 + t2)print(t1 * 4)print(2 in t1)print(10 not in t1)#都是生成了新的元组，而不是修改的员来的元组 # 2.切片# 和列表的用法完全相同，只不过得到的结果为元组# 3.系统功能print(len(t1))print(max(t1))print(min(t1))print(t1.count(2))#print(t1.cp)#没有这个功能，因为它不能改变，所以不要给他备份# 4.遍历tuple1 = (34,4,6,56,5)n = 0while n < len(tuple1):print(tuple1[n])n += 1for num in tuple1:print(num)for i in range(len(tuple1)):print(i,tuple1[i])for i,ele in enumerate(tuple1):print(i,ele)# 5.【problem】问题:虽然元组是不可变的，但是如果元组中的元素为列表，该列表仍然是可变的t1 = (4,5,6,[11,22])print(t1)t1[-1][1] = 100#//可运行成功，因为他修改的是列表，而不是元组print(t1)"""【problem】：元组的意义：涉及到进程和线程，多进程多线程中有的不希望被改掉，那么就可以用元组【problem】元组和列表的区别和联系相同点：a.二者都是有序的b.二者都可以存储不同类型的元素c.二者都可以存储重复元素d.二者的遍历方式完全相同不同点：a.表示方式,元组:()，列表:[]b.可变性：元组是不可变的，列表是可变的c.使用场景：在多线程的使用场景中，为了避免多线程访问同一个数据造成数据的混乱，则可以使用元组，如果涉及元素的增加或者删除，则可以使用列表d.元组在创建时间上和占用的空间上优于列表{注意：列表的底层维护了一栈，计算机底层快速的复制了一个然后进行增加等操作，操作一次复制一次，因为元组不可变，所以，元组不需要复制}"""
7.字典
列表和元组的使用缺点：当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦
解决方案：既能存储多个数据，还能在访问元素的很方便的定位到需要的元素，采用字典
字典的本质：字典是一种无序的，可变的，存储键值对的集合
习惯使用场景：
列表更适合保存相似数据，比如多个商品、多个姓名、多个时间
字典更适合保存不同数据，比如一个商品的不同信息、一个人的不同信息
"""#语法语法：{键1:值1, 键2:值2, 键3:值3, ..., 键n:值n}说明：- 字典和列表类似，都可以用来存储多个数据- 在列表中查找某个元素时，是根据下标进行的；字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）- 字典中的每个元素都由2部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值- 键可以使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表，字典（字典数据类型本身也是可变的）等可变数据类型- 每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value"""# 1.定义一个空字典dict1 = {}print(type(dict1))# 2.key的注意事项# 注意1：key是唯一的dict2 = {"zhangsan":99,"lisi":100,"zhangsan":66}#结果只有一个"zhangsan ":66,另一个"zhangsan ":99,不在了，后面的吧前面的覆盖了print(dict2)# 注意2：key必须是不可变的数据类型# dict3 = {[1,2,3]:10} # TypeError: unhashable type: 'list' 哈希#[1,2,3]要是哈西的才能放在这里# 3.dict也是可变的数据类型# dict是无序的,OrderedDict可以生成一个有序字典dict3 = {"zhangsan":99,"lisi":100,"tom":55,"bob":19}print(dict3)#{"zhangsan":99,"lisi":100,"tom":55,"bob":19}顺序与原来的一致，主要因为解释器在起作用，但是确实是无序的# a.获取字典中的键值，语法：字典名[key]print(dict3["lisi"])# b.修改指定key对应的valuedict3["lisi"] = 45print(dict3)# cdict3["rose"] = 77print(dict3)# 注意：字典[key] = value，如果key存在，则表示修改，如果key不存在，则表示添加键值对# 4.【importance】创建字典的方式# 法一dict1 = {"aa":10,"bb":20}print(dict1)# 法二dict2 = {}dict2["aa"] = 10dict2["cc"] = 30print(dict2)# 法三# dict(key=value....)dict3 = dict(name='hello',age=10)print(dict3)# 法四# dict([(key1,value1),(key2,value2),(key3,value3).....])dict4 = dict([("a",11),('b',22),('c',33)])print(dict4)# 法五# dict(zip([所有的key],[所有的value]))#zip此处表示映射dict5 = dict(zip([11,22],['a','b','c']))print(dict5)#两个参考的是少数的的哪个#法六#给了一个列表将列表变成了字典dict1 = dict.fromkeys([11,22])print(dict1) #{11: None, 22: None}dict1 = dict.fromkeys((11,22))print(dict1)#########遍历字典dict1 = {"zhangsan":99,"lisi":100,"tom":55,"bob":19}# 获取所有的键print(dict1.keys())# 获取所有的值print(dict1.values())# 获取所有的键值print(dict1.items())#字典可以理解成两个列表# 法一for key in dict1:print(key,dict1[key])# 法二for key in dict1.keys():print(key,dict1[key])# 法三for value in dict1.values():print(value)# 法四for key,value in dict1.items():print(key,value)
8.大练兵
"""生成50-300之间可重复的10个数据存放于列表中, 对列表进行排重,并对列表使用冒泡排序进行降序排序例如：随机生成了[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]去重之后 [70, 88, 91, 107, 234, 177, 282, 197]降序排序 [282, 234, 197, 177, 107, 91, 88, 70]"""#法一import randomnums = []for _ in range(10):nums.append(random.choice(range(50,301)))print(nums)for i in range(len(nums)-1):count = nums.count(nums[i])if count >= 2:nums.remove(nums[i])print(nums)for m in range(len(nums)):for n in range(len(nums)-1-m):if nums[n] < nums[n+1]:nums[n],nums[n+1] = nums[n+1],nums[n]print(nums)#法二#生成50-300之间可重复的10个数据存放于列表中, 对列表进行排重,并对列表使用冒泡排序进行降序排序import randomlist1 = [random.randrange(50,300) for i in range(0,10) ]for num in list1:while list1.count(num) > 1:list1.remove(num)print(list1)for i in range(len(list1)-1):for j in range(len(list1)-1-i):if list1[j] < list1[j+1]:list1[j],list1[j+1] = list1[j+1],list1[j]print(list1)"""[运行结果][288, 207, 246, 87, 221, 50, 236, 242, 273, 79][288, 273, 246, 242, 236, 221, 207, 87, 79, 50]"""#法三import randomnum_list = []for _ in range(10):num_list.append(random.choice(50,301))# 排重list1 = []for num in num_list:if num not in list1:list1.append(num)# 排序for i in range(len(list1) - 1):for j in range(len(list1) - 1 - i):if list1[j] < list1[j + 1]:list1[j],list1[j + 1] = list1[j + 1],list1[j]"""2.自定义一个数字列表，获取这个列表中的最小值，并将列表转化为元组，要求：不能使用min()"""#法一list2 = [12,31,42,52,14,63,52,88]list2.sort()min_value = list2[0]tuple2 = tuple(list2)print(min_value)print(tuple2)#法二num_list = [34,6,546,5,100,16,77,56,88,10]min_value = num_list[0]for i in range(1,len(num_list)):if num_list[i] < min_value:min_value = num_list[i]num_tuple = tuple(num_list)"""3.自定义一个数字列表，元素为10个,找出列表中最大数连同下标一起输出"""#法一num_list = [34,6,546,5,100,16,77,56,88,10]max_value = num_list[0]max_index = 0for i in range(1,len(num_list)):if num_list[i] > max_value:max_value = num_list[i]max_index = iprint("最大值%d在列表中的位置为：%d" % (max_value,max_index))#法二list3 = [14,52,25,82,14,52,15,77,32,71]max_value = list3[0]for i in range(len(list3)):if max_value < list3[i]:max_value = list3[i]for j in range(len(list3)):if max_value == list3[j]:num = jprint('列表中最大数%s,%s'%(max_value,num))#法三list3 = [131, 262, 83, 271, 228, 243, 170, 200, 188, 178]MaxNum = max(list3)print(MaxNum)index = list3.index(MaxNum)print(index)"""运行结果： 271 3""""""4.利用列表推导式, 完成以下需求"""#a. 生成一个存放1-100之间个位数为3的数据列表#结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]#法一list1 = [i for i in range(100+1) if i%100%10 == 3]print(list1)#法二list1 = [i for i in range(1, 101)if i % 10 == 3]#b. 利用列表推导式将已知列表中的整数提取出来#例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]#法一list1 = [True, 17, "hello", "bye", 98, 34, 21]list2 = [i for i in list1 if isinstance(i, int) and not isinstance(i,bool)]#法二list42 = [True, 17, "hello", "bye", 98, 34, 21]list421 = [num for num in list2 if type(num) == int]print(list421)#c.利用列表推导式存放指定列表中字符串的长度#例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]#法一list43 = ["good", "nice", "see you", "bye"]list431 = [len(i) for i in list43 ]print(list431)#法二list2 = ["good", "nice", "see you", "bye"]list22=[len(list2[i])for i in range(len(list2)) ]print(list22)#法三list1 = ["good", "nice", "see you", "bye"]list2 = [len(i) for i in list1]
"""1.自定义一个数字列表，求列表中第二大数的下标"""#法一list1 = [14,52,25,82,14,52,15,77,32,71]for i in range(len(list1)):for j in range(i,len(list1)):if list1[i] < list1[j]:list1[i],list1[j] = list1[j],list1[i]max_count = list1.count(list1[0])for m in range(len(list1)):if m > max_count:print('列表中第二大数%s的下标:%s'%(list1[m],m))break#法二list1 = [14,52,25,82,14,52,15,77,32,71]tuple1 = tuple(list1)list1.sort(reverse=False)print(tuple1.index(list1[-2]))#法三num_list = [34,6,546,5,100,546,546,16,77]# 备份new_list = num_list.copy()# 升序排序for i in range(len(new_list) - 1):for j in range(len(new_list) - 1 - i):if new_list[j] > new_list[j + 1]:new_list[j],new_list[j + 1] = new_list[j + 1],new_list[j]print(new_list)# 获取最大值max_value = new_list[-1]# 统计最大值的个数max_count = new_list.count(max_value)# 获取第二大值second_value = new_list[-(max_count + 1)]# 查找在列表中的位置:顺序查找for i in range(len(num_list)):if second_value == num_list[i]:print("第二大值%d在列表中的下标为:%d" % (second_value,i))"""2.已知列表list = [34,55,67,88,99,100],使用二分法查找67在列表中的位置"""#法一list2 = [34,55,67,88,99,100]key = 67left = 0right = len(list2)-1while left <= right:middle = (left + right) // 2if key < list2[middle]:right += 1elif key > list2[middle]:right += 1else:print('%s在列表中的位置:%s'%(key,middle))break#法二list1 = [34,55,67,88,99,100]list1.sort()# 待查找元素key = 67# 定义变量，表示索引的最大值和最小值left = 0right = len(list1) - 1while left <= right:# 计算中间下标middle = (left + right) // 2# 比较if list1[middle] < key:left = middle + 1elif list1[middle] > key:right = middle - 1else:print("%d索引为：%d" % (key,middle))breakelse:print("%d在列表中不存在" % (key))"""3.自定义一个列表，最大的与第一个元素交换，最小的与最后一个元素交换，输出交换之后的列表"""#法一list3 = [14,52,25,82,57,52,6,77,32,71]list31 = list3.copy()list31.sort()max_value = list31[-1]min_value = list31[0]for i in range(len(list3)):if max_value == list3[i]:breakfor j in range(len(list3)):if min_value == list3[j]:breaklist3[0],list3[i] = list3[i],list3[0]list3[-1],list3[j] = list3[j],list3[-1]print(list3)#法二list_num = [1332, 45, 43243, 4346, 34234, 656, 323, 99999]maxi = list_num[0]minn = list_num[0]# maxi_index = 0for i in range(1, len(list_num)):if list_num[i] > maxi:maxi = list_num[i]# maxi_index = ifor i in range(1, len(list_num)):if list_num[i] < minn:minn = list_num[i]list_num[0], maxi = maxi, list_num[0]list_num[-1], minn = minn, list_num[-1]print(list_num)"""4.从控制台输入一段文本， 统计每个字符出现的次数"""#法一text = input('输入一段文本')list41 = []list41.extend(text)list42 = []for i in range(len(list41)):count = list41.count(list41[i])list42.append(count)print(list41)print(list42)dict1 = dict(zip(list41,list42))print(dict1)#法二eng = input("输入一个英文句子：")dict = {}for i in eng:if i not in dict:dict[i] = 1else:dict[i] += 1print(dict)
"""1.dict_list = [{“科目”:“政治”, “成绩”:98}, {“科目”:“语文”, “成绩”:77}, {“科目”:“数学”, “成绩”:99}, {“科目”:“历史”, “成绩”:65}]按照字典中的成绩对列表进行降序排序 【使用排序算法】结果为： [{“科目”:“数学”, “成绩”:99}, {“科目”:“政治”, “成绩”:98}, {“科目”:“语文”, “成绩”:77}, {“科目”:“历史”, “成绩”:65}]"""#法一dict_list = [{'科目':'政治', '成绩':98}, {'科目':'语文', '成绩':77}, {'科目':'数学', '成绩':99}, {'科目':'历史', '成绩':65}]for i in range(len(dict_list)):for j in range(i,len(dict_list)):if dict_list[i]['成绩'] < dict_list[j]['成绩']:dict_list[i],dict_list[j]=dict_list[j],dict_list[i]print(dict_list)#法二#按照字典中的成绩对列表进行降序排序dict_list = [{'科目':'政治', '成绩':98},{'科目':'语文', '成绩':77},{'科目':'数学', '成绩':99},{'科目':'历史', '成绩':65}]newDictList = sorted(dict_list,key=lambda x:x["成绩"],reverse=True)print(newDictList)#运行结果：[{'科目': '数学', '成绩': 99}, {'科目': '政治', '成绩': 98}, {'科目': '语文', '成绩': 77}, {'科目': '历史', '成绩': 65}]"""newDictList = sorted(dict_list,key=lambda x:x["成绩"],reverse=True)在匿名函数当中我们接收的x是kids当中的元素，也就是一个dict，所以我们想要指定我们希望的字段，需要用dict访问元素的方法，也就是用中括号来查找对应字段的值。学习自定义排序：链接：/weixin_39949506/article/details/110701950?utm_term=python%E8%87%AA%E5%AE%9A%E4%B9%89%E6%8E%92%E5%BA%8F%E8%A7%84%E5%88%99&utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduweb~default-2-110701950&spm=3001.4430"""#法三dict_list = [{'科目':'政治', '成绩':98},{'科目':'语文', '成绩':77},{'科目':'数学', '成绩':99},{'科目':'历史', '成绩':65}]# 比较的条件：成绩# 交换：字典for i in range(len(dict_list) - 1):for j in range(len(dict_list) - 1 - i):if dict_list[j]["成绩"] < dict_list[j + 1]["成绩"]:dict_list[j],dict_list[j + 1] = dict_list[j + 1],dict_list[j]print(dict_list)"""2.dict_list = [{“科目”:“政治”, “成绩”:98}, {“科目”:“语文”, “成绩”:77}, {“科目”:“数学”, “成绩”:99}, {“科目”:“历史”, “成绩”:65}]去除列表中成绩小于70的字典 【列表推导式完成】"""#法一dict_list = [{'科目':'政治', '成绩':98},{'科目':'语文', '成绩':77},{'科目':'数学', '成绩':99},{'科目':'历史', '成绩':65}]newlist = [subdict for subdict in dict_list if subdict["成绩"] >= 70]print(newlist)
