Python语言程序设计 第五周 函数和代码复用

Python程序设计

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

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

案列：计算n！

def fact（n）：
    s = 1
    for i in range(1,n+1)
        s *= i
    return

y = f(x)
函数定义时，所指定的参数是一种占位符
函数定义后，如果不经过调用，不会被执行
函数定义时，参数是输入、函数体是处理、结果是输出（IPO）
参数是输入，函数体本身是对参数的处理，return给出函数运行的结果
输入、处理、输出，简单理解，函数就是IPO的一种实现，函数也是一段完整代码的封装
函数的使用及调用过程
函数的调用
调用是运行函数代码的方式

def fact(n):
    s = 1
    for i in range(1,1+n)
        s *= i
    return s

所谓调用就是用函数的名称，给定一个具体的值作为参数，所以调用时实际参数的值是运行函数的输入
调用是要给出实际参数
实际参数替换定义中的参数
函数调用后得到返回值

定义不被执行，而调用的时候通过给定实际参数替换定义中的实际参数，获得运算结果
参数个数
函数可以有参数，也可以没有，但必须保留括号

def  <函数名>（）：
    <函数体>
    return <返回值>
def fact（）：
    print("我也是函数")

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

def  <函数名>（<非可选参数>,<可选参数>）：
    <函数体>
    return <返回值>

可选参数一定要放在必选参数传递后面
计算 n!//m

def fact(n,m=1):
    s = 1
    for i in range(1,n+1)
       s *= i
    return s//m

可变参数传递
函数定义时可以设计可变数量参数，既不确定参数总数量

def 《函数名》（《参数》，*b）：
    《函数体》
    return 《返回值》

首先定义函数，确定要给的函数放在前面，最后增加一个*b表达不确定参数

计算 n！乘数
def fact（n，*b）：
    s = 1
    for i in range（1，n+1）：
        s *= i
    for item in b：
        s *= item
    return s

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

def fact（n,m=1）:
    s = 1
    for i in range(1,n+1)：
        s *= i
    return s//m

>>>fact(10,5)位置传递
725760
>>>fact(m=5,n=10)名称传递
725760

函数的返回值
函数可以返回0个或多个结果
return保留字来传递返回值
函数可以有返回值，也可以没有，可以有return，也可以没有
return可以传递0个返回值，也可以传递任意多个返回值
函数返回值可以返回0个或者多个结果

def fact（n,m = 1）:
    s = 1
    for i in range(1,n+1):
        s *= i
    return s//m,n,m
>>>fact(10,5)
(725760,10,5)元组类型


将函数运算的返回值分别赋给3个值,用元组方式返回值
>>>a,b,c = fact(10,5)
>>>print(a,b,c)
725760 10 5

局部变量和全局变量

n,s = 10,100
def fact(n):
    s = 1
    for i in range(1,n+1)
        s *= i
    return s
print(fact(n),s)

>>>
3628800 100
n和s是全局变量
fact（）函数中的n和s是局部变量

规则1：局部变量和全局变量是不同变量
局部变量是函数内部的占位符，与全局变量可能重名但不同
函数运算结束后，局部变量被释放
可以使用global保留字在函数内使用全局变量

规则二：局部变量为组合数据类型且未创建，等同于全局变量
局部变量为组合数据类型且未创建，它的名字又与全局变量名字相同，那它就是个全局变量
列表是组合数据类型
组合数据类型就是由多个数组成的这么一个类型

ls = ["F","f"]  通过使用[]真实创建了一个全局变量列表ls
def func(a):
    ls.append(a)      此处ls是列表数据类型，未真实创建则等同于全局变量
    return
func("C")            全局变量ls被修改
print(ls)

运行结果
>>>
['F','f','C']



ls = ["F","f"]  通过使用[]真实创建了一个全局变量列表ls
def func(a):
    ls = []
    ls.append(a)      此处ls是列表数据类型，未真实创建则等同于全局变量
    return
func("C")            全局变量ls被修改
print(ls)

运行结果
>>>
['F','f']

函数运行过后局部变量会被释放或者消亡
局部变量和全局变量使用规则
基本数据类型，无论是否重名，局部变量与全局变量不同
可以通过global保留字内部声明全局变量
组合数据类型，如果局部变量未真实创建，则是全局变量
lambda函数
lanbda函数返回函数名作为结果
lambda函数是一种匿名函数，既没有名字的函数
使用lambda保留字定义，函数名是返回结果
lambda函数用于定义简单的、能在一行内表示的函数
<函数名> = lambda<参数>：<表达式>
等价于
def <函数名>（<参数>）：
<函数体>
return <返回值>
所不同的是，lanbda函数的函数表现仅能使用表达式来实现，不能使用函数体来实现

>>>f = lambda x,y : x+y
>>>f(10,15)
25

>>>f = lambda : "lambda函数"
>>>print(f())
lambda函数

谨慎使用lambda函数
-lambda函数主要用作一些特定函数或方法的参数
-lambda函数有一些固定使用方式，建议逐步掌握
-一般情况下，建议使用def定义的普通函数
总结
使用保留字def定义函数，lambda定义匿名函数
可选参数（赋初值）、可变参数（*b）、名称传递
保留字return可以返回任意多个结果
保留字global声明使用全局变量，一些隐式规则

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

代码复用
函数和对象是代码复用的2种主要形式
函数：将代码命名在代码层面建立了初步抽象
|
|抽象级别
|
对象：属性和方法 .和.()在函数之上再次组织进行抽象

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

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

函数递归的理解

在函数定义中，调用函数自身是递归的理解

链条：计算过程中存在递归链条
比如n!与（n-1）！就构成了递归链条
基例：存在一个或多个不需要再次递归的基例，基础的实例，它与其它值之间并不存在递归关系，他已经时递归的最末端，类似于数学归纳法

数学归纳法
证明当n取第一个值n0时命题成立
假设当nk时命题成立，证明当n = n（k+1）时命题也成立
递归是数学归纳法思维的编程中的一种体现

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

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

函数递归实例分析
字符串反转
将字符串反转后输出

>>>s[::-1]

def rvs(s):
	if s == "" :
		return s
	else :
		return rvs(s[1:])+s[0]	

斐波那契数列
F(n) = F(n-1)+F(n-2)
函数+分支结构
递归链条
递归基例

def f(n):
	if n == 1 or n ==2:
		return 1
	else:
		return f(n-1)+f(n-2)	

汉诺塔问题

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)

5.4 PyInstaller库的使用

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

将我们写得扩展名为.py的python源代码转换成无需源代码的可执行文件

简单说
我们希望用可执行文件的形式，来执行一段程序，而不是直接用源代码
（因为有时候在linux，windows，mac平台上没有安装python的idle或者python的解释器）
如果没有解释器，我们的程序该如何执行呢，我们首先需要将源程序去编译，或者打包成一个直接可执行的程序，这就是打包所需要的作用

PyInstaller库是第三方库
官方网站：http://www.pyinstaller.org
第三方库：使用前需要额外安装
安装第三方库需要使用pip工具
PyInstaller库的安装
（cmd命令行） pip install pyinstaller
在命令行下执行命令 pip install ，后边加上我们希望安装的库的名称

PyInstaller库的使用说明

参数及描述
-h 查看帮助
–clean 清理打包过程中的临时文件
-D，–onedir 默认值，生成dist文件夹
-F，–onefile 在dist文件夹中只生成独立的打包文件
-i<图标文件名.ico> 指定打包程序使用的图标（icon）文件

实例8 科赫雪花小包裹

科赫曲线也叫雪花曲线，一种用于分形的曲线

科赫雪花小包裹(上)
科赫曲线的绘制
递归思想：函数+分支
递归链条：线段的组合
递归基例：初识线段

#KochDrawV1.py
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)

#KochDrawV1.py
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.penup()
	turtle.goto(-300,-50)
	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()
main()