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~

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

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

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

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()

运行结果:
在这里插入图片描述
解释一下if-else紧凑的问题(两个例子应该可以看懂了吧)。

turtle.pendown() if draw else turtle.penup()#若drawLine(True)就落下画笔,drawLine(False)抬起画笔
#相当于:
if(draw):
        turtle.pendown()
    else:
        turtle.penup()
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)

datetime类
在这里插入图片描述

常用属性:
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
格式化时间:

格式化字符串意义
%Y四位数的年份表示(000-9999)
%y两位数的年份表示(00-99)
%m月份(01-12)
%d月内中的一天(0-31)
%H24小时制小时数(0-23)
%I12小时制小时数(01-12)
%M分钟数(00=59)
%S秒(00-59)
%a本地简化星期名称
%A本地完整星期名称
%b本地简化的月份名称
%B本地完整的月份名称
%c本地相应的日期表示和时间表示
%j年内的一天(001-366)
%p本地A.M.或P.M.的等价符
%U一年中的星期数(00-53)星期天为星期的开始
%w星期(0-6),星期天为星期的开始
%W一年中的星期数(00-53)星期一为星期的开始
%x本地相应的日期表示
%X本地相应的时间表示
%Z当前时区的名称

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()

运行结果:
在这里插入图片描述
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()

运行结果:
在这里插入图片描述
P150

5.25

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

5.26

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

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

5.27

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

关于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()

运行结果:
在这里插入图片描述
5.2 实现isOdd()函数,参数为整数,如果整数为奇数,返回True,否则返回False。

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

运行结果:
在这里插入图片描述
在这里插入图片描述

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("请输入一个字符串:")))

5.4 实现multi()函数,参数个数不限,返回所有参数的乘积。

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

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()

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

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))

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

  • 134
    点赞
  • 679
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
### 回答1: 当然,我很乐意为您提供关于Python语言程序设计基础的信息。以下是第七章的答案: 第七章:循环结构 1. 什么是循环结构? 循环结构是指在程序中,多次执行相同或类似的一组指令的结构。在Python中,循环结构主要有两种:for循环和while循环。 2. for循环和while循环的区别是什么? for循环用于遍历一个序列(如列表、元组、字符串等)或其他可迭代对象,每次迭代会取出序列中的一个元素进行处理。while循环则根据条件表达式的真假情况来反复执行代码块,直到条件不再满足为止。 3. for循环的语法是什么? for循环的语法如下: ``` for 变量 in 序列: 代码块 ``` 其中,变量为循环变量,序列为被遍历的对象。每次循环时,变量会被赋值为序列中的一个元素,并执行代码块。 4. while循环的语法是什么? while循环的语法如下: ``` while 条件表达式: 代码块 ``` 其中,条件表达式为一个布尔表达式,每次循环时都会被重新计算,只有在表达式为True时才会执行代码块。 5. 如何使用break和continue控制循环流程? break语句可以在循环内部终止循环,而continue语句可以跳过本次循环,继续执行下一次循环。它们的使用方法如下: ``` # 使用break语句终止循环 for 变量 in 序列: if 条件表达式: break # 其他代码块 # 使用continue语句跳过本次循环 for 变量 in 序列: if 条件表达式: continue # 其他代码块 ``` 6. 如何使用else语句与循环配合使用? 在循环结构中,else语句可以与for和while循环配合使用。它的作用是在循环结束后执行一段代码块,但只有在循环没有被break语句终止时才会执行。具体使用方法如下: ``` # 使用for循环与else语句配合使用 for 变量 in 序列: # 循环代码块 else: # 在循环正常结束后执行的代码块 # 使用while循环与else语句配合使用 while 条件表达式: # 循环代码块 else: # 在循环正常结束后执行的代码块 ``` 希望这些抱歉,您的问题没有完整提出来。请重新提交完整的问题,我将尽力回答。 ### 回答2: 第七章主要讲述了函数的知识。函数是一段可以反复调用的代码块,可以完成特定的功能。函数的使用可以提高代码的复用性和开发效率。 第一题:函数定义语法 函数定义语法如下: ```python def function_name(parameters): """函数文档字符串""" function_body return [expression] ``` 其中,函数名是由字母、数字和下划线组成的标识符。参数可以是位置参数、默认参数、关键字参数和可变参数。函数文档字符串是用来描述函数功能的字符串,可以通过函数的__doc__属性来获取。函数体中包含了具体的实现代码,可以通过return语句返回结果。 第二题:调用函数 调用函数的语法如下: ```python function_name(arguments) ``` 其中,函数名是需要调用的函数名,arguments是函数的参数。函数的返回值可以使用变量来存储,也可以直接使用。 第三题:函数的参数类型 函数的参数类型包括位置参数、默认参数、关键字参数和可变参数。 位置参数:按照参数顺序依次传递参数,调用函数时需要按照函数定义时的参数顺序传递参数。 默认参数:给参数设置默认值,调用函数时可以不传递这些参数,使用默认值。 关键字参数:根据参数名称来传递参数,调用函数时可以不按照函数定义时的参数顺序传递参数,而是按照参数名来传递。 可变参数:传递可变数量的参数,可以使用*args表示不带参数名的可变参数,使用**kwargs表示带参数名的可变参数。 第四题:函数定义中可变参数的用法 函数定义中可变参数的用法是通过*args和**kwargs来定义不定数量的参数。其中,*args表示不带参数名的可变参数,可以使用for循环遍历获取参数值;**kwargs表示带参数名的可变参数,可以使用字典的方式获取参数值。 ```python def func(*args, **kwargs): for i in args: print(i) for key, value in kwargs.items(): print(key, value) ``` 第五题:函数返回值 函数可以使用return语句返回结果,返回值可以是单个值,也可以是列表、元组和字典等数据结构。如果函数没有return语句,则默认返回None。 ```python def add(a, b): return a + b result = add(1, 2) print(result) # 3 ``` 第六题:递归函数的特点 递归函数是指在函数内部调用自身的函数。递归函数的特点如下: 1. 递归函数必须有一个结束条件,否则会无限调用下去导致栈溢出。 2. 递归函数的效率不如循环,因为每次调用函数都需要保存函数的信息,占用内存。 3. 递归函数可以处理一些复杂的问题,尤其是与树、图相关的问题,其代码可读性和简洁性都很好。 第七题:Python中的Lambda表达式 Lambda表达式是一种匿名函数,可以在需要函数对象的任何地方使用,它的语法如下: ```python lambda arguments: expression ``` 其中,arguments为函数的参数,expression为函数的返回结果。Lambda表达式的执行结果为一个函数对象,可以通过调用该函数对象来获取结果。 ```python f = lambda x, y: x + y result = f(1, 2) print(result) # 3 ``` Lambda表达式通常用于函数式编程中的参数传递,可以让我们更方便地定义简单的函数。 ### 回答3: 第七章主要讲解了函数的概念、定义及其常见应用。本章主要包括以下几个方面的内容: 1、函数的定义和调用:函数是一段代码的封装,可以通过函数名来调用这段代码。在Python中,定义一个函数需要用到关键字“def”,然后是函数名和参数列表,最后是函数体。完成函数的定义后,可以通过函数名来调用这个函数。 2、函数的参数传递:Python中函数的参数传递有两种方式,分别是值传递和引用传递。在值传递的情况下,函数内对参数的修改对外界是不可见的;在引用传递的情况下,函数内对参数的修改对外界也是可见的。 3、函数的返回值:函数可以通过return语句来返回一个值,并且可以在调用函数的地方把这个返回值赋给一个变量。如果函数没有显式地指定返回值,则默认返回None。 4、变量的作用域:Python中的变量作用域主要有全局作用域和局部作用域。如果在函数内部定义了一个变量,则它只在函数内部有效,在函数外部不能访问。而全局变量则可以在函数内部和外部都可以访问。 5、内置函数:Python内置了很多函数,它们可以直接使用。常见的内置函数有print、input、len、range等。 除此之外,本章还介绍了常见的高阶函数,包括map、reduce、filter和lambda函数等。这些函数在Python中被广泛应用,在数据处理、函数式编程等方面发挥了重要作用。 此外,在本章的课后习题中,还有一些实践性较强的编程题目,可以帮助读者进一步巩固所学知识。通过掌握本章的内容,读者可以更加深入地理解函数的概念和应用,为以后的Python编程奠定扎实的基础

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值