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 '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
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 '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
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.续上题，将上题结果以词云的方式展现，并尝试美化生成的词云图片。
在这里插入代码片