Python基础刷题，期末不挂科~~~（持续更新中）一2.解题思路循环遍历从1—n，累加变量初始值赋0，用一个变量控制

2.解题思路循环遍历从1—n，累加变量初始值赋0，用一个变量控制-1的变换即可。

n=eval(input()) t=1 s=0 for i in range(1,n+1): s=s+ti**i t=-1 print(s) 1 2 3 4 5 6 7 三十一、数列求和【part two】 1.题意

2.解题思路方法一：循环遍历从1—n，用t控制正负号系数，i是底数，此时指数需要单独用k控制

n=eval(input()) s=0 t=1 k=1 for i in range(1,n+1): if k>10: k=1 s+=i**kt t=-1 k+=1 print(s) 1 2 3 4 5 6 7 8 9 10 11 方法二：这个是同学想出来的思路依然是循环遍历从1—n，用t控制正负号系数，i是底数，不过此时指数的控制换了思想，用每一个i的最后一位当作指数，特判一下当i的最后一位为0时，指数为10

n=eval(input()) t=1 s=0 for i in range(1,n+1): a=i%10 if a==0: a=10

s+=i**(a)*t
t=-t

print(s)

1 2 3 4 5 6 7 8 9 10 11 12 13 三十二、列表元素绝对值排列 1.题意

2.解题思路在列表中将元素存储为整数，调用列表的sort()方法。注意： ①如何将元素存储为整型？两种方法。map映射或者是列表推导式 ②如何实现列表绝对值排序？两种方法。自己编写绝对值函数调用，或者直接调用绝对值关键字

def dx(x): return abs(x)

a = input().split(" ") s1 = [int(a[i]) for i in range(len(a))] s1.sort(key=dx) print(s1)

1 2 3 4 5 6 7 8 9 10 更加简单的方法，在abs就是绝对值得关键字，直接在sort中直接key=abs即可。

s=list(map(int,input().split())) s.sort(key=abs) print(s) 1 2 3 三十三、删除字符串中连续的重复字符 1.题意

2.解题思路判断字符串中前一个字符和后一个字符是否相等即可，如果不相等，就把前一个输出(或者把后一个输出)，再注意一下边界就OK

s=input() for i in range(len(s)-1): if s[i+1]!=s[i]: print(s[i],end="") print(s[len(s)-1])

1 2 3 4 5 6 s = input() print(s[0],sep="",end="") for i in range(1,len(s)): if s[i]==s[i-1]: continue else: print(s[i],sep="",end="")

1 2 3 4 5 6 7 8 三十五、列表合并去重 1.题意

2.解题思路排序和去重的实现方式，这里有一个简单方法便是set集合，可以自动实现排序+去重。注意以下几个知识点： 1.set的用法 ①得到是一个集合{}，要想得到列表还要转化 ②set是集合，创建集合set()。 ③向集合中添加元素s.add(x)。如果元素x不在集合中，将x增加到s，如果已存在，则不会有任何操作 2.input.split()和input.split(" ")的区别： split()和split(’ ')是有区别的，split（）是将多个空格当成一个空格；但用split(’ ')的时候，多个空格也要分割，所以可能会分割出来空。 3.map映射函数的用法： map(映射函数，序列…)，即根据指定映射函数对多个参数序列进行运算 ①map()函数是将指定的序列中所有元素作为参数，通过指定函数，将结果构成一个新的序列返回。 ②序列个数由映射函数的参数个数决定 ③map()函数的返回值是迭代对象map

a=list(map(int,input().split())) b=list(map(int,input().split())) a.extend(b) a=list(set(a)) print(a)

1 2 3 4 5 6 a = input().split(" ") b = input().split(" ") s1 = [int(i) for i in a] s2 = [int(i) for i in b] s1.extend(s2)

s1 = list(set(s1)) print(s1) 1 2 3 4 5 6 7 8 三十七、乘积的列表 1.题意

2.解题思路方法一：变乘为除，注意为零时情况第一次做这道题的思路的时候，自己聪明的想出一个绝对无敌的方法，就是变乘为除，先把所有数都乘一遍，然后除去当前这个数便是当前数的结果，结果提交一直报WA，哦，原来是还可能出现0这种数，0乘任何数都是0了，而且分母也不能为0。所以这种方法还是麻烦

a = input().split(" ") s1 = [] for i in range(len(a)): s1.append(int(a[i]))

cnt = s1.count(0) if cnt==1: for i in range(len(s1)): if s1[i] == 0: t = d1 else: t = int(d2/s1[i]) s2.append(t) elif cnt>1: t = 0 for i in range(len(s1)): s2.append(t) elif cnt==0: for i in range(len(s1)): t = int(d1/s1[i]) s2.append(t)

print(s2) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 方法二：两重循环枚举两重循环枚举，外循环控制枚举到哪个数了，内循环枚举除当前数外其余数相乘，将结果添加到一个新列表即可。注意：除去当前数的判断条件该如何表示

错误代码：

a=list(map(int,input().split())) b=[] for i in range(len(a)): ans=1 for j in range(len(a)): if a[j]==a[i]: pass else: ans=ans*a[j] b.append(ans) print(b) 1 2 3 4 5 6 7 8 9 10 11 正确代码：

a=list(map(int,input().split())) b=[] for i in range(len(a)): ans=1 for j in range(len(a)): if j==i: pass else: ans=ans*a[j] b.append(ans) print(b) 1 2 3 4 5 6 7 8 9 10 11 三十八、0的组合 1.题意

2.解题思路 ①以列表形式输入 ②对列表中元素进行排序，目的是使情况相同的序列顺序也保持一致，方便对序列进行去重 ③三重循环从头到尾枚举三个数相加等于0的情况 ④如果满足将其以元组的形式添加到集合中 ⑤因为集合自动实现了去重，结果只需输出集合的长度即可

注意 1.set的用法： ①得到是一个集合{}，要想得到列表还要转化 ②set是集合，创建集合set()。 ③向集合中添加元素s.add(x)。如果元素x不在集合中，将x增加到s，如果已存在，则不会有任何操作 2.sorted()函数和列表的.sort()方法注意sorted函数对输入数据的简便处理 3.序列类型只有三种：字符串、列表、元组字典和集合不是序列类型

a=list(map(int,input().split())) a.sort() b=set() for i in range(len(a)): for j in range(i+1,len(a)): for k in range(j+1,len(a)): if a[i]+a[j]+a[k]==0: b.add((a[i],a[j],a[k])) print(len(b))

1 2 3 4 5 6 7 8 9 10 a=list(map(int,input().split())) a=sorted(a) b=set() for i in range(len(a)): for j in range(i+1,len(a)): for k in range(j+1,len(a)): if a[i]+a[j]+a[k]==0: b.add((a[i],a[j],a[k])) print(len(b)) 1 2 3 4 5 6 7 8 9 a = sorted(list(map(int,input().split()))) l = len(a) b = set() for i in range(l): for j in range(i+1,l): for k in range(j+1,l): if a[i]+a[j]+a[k]==0: b.add((a[i],a[j],a[k])) print(len(b))

1 2 3 4 5 6 7 8 9 10 11 三十九、矩阵翻来覆去的运算 1.题意

2.解题思路这道题题意好理解，关键是要学会如何在Python输入矩阵：两种方法，但本质上都是列表套列表 ①

n=int(input()) a=[] for i in range(n): s=list(map(int,input().split())) a.append(s) 1 2 3 4 5 ②

n=int(input()) a=[] for i in range(n): s=input() a.append([int(n) for n in s.split()]) 1 2 3 4 5 先特判一下错误情况，然后两重循环遍历列表，计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和

方法一：

n=int(input()) a=[] for i in range(n): s=list(map(int,input().split())) a.append(s) #print(a) if len(a[0]) != n: print("输入错误，请重新输入！") else: sum=0 for i in range(n): for j in range(n): if i!=n-1 and j!=n-1 and i+j!=n-1: sum+=a[i][j] print(sum)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 方法二：

else: sum=0 for i in range(n): for j in range(n): if i!=n-1 and j!=n-1 and i+j!=n-1: sum+=a[i][j] print(sum)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 四十一、和谐列表 1.题意

2.解题思路 a=list(map(int,input().split(","))) d={} for i in a: if i in d: d[i] += 1 else: d[i] = 1 res = [] for i in d: if i + 1 in d: res.append(d[i]+d[i+1]) if not res: print(0) else: print(max(res))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 四十三、字符串基本操作 1.题意

2.解题思路循环遍历一遍字符串统计大写字母、小写字母、数字，注意输出格式即可，最后还要转化为大写

s = input() cnt1,cnt2,cnt3,cnt4=0,0,0,0 for i in s: if i>='a' and i<='z': cnt1+=1 elif i>='A' and i<='Z': cnt2+=1 elif i>='0' and i<='9': cnt3+=1 else: cnt4+=1

print("字母字符数有{:d}，阿拉伯数字字符数有{:d}，其他字符有{:d}，本条字符转换为:{:s}".format(cnt1+cnt2,cnt3,cnt4,s.upper()))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 四十五、有序列表插入元素 1.题意

2.解题思路方法一：直接将待插入值插到列表最后，然后排序即可得到新序列计算插入的最大索引值：直接利用小技巧，在新序列中利用方法找到第一个出现的索引值+该插入值出现的次数-1(它本身)即可得到注意：输入还可以语句在一行中来写输出使用fstring方式简单

a,b=list(map(int,(input().split()))),eval(input()) a.append(b) a.sort() print(f"输出后的列表为{a},插入索引值为{a.index(b)+a.count(b)-1}")

1 2 3 4 5 方法二：第一次时用的方法，较麻烦，但也很好理解

a = list(map(int,input().split())) n =eval(input())

if n >=a[len(a)-1]: a.insert(len(a),n) print("输出后的列表为", end="") print(a, end="") print(",插入索引值为", end="") print(len(a)-1) elif n<a[0]: a.insert(0,n) print("输出后的列表为", end="") print(a, end="") print(",插入索引值为", end="") print(0) else: t = 0 for i in range(len(a)): if n >= a[i] and n < a[i + 1]: t = i break

a.insert(t + 1, n)

print("输出后的列表为", end="")
print(a, end="")
print(",插入索引值为", end="")
print(t + 1)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 四十六、列表排列 1.题意

2.解题思路方法一：很简单的一道题，两次循环，第一次循环先将除0和0.0外的数遍历添加到一个新列表中，第二次循环将0和0.0按顺序添加到列表中，将新列表输出即可注意输入方式

s=list(map(eval,input().split(","))) t=[] for i in s: if i!=0 or i!=0.0: t.append(i) for i in s: if i==0 or i==0.0: t.append(i) print(t) 1 2 3 4 5 6 7 8 9 方法二：注意输入方式，可以直接用map(eval,)，自动识别映射了直接利用列表中的排序方法

list.sort(cmp=None, key=None, reverse=False) ①cmp – 可选参数,如果指定了该参数会使用该参数的方法进行排序。 ②key --主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 ③ reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。 bool()函数对括号内的内容判断真假，真则返回true,假则返回false。一般来说，对于数字类型，为0则假，非0 则真。假的情况往往较少，下面列举一些为假的情况。 1.定义为false的对象：None 和False 2.值为0的数字类型:0, 0.0 ,0j,Decimal(0),fraction(0,1) 3.空的序列和集合：’’,{},(),[],set(),range(0)

所以key=bool，如果是为假，先排序，而只有0和0.0为假，所以在降序输出reverse = True即可得到

a = list((input().split(","))) for i in range(len(a)): if a[i].count('.')==1: a[i]=float(a[i]) else: a[i]=int(a[i]) a.sort(key=bool, reverse=True)

print(a)

2.解题思路将两个序列分别用列表存储，特判一下长度是否相同，相同的遍历一遍，求对应索引上值的和

a = list(map(int,input().split())) b = list(map(int,input().split()))

if len(a) != len(b): print("不构成矩阵。") else: for i in range(len(a)): print(a[i]+b[i],end=" ") 1 2 3 4 5 6 7 8 五十二、不常见的单词 1.题意

2.解题思路用列表操作，将两个列表合并，计算出现一次的元素，如果出现了一次就添加到新列表中，输出新列表

s1 = list(input().split()) s2 = list(input().split()) s1.extend(s2) s3=[] for i in range(len(s1)): if s1.count(s1[i])==1: s3.append(s1[i]) print(s3) 1 2 3 4 5 6 7 8 五十四、又见字符统计 1.题意

2.解题思路 ①首先要排除错误的情况，如果字符串中出现非字母，直接输出错误，使用string.isalpha()方法：如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False ②然后将字符串全部转为大写，或者全部转为小写来操作。 ③核心操作：遍历一遍26个英文字母（大写或小写），利用count()方法统计字符串中每个字母出现的个数，然后存到一个列表中这里要用到字符串中的chr() 和 ord()函数 chr()将unicode编码转换为相对应字符 ord()将字符转换为unicode编码也可以直接记住 a是97 ，z是122 ④最后输出这个列表

普通写法：

s=input() if s.isalpha()==False: print("Error!") else: s=s.lower() t=[] for i in range(ord('a'), ord('z')+1): t.append(s.count(chr(i))) print(t) 1 2 3 4 5 6 7 8 9 s=input() if s.isalpha()==False: print("Error!") else: s=s.lower() t=[] for i in range(97,122+1): t.append(s.count(chr(i))) print(t) 1 2 3 4 5 6 7 8 9 列表推导式写法：

s=input() if s.isalpha()==False: print("Error!") else: s=s.lower() print([s.count(chr(i)) for i in range(ord('a'), ord('z')+1)]) 1 2 3 4 5 6 五十七、有序列表的重复项删除 1.题意

2.解题思路最简单的方法，使用set()集合，但是题目要求不让使用set来做，管他呢，能过就行

s1 = list(input().split()) print(len(set(s1))) 1 2 五十八、字符间最短的距离 1.题意

2.解题思路两重循环暴力遍历字符串即可，每一个字符都遍历，与已知字符的下标比较求出最小值，添加到新列表中，每个字符都重复这样操作，直到外循环遍历完整个字符串为止。

方法一：

s=input() c=input() t=[] for i in range(len(s)): ans=1000000 for j in range(len(s)): if s[j]==c: ans=min(ans,abs(j-i)) t.append(ans) print(t)

1 2 3 4 5 6 7 8 9 10 11 12 方法二：

n = input() m = input() lst = [] len1 = [] answer = [] for i in range(len(n)): if n[i] == m: lst.append(i) for l in range(len(n)): len1.clear() for j in lst: len1.append(abs(l-j)) answer.append(min(len1)) print(answer)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 六十一、书籍购买 1.题意

2.解题思路简单的分支结构题目，只需要注意输出格式即可，三种方法： ①纯print语句输出 ②字符串format格式化方法 ③fstring输出方法本题显然用第三种方法更简单

n=eval(input()) s=input() ans=0 if s=="yes": if n>=15: ans=7.5 elif n>=10 and n<15: ans=8 else: ans=8.5 if s=="no": if n>=15: ans=8.5 else: ans=9.5 print(f"享受{ans}折优惠") 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 六十三、歌咏小能手 1.题意

2.解题思路方法一：将得分输入到列表中，把最小值，最大值从列表中删除，求和再求平均值，循环再计算

n=eval(input()) a= list(map(int,input().split(",")))

a.remove(max(a)) a.remove(min(a))

sum = 0 for i in a: sum += i ave = float(sum/(n-2)) cnt = 0 for i in a: if i<ave: cnt+=1 print("此人最终得分是:{:.3f},有{:d}个低于平均值的成绩。".format(ave, cnt))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 n=eval(input()) a= list(map(int,input().split(","))) a.remove(max(a)) a.remove(min(a)) ave = sum(a)/(n-2) cnt = 0 for i in a: if i<ave: cnt+=1 print("此人最终得分是:{:.3f},有{:d}个低于平均值的成绩。".format(ave, cnt))

1 2 3 4 5 6 7 8 9 10 11 12 13 方法二：直接利用函数sum(),max(),min()计算出平均数，再遍历一遍列表，如果小于平均值并且不是最大值和最小值，就计数

n=eval(input()) a=list(map(int,input().split(","))) ave=(sum(a)-max(a)-min(a))/(n-2) cnt=0 for i in a: if i<ave and i!=max(a) and i!=min(a): cnt+=1 print("此人最终得分是:{:.3f},有{:d}个低于平均值的成绩。".format(ave,cnt)) 1 2 3 4 5 6 7 8 六十四、矩阵相加 1.题意

2.解题思路方法一：

n=int(input()) a=[] for i in range(n): s=list(map(int,input().split())) a.append(s)

b=[] for i in range(n): s=list(map(int,input().split())) b.append(s)

for i in range(n): for j in range(n): t=a[i][j] + b[i][j] if(j==n-1): print("{:^3d}".format(t),end=" ") else: print("{:^3d}".format(t), end=" ")

print(end="\n")

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 方法二：

n=int(input()) a=[] for i in range(n): s1=input() a.append([int(n) for n in s1.split()])

b=[] for i in range(n): s2=input() b.append([int(n) for n in s2.split()])

for i in range(n): for j in range(n): t=a[i][j] + b[i][j] if(j==n-1): print("{:^3d}".format(t),end=" ") else: print("{:^3d}".format(t), end=" ")

print(end="\n")

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 六十六、单词的区域 1.题意

2.解题思路字典题：这个题就是要统计输入的单词在哪个颜色的区域，（1）首先把每个颜色区域中的字母存到不同的列表中，方便后面的计算（2）然后输入的时候字符串分割是把一个单词一个单词的输入到列表中， for i in s: #就是遍历列表中每一个总的单词 for j in i:就是遍历每一个单词中的每一个字母 if j in ye:然后如果这个单词的字母在ye也就是黄色区域中的话， cnt +=1，cnt就增1，所以前面要就要初始化cnt=0 然后可能存在一个单词中有的字母在这个区域，有的字母在另一个区域，所以要特判一下，即if cnt == len(i):此时就是这个单词中所有的字母都在ye黄色区域中，就把这个单词添加到一个一个新列表pye中，即pye.append(i) （3）同理，后面重复三次。分别处理三个区域，最后在将其三个列表加入到字典中，输出即可

s = list(input().split())

re = ['q','w','e','a','s','d','z','x','c','Q','W','E','A','S','D','Z','X','C'] bl = ['r','t','y','f','g','h','v','b','n','R','T','Y','F','G','H','V','B','N'] ye =['u','i','o','p','j','k','l','m','U','I','O','P','J','K','L','M']

words={} pre=[] for i in s: cnt=0 for j in i: if j in re: cnt +=1 if cnt== len(i): pre.append(i) pbl=[] for i in s: cnt=0 for j in i: if j in bl: cnt +=1 if cnt== len(i): pbl.append(i)

pye=[] for i in s: cnt=0 for j in i: if j in ye: cnt +=1 if cnt== len(i): pye.append(i) words['Red'] = pre words['Blue'] = pbl words['Yellow'] = pye

print(words) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 七十一、三个数必有最大2 1.题意

2.解题思路先求出三个数中绝对值最大的那个数，将三个数都添加到列表中，遍历列表，求他们绝对值最大的数，记录这个原数值，出现了就break掉（保证是最先出现的数)。输出这个数

a = eval(input()) b = eval(input()) c = eval(input()) t = max(abs(a),abs(b),abs(c)) s= [] s.append(a) s.append(b) s.append(c)

for i in s: if abs(i)==t: f=i break; print(f)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 七十八、字符串的重新排列 1.题意

2.解题思路核心：利用桶的思想初始化一个长度一个的桶res，桶的下标就是列表 iLis[i] 的数值。这样就可以将字符串 sLis的第 i 个字符，按照列表 iLis[i] 的值所指示的位置放置到桶内。

注意： ①res列表要开一个长度和已知字符串一样长的空列表，里面每个元素的值都初始化为空字符串 ②学会使用.join()方法，这样就不用再循环输出了 string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

方法一：暴力

sli = list(input()) ili = list(map(int,input().split(","))) res = [] for i in range(len(sli)): res.append("") for i in range(len(sli)): res[ili[i]] = sli[i] for i in res: print(i,end="") 1 2 3 4 5 6 7 8 9 方法二：使用了.join()方法

sli = list(input()) ili = list(map(int,input().split(","))) res = [] for i in range(len(sli)): res.append("") for i in range(len(sli)): res[ili[i]] = sli[i] print("".join(res)) 1 2 3 4 5 6 7 8 方法三：用列表推导式实现

sli = list(input()) ili = list(map(int,input().split(",")))

res = ["" for i in range(len(sli))] for i in range(len(sli)): res[ili[i]] = sli[i] print("".join(res)) 1 2 3 4 5 6 7 七十九、下三角矩阵判断 1.题意

2.解题思路先是矩阵输入，利用二维列表的方法输入，记住模板然后对矩阵进行操作，两重循环遍历列表索引，i<j代表是下三角的区域然后利用标志旗帜法标记最后输出。注意这个题是多组样例输入，外面还要再加一重循环，两种实现

方法一：

t=eval(input()) while t!=0: n=eval(input()) a=[] for i in range(n): s=list(map(int,input().split())) a.append(s)

flag=1
for i in range(n):
    for j in range(n):
        if i<j and a[i][j]!=0:
            flag=0

if flag==1:
    print("Yes")
else:
    print("No")
t-=1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 方法二：

t=eval(input()) for k in range(t): n=eval(input()) a=[] for i in range(n): s=list(map(int,input().split())) a.append(s) flag=1 for i in range(n): for j in range(n): if i<j and a[i][j]!=0: flag=0 if flag==1: print("Yes") else: print("No")

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 八十二、寻找缺失的整数 1.题意

2.解题思路方法一：（1）首先注意输入方式，（2）对整数序列进行升序排序，（3）构造一个从最小值到最大值的序列（4）然后把已知整数序列lis添加到新的序列中，如果数字出现的个数是1，就添加到新列表中，（5）最后对新列表判断即可，注意正整数是要求n大于0

s, n = input().split() n=eval(n) a=list(map(int,s.split(",")))

a.sort() t=[] for i in range(a[0],a[len(a)-1]): t.append(i)

t.extend(a) f=[] for i in t: if t.count(i)==1: f.append(i)

if n<=0 or n>=len(f): print("Out Of Range!") else: print("The {:d}th missing integer is {:d}!".format(n,f[n-1]))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 方法二：（1）首先注意输入方式，（2）对整数序列进行升序排序，（3）循环构造一个从最小值到最大值的序列，只需判断已知的整数序列lis中的数是否在序列中即可，如果不在序列中，就添加到一个新列表中（4）最后对新列表判断即可，注意正整数是要求n大于0

s,n=input().split() n=eval(n) s=list(map(int,s.split(","))) s.sort() a=[] for i in range(s[0],s[len(s)-1]): if i not in s: a.append(i) if n<=0 or n>=len(a): print("Out Of Range!") else: print(f"The {n}th missing integer is {a[n-1]}!")

1 2 3 4 5 6 7 8 9 10 11 12 13 八十三、求矩阵局部极大值 1.题意

2.解题思路首先注意如何输入在一行中用空格隔开的两个数然后输入矩阵，依然采用二维列表的方法存储矩阵，然后对二维列表进行操作，通过两重循环遍历二维列表索引的方式操作矩阵利用标志旗帜法特判特殊情况

m,n=map(int,input().split()) a=[] for i in range(m): s=list(map(int,input().split())) a.append(s) flag=1 for i in range(1,m-1): for j in range(1,n-1): if a[i][j]>a[i+1][j] and a[i][j]>a[i-1][j] and a[i][j]>a[i][j+1] and a[i][j]>a[i][j-1]: flag=0 print("%d %d %d"%(a[i][j],i+1,j+1)) if flag==1: print("None %d %d"%(m,n))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 八十四、反转单词中的字母 1.题意

2.解题思路方法一：利用字符串中的方法： replace():可以实现字符的替换 swapcase():可以实现大小写之间的互换再利用字符串切片实现字符串的反转注意以上方法每实现一步都要赋给一个值

s=input() s=s.replace(" ","#") s=s.swapcase() s=s[::-1] print(s)

1 2 3 4 5 6 7 方法二：利用列表及其方法：现将每个字符都存入列表当中，利用列表中的反转方法，将列表元素反转，遍历列表，大写元素输出为小写，小写元素输出为大写，空格输出#

s = list(input()) s.reverse() for i in s: if i==" ": print("#",end="") if i>='a' and i<='z': print(i.upper(),end="") if i>='A' and i<='Z': print(i.lower(),end="") 1 2 3 4 5 6 7 8 9 八十六、输出指定的英文字母 1.题意

2.解题思路用列表进行计算， ①先将列表反转，这样就可以实现从右开始挑选了 ②遍历列表，判断是否是小写字母，在这个字母之前是否出现过，利用not in 成员运算符和切片实现，是的话存入到一个新列表中（核心：(s[i] not in s[0:i]） ③对新列表进行操作：特判not found情况，也就是不足七个字母否则，先切片截取前七个数，然后反转这个列表，输出列表中的每个元素即可注意： ①列表切片反转可以直接在切片中一步完成，不需要使用reverse方法 ②输出没必要遍历列表输出每一个元素，直接用join()方法即可

方法一：

s=list(input()) s.reverse() t=[] for i in range(len(s)): if s[i]>='a' and s[i]<='z' and (s[i] not in s[0:i]): t.append(s[i]) if len(t)<7: print("not found") else:

t=t[0:6+1:1]
t.reverse()
print("".join(t))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 方法二：

s=list(input()) s.reverse() t=[] for i in range(len(s)): if s[i]>='a' and s[i]<='z' and (s[i] not in s[0:i]): t.append(s[i]) if len(t)<7: print("not found") else: t=t[6::-1] print("".join(t)) 1 2 3 4 5 6 7 8 9 10 11 方法三：第一次做的时候，纯暴力，比较愚蠢的做法

st =list(input())

s=[] for i in range(len(st)): if st[i]<='z' and st[i]>='a': s.append(st[i]) s.reverse() s1=[] s1.append(s[0]) for i in range(1,len(s)): flag = 0 for j in range(0,i): if s[i]==s[j]: flag=1 break if flag==0: s1.append(s[i])

if len(s1)<7: print("not found") else: s2 = [] for i in range(len(s1)): if i == 6: s2.append(s1[i]) break else: s2.append(s1[i]) s2.reverse() for i in range(len(s1)): if i==6: print(s2[i]) break else: print(s2[i],end="")

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 八十九、七进制数 1.题意

2.解题思路短除法

a=eval(input()) n=abs(a) t="" while n!=0: x=n%7 n=n//7 t=str(x)+t if a<0: print("-"+t) else: print(t) 1 2 3 4 5 6 7 8 9 10 11 九十一、循环数数 1.题意

2.解题思路第一重循环：遍历1~n，将数字转变为字符串，方便进行循环移位，开一个标记变量

第二重循环：实现将字符串循环移位，再将其转换为整数

第三重循环：判读整数是否为素数，用标记变量标记，计数

核心：num=num[1:]+num[:1] 利用字符串切片，能够实现循环移位的操作

n = input() s1=n[1:] s2=n[:1] s=n[1:]+n[:1] print(s1) print(s2) print(s) 1 2 3 4 5 6 7 代码：

import math

n=int(input()) sum=0 for i in range(2,n): flag=True num=str(i) for j in range(len(num)): num=num[1:]+num[:1] temp=int(num) for k in range(2, int(math.sqrt(temp)) + 1): if temp % k == 0: flag = False break if flag==False: break if flag: sum += 1 print(sum)