python試題

A. python題

望採納~
a = input('請輸入學生成績（空格分隔）：')
a.split(' ')

for i in a:
if a >= 90:
print('A')
elif a >= 80:
print('B')
elif a >= 70:
print('C')
elif a >= 60:
print('D')
elif a < 60:
print('F')#怎麼總感覺是E>_<

B. Python題目

C. Python習題

這里輸出['B','C','D','E','F','G','H'] 這類字元，用list(str)會簡單很多，所以每次要從第i位開始截斷字元串。

l = "ABCDEFGH"

for i in range(len(l)):

...: print(l[i], list(l[i+1:]))

見如下：

D. Python題

# 2021-05-13 Luke

ls = []
while True:
x = input("請輸入成績（輸入完請按q退出）:")
if x == 'q':
break
else:
ls.append(int(x))
ls.sort(reverse=True)

n = 0
for i in ls:
n = n + i
sum_ = n / len(ls)
print("第一名分數是:" + str(ls[0]) + " 第二名分數是:" +
str(ls[1]) + " 第三名分數是:" + str(ls[2]) + " 平均成績是:" + str(sum_))

E. 幾個Python題目

1.【選擇】下面哪個選項不是定義列表的正確方式？（D）

D.myList4=2,3,4,5

答案解析：這是定義元組的方式，而不是列表

2.【選擇】根據下面表達式，a的值是：（C）

C.loWo

3.【填空】請寫出如何切片myList[]的倒數第3~5位。

myList[-3:-5]

4.【判斷】列表內元素的下標是從0開始的。（√）

5.【選擇】下列Python表達式可以將列表反向並改變原列表值的是：（D）

D.myList.reverse()

答案解析：切片會生成新的列表；reversed只是生成新的迭代器；只有list.reverse()會對原表的值進行改變

-----------

1.【判斷】Python語句「x="a","b","c"」中，x是一個元組。（√）

2.【選擇】執行下列Python語句會報錯的是：（A）

A.myTuple[3]=30

答案解析：元組是immutable（不可變）的，所以不能改變元組的值

3.【填空】使用Python內置函數，計算元組myTuple的語句是：

sum(myTuple)

4.【選擇】下列關於Python的描述錯誤的是：（C）

C.對元組內部元素進行排序使用的是sort()

答案解析：元組不可變，所以不能對元素進行排序

------------

1.【選擇】下列關於Python中字元串說法錯誤的是：（D）

D.Python中字元類型是char，字元串的類型是str

答案解析：python字元和字元串類型都是str

3.【填空】請寫出用空格「」合並字元串「Jane」、「Doe」的Python語句：

"Jane"+""+"Doe"

4.【選擇】下列不是Python3中解決路徑中特殊字元問題的選項是：（C）

C.s=u"D: est"

------------

1.【選擇】下列不是序列的是：（C）

C.集合

3.【選擇】下面哪些操作是序列都具有的？（D）

D.以上都是

-----

1.【判斷】Python中符號{}僅用在集合這一數據類型中。（B.×）

3.【填空】語句set("datascience")的結果是：

集合{'d','a','t','s','c','i','e','n'}

4.【選擇】下列關於集合的說法錯誤的是：（A）

A.集合具有互異性，定義集合時不允許出現相同的元素

答案解析：出現了重復也沒事，會自動去重的。

7.【選擇】在Python中對數據進行去重處理，一般會藉助下列哪種數據類型？（C）

C.集合

---------

1.【填空】有兩個列表a=["name","age","sex"]，b=["jonh","23","M"],請用一個語句將這兩個列表轉換成字典，其中列表a中的元素為「鍵」，列表b中的元素為「值」。

dict(zip(a,b))

2.【填空】定義一個新字典如下，用print輸出dict1的結果是：

{1:3,2:'a'}

4.【判斷】下面對字典d的定義是正確的。（B.×）

答案解析：列表不能用做鍵。應該用元組('a','b')做鍵。

F. python練習題

#-*-coding:utf-8-*-
defGuess(word):
print'==============================='
print'Wordsofar:%s'%('*'*len(word))
foriinrange(len(word)):
whileTrue:
j=raw_input('Takeguessnumber%d:
'%(i+1))
ifj==word[i]:
print'Gotit!'
print'Wordsofar:%s'%(word[:i+1]+'*'*(len(word)-i-1))
break
else:
print'Sorry!'
print'Wordsofar:%s'%(word[:i]+'*'*(len(word)-i))
defmain():
whileTrue:
word=raw_input('Enterthesecretword(allinlowercase):
')
Guess(word)
print'Congratulations.Youcorrectlyguessedtheword:%s'%word
choise=raw_input('Doyouwanttoplayonemoretime?y/n?
')
ifchoise=='n':
print'ExitNow...'
break

if__name__=='__main__':
main()

>>

Enter the secret word (all in lowercase):

hi

===============================

Word so far:**

Take guess number 1:

a

Sorry!

Word so far:**

Take guess number 1:

h

Got it!

Word so far:h*

Take guess number 2:

i

Got it!

Word so far:hi

Congratulations. You correctly guessed the word: hi

Do you want to play one more time? y/n?

n

Exit Now...

G. Python列表題目

字元串[x:y:z]x表示起始位置，y表示終止位置，z表示步長。x不填表示從最開頭起始y不填表示到最後，-1表示倒著讀取
平常切片[x:y]其實是[x:y:1]把:1省略了

H. python題：

1. 歐幾里德演算法
歐幾里德演算法又稱輾轉相除法， 用於計算兩個整數a, b的最大公約數。其計算原理依賴於下面的定理：
定理： gcd(a, b) = gcd(b, a mod b)
證明：
a可以表示成a = kb + r, 則r = a mod b
假設d是a, b的一個公約數， 則有 d|a, d|b, 而r = a - kb, 因此d|r。
因此，d是(b, a mod b)的公約數。
加上d是(b，a mod b)的公約數，則d|b, d|r, 但是a = kb + r,因此d也是(a, b)的公約數。
因此，(a, b) 和(a, a mod b)的公約數是一樣的，其最大公約數也必然相等，得證。
歐幾里德的Python語言描述為：

1
2
3
4
5
6
7
8
9
10

def gcd(a, b):
if a < b:
a, b = b, a

while b != 0:
temp = a % b
a = b
b = temp

return a

2. Stein演算法
歐幾里德演算法是計算兩個數最大公約數的傳統演算法，無論是理論，還是從效率上都是很好的。但是他有一個致命的缺陷，這個缺陷只有在很大的素數時才會顯現出來。
考慮現在的硬體平台，一般整數最多也就是64位， 對於這樣的整數，計算兩個數值就的模很簡單的。對於字長為32位的平台，計算兩個不超過32位的整數的模，只需要一個指令周期，而計算64位以下的整數模，也不過幾個周期而已。但是對於更大的素數，這樣的計算過程就不得不由用戶來設計，為了計算兩個超過64位的整數的模，用戶也許不得不採用類似於多位除法手算過程中的試商法，這個過程不但復雜，而且消耗了很多CPU時間。對於現代密碼演算法，要求計算128位以上的素數的情況比比皆是，設計這樣的程序迫切希望能夠拋棄除法和取模。
Stein演算法由J.Stein 1961年提出，這個方法也是計算兩個數的最大公約數。和歐幾里德演算法不同的是，Stein演算法只有整數的移位和加減法，這對於程序設計者是一個福音。
為了說明Stein演算法的正確性，首先必須注意到以下結論：
gcd(a, a) = a， 也就是一個數和他自己的公約數是其自身。
gcd(ka, kb) = k * gcd(a, b)，也就是最大公約數運算和倍乘運算可以交換，特殊的，當k=2時，說明兩個偶數的最大公約數比如能被2整除。
Stein演算法的python實現如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

def gcd_Stein(a, b):
if a < b:
a, b = b, a
if (0 == b):
return a
if a % 2 == 0 and b % 2 == 0:
return 2 * gcd_Stein(a/2, b/2)
if a % 2 == 0:
return gcd_Stein(a / 2, b)
if b % 2 == 0:
return gcd_Stein(a, b / 2)

return gcd_Stein((a + b) / 2, (a - b) / 2)

3. 一般求解實現
核心代碼很簡單：

1
2
3

def gcd(a, b):
if b == 0:return a
return gcd(b, a % b)

附上一個用Python實現求最大公約數同時判斷是否是素數的一般方法：
程序如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#!/usr/bin/env python

def showMaxFactor(num):
count = num / 2
while count > 1:
if num % count == 0:
print 'largest factor of %d is %d' % (num, count)
break #break跳出時會跳出下面的else語句
count -= 1
else:
print num, "is prime"

for eachNum in range(10,21):
showMaxFactor(eachNum)

輸出如下:

1
2
3
4
5
6
7
8
9
10
11

largest factor of 10 is 5
11 is prime
largest factor of 12 is 6
13 is prime
largest factor of 14 is 7
largest factor of 15 is 5
largest factor of 16 is 8
17 is prime
largest factor of 18 is 9
19 is prime
largest factor of 20 is 10