欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Python课程第五周笔记及作业练习

程序员文章站 2022-04-10 20:56:33
...

Python第五周

笔记

  1. 函数的定义
    函数是一段代码的表示
    -函数是一段具有特定功能的、可重用的语句组
    -函数是一种功能的抽象,一般函数表达特定功能
    -两个作用:降低编程难度和代码复用
    def <函数名>(<参数(0个或多个)>):
    <函数体>
    return <返回值>
    -函数定义时,所制定的参数是一种占位符
    -函数定义后,如果不经过调用,不会被执行
    -函数定义时,参数是输入、函数体是处理、结果是输出(IPO)
  2. 函数的调用
    要用语句将函数调用出来
    3. 参数个数
    函数可以有参数,也可以没有,但必须保留括号
    def <函数名>():
    <函数体>
    return <返回值>
  3. 可选参数传递
    函数定义时可以为某些参数指定默认值,构成可选参数
    def <函数名>(<非可选参数>,<可选参数>):
    <函数体>
    return <返回值>
    函数定义时可以设计可变数量参数,既不确定参数总数量
    def <函数名>(<参数>,*b)
    <函数体>
    return<返回值>
  4. 参数传递的两种方式
    函数调用时,参数可以按照位置或名称方式传递
    ① 位置传递:如fact(10,5)
    ② 名称传递:如fact(m=5,n=10)
  5. 函数的返回值
    函数可以返回0个或多个结果
    -return保留字用来传递返回值
    -函数可以有返回值,也可以没有,可以有return,也可以没有
    -return可以传递0个返回值,也可以传递任意多个返回值

    def fact(n,m=1):
    s=1
    for i in range(1,n+1):
    s=s*i
    return s//m,n,m
    return s//m,n,m,返回三个参数用逗号隔开
    如fact(10,5)
    (725760,10,5)→元组类型
    Or:
>>>a,b,c=fact(10,5)
>>>print(a,b,c)
725760 10 5
  1. 局部变量和全局变量
    程序全局变量,函数局部变量
    Python课程第五周笔记及作业练习
    规则1:局部变量和全局变量是不同变量
    -局部变量是函数内部的占位符,与全局变量可能重名但不同
    -函数运算结束后,局部变量被释放
    -可以使用global保留字在函数内部使用全局变量
    在函数中使用全局变量用到global保留字
    Python课程第五周笔记及作业练习
    规则2:局部变量为组合数据类型且未创建,等同于全局变量
    Python课程第五周笔记及作业练习
    若组合类型,在函数内部没有被真实创建,它的名字又与全局变量名字相同,则其为全局变量。
    Python课程第五周笔记及作业练习
    若组合类型在函数中被创建,则变为局部变量了。
    使用规则:
    -基本数据类型,无论是否崇明,局部变量与全局变量不同
    -可以通过global保留字在函数内部声明全局变量
    -组合数据类型,如果局部变量未真实创建,则是全局变量
  2. lambda函数
    lambda函数返回函数名作为结果
    -lambda函数是一种匿名函数,即没有名字的函数
    -使用lambda保留字定义,函数名是返回结果
    -lambda函数用于定义简单的、能够在一行内表示的函数
    Python课程第五周笔记及作业练习
    谨慎使用lambda函数
    -lambda函数主要用作一些特定函数或方法的参数
    -lambda函数有一些固定使用方式,建议逐步掌握
    -一般情况,建议使用def定义的普通函数
  3. 七段数码管绘制
    Python课程第五周笔记及作业练习
  4. 代码复用与函数递归
    代码复用:
    函数和对象是代码复用的两种主要形式
    函数:将代码命名,在代码层面建立了初步抽象;对象:属性与方法,..(),在函数之上再次组织进行抽象
  5. 模块化设计
    分而治之
    -通过函数或对象封装将程序划分为模块及模块间的表达
    -具体包括:主程序、子程序和子程序间关系
    -分而治之:一种分而治之、分层抽象、体系化的设计思想
    紧耦合与松耦合
    -紧耦合:两个部分之间交流很多,无法独立存在
    -松耦合:两个部分之间交流很少,可以独立存在
    -模块内部紧耦合、模块之间松耦合
  6. 递归
    函数定义中调用函数自身的方式
    两个关键特征
    -链条:计算过程中存在递归链条
    -基例:存在一个或多个不需要再次递归的基例
    类似于数学归纳法
  7. 字符串反转
    将字符串s反转后输出
    s[::-1]从头到尾以-1步长输出,即反转
  8. 斐波那契数列
    Python课程第五周笔记及作业练习
  9. 汉诺塔实例
#汉诺塔
count=0
def hanoi(n,src,dst,mid):
    global count
    if n==1:
        print("{}:{}->{}".format(1,src,dst))
        count+=1
    else:
        hanoi(n-1,src,mid,dst)
        print("{}:{}->{}".format(n,src,dst))
        count+=1
        hanoi(n-1,mid,dst,src)
  1. PyInstaller库的使用
    PyInstaller库是第三方库
    Python课程第五周笔记及作业练习
  2. 科赫雪花小包裹
#科赫雪花小包裹
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(600,600)
    turtle.penup()
    turtle.goto(-200,100)
    turtle.pendown()
    turtle.pensize(2)
    level=5     #3阶科赫曲线,阶数
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
main()

作业

选择题:
单项选择题
点击选项选择正确答案,每题有且仅有一个正确答案

1
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬以下选项不是函数作用的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
增强代码可读性
B
提高代码执行速度
C
降低编程复杂度
D
复用代码
正确答案 B
函数不能直接提高代码执行速度。
2
1 分
#0034003200350035003900321593948385395
下列程序的输出结果为:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
def f(a,b):
a=4
return a+b
def main():
a=5
b=6
print(f(a,b),a+b)
main()

A
11 10
B
10 10
C
11 11
D
10 11
正确答案 D
这里没有全局变量,都是函数局部变量的运算。
3
1 分
#0034003200350035003900321593948385403
以下关于Python函数说法错误的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
def func(a,b):
c=a**2+b
b=a
return c
a=10
b=100
c=func(a,b)+a
A
该函数名称为func
B
执行该函数后,变量a的值为10
C
执行该函数后,变量c的值为200
D
执行该函数后,变量b的值为100
正确答案 C
这里没有全局变量,请在IDLE中执行代码观察结果。
4
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385404以下关于函数调用描述正确的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
函数和调用只能发生在同一个文件中
B
函数在调用前不需要定义,拿来即用就好
C
Python内置函数调用前需要引用相应的库
D
自定义函数调用前必须定义
正确答案 D
函数调用前必须已经存在函数定义,否则无法执行。
Python内置函数直接使用,不需要引用任何模块。
5
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385408以下关于模块化设计描述错误的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
高耦合度的特点是复用较为困难
B
模块间关系尽可能简单,模块之间耦合度低
C
应尽可能合理划分功能块,功能块内部耦合度高
D
应尽可能合理划分功能块,功能块内部耦合度低
正确答案 D
模块内高耦合、模块间低耦合。
6
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385410以下对递归描述错误的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
递归程序都可以有非递归编写方法
B
一定要有基例
C
书写简单
D
执行效率高
正确答案 D
递归不提高程序执行效率。
任何递归程序都可以通过堆栈或队列变成非递归程序(这是程序的高级应用)。
7
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385416以下关于函数说法错误的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
函数可以看做是一段具有名字的子程序
B
函数通过函数名来调用
C
函数是一段具有特定功能的、可重用的语句组
D
对函数的使用必须了解其内部实现原理
正确答案 D
调用函数不需要知道函数内部实现原理,只需要知道调用方法(即接口)即可。
8
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385418哪个选项对于函数的定义是错误的?‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
def vfunc(*a,b):
B
def vfunc(a,*b):
C
def vfunc(a,b):
D
def vfunc(a,b=2):
正确答案 A
def vfunc(*a, b) 是错误的定义:*a表示可变参数,可变参数只能放在函数参数的最后。
9
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385419关于return语句,以下选项描述正确的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
return只能返回一个值
B
函数必须有一个return语句
C
函数可以没有return语句
D
函数中最多只有一个return语句
正确答案 C
函数可以包含0个或多个return语句
10
1 分
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬#0034003200350035003900321593948385420以下关于递归函数基例的说法错误的是:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
A
递归函数的基例不再进行递归
B
递归函数必须有基例
C
递归函数的基例决定递归的深度
D
每个递归函数都只能有一个基例
正确答案 D
每个递归函数至少存在一个基例,但可能存在多个基例。
编程题:
1.
随机密码生成
描述
补充编程模板中代码,完成如下功能:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
以整数17为随机数种子,获取用户输入整数N为长度,产生3个长度为N位的密码,密码的每位是一个数字。每个密码单独一行输出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
产生密码采用random.randint()函数。

#作业第一题
import random

def genpwd(length):
    return random.randint(pow(10,length-1),pow(10,length))

length = eval(input())
random.seed(17)
for i in range(3):
    print(genpwd(length))

连续质数计算
描述
补充编程模板中代码,完成如下功能:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
获得用户输入数字N,计算并输出从N开始的5个质数,单行输出,质数间用逗号,分割。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
注意:需要考虑用户输入的数字N可能是浮点数,应对输入取整数;最后一个输出后不用逗号。

#作业第二题,不太会写,看的答案
def prime(m):
    for i in range(2,m):
        if m % i == 0:
            return False
    return True

n = eval(input())
n_ = int(n)
n_ = n_+1 if n_ < n else n_
count = 5

while count > 0:
    if prime(n_):
        if count > 1:
            print(n_, end=",")
        else:
            print(n_, end="")
        count -= 1 
    n_ += 1

练习

实例7:七段数码管绘制
‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
描述
这是"实例"题,与课上讲解实例相同,请作答检验学习效果。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
七段数码管是一种展示数字的有效方式。

#练习第一题
import turtle,time
def drawGap():
    turtle.penup()
    turtle.fd(5)
def drawLine(draw):     #绘制单段数码管
    drawGap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(digit):   #根据数字绘制七段数码管
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()      #为绘制后续数字确定位置
    turtle.fd(20)       #为绘制后续数字确定位置
def drawDate(date):     #获得要输出的数字 date为日期,格式为'%Y-%m=%d+'
    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))  #通过eval()函数将数字变为整数
def main():
    turtle.setup(800,350,200,200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    turtle.hideturtle()
    turtle.done()
main()

实例8:科赫雪花小包裹
描述
这是"实例"题,与课上讲解实例相同,请作答检验学习效果。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
科赫曲线,也叫雪花曲线。绘制科赫曲线。

#练习第二题
# 请在...补充一行或多行代码

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(level):
    turtle.setup(600,600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
main()
    
try:
    level = eval(input("请输入科赫曲线的阶: "))
    main(level)
except:
    print("输入错误")

任意累积
描述
请根据编程模板补充代码,计算任意个输入数字的乘积。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
注意,仅需要在标注…的地方补充一行或多行代码。

#练习第三题
# 请在...补充一行或多行代码
def cmul(a,*b):
    for item in b:
        a=a*item
    return a

print(eval("cmul({})".format(input())))

斐波那契数列计算
描述
根据编程模板补充代码,计算斐波那契数列的值,具体功能如下:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬

  1. 获取用户输入整数N,其中,N为正整数‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
  2. 计算斐波那契数列的值‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
    如果将斐波那契数列表示为fbi(N),对于整数N,值如下:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
    fbi(1)和fbi(2)的值是1,当N>2时,fbi(N) = fbi(N-1) + fbi(N-2)
    ‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
    请采用递归方式编写。
#练习第四题
# 请在...补充一行或多行代码
def fbi(n):
    if n==1 or n==2:
        return 1
    else:
        return fbi(n-1)+fbi(n-2)

n = eval(input())
print(fbi(n))

汉诺塔实践
描述
汉诺塔问题大家都清楚,这里不再赘述。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
请补充编程模板中代码,完成如下功能:‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
有三个圆柱A、B、C,初始时A上有N个圆盘,N由用户输入给出,最终移动到圆柱C上。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
每次移动步骤的表达方式示例如下:[STEP 10] A->C。其中,STEP是步骤序号,宽度为4个字符,右对齐。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
请编写代码,获得输入N后,输出汉诺塔移动的步骤。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
输入格式
一个整数‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
输出格式
每个步骤一行,每行参考格式如下:[STEP 10] A->C

#练习第五题
# 请在...补充一行或多行代码
steps = 0
def hanoi(src, des, mid, n):
    global steps
    if n == 1:
        steps+=1
        print("[STEP{:>4}] {}->{}".format(steps, src, des))
    else:
        hanoi(src, mid, des, n-1)
        steps+=1
        print("[STEP{:>4}] {}->{}".format(steps, src, des))
        hanoi(mid,des,src,n-1)
N = eval(input())
hanoi("A", "C", "B", N)

Python课程第五周笔记及作业练习

相关标签: 自学