| 1級 |
|
|
|
| 題： |
| 編寫一個程序，查找所有可以被7整除但不是5的倍數的數字。 |
| 在2000到3200之間（均包括在內）。 |
| 所獲得的數字應以逗號分隔的順序打印在一行上。 |
|
|
| 提示： |
| 考慮使用範圍（＃begin，＃end）方法 |
|
|
| 解： |
| l = [] |
| 對於範圍內的i（2000，3201）： |
| 如果（i％7 == 0）和（i％5！= 0）： |
| l.append（str（i）） |
|
|
| 打印'，'。join（l） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題2 |
| 1級 |
|
|
| 題： |
| 編寫一個程序，可以計算給定數字的階乘。 |
| 結果應以逗號分隔的順序打印在一行上。 |
| 假設將以下輸入提供給程序： |
| 8 |
| 然後，輸出應爲： |
| 40320 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| def fact（x）： |
| 如果x == 0： |
| 返回1 |
| 返回x *事實（x-1） |
|
|
| x = int（raw_input（）） |
| 列印事實（x） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題3 |
| 1級 |
|
|
| 題： |
| 使用給定的整數n，編寫程序以生成包含（i，i * i）的字典，該字典爲1到n之間的整數（都包括在內）。然後程序應打印字典。 |
| 假設將以下輸入提供給程序： |
| 8 |
| 然後，輸出應爲： |
| {1：1、2：4、3：9、4：16、5：25、6：36、7：49、8：64} |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
| 考慮使用dict（） |
|
|
| 解： |
| n = int（原始輸入（）） |
| d = dict（） |
| 對於範圍（1，n + 1）中的i： |
| d [i] = i * i |
|
|
| 打印d |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題4 |
| 1級 |
|
|
| 題： |
| 編寫一個程序，該程序從控制檯接受一個逗號分隔的數字序列，並生成一個列表和一個包含每個數字的元組。 |
| 假設將以下輸入提供給程序：交流裙：753532316 |
| 34,67,55,33,12,98 |
| 然後，輸出應爲： |
| ['34'，'67'，'55'，'33'，'12'，'98'] |
| （“ 34”，“ 67”，“ 55”，“ 33”，“ 12”，“ 98”） |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
| tuple（）方法可以將列表轉換爲元組 |
|
|
| 解： |
| 值= raw_input（） |
| l = values.split（“，”） |
| t =元組（l） |
| 打印l |
| 打印t |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題5 |
| 1級 |
|
|
| 題： |
| 定義一個至少具有兩個方法的類： |
| getString：從控制檯輸入獲取字符串 |
| printString：以大寫形式輸出字符串。 |
| 還請包括簡單的測試功能以測試類方法。 |
|
|
| 提示： |
| 使用__init__方法構造一些參數 |
|
|
| 解： |
| InputOutString（object）類： |
| def __init __（）： |
| self.s =“” |
|
|
| def getString（）： |
| self.s = raw_input（） |
|
|
| def printString（）： |
| 打印self.s.upper（） |
|
|
| strObj = InputOutString（） |
| strObj.getString（） |
| strObj.printString（） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題6 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，根據給定的公式計算並打印值： |
| Q = [（2 * C * D）/ H]的平方根 |
| 以下是C和H的固定值： |
| C爲50。H爲30。 |
| D是變量，其值應以逗號分隔的順序輸入到程序中。 |
| 例 |
| 讓我們假設以下逗號分隔的輸入序列已賦予程序： |
| 100,150,180 |
| 該程序的輸出應爲： |
| 18,22,24 |
|
|
| 提示： |
| 如果收到的輸出爲十進制格式，則應四捨五入至最接近的值（例如，如果收到的輸出爲26.0，則應將其打印爲26）。 |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| ＃！/ usr / bin / env python |
| 導入數學 |
| c = 50 |
| h = 30 |
| 值= [] |
| items = [x代表raw_input（）。split（'，'）中的x] |
| 對於d個項目： |
| value.append（str（int（round（math.sqrt（2 * c * float（d）/ h））））） |
|
|
| 打印'，'。join（value） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題7 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，該程序將X，Y兩位數字作爲輸入並生成一個二維數組。數組的第i行和第j列中的元素值應爲i * j。 |
| 注意：i = 0,1 ..，X-1; j = 0,1，¡Y-1。 |
| 例 |
| 假設將以下輸入提供給程序： |
| 3,5 |
| 然後，程序的輸出應爲： |
| [[0，0，0，0，0]，[0，1，2，3，4]，[0，2，4，6，8]] |
|
|
| 提示： |
| 注意：如果將輸入數據提供給問題，則應將其假定爲以逗號分隔形式的控制檯輸入。 |
|
|
| 解： |
| input_str = raw_input（） |
| Dimensions = [input_str.split（'，'）中x的int（x）] |
| rowNum =尺寸[0] |
| colNum =尺寸[1] |
| multilist = [[0表示範圍（colNum）的col]]表示範圍（rowNum）的行] |
|
|
| 對於範圍（rowNum）中的行： |
| 對於範圍內的col（colNum）： |
| multilist [row] [col] = row * col |
|
|
| 打印多列表 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題8 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，該程序接受以逗號分隔的單詞序列作爲輸入，並在按字母順序對單詞進行排序後以逗號分隔的順序打印這些單詞。 |
| 假設將以下輸入提供給程序： |
| 沒有，你好，袋，世界 |
| 然後，輸出應爲： |
| 袋，你好，沒有，世界 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| items = [x代表raw_input（）。split（'，'）中的x] |
| items.sort（） |
| 打印'，'。join（項目） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題9 |
| 2級 |
|
|
| 問題： |
| 編寫一個接受行序列作爲輸入的程序，並在將句子中的所有字符都大寫之後打印行。 |
| 假設將以下輸入提供給程序： |
| 你好，世界 |
| 實踐使完美 |
| 然後，輸出應爲： |
| 你好，世界 |
| 實踐完美 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| 行數= [] |
| 而True： |
| s = raw_input（） |
| 如果s： |
| lines.append（s.upper（）） |
| 其他： |
| 打破; |
|
|
| 對於以下句子： |
| 打印句子 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題10 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，該程序接受一系列由空格分隔的單詞作爲輸入，並在刪除所有重複的單詞並將其按字母數字順序排序後打印這些單詞。 |
| 假設將以下輸入提供給程序： |
| 你好世界，實踐使世界變得完美，你好世界 |
| 然後，輸出應爲： |
| 再次，你好使完美實踐世界 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
| 我們使用set容器自動刪除重複的數據，然後使用sorted（）對數據進行排序。 |
|
|
| 解： |
| s = raw_input（） |
| 單詞= [s.split（“”）中的單詞對單詞] |
| 打印“” .join（sorted（list（set（set（words）））） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題11 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，該程序接受以逗號分隔的4位二進制數字序列作爲輸入，然後檢查它們是否可被5整除。被5整除的數字將以逗號分隔的順序打印。 |
| 例： |
| 0100,0011,1010,1001 |
| 然後輸出應爲： |
| 1010 |
| 注意：假設數據是通過控制檯輸入的。 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| 值= [] |
| items = [x代表raw_input（）。split（'，'）中的x] |
| 對於p項： |
| intp = int（p，2） |
| 如果不是intp％5： |
| value.append（p） |
|
|
| 打印'，'。join（value） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題12 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，它將找到介於1000和3000之間的所有此類數字（均包括在內），以使該數字的每個數字均爲偶數。 |
| 所獲得的數字應以逗號分隔的順序打印在一行上。 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| 值= [] |
| 對於範圍在（1000，3001）中的i： |
| s = str（i） |
| if（int（s [0]）％2 == 0）和（int（s [1]）％2 == 0）和（int（s [2]）％2 == 0）和（int（s [3]）％2 == 0）： |
| values.append（s） |
| 打印“，”。join（值） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題13 |
| 2級 |
|
|
| 題： |
| 編寫一個接受句子並計算字母和數字數量的程序。 |
| 假設將以下輸入提供給程序： |
| 你好，世界！123 |
| 然後，輸出應爲： |
| 字母10 |
| 數字3 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| s = raw_input（） |
| d = {“數字”：0，“字母”：0} |
| 對於c in s： |
| 如果c.isdigit（）： |
| d [“ DIGITS”] + = 1 |
| elif c.isalpha（）： |
| d [“ LETTERS”] + = 1 |
| 其他： |
| 通過 |
| 打印“字母”，d [“字母”] |
| 打印“ DIGITS”，d [“ DIGITS”] |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題14 |
| 2級 |
|
|
| 題： |
| 編寫一個接受句子的程序，並計算大寫字母和小寫字母的數量。 |
| 假設將以下輸入提供給程序： |
| 你好，世界！ |
| 然後，輸出應爲： |
| 大寫1 |
| 小寫9 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| s = raw_input（） |
| d = {“大寫”：0，“小寫”：0} |
| 對於c in s： |
| 如果c.isupper（）： |
| d [“大寫”] + = 1 |
| elif c.islower（）： |
| d [“小寫”] + = 1 |
| 其他： |
| 通過 |
| 打印“大寫”，d [“大寫”] |
| 打印“小寫”，d [“小寫”] |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題15 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，以給定的數字作爲a的值來計算a + aa + aaa + aaaa的值。 |
| 假設將以下輸入提供給程序： |
| 9 |
| 然後，輸出應爲： |
| 11106 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| 一個= raw_input（） |
| n1 = int（“％s”％a） |
| n2 = int（“％s％s”％（a，a）） |
| n3 = int（“％s％s％s”％（a，a，a）） |
| n4 = int（“％s％s％s％s”％（a，a，a，a）） |
| 打印n1 + n2 + n3 + n4 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題16 |
| 2級 |
|
|
| 題： |
| 使用列表推導對列表中的每個奇數取平方。該列表由一系列逗號分隔的數字輸入。 |
| 假設將以下輸入提供給程序： |
| 1,2,3,4,5,6,7,8,9 |
| 然後，輸出應爲： |
| 1,3,5,7,9 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| 值= raw_input（） |
| 數字= [如果int（x）％2！= 0，則x爲values.split（“，”）中的x。 |
| 打印“，”。join（數字） |
| ＃----------------------------------------＃ |
|
|
| 問題17 |
| 2級 |
|
|
| 題： |
| 編寫一個程序，該程序根據控制檯輸入的交易日誌來計算銀行帳戶的淨額。事務日誌格式如下所示： |
| D 100 |
| 200號 |
|
|
| D表示存款，W表示提款。 |
| 假設將以下輸入提供給程序： |
| D 300 |
| D 300 |
| 200號 |
| D 100 |
| 然後，輸出應爲： |
| 500 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| netAmount = 0 |
| 而True： |
| s = raw_input（） |
| 如果不是s： |
| 打破 |
| 值= s.split（“”） |
| 操作=值[0] |
| 數量= int（值[1]） |
| 如果operation ==“ D”： |
| netAmount + =金額 |
| elif operation ==“ W”： |
| netAmount- =金額 |
| 其他： |
| 通過 |
| 打印淨額 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題18 |
| 3級 |
|
|
| 題： |
| 網站要求用戶輸入用戶名和密碼進行註冊。編寫程序以檢查用戶輸入的密碼的有效性。 |
| 以下是檢查密碼的標準： |
| 1. [az]之間至少1個字母 |
| 2. [0-9]之間至少1個數字 |
| 1. [AZ]之間至少1個字母 |
| 3. [$＃@]中的至少1個字符 |
| 4.最小交易密碼長度：6 |
| 5.交易密碼的最大長度：12 |
| 您的程序應接受一系列用逗號分隔的密碼，並將根據上述條件進行檢查。符合條件的密碼將被打印，每個密碼之間用逗號分隔。 |
| 例 |
| 如果輸入以下密碼作爲程序輸入： |
| ABd1234 @ 1，a F1＃，2w3E *，2We3345 |
| 然後，程序的輸出應爲： |
| ABd1234 @ 1 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解決方案： |
| 匯入 |
| 值= [] |
| items = [x代表raw_input（）。split（'，'）中的x] |
| 對於p項： |
| 如果len（p）<6或len（p）> 12： |
| 繼續 |
| 其他： |
| 通過 |
| 如果不是re.search（“ [az]”，p）： |
| 繼續 |
| 如果不是re.search（“ [0-9]”，p）： |
| 繼續 |
| 如果不是re.search（“ [AZ]”，p）： |
| 繼續 |
| Elif not re.search（“ [$＃@]”，p）： |
| 繼續 |
| elif re.search（“ \ s”，p）： |
| 繼續 |
| 其他： |
| 通過 |
| value.append（p） |
| 打印“，”。join（值） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題19 |
| 3級 |
|
|
| 題： |
| 您需要編寫程序以升序對（名稱，年齡，身高）元組進行排序，其中名稱是字符串，年齡和身高是數字。元組由控制檯輸入。排序標準是： |
| 1：根據名稱排序； |
| 2：然後根據年齡排序； |
| 3：然後按分數排序。 |
| 優先級是名稱>年齡>得分。 |
| 如果給出以下元組作爲程序的輸入： |
| 湯姆19,80 |
| 約翰20,90 |
| 喬尼17,91 |
| 喬尼，17,93 |
| 傑森21,85 |
| 然後，程序的輸出應爲： |
| [（'John'，'20'，'90'），（'Jony'，'17'，'91'），（'Jony'，'17'，'93'），（'Json'，'21 '，'85'），（'Tom'，'19'，'80'）] |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
| 我們使用itemgetter啓用多個排序鍵。 |
|
|
| 解決方案： |
| 從操作員導入itemgetter，attrgetter |
|
|
| l = [] |
| 而True： |
| s = raw_input（） |
| 如果不是s： |
| 打破 |
| l.append（tuple（s.split（“，”））） |
|
|
| 打印排序（l，key = itemgetter（0,1,2）） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題20 |
| 3級 |
|
|
| 題： |
| 用生成器定義一個類，該生成器可以在給定範圍0和n之間迭代可以被7整除的數字。 |
|
|
| 提示： |
| 考慮使用量 |
|
|
| 解： |
| def putNumbers（n）： |
| 我= 0 |
| 而我<n： |
| j = i |
| i = i + 1 |
| 如果j％7 == 0： |
| 屈服j |
|
|
| 對於我反向（100）： |
| 打印我 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題21 |
| 3級 |
|
|
| 問題： |
| 機器人從原始點（0,0）開始在平面中移動。機器人可以按照給定的步驟向上，下，左和右移動。機器人運動的軌跡如下所示： |
| 上5 |
| 下3 |
| 左3 |
| 右2 |
| ¡ |
| 方向後的數字爲步長。請編寫一個程序，以計算一系列移動和原始點之後與當前位置的距離。如果距離是浮點數，則只需打印最接近的整數。 |
| 例： |
| 如果給出以下元組作爲程序的輸入： |
| 上5 |
| 下3 |
| 左3 |
| 右2 |
| 然後，程序的輸出應爲： |
| 2 |
|
|
| 提示： |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| 導入數學 |
| pos = [0,0] |
| 而True： |
| s = raw_input（） |
| 如果不是s： |
| 打破 |
| 運動= s.split（“”） |
| 方向=運動[0] |
| 步長= int（運動[1]） |
| 如果direction ==“ UP”： |
| pos [0] + =步驟 |
| elif direction ==“ DOWN”： |
| pos [0]-=步驟 |
| elif direction ==“左”： |
| pos [1]-=步驟 |
| elif direction ==“ RIGHT”： |
| pos [1] + =步驟 |
| 其他： |
| 通過 |
|
|
| 打印int（round（math.sqrt（pos [1] ** 2 + pos [0] ** 2））） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題22 |
| 3級 |
|
|
| 題： |
| 編寫程序以計算輸入中單詞的頻率。在按字母數字順序對鍵進行排序後，應輸出輸出。 |
| 假設將以下輸入提供給程序： |
| 是Python的新手，還是在Python 2和Python 3之間選擇？閱讀Python 2或Python 3。 |
| 然後，輸出應爲： |
| 2：2 |
| 3 :: 1 |
| 3？：1 |
| 新增：1個 |
| 的Python：5 |
| 閱讀：1 |
| 和：1 |
| 之間：1 |
| 選擇：1 |
| 或：2 |
| 至：1 |
|
|
| 提示 |
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
| freq = {}＃文字中的詞頻 |
| 行= raw_input（） |
| 對於line.split（）中的單詞： |
| freq [word] = freq.get（word，0）+1 |
|
|
| 單詞= freq.keys（） |
| words.sort（） |
|
|
| 對於w而言： |
| 打印“％s：％d”％（w，freq [w]） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題23 |
| 1級 |
|
|
| 題： |
| 編寫一種可以計算數字平方值的方法 |
|
|
| 提示： |
| 使用**運算符 |
|
|
| 解： |
| def平方（數字）： |
| 返回數字** 2 |
|
|
| 打印方塊（2） |
| 打印方塊（3） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題24 |
| 1級 |
|
|
| 題： |
| Python具有許多內置函數，如果您不知道如何使用它，則可以在線閱讀文檔或查找一些書籍。但是Python對於每個內置函數都有一個內置文檔函數。 |
| 請編寫程序以打印一些Python內置函數文檔，例如abs（），int（），raw_input（） |
| 併爲您自己的功能添加文檔 |
|
|
| 提示： |
| 內置文檔方法是__doc__ |
|
|
| 解： |
| 打印Abs .__ doc__ |
| 打印int .__ doc__ |
| 打印raw_input .__ doc__ |
|
|
| def平方（數字）： |
| '''返回輸入數字的平方值。 |
|
|
| 輸入的數字必須是整數。 |
| ''' |
| 返回數字** 2 |
|
|
| 打印方塊（2） |
| 打印方塊。__doc__ |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 問題25 |
| 1級 |
|
|
| 題： |
| 定義一個類，該類具有一個類參數並且具有相同的實例參數。 |
|
|
| 提示： |
| 定義實例參數，需要將其添加到__init__方法中 |
| 您可以使用構造參數初始化對象或稍後設置值 |
|
|
| 解： |
| 班級人員： |
| ＃定義類參數“名稱” |
| 名稱=“人” |
|
|
| def __init __（self，name = None）： |
| ＃self.name是實例參數 |
| self.name =名稱 |
|
|
| 傑弗裏= Person（“傑弗裏”） |
| 打印“％s名稱爲％s”％（Person.name，jeffrey.name） |
|
|
| nico =人（） |
| nico.name =“尼科” |
| 打印“％ s名稱爲％s ”％（Person.name，nico.name） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 題： |
| 定義一個可以計算兩個數字之和的函數。 |
|
|
| 提示： |
| 定義一個以兩個數字作爲參數的函數。您可以在函數中計算總和並返回值。 |
|
|
| 解 |
| def SumFunction（數字1，數字2）： |
| 返回數字1+數字2 |
|
|
| 打印SumFunction（1,2） |
|
|
| ＃----------------------------------------＃ |
| 題： |
| 定義一個可以將整數轉換爲字符串並在控制檯中打印的函數。 |
|
|
| 提示： |
|
|
| 使用str（）將數字轉換爲字符串。 |
|
|
| 解 |
| def printValue（n）： |
| 打印str（n） |
|
|
| printValue（3） |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
| 定義一個可以將整數轉換爲字符串並在控制檯中打印的函數。 |
|
|
| 提示： |
|
|
| 使用str（）將數字轉換爲字符串。 |
|
|
| 解 |
| def printValue（n）： |
| 打印str（n） |
|
|
| printValue（3） |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個函數，該函數可以接收兩個字符串形式的整數並計算它們的總和，然後在控制檯中將其打印出來。 |
|
|
| 提示： |
|
|
| 使用int（）將字符串轉換爲整數。 |
|
|
| 解 |
| def printValue（s1，s2）： |
| 打印int（s1）+ int（s2） |
|
|
| printValue（“ 3”，“ 4”）＃7 |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
|
|
| 題： |
| 定義一個函數，該函數可以接受兩個字符串作爲輸入並將其連接起來，然後在控制檯中將其打印出來。 |
|
|
| 提示： |
|
|
| 使用+連接字符串 |
|
|
| 解 |
| def printValue（s1，s2）： |
| 打印s1 + s2 |
|
|
| printValue（“ 3”，“ 4”）＃34 |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
|
|
| 題： |
| 定義一個可以接受兩個字符串作爲輸入的函數，並在控制檯中打印最大長度的字符串。如果兩個字符串的長度相同，則該函數應逐行打印所有字符串。 |
|
|
| 提示： |
|
|
| 使用len（）函數獲取字符串的長度 |
|
|
| 解 |
| def printValue（s1，s2）： |
| len1 = len（s1） |
| len2 = len（s2） |
| 如果len1> len2： |
| 打印s1 |
| elif len2> len1： |
| 打印s2 |
| 其他： |
| 打印s1 |
| 打印s2 |
|
|
|
|
| printValue（“一個”，“三個”） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個可以接受整數作爲輸入的函數，如果數字是偶數，則打印“它是偶數”，否則打印“它是奇數”。 |
|
|
| 提示： |
|
|
| 使用％運算符檢查數字是偶數還是奇數。 |
|
|
| 解 |
| def checkValue（n）： |
| 如果n％2 == 0： |
| 打印“這是一個偶數” |
| 其他： |
| 打印“這是一個奇數” |
|
|
|
|
| checkValue（7） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個可以打印字典的函數，其中鍵是1到3之間的數字（都包括在內），值是鍵的平方。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式將條目放入字典中。 |
| 使用**運算符可獲取數字的冪。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| d [1] = 1 |
| d [2] = 2 ** 2 |
| d [3] = 3 ** 2 |
| 打印d |
|
|
|
|
| printDict（） |
|
|
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個可以打印字典的函數，其中鍵是1到20之間的數字（都包括在內），值是鍵的平方。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式將條目放入字典中。 |
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| 對於範圍在（1,21）中的i： |
| d [i] = i ** 2 |
| 打印d |
|
|
|
|
| printDict（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個可以生成字典的函數，其中鍵是1到20之間的數字（均包括在內），值是鍵的平方。該功能應僅打印值。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式將條目放入字典中。 |
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用keys（）迭代字典中的鍵。我們也可以使用item（）來獲取鍵/值對。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| 對於範圍在（1,21）中的i： |
| d [i] = i ** 2 |
| 對於d.items（）中的（k，v）： |
| 打印v |
|
|
|
|
| printDict（） |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個可以生成字典的函數，其中鍵是1到20之間的數字（均包括在內），值是鍵的平方。該功能應僅打印鍵。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式將條目放入字典中。 |
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用keys（）迭代字典中的鍵。我們也可以使用item（）來獲取鍵/值對。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| 對於範圍在（1,21）中的i： |
| d [i] = i ** 2 |
| 對於d.keys（）中的k： |
| 打印k |
|
|
|
|
| printDict（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個函數，該函數可以生成並打印一個列表，其中值是介於1到20之間的數字的平方（均包括在內）。 |
|
|
| 提示： |
|
|
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用list.append（）將值添加到列表中。 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 對於範圍在（1,21）中的i： |
| li.append（i ** 2） |
| 打印李 |
|
|
|
|
| printList（） |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個函數，該函數可以生成一個列表，其中值是介於1到20之間的數字的平方（均包括在內）。然後，該功能需要打印列表中的前5個元素。 |
|
|
| 提示： |
|
|
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用list.append（）將值添加到列表中。 |
| 使用[n1：n2]分割列表 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 對於範圍在（1,21）中的i： |
| li.append（i ** 2） |
| 打印li [：5] |
|
|
|
|
| printList（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個函數，該函數可以生成一個列表，其中值是介於1到20之間的數字的平方（均包括在內）。然後，該功能需要打印列表中的最後5個元素。 |
|
|
| 提示： |
|
|
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用list.append（）將值添加到列表中。 |
| 使用[n1：n2]分割列表 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 對於範圍在（1,21）中的i： |
| li.append（i ** 2） |
| 打印李[-5：] |
|
|
|
|
| printList（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個函數，該函數可以生成一個列表，其中值是介於1到20之間的數字的平方（均包括在內）。然後，該函數需要打印列表中前5個元素以外的所有值。 |
|
|
| 提示： |
|
|
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用list.append（）將值添加到列表中。 |
| 使用[n1：n2]分割列表 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 對於範圍在（1,21）中的i： |
| li.append（i ** 2） |
| 打印李[5：] |
|
|
|
|
| printList（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 定義一個函數，該函數可以生成和打印一個元組，其中值是介於1和20之間的數字的平方（均包括在內）。 |
|
|
| 提示： |
|
|
| 使用**運算符可獲取數字的冪。 |
| 使用range（）進行循環。 |
| 使用list.append（）將值添加到列表中。 |
| 使用tuple（）從列表中獲取一個元組。 |
|
|
| 解 |
| def printTuple（）： |
| li = list（） |
| 對於範圍在（1,21）中的i： |
| li.append（i ** 2） |
| 打印元組（li） |
|
|
| printTuple（） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 使用給定的元組（1,2,3,4,5,6,7,8,9,10），編寫一個程序以一行打印前半值，然後以一行打印後半值。 |
|
|
| 提示： |
|
|
| 使用[n1：n2]表示法從元組中獲取一個切片。 |
|
|
| 解 |
| tp =（1,2,3,4,5,6,7,8,9,10） |
| tp1 = tp [：5] |
| tp2 = tp [5：] |
| 打印TP1 |
| 打印tp2 |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 題： |
| 編寫一個程序來生成並打印另一個在給定元組（1,2,3,4,5,6,7,8,9,10）中其值爲偶數的元組。 |
|
|
| 提示： |
|
|
| 使用“ for”來迭代元組 |
| 使用tuple（）從列表中生成一個元組。 |
|
|
| 解 |
| tp =（1,2,3,4,5,6,7,8,9,10） |
| li = list（） |
| 對於我在TP中： |
| 如果tp [i]％2 == 0： |
| li.append（tp [i]） |
|
|
| tp2 =元組（li） |
| 打印tp2 |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.14 |
|
|
| 題： |
| 編寫一個接受字符串作爲輸入的程序，如果該字符串是“ yes”或“ YES”或“ Yes”，則打印“ Yes”，否則打印“ No”。 |
|
|
| 提示： |
|
|
| 使用if語句判斷條件。 |
|
|
| 解 |
| s = raw_input（） |
| 如果s ==“ yes”或s ==“ YES”或s ==“ Yes”： |
| 打印“是” |
| 其他： |
| 打印“否” |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 3.4 |
|
|
| 題： |
| 編寫一個程序，該程序可以使用過濾器功能過濾列表中的偶數。列表爲：[1,2,3,4,5,6,7,8,9,10]。 |
|
|
| 提示： |
|
|
| 使用filter（）過濾列表中的某些元素。 |
| 使用lambda定義匿名函數。 |
|
|
| 解 |
| li = [1,2,3,4,5,6,7,8,9,10] |
| evenNumbers = filter（lambda x：x％2 == 0，li） |
| 打印偶數 |
|
|
|
|
| ＃----------------------------------------＃ |
| 3.4 |
|
|
| 題： |
| 編寫一個程序，該程序可以map（）創建一個列表，該列表的元素是[1,2,3,4,5,6,7,8,9,10]中的元素的平方。 |
|
|
| 提示： |
|
|
| 使用map（）生成一個列表。 |
| 使用lambda定義匿名函數。 |
|
|
| 解 |
| li = [1,2,3,4,5,6,7,8,9,10] |
| squaredNumbers = map（lambda x：x ** 2，li） |
| 打印平方數 |
|
|
| ＃----------------------------------------＃ |
| 3.5 |
|
|
| 題： |
| 編寫一個程序，該程序可以map（）和filter（）組成一個列表，該列表的元素爲[1,2,3,4,5,6,7,8,9,10]中的偶數平方。 |
|
|
| 提示： |
|
|
| 使用map（）生成一個列表。 |
| 使用filter（）過濾列表中的元素。 |
| 使用lambda定義匿名函數。 |
|
|
| 解 |
| li = [1,2,3,4,5,6,7,8,9,10] |
| evenNumbers = map（lambda x：x ** 2，filter（lambda x：x％2 == 0，li）） |
| 打印偶數 |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 3.5 |
|
|
| 題： |
| 編寫一個程序，該程序可以使用filter（）創建一個列表，該列表的元素爲1到20之間的偶數（均包括在內）。 |
|
|
| 提示： |
|
|
| 使用filter（）過濾列表中的元素。 |
| 使用lambda定義匿名函數。 |
|
|
| 解 |
| evenNumbers = filter（lambda x：x％2 == 0，range（1,21）） |
| 打印偶數 |
|
|
|
|
| ＃----------------------------------------＃ |
| 3.5 |
|
|
| 題： |
| 編寫一個程序，該程序可以map（）創建一個列表，該列表的元素爲1到20之間的數字平方（均包括在內）。 |
|
|
| 提示： |
|
|
| 使用map（）生成一個列表。 |
| 使用lambda定義匿名函數。 |
|
|
| 解 |
| squaredNumbers = map（lambda x：x ** 2，range（1,21）） |
| 打印平方數 |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 7.2 |
|
|
| 題： |
| 定義一個名爲American的類，該類具有一個稱爲printNationality的靜態方法。 |
|
|
| 提示： |
|
|
| 使用@staticmethod裝飾器定義類的靜態方法。 |
|
|
| 解 |
| American類（對象）： |
| @staticmethod |
| def printNationality（）： |
| 打印“美國” |
|
|
| anAmerican = American（） |
| anAmerican.printNationality（） |
| American.printNationality（） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 7.2 |
|
|
| 題： |
| 定義一個名爲American的類及其子類NewYorker。 |
|
|
| 提示： |
|
|
| 使用類Subclass（ParentClass）定義一個子類。 |
|
|
| 解： |
|
|
| American類（對象）： |
| 通過 |
|
|
| NewYorker（美國）類： |
| 通過 |
|
|
| anAmerican = American（） |
| aNewYorker = NewYorker（） |
| 打印美國人 |
| 打印紐約 |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
|
|
| 7.2 |
|
|
| 題： |
| 定義一個名爲Circle的類，該類可以由半徑構造。Circle類具有一種可以計算面積的方法。 |
|
|
| 提示： |
|
|
| 使用def methodName（self）定義方法。 |
|
|
| 解： |
|
|
| Circle（對象）類： |
| def __init __（self，r）： |
| self.radius = r |
|
|
| def區域（個體）： |
| 返回self.radius ** 2 * 3.14 |
|
|
| aCircle =圓（2） |
| 打印aCircle.area（） |
|
|
|
|
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 7.2 |
|
|
| 定義一個名爲Rectangle的類，該類可以通過長度和寬度來構造。Rectangle類具有可以計算面積的方法。 |
|
|
| 提示： |
|
|
| 使用def methodName（self）定義方法。 |
|
|
| 解： |
|
|
| Rectangle（object）類： |
| def __init __（self，l，w）： |
| self.length = l |
| self.width = w |
|
|
| def區域（個體）： |
| 返回self.length * self.width |
|
|
| aRectangle =矩形（2,10） |
| 打印aRectangle.area（） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 7.2 |
|
|
| 定義一個名爲Shape的類及其子類Square。Square類具有一個init函數，該函數以長度作爲參數。這兩個類都有一個Area函數，該函數可以打印Shape的區域默認爲0的形狀的區域。 |
|
|
| 提示： |
|
|
| 要覆蓋超類中的方法，我們可以在超類中定義一個具有相同名稱的方法。 |
|
|
| 解： |
|
|
| 類Shape（object）： |
| def __init __（）： |
| 通過 |
|
|
| def區域（個體）： |
| 返回0 |
|
|
| 方形（形狀）類： |
| def __init __（self，l）： |
| Shape .__ init __（個體） |
| self.length = l |
|
|
| def區域（個體）： |
| 返回self.length * self.length |
|
|
| aSquare =正方形（3） |
| 打印aSquare.area（） |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
|
|
| 請引發RuntimeError異常。 |
|
|
| 提示： |
|
|
| 使用raise（）引發異常。 |
|
|
| 解： |
|
|
| 引發RuntimeError（'出了點問題'） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 編寫一個函數以計算5/0並使用try / except捕獲異常。 |
|
|
| 提示： |
|
|
| 使用try / except捕獲異常。 |
|
|
| 解： |
|
|
| def throws（）： |
| 返回5/0 |
|
|
| 嘗試： |
| throws（） |
| 除了ZeroDivisionError： |
| 打印“除以零！” |
| 除了Exception以外，err： |
| 打印“捕獲異常” |
| 最後： |
| 打印“最後阻止清理” |
|
|
|
|
| ＃----------------------------------------＃ |
| 定義一個自定義異常類，該類將字符串消息作爲屬性。 |
|
|
| 提示： |
|
|
| 要定義自定義異常，我們需要定義一個從Exception繼承的類。 |
|
|
| 解： |
|
|
| 類MyError（Exception）： |
| “”“我自己的異常類 |
|
|
| 屬性： |
| msg-錯誤說明 |
| “” |
|
|
| def __init __（self，msg）： |
| self.msg =味精 |
|
|
| 錯誤= MyError（“出問題了”） |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 假設我們有一些“ [email protected]”格式的電子郵件地址，請編寫程序以打印給定電子郵件地址的用戶名。用戶名和公司名都僅由字母組成。 |
|
|
| 例： |
| 如果給該程序輸入以下電子郵件地址： |
|
|
| [email protected] |
|
|
| 然後，程序的輸出應爲： |
|
|
| 約翰 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 提示： |
|
|
| 使用\ w匹配字母。 |
|
|
| 解： |
| 匯入 |
| emailAddress = raw_input（） |
| pat2 =“（\ w +）@（（\ w + \。）+（com））” |
| r2 = re.match（pat2，emailAddress） |
| 打印r2.group（1） |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 假設我們有一些“ [email protected]”格式的電子郵件地址，請編寫程序以打印給定電子郵件地址的公司名稱。用戶名和公司名都僅由字母組成。 |
|
|
| 例： |
| 如果給該程序輸入以下電子郵件地址： |
|
|
| [email protected] |
|
|
| 然後，程序的輸出應爲： |
|
|
| 谷歌 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 提示： |
|
|
| 使用\ w匹配字母。 |
|
|
| 解： |
| 匯入 |
| emailAddress = raw_input（） |
| pat2 =“（\ w +）@（\ w +）\。（com）” |
| r2 = re.match（pat2，emailAddress） |
| 打印r2.group（2） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 編寫一個程序，該程序接受由空格分隔的單詞序列作爲輸入，以僅打印由數字組成的單詞。 |
|
|
| 例： |
| 如果給出以下單詞作爲程序輸入： |
|
|
| 2只貓和3只狗。 |
|
|
| 然後，程序的輸出應爲： |
|
|
| ['2'，'3'] |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 提示： |
|
|
| 使用re.findall（）使用正則表達式查找所有子字符串。 |
|
|
| 解： |
| 匯入 |
| s = raw_input（） |
| 打印re.findall（“ \ d +”，s） |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
|
|
| 打印一個unicode字符串“ hello world”。 |
|
|
| 提示： |
|
|
| 使用u'strings'格式定義unicode字符串。 |
|
|
| 解： |
|
|
| unicodeString = u“你好，世界！” |
| 打印unicodeString |
|
|
| ＃----------------------------------------＃ |
| 編寫程序以讀取ASCII字符串並將其轉換爲utf-8編碼的unicode字符串。 |
|
|
| 提示： |
|
|
| 使用unicode（）函數進行轉換。 |
|
|
| 解： |
|
|
| s = raw_input（） |
| u = unicode（s，“ utf-8”） |
| 打印你 |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 編寫特殊註釋以指示Python源代碼文件爲unicode。 |
|
|
| 提示： |
|
|
| 解： |
|
|
| ＃-*-編碼：utf-8-*- |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 編寫一個程序，通過控制檯（n> 0）輸入給定的n輸入來計算1/2 + 2/3 + 3/4 + ... + n / n + 1。 |
|
|
| 例： |
| 如果以下n作爲程序輸入： |
|
|
| 5 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 3.55 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 提示： |
| 使用float（）將整數轉換爲float |
|
|
| 解： |
|
|
| n = int（原始輸入（）） |
| 總和= 0.0 |
| 對於範圍（1，n + 1）中的i： |
| 總和+ = float（float（i）/（i + 1）） |
| 列印總和 |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 編寫程序進行計算： |
|
|
| 當n> 0時f（n）= f（n-1）+100 |
| 並且f（0）= 1 |
|
|
| 通過控制檯輸入給定的n（n> 0）。 |
|
|
| 例： |
| 如果以下n作爲程序輸入： |
|
|
| 5 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 500 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 提示： |
| 我們可以在Python中定義遞歸函數。 |
|
|
| 解： |
|
|
| 定義f（n）： |
| 如果n == 0： |
| 返回0 |
| 其他： |
| 返回f（n-1）+100 |
|
|
| n = int（原始輸入（）） |
| 打印f（n） |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
|
|
| 斐波那契數列是根據以下公式計算的： |
|
|
|
|
| 如果n = 0，則f（n）= 0 |
| 如果n = 1，則f（n）= 1 |
| 如果n> 1，則f（n）= f（n-1）+ f（n-2） |
|
|
| 請編寫一個程序，以控制檯輸入給定的n輸入來計算f（n）的值。 |
|
|
| 例： |
| 如果以下n作爲程序輸入： |
|
|
| 7 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 13 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 提示： |
| 我們可以在Python中定義遞歸函數。 |
|
|
|
|
| 解： |
|
|
| 定義f（n）： |
| 如果n == 0：返回0 |
| elif n == 1：返回1 |
| 否則：返回f（n-1）+ f（n-2） |
|
|
| n = int（原始輸入（）） |
| 打印f（n） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 斐波那契數列是根據以下公式計算的： |
|
|
|
|
| 如果n = 0，則f（n）= 0 |
| 如果n = 1，則f（n）= 1 |
| 如果n> 1，則f（n）= f（n-1）+ f（n-2） |
|
|
| 請編寫一個使用列表推導的程序，以控制檯輸入給定的n輸入以逗號分隔的形式打印斐波那契數列。 |
|
|
| 例： |
| 如果以下n作爲程序輸入： |
|
|
| 7 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 0,1,1,2,3,5,8,13 |
|
|
|
|
| 提示： |
| 我們可以在Python中定義遞歸函數。 |
| 使用列表推導從現有列表生成列表。 |
| 使用string.join（）連接字符串列表。 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
|
|
| 定義f（n）： |
| 如果n == 0：返回0 |
| elif n == 1：返回1 |
| 否則：返回f（n-1）+ f（n-2） |
|
|
| n = int（原始輸入（）） |
| 值= [str（f（x））對於x在範圍（0，n + 1）中 |
| 打印“，”。join（值） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 當控制檯輸入n時，請使用生成器編寫一個程序，以逗號分隔的形式打印0到n之間的偶數。 |
|
|
| 例： |
| 如果以下n作爲程序輸入： |
|
|
| 10 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 0,2,4,6,8,10 |
|
|
| 提示： |
| 使用yield生成發生器中的下一個值。 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
|
|
| def EvenGenerator（n）： |
| i = 0 |
| 當i <= n時： |
| 如果i％2 == 0： |
| 讓我 |
| i + = 1 |
|
|
|
|
| n = int（原始輸入（）） |
| 值= [] |
| 爲我在EvenGenerator（n）中： |
| values.append（str（i）） |
|
|
| 打印“，”。join（值） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 當控制檯輸入n時，請使用生成器編寫一個程序，以逗號分隔的形式打印可以在0和n之間被5和7整除的數字。 |
|
|
| 例： |
| 如果以下n作爲程序輸入： |
|
|
| 100 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 0,35,70 |
|
|
| 提示： |
| 使用yield生成發生器中的下一個值。 |
|
|
| 如果將輸入數據提供給問題，則應假定它是控制檯輸入。 |
|
|
| 解： |
|
|
| def NumGenerator（n）： |
| 對於範圍（n + 1）中的i： |
| 如果i％5 == 0和i％7 == 0： |
| 讓我 |
|
|
| n = int（原始輸入（）） |
| 值= [] |
| 對於NumGenerator（n）中的i： |
| values.append（str（i）） |
|
|
| 打印“，”。join（值） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
|
|
| 請編寫assert語句以驗證列表[2,4,6,8]中的每個數字都是偶數。 |
|
|
|
|
|
|
| 提示： |
| 使用“斷言表達式”進行斷言。 |
|
|
|
|
| 解： |
|
|
| li = [2,4,6,8] |
| 對於我在李： |
| 斷言i％2 == 0 |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個從控制檯接受基本數學表達式的程序，並打印評估結果。 |
|
|
| 例： |
| 如果將以下字符串作爲程序輸入： |
|
|
| 35 + 3 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 38 |
|
|
| 提示： |
| 使用eval（）評估表達式。 |
|
|
|
|
| 解： |
|
|
| 表達式= raw_input（） |
| 打印eval（表達式） |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個二進制搜索功能，該功能可以搜索已排序列表中的項目。該函數應返回列表中要搜索的元素的索引。 |
|
|
|
|
| 提示： |
| 使用if / elif處理條件。 |
|
|
|
|
| 解： |
|
|
| 導入數學 |
| def bin_search（li，element）： |
| 底部= 0 |
| 頂部= len（li）-1 |
| 指數= -1 |
| 而top> = bottom和index ==-1： |
| mid = int（math.floor（（top + bottom）/2.0）） |
| 如果li [mid] == element： |
| 指數=中 |
| elif li [mid]>元素： |
| 頂端= 1 |
| 其他： |
| 底部=中+1 |
|
|
| 回報指數 |
|
|
| li = [2,5,7,9,11,17,222] |
| 打印bin_search（li，11） |
| 打印bin_search（li，12） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個二進制搜索功能，該功能可以搜索已排序列表中的項目。該函數應返回列表中要搜索的元素的索引。 |
|
|
|
|
| 提示： |
| 使用if / elif處理條件。 |
|
|
|
|
| 解： |
|
|
| 導入數學 |
| def bin_search（li，element）： |
| 底部= 0 |
| 頂部= len（li）-1 |
| 指數= -1 |
| 而top> = bottom和index ==-1： |
| mid = int（math.floor（（top + bottom）/2.0）） |
| 如果li [mid] == element： |
| 指數=中 |
| elif li [mid]>元素： |
| 頂端= 1 |
| 其他： |
| 底部=中+1 |
|
|
| 回報指數 |
|
|
| li = [2,5,7,9,11,17,222] |
| 打印bin_search（li，11） |
| 打印bin_search（li，12） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請使用Python數學模塊生成一個隨機浮點，其值在10到100之間。 |
|
|
|
|
|
|
| 提示： |
| 使用random.random（）在[0,1]中生成隨機浮點數。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.random（）* 100 |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請使用Python數學模塊生成一個隨機浮點，其值在5到95之間。 |
|
|
|
|
|
|
| 提示： |
| 使用random.random（）在[0,1]中生成隨機浮點數。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.random（）* 100-5 |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序，使用隨機模塊和列表推導輸出0到10之間的一個隨機偶數。 |
|
|
|
|
|
|
| 提示： |
| 使用random.choice（）從列表中隨機元素。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.choice（[如果i％2 == 0，則[i代表範圍（11）中的i]] |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序以輸出一個隨機數，使用隨機模塊和列表推導，該隨機數可被5和7整除（介於0和10之間，包括0和10）。 |
|
|
|
|
|
|
| 提示： |
| 使用random.choice（）從列表中隨機元素。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.choice（[如果i％5 == 0和i％7 == 0，[i代表範圍（201）中的i]） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 請編寫一個程序以生成包含5個隨機數（介於100和200之間）的列表。 |
|
|
|
|
|
|
| 提示： |
| 使用random.sample（）生成隨機值列表。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.sample（range（100），5） |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序以隨機生成一個列表，該列表包含5個偶數（介於100和200之間）。 |
|
|
|
|
|
|
| 提示： |
| 使用random.sample（）生成隨機值列表。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.sample（[如果i％2 == 0，[i代表i在範圍（100,201）中]，5） |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序以隨機生成一個包含5個數字的列表，這些數字可被5和7整除（介於1和1000之間）。 |
|
|
|
|
|
|
| 提示： |
| 使用random.sample（）生成隨機值列表。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.sample（[如果i％5 == 0和i％7 == 0，[i代表範圍（1,1001）中的i]，5） |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 請編寫一個程序以隨機打印7到15之間的一個整數。 |
|
|
|
|
|
|
| 提示： |
| 使用random.randrange（）到給定範圍內的隨機整數。 |
|
|
|
|
| 解： |
|
|
| 隨機導入 |
| 打印random.randrange（7,16） |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 請編寫一個程序來壓縮和解壓縮字符串“ hello world！hello world！hello world！hello world！”。 |
|
|
|
|
|
|
| 提示： |
| 使用zlib.compress（）和zlib.decompress（）壓縮和解壓縮字符串。 |
|
|
|
|
| 解： |
|
|
| 導入zlib |
| s ='你好世界！你好世界！你好世界！你好世界！' |
| t = zlib.compress（s） |
| 打印t |
| 打印zlib.decompress（t） |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫程序以打印“ 1 + 1”的執行運行時間100次。 |
|
|
|
|
|
|
| 提示： |
| 使用timeit（）函數測量運行時間。 |
|
|
| 解： |
|
|
| 從timeit import Timer |
| t =計時器（“對於i在範圍（100）：1 + 1”中） |
| 打印t.timeit（） |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序以隨機播放並打印列表[3,6,7,8]。 |
|
|
|
|
|
|
| 提示： |
| 使用shuffle（）函數可以隨機播放列表。 |
|
|
| 解： |
|
|
| 從隨機導入洗牌 |
| li = [3,6,7,8] |
| 洗牌 |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序以隨機播放並打印列表[3,6,7,8]。 |
|
|
|
|
|
|
| 提示： |
| 使用shuffle（）函數可以隨機播放列表。 |
|
|
| 解： |
|
|
| 從隨機導入洗牌 |
| li = [3,6,7,8] |
| 洗牌 |
| 打印李 |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序以生成所有句子，其中主語位於[“ I”，“ You”]中，動詞位於[“ Play”，“ Love”]中，而賓語位於[“ Hockey”，“ Football”]中。 |
|
|
| 提示： |
| 使用list [index]表示法從列表中獲取元素。 |
|
|
| 解： |
|
|
| subject = [“ I”，“ You”] |
| 動詞= [“播放”，“愛”] |
| objects = [“ Hockey”，“ Football”] |
| 對於範圍內的我（len（subjects））： |
| 對於範圍內的j（len（動詞））： |
| 對於範圍內的k（len（objects））： |
| 句子=“％s％s％s”。％（主題[i]，動詞[j]，賓語[k]） |
| 打印句子 |
|
|
|
|
| ＃----------------------------------------＃ |
| 請刪除[5,6,77,45,22,12,24]中的刪除偶數後編寫程序以打印列表。 |
|
|
| 提示： |
| 使用列表推導從列表中刪除一堆元素。 |
|
|
| 解： |
|
|
| li = [5,6,77,45,22,12,24] |
| li = [如果x％2！= 0，則x爲li中的x。 |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 通過使用列表理解，請編寫一個程序以刪除在[12,24,35,70,88,120,155]中可被5和7整除的刪除數字後打印列表。 |
|
|
| 提示： |
| 使用列表推導從列表中刪除一堆元素。 |
|
|
| 解： |
|
|
| li = [12,24,35,70,88,120,155] |
| li = [如果x％5！= 0和x％7！= 0，則x在li中的x |
| 打印李 |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 通過使用列表理解，請編寫一個程序以刪除[12,24,35,70,88,120,155]中的第0、2、4、6個數字，然後打印列表。 |
|
|
| 提示： |
| 使用列表推導從列表中刪除一堆元素。 |
| 使用enumerate（）獲取（索引，值）元組。 |
|
|
| 解： |
|
|
| li = [12,24,35,70,88,120,155] |
| li = [如果i％2！= 0，則枚舉（li）中（i，x）的x] |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 通過使用列表理解，請編寫一個程序，生成一個3 * 5 * 8 3D數組，每個元素爲0。 |
|
|
| 提示： |
| 使用列表推導來創建數組。 |
|
|
| 解： |
|
|
| array = [[[0 for col in range（8）] for col in range（5）] for row in range（3）] |
| 打印陣列 |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 通過使用列表理解，請編寫一個程序以刪除[12,24,35,70,88,120,155]中的第0、4、5個數字以打印列表。 |
|
|
| 提示： |
| 使用列表推導從列表中刪除一堆元素。 |
| 使用enumerate（）獲取（索引，值）元組。 |
|
|
| 解： |
|
|
| li = [12,24,35,70,88,120,155] |
| li = [如果我不在（0,4,5）中，則x（i，x）在enumerate（li）中] |
| 打印李 |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 通過使用列表理解，請在刪除[12,24,35,24,88,120,155]中的值24之後編寫程序以打印列表。 |
|
|
| 提示： |
| 使用列表的remove方法刪除一個值。 |
|
|
| 解： |
|
|
| li = [12,24,35,24,88,120,155] |
| li = [如果x！= 24，則x表示li中的x。 |
| 打印李 |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 用兩個給定的列表[1,3,6,78,35,55]和[12,24,35,24,88,120,155]，編寫一個程序來製作一個列表，其元素是上述給定列表的交集。 |
|
|
| 提示： |
| 使用set（）和“＆=”進行交集操作。 |
|
|
| 解： |
|
|
| set1 = set（[1,3,6,78,35,55]） |
| set2 = set（[12,24,35,24,88,120,155]） |
| set1＆= set2 |
| li =列表（set1） |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
|
|
| 使用給定的列表[12,24,35,24,88,120,155,88,120,155]，編寫一個程序，在刪除所有保留原始順序的重複值之後，打印此列表。 |
|
|
| 提示： |
| 使用set（）存儲許多值，不能重複。 |
|
|
| 解： |
|
|
| def removeDuplicate（li）： |
| newli = [] |
| 看到= set（） |
| 對於li中的項目： |
| 如果沒有看到項目： |
| seen.add（item） |
| newli.append（項目） |
|
|
| 返回newli |
|
|
| li = [12,24,35,24,88,120,155,88,120,155] |
| 打印removeDuplicate（li） |
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 定義一個類Person及其兩個子類：Male和Female。所有類都有一個方法“ getGender”，可以爲“男”類打印“男”，爲“女”打印“女”。 |
|
|
| 提示： |
| 使用Subclass（Parentclass）定義子類。 |
|
|
| 解： |
|
|
| 類Person（object）： |
| def getGender（self）： |
| 返回“未知” |
|
|
| 男（人）類： |
| def getGender（self）： |
| 返回“男” |
|
|
| 女類（人）： |
| def getGender（self）： |
| 返回“女” |
|
|
| aMale =男性（） |
| aFemale =女性 |
| 打印aMale.getGender（） |
| 打印aFemale.getGender（） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 請編寫一個程序來計算和打印控制檯輸入的字符串中每個字符的編號。 |
|
|
| 例： |
| 如果將以下字符串作爲程序輸入： |
|
|
| abcdefgabc |
|
|
| 然後，程序的輸出應爲： |
|
|
| a2 |
| ，2 |
| ，2 |
| 1一 |
| d，1 |
| 1一 |
| ，1 |
|
|
| 提示： |
| 使用dict來存儲鍵/值對。 |
| 使用dict.get（）方法查找具有默認值的鍵。 |
|
|
| 解： |
|
|
| dic = {} |
| s = raw_input（） |
| 對於s in s： |
| dic [s] = dic.get（s，0）+1 |
| 打印'\ n'.join（[。％s，％s'％（k，v）對於dic.items（）中的k，v） |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 請編寫一個程序，該程序從控制檯接受一個字符串，然後以相反的順序打印它。 |
|
|
| 例： |
| 如果將以下字符串作爲程序輸入： |
|
|
| 投票給先生 |
|
|
| 然後，程序的輸出應爲： |
|
|
| 里斯·埃托夫·埃西爾 |
|
|
| 提示： |
| 使用list [::-1]以相反的順序迭代列表。 |
|
|
| 解： |
|
|
| s = raw_input（） |
| s = s [::-1] |
| 打印 |
|
|
| ＃----------------------------------------＃ |
|
|
| 題： |
|
|
| 請編寫一個程序，該程序從控制檯接受一個字符串，並打印具有偶數索引的字符。 |
|
|
| 例： |
| 如果將以下字符串作爲程序輸入： |
|
|
| H1e2l3l4o5w6o7r8l9d |
|
|
| 然後，程序的輸出應爲： |
|
|
| 你好，世界 |
|
|
| 提示： |
| 使用list [:: 2]通過步驟2迭代列表。 |
|
|
| 解： |
|
|
| s = raw_input（） |
| s = s [:: 2] |
| 打印 |
| ＃----------------------------------------＃ |
|
|
|
|
| 題： |
|
|
| 請編寫一個打印所有[1,2,3]排列的程序 |
|
|
|
|
| 提示： |
| 使用itertools.permutations（）獲取列表的排列。 |
|
|
| 解： |
|
|
| 導入itertools |
| 打印列表（itertools.permutations（[1,2,3]）） |
|
|
| ＃----------------------------------------＃ |
| 題： |
|
|
| 編寫程序來解決經典的古代中國難題： |
| 我們在一個農場的雞和兔子中算出35頭和94腿。我們有多少隻兔子和幾隻雞？ |
|
|
| 暗示： |
| 使用for循環迭代所有可能的解決方案。 |
|
|
| 解： |
|
|
| defsolve（numheads，numlegs）： |
| ns ='沒有解決方案！' |
| 對於我在範圍內（numheads + 1）： |
| j =數字頭 |
| 如果2 * i + 4 * j ==數字 |
| 返回我，j |
| 返回ns，ns |
|
|
| numheads = 35 |
| numlegs = 94 |
| 解決方案= solve（numheads，numlegs） |
| 打印解決方案 |
|
|
| ＃----------------------------------------＃ |
