Python基础刷题，期末不挂科~~~（持续更新中）

刷题目录

• • 一、四位数逆序输出
  • • 1.题意
    • 2.解题思路
  • 二、时间计算
  • • 1.题意
    • 2.解题思路
  • 三、烧热水
  • • 1.题意
    • 2.解题思路
  • 四、利息计算
  • • 1.题意
    • 2.解题思路
  • 五、BMI指数计算
  • • 1.题意
    • 2.解题思路
  • 六、温度转换
  • • 1.题意
    • 2.解题思路
  • 七、圆的周长与面积
  • • 1.题意
  • 八、三角形面积
  • • 1.题意
    • 2.解题思路
  • 九、字符串逆序
  • • 1.题意
    • 2.解题思路
  • 十、字符串截取
  • • 1.题意
    • 2.解题思路
  • 十一、判断回文字符串
  • • 1.题意
    • 2.解题思路
  • 十二、计算字符个数
  • • 1.题意
    • 2.解题思路
  • 十三、节约用电
  • • 1.题意
    • 2.解题思路
  • 十四、克莱姆法则求解方程
  • • 1.题意
    • 2.解题思路
  • 十五、计算年薪
  • • 1.题意
    • 2.解题思路
  • 十六、划分分数等级
  • • 1.题意
    • 2.解题思路
  • 十七、字母反转
  • • 1.题意
    • 2.解题思路
  • 十八、查找指定字符
  • • 1.题意
    • 2.解题思路
  • 二十、单词统计【part one】
  • • 1.题意
    • 2.解题思路
  • 二十一、温度转换【part two】
  • • 1.题意
    • 2.解题思路
  • 二十二、字符串循环左移
  • • 1.题意
    • 2.解题思路
  • 二十三、打印空心三角形
  • • 1.题意
    • 2.解题思路
  • 二十四、工作日的力量【part one】
  • • 1.题意
    • 2.解题思路
  • 二十八、循环数数
  • • 1.题意
    • 2.解题思路
  • 三十、数列求和【part one】
  • • 1.题意
    • 2.解题思路
  • 三十一、数列求和【part two】
  • • 1.题意
    • 2.解题思路
  • 三十二、列表元素绝对值排列
  • • 1.题意
    • 2.解题思路
  • 三十三、删除字符串中连续的重复字符
  • • 1.题意
    • 2.解题思路
  • 三十五、列表合并去重
  • • 1.题意
    • 2.解题思路
  • 三十七、乘积的列表
  • • 1.题意
    • 2.解题思路
  • 三十八、0的组合
  • • 1.题意
    • 2.解题思路
  • 三十九、矩阵翻来覆去的运算
  • • 1.题意
    • 2.解题思路
  • 四十一、和谐列表
  • • 1.题意
    • 2.解题思路
  • 四十三、字符串基本操作
  • • 1.题意
    • 2.解题思路
  • 四十五、有序列表插入元素
  • • 1.题意
    • 2.解题思路
  • 四十六、列表排列
  • • 1.题意
    • 2.解题思路
  • 五十、稀疏矩阵存储
  • • 1.题意
    • 2.解题思路
  • 五十二、不常见的单词
  • • 1.题意
    • 2.解题思路
  • 五十四、又见字符统计
  • • 1.题意
    • 2.解题思路
  • 五十七、有序列表的重复项删除
  • • 1.题意
    • 2.解题思路
  • 五十八、字符间最短的距离
  • • 1.题意
    • 2.解题思路
  • 六十一、书籍购买
  • • 1.题意
    • 2.解题思路
  • 六十三、歌咏小能手
  • • 1.题意
    • 2.解题思路
  • 六十四、矩阵相加
  • • 1.题意
    • 2.解题思路
  • 七十一、三个数必有最大2
  • • 1.题意
    • 2.解题思路
  • 七十八、字符串的重新排列
  • • 1.题意
    • 2.解题思路
  • 八十二、寻找缺失的整数
  • • 1.题意
    • 2.解题思路
  • 八十四、反转单词中的字母
  • • 1.题意
    • 2.解题思路
  • 八十六、输出指定的英文字母
  • • 1.题意
    • 2.解题思路
  • 八十九、七进制数
  • • 1.题意
    • 2.解题思路
  • 九十一、循环数数
  • • 1.题意
    • 2.解题思路

一、四位数逆序输出 1.题意

2.解题思路

方法一：字符串切片
输出为字符串类型，利用字符串的切片将字符串反转，然后循环输出每个字符
注意：
①字符串切片操作[-1::-1]可以实现字符串反转
②注意输出操作，如何用空格隔开输出

s=input()
s=s[-1::-1]
for i in s:
    print(i,end=" ")

方法二：列表反转
利用列表进行计算，把每一个字符以整型的形式存进列表中，将列表反转然后输出列表中的元素，也可以不用反转直接逆序输出列表中的每一个元素

s=list(map(int,input()))
s.reverse()
for i in s:
    print(i,end=" ")

方法三：分离数位
把字符串转化为整型，以整数的形式计算，利用/和%分离每一位用变量存储，然后直接逆序输出每一位。这种方法太简单，不再细说

二、时间计算 1.题意

2.解题思路

本质上也是个分离数位的问题，给定秒数分别计算小时、分钟、秒，小学数学问题，具体计算看代码，主要python中的这道题输出需注意，可以使用以下两种方式输出：
方法一：直接print()中输出

n=eval(input())
h=n/3600
m=n%3600/60
s=n%3600%60
print("%d时%d分%d秒"%(h,m,s))

方法二：利用字符串中的.format()格式化函数输出
需注意：此时变量的类型与前面占位符中的类型需要对应，因为/是除不是整除，得到的是浮点型，所以还需要类型转换为int，有下面两种实现。而上面直接print()输出，相当于是直接输出把浮点型变成int强制类型转换了。

n=eval(input())
h=int(n/3600)
m=int(n%3600/60)
s=int(n%3600%60)
print("{:d}时{:d}分{:d}秒".format(h,m,s))

n=eval(input())
h=n//3600
m=n%3600//60
s=n%3600%60
print("{:d}时{:d}分{:d}秒".format(h,m,s))

三、烧热水 1.题意

2.解题思路

输入这个三个变量，然后根据题目中公式计算即可。没啥好说的，只需要注意输入输出是浮点型

m=eval(input())
qf=eval(input())
ql=eval(input())

q=m*(ql-qf)*4184
print("%.1lf"%(q))

四、利息计算 1.题意

2.解题思路

也是一个简单的计算问题，但是需注意题目中有几个坑：
①年利率要转换为月利率，即年利率/12=月利率
②年数要转换为月数，即年数*12=月数
③月利率是一个百分比，所以要乘上0.01变成百分数
④多少次方使用两个乘号

ml=eval(input())
f=eval(input())
y=eval(input())

mf=ml/((1+(f/12)*0.01)**(y*12))
print("%.2f"%(mf))

五、BMI指数计算 1.题意

2.解题思路

简单的公式计算，注意输入和输出格式即可。

w,h=eval(input()),eval(input())
ans=w/(h*h)
print("%.2f"%(ans))

w,h=eval(input()),eval(input())
ans=w/(h*h)
print("{:.2f}".format(ans))

六、温度转换 1.题意

2.解题思路

利用字符串切片，切出第一个字符和后面的问题，判断利用公式进行温度转换，注意输出

s=input()
x=s[0]
t=eval(s[1::])
if x=="C":
    f=t*1.8+32
    print("F{:.2f}".format(f))
if x=='F':
    c=(t-32)/1.8
    print("C{:.2f}".format(c))

七、圆的周长与面积 1.题意

2.解题思路
简单计算没啥好说的，注意类型之间的转换和输出

r=eval(input())
pi=3.14159
l=2*pi*r
s=pi*r*r
print("%.4f %.4f"%(l,s))

八、三角形面积 1.题意

2.解题思路

简单公式计算问题，需注意开平方的实现方式：
①利用python自带的幂运算函数pow(x,1/2)
②导入math数学函数库，利用里面的.sqrt()开平方函数

方法一：

a=eval(input())
b=eval(input())
c=eval(input())
p=(a+b+c)/2
s=pow(p*(p-a)*(p-b)*(p-c),1/2)
print("%.2f"%(s))

方法二：

import math
a=eval(input())
b=eval(input())
c=eval(input())
p=(a+b+c)/2
s=math.sqrt(p*(p-a)*(p-b)*(p-c))
print("%.2f"%(s))

九、字符串逆序 1.题意

2.解题思路

超简单题，与第一题四位数逆序输出中的方法一样。
方法一：字符串切片

s=input()
s=s[-1::-1]
print(s)

方法二：列表反转函数

s=input()
a=list(s)
a.reverse()
for i in a:
    print(i,end="")

十、字符串截取 1.题意

2.解题思路

这道题纯无聊题，最傻的方法直接输出呗

print("故宫长城")

正规做法：是使用字符串切片和.join()拼接函数
注意切片范围顺序和.join()方法如何使用

s=input()
s1=s[4:5+1:1]
s2=s[7:8+1:1]
seq=(s1,s2)
t=""
print(t.join(seq))

十一、判断回文字符串 1.题意

2.解题思路

方法一：
通过判断字符串是奇数长度还是偶数长度，分别来根据中间实行切片左右两段，如果左端等于右端的逆序，说明就是回文串
注意输出时需要先输出原本的字符串

s=input()
le=len(s)

if le%2==0:
    s1=s[0:le//2:1]
    s2=s[le//2:le+1:1]
else:
    s1=s[0:le//2+1:1]
    s2=s[le//2:le+1:1]
s2=s2[-1::-1]
print(s)
if s1==s2:

    print("Yes")
else:
    print("No")

方法二：
利用列表反转，先让两个列表分别等于字符串s，将其中一个列表反转，判断两个列表是否相等即可。列表相等即列表中对应的每一个元素的值相等

s=input()
s1=list(s)
s2=list(s)
s2.reverse()

print(s)
if s1==s2:
    print("Yes")
else:
    print("No")

方法三：
使用reversed()函数
reversed(seq)。
reversed 函数返回一个反转的迭代器。
seq – 要转换的序列，可以是 tuple, string, list 或 range。

s = input()
rs = list(reversed(s))
print(s)
if list(s) == rs:
    print("Yes")
else:
    print("No")

十二、计算字符个数 1.题意

2.解题思路

方法一：
利用lower()方法把大写字母都转换为小写字母，再利用count()方法统计在字符串中字符出现的次数。
也可以利用upper()方法把小写字母都转换为大写字母
注意：本题目的输入是以空格隔开的，学会如何处理这种输入

s,f = input().split()
s=s.lower()
f=f.lower()
cnt=s.count(f)
print(cnt)

s,f = input().split()
s=s.upper()
f=f.upper()
cnt=s.count(f)
print(cnt)

方法二：

s1, s2 = input().split() 
s3 = s1.lower()
s4 = s2.lower()
print(len(s3.split(s4))-1)

十三、节约用电 1.题意

2.解题思路

简单多重分支题目，没啥好说的

n=eval(input())

if n<0:
    print("Invalid Value!")
elif n<=50:
    res=0.53*n
    print("cost = %.2f"%(res))
else:
    res=(n-50)*(0.53+0.05)+50*0.53
    print("cost = %.2f"%(res))

十四、克莱姆法则求解方程 1.题意

2.解题思路

也是一个公式计算问题，但需要注意以下几点：
①如何处理这种以逗号分隔开的数据？
②类型转化问题：eval()评估函数可以把字符串上面的引号去掉，自动识别出其是什么类型。
③计算时分母不能为0，所以这个题要先判断，再去计算结果。而不能先计算结果再判断

a,b,c,d,e,f=input().split(",")
a=eval(a)
b=eval(b)
c=eval(c)
d=eval(d)
e=eval(e)
f=eval(f)

if a*d-b*c==0:
    print("The equation has no solution")
else:
    x = (e * d - b * f) / (a * d - b * c)
    y = (a * f - e * c) / (a * d - b * c)
    print("x=%.1f,y=%.1f"%(x,y))

十五、计算年薪 1.题意

2.解题思路

简单的分支结构计算题目，注意以下输出格式即可

s=input()
n=eval(input())
res=0
if n<40000:
    res=n*(1+0.05)
else :
    res=40000+2000+(n-40000)*(1+0.02)
print("{:s}新一年的年薪是：{:.1f}元".format(s,res))

十六、划分分数等级 1.题意

2.解题思路

最简单的多分支结构

n=eval(input())
if n<=100 and n>=90:
    print("A")
elif n<=89 and n>=80:
    print("B")
elif n<=79 and n>=70:
    print("C")
elif n<=69 and n>=60:
    print("D")
elif n<=59 and n>=0:
    print("E")
else:
    print("Invalid")

十七、字母反转 1.题意

2.解题思路

本题关键是在于如何多组换行数据输入，利用while循环+input语句，循环结束条件单独判断：
大小写之间的互换可以直接使用字符串swapcase方法

while True:
    s=input()
    if s=="$":
        break
    elif s[-1]=="$":
        print(s[0:-1].swapcase())
        break
    else:
        print(s.swapcase())

十八、查找指定字符 1.题意

2.解题思路

先把指定字符和模板字符都转化为大写或者小写，再直接用rfind()方法去查找出现该字符的最大下标即可
字符串常用的几种方法：
①.lower()把所有大写字母转为小写字母，注意还要赋给一个值
②.upper()把所有小写字母转为大写字母，注意还要赋给一个值
③.rfind()查找出现该字符的最大下标，如果没有，返回-1

s=input()
t=input()
if len(t)>20:
    print("输入错误！")
else:
    s=s.upper()
    t=t.upper()
    res=t.rfind(s)
    if res==-1:
        print("Not Found")
    else:
        print("index = %d"%(res))

下面这是第一次做的时候自己写的垃圾代码，哈哈哈哈

n = input()
s = input()
if len(s)>20:
    print("输入错误！")
else:
    if n<='z' and n>='a':
        s=s.lower()
        c = s.rfind(n)
        if c != -1:
            print("index = {}".format(c))
        else:
            print('Not Found')
    elif n<='Z' and n>='A':
        s=s.upper()
        c = s.rfind(n)
        if c != -1:
            print("index = {}".format(c))
        else:
            print('Not Found')
    else:
        c = s.rfind(n)
        if c != -1:
            print("index = {}".format(c))
        else:
            print('Not Found')

二十、单词统计【part one】 1.题意

2.解题思路

超简单偷鸡方法，利用输入处理数据把空格自动删除掉，存到列表中，有几个元素吧就是有几个单词了
哈哈哈哈哈哈哈

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

二十一、温度转换【part two】 1.题意

2.解题思路

分支结构，一共需要判断五次

n=input()
if n[-1]=='C':
    n1=n[:-1]
    m=float(n1)*1.8+32
    m=('%.2f'%m)
    print(str(m)+'F')
elif n[-1]=='c':
    n1 = n[:-1]
    m = float(n1) * 1.8 + 32
    m=('%.2f'%m)
    print(str(m)+'f')
elif n[-1]=='F':
    n1 = n[:-1]
    m=(float(n1)-32)/1.8
    m=('%.2f'%m)
    print(str(m)+'C')
elif n[-1]=='f':
    n1 = n[:-1]

    m = (float(n1)-32)/ 1.8
    m=('%.2f'%m)
    print(str(m)+'c')
else:
    print('输入格式错误！')

二十二、字符串循环左移 1.题意

2.解题思路

方法一：利用字符串的切片来做即可，easy

s=input()
n=eval(input())
s1=s[0:n:1]
s2=s[n::1]
print(s2+s1)

s=list(input())
n=eval(input())
s1=s[0:n:1]
s2=s[n:len(s)+1:1]
s3=s2+s1
for i in s3:
    print(i,end="")

方法二：利用列表的切片来做(列表也是序列类型，序列类型都可以进行切片)

s=list(input())
n=eval(input())
s1=s[0:n:1]
s2=s[n:len(s)+1:1]
s3=s2+s1
for i in s3:
    print(i,end="")

二十三、打印空心三角形 1.题意

2.解题思路

核心思想：经典的遍历循环嵌套的题目，即两重嵌套循环：一个控制行数，一个控制每一行的内容*和空格
注意输出语句格式和每一行结束后要换行
几种方式实现方式吧，核心思想都是一样的：

n=eval(input())
for i in range(1,n+1):
    if i==1 or i==n:
        for j in range(i):
            print("*",end="")
    else:
        print("*",end="")
        for j in range(i-2):
            print(" ",end="")
        print("*",end="")
    print(end="n")

n = eval(input())
cnt = 0
for i in range(1, n+1):
    if i == 1:
        print("*")
    elif i == n:
        for j in range(1, n + 1):
            print("*", end="")
    else:
        print("*", end="")
        for j in range(i-2):
            print(" ",end="")
        print("*")

n=eval(input())
for i in range(1,n+1):
    for j in range(1,i+1):
        if j==1 or i==j or i==n:
            print("*",end='')
        else:
            print(end=' ')
    print(end='n')

二十四、工作日的力量【part one】 1.题意

2.解题思路

遍历一遍n天，只要是在星期六和星期七这两天就减0.01，其他天数加0.01

主要是理解以下两点：
①如何判断星期六和星期天这两天？ i%7=6 为星期六 i%7=0为星期天
②理解退步和进步表示关系 res*=（1±0.01）

n = eval(input())
res=1.0
for i in range(1,n+1):
    if i%7==0 or i%7==6:
        res=res*(1-0.01)
    else:
        res=res*(1+0.01)
print("%.2f"%(res))

二十八、循环数数 1.题意

2.解题思路 三十、数列求和【part one】 1.题意

2.解题思路

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

n=eval(input())
t=1
s=0
for i in range(1,n+1):
    s=s+t*i**i
    t*=-1
print(s)

三十一、数列求和【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**k*t
    t*=-1
    k+=1
print(s)

三十二、列表元素绝对值排列 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)

更加简单的方法，在abs就是绝对值得关键字，直接在sort中直接key=abs即可。

s=list(map(int,input().split()))
s.sort(key=abs)
print(s)

三十三、删除字符串中连续的重复字符 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])

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.解题思路

排序和去重的实现方式，这里有一个简单方法便是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)

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.解题思路

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

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

s2 = []
d1 = 1
d2 = 1
for i in range(len(s1)):
    if s1[i] == 0:
        d2 = d2*s1[i]
    else:
        d1 = d1*s1[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)

方法二：两重循环枚举
两重循环枚举，外循环控制枚举到哪个数了，内循环枚举除当前数外其余数相乘，将结果添加到一个新列表即可。
注意：除去当前数的判断条件该如何表示

错误代码：

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)

正确代码：

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)

三十八、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))

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))

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.解题思路

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

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

②

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

先特判一下错误情况，然后两重循环遍历列表，计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和

方法一：

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)

方法二：

n=int(input())
a=[]
for i in range(n):
    s=input()
    a.append([int(n) for n in s.split()])
#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.解题思路

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.解题思路

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

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.解题思路

方法一：
直接将待插入值插到列表最后，然后排序即可得到新序列
计算插入的最大索引值：直接利用小技巧，在新序列中利用方法找到第一个出现的索引值+该插入值出现的次数-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}")

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

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[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.解题思路

方法一：
很简单的一道题，两次循环，第一次循环先将除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)

方法二：
注意输入方式，可以直接用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)

a = list(map(eval,(input().split(","))))
a.sort(key=bool, reverse=True)
print(a)

五十、稀疏矩阵存储 1.题意

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.解题思路

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

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.解题思路

①首先要排除错误的情况，如果字符串中出现非字母，直接输出错误，使用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)

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)

列表推导式写法：

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.解题思路

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

s1 = list(input().split())
print(len(set(s1)))

五十八、字符间最短的距离 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)

方法二：

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.解题思路

简单的分支结构题目，只需要注意输出格式即可，三种方法：
①纯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.解题思路

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

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 
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 
方法二：
 直接利用函数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 
六十四、矩阵相加 
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")

 
方法二：
 
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")
 
七十一、三个数必有最大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.解题思路 
核心：利用桶的思想
 初始化一个长度一个的桶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="")
 
方法二：使用了.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))
 
方法三：用列表推导式实现
 
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.解题思路 
八十四、反转单词中的字母 
1.题意 
 
2.解题思路 
方法一：
 利用字符串中的方法：
 replace():可以实现字符的替换
 swapcase():可以实现大小写之间的互换
 再利用字符串切片实现字符串的反转
 注意以上方法每实现一步都要赋给一个值
 
s=input()
s=s.replace(" ","#")
s=s.swapcase()
s=s[::-1]
print(s)


 
方法二：
 利用列表及其方法：
 现将每个字符都存入列表当中，利用列表中的反转方法，将列表元素反转，遍历列表，大写元素输出为小写，小写元素输出为大写，空格输出#
 
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.解题思路 
用列表进行计算，
 ①先将列表反转，这样就可以实现从右开始挑选了
 ②遍历列表，判断是否是小写字母，在这个字母之前是否出现过，利用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))

 
方法二：
 
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))
 
方法三：第一次做的时候，纯暴力，比较愚蠢的做法
 
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.解题思路 
短除法
 
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.解题思路 
第一重循环：遍历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)
 
代码：
 
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)