Python語言程式設計2018年版課後習題答案（全國計算機等級考試二級教程）嵩天著
阿新 • • 發佈：2018-11-30
Python語言程式設計2018年版程式設計題（全國計算機等級考試二級教程）嵩天著
第二章 程式設計題
1.獲得使用者輸入的一個整數N，計算並輸出N的32次方。
num = eval(input("請輸入整數N:"))
print(num**32)
2.獲得使用者輸入的一段文字，將這段文字進行垂直輸出。
str = input()
for i in str:
print(i)
3.獲得使用者輸入的一個合法算式，例如：1.2+3.4，輸出運算結果。
這裡寫程式碼片
4.獲得使用者輸入的一個小數，提取並輸出其整數部分。
num=input("請輸入一個小數：")； print(int(num))
5.下面這段程式碼能夠獲得使用者輸入的一個整數N，計算並輸出1到N相加的和。然而，這段程式碼存在多個語法錯誤，請指出錯誤所在並糾正。
n=input("請輸入整數N:");
sum=0
for i in range(n):
sum+=i+1
print("1到N求和結果：".format(sum)）
第三章 程式設計題
1.獲得使用者輸入的一個整數，輸出該整數百位及以上的數字。
x=input('請輸入一個整數') x=int(x) if 0<x<99: print('請重新輸入一個三位以上的數') elif x>=100: x=x//100 print(x) else: x=x//100 print(x)
2.獲得使用者輸入的一個字串，將字串按照空格分隔，然後逐行打印出來。
s = input('請輸入一個字串，例如：Django is cool')
for i in s:
print(' '.join(s))#將列表轉換成以空格分隔的字串
3.程式讀入一個表示星期幾的數字（1——7），輸出對應的星期字串名稱。例如：輸入3，返回“星期三”。
w=input('請輸入一個表示星期幾的數字（1——7）') print(str("星期"+"w")) week=input('請輸入一個表示星期幾的數字（1——7）') week=int(range(1,8)) if 8<=week: print("請輸入一個表示星期幾的數字（1——7）") else: print(str("星期"+"week"))
4.設n是一任意自然數，如果n的各位數字反向排列所得自然數與n相等，則n被稱為迴文數。從鍵盤輸入一個5位數字，請編寫程式判斷這個數字是不是迴文數。
#--------迴文數判斷執行正確-----------
a = input("請輸入數字:")
l = len(a)
flag = True
for i in range(1,l//2):
if a[i-1] != a[-1]:
flag = False
break
if flag:
print("是迴文數.")
else:
print("不是迴文數.")
這裡有三點：
設定flag，用布林運算子
長度為l//2，不用+1
條件裡無需判斷相等的情況，不需要continue。number = eval(input("輸入一個n位數："))
#--------迴文數判斷執行正確-----------
num = input("請輸入一個四位數：")
num = int(num)
a = num // 1000
b = num // 100 % 10
c = num // 10 % 10
d = num % 10
newnum = d * 1000 + c * 100 + b * 10 + a
result = (num == newnum)
print("是否是迴文數：", result)
#--------迴文數判斷執行錯誤-----------
number = str(number)
if(number == number[::-1]):
print("是迴文數")
else:
print("不是迴文數")
#--------迴文數判斷執行錯誤-----------
n=int(input(""))
n=str(n)
m=n[::-1]
if(n==m):
print("yes")
else:
print("no")
5.輸入一個十進位制整數，分別輸出其二進位制、八進位制、十六進位制字串。
num=eval(input("請輸入一個十進位制整數："))
print(bin(num))
print(oct(num))
print(hex(num))
6.Python顯示進度條，實時顯示處理進度
**前言**
在大多數時候，我們的程式會一直進行迴圈處理。這時候，
我們非常希望能夠知道程式的處理進度，由此來決定接下
來該做些什麼。接下來告訴大家如何簡單又漂亮的實現這一功能。
如何使用這個類
使用這個類很簡單，只需要兩步即可完成，如下：
process_bar = ShowProcess(max_steps, infoDone)
# 1.在迴圈前定義類的實體， max_steps是總的步數， infoDone是在完成時需要顯示的字串
for i in range(max_steps):
process_bar.show_process() # 2.顯示當前進度
time.sleep(0.05)
**進度條的實現**
# -*- coding: UTF-8 -*-
import sys, time
class ShowProcess():
"""
顯示處理進度的類
呼叫該類相關函式即可實現處理進度的顯示
"""
i = 0 # 當前的處理進度
max_steps = 0 # 總共需要處理的次數
max_arrow = 50 #進度條的長度
infoDone = 'done'
# 初始化函式，需要知道總共的處理次數
def __init__(self, max_steps, infoDone = 'Done'):
self.max_steps = max_steps
self.i = 0
self.infoDone = infoDone
# 顯示函式，根據當前的處理進度i顯示進度
# 效果為[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]100.00%
def show_process(self, i=None):
if i is not None:
self.i = i
else:
self.i += 1
num_arrow = int(self.i * self.max_arrow / self.max_steps) #計算顯示多少個'>'
num_line = self.max_arrow - num_arrow #計算顯示多少個'-'
percent = self.i * 100.0 / self.max_steps #計算完成進度，格式為xx.xx%
process_bar = '[' + '>' * num_arrow + '-' * num_line + ']'\
+ '%.2f' % percent + '%' + '\r' #帶輸出的字串，'\r'表示不換行回到最左邊
sys.stdout.write(process_bar) #這兩句列印字元到終端
sys.stdout.flush()
if self.i >= self.max_steps:
self.close()
def close(self):
print('')
print(self.infoDone)
self.i = 0
if __name__=='__main__':
max_steps = 100
process_bar = ShowProcess(max_steps, 'OK')
for i in range(max_steps):
process_bar.show_process()
time.sleep(0.01)
執行
按照主函式的方法呼叫此類即可，顯示效果如下：
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]100.00%
OK
**其他案例**
使用 sys.stdout 或 sys.stderr 就可以輸出一個簡單的進度條：
import time
import sys
def report_progress(progress, total, lbar_prefix = '', rbar_prefix=''):
percent = round(progress / float(total) * 100)
buf = "%s|%s| %s%d/%d %s"%(lbar_prefix, ('#' * percent).ljust(100, '-'),
rbar_prefix, progress, float(total), "%d%%"%(percent))
sys.stdout.write(buf)
sys.stdout.write('\r')
sys.stdout.flush()
def report_progress_done():
sys.stdout.write('\n')
total = 100
report_progress(0, total)
for progress in range(1, 101):
time.sleep(0.1)
report_progress(progress, total)
report_progress_done()
---------------------
本文來自 亦遊 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/tp7309/article/details/79408555?utm_source=copy
第四章 程式設計題
1.輸入一個年份，輸出是否為閏年。#閏年條件：能被4整除但不能被100整除，或者能被400整除的年份都是閏年。
y=input("請輸入一個年份：")
year=int(y)
if year%4==0 and year%100!=0:
print(year,"是閏年")
elif year%400==0:
print(year,"是閏年")
else:
print(year,"不是閏年")
2.最大公約數計算。獲得兩個整數，求出這兩個整數的最大公約數和最小公倍數。最大公約數的計算一般使用輾轉相除法(歐幾里德演算法)，最小公倍數一般使用兩個數的乘積除以最大公約數。
1. 求最小公倍數的演算法:
最小公倍數 = 兩個整數的乘積 / 最大公約數
所以我們首先要求出兩個整數的最大公約數, 求兩個數的最大公約數思路如下:
2. 求最大公約數演算法:
1. 整數A對整數B進行取整, 餘數用整數C來表示 舉例: C = A % B
2. 如果C等於0,則C就是整數A和整數B的最大公約數
3. 如果C不等於0, 將B賦值給A, 將C賦值給B ,然後進行 1, 2 兩步,直到餘數為0, 則可以得知最大公約數
def fun(num1, num2): # 定義一個函式, 兩個形參
if num1 < num2: # 判讀兩個整數的大小,目的為了將大的數作為除數,小的作為被除數
num1, num2 = num2, num1 # 如果if條件滿足,則進行值的交換
vari1 = num1 * num2 # 計算出兩個整數的乘積,方便後面計算最小公倍數
vari2 = num1 % num2 # 對2個整數進行取餘數
while vari2 != 0: # 判斷餘數是否為0, 如果不為0,則進入迴圈
num1 = num2 # 重新進行賦值,進行下次計算
num2 = vari2
vari2 = num1 % num2 # 對重新賦值後的兩個整數取餘數
# 直到 vari2 等於0,得到最到公約數就退出迴圈
vari1 /= num2 # 得出最小公倍數
print("最大公約數為:%d" % num2) # 輸出
print("最小公倍數為:%d" % vari1) # 輸出
fun(6, 9)
----------
歐幾里德演算法又稱輾轉相除法，用於計算兩個整數m, n的最大公約數。其計算原理依賴於下面的定理：
gcd(m, n) = gcd(n, m mod n)
這個定理的意思是：整數m、n的最大公約數等於n和m除以n的餘數的最大公約數。
例如：有兩個整數：120和45，我們按照上面的方法求他們的最大公約數。
1. gcd(120, 45) = gcd(45, 120 % 45) = gcd(45, 30)
2. gcd(45, 30) = gcd(30, 45 % 30) = gcd(30, 15)
3. gcd(30, 15) = gcd(15, 30 % 15) = gcd(15, 0) = 15
當 m % n 等於零時，即求15和0的最大公約數時，這個迴圈應該終止，15就是120和45的最大公約數。
Python程式碼實現如下：
def gcd(m, n):
while n:
m, n = n, m % n
return m
3.統計不同字元個數。使用者從鍵盤鍵入一行字元，編寫一個程式，統計並輸出其中英文字元、數字、空格和其他字元的個數。
[原文連結](https://blog.csdn.net/htuhxf/article/details/79944051)
一、習題要求
統計不同字元個數。使用者從鍵盤輸入一行字元，編寫一個程式，統計並輸出其中英文字元、數字、空格和其他字元的個數。
**二、思路分析**
最重要的是找到一個標準，可以利用if語句把需要統計的字元區別開來。
顯而易見，python3.X直接使用unicode這個特點，就可以利用，
第1步：確定unicode編碼範圍：
漢字： 十六進位制 [0x4e00, 0x9fa5] / 十進位制 [19968，40869]
數字：十六進位制 [0x30, 0x39] / 十進位制 [48, 57]
小寫字母：十六進位制 [0x61, 0x7a] / 十進位制 [97，122]
大寫字母：十六進位制 [0x41, 0x5a] / 十進位制 [65, 90]，
注：chr(x) & ord(x)使用的是 單個字元，或者十進位制INT格式的unicode編碼；
第2步：保證輸出結果只有一行
第3步：編寫程式碼
**三、程式碼：**
text = input('請輸入字元：') # 介面：讓使用者輸入字元
zhongwen=shuzi=yingwen=kongge=qita=0 # 設定初始值，以便用於for in迴圈
for i in text:
if 40869 >= ord(i) >= 19968: # 本處使用十進位制，簡單。或者使用十六進位制，再用ord('\u9fa5')轉換為十進位制的unicode編碼；
zhongwen +=1
elif 57 >= ord(i) >= 48:
shuzi+=1
elif 122>= ord(str.lower(i)) >= 97: # 直接使用str.lower()函式，將英文字元統一為小寫，節省程式碼；
yingwen +=1
elif i ==' ':
kongge +=1
else:
qita +=1
print('中文字元個數為{}'.format(zhongwen),'\n'+'數字字元個數為{}'.format(shuzi),'\n'+'英文字元個數為{}'.format(yingwen),'\n'+'空格字元個數為{}'.format(kongge),'\n'+'其他字元個數為{}'.format(qita))
注：
- print()函式和for語句對齊後，輸出結果僅僅是最後統計值，輸出一次。
- 使用'\n'+'string'來使得輸出結果換行；
- python3.x 預設十進位制。之前直接使用 十六進位制的漢字編碼，易出錯，如‘u9fa5’會被當作string處理。
4.猜數字遊戲續。當用戶輸入的不是整數（如字母、浮點數等）時，程式會終止執行退出。改編題目1中的程式，當用戶輸入出錯時給出“輸入內容必須是整數！”的提示，並讓使用者重新輸入。
[原文連結](https://blog.csdn.net/TimeOld/article/details/79699874)
import random
secret = random.randint(0,9) #這裡使用random()產生0~9之間整數
#print(secret)
print('------猜數字遊戲！-----')
guess = -1
N = 0 #記錄次數
while guess != secret:
temp = input('請輸入數字0--9之間：\n')
if not temp.isdigit(): #判斷輸入的是否為非整數
print('輸入內容必須為整數！！！！\n再來一次吧\n')
else:
N+=1
guess = int(temp)
if guess > secret:
print('遺憾，太大了！\n')
if guess < secret:
print('遺憾，太小了！\n')
if guess == secret:
print('預測{}次，你猜中了！'.format(N))
watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzE3NDYzOQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
import random
target=random.randint(1,1000)
count=0
while True:
try:
guess=eval(input('請輸入一個猜測的整數（1到1000）：'))
except:
print('輸入有誤，請重試，不計入猜測次數哦！')
continue
count=count+1
if guess>target:
print('猜大了')
elif guess<target:
print('猜小了')
else:
print('猜對了')
break
print('此輪猜測的次數是：',count)
注：
**Python isdigit()方法**
描述
Python isdigit() 方法檢測字串是否只由數字組成。
語法
isdigit()方法語法：
str.isdigit()
返回值
如果字串只包含數字則返回 True 否則返回 False。
例項
以下例項展示了isdigit()方法的例項：
str = "123456"; # Only digit（數字） in this string
print str.isdigit();
執行結果：True
str = "this is string example....wow!!!";
print str.isdigit();
執行結果：False
5.羊車門問題。有三扇關閉的門，一扇門後面停著汽車，其餘門後是山羊，只有主持人知道每扇門後面是什麼，參賽者可以選擇一扇門，在開啟它之前，主持人會開啟另外一扇門，露出門後的山羊，然後允許參賽者更換自己的選擇，請問參賽者更換選擇後能否增加猜中汽車的機會？這是一個經典問題，請使用random庫，對這個隨機事件進行預測，分別輸出參賽者改變選擇和堅持選擇獲勝的概率。
[原文連結](https://blog.csdn.net/honorwh/article/details/81810006)
1.我認為會增加選中汽車的機會。
原因如下：
（1）不換選擇：選對的概率為1/3
（2）更換選擇：
假設一開始選中的是車，主持人指出其中一隻羊之後，那麼剩下的一個門也必定是羊，那麼此
時更改選擇必定是得不到車的，這是第一種；假如一開始選中的是羊，在主持人指出一隻之後
，無論如何更改選擇都是可以得到車的，所以有兩種情況更改是ok的，所以是2/3。
from random import*
TIMES = 10000
my_first_choice_n=0#初始化不改選擇的次數
my_change_choice_n=0#初始化更改選擇的次數
for i in range(TIMES):
car_inDoor=randint(0,2)
my_guess=randint(0,2)
if car_inDoor==my_guess:
my_first_choice_n+=1
else:
my_change_choice_n+=1
print("不改選擇:{}".format(my_first_choice_n/TIMES))
print("更改選擇:{}".format(my_change_choice_n/TIMES))
執行結果：
不改選擇:0.3299
更改選擇:0.6701
關於這道題，出現了許多種不同的分析，彼此爭論不休，比如下面這些典型的分析：
分析1： 第一次選擇A、B、C門正確的概率為1/3；主持人排除一扇門並不會改變A, B, C的
概率，所以，不管是否改變概率都是1/3。
分析2： 第一次選擇A門正確的概率為1/3，主持人排除一扇門以後，剩下兩扇門的概率都相
應地變成了1/2。所以，不管是否改變概率都是1/2。
分析3： 第一次選擇A門正確的概率為1/3，主持人排除一扇門之後，如果不重新選擇，A門
正確的概率還是1/3，而重新選擇另一扇門可以使概率上升為1/2。
分析4： 第一次選擇A門正確的概率為1/3，主持人排除一扇門之後，如果不重新選擇，A門
正確的概率還是1/3，而重新選擇另一扇門可以使概率上升到2/3。
這麼多種分析，到底那種正確呢？其實，通過概率樹就可以直觀地看出來：
**不換選策略**
在不換選策略下，第一次選對的概率為1/3，選錯的概率為2/3。如果第一次選對，那麼繼續
選對的概率為1。如果第一次選錯，那麼繼續選錯的概率也為1。所以，最終選對的概率為1/3
。
**換選策略**
在換選策略下，第一次選對的概率為1/3，選錯的概率為2/3.如果第一次選對，那麼改變後選
對的概率為0.如果第一次選錯，那麼改變後選擇對的概率為1.所以，最終選對的概率為2/3.
有了概率樹這個工具以後，對於問題的分析就直觀多了。我們還可以進一步思考：假如問題變
為n扇門，主持人排除m扇門，那麼改變選擇和不改變選擇兩種策略選對的概率分別是多少？
第五章 程式設計題
1.實現isNum()函式，引數為一個字元，如果這個字串屬於整數、浮點數或複數的表示，則返回True，否則返回False。
答案解析不正確版
2.實現isPrime（）函式，引數為整數，要有異常處理。如果整數是質數，返回True，否則返回False。
3.編寫一個函式計算傳入字元中數字、字母、空格以及其他字元的個數。
答案解析1
def func1(a):
count1 = 0
count2 = 0
count3 = 0
count4 = 0
for i in a:
if i.isdigit():#數字
count1+=1
elif i.isalpha():#字母
count2+=1
elif i.isspace():#空格
count3+=1
else:#其他
count4+=1
print("數字有%d個：" % count1)
print("字母有%d個：" % count2)
print("空格有%d個：" % count3)
print("其他有%d個：" % count4)
return (count1, count2, count3, count4)
str_num = input("輸入:")
func1(str_num)
4.編寫一個函式，列印200以內的所有素數，以空格分割。
5.編寫一個函式，引數為一個整數n。利用遞迴獲取斐波那契數列中第n個數並返回。
斐波那契數列. 斐波那契數列形如1,1,2,3,5,8,13,21,等等. 也就是說,下一個值是序列
中前兩個值之和. 寫一個函式,給定N,返回第N個斐波那契數字.例如,第1個斐波那契數字
是1,第6個是8.
def fibonacci(x):
fibList = [1,1]
for i in xrange(2,x+1):
fibList.append(fibList[i-2] + fibList[i-1])
return fibList[-1]
num = int(raw_input("Enter a numer:"))
print fibonacci(num)
第六章 程式設計題
1.英文字元頻率統計。編寫一個程式，對給定的字串中出現的A~Z字母頻率分析，忽略大小寫，採用降序方式輸出。
【經典演算法】:英文文章統計字元頻率
字母出現頻率統計用python實現
這裡寫程式碼片
2.中文字元頻率統計。編寫一個程式，對給定的字串中出現的全部字元（含中文字元）頻率進行分析，採用降序方式輸出。
【經典演算法】:基於中文字元分析的統計頻率演算法實現
利用python做中文詞頻分析
3.隨機密碼生成。編寫程式在26個字母大小寫和9個數字組成的列表中隨機生成10個8位密碼。
Python 生成8位必含數字、大小寫字母的字串（密碼）
python生成隨機密碼：random庫
這裡寫程式碼片
4.重複元素判定。編寫一個函式，接收列表作為引數，如果一個元素在列表中出現了不止一次，則返回True，但不要改變原來列表的值。同時編寫呼叫這個函式和輸出測試結果的程式。
#second 2 重複元素判定
def testReEle(lis):
tem = set(lis)
if len(tem) == len(lis):
print('True')
else:
print('False')
def getList():
lis = []
ch = input("請輸入判定元素，回車表示結束：")
while ch != '':
lis.append(ch)
ch = input("請輸入判定元素，回車表示結束：")
testReEle(lis)
getList()
5.重複元素判定續。利用集合的無重複性改變上一個程式。獲得一個更快更簡潔的版本。
這裡寫程式碼片
第七章
1.輸入一個檔案和一個字元，統計該字元在檔案中出現的次數。
2.假設有一個英語文字檔案，編寫一個程式讀取其內容並將裡面的大寫字母變小寫字母，小寫字母變成大寫字母。
#輸入一串字元，將大寫字母轉換成小寫字母，小寫字母轉換為大寫字母
a = input("請 輸入字元：")
b = []
for n in a :
if "a"<= n <= "z":
b.append(n.upper())
elif"A" <= n <= "Z" :
b.append(n.lower())
else:
b.append(n)
print("".join(b))
---------------------
本文來自 渣渣不輝 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/luomanluoland/article/details/80622578?utm_source=copy
3.編寫一個程式，生成一個10*10的隨機矩陣並儲存為檔案(空格分隔行向量、換行分隔列向量)，再寫程式將剛才儲存的矩陣檔案另存為CSV格式，用Excel或文字編輯器開啟看看結果對不對。
在這裡插入程式碼片
4.編寫一個程式，讀取一個Python原始碼檔案，將檔案中所有除保留字外的小寫字母換成大寫字母，生成後的檔案要能夠被Python直譯器正確執行。
import keyword
s=keyword.kwlist
#建立保留字列表
file_name = "F:\個人\Python\PY\Python實驗6/t.txt"
f = open(file_name, "r")
ls=[]
for i in f.readlines():
i=i.split()
ls.append(i)
print(ls)
#建立一個以每行的所有單詞為元素組成的一個列表組
f.close()
f = open(file_name, "w+")
for i in range(len(ls)):
if ls[i]:
for j in range(len(ls[i])):
x= ls[i][j]
if x not in s:
x=x.upper()
else:
x=x.lower()
if j == len(ls[i])-1:#判定是否遍歷至每行的末尾
f.write(x+"\n")
else:
f.write(x+" ")
else:
f.write(" "+"\n")
f.close()
---------------------
本文來自 Stark_595 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/Stark_595/article/details/80601213?utm_source=copy
[其他詳細解答](https://blog.csdn.net/zhi_it_coder/article/details/80740078)
5.編寫一個程式，要求能夠將元素為任意Python支援的型別(包括含有半形逗號的字串)的列表轉儲為CSV，並能夠重新正確解析為列表。
在這裡插入程式碼片
第八章
1.使用者輸入一個年份，編寫程式判斷該年是否閏年，如果年份能被 400 整除則為閏年，如果年份能被4整除，但不能被100整除為閏年。
y=input("請輸入一個年份：")
year=int(y)
if year%4==0 and year%100!=0:
print(year,"是閏年")
elif year%400==0:
print(year,"是閏年")
else:
print(year,"不是閏年")
2.參考最後一個例項,嘗試將不同標籤中的內容分門別類的提取出來，再想想如何提取可以更為準確。(提示:可查閱 HTML 相關語法)
在這裡插入程式碼片
3.續上一題，找另外一個網站，嘗試程式設計提取一些自己感興趣的東西出來。(提示:可自行搜尋用於 HTML 解析的第三方)
在這裡插入程式碼片
4.參考第六章最後一個例子，按照 8.2節 的方法重新實現一個有較好的函式封裝的《Hamlet》文字詞頻統計程式。
第六章例子：
#CalHamlet.py
def getText():
txt=open("hamlet.txt","r").read()
txt=txt.lower() #將字母變成小寫，排除原文中大小寫差異對詞頻的干擾
for ch in '!"#$%&()*+,-./:;<=>[email protected][\\]^_‘{|}~':
txt=txt.replace(ch," ") #將文字中特殊字元替換成空格
return txt
hamletTxt=getText()
words=hamletTxt.split()
counts={} #對每個單詞進行計數
for word in words:
counts[word]=counts.get(word,0)+1
items=list(counts.items()) #將字典轉換為記錄列表
items.sort(key=lambda x:x[1],reverse=True) #以第二列排序
for i in range(10):
word,count=items[i]
print("{0:<10}{1:>5}".format(word,count))
8.2節程式設計方法論——自頂向下設計和自底向上執行
|第一步| 分解並提取英文文章的單詞 |
|-第三步-|--|
| 第二步 | 對每個單詞進行計數 |
def getText():
txt=open("hamlet.txt","r").read()
txt=txt.lower() #將字母變成小寫，排除原文中大小寫差異對詞頻的干擾
for ch in '!"#$%&()*+,-./:;<=>[email protected][\\]^_‘{|}~':
txt=txt.replace(ch," ") #將文字中特殊字元替換成空格
return txt
def counts={} #對每個單詞進行計數
for word in words:
counts[word]=counts.get(word,0)+1\
def items():
items=list(counts.items()) #將字典轉換為記錄列表
items.sort(key=lambda x:x[1],reverse=True) #以第二列排序
for i in range(10):
word,count=items[i]
print("{0:<10}{1:>5}".format(word,count))
def main():
getText()
counts={}
items()
main()
5.詞雲是設計和統計的結合，也是藝術與電腦科學的碰撞，wordcloud是一款基於Python的詞雲第三方庫支援對詞語數量，背景蒙版，字型顏色等各種細節的設定，試結合上一題構建《Hamlet》的詞雲效果。
#CalHamlet詞雲.py
from wordcloud import WordCloud
from scipy.misc import imread
mask = imread("hamlet.png")
f=open("hamlet.txt","r")
txt=f.read()
wordcloud=WordCloud(background_color="white",\
width=800,\
height=600,\
max_words=200,\
max_font_size=80,\
mask=mask,\
).generate(txt)
wordcloud.to_file("hamlet詞雲圖片.png")
第九章
1.使用 turtle庫 繪製一個蜂窩狀六邊形。
1.turtle正方形繪製
使用turtle庫，繪製一個正方形。
因為每畫一條邊，畫筆需要逆時針旋轉90度（left（）函式可以解決這個問題，引數為旋轉度數的數值），因此用迴圈實現更為簡單。
from turtle import *
setup(300,500,200,200)
pensize(10)
pencolor("black")
for i in range(4):
fd(100)
left(90)
done()
1
2
3
4
5
6
7
8
2.turtle六邊形繪製
使用turtle庫，繪製一個六邊形。
和第一題一樣的思路，只不過旋轉度數需要改為60度，並且迴圈也要改成6次。（可以對照六邊形想象下）
from turtle import *
setup(400,600,200,200)
pensize(10)
pencolor("black")
for i in range(6):
fd(100)
left(60)
done()
1
2
3
4
5
6
7
8
3.turtle疊邊形繪製
使用turtle庫，繪製一個疊邊形，其中，疊邊形內角為80度。
小白第一次知道了疊邊形的存在(；´д｀)ゞ
它長這個樣子
懵圈了兩秒鐘之後發現好像還是和前兩題一樣的思路，只不過……旋轉度數變成了80度並且需要迴圈9次……（可以數一下）
from turtle import *
setup(400,600,200,200)
pensize(5)
pencolor("black")
for i in range(9):
fd(100)
left(80)
done()
1
2
3
4
5
6
7
8
4.turtle同切圓繪製
使用turtle庫，繪製一個同切圓。
一組同切圓的關鍵在於有一個共同的切點，也就是說起始點都是一樣的只是半徑不同。因此我們可以用circle（）函式畫圓，同樣採用迴圈（這裡迴圈次數取決於你想畫幾個圓）
from turtle import *
setup(400,600,200,200)
pensize(5)
pencolor("black")
for i in range(4):
circle(20*i+20)
done()
1
2
3
4
5
6
7
5.長度轉換 I
請編寫程式，完成米和英寸之間的長度轉換，基本需求如下：
1. 輸入英寸，轉換成米； 輸入米，轉換成英寸。
2. 英寸採用in標記，放在數值結尾；米採用m標記，放在數值結尾。
3. 1 米 = 39.37 英寸
4. 輸入引數請使用input()，不要增加提示字串資訊。
和之前的溫度轉換類似的題目
按著那個來就好
a=input()
if a[-1]in['m','M']:
b=eval(a[0:-1])*39.37
print("{:.3f}in".format(b))
elif a[-1]in['n','N']:
b=eval(a[0:-2])/39.37
print("{:.3f}m".format(b))
else:
print("wrong!")
---------------------
本文來自 苜榆 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/weixin_40400161/article/details/82185504?utm_source=copy
2.使用 turtle庫 繪製一朵玫瑰花。
import turtle
# 設定初始位置
turtle.penup()
turtle.left(90)
turtle.fd(200)
turtle.pendown()
turtle.right(90)
# 花蕊
turtle.fillcolor("red")
turtle.begin_fill()
turtle.circle(10,180)
turtle.circle(25,110)
turtle.left(50)
turtle.circle(60,45)
turtle.circle(20,170)
turtle.right(24)
turtle.fd(30)
turtle.left(10)
turtle.circle(30,110)
turtle.fd(20)
turtle.left(40)
turtle.circle(90,70)
turtle.circle(30,150)
turtle.right(30)
turtle.fd(15)
turtle.circle(80,90)
turtle.left(15)
turtle.fd(45)
turtle.right(165)
turtle.fd(20)
turtle.left(155)
turtle.circle(150,80)
turtle.left(50)
turtle.circle(150,90)
turtle.end_fill()
# 花瓣1
turtle.left(150)
turtle.circle(-90,70)
turtle.left(20)
turtle.circle(75,105)
turtle.setheading(60)
turtle.circle(80,98)
turtle.circle(-90,40)
# 花瓣2
turtle.left(180)
turtle.circle(90,40)
turtle.circle(-80,98)
turtle.setheading(-83)
# 葉子1
turtle.fd(30)
turtle.left(90)
turtle.fd(25)
turtle.left(45)
turtle.fillcolor("green")
turtle.begin_fill()
turtle.circle(-80,90)
turtle.right(90)
turtle.circle(-80,90)
turtle.end_fill()
turtle.right(135)
turtle.fd(60)
turtle.left(180)
turtle.fd(85)
turtle.left(90)
turtle.fd(80)
# 葉子2
turtle.right(90)
turtle.right(45)
turtle.fillcolor("green")
turtle.begin_fill()
turtle.circle(80,90)
turtle.left(90)
turtle.circle(80,90)
turtle.end_fill()
turtle.left(135)
turtle.fd(60)
turtle.left(180)
turtle.fd(60)
turtle.right(90)
turtle.circle(200,60)
---------------------
本文來自 溫柔小豬 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/zaq0123/article/details/78573186?utm_source=copy
3.使用 turtle庫 繪製一個顏色圖譜。
小海龜從起點開始畫一個正方形接著向右再畫一個正方形一直向右迴圈五次，然後向下畫一個正方形，接著向左迴圈畫五個正方形。每個正方形的顏色都不一樣。
4.利用 random庫 生成一個包含10個 0 ~ 100 之間的隨機整數的列表。
import random # 隨機數產生10個整數(0-100),放入一個列表中,統計出現次數最多的數字.
number = [] # 1.存放隨機數列表
for i in range(0, 10): # 2.迴圈10次
num = random.randint(0,100) # 3.生成0-100之間的隨機整數
number.append(num) # 4.新增到列表中
print(number)
**拓展：**
import random
# 隨機數產生100個整數(0-100),放入一個列表中,統計出現次數最多的數字.
# 1.存放隨機數列表
number = []
# 2.迴圈100次
for i in range(0, 100):
# 3.生成隨機數
num = random.randint(0,100)
# 4.新增到列表中
number.append(num)
print(number)
# 5.統計每一個數字出現的次數
result = {}
# 5.1 把數字作為key,出現的次數作為值
# 迴圈遍歷每一個數字
for num in number:
# 判斷字典中是否有num這個key
if num in result.keys():
# 讓數字對應的次數+1
result[num] += 1
else:
# 以數字作為key,值為1次
result[num] = 1
# 獲取出現最多的次數
max_num = max(result.values())
print(max_num)
# 根據次數(value)找到對應的數字(key)
for item in result.items():
# 判斷item中的value是否和max_num一致
if item[1] == max_num:
print('出現次數最多的數字為:%s 次數為:%s' % (item[0], item[1]))
---------------------
本文來自 程式猿少年郎 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/shaonianlang75/article/details/80986179?utm_source=copy
5.利用 time庫 將當前日期時間轉化為類似"Sunday,8.January 2017 11:03PM"的格式。
import time
t=time.localtime()
l=time.strftime("%Y-%m-%d %H:%M:%S",t)
print(l)
執行結果2018-09-24 20:27:50
import time
t=time.localtime()
l=time.strftime("%A-%d-%B-%Y %H:%M:%p",t)
print(l)
執行結果Monday-24-September-2018 20:32:PM
[Python time庫的使用](https://blog.csdn.net/MessiNine/article/details/80358004)
第十章
1.使用 jieba.cut() 對"python是最有意思的程式語言"，進行分詞，輸出結果，並將該迭代器轉換為列表型別。
import jieba
Is=jieba.lcut("python是最有意思的程式語言")
print(Is)
2.使用 jieba.cut() 對"今天晚上我吃了義大利麵"進行分詞，輸出結果，並使"義大利麵"作為一個詞出現在結果中。
import jieba
jieba.add_word("義大利麵")
Is=jieba.lcut("今天晚上我吃了義大利麵")
print(Is)
3.自選一篇報告或者演講稿利用 jieba 分析出其詞頻排前5的關鍵詞。
import jieba
f=open("紅樓夢.txt","r",encoding='utf-8')
txt=f.read()
f.close()
words=jieba.lcut(txt)
counts={} #對每個人名進行計數
for word in words:
if len(word)==1:#排除單個字元的分詞結果
continue
else:
counts[word]=counts.get(word,0)+1
items=list(counts.items()) #將字典轉換為記錄列表
items.sort(key=lambda x:x[1],reverse=True) #以第二列排序
for i in range(5): #輸出排列前五的
word,count=items[i]
print("{0:<10}{1:>5}".format(word,count))
4.參考本章最後的例項，選擇你喜歡的小說，統計出場人物詞頻排名。
#Calthreekindom.py
import jieba
text=open('三國演義.txt',"r",encoding='utf-8').read()
words=jieba.lcut(text)
counts={}
for word in words:
if len(word)==1: #排除帶個字元的分詞效果
continue
else:
counts[word]=counts.get(word,0)+1
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range(15):
word,count=items[i]
print("{0:<10}{1:>5}".format(word,count))
5.續上題，將上題結果以詞雲的方式展現，並嘗試美化生成的詞雲圖片。
在這裡插入程式碼片