python核心编程第二版第五章答案

5.1整形。讲讲Python普通整型和长整型的区别。
普通整型：python的标准型整数是最通用的数字类型,32位机器上，标准整型取值范围是-231到231-1。在64位机器上使用64位编译器编译python，在这个系统上的整型将是64位。python标准整型等价于C的（有符号）长整型。一般用十进制表示整型，python支持八进制和十六进制表示，八进制以“0”开始，十六进制以“0x”或者“0X”开始。

长整型：python的长整型类型可以表达的数值仅仅与机器支持的虚拟内存大小有关，python可以轻松表达很大的整型。长整型类型是标准整型类型的超集，在整型值后加一个L表示这个整型是长整型。虽然小写字母l也可以标记长整型，但是我们建议使用大写L。

5.2操作符。
（a）写一个函数，计算并返回两个数的乘积。

def mul（a，b）：
c = a * b
return c

（b）写一段代码调用这个函数，并显示它的结果

print(mul(3,5))
15

5.3标准类型操作符。写一段脚本，输入一个测验成绩，根据下面的标准，输出它的评分成绩（A-F）
A：90~100
B：80~89
C：70~79
D：60~69
F：<60

def score(a):
    if a >= 90 and a <= 100:
        return 'A'
    elif a >= 80 and a < 90:
        return 'B'
    elif a >= 70 and a < 80:
        return 'C'
    elif a >= 60 and a < 70:
        return 'D'
    elif a < 60:
        return 'F'
print(score(80))

5.4取余。判断给定年份是否是闰年。使用下面的公式。
一个闰年指的是它可以被4整除，但不能被100整除。或者它既可以被4整除又可以被100整除。1992，1996,2000是闰年，但1967和1900不是闰年。下一个闰年的整世纪是2400年。

def runnian():
    a = int(input('Please input a year'))
    try:
        if a % 4 == 0 and a % 100 != 0:
            return '这是一个闰年'
        elif a % 400 == 0:
            return  '这是一个世纪闰年'
        else:
            return  '这不是闰年'
    except:
        return '你必须输入一个年份'

5.5取余。取一个任意小于1美元的金额。然后计算可以换乘最少多少枚硬币。硬币有1美分，5美分，10美分，25美分4种。举例0.76美元应该=3个25美分+1个1美分，如果结果是2个25美分和26个1美分就不符合要求**

def meifen():
    try:
        a = float(input('请输入美元的数值'))
        (b,x) = divmod(a,0.25)
        (c,x) = divmod(x,0.1)
        (d,x) = divmod(x,0.01)
        #用divmod方法取得每次的取余和余数
        print(str(a)+'美元由'+str(b)+'个25美分，'+str(c)+'个10美分和'+str(d)+'个1美分组成。')
    except:
        print('请输入正确的美元数值')
meifen()

5.6算术。写一个计算器程序。你的代码可以接受这样的表达式，两个操作数加一个操作符：N1 操作符`N2,。其中N1与N2是整型或者浮点型，操作符可以是+，-，*，/，%，，计算这个表达式的结果，然后显示出来。提示：可以使用字符串方法split()，但不能使用内建函数eval（）。**

```def jisuanqi():
    try:
        x = str(input('please input your formula'))
        #使用str.split方法将原先的公式分解成一个列表，我们已知的只有符号，因此通过符号将公式分成两部分进行计算。
        if len(x.split('+')) == 2:
            y = float(x.split('+')[0]) + float(x.split('+')[1])
            return y
        elif len(x.split('-')) == 2:
            y = float(x.split('-')[0]) - float(x.split('-')[1])
            return y
        elif len(x.split('*')) == 2:
            y = float(x.split('*')[0]) * float(x.split('*')[1])
            return y
        elif len(x.split('/')) == 2:
            y = float(x.split('/')[0]) / float(x.split('/')[1])
            return y
        elif len(x.split('%')) == 2:
            y = float(x.split('%')[0]) / float(x.split('%')[1])
            return y
        elif len(x.split('**')) == 2:
            y = float(x.split('**')[0]) / float(x.split('**')[1])
            return y
    except:
        print('please input right formula')
jisuanqi()

5.8.几何。计算面积和体积。
（a）正方形和立方体
（b）圆和球

import math
def area_square():
    try:
        a = float(input('please input side length'))
        x = a **2
        return x
    except:
        return 'please input right side length'
def area_circular():
    try:
        a = float(input('please input radius'))
        x = math.pi * a **2
    except:
        return 'please input right radius'
def volume_cube():
    try:
        a = float(input('please input side length'))
        x = a ** 3
        return x
    except:
        return 'please input right side length'
def volume_sphere():
    try:
        a = float(input('please input radius'))
        x = 4/3*math.pi*a ** 3
        return x
    except:
        return 'please input right radius'

volume_sphere()

5.9
（a）因为0开头的数是八进制数
（b）因为l是L的小写不是1
5.10
写一对函数来进行华氏度到摄氏度的转化。公式为C=（F-32）)*（5/9），使用真正的除法

from __future__ import division
def zhuanhua():
    try:
        F = float(input('please input right Fahrenheit degree'))
        C = (F - 32) * (5 / 9)
        return C
    except:
        return 'please input right Fahrenheit degree'
zhuanhua()

5.11取余。
(d)使用循环和算术运算，求出0~20之间所有的偶数。

def zhengchu():
    try:
        a = int(input('please input a number'))
        b = int(input('please input a number'))
        if a % b == 0 or b % a == 0:
            print(True)
        elif a == 0 or b == 0:
            print(True)
        else:
            print(False)
    except:
        return 'please input right number'
zhengchu()

5.12系统限制，写一段脚本确认下你的python能处理的整型，长整型，浮点型和复数范围。

import sys

print(sys.maxsize)
print(-sys.maxsize-1)
print(sys.float_info)
print(sys.long_info)

5.13转换。写一个函数，以小时和分钟表示的时间转换为只用分钟表示的时间。

def time():
    try:
        a = str(input('please input tour time'))
        y = a.split(':')
        z = int(y[0]) * 60 + int(y[1])
        return z
    except:
        return 'please input a right time'
time()

5.14由日利率计算年利率。

def lilv():
    x = float(input('please input daily interest rate'))
    y = (1+x) ** 365 -1
    return y

5.15最大公约数和最小公倍数。请计算2个整型的最大公约数和最小公倍数。
#思路：先用辗转相除法得出最大公因数，再通过辗转相除法得出每次当前2个数/最大公因数的最大公因数，这样就可以得到所有的公因数了，然后把所有的公因数相乘，再把输入的2个数除以这个公因数相乘的乘积得到的2个商，再把2个商相乘，再乘以这个公因数相乘的乘积就可以得到最小公倍数了。这个算法用了2次递归，速度应该较快。

gongyinshu = [1]
这里初始列表为1的原因是因为如果只有一个公因数无法相乘，如果有个1就可以相乘
def xunhuan(a,b):
    min_gongyinshu_1 = 1
    #经过N次循环每次都得到最大公因数
    if quyu(a,b) == 1:
    #递归的基线条件是2个数的最大公因数为1，递归条件就是2个数的最大公因数不为1
        for i in gongyinshu:
            min_gongyinshu_1 *=i
        return min_gongyinshu_1
    #当最大公因数为1的时候，把所取得的公因数相乘
    else:
        #否则每次都取最大公因数，并且存储到列表中，并且把原先的数除以最大公因数再次进行循环
        c = quyu(a, b)
        gongyinshu.append(c)
        a = a / c
        b = b / c
        return xunhuan(a,b)



def quyu(i,j):
    #创建一个递归算法，使用辗转相除法的到最大公约数
    x = max(i,j)
    y = min(i,j)
    z = x % y
    if z == 0:
    #递归的基线条件是当2个数可以整除时，2个数不能整除就是递归条件
        return y
    else:
        return quyu(y,z)


def common_divisor():
    a = int(input('please input a number'))
    b = int(input('please input a number'))
    c = max(a, b)
    d = min(a, b)
    if d == 0:
        print('最大公约数为0', '最小公倍数为' + str(c))

    w = quyu(a, b)
    # 通过辗转相除法得到最大公倍数
    print('最大公约数是' + str(w))
    z = xunhuan(a,b)
    min_gongyinshu = (a / z) * (b / z) *z
    print('最小公倍数是'+str(min_gongyinshu))


common_divisor()

5.16

a = float(input('please input initial amount'))
b = float(input('please input monthly expenses'))
def zhichu(a,b):
    c = a - b
    if c <= 0:
        c = 0
        return print('当前剩余金额' + str(c))
    else:
        print('当前剩余金额' + str(c))
        return zhichu(c,b)
zhichu(a,b)