【创作赢红包】【2023】某python语言程序设计跟学第五周内容

1.函数的定义与使用

1.1.函数的理解与定义

函数是一段代码的表示

• 函数是一段具有特定功能的、可重用的语句组
• 函数是一种功能的抽象，一般函数表达特定功能
• 两个作用：降低编程难度和代码复用

def <函数名>(<参数（0个或多个）>):
  <函数体>
  return <返回值>

1.2.函数的使用与调用过程

调用是运行函数代码的方式

函数的调用过程大致如下：

• 当调用一个函数时，Python 会在当前作用域中查找该函数的定义。如果找到了，就会开始执行该函数的代码。

• 在执行函数之前，Python 会创建一个新的局部作用域。该作用域包含函数的参数、函数内部定义的变量以及任何在函数内部创建的变量。

• 在函数内部，Python 会按照顺序执行函数体中的语句。在执行函数体中的语句时，所有的变量引用都会在当前作用域中解析。

• 当遇到 return 语句时，函数会终止执行，并将 return 后面的值返回给调用者。如果函数没有 return 语句，则会返回 None。

• 在函数执行完毕后，Python 会删除该函数的局部作用域，并将控制权返回给调用者。

1.3.函数的参数传递

函数个数：

• 函数可以有参数，也可以没有参数，但是必须保留括号

def <函数名>():
  <函数体>
  return <返回值>

可选参数传递：

• 函数定义时可以为某些参数指定默认值，构成可选参数

def <函数名>(<非可选参数>, <可选参数>):
  <函数体>
  return <返回值>

函数调用时，参数可以按照位置或名称方式传递

1.4.函数的返回值

函数可以返回0个或多个结果

• return保留字用来传递返回值
• 函数可以有返回值，也可以没有，可以有return，也可以没有
• return可以传递0个返回值，也可以传递任意多个返回值

1.5.局部变量和全局变量

局部变量和全局变量是指变量的作用域。

局部变量是在函数内部定义的变量，只能在该函数内部访问。当函数执行完毕后，局部变量的作用域就会结束，这些变量也就被销毁了。

全局变量是在函数外部定义的变量，可以在任何地方被访问，包括函数内部。

如果在函数内部尝试修改全局变量的值，需要使用 global 关键字声明变量，否则 Python 会将其视为一个新的局部变量。

局部变量为组合数据类型且未创建，等同于全局变量

1.6.lambda函数

lambda函数返回函数名作为结果

• lambda是一种匿名函数，既没有名字的函数
• 使用lambda保留字定义，函数名是返回结果
• lambda函数用于定义简单的、能够在一行内表示的函数

语法：

<函数名> = lambda <参数>: <表达式>

示例：

my_list = [1, 2, 3, 4, 5]
new_list = list(map(lambda x: x * 2, my_list))
print(new_list)  # 输出 [2, 4, 6, 8, 10]
# 结果
[2, 4, 6, 8, 10]

2.实例：七段数码管绘制

开发思路：

步骤一：绘制单个数码管

步骤二：获取一段数字，绘制多个数码管

步骤三：获得当前系统时间，绘制对应的数码管

代码：

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(d): #根据数字绘制七段数码管
    drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    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, 350, 200, 200)
    turtle.penup()
    turtle.fd(-350)
    turtle.pensize(5)
#    drawDate('2018-10=10+')
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    turtle.hideturtle()
    turtle.done()
main()

效果：

3.代码复用与函数递归

3.1.代码复用与模块化设计

代码复用：

把代码当成资源进行抽象

• 代码资源化：程序代码是一种用来表达计算的”资源“
• 代码抽象化：使用函数等方法对代码赋予更高级别的定义
• 代码复用：同一份代码在需要时可以被重复使用

函数 和 对象 是代码复用的两种主要方式

函数：将代码命名在代码层面建立了初步抽象

对象：属性和方法，在函数之上再次组织进行抽象

模块化设计：

分而治之

• 通过函数或对象封装将程序划分为模块及模块间的表达
• 具体包括：主程序、子程序和子程序间关系
• 分而治之：一种分而治之、分层抽象、体系化的设计思想

紧耦合和松耦合

• 紧耦合：两个部分之间交流很多，无法独立存在
• 松耦合：两个部分之间交流较少，可以独立存在
• 模块内部紧耦合，模块之间松耦合

紧耦合（Tight coupling）指的是模块之间的依赖关系非常强，一个模块的修改会直接影响到其他模块的运行。这种情况下，模块之间的耦合度很高，代码难以维护和修改。

在Python中，紧耦合的例子可能是实例化一个类时，需要显式地传递其他类的实例对象作为参数，或者在类的方法中直接引用其他类的实例对象。

松耦合（Loose coupling）指的是模块之间的依赖关系相对较弱，一个模块的修改不会对其他模块造成太大的影响。这种情况下，模块之间的耦合度较低，代码更容易维护和修改。

在Python中，松耦合的例子可能是使用接口或回调函数来实现模块之间的通信，或者使用中间件或框架来解耦模块之间的依赖。

3.2.函数递归的理解

递归的定义：

​ 递归是指函数直接或间接地调用自身的过程。在一个递归的过程中，函数会不断地调用自身，直到满足某个条件才停止递归。

有两个关键特征：

• 链条：计算过程中存在递归链条
• 基例：存在一个或多个不需要再次递归的基例

3.3.函数递归的调用过程

递归的实现：

需要函数+分支语句

• 递归本身是一个函数，需要函数定义方式描述
• 函数内部，采用分支语句对输入参数进行判断
• 基例和链条，分别编写对应代码

示例：

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))

该函数接受一个整数参数n，如果n为0，则返回1；否则返回n与factorial(n-1)的乘积。

例如，factorial(5)的计算过程如下：

factorial(5)
= 5 * factorial(4)
= 5 * 4 * factorial(3)
= 5 * 4 * 3 * factorial(2)
= 5 * 4 * 3 * 2 * factorial(1)
= 5 * 4 * 3 * 2 * 1 * factorial(0)
= 5 * 4 * 3 * 2 * 1 * 1
= 120

递归函数需要注意以下几点：

1. 递归函数必须有一个终止条件，否则会陷入无限循环。
2. 递归函数的调用过程会占用栈空间，如果递归深度太大，可能会导致栈溢出。因此，递归函数应该尽量避免过深的递归。
3. 递归函数的执行效率通常较低，因为每次递归调用都需要进行函数调用、参数传递等操作，会产生额外的开销。

4.PyInstaller库基本介绍

PyInstaller是第三方库

• 官网：https://pyinstaller.org/

• 使用前要先安装

• 安装第三方库可以使用pip安装

  pip install pyinstaller
  

将.py源代码转换成无需源代码的可执行文件

.py——>PyInstaller——>{Linux、Winodws、Mac OS}

4.1.PyInstaller库使用说明

在命令行模式输入：

pyinstaller -F <file.py>

常用参数：

• -h：查看帮助
• –clean：清理打包过程中临时文件
• -D：默认值，生成dist文件夹
• -F：在dist文件夹中只生成独立的打包文件
• -i <图标文件名.ico>：指定打包过程中使用的图标文件

5.实例：科赫雪花小包裹

代码：

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 = 3      # 3阶科赫雪花，阶数
    koch(400,level)     
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
    turtle.done()
main()

效果：

生成小包裹：注意名称

pyinstaller -i test.ico -F test1.py