《python123期末突击那些事》分配学号/判断火车票座位/时间差之天数计算/画国际象棋盘/研究生录取率

 

三行代码系列：

#

获得输入的一个字符串s，以字符减号(-)分割s，将其中首尾两段用加号(+)组合后输出。

b = input.split("-")
print("{}+{}".format(b[0],b[-1]))

 

#

打印输出如下信息：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

世界，你好！‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

要求：采用垂直方式输出。

print("\n".join("世界，你好！"))

这个join函数的意思是在后面括号里的每个元素后面加（也就是join啦）\n

 

#

人民币和美元是世界上通用的两种货币之一，写一个程序进行货币间币值转换，其中：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

人民币和美元间汇率固定为：1 美元 = 6.78 人民币。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

程序可以接受人民币或美元输入，转换为美元或人民币输出。人民币采用 RMB 表示，美元 USD 表示，符号和数值之间没有空格。

输入："RMB123" 输出："USD18.14"，或者 输入："USD20" 输出："RMB135.60"

S = input()
s = eval(S[3:])
if S[0] in ['R']:
    ans = s/6.78
    print("USD{:.2f}".format(ans))
else:
    ans = s*6.78
    print("RMB{:.2f}".format(ans))

 

#

获得用户输入的一个数字，可能是整数或浮点数 a，计算 a 的三次方值，并打印输出。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出结果采用宽度 20 个字符、居中输出、多余字符采用减号 (-) 填充。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

如果结果超过 20 个字符，则以结果宽度为准。

print("{:-^20}".format(eval(input())**3))

 

#

获得用户输入的一个字符串，格式如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬M OP N‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

其中，M 和 N 是任何数字，OP 代表一种操作，表示为如下四种：+, -, *, /（加减乘除）‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬；‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

根据 OP，输出 M OP N 的运算结果，统一保存小数点后 2 位。

print("{:.2f}".format(eval(input())))

这个和前面的一样啦，eval可以执行括号里的代码

具体地说，可以执行去掉一对引号后的代码，如果输入是11+10,得到21，如果输入是"11+10",输出11+10

类似的选择题：

A的结果是报错，因为str类型不能和int型直接相加

B的结果是2，因为相当于把表达式算出来之后打印结果

C的结果是2，相当于执行表达式1+1的值

D的结果是11，因为“1”+“1”，虽然有引号，但“1”的左右引号是配对的，最外层是没有的，字符1和字符1简单拼接在一起，相当于eval（“11")，输出11

 

#

获得用户输入，去掉其中全部空格，将其他字符按收入顺序打印输出。 ‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例1：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入："Python 是 一个 通用语言"
输出："Python是一个通用语言"

s=input()
s=s.replace(" ","")
print(s)

知道有replace这个函数，就很好写

 

#

输入一个带有字母 a 的字符串，输出其中字母 a 的出现次数。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例1：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入："The python language is a multimodel language."
输出："5"

print(input().count("a"))

 

程序控制系列：

#

打印九九乘法表：

for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={:<3}".format(j,i,i*j),end="")
    print("")

也是个循环的事儿，代码:<3,说的是左对齐，占三格

 

#

鲁棒输入：获得用户的任何可能输入，将其中的英文字符进行打印输出，程序不出现错误。

ps：题外话，看到鲁棒这个词愣了一下，这是个啥？然后查了一下，原文是robust，鲁棒是音译的结果，被调侃为山东人（鲁）身体很棒

s=input()
for i in s:
    if ord("a")<=ord(i)<=ord("z"):
        print(i,end="")
    else:
        print("",end="")

 

#

四位玫瑰数是4位数的自幂数。自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

请输出所有4位数的四位玫瑰数，按照从小到大顺序，每个数字一行。

for i in range(1000,10000):
    str_num=str(i)
    if (int(str_num[0])**4+int(str_num[1])**4+int(str_num[2])**4+int(str_num[3])**4) == i:
        print(i)

 

#

求 100 以内所有素数之和并输出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

素数指从大于 1，且仅能被 1 和自己整除的整数。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

提示：可以逐一判断 100 以内每个数是否为素数，然后求和。

sum=0
for i in range(1,100):
    flag=0
    for j in range(2,i-1):
        if i%j==0:
            flag=1
            break
    if flag==0:
        sum+=i
print(sum)

 

#

在我国古代的《算经》里有一个著名的不定方程问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

for i in range(0,101):
    for j in range(0,101):
        if (100-i-j)%3!=0:
            continue
        elif i*5+j*3+((100-i-j)/3) == 100:
            print("公鸡:{:<3}母鸡:{:<3}小鸡:{:<3}".format(i,j,100-i-j))

依稀记得啊哈算法里面有这道题

 

#

黄鼠狼和狐狸比赛跳跃，黄鼠狼和狐狸每次跳跃距离不同，黄鼠狼每跳一下的距离是skunk 厘米，狐狸每一跳的距离是fox 厘米。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

比赛从同一个起点开始，相同方向，同时起跳，跳跃无间隔。赛道上每隔 trap厘米有一个陷阱，若黄鼠狼和狐狸跳跃频率相同，问谁先掉进陷阱？

import math
s=int(input())
f=int(input())
t=int(input())
ans1=s*t/math.gcd(s,t)
ans2=f*t/math.gcd(f,t)
if ans1<ans2:
    print("黄鼠狼")
else:
    print("狐狸")

掉进陷阱时取最小公倍数，用A*B/gcd（A,B)即可得到最小公倍数，比较大小即可

python内置了gcd函数，import一下math就好

 

#

现有方程：f(x) = x⁵-15x⁴+85x³-225x²+274x-121, 已知f(x)在[1.5,2.4]区间单调下降，且在该区间f(x)==0有且只有一个根，用二分法求解该根。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入一个正整数n，当f(x)值小于10^-n时认为函数值为0‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出方程在[1.5,2.4]区间的根，精确到小数点后第6位‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入：9	
输出：1.849016

def f(x):
    return x**5-15*x**4+85*x**3-225*x**2+274*x-121
l,r,mid=1.5,2.4,(1.5+2.4)/2
n=int(input())
while(abs(f(mid))>10**(-n)):
    if f(mid)<0:
        r=mid
    else:
        l=mid
    mid=(l+r)/2
print("{:6f}".format(mid))

二分法常见套路，这次重写学会了简短代码，nice~

 

#

用户输入一个数字和一个字母组成的座位号，根据字母判断位置是窗口、中间还是过道。目前中国高铁和国内飞机窗口位置的字母是'A'和'F',过道位置是'C'和 'D'，中间位置是'B'。每个车厢座位排数是1-17，输入时不区分字母大小写。根据输入判定座位的位置，当输入的数据不是一个合法的座位号时，输出“座位号不存在”。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬:输入一个数字和字母组合成的字符串‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬ '窗口'、'中间'、'过道' 或'座位号不存在'‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭
输入：12F
输出：窗口‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入：2C
输出：过道‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入：1ZZ
输出：座位号不存在        

s,flag,list1,list2=input(),1,[],["a","b","c","d","f","A","B","C","D","F"]
for i in range(1,18):
    b=str(i)
    for j in list2:
        list1.append(b+j)
if s in list1:
    if s[-1]=='A' or s[-1]=='F' or s[-1]=='a' or s[-1]=='f':
        print("窗口")
    elif s[-1]=='B' or s[-1]=='b':
        print("中间")
    else:
        print("过道")
else:
    print("座位号不存在")

这题比较难的是异常输入，来个！@￥#EFD，或者123c123c什么的，不好搞

思路转换：把正确的枚举出来

代码比标答少一行（当然啦，我稍稍压过嘿嘿

 

#

给用户三次输入用户名和密码的机会，要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

1. 如输入第一行输入用户名为 ‘Kate’，第二行输入密码为 ‘666666’，输出 ‘登录成功！’，退出程序；
2. 当一共有 3 次输入用户名或密码不正确输出 “3次用户名或者密码均有误！退出程序。”。

flag = 0
for i in range(3):
    name,password= input(),input()
    if name == 'Kate' and password == '666666':
        flag = 1
        print("登录成功！")
        break
if flag == 0:
    print("3次用户名或者密码均有误！退出程序。")

 

组合数据类型系列

#

字典 d 中存储了我国 42 所双一流高校及所在省份的对应关系，请以这个列表为数据变量，完善 Python 代码，统计各省份学校的数量。

d = {"北京大学":"北京", "中国人民大学":"北京","清华大学":"北京",\
"北京航空航天大学":"北京","北京理工大学":"北京","中国农业大学":"北京",\
"北京师范大学":"北京","中央民族大学":"北京","南开大学":"天津",\
"天津大学":"天津","大连理工大学":"辽宁","吉林大学":"吉林",\
"哈尔滨工业大学":"黑龙江","复旦大学":"上海", "同济大学":"上海",\
"上海交通大学":"上海","华东师范大学":"上海", "南京大学":"江苏",\
"东南大学":"江苏","浙江大学":"浙江","中国科学技术大学":"安徽",\
"厦门大学":"福建","山东大学":"山东", "中国海洋大学":"山东",\
"武汉大学":"湖北","华中科技大学":"湖北", "中南大学":"湖南",\
"中山大学":"广东","华南理工大学":"广东", "四川大学":"四川",\
"电子科技大学":"四川","重庆大学":"重庆","西安交通大学":"陕西",\
"西北工业大学":"陕西","兰州大学":"甘肃", "国防科技大学":"湖南",\
"东北大学":"辽宁","郑州大学":"河南", "湖南大学":"湖南", "云南大学":"云南", \
"西北农林科技大学":"陕西", "新疆大学":"新疆"}
b={}
for v in d.values():
    b[v]=b.get(v,0)+1

for k,v in b.items():
    print("{}:{}".format(k,v))

代码里用k，v和items枚举字典元素是一个写法，另一个写法是：

for i in b.keys():
    print("{}:{}".format(i,b[i]))

 

#

数据脱敏是指对敏感信息进行变形处理，比如将电话号码 ‘13000000000’ 中的四位用 ’*‘ 来代替，变为 ‘130****0000’。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

本题要求从输入的学生信息中将手机号码，姓名，学号数据进行脱敏处理。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬处理规则如下：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

学号（13 位或 14 位数串）：第 5-11 位修改为“*” 如 ’0121134567801‘ 修改为 ’0121*******01‘‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

姓名：第2位修改为“*“如'贾诩' 修改为“贾*“‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

电话号码（11位数串）：第4-7位 修改为“*“如‘13000000000’中修改为‘130****0000’‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬:第一行输入 n，代表 n 个同学的信息‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬,依次输入 n 行学生信息数据，每行输入一名学生的学号、姓名、电话号码，数据间以空格间隔‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬:将学生数据脱敏后的信息保存到二维列表中，并输出这个二维表。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬如果 n 不是正整数，输出’ERROR‘。（本题保证 n 是整数，且信息完整）‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例 1‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入：
2
01211345678011 张辽 14457673508
01211345678012 徐晃 18514863218
输出：    
[['0121*******011', '张*', '144****3508'], ['0121*******012', '徐*', '185****3218']]

n,beijixing=int(input()),[]
if n>0:
    for i in range(0,n):
        s=input().split(" ")
        s[0],s[1],s[2]=s[0][:4]+"*"*7+s[0][11:],s[1][:1]+'*'+s[1][2:],s[2][:3]+'*'*4+s[2][7:]
        beijixing.append(s)
    print(beijixing)
else:
    print("ERROR")

思路是把字符串先切割，比较难搞的是13或者14位，位数不定，不能直接索引

不过没关系，python本来就内置[x:]，爱多少多少~

 

#

读入一个字典类型的字符串，反转其中键值对输出。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
即，读入字典key:value模式，输出value:key模式。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入格式:用户输入的字典格式的字符串，如果输入不正确，提示：输入错误。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输出格式‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬:给定字典d，按照print(d)方式输出‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
示例 1    
{"a": 1, "b": 2}
{1: 'a', 2: 'b'}

try:
    d=eval(input())
    b={}
    for k,v in d.items():
        b[v]=k
    print(b)
except:
    print("输入错误。")

第一个难点是把读入变成字典，直接读入的话是str，没想到用eval也可以

第二个难点是怎么判断输入有没有错误：try..except结构可以在上面的代码不能顺利运行时切掉，不用考虑奇奇怪怪的情况

 

函数系列

#

猴子第一天摘下若干个桃子，立即吃了一半，还不过瘾又多吃了一个，第二天将第一天剩下的桃子吃了一半又多吃了一个，以后每天以这个规律吃下去，到第十天再去吃时发现只剩下一个桃子，问猴子第一天摘了多少个桃子？‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
第10天有1只桃子 
第9天有4只桃子 
第8天有10只桃子 
第7天有22只桃子 
第6天有46只桃子 
第5天有94只桃子 
第4天有190只桃子 
第3天有382只桃子 
第2天有766只桃子 
第1天有1534只桃子

def find(x):
    ans=20030202
    if x==10:
        ans=1
    else:
        ans=(find(x+1)+1)*2
    print("第{}天有{}只桃子".format(x, ans))
    return ans
find(1)

or：

def peach(n):
    if n==10:
        return 1
    else:
        return peach(n+1)*2+2
for i in range(10,0,-1):
    print("第{}天有{}只桃子".format(i,peach(i)))

 

#

在两行中分别输入一个字符串s和整数n，定义一个函数将字符串s循环向右移动n位，n为负数时左移。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
若s为空字符串''，则不论n为多少，均输出空字符串''。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
如 s='123456'    n=3‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输出结果：456123

 

def f(s,n):
    lengh=len(s)
    n=(n+lengh)%lengh
    print(s[lengh-n:]+s[0:lengh-n])
s=input()
n=int(input())
f(s,n)

先注意到长度可能很长，可能出现周期，所以要mod（但是好像数据没有那么强，舍友没mod也过了

负数取模要加lengh

画图发现其实就是截取后面一段，然后拼接在前面

 

#

设计一个用二分法计算一个大于或等于 1 的实数 n 的平方根的函数sqrt_binary(n)，计算精度控制在计算结果的平方与输入的误差不大于1e-6。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
注：初始区间取[0,n]‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入一个实数 n（大于或等于1）‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
第一行输出用自己设计的函数计算得到的平方根‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
第二行输出用math库开平方函数计算得到的平方根

 

import math
def sqrt_binary(num):
    l,r,mid=0,num,num/2
    while(abs(mid**2-num)>1e-6):
        if mid*mid-num>0:
            r=mid
        else:
            l=mid
        mid=(l+r)/2
    return mid
num = float(input())
print(sqrt_binary(num))
print(math.sqrt(num))

 

#

输入一个正整数n，把数字n分解成不能再分解因子的乘法，比如：8=222， 10 = 2*5，而不是 8 = 2 * 4 这种可以再分解的。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入：12
输出：[2, 2, 3]

 

def defactor(N):      # 定义一个函数名称为defactor，意义是返回N的所有因子
    for i in range(2,N): #从2开始试试
        if N % i ==0: # 如果试到 i 是 N 的因子的话，就返回i的所有因子和N/i的所有因子 的列表
            return defactor(i)+defactor(int(N/i)) # 拼接 列表 + 列表，例如[2]+[3] 结果为[2, 3]
    else:
        return [N]    # 返回列表
print(defactor(int(input())))

复习到这里突然好奇正确性，稍微想了一下，如果是2,3的倍数，那么肯定先把2，3挑出来了，如果是4的倍数，肯定在前面就被2挑走了，有点埃氏筛法的意思

小坑点：哪怕是整除，N/i返回的也是一个float类型的值，要int，不然在range会报错

 

#

以整数 17 为随机数种子，获取用户输入整数 N 为长度，产生 3 个长度为 N 位的密码，密码的每位是一个数字。每个密码单独一行输出。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
生成密码采用 random.randint() 函数。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入：
3
输出：
634
524
926

 

import random
def genpwd(length):
    return random.randint(pow(10,length-1),pow(10,length))
n=int(input())
random.seed(17)
for i in range(3):
    print(genpwd(n))

随机种子固定后随机出来的数也固定了，因为随机是伪随机

range(n),只有一个参数表示循环n次

 

#

获得用户输入的两个与时间相关的字符串，两个时间用逗号分隔，每个时间字符串格式示例如下：2018年08月01日17点21分21秒。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

计算两个时间差的绝对值，输出相差的完整天数。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例1：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入："2018年10月10日17点18分20秒,2018年10月11日19点18分20秒"
输出："1"

import time
s=input().split(",")
t1,t2=time.strptime(s[0],'%Y年%m月%d日%H点%M分%S秒'),time.strptime(s[1],'%Y年%m月%d日%H点%M分%S秒')
print(int(abs(time.mktime(t1)-time.mktime(t2))/(24*60*60)))

把s切割了是常规操作

time库里面的strptime是把格式标准的日期表达式中的要素提取出来

输出是这样:

 

同理，如果是其他格式统一的日期，修改：'%Y年%m月%d日%H点%M分%S秒'即可

（我一直以为是时，卡了好一会，发现是点，一点都不正规好嘛！

然后是天数计算，time.mktime函数是把strptime元素转化成自1970年1月1日以来的秒数

取完整天数的话/一天有24*60*60秒即可

总结：

刚开始写完全不会，看了题解啥都会，这就是一道内置函数题呜呜

 

文件系列

#

下面是一个传感器采集数据文件 sensor-data.txt 的一部分：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
2018-02-28 01:03:16 19.3024 38.4629 45.08 2.68742 
2018-02-28 01:06:16 19.1652 38.8039 46.08 2.68742 
2018-02-28 01:06:46 19.175 38.8379 47.08 2.69964

其中，每行是一个读数，空格分隔多个含义，分别包括日期、时间、温度、湿度、光照和电压。其中，光照处于第 5 列。

请编写程序，统计并输出传感器采集数据中光照部分的最大值、最小值和平均值，所有值保留小数点后 2 位。

 

with open("sensor-data.txt","r",encoding="UTF-8") as f:
    s=f.read()
    s=s.split("\n")
    minn,maxn,sum=20030202,-20030202,0
    for i in s:
        a=i.split(" ")
        minn=min(minn,eval(a[4]))
        maxn=max(maxn,eval(a[4]))
        sum+=eval(a[4])
    print("最大值、最小值、平均值分别是:{:.2f},{:.2f},{:.2f}".format(maxn,minn,sum/len(s)))

记一下文件的读入写法，"with open("文件名","r",encoding="UTF-8") as 你想取的名字:

编码和读写方式也可以改，不过目前没怎么碰到

这种数据一行一行出现，每行再有若干列的，先用"\n"切割，再用“  ”切割

不然..不然一个字符一个字符的抠吗(狗头

 

#

分配学号

附件中学院代码和专业代码文件中的数据是每个学院的编号和专业的编号，学生名单文件中有若干学生信息，学生出现的顺序是他在班级中排名顺序，每行中的数据用逗号分隔，各数据依顺代表：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
学生姓名,学生性别,学院,专业名称,行政班（专业加班级号，例如经济1901）,入学年级。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
请为其增加学号，学号创建规则是：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
学生层次（本科为012）+入学年份后两位+学院代码+专业代码+班级号+班中排名。例如‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
012171985170110 表示本科生、2017年入学、文法学院、 编辑出版专业、1701班、排名为10的同学‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输入‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
第一行输入学生姓名‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
第二行输入班级‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输出‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬其学号和学生姓名,学生性别,学院,专业名称,行政班,入学年级信息，各项之间空格分隔‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
输出该班级所有同学的信息‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入：
段宁
金融gj1701
输出：    
012142172140101 段宁 女 国际学院 金融 金融gj1401 2014
012172172170101 罗愚 女 国际学院 金融 金融gj1701 2017
012172172170102 卢佳 女 国际学院 金融 金融gj1701 2017
012172172170103 张郁苓 女 国际学院 金融 金融gj1701 2017

 

with open('studentList.csv', 'r', encoding='utf-8') as a:
   student=a.read()
   stu=[]
   order={}
   for i in student.splitlines():
      a=i
      a=a.split(',')
      rank=0
      for j in student.splitlines():
         if a[4] in j:
            rank=rank+1
         if a[0] in j:
            break
      order.update({a[0]: rank})
      a.append(rank)
      stu.append(a)
with open('schoolCode.csv', 'r', encoding='utf-8') as b:
   school=b.read()
   sch={}
   for i in school.splitlines():
      s=i.split(',')
      sch[s[0]]=s[1]
with open('MajorCode.csv', 'r', encoding='utf-8') as c:
   major=c.read()
   maj={}
   for i in major.splitlines():
      s=i.split(',')
      maj[s[0]]=s[1]
def give(x):
   s="012"
   x=x.split(',')
   s=s+x[5][2]+x[5][3]+sch[x[2]]+maj[x[3]]+x[4][-4:]
   if order[x[0]]<10:
      s=s+'0'+str(order[x[0]])
   else:
      s=s+str(order[x[0]])
   print("{} {} {} {} {} {} {}".format(s,x[0],x[1],x[2],x[3],x[4],x[5]))
name=input()
cla=input()
for i in student.splitlines():
   if name in i:
      give(i)
      break
for i in student.splitlines():
   if name in i or cla not in i:
      continue
   else:
      give(i)

就是不停创建字典，求在班内排名，字符串拼接，大模拟题

 

#

附件是一个 CSV 文件，其中每个数据前后存在空格，请对其进行清洗，要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬
去掉每个数据前后空格，即数据之间仅用逗号 (,) 分割；
清洗后打印输出。
输入：" 1, 2, 3, 4, 5 'a', 'b' , 'c' , 'd','e' " 
输出：" 1,2,3,4,5 'a','b','c','d','e' "

with open('data.csv', 'r', encoding='utf-8') as f:
   s=f.read()
   s=s.replace(' ','')
   print(s)

一般来说这种清除空格的，也不知道到底有多少空格，具体分布在哪里

也不用考虑那么多，统统用replace函数换成""就可以

 

#

分析附件 data.txt 文件的字符分布，即每个字符对应的数量。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

按照 字符:数量 显示，每行一个结果，如果没有出现该字节则不显示输出，字符采用 Unicode 编码升序排列。

with open('data.txt', 'r', encoding='utf-8') as f:
   s=f.read()
   d={}
   for i in s:
      d[i]=d.get(i,0)+1
   d=sorted(d.items(),key=lambda e:e[0],reverse =False)
   for i in d:
      print("{}:{}".format(i[0],i[1]))

关键在于怎么排序

   d=sorted(d.items(),key=lambda e:e[0],reverse =False)

其中d.items()表示对d的每个队排序

key=lambda 这句好像是固定语法，看到的排序代码都有这句

e:e[0] ，其中e可以替换成另外的字母x,y,比如x:x[0]  y:y[0]都合法

e[0]表示以第一个元素为关键字

reverse表示是否反序，默认升序

 

#

研究生录取率（快帮我测测以后能不能被ubc录取

with open('admit2.csv', 'r', encoding='utf-8') as a:
    admit2,stu,j=a.read(),[],0
    for i in admit2.splitlines():
        if j==0:
            j=1
            continue
        elif j==1:
            s=i.split(',')
            stu.append(s)
def work1():
    cnttot=0
    cnt4=0
    for i in stu:
        if float(eval(i[8]))>=0.8:
            cnttot=cnttot+1
        if float(eval(i[3]))>=4:
            cnt4=cnt4+1
    print("Top University in >=80%:{:.2f}%".format(cnt4*100/cnttot))
def workR():
    cnt9,cntok9=0=0,0
    for i in stu:
        if float(eval(i[8]))>=0.9:
            cnt9=cnt9+1
        if i[5]=='1':
            cntok9=cntok9+1
    print("Reseach in >=90%:{:.2f}%".format(cntok9*100/cnt9))
    cnt7 ,cntok7= 0, 0
    for i in stu:
        if float(eval(i[8])) <= 0.7:
            cnt7 = cnt7 + 1
        if i[5] == '1':
            cntok7 = cntok7 + 1
    print("Reseach in <=70%:{:.2f}%".format(cntok7*100 / cnt7))
def work2():
     minn,maxn,sum,cut= 20030202,-20030202,0,0
        for i in stu:
            if float(i[8]) >= 0.8:
                 minn,maxn,sum,cnt= min(minn, float(eval(i[3]))),max(maxn, float(eval(i[3]))),sum + float(eval(i[3])),cnt + 1
        print("TOEFL Average Score:{:.2f}".format(sum/cnt))
        print("TOEFL Max Score:{:.2f}".format(maxn))
        print("TOEFL Min Score:{:.2f}".format(minn))
def work3():
    minn,maxn,sum,cut= 20030202,-20030202,0,0
    for i in stu:
        if float(eval(i[8])) >= 0.8:
            minn,maxn,sum,cnt= min(minn, float(eval(i[1]))),max(maxn, float(eval(i[1]))),sum + float(eval(i[1])),cnt + 1
    print("CGPA Average Score:{:.3f}".format(sum / cnt))
    print("CGPA Max Score:{:.3f}".format(maxn))
    print("CGPA Min Score:{:.3f}".format(minn))
n=input()
if n=='1':
    work1()
elif n=='Research':
    workR()
elif n=='2':
    work2()
elif n=='3':
    work3()
else:
    print('ERROR')

本质上还是一个大模拟，注意输出格式

然后第一部分为什么要设置j这个变量..因为一直报错打开csv文件发现第一行是 托福、gpa、录取结果啥的，不是学生信息，单独拎出来

 

运用python语言系列

#

画五角星

import turtle
turtle.pensize(7)
turtle.pencolor("yellow")
turtle.fillcolor("red")
turtle.begin_fill()
for i in range(5):
    turtle.left(72)#因为先left比较好计算角度，就稍微改了一下模板
    turtle.forward(91)
    turtle.right(144)
    turtle.forward(91)
turtle.end_fill()
turtle.hideturtle()   #隐藏画笔
turtle.done()        

 

#

画奥运五环

import turtle
coordA=(-110,0,110,-55,55)     #五个图起点坐标的x值
coordB=(-25,-25,-25,-75,-75)   #五个圆起点坐标的y值
a=('red','blue','green','yellow','black')
turtle.pensize(5)
for i in range(5):
    turtle.penup()
    turtle.goto(coordA[i],coordB[i]) #移动到第i个圆的起点坐标
    turtle.pendown()
    turtle.pencolor(a[i])
    turtle.circle(50,361)

小学生画画高级版

想位置，换颜色，画圆，下一个~

 

#

绘制：

 

 

import numpy as np
import matplotlib.pyplot as plt
n = 256
X = np.linspace(-np.pi,np.pi,n,endpoint=True) #产生一系列X值
Y = np.sin(2*X)+1                           #计算Y值
plt.plot(X,Y,color='blue',alpha=1)
plt.fill_between(X,1,Y,color='blue',alpha=0.3)

X = np.linspace(-np.pi,np.pi,n,endpoint=True) #产生一系列X值
Y = np.sin(2*X)                           #计算Y值
plt.plot(X,Y-1,color='blue',alpha=1)
plt.fill_between(X,-1,Y-1,where=-1>Y-1,color='red',alpha=.3)
plt.fill_between(X,-1,Y-1,where=-1<Y-1,color='blue',alpha=.3)
plt.show() 

plot是很常用的绘制函数，matlab里面也有，就不多说了

plt.fill_between(X,1,Y,color='blue',alpha=0.3)

 这个，这个：是填充特定区域的意思，对X管辖的所有区域，介于(1,Y)或者（Y,1）之间的区域，涂blue，透明度(常用alpha代表)是0.3

更高级的用法:plt.fill_between(X,-1,Y-1,where=-1>Y-1,color='red',alpha=.3)

如果虽然都介于这个范围，也可以用where=(条件)来分区域画

这个属于知道了就好..临时search临时用

 

#

import turtle
n,step = eval(input()),17
turtle.speed(0)
turtle.color("black")
# 先用比较大的size涂一遍边框
turtle.pensize(7)
turtle.goto(0, -step)
for i in range(4):
    turtle.forward(step * n)
    turtle.left(90)
# 填色
turtle.pensize(2)
for i in range(n):
    for j in range(n):
        turtle.penup()
        turtle.goto(i * step, j * step)
        turtle.pendown()
        turtle.begin_fill()
        if (i + j) % 2 == 0:
            turtle.color("white")
        else:
            turtle.color("black")
        for k in range(4):
            turtle.forward(step)
            turtle.right(90)
        turtle.end_fill()
turtle.done()

实现这个，先把框涂一圈，起点是（0,-step)，然后for循环四条边

注意小海龟初始是水平向右，left是逆时针转

接下来涂小格子，起点为(i*step,j*step),for循环一周，同时开fill，就能上色了

你说白色怎么办？白色就上白色吖，当然直接跳过也可以，我有点喜欢对称美

观察到白色方块的位置在(i+j)%2==0，判断一下就好

penup是指把笔提起来，没有落在纸上，不会画出痕迹

pendown是把笔落下去，可以画东西了