python语言程序设计 答案,python程序设计教程题库_《python程序设计》输入半径,计算圆的周长、面积;球的表面积和体积(结果保留

@书本为Python程序设计与算法基础教程(第二版)-----江红、余青松   编著

第二章、python语言基础

1.编写程序，输入球的半径，计算球的表面积和体积（结果保留两位小数）

#计算圆的表面积和体积：
import math
r = float(input("请输入球的半径："))
area = 4 * math.pi * r**2
volume = 4/3*math.pi*r**3
print(str.format("球的表面积为：{0:2.2f}，体积为：{1:2.2f}",area,volume))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入球的半径：666
球的表面积为：5573889.08，体积为：1237403376.70

2.编写程序，声明函数getValue(b,r,n)，根据本金b，年利率r和年数n计算最终收益v

money = int(input("请输入本金："))
rate = float(input("请输入年利率(<1)："))
years = int(input("请输入年数："))
 
def getValue(b,r,n):
    return b*(1+r)**n
 
print(str.format("本金利率和为：{0:2.2f}",getValue(money,rate,years)))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入本金：10000
请输入年利率(<1)：0.6
请输入年数：6
本金利率和为：167772.16

3. 编写程序，求解一元二次方程x2-10x+16=0

from math import sqrt 
x = (10+sqrt(10*10-4*16))/2
y = (10-sqrt(10*10-4*16))/2
print(str.format("x*x-10*x+16=0的解为：{0:2.2f}，{1:2.2f}",x,y))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
x*x-10*x+16=0的解为：8.00，2.00

4.编写程序，提示输入姓名和出生年份，输出姓名和年龄

import datetime
sName = str(input("请输入您的姓名："))
birthday = int(input("请输入您的出生年份："))
age = datetime.date.today().year - birthday
print("您好！{0}。您{1}岁python打印皮卡丘代码。".format(sName,age))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入您的姓名：zgh
请输入您的出生年份：1999
您好！zgh。您20岁。

第三章、程序流控制

1.编写程序，计算1=2+3+…+100之和

#1.使用for循环（递增）：
total = 0
for i in range(101):
    total += i
print(total) 
 
#2.使用求和公式：
>>> (1 + 100) * 100 /2
5050.0
 
#3.使用累计迭代器itertools.accumulate：
>>> import itertools
>>> list(itertools.accumulate(range(1, 101)))[99]
5050

2.编写程序，计算10+9+8+…+1之和

#使用累计迭代器itertools.accumulate：
>>> import itertools
>>> list(itertools.accumulate(range(1,11)))[9]
55

3.编写程序，计算1+3+5+7+…+99之和

#1.使用for循环（递增）：
total = 0
for i in range(1,100,2):
    total += i
print(total) 
 
#2.使用累计迭代器itertools.accumulate：
>>> import itertools
>>> list(itertools.accumulate(range(1,100,2)))[49]
2500

4.编写程序，计算2+4+6+8+…+100之和

#使用累计迭代器itertools.accumulate：
>>> import itertools
>>> x = list(itertools.accumulate(range(2,101,2)))
>>> x[len(x)-1]
2550

5.编写程序，使用不同的实现方法输出2000~3000的所有闰年

#1.
for y in range(2000,3001):
    if((y % 4 == 0 and y % 100 != 0) or y % 400 == 0):
        print(y,end = ' ')
 
#2.使用calendar模块的isleap()函数来判断：
from calendar import isleap
for y in range(2000,3001):
    if(isleap(y)):print(y,end = " ")
'
运行
运行

6.编写程序，计算Sn=1-3+5-7+9-11…

#1.
n = int(input("项数："))
total = 0
flag = True
for i in range(1,2*n,2):
    if(flag):
        total += i
        flag = False
    else:
        total -= i
        flag = True
print(total)
 
 
#2.
n = int(input("项数："))
total = 0
x = 2
for i in range(1,2*n,2):
    total += pow(-1,x)*i
    x += 1 
print(total)
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>
项数：10
-10

7.编写程序，计算Sn=1+1/2+1/3+…

n = int(input("项数："))
total = 0.0
for i in range(1,n+1):
    total += 1/i 
print(total)
 
#>>>>>>>>>>>>>>>>>>>>>>>>>
项数：10
2.9289682539682538

8.编写程序，打印九九乘法表。要求输入九九乘法表的各种显示效果（上三角，下三角，矩形块等方式）

#矩形块：
for i in range(1,10):
    s = ""
    for j in range(1,10):
        s += str.format("%d * %d = %02d  " %(i, j, i*j))
    print(s)
 
 
#下三角：
for i in range(1,10):
    s = ""
    for j in range(1,i+1):
        s += str.format("%d * %d = %02d  " %(i, j, i*j))
    print(s)
 
#上三角：
for i in range(1,10):
    s = ""
    for k in range(1,i):
        s += "                   "
    for j in range(i,10):
        s += str.format("%d * %d = %02d  " %(i, j, i*j))
    print(s)
'
运行
运行

9.编写程序，输入三角形的三条边，先判断是否可以构成三角形，如果可以，则进一步求三角形的周长和面积，否则报错“无法构成三角形！”

from math import sqrt
 
a = float(input("请输入三角形的边长a："))
b = float(input("请输入三角形的边长b："))
c = float(input("请输入三角形的边长c："))
 
if(a < b): a,b = b,a
if(a < c): a,c = c,a
if(b < c): b,c = c,b
 
if(a < 0 or b < 0 or c < 0 or b+c <= a): print("无法构成三角形！")
else:
    h = (a+b+c)/2
    area = sqrt(h*(h-a)*(h-b)*(h-c))
    print("周长：{0}，面积：{1}".format(a+b+c,area))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入三角形的边长a：4
请输入三角形的边长b：3
请输入三角形的边长c：5
周长：12.0，面积：6.0

10.编写程序，输入x，根据如下公式计算分段函数y的值。请分别用单分支语句，双分支语句结构以及条件运算语句等方法实现

y = (x2-3x)/(x+1) + 2π + sinx （x≥0 ）
y = ln(-5x) + 6√(|x|+e4) - (x+1)3 (x<0)

#单分支语句：
import math
x = float(input("请输入x："))
if(x >= 0):
    y = (x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)
if(x < 0):
    y = math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)
print(y)
 
#双分支语句：
import math
x = float(input("请输入x："))
if(x >= 0):
    y = (x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)
else:
    y = math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)
print(y)
 
#条件运算语句：
import math
x = float(input("请输入x："))
y = ((x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)) if(x >= 0) \
else (math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)) 
print(y)
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#运行1：
请输入x：666
668.2715406628656
#运行2：
请输入x：-666
294079794.1744833

11. 编写程序，输入一元二次方程的3个系数a、b、c，求ax2+bx+c=0方程的解

import math
a = float(input("请输入系数a："))
b = float(input("请输入系数b："))
c = float(input("请输入系数c："))
 
delta = b*b -4*a*c
 
if(a == 0):
    if(b == 0): print("无解")
    else: print("有一个实根：",-1*c/b)
elif(delta == 0): print("有两个相等实根：x1 = x2 = ", (-1*b)/(2*a))
elif(delta > 0): print("有两个不等实根：x1 = {0}，x2 = {1}".format\
                       ((-1*b +math.sqrt(delta))/2*a,(-1*b -math.sqrt(delta))/2*a))
elif(delta < 0): print("有两个共轭复根：x1 = {0}，x2 = {1}".format\
                       (complex( (-1*b)/(2*a),math.sqrt(delta*-1)/(2*a)),complex( (-1*b)/(2*a),-1*math.sqrt(delta*-1)/(2*a))))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#运行一：
请输入系数a：0
请输入系数b：0
请输入系数c：10
无解
 
#运行二：
请输入系数a：0
请输入系数b：10
请输入系数c：5
有一个实根： -0.5
 
#运行三：
请输入系数a：1
请输入系数b：8
请输入系数c：16
有两个相等实根：x1 = x2 =  -4.0
 
#运行四：
请输入系数a：1
请输入系数b：-5
请输入系数c：6
有两个不等实根：x1 = 3.0，x2 = 2.0
 
#运行五：
请输入系数a：5
请输入系数b：2
请输入系数c：1
有两个共轭复根：x1 = (-0.2+0.4j)，x2 = (-0.2-0.4j)

12.编写程序，输入整数n（n≥0）,分别利用for循环和while循环求n!

#1.for循环：
n = int(input("请输入n："))
if(n == 0): total = 1
if(n > 0):
    total = 1
    for i in range(n,0,-1):
        total *= i
print(total)
 
#2.while循环：
n = int(input("请输入n："))
if(n == 0): total = 1
if(n > 0):
    total = 1
    while(n >= 1):
        total *= n
        n -= 1
print(total)
 
#3.使用累计迭代器itertools.accumulate;
>>> import itertools, operator
>>> n = int(input('请输入n：'))
请输入n：7
>>> x = list(accumulate(range(1, n+1), operator.mul))
>>> x[len(x)-1]
5040

13.编写程序，产生两个0~100（包含0和100）的随机整数a和b，求这两个整数的最大公约数和最小公倍数

import random
 
a = random.randint(0,100)
b = random.randint(0,100)
sum = a*b
 
print(a) #输出原来的a，b
print(b)
 
if(a < b): a,b = b,a
 
while(a%b != 0):
    a,b = b,a%b
 
print("最大公约数：{0}，最小公倍数：{1}".format(b,sum/b))
'
运行
运行

第四章、常用内置数据类型

1.编写程序，格式化输出杨辉三角

def generate(numRows):
    l1 = [1]
    n = 0
    while n < numRows:
        print(str(l1).center(66))
        l1 = [sum(t) for t in zip([0] + l1, l1 + [0])]  #利用zip函数算出每一行 
        n += 1                                          #如第二行 zip([0,1],[1,0])=[1,1],以此类推
a=int(input("请输入行数"))
generate(a)
'
运行
运行

2.输入直角三角形的两个直角边，求三角形的周长和面积，以及两个锐角的度数。结果保留一位小数

import math
a = float(input("请输入直角三角形的直角边a："))
b = float(input("请输入直角三角形的直角边b："))
c = math.sqrt(a*a+b*b)
p = a + b + c
area = 0.5*a*b
print("三角形的周长：{0:1.1f}，面积：{1:1.1f}".format(p,area))
 
sina = a/c
sinb = b/c
 
a_degree = round(math.asin(sina) * 180 / math.pi,0)
b_degree = round(math.asin(sinb) * 180 / math.pi,0)
 
print("三角形直角边a的度数：{0}，b的度数：{1}".format(a_degree,b_degree))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入直角三角形的直角边a：3
请输入直角三角形的直角边b：4
三角形的周长：12.0，面积：6.0
三角形直角边a的度数：37.0，b的度数：53.0

3.编程产生0~100（包含0和100）的三个随机数a、b、c，要求至少使用两种不同的方法，将三个数按从小到大的顺序排序

#1.
import random
a = random.randint(0, 100)
b = random.randint(0, 100)
c = random.randint(0, 100)
print(str.format("原始值：{0}，{1}，{2}", a, b, c))
 
if(a > b): a,b = b,a
if(a > c): a,c = c,a
if(b > c): b,c = c,b
print(str.format("增序：{0}，{1}，{2}", a, b, c))
 
#2.使用内置函数max、min、sum:
import random
a = random.randint(0, 100)
b = random.randint(0, 100)
c = random.randint(0, 100)
print(str.format("原始值：{0}，{1}，{2}", a, b, c))
 
maxx = max(a, b, c)
minx = min(a, b, c)
median = sum([a, b, c]) - minx - maxx
print(str.format("增序：{0}，{1}，{2}", minx, median, maxx))
 
#3.使用内置函数sorted:
>>> import random
>>> a = random.randint(0,100)
>>> b = random.randint(0,100)
>>> c = random.randint(0,100)
>>> print("init value: {0} , {1} , {2}".format(a,b,c))
init value: 17 , 6 , 59
>>> sorted([a,b,c])
[6, 17, 59]

4.编程计算有固定工资收入的党员每月所缴纳的党费。

工资基数3000元及以下者，交纳工资基数的0.5%
工资基数3000~5000元者，交纳工资基数的1%
工资基数在5000~10000元者，交纳工资基数的1.5%
工资基数超过10000元者，交纳工资基数的2%

salary = float(input("请输入有固定工资收入的党员的月工资："))
if salary <= 3000: dues = salary*0.005
elif salary <= 5000: dues = salary*0.01
elif salary <= 10000: dues = salary*0.15
else: dues = salary*0.02
 
print("交纳党费：",dues)
'
运行
运行

5.编程实现袖珍计算器，要求输入两个操作数和一个操作符（+、-、*、/、%），根据操作符输出运算结果。注意/和%运算符的零异常问题

a = float(input("请输入操作数（左）："))
b = float(input("请输入操作数（右）："))
operator = input("请输入操作符（+、-、*、/、%）：")
 
if(b == 0 and (operator == '/' or operator == '%')):
    print("分母为零，异常！")
else:
    if operator == '+': result = a+b
    elif operator == '-': result = a-b
    elif operator == '*': result = a*b
    elif operator == '/': result = a/b
    elif operator == '%': result = a%b
    print("{0} {1} {2}= {3}：".format(a,operator,b,result))

6.输入三角形的3条边a、b、c，判断此3边是否可以构成三角形。若能，进一步判断三角形的性质，即为等边、等腰、直角或其他三角形

a = float(input("请输入三角形的边a："))
b = float(input("请输入三角形的边b："))
c = float(input("请输入三角形的边c："))
if(a > b): a,b = b,a
if(a > c): a,c = c,a
if(b > c): b,c = c,b
 
result = "三角形"
if(not(a>0 and b>0 and c>0 and a+b>c)):
    result = '此三边无法构成三角形'
else:
    if a == b == c: result = '等边三角形'
    elif(a==b or a==c or b==c): result = '等腰三角形'
    elif(a*a+b*b == c*c): result = '直角三角形'
 
print(result)

7.编程实现鸡兔同笼问题

已知在同一个笼子里共有h只鸡和兔，鸡和兔的总脚数为f，其中h和f由用户输入，求鸡和兔各有多少只？要求使用两种方法：一是求解方程；二是利用循环进行枚举测试

h = int(input("请输入总头数："))
f = int(input("请输入总脚数："))
 
def fun1(h,f):
    rabbits = f/2-h
    chicken = h-rabbits
    if(chicken < 0 or rabbits < 0): return '无解'
    return chicken,rabbits
 
def fun2(h,f):
    for i in range(0,h+1):
        if(2*i + 4*(h-i) == f):return i,h-i
    return '无解'
 
if(h>0 and f>0 and f % 2 == 0):
    if fun1(h,f)=='无解':
        print("无解")
    else:
        print("方法一：鸡：{0}，兔：{1}".format(fun1(h,f)[0],fun1(h,f)[1]))
        print("方法二：鸡：{0}，兔：{1}".format(fun2(h,f)[0],fun2(h,f)[1]))
else:
    print('输入的数据无意义')    

8.输入任意实数x，计算ex的近似值，直到最后一项的绝对值小于10-6为止

ex = 1 + x + x2/2 + x3/3! + x4/4! + … + xn/n!

x = int(input("请输入任意实数："))
e = 1
i = 1
t = 1
a = 1
while(a >= 10e-6):
    t *= i
    a = pow(x,i)/t
    e += a
    i += 1
print(e)
 
#>>>>>>>>>>>>>>>>>>>>>>>>
请输入任意实数：1
2.7182815255731922

9.输入任意实数a（a>=0），用迭代法求x=√a，要求计算的相对偏差小于10-6

求平方根的公式：Xn+1 = 0.5(Xn + a/Xn)

import math
 
a = int(input("请输入任意实数a(>=0)："))
 
x = a / 2
y = (x + a/x) / 2
 
while(abs(y-x) >= pow(10,-6)):
    x = y
    y = (x + a/x) / 2
 
print(y)
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入任意实数a(>=0)：2
1.414213562373095

10.即有一个数，用3除余2，用5除余3，用7除余2，请问0~1000中这样的数有哪些？

我国古代有位大将，名叫韩信。他每次集合部队，只要求部下先后按1-3，1-5，1-7报数，然后再报告一下各队每次报数的余数，他就知道到了多少人。他的这种巧妙算法被人们称作“鬼谷算”，也叫“隔墙算”，或称为“韩信点兵”，外国人还称它为“中国余数定理”。

for i in range(0,1001):
    if((i % 3 == 2 )and (i % 5 == 3) and (i % 7 == 2)): print(i, end="  ")
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
23  128  233  338  443  548  653  758  863  968

11.一球从100米的高度自由下落，每次落地后反弹回原高度的一半，再落下。求小球在第10次落地时共经过多少米?第10次反弹多高

规律：
第一次下落时的高度：100
第二次下落时的高度（第一次反弹的高度）：50
第三次下落时的高度（第二次反弹的高度）：25
…

n = 10
h_down = 100
h_up = 0
sum = 0
for i in range(1,n+1):
    sum += h_down+h_up
    h_down = h_up = h_down/2
 
print("小球在第十次落地时共经过：{0}米，第十次反弹高度：{1}米".format(sum,h_up))  
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
小球在第十次落地时共经过：299.609375米，第十次反弹高度：0.09765625米

12.猴子第一天摘下若干个桃子，当天吃掉一半多一个；第二天接着吃了剩下的桃子的一半多一个；以后每天都吃了前一天剩下的桃子的一半多一个。到第八天发现只剩一个桃子了。请问猴子第一天共摘了多少个桃子？

这是一个递推问题。某天所剩桃子数x。后一天所剩桃子数y = x - (x/2+1) = x/2-1。则x = 2(y+1)

result = 1
for i in range(8,0,-1):
    print("第{0}天桃子数：{1}".format(i,result))
    result = 2*(result+1)
'
运行
运行

13.计算Sn = 1+11+111+…+111…111（最后一项是n个1）。n是一个随机产生的1~10（包括1和10）中的正整数

import random
n = random.randint(1,10)
x = 1
s = 0
for i in range(1,n+1):
    s += x
    x = 10*x+1
 
print("n = {0}，sn = {1}".format(n,s))
'
运行
运行

第五章、序列数据类型

1.统计所输入字符串中单词的个数，单词之间用空格分隔

s = input("请输入字符串：")
num = 0
for i in s:
    if((i >= 'a' and i <= 'z') or (i >= 'A' and i <= 'Z')):
        num += 1
 
print("其中的单词总数：",num) 
'
运行
运行

2.编写程序，删除一个list里面重复元素

#利用set集合不重复的性质：
lis = [1,2,2,3,3,3,4,5,6,6,6]
s = set(l)
lis = list(s)
print(lis)
 
#既可以去除重复项，又可以保证原来的顺序：
def unique(items):
    items_existed = set()
    for item in items:
        if item not in items_existed:
            yield item
            items_existed.add(item)
 
if __name__ == '__main__':
    a = [1, 8, 5, 1, 9, 2, 1, 10]
    a1 = unique(a)
    print(list(a1))

3.编写程序，将列表[9,7,8,3,2,1,5,6]中的偶数变成它的平方，奇数保持不变

lis = [9,7,8,3,2,1,5,6]
for i,value in enumerate(lis):
    if(value % 2 == 0):lis[i] = value**2
print(lis)
'
运行
运行

4.编写程序，输入字符串，将其每个字符的ASCII码形成列表并输出

s = input("请输入一个字符串：")
l = list()
for i in s:
    l.append(ord(i))
print(l)
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入一个字符串：zgh666
[122, 103, 104, 54, 54, 54]

第八章、函数和函数试编程

1.定义计算并返回第n阶调和数（1+1/2+1/3+…+1/n）的函数，输出前n个调和数

def harmonic(n):
    total = 0.0
    for i in range(1, n+1):
        total += 1.0/i
    return total
n = int(input("n："))
print("输出前n个调和数的值：")
for i in range(1, n+1):
    print(harmonic(i))
'
运行
运行

2.编写程序，定义一个求阶乘的函数fact(n)，并编写测试代码，要求输入整数n（n>=0）。请分别使用递归和非递归方式实现

#1.递归
ef fact(n):
    if n == 0 :
        return 1
    return n*fact(n-1)
 
n = int(input("请输入整数n（n>=0）："))
print(str(n)+" ! =  " + str(fact(n)))
 
#2.非递归：
def fact(n):
    t = 1
    for i in range(1,n+1):
        t *= i
    return t
 
n = int(input("请输入整数n（n>=0）："))
print(str(n)+" ! =  " + str(fact(n)))

3.编写程序，定义一个求Fibonacci数列的函数fib(n)，并编写测试代码，输出前20项（每项宽度5个字符位置，右对齐），每行输出10个。请分别使用递归和非递归方式实现

#1.递归：
def fib(n):
    if (n == 1 or n == 2):
        return 1
    return fib(n-1)+fib(n-2)
 
for i in range(1,21):
    print(str(fib(i)).rjust(5,' '),end = ' ')
    if i %10 == 0:
        print()
 
#2.非递归：
def fib(n):
    if (n == 1 or n == 2):
        return 1
    n1 = n2 = 1
    for i  in range(3,n+1):
        n3 = n1+n2
        n1 = n2
        n2 = n3
    return n3
 
for i in range(1,21):
    print(str(fib(i)).rjust(5,' '),end = ' ')
    if i %10 == 0:
        print()
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 1     1     2     3     5     8    13    21    34    55
   89   144   233   377   610   987  1597  2584  4181  6765

4.编写程序，利用可变参数定义一个求任意个数数值的最小值的函数min_n(a,b,*c)，并编写测试代码。例如对于“print(min_n(8, 2))”以及“print(min_n(16, 1, 7, 4, 15))”的测试代码

def min_n(a,b,*c):
    min_number = a if(a < b) else b
    for n in c:
        if n < min_number:
            min_number = n
    return min_number
 
print(min_n(8, 2))
print(min_n(16, 1, 7, 4, 15))
 
#>>>>>>>>>>>>>>>>>>>>>>>>
2
1
'
运行
运行

5.编写程序，利用元组作为函数的返回值，求序列类型中的最大值、最小值和元素个数，并编写测试代码，假设测试代码数据分别为s1=[9, 7, 8, 3, 2, 1, 55, 6]、s2=[“apple”, “pear”, “melon”, “kiwi”]和s3="TheQuickBrownFox"
 

def func(n):
    return (max(n),min(n),len(n))
    
s1=[9, 7, 8, 3, 2, 1, 55, 6]
s2=["apple", "pear", "melon", "kiwi"]
s3="TheQuickBrownFox"
 
for i in (s1,s2,s3):
    print("list = ", i)
    t = func(i)
    print("最大值 = {0}，最小值 = {1}，元素个数 = {2}".format(t[0], t[1], t[2]))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
list =  [9, 7, 8, 3, 2, 1, 55, 6]
最大值 = 55，最小值 = 1，元素个数 = 8
list =  ['apple', 'pear', 'melon', 'kiwi']
最大值 = pear，最小值 = apple，元素个数 = 4
list =  TheQuickBrownFox
最大值 = x，最小值 = B，元素个数 = 16

第九章、

1.编写程序，创建类MyMath，计算圆的周长和面积以及球的表面积和体积，并编写测试代码，结果均保留两位小数

import math
class MyMath:
    def __init__(self, r):
        self.r = r
    def perimeter_round(self):
        return 2 * math.pi * self.r
    def area_round(self):
        return math.pi * self.r * self.r
    def area_ball(self):
        return 4 * math.pi * self.r ** 2
    def volume_ball(self):
        return 4 / 3 * math.pi *self.r ** 3
 
if __name__ == '__main__':
    n = float(input("请输入半径："))
    m = MyMath(n)
    print("圆的周长 = {0:.2f}\n圆的面积 = {1:.2f}\n球的表面积 = {2:.2f}\n球的体积 = {3:.2f}".\
          format(m.perimeter_round(), m.area_round(), m.area_ball(), m.volume_ball()))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入半径：5
圆的周长 = 31.42
圆的面积 = 78.54
球的表面积 = 62.83
球的体积 = 523.60

2.编写程序，创建类Temperature，其包含成员变量degree（表示温度）以及实例方法ToFahrenheit（将摄氏温度转换为华氏温度）和ToCelsius（将华氏温度转换为摄氏温度），并编写测试代码

class Temperature:
    def __init__(self, degree):
        self.degree = degree
    def toFahrenheit(self):
        return self.degree*9/5 + 32
    def toCelsius(self):
        return (self.degree -32) * 5/9
 
if __name__ == '__main__':
    n1 = float(input("请输入摄氏温度："))
    t1 = Temperature(n1)
    print("摄氏温度 = {0:.2f}， 华氏温度 = {1:.2f}".format(n1, t1.toFahrenheit()))
    n2 = float(input("请输入华氏温度："))
    t2 = Temperature(n2)
    print("摄氏温度 = {0:.2f}， 华氏温度 = {1:.2f}".format(t2.toCelsius(), n2))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入摄氏温度：30
摄氏温度 = 30.00， 华氏温度 = 86.00
请输入华氏温度：70
摄氏温度 = 21.11， 华氏温度 = 70.00

第十章、

1.编写程序，创建一个实现+、-、*、/和**（幂）运算的模块MyMath.py，并编写测试代码

#先创建一个模块代码MyMath.py
def add(x,y):
    return x+y
def sub(x,y):
    return x-y
def mul(x,y):
    return x*y
def div(x,y):
    if y == 0: return "除数不能为零！"
    return x/y
def power(x,y):
    return x**y
'
运行
运行

测试代码：

>>> import MyMath
>>> dir(MyMath)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'add', 'div', 'mul', 'power', 'sub']
>>> MyMath.add(10,12)
22
>>> MyMath.div(5,4)
1.25
>>> MyMath.mul(9,9)
81
>>> MyMath.sub(6,1)
5
>>> MyMath.power(2,10)
1024

2.编写程序，创建一个求圆的面积和球体体积的模块AreaVolume.py，并编写只有独立运行时才执行的测试代码，要求输入半径，输出结果保留两位小数

#先创建一个模块代码AreaVolume.py：
import math
def area(r):
    return math.pi * r * r
def volume(r):
    return 4/3 * math.pi * r**3
 
#测试代码：
import AreaVolume
 
if __name__ == '__main__':
    r = float(input("请输入半径："))
    print("圆的面积：{0:.2f}，球的体积：{1:.2f}".\
          format(AreaVolume.area(r), AreaVolume.volume(r)))
 
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入半径：5.1
圆的面积：81.71，球的体积：555.65

3.编写程序，创建输出命令行参数个数以及各参数内容的模块SysArgvs.py，并编写测试代码

#先创建一个模块代码SysArgvs.py
import sys
print("参数个数：", len(sys.argv))
for i,x in enumerate(sys.argv):
    print("argv[{0}] = {1}".format(i, x))
'
运行
运行

测试（cmd）：

D:\zgh\desktop>python SysArgvs.py
参数个数： 1
argv[0] = SysArgvs.py
 
D:\zgh\desktop>python SysArgvs.py a b c
参数个数： 4
argv[0] = SysArgvs.py
argv[1] = a
argv[2] = b
argv[3] = c