Python语言程序设计基础 第二版（嵩天著）课后答案第五章_python语言程序设计基础第二版第五章答案

思考与练习：
P128
5.1 A
5.2 D
5.3 错误
5.4 合法。但f2（）未创建之前调用无效。如下所示

关于lambda函数（匿名函数）：lambda函数用法

P132

5.5 可选参数必须定义在非可选参数后面。下面例子中，str为非可选参数，times为可选参数。所以times必须定义在str后面。例：

def dup (str,times = 2):
    print(str*times)
dup("knock~") #当没有传入参数时，用默认值代替
#knock~knock~
dup("knock~",4)#若传入参数即按参数值
#knock~knock~knock~knock~

1
2
3
4
5
6
7

5.6 可变数量参数，通过在参数前增加星号（*）实现。带有星号的可变参数只能出现在参数列表的最后。调用时，这些参数被当做元组类型传递到函数中。例：

def vfunc(a,*b):
    print(type(b))  #输出b的类型
    print(b) #(2, 3, 4, 5)被当做元组类型
    for n in b:
        a += n
    return a
print(vfunc(1,2,3,4,5))
#<class 'tuple'>
#(2, 3, 4, 5)
#15
1
2
3
4
5
6
7
8
9
10

5.7 返回值是 元组类型。

以上三题具体解释都可以看课本P128~P130，解释的更具体。
1.关于元组类型：关于元组类型
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
元组中的元素值是不允许修改的，但可以用“+”对元组进行连接组合
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
元组的读取：

元组内置函数：

2.组合数据类型：组合数据类型
序列类型 （字符串、元组、列表）
集合类型 （集合）集合是用大括号 {} 表示
映射类型 （字典）字典是通过大括号来表示 {} 以冒号连接，不同键值对通过逗号连接

序列类型通用操作符和函数12个：

列表特有的函数或方法：

集合类型的操作符：

集合类型的操作函数或方法：

字典类型的函数和方法：

5.8 位置传递：（默认传递）支持可变数量参数，但容易忘记实参的含义，受顺序局限。

​ 名称传递：不易忘记实参的含义，适用于很多个参数时，不受顺序局限，但不支持可变数量参数。

5.9 如果函数里没有创建同名变量，则可以直接使用，不需global声明。

总结 python函数对变量的作用遵守如下原则：

（1）简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量被释放，如有全局同名变量，其值不变。

（2）简单数据类型变量在用global保留字声明后，作为全局变量使用，函数退出后该变量保留且值被函数改变。

（3）对于组合数据类型的全局变量，如果在函数内部没有被真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值。

（4）如果函数内部真实创建了组合数据类型变量，无论是否有 同名全局变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量值不变。
P136

5.10

from datetime import datetime
now = datetime.now()   #初始化一个datetime对象
now = now.strftime("%Y-%m-%d %H:%M:%S") #格式化当前时间
print(now)
#2021-01-24 11:55:40

1
2
3
4
5
6

5.11

from datetime import datetime

now = datetime.now()#初始化一个datetime对象
now = now.strftime("%Y-%m-%d %H:%M:%S")#格式化当前时间
print(now)

now = datetime.now()
now = now.strftime("%Y-%b-%d %H:%M:%S")
print(now)

now = datetime.now()
now = now.strftime("%Y-%B-%d %H:%M:%S")
print(now)

now = datetime.now()
now = now.strftime("%d-%m-%Y %H:%M:%S")
print(now)

now = datetime.now()
now = now.strftime("%d-%b-%Y %H:%M:%S")
print(now)
#运行结果：
# 2021-01-24 12:04:59
# 2021-Jan-24 12:04:59
# 2021-January-24 12:04:59
# 24-01-2021 12:04:59
# 24-Jan-2021 12:04:59
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.12 分别在程序的开始记录一个时间，程序的结尾记录一个时间。用结尾的时间减去开始的时间即程序运行所用的时间。

P141

5.13 使表达更紧凑
5.14 去掉绘画时的箭头。（在第二章时曾接触过）
5.15 为了调用drawDate函数增加“年，月，日”几个字

简单解释一下实例7的代码（这里直接解释的7.2，因为它比较完善）没有过多解释关于turtle库的函数，因为在第二章应该已经掌握了，主要注释了关于七段数码管绘制的问题。

import turtle
import datetime

def drawGap():  #数码管间隔
    turtle.penup()
    turtle.fd(5)

def drawLine(draw): #绘制单段数码管
    drawGap()
    turtle.pendown() if draw else turtle.penup() #若drawLine(True)就落下画笔，drawLine(False)抬起画笔
    turtle.fd(40)
    drawGap()
    turtle.right(90)

def drawDigit(d):  # 根据数字绘制
    drawLine(True) if d in [2, 3, 4, 5, 6, 8, 9] else drawLine(False)   #第一根数码管由课本图5.5可见（没有课本可以自己画一下数字感受一下）：数字2，3，4，5，6，8，9需要用到
    drawLine(True) if d in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawLine(False)#第二根数码管由课本图5.5可见（没有课本可以自己画一下数字感受一下）：数字0, 1, 3, 4, 5, 6, 7, 8, 9需要用到
    drawLine(True) if d in [0, 2, 3, 5, 6, 8, 9] else drawLine(False)   #以下都跟上面的原因一样
    drawLine(True) if d in [0, 2, 6, 8] else drawLine(False)
    turtle.left(90)#画完了下面的方块，转换画笔方向画上面三根管
    drawLine(True) if d in [0, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if d in [0, 2, 3, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if d in [0, 1, 2, 3, 4, 7, 8, 9] else drawLine(False)
    turtle.left(180) #画完之后转换画笔方向为下面的移动画笔做准备
    turtle.penup()  # 为绘制后续数字确定位置
    turtle.fd(20)  # 为绘制后续数字确定位置

def drawDate(date):
    turtle.pencolor('red')
    for i in date:
        if i == '-':
            turtle.write('年', font=('Arial', 18, 'normal'))
            turtle.pencolor('green')
            turtle.fd(40)
        elif i == '=':
            turtle.write('月', font=('Arial', 18, 'normal'))
            turtle.pencolor('blue')
            turtle.fd(40)
        elif i == '+':
            turtle.write('日', font=('Arial', 18, 'normal'))
        else:
            drawDigit(eval(i))

def main():
    turtle.setup(800, 450, 200, 200)
    turtle.penup()
    turtle.fd(-350)
    turtle.pensize(5)
    drawDate(datetime.datetime.now().strftime('%Y-%m=%d+'))
    turtle.hideturtle()
    turtle.done()
main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

运行结果：

解释一下if-else紧凑的问题（两个例子应该可以看懂了吧）。

turtle.pendown() if draw else turtle.penup()#若drawLine(True)就落下画笔，drawLine(False)抬起画笔
#相当于：
if(draw):
        turtle.pendown()
    else:
        turtle.penup()
1
2
3
4
5
6

drawLine(True) if d in [2, 3, 4, 5, 6, 8, 9] else drawLine(False)
#相当于：
if d in [2, 3, 4, 5, 6, 8, 9]:
        drawLine(True)
    else:
        drawLine(False)
1
2
3
4
5
6

datetime类

常用属性：

格式化时间：

P142
5.16 错误
5.17 错误
5.18 松耦合体现在每一个函数之间的功能差异大，每一个函数的工作分明。

紧耦合体现在每个函数中的语言都很简练，功能衔接紧密。

P146
5.19 C

5.20 找到可以结束递归的条件就是基例
递归算法有四个特性：
（1）必须有可最终达到的终止条件，否则程序将陷入无穷循环
（2）子问题在规模上比原问题小，或更接近终止条件；
（3）子问题可通过再次递归调用求解或因满足终止条件而直接求解；
（4）子问题的解应能组合为整个问题的解。

5.21
递归：一个函数在内部调用自己

循环：在哪里都可以，可以不涉及函数，也可以在函数内部

P148

5.22 turtle.speed()：设置绘制的速度，1-10，1最慢，10最快

5.23

import turtle
def koch(size, n):
    if n == 0:
        turtle.fd(size)
    else:
        for angle in [0, -60, 120, -60]:  #修改旋转方向即可
           turtle.left(angle)
           koch(size/3, n-1)
def main():
    turtle.setup(800,400)
    turtle.speed(10)  #控制绘制速度
    turtle.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    koch(600,3)     # 0阶科赫曲线长度，阶数
    turtle.hideturtle()
    turtle.done()
main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：

5.24

import turtle
def koch(size, n):
    if n == 0:
        turtle.fd(size)
    else:
        for angle in [0, 60, -120, 60]: 
           turtle.left(angle)
           koch(size/3, n-1)
def main():
    turtle.setup(800,400)
    turtle.speed(0)  #控制绘制速度
    turtle.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    turtle.pencolor("red")
    koch(600,3)     # 0阶科赫曲线长度，阶数
    turtle.hideturtle()
    turtle.done()
main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

P150

5.25

n = 1   #整数
f = 1.00 #浮点数
str = "123" #字符串
print(type(n),type(f),type(str))
#运行结果：
#<class 'int'> <class 'float'> <class 'str'>
1
2
3
4
5
6

5.26

n = 1   #整数
f = 1.00 #浮点数
str = "123" #字符串
print(len(str))
#运行结果：
#3
1
2
3
4
5
6

len() 返回字符串、列表、字典、元组等长度。对于单纯的整数类型和浮点型并不适用。

5.27

print(hex(1024))
print(hex(12800))
print(hex(65536))
#运行结果：
# 0x400
# 0x3200
# 0x10000

1
2
3
4
5
6
7
8

关于python的68个内置函数：内置函数

程序练习题：
5.1 程序练习题3.5输出了一个简单的田字格，用函数简化其代码，输出如图5.12所示的更大的田字格。

def tian(n): #田字函数
    a = 5*n+1
    for i in range(1,a+1):
        if i % 5 == 1:
            print("+----------" * n+"+") #确定单个田字格的横线
        else:
            print("|          " * n+"|") #确定单个田字格竖线的间隔
def main():
    n = 4
    tian(n)
main()
1
2
3
4
5
6
7
8
9
10
11

运行结果：

5.2 实现isOdd()函数，参数为整数，如果整数为奇数，返回True，否则返回False。

def isOdd(n):
    if n%2!=0:
        return True
    else:
        return False
print(isOdd(eval(input("请输入一个整数："))))
1
2
3
4
5
6

运行结果：

5.3 实现isNum()函数，参数为一个字符串，如果这个字符串属于整数，浮点数或复数的表示，则返回True，否则返回False。

def isNum(str):
    try:
        n = eval(str)
        if type(n) == int or type(n) == float or type(n) == complex:
            return True
        else:
            return False
    except:
        print("输入错误")
print(isNum(input("请输入一个字符串：")))
1
2
3
4
5
6
7
8
9
10

5.4 实现multi（）函数，参数个数不限，返回所有参数的乘积。

def multi(a,*b):
    for i in b:
        a *= i
    return a
print(multi(1,2,3,4))
1
2
3
4
5

5.5 实现isPrime（）函数，参数为整数，要有异常处理。如果整数是质数，返回True，否则返回False。

def isprime(): # 判断一个输入是否为素数
    n = input("请输入一个整数： ")
    try:
        n = eval(n) # 若输入不为数字则报错
        if isinstance(n,int): # 判断为整数
            if n > 1 :# 判断素数
                for i in range(2,n): 
                    if n % i == 0: #遍历除法，若能被整除即不为素数
                        return False # 第一次被整除后就跳出
                        break
                else: 
                    return True
            else: # 小于1的必然不是素数
                return False
        else:
            return False
    except:
        print("输入错误")
isprime()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.6 使用datetime库，对自己的生日输出不少于10种日期格式。

import datetime
bir = datetime.datetime(2021,1,24)
print(bir.strftime("%Y-%m-%d"))
print(bir.strftime("%Y-%B-%d"))
print(bir.strftime("%Y-%b-%d"))
print(bir.strftime("%x"))
print(bir.strftime("%d-%m-%Y"))
print(bir.strftime("%d-%B-%Y"))
print(bir.strftime("%d-%b-%Y"))
print(bir.strftime("%b-%d-%Y"))
print(bir.strftime("%B-%d-%Y"))
print(bir.strftime("%m-%d-%Y"))
#运行结果：
#2021-01-24
# 2021-January-24
# 2021-Jan-24
# 01/24/21
# 24-01-2021
# 24-January-2021
# 24-Jan-2021
# Jan-24-2021
# January-24-2021
# 01-24-2021
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5.7 汉诺塔是学习计算机递归算法的经典入门案例，该案例来源于真实故事。在世界的某个地方有一个很虔诚的宗教组织，其中僧侣维护者一项神圣任务：保持宇宙的时间。在事件的最开始，僧侣在平台上竖立了3的垂直杆，在最左侧杆上有64个不同半径的金色同色圆盘，直径较大的堆放在下方形成了金字塔样子的整体外观。僧侣们的任务是将所有圆盘从最左侧杆子移动到最右侧杆子上，这个宗教认为僧侣们完成任务的时候，万事万物将会化为乌有，宇宙将结束。为了保持神圣的顺序，僧侣们移动圆盘需要遵从特定的规则：一次只能移动一个盘子、盘子只能在3个标杆之前移动、更大的盘子不能放在更小的盘子上面。
汉诺塔是一个数学难题，其问题描述为如何将所有圆盘从A移动到C。请用Python编写一个汉诺塔的移动函数，采用递归方法解决这个难题，要求输入汉诺塔的层数，输出整个移动流程。

c = 0
def han(n,src,dst,mid): # n为第几块圆盘
    global c
    if n == 1:
        print("{}:{}->{}".format(1,src,dst)) # 第一块圆盘的移动
        c += 1
    else: # n与n-1的移动
        han(n-1,src,mid,dst) #把n-1个圆盘移动到中柱子，而右柱子成为中转站
        print("{}:{}->{}".format(n,src,dst)) # 再把第n个圆盘移动到右柱子
        c += 1
        han(n-1,mid,dst,src) # 再把左柱子作为中转站，把在中柱子的n-1个圆盘移动到右柱子
han(3,"A","C","B")
print("共需要{}步".format(c))
1
2
3
4
5
6
7
8
9
10
11
12
13

注：写博客只是为了当笔记看，有任何问题可以评论说，一起互相交流学习