Python3-1 流程控制（分支結構）
一、判斷題
1-1.在 if...elif...else 的多分支語句中只會執行一個語句塊。T
使用 if - elif - else 語句，有兩個判斷條件，如果 if 后的條件成立(為 True)，則執行 if 判斷語句后帶縮進的代碼邏輯. 如果 elif 后的條件成功(為 True)，則執行 elif 判斷語句后帶縮進的代碼邏輯，否則執行 else 后帶縮進的代碼邏輯。 值得注意的是，if - elif - else 語句中，僅有一個條件成立后，就會退出當前整個判斷語句，簡單來說，這三條判斷路徑，只會走其中一條。
條件表達式
age = 12
if age < 18:
s = 'minor'
else:
s = 'adult'
可以簡化為：
s = 'minor' if age < 18 else 'adult'
二、單選題
2-1.下面程序的運行結果是什么？ 1
s=0
a,b=1,2 #a=1;b=2
if a>0: # true 退出循環
s=s+1
elif b>0:
s=s+1
print(s)
三、編程題
7-1 sdut-sel-10 直角坐標系象限判斷
X是一個喜歡數學的小孩，現在剛剛學了坐標系。象限划分示意圖如下：
他想知道點(X,Y)在第幾象限內。輸入數據保證點不在坐標軸及原點上。
輸入格式:
多組輸入。
每組輸入兩個整數X，Y，代表點（X，Y），中間用空格隔開。
輸出格式:
輸出一個整數代表點在第幾象限內。
輸入樣例:
在這里給出一組輸入。例如：
2 3
-2 -3
輸出樣例:
在這里給出相應的輸出。例如：
1
3
結尾無空行
while 1: # 多組輸入
try:
x,y=map(int,input().split())
if x>0 and y>0:
print(1)
elif x>0 and y<0:
print(4)
elif x<0 and y>0:
print(2)
else:
print(3)
except:
break
7-2 sdut-計算分段函數
計算下列分段函數g(x)的值：
輸入格式:
在一行中輸入實數x。
輸出格式:
在一行中按“g(x) = result”的格式輸出，其中x與result都保留3位小數。
輸入樣例1:
500
結尾無空行
輸出樣例1:
g(500.000) = 0.001
結尾無空行
輸入樣例2:
0
結尾無空行
輸出樣例2:
g(0.000) = 0.000
結尾無空行
x=float(input()) # 注意轉化
if x==0:
re=0
print("g({:.3f}) = {:.3f}".format(x,re)) #注意輸出格式
else:
re=1/(2*x)
print("g({:.3f}) = {:.3f}".format(x,re))
7-3 sdut-sel-2 汽車超速罰款（選擇結構）
許多社區都有“雷達”標志，告訴司機他們的速度是多少，希望他們能夠慢下來。
你將輸出一個“雷達”標志的信息，根據司機駕駛車速的情況向他（她）顯示信息。
在此，鄭重地提醒各位小伙伴們：在道路上駕駛機動車一定要遵守交通規則，注意交通安全！道路千萬條，安全第一條！！！
輸入格式:
在一行內輸入2個整數。第一個表示速度的限制，第二個表示司機的開車速度。
輸出格式:
如果司機沒有超速，輸出應該是：Congratulations, you are within the speed limit!
如果司機超速行駛，輸出為：You are speeding and your fine is F.（F為上表中描述的罰款數額）
輸入樣例1:
40 39
結尾無空行
輸出樣例1:
Congratulations, you are within the speed limit!
結尾無空行
輸入樣例2:
100 131
結尾無空行
輸出樣例2:
You are speeding and your fine is 500.
結尾無空行
輸入樣例3:
100 120
結尾無空行
輸出樣例3:
You are speeding and your fine is 100.
結尾無空行
x,y=map(int,input().split())
a=x-y
b=abs(a)
if a>=0:
print("Congratulations, you are within the speed limit!",end='')
else:
if b>=1 and b<=20:
print("You are speeding and your fine is {}.".format(100),end='')
elif b>=21 and b<=30:
print("You are speeding and your fine is {}.".format(270),end='')
else:
print("You are speeding and your fine is {}.".format(500),end='')
注意帶上標點，俺因為個句號沒提交上
7-4 sdut-運輸計費問題
某運輸公司對用戶計算運費。路程（S）越遠，每公里運費越低。標准如下：
其中，基本運輸費用為：每噸每公里1元。
現請你幫助該運輸公司設計計費程序，計算運輸費用。
輸入格式:
每次運輸的載重（噸）、里程（公里），中間有一個空格。
輸出格式:
輸出其運輸費用，精確到元。
輸入樣例1:
1 200
結尾無空行
輸出樣例1:
200
結尾無空行
輸入樣例2:
10 2500
輸出樣例2:
22500
結尾無空行
錯誤提交：
t,s=map(int,input().split())
al=t*s
if s<250:
print(al,end='')
elif s>=250 and s<500:
al=al*0.98
print(int(al),end='')
elif s >= 500 and s < 1000:
al = al * 0.95
print(int(al),end='')
elif s>=1000 and s<2000:
al=al*0.92
print(int(al),end='')
elif s>=2000 and s<3000:
al=al*0.90
print(int(al),end='')
else:
al = al * 0.85
print(int(al),end='')
提交之后只有第一個if語句是正確的，但是其他的都顯示非零返回，
t,s=map(float,input().split())
al=t*s
if s<250:
print(round(al))
elif 250<= s <500:
print(round(al*0.98))
elif 500<= s < 1000:
print(round(al * 0.95))
elif 1000<= s <2000:
print(round(al*0.92))
elif 2000<= s <3000:
print(round(al*0.90))
else:
print(int(al * 0.85))
在上面的函數提交中，使用int函數和round函數結果都是一樣的，都會對浮點數進行四舍五入，那為什么上一個提交會顯示非零返回呢？
猛的一看 int（） round() math.floor() 這幾個函數函數好像做的是同一件事情，很容易將他們弄混，下面是他們的一些不同之處：
int（）函數直接截去小數部分
floor（） 得到最接近原數但是小於原數的部分
round()得到最接近原數的整數（返回為浮點類型）
# round()
import math
print(round(80.45799613235,2))
print(round(80.45799613235,4))
# int
print(int(80.955414245))
# floor
print(math.floor(80.999))
7-5 sdut-階梯電價
為了提倡居民節約用電，某省電力公司執行“階梯電價”，安裝一戶一表的居民用戶電價分為兩個“階梯”：
月用電量50千瓦時（含50千瓦時）以內的，電價為0.53元/千瓦時；
超過50千瓦時的，超出部分的用電量，電價上調 X 元/千瓦時。（不是上調為）
請編寫程序計算電費。
輸入格式:
在一行中，輸入某用戶的月用電量（單位：千瓦時）和電價上調的X值（單位：元），中間用空格分開。
輸出格式:
在一行中輸出該用戶應支付的電費（元），結果保留兩位小數，格式如：“cost=應付電費值”。
輸入樣例1:
10 0.05
結尾無空行
輸出樣例1:
cost=5.30
結尾無空行
輸入樣例2:
100 0.05
結尾無空行
輸出樣例2:
cost=55.50
結尾無空行
輸入樣例3:
-100 0.05
結尾無空行
輸出樣例2:
cost=0.00
結尾無空行
a,b=map(float,input().split())
if a>50:
print("cost={:.2f}".format(50*0.53+(a-50)*(b+0.53)),end='')
elif 0<a<=50:
print("cost={:.2f}".format(a*0.53),end='')
else:
print("cost={:.2f}".format(abs(a*0)),end='')
在這個題中我知道還有-0.00這個玩意兒，在計算機語言中輸出的數字都是嚴格按照程序計算的，而不是符合我們平時的邏輯規則的，不是現實的數學里沒有-0，計算機語言里就沒有的。
7-6 sdut-分段計算居民水費
為鼓勵居民節約用水，自來水公司采取按用水量階梯式計價的辦法，居民應交水費y（元）與月用水量x（噸）相關，請編寫程序實現水費的計算。
（1）當x不超過15噸時，y=4x/3；
（2）超過后，y=2.5x−17.5。
輸入格式:
在一行中給出非負實數x。
輸出格式:
在一行輸出應交的水費，精確到小數點后2位。
輸入樣例1:
12
結尾無空行
輸出樣例1:
16.00
結尾無空行
輸入樣例2:
16
結尾無空行
輸出樣例2:
22.50
結尾無空行
x=float(input())
if 0<x<15:
print("{:.2f}".format((4*x)/3))
else:
print("{:.2f}".format(2.5*x-17.5))
Python3-2 流程控制（循環結構）
一、判斷題
1-1.在Python循環中，continue語句的作用是：退出循環的當前迭代，開啟下一輪循環。T
Python continue 語句跳出本次循環，而break跳出整個循環。
continue 語句用來告訴Python跳過當前循環的剩余語句，然后繼續進行下一輪循環。
continue語句用在while和for循環中。
1-2.在Python循環中，對於帶有else子句的循環，如果因為執行了break語句而退出的話，會執行else子句的代碼。F
Python主要有for循環和while循環兩種形式的循環結構，多個循環可以嵌套使用，並且還經常和選擇結構嵌套使用。while循環一般用於循環次數難以提前確定的情況，當然也可以用於循環次數確定的情況；for循環一般用於循環次數可以提前確定的情況，尤其適用於枚舉或遍歷序列或迭代對象中元素的場合。對於帶有else子句的循環結構，如果循環因為條件表達式不成立或序列遍歷結束而自然結束時則執行else結構中的語句，如果循環是因為執行了break語句而導致循環提前結束則不會執行else中的語句。
1-3.在Python循環中，使用for i in range(10) 和 for i in range(10,20)，控制循環次數是一樣的。T
print(list(range(10)))
print(list(range(10,20)))
'''
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
'''
range()函數左閉右開
1-5.下面程序輸入5，輸出是1。F
a=[3,5,7,11,13,16,21,24,28,32,36,40,46]
x = int(input())
found = -1
left = 0 #第一個元素下標
right = len(a)-1 #最后一個元素下標
while left<right:
mid = (left + right) // 2
if a[mid] > x:
right = mid - 1
elif a[mid] < x:
left = mid + 1
else: # a[mid]==x
found = mid
break
print(found)
輸入5-->mid=(0+12)//2=6,a[mid]=21-->21>5,right=5,跳出循環，此時found=-1，輸出found
實際上是二分查找：
二、單選題
2-3.下面程序中語句print(i*j)共執行了______15_______次。
for i in range(5):
for j in range(2,5):
print(i*j)
外層的循環執行了五次，里層的循環執行了5*3次，每次外面的循環執行一次，里層的循環就會執行三次。
2-4.下面那個語句不能完成1到10的累加功能? total初值為0。A
A.
for i in range(10,0):
total+=i
B.
for i in range(1,11):
total+=i
C.
for i in range(10,0,-1):
total+=i
D.
for i in (10,9,8,7,6,5,4,3,2,1):
total+=i
rang(10,0)里面什么也沒有，是空的，但是range(10,0,-1)是倒序的，[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]，注意左閉右開，和D中一樣。
2-5.下面程序輸入1時，輸出是什么？。是素數
num=int(input())
a=num-1
while a>1:
if num % a == 0:
print("不是素數")
break
a=a-1
else:
print("是素數")
輸入1，a=0，不符合循環條件，所以執行else語句，輸出是素數。
2-6.Python中，列表推導式在邏輯上等價於（ 循環語句）。
列表推導式可以使用非常簡潔的方式對列表或其他可迭代對象的元素進行遍歷和過濾，快速生成滿足特定需求的列表，代碼具有非常強的可讀性，是Python程序開發時應用最多的技術之一。Python的內部實現對列表推導式做了大量優化，可以保證很快的運行速度，也是推薦使用的一種技術。列表推導式的語法形式為：
[表達式 for 變量 in 序列或迭代對象 if 條件表達式]
列表推導式在邏輯上等價於一個循環語句，只是形式上更加簡潔。
2-7.a=[2,3,4,1,6,9,8],執⾏b = [index for index, value in enumerate(a) if value > 3]后，b=( )。
D.[2,4,5,6]
列表推導式，最外層的循環是下標、數值在由列表a構成的索引中，條件是數值大於三，然后返回下標。
2-9.有如下代碼：
i = sum = 0
while i <= 4:
sum += i
i = i+1
print(sum)
以上代碼輸出的結果是？10
i從0開始，然后進入循環，sum=0,i=1-->sum=1,i=2-->sum=3,i=3-->sum=6,i=4-->sum=10,i=5 exit.
三、填空題
4-1
下面程序運行后輸出是 150
l3=[i+j for i in range(1,6) for j in range(1,6)]
print(sum(l3))
雙層循環，1+1，1+2，1+3，1+4，1+5；2+1...依次類推
4-2
下面程序運行后輸出是 2
l3=[[(i,j) for i in range(1,6)] for j in range(1,6)]
print(l3[2][1][0])
看下面的代碼：
l3=[[(i,j) for i in range(1,6)] for j in range(1,6)]
print(l3)
'''
[(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)] [(1, 2), (2, 2), (3, 2), (4, 2), (5, 2)] [(1, 3), (2, 3), (3, 3), (4, 3), (5, 3)] [(1, 4), (2, 4), (3, 4), (4, 4), (5, 4)] [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)]
'''
上面是以元組組成的五個列表，先執行中括號中的循環，然后將外面的循環作為外層循環。
l3=[[[(i,j) for i in range(1,6)] for j in range(1,6)]]
print(l3)
'''
[[(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)], [(1, 2), (2, 2), (3, 2), (4, 2), (5, 2)], [(1, 3), (2, 3), (3, 3), (4, 3), (5, 3)], [(1, 4), (2, 4), (3, 4), (4, 4), (5, 4)], [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)]]
'''
再加一個中括號就是嵌套列表。
4-3
下面程序的輸出是 7
row=[0]*3
data=[row,row,row]
data[2][2]=7
print(data[0][2])
因為在data列表的每個元素中都是row，所以當其中一個元素更改，也就是row被更改，其余的元素也會跟着變。
row=[0]*3
print(row)
data=[row,row,row]
print(data)
data[2][2]=7
print(data)
print(data[0][2])
'''
[0, 0, 0]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 7], [0, 0, 7], [0, 0, 7]]
7
'''
4-4
下面程序運行后，位於最后一行的最后一個數字是
for i in range(1,5):
j=0
while j<i:
print(j,end=" ")
j+=1
print()
是一個雙層循環，一個四行，一行需要j<i個，所以最后一個是3。
4-5
下面程序運行后，倒數第二行打印出 1xxx2xxx
i=5
while i>=1:
num=1
for j in range(1,i+1):
print(num,end="xxx")
num*=2
print()
i-=1
最外面的while循環決定一共五行，第二個循環決定行數，
四、編程題
7-8 sdut-入門-4 A+B for Input-Output Practice (IV)
你的任務是計算一些整數的和。
輸入格式:
輸入包含多個測試用例。
每個測試用例包含一個整數N，然后在同一行中跟隨N個整數。以0開始的測試用例終止輸入，並且這個測試用例不被處理。
輸出格式:
對於每一組輸入整數，您應該在一行中輸出它們的和，輸入的每一行都有一行輸出。
輸入樣例:
在這里給出一組輸入。例如：
4 1 2 3 4
5 1 2 3 4 5
0
輸出樣例:
在這里給出相應的輸出。例如：
10
15
while 1:
try:
ls=[eval(x) for x in input().split()]
if ls[0]==0:
break
s=0
for i in range(0,ls[0]):
i+=1
s+=ls[i]
print(s)
except:
break
7-10 sdut-入門-6 A+B for Input-Output Practice (VI)
你的任務是計算一些整數的和。
輸入格式:
輸入包含多個測試用例，一個用例一行。每一種情況都以一個整數N開始，然后在同一行中跟隨N個整數。
輸出格式:
對於每個測試用例，您應該在一行中輸出N個整數的和，並在輸入的每一行中輸出一行。。
輸入樣例:
在這里給出一組輸入。例如：
4 1 2 3 4
5 1 2 3 4 5
輸出樣例:
在這里給出相應的輸出。例如：
10
15
# 錯誤答案（暫時沒找錯誤）：
while 1:
try:
ls=[eval(x) for x in input().split()]
s=0
for i in range(1,ls[0]+1):
s+=ls[i]
print(s)
except:
break
7-18 sdut-水仙花數
水仙花數是指一個N位正整數（N≥3），它的每個位上的數字的N次冪之和等於它本身。 例如：153=1×1×1+5×5×5+3×3×3。
請計算所有N位水仙花數。
輸入格式:
在一行內，給出一個正整數N（3≤N≤5）。
輸出格式:
按遞增順序輸出所有N位水仙花數，每個數字占一行。
輸入樣例:
在這里給出一組輸入。例如：
3
結尾無空行
輸出樣例:
在這里給出相應的輸出。例如：
153
370
371
407
結尾無空行
錯誤1：
def f(a, n):
a=str(a)
l = [eval(x) for x in a]
s = 0
for x in l:
s += x ** n
if s == int(a):
return a
else:
return
n = int(input())
ls = [i for i in range(10 ** (n - 1), eval('9' * n) + 1)]
for x in ls:
if f(x, n):
print(x)
輸入5的時候運行超時，在pc運行肉眼可見的慢，沒找到改進的方法，但是找到兩個投機取巧的方法：
n = int(input())
ls = [i for i in range(10 ** (n - 1), eval('9' * n) + 1)]
s=0
lst=list
for x in ls:
a=x//10000
b=x//1000%10
d=x//100%10
e=x//10%10
f=x%10
s=a**n+b**n+f**n+d**n+e**n
if s==x:
print(x)
或者更直接一點，就是輸入3，4，5的時候分別等於哪些數，輸出就行
找到了更簡單的方法：
# 正確答案：
n = input()
n = int(n)
s = 10 ** (n - 1)
e = 10 ** n
for i in range(s, e):
if i==sum([int(j)**n for j in str(i)]):
print(i)
這是對最上面的錯誤答案的簡化了，主要是忘了最簡單的求和函數，把位數直接從字符中分離出來然后變成整數，所以說多交流也是很好的。（碎碎念不用理）
7-19 sdut-最大公約數和最小公倍數
給定2個正整數，求它們的最大公約數和最小公倍數，並輸出。
輸入格式:
輸入有若干組。
每組數據，在一行中給出兩個正整數M和N（≤1000），中間有1個空格。
輸出格式:
對於每組輸入，在一行中順序輸出M和N的最大公約數和最小公倍數，兩數字間以1個空格分隔。
輸入樣例:
18 12
20 15
39 26
5 76
45 25
1993 343結尾無空行
輸出樣例:
在這里給出相應的輸出。例如：
6 36
5 60
13 78
1 380
5 225
1 683599結尾無空行
while 1:
try:
a, b = map(int, input().split())
c=min(a,b)
for i in range(1, c+1):
if b % i == 0 and a % i == 0:
ma = i
t = a * b / ma
print("{} {}".format(ma,int(t)))
except:
break
上幾次提交的時候被找到的答案完全帶跑了，把range的范圍定義子啊2--c+1，但是最大公約數是一的狀況就被忽略掉了，我完全沒有想過把范圍改改，加了很多不必要的條件，還是錯的，但是只要改一下范圍就可以了，有時候過於相信答案也是非常不行的，最起碼自己得有主見，得自信一點兒。（碎碎念，請忽略）
7-2 sdut-求π的近似值
用公式求π的近似值： 
當求和項小於誤差時，求和結束。
輸入格式:
在一行輸入誤差范圍。
輸出格式:
在一行輸出π的近似值（保留6位小數）。
輸入樣例:
在這里給出一組輸入。例如：
0.00000001
結尾無空行
輸出樣例:
3.141497
結尾無空行
import math
def fun(m):
suma=0
count=1
c=1
while count>m:
count=1.0/math.pow(c,2)
suma+=count
c+=1
return math.sqrt(suma*6)
m=float(input())
print("{:.6f}".format(fun(m)))
這個題的意思是求和項的最后一項小於輸入的數時，就輸出相應的值。
這里自定義了函數方法，循環的條件就是求和項的最后一項大於輸入值，求和項的最后一項單獨拿出來，然后執行求和，注意輸出的和不是要求的值，需要在轉化一布。
7-3 sdut-求誤差小於輸入值的e的近似值
7-3 sdut-求誤差小於輸入值的e的近似值 (10 分)
自然常數e可以用級數1+1/1!+1/2!+⋯+1/n!來近似計算。ei代表前i項求和。輸入誤差范圍error，當 
，則表示e的近似值滿足誤差范圍。
輸入格式:
在一行輸入誤差范圍，誤差小於等於0.01。
輸出格式:
在一行輸出e的近似值（保留6位小數）。
輸入樣例1:
0.01
結尾無空行
輸出樣例1:
2.716667
結尾無空行
輸入樣例2:
0.01
結尾無空行
輸出樣例2:
2.716667
結尾無空行
n=float(input())
def e(n):
m=1
s=1
for i in range(1,n):
m*=i
s+=1/m
return s
cnt=1
while(True):
if abs(e(cnt)-e(cnt+1))<n:
print("{:.6f}".format(e(cnt+1)))
break
else:
cnt+=1
這個題和上一個題不同的是，這次是求和項的最后兩項的差小於輸入的數即為應該輸出的正確答案。
和上一個題的思路有些相同，需要把最后兩項拿出來，每一項的運算模式都是一樣的，所以寫成了函數方法，然后最后兩項調用函數方法做差，在循環里實現函數這個求和序列。
7-4 求6+66+666+6666+66666。
輸入2個正整數m和n。 求和：m+mm+mmm+mmmm+ ... +mmm……mmm（n個m)
例如：輸入：6和5，則求和：6+66+666+6666+66666 並輸出。
輸入格式:
第一行表示正整數m；（0<=m<=9）
第二行輸入正整數n。（0<=m<=1000）
輸出格式:
在一行內輸出按照要求計算的累加和。
輸入樣例:
在這里給出一組輸入。例如：
6
2結尾無空行
輸出樣例:
在這里給出相應的輸出。例如：
72
結尾無空行
from functools import reduce
m=input()
n=int(input())
def drop(x,y):
return x+y
ls=[eval(m*i) for i in range(1,n+1)]
print(reduce(drop,ls))
上面的求和每一項都是相同的，所以運用字符串相乘更加簡單一些，求和那里整的難了，下面是簡化了的程序：
m=input()
n=int(input())
ls=[eval(m*i) for i in range(1,n+1)]
print(sum(ls))
7-13 sdut-九九乘法表
九九乘法表是數學學習的基礎，今天我們就來看看乘法表的相關問題。《九九乘法歌訣》，又常稱為“小九九”,如下圖所示。你的任務是寫一個程序，對於給定的一個正整數 n ，輸出“九九乘法表”的前 n 行。例如，輸入 n 為 9，你的程序的輸出將為下圖：
輸入格式:
輸入包含多組測試數據，以 EOF 結束。每組測試數據只包含一個正整數 n (0 < n < 10)。
輸出格式:
對於每組測試數據，輸出上圖所示“九九乘法表”的前 n 行。
輸入樣例:
2
3
結尾無空行
輸出樣例:
在這里給出相應的輸出。例如：
1*1=1
1*2=2 2*2=4
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
結尾無空行
以下是錯誤錯誤代碼：
while 1:
try:
n = int(input())
if 0 < n < 10:
for i in range(1, n + 1):
for j in range(1, i):
print("%d*%d=%d" % (j, i, i * j), end=" ")
print("%d*%d=%d" % (i, i, i * i))
else:
break
except:
break
在PC上運行沒有錯誤，但是在pta上提交顯示部分錯誤，有答案不正確。
7-23 sdut-單鏈表數據的拆分
輸入N個整數順序建立一個單鏈表，將該單鏈表拆分成兩個子鏈表：
第一個子鏈表存放了所有的偶數，第二個子鏈表存放了所有的奇數。
兩個子鏈表中數據的相對次序與原鏈表一致。
輸入格式:
第一行輸入整數N;
第二行依次輸入N個整數，中間用空格隔開。
輸出格式:
第1行分別輸出偶數鏈表與奇數鏈表的元素個數；
第2行依次輸出偶數子鏈表的所有數據；
第3行依次輸出奇數子鏈表的所有數據。
輸入樣例:
10
1 3 22 8 15 999 9 44 6 1001
結尾無空行
輸出樣例:
4 6
22 8 44 6
1 3 15 999 9 1001
結尾無空行
n = int(input())
ls = [eval(x) for x in input().split()]
l1 = [i for i in ls if i % 2 == 0]
l3=' '.join(str(i) for i in ls if int(i)%2==0)
l2 = [i for i in ls if i % 2 == 1]
l4=' '.join(str(i) for i in ls if int(i)%2==1)
print(len(l1), len(l2))
print(l3)
print(l4)
想直接輸出一個列表但是不想用循環，所以直接用了字符串。
偷懶，請大家不要學【狗頭】
Python4 字符串
一、判斷題
1-1
當輸入是10.0時，下面程序的輸出是f(10.0) = 0.1。F
x=int(input())
if x==0:
result=0
else:
result=1/x
print('f({0:.1f}) = {1:.1f}'.format(x,result))
這就涉及到了int函數的應用了:
class int(x,base=10) #x是數字或者字符串，base是進制數，默認是十進制，返回整型數據
int() #無參數時返回0
int(3.6) #3
int('12',16) #如果是帶參數base的話，參數要用字符串形式，因為輸入純數字的時候int()的作用是取整
int("3.5",8) # 報錯，str必須為整數
int("1010",2) # 1010是正確的二進制格式
總結：int()對純數字的作用是取整，進行進制轉換必須用字符串類型，而且字符串中的數字為整數，base為2時進行的是將前面的二進制轉換為十進制，其余base則是將前面的字符串轉換成對應的進制數。
1-2
下面程序中： F
m=int(input())
print('{:^5}'.format('*'*m))
print('{:^m}'.format('*'*m))
若輸入是5，則輸出是：
*****
*****
這又涉及到format函數的用法了：
-
format函數格式化輸出：
-
位置：
print("{} {}".format("123","456")) # 默認順序輸出 print("{1} {0}".format("123","456")) # 顛倒位置 print("{1} {0} {0}".format("123","456")) # 重復輸出 ''' 輸出結果： 123 456 456 123 456 123 123 ''' -
設置參數：
print("名字:{name},年齡:{age}".format(name="sss",age="18")) # 通過字典 site={"name":"sss","age":"19"} print("名字：{name},年齡：{age}".format(**site)) #通過列表索引 list1=["sss","14"] print("名字：{0[0]},年齡：{0[1]}".format(list1)) #{0[0]},第一個0代表format中的第一個列表，第二個0代表列表中的第一個參數 ''' 輸出結果： 名字:sss,年齡:18 名字：sss,年齡：19 名字：sss,年齡：14 ''' -
類方法：
class A(object): #類 def __init__(self,value): # 構造方法，value初始化 self.value=value A_value=A(45) # 初始化value print("value的值為{0.value}".format(A_value)) # 輸出結果：value的值為45 -
數字格式化：
print("{:.2f}".format(3.1415926)) # 3.14 print("{:.3f}".format(3.456897)) # 3.457數字 格式 輸出 描述 3.1415926 {:.2f} 3.14 保留小數點后兩位 3.1415926 {:+.2f} +3.14 帶符號保留小數點后兩位 -1 {:+.2f} -1.00 帶符號保留小數點后兩位 2.71828 {:.0f} 3 不帶小數 5 {:0>2d} 05 數字補零 (填充左邊, 寬度為2) 5 {:x<4d} 5xxx 數字補x (填充右邊, 寬度為4) 10 {:x<4d} 10xx 數字補x (填充右邊, 寬度為4) 1000000 {:,} 1,000,000 以逗號分隔的數字格式 0.25 {:.2%} 25.00% 百分比格式 1000000000 {:.2e} 1.00e+09 指數記法 13 {:>10d} 13 右對齊 (默認, 寬度為10) 13 {:<10d} 13 左對齊 (寬度為10) 13 {:^10d} 13 中間對齊 (寬度為10) 11 '{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)1011 11 13 b 0xb 0XB進制 ^, <, > 分別是居中、左對齊、右對齊，后面帶寬度， : 號后面帶填充的字符，只能是一個字符，不指定則默認是用空格填充。
+ 表示在正數前顯示 +，負數前顯示 -； （空格）表示在正數前加空格
b、d、o、x 分別是二進制、十進制、八進制、十六進制。
此外還可以用{}來充當轉義符：
print("{0}對應的第一個位置是{{0}}".format("123456")) #第一個大括號中的0可以省略 print("{1}對應的第一個位置是{{1}}".format("123456","absdf")) # 輸出結果：123456對應的第一個位置是{0} # 輸出結果：absdf對應的第一個位置是{1}
-
1-3
下面程序中， F
print("這是字符串輸出格式{:5s}".format("123"))
執行后，輸出是： 這是字符串輸出格式□□123。 □表示空格。
1-4
下面程序中，T
print("這是字符串輸出格式{:5d}".format(123))
執行后，輸出是： 這是字符串輸出格式□□123。 □表示空格。
在utf-8中漢字占3個字節，數字字母占1個字節，在format查看字符串所占的字節數要用到encode函數。
1-6
可以通過[]來訪問字符串的某個字符，也可以將它修改成其他字符。F
字符串一旦被創建就不可以被修改，一旦“修改”就變成新的對象了。
1-8
print("12 "*3==" ".join(["12","12","12"])) 的輸出是True。 F
a="12 "*3
b=" ".join(["12","12","12"])
print(a)
print(b)
print(type(a),type(b))
print(a==b)
print(a is b)
'''
12 12 12
12 12 12
<class 'str'> <class 'str'>
False
False
'''
# 這樣看不是很明顯，把它們全部變成列表：
print(list(a),list(b))
'''
['1', '2', ' ', '1', '2', ' ', '1', '2', ' ']
['1', '2', ' ', '1', '2', ' ', '1', '2']
'''
# 用*多了一個空格，但是join函數沒有，join是split的逆函數。
1-9
語句print("輸出結果是{:8s}".format("this"))的輸出是：輸出結果是 :□□□□this。 □表示空格。 F
輸出默認為左對齊，這樣看更直觀一些：
print("輸出結果是{:m>8s}".format("this"))
print("輸出結果是{:a<8s}".format("this"))
print("輸出結果是{:8s}".format("this"))
'''
輸出結果是mmmmthis
輸出結果是thisaaaa
輸出結果是this
'''
1-10
語句print("輸出結果是{:8d}".format(1234))的輸出是：輸出結果是 1234□□□□。 □表示空格。 F
print("int占八位：{:8d}".format(1234)) # 默認右對齊
print("字符串占八位：{:8s}".format("1234")) # 默認左對齊
print("浮點數占八位：{:8f}".format(1.123)) # 默認左對齊后面補0
print("浮點數占八位保留兩位：{:8.2f}".format(1.234)) # 默認右對齊
'''
int占八位： 1234
字符串占八位：1234
浮點數占八位：1.123000
浮點數占八位保留兩位： 1.23
'''
1-12
下面程序的輸入是5，輸出是否正確? F
m=int(input())
print('{:^5}'.format('*'*m))
print('{:^m}'.format('*'*m))
輸出結果：
*****
*****
修改的代碼：
m=int(input())
print('{:^5}'.format('*'*m))
print('{:^{}}'.format('*'*m,m))
1-13
在python中，字符串屬於不可變有序序列。 T
1-14
Python可以利用字符串方法replace()對字符串對象進行原地修改。 F
這里理解為對原對象進行修改，就是對象可變，不知道對不對，待定
1-15
已知x為非空字符串，那么表達式 ''.join(x.split()) == x 的值一定為True。 T
二、單選題
2-7
假設s和t都是字符串變量，並且t不是s的子串，那么表達式s.find(t)的值是？ -1
用到了find函數，找不到返回的是-1
2-8
假設s和t都是字符串變量，並且t不是s的子串，那么表達式s.index(t)的值是？
報異常
s="123sdfaa79**"
print(s.index('t'))
'''
ValueError: substring not found
'''
2-9
表達式max('1111', '222', '33', '4')的值是？ 4
關於max函數怎么比較字符串的大小，是取決於字符串的第一個字符的ASCII碼：
print(max('14', '222', '33', '4'))
print(ord('4'),ord('1'))
'''
4
52 49
'''
關於怎么查字符串的ASCII碼，可以應用ord函數。
三、多選題
3-5
欲打印出信息：“我叫小明，今年 10 歲! ”（不包括雙引號），可使用的語句包括： ABCD
(2分)
A.
print ("我叫%s,今年%d歲!" % ('小明', 10))
B.
class Student: # 類
def __init__(self, name,age): # 初始化
self.name = name # 形參轉實參
self.age=age
stu = Student('小明', 10) # 調用類
print('我叫{0.name},今年{0.age}歲!'.format(stu))
C.
dct={'name':'小明','age':10}
print('我叫{name},今年{age}歲!'.format(**dct)) # 字典
D.
lst=['小明', 10]
print('我叫{0[0]},今年{0[1]}歲!'.format(lst)) # 列表的格式化輸出
四、編程題
7-1 sdut-oop-8 分數四則運算（類和對象）
定義類Fraction，在其中定義屬性:numerator和denominator，分別表示分子和分母。
然定再定義兩個分數的加、減、乘、除運算的方法。
在主類中輸入2個分數，計算它們的四則運算結果。
提示：若用Python語言來實現，不必自行創建類，可直接使用 fractions模塊處理分數的表示與運算。
輸入格式:
第一行是整數N，表示待進行分數四則運算式子的數量。接下來包含N行輸入。
每行數據是一個字符串，格式是"a/boc/d"。
其中a, b, c, d為數字（每個數字保證在int類型范圍內，為正數並且不存在正號）。o是運算符"+"或者"-","*",""。
輸出格式:
對於每一行分數四則運算，輸出一行計算結果。
注意：結果應符合書寫習慣，沒有多余的符號、分子、分母，並且化簡至最簡分數形式。
輸入樣例:
5
1/100+3/100
1/4-1/2
1/3-1/3
1/2*2/1
1/2\1/2結尾無空行
輸出樣例:
1/25
-1/4
0
1
1結尾無空行
from fractions import Fraction
n=int(input())
while n:
a = input()
if a.find('+')!=-1:
ls = a.split('+')
print(Fraction(ls[0]) + Fraction(ls[1]))
elif a.find('-')!=-1:
ls = a.split('-')
print(Fraction(ls[0]) - Fraction(ls[1]))
elif a.find('*')!=-1:
ls = a.split('*')
print(Fraction(ls[0]) * Fraction(ls[1]))
else:
ls = a.split('\\')
print(Fraction(ls[0]) / Fraction(ls[1]))
n-=1
做這個題的時候簡直了，首先是我忘了find找不到要找的字符串的時候返回的是-1，而返回的-1布爾值又是true，所以只能執行第一個if語句，然后又是把a放在了最外面，就這個錯誤阻擋我往下做，然后我又嘗試了好幾個不同的方法，最后還是覺得第一個不錯，又回來改。
7-6 sdut-逆序的N位數
讀入一個正整數（前后可能有空白字符—空格或者Tab字符），位數不限，然后輸出按位逆序的數字。
注意：當輸入的數字含有結尾的0時，輸出不應帶有前導的0。比如輸入700，輸出7。
輸入格式:
輸入一個正整數。
輸出格式:
輸出按位逆序的數。
輸入樣例1:
123456789
結尾無空行
輸出樣例1:
987654321
結尾無空行
輸入樣例2:
10000000
結尾無空行
輸出樣例2:
1
結尾無空行
# 方法一：
n = input()
n = n.strip()
n = n.strip('0')
if not n:
print(0)
else:
n = n[::-1]
print(n)
# 方法二：
n=int(input())
s1=""
if not n:
print(0)
else:
while n:
if s1=="" and n%10==0:
pass
else:
s1+=str(n%10)
n//=10
print(s1)
方法一和二是兩種不同的思路
方法一其實有兩個需要注意的地方，輸入0和輸入空格或者制表符，只輸入這個三個的話返回的是空，但是對於平台來說這個答案是錯誤的，所以需要單獨拿出來判斷是否為空，答案部分錯誤的時候其實是其中的特殊情況有錯誤，其余的答案沒有錯。
對於方法二，也判斷了整數時為空的情況，整數比字符串好一點，輸入空格會直接報異常，下面的算法是利用模算法來讓整數倒置。
其實對於這道題來說用數字型比較好，畢竟不需要考慮兩種特殊情況（可能也是我比較笨的原因【🐕】）
7-7 sdut-輸出字符串中最大字符及其索引位置
輸入字符串，排序后輸出最大字符及該字符在原字符串中的索引。
相同字符的索引取最大值。
輸入格式:
一行輸入字符串。
輸出格式:
在一行內輸出最大字符及其最大索引位置。字符和數字間有3個空格。
輸入樣例1:
Hello Python
結尾無空行
輸出樣例1:
y 7
結尾無空行
輸入樣例2:
HELLO EVERYONE YEAR 2021
結尾無空行
輸出樣例2:
Y 15
結尾無空行
a=input()
ls=[x for x in a]
ma=0
for i in range(len(ls)):
if ord(ls[i])>ma:
ma=ord(ls[i])
# print("{} {}".format(chr(ma),ls.index(chr(ma))))
value=chr(ma)
l=[j for j in range(len(ls)) if value==ls[j]]
b=max(l)
print("{} {}".format(chr(ma),b))
首先找出最大的字母，按照ASCII碼，然后找出下標比較一下。
7-9 sdut-十進制數轉換成二進制后1和0的個數
輸入一個非負整數，求它變成二進制后1和0的個數。
（PYTHON實現提示：用bin函數）。
輸入格式:
輸入一個十進制的正整數。
輸出格式:
輸出二進制數中1和0的個數。中間用1個空格分開。
輸入樣例1:
37
結尾無空行
輸出樣例1:
3 3
結尾無空行
輸入樣例2:
0
結尾無空行
輸出樣例2:
0 1
結尾無空行
n=bin(int(input()))
n=n[2:]
a,b=0,0
for x in n:
if x=='0':
a+=1
else:
b+=1
print(b,a)
7-8 sdut-計算多個字符串中最長的字符串長度
有n(1<n<10)個字符串，計算最長的字符串的長度。
注意：前導空格不計算在內！
輸入格式:
在第一行中輸入n，接下的每行輸入一個字符串。
輸出格式:
在一行中輸出最長的字符串的長度，形式為：length=?。
輸入樣例:
4
blue
yellow
red
green結尾無空行
輸出樣例:
length=6
結尾無空行
n=int(input())
ma=0
while n:
a=input()
a=a.strip()
if len(a)>ma:
ma=len(a)
n-=1
print("length={}".format(ma))
直接是每一個輸入然后比較的，就不用輸入完再挨個比較了。