python从入门到精通（三）：函数

第十八章：函数

（一）函数的学习架构

• 函数的快速体验
• 函数的基本使用
• 函数的参数
• 函数的返回值
• 函数的嵌套调用
• 在模块中定义函数

（二）函数的快速体验

所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用函数的使用
包含两个步骤:

• 1.定义函数–封装独立的功能
• 2.调用函数–享受封装的成果

函数的作用：在开发程序时，使用函数可以提高编写的效率以及代码的重用，也就是代码的复用率和维护性

练习题：创建九九乘法表函数并调用

1.创建文件chengfabiao.py

def multiple_table():
	i=1
	while i < 10:
		j = 1
		while j <= i:
			print("%d + %d = %d" %(j,i,j*i),end="\t")
			j+=1
		print("")
		i+=1

2.创建文件yinyongcfb.py并调用函数

import chengfabiao
chengfabiao.multiple_table()

3.结果输出

（三）函数的定义

函数的语法格式如下：

def 函数名(参数):
	函数封装的代码
	return 返回值
	...

• def 是英文 define 的缩写

• 函数名称应该能够表达函数封装代码的功能，方便后续的调用

• 函数名称的命名应该符合标识符的命名规则

   可以由字母、下划线和数字组成
   不能以数字开头
   不能与关键字重名
  

通常情况下，在Python语言中定义一个具有特定功能的函数需要符合以下规则：

• 函数代码块以def关键字开头，后接函数标识符名称和形参列表；
• 任何传入的参数和自变量必须放在圆括号内；
• 函数的第一行语句可以选择性地使用文档字符串（即函数说明）；
• 函数内容以冒号起始，并且严格统一缩进；
• 函数都有返回值，默认返回None。

return 返回值 ：
整体作为函数的可选参数，用于设置该函数的返回值。return 语句用于将函数处理结果返回，或者返回一些其他数据。当 return 被执行，代表函数调用结束，也就是说 return 语句的作用之二就是结束函数的调用，所以 return 后的返回代码只能是一行。如果函数体里不写 return，默认返回 None。

# 定义函数：返回 a 和 b 中的最大值
def max_ab(a, b):
    if type(a) == int and type(b) == int:
        return a if a >= b else b
    else:
        return '类型错误' # 处理结果返回

3.1 函数的调用

调用函数很简单的，通过 函数名() 即可完成对函数的调用

函数名()

def hello() :
    print("Hello World!")

hello() # 对函数的调用

练习题：

#注意: 定义好函数之后，之表示这个函数封装了一段代码而已
#如果不主动调用函数，灰数是不会主动执行的
def Say_Hello():
    print("hello 1")
    print("hello 2")
    print("hello 3")
     
Say_Hello()

hello 1
hello 2
hello 3

3.4 函数的文档注释

在开发中，如果希望给函数添加注释，应该在 定义函数 的下方，使用 连续的三对引号
在连续的三对引号 之间编写对函数的说明文字
在函数调用位置，使用快捷键CTRL + Q 可以查看函的说明信息
注意:因为函数体相对比较独立，函数定义的上方，应该和其他代码(包括注释)保留两个空行

菜单栏对应的显示文档说明选项

（四）函数的参数

练习题：求两数之和

def sum_2_num():
    """求两数之和"""
    num1 = 10
    num2 = 20
    sum_num = num1 + num2
    print("%d + %d = %d" % (num1,num2,sum_num))  
    
sum_2_num()

10 + 20 = 30

思考：存在什么问题
函数只能处理固定数值的相加
如何解决?
如果能够把需要计算的数字，在调用函数时，传递到函数内部就好了!

4.1 函数参数的使用

在函数名的后面的小括号内部填写参数
多个参数之间使用，分隔

def sum_2_num(num1,num2):
    """求两数之和"""
    sum_num = num1 + num2
    print("%d + %d = %d" % (num1,num2,sum_num))  #只有函数内部才知道函数的返回值
# 根据参数的顺序依次填写
sum_2_num(50,20)  #并不知道函数的返回值

4.2 参数的作用

函数把具有独立功能的代码块 组织为一个小模块，在需要的时候调用
函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

• 1在函数内部，把参数当做变量使用，进行需要的数据处理
• 2.函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

4.3 函数的形参和实参

形参:定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用。
实参:调用函数时，小括号中的参数，是用来把数据传递到函数内部用的。

4.4 函数的返回值

在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理

• 返回值 是函数完成工作后，最后给调用者的一个结果
• 在函数中使用 return 关键字可以返回结果
• 调用函数一方，可以使用变量来接收函的返回结果
• 注意:return 表示返回后续的代码都不会被执行

def sum_2_num(num1,num2):
    """求两数之和"""
    return num1 + num2
    # 也可指这么写
    # sum_result = num1 +num2
    # return sum_result

#调用函数，并使用 result 变量接收计算结果
result = sum_2_num(50,20)

print("两数之和为 %d" % (result))  

4.5 值传递和引用传递

Python 中，根据实际参数的类型不同，函数参数的传递方式可分为两种：

• 值传递：适用于实参类型为不可变类型（字符串、数字、元组）；
• 引用传递：适用于实参类型为可变类型（列表，字典）。

值传递和引用传递的区别是，函数参数进行值传递后，若形参的值发生改变，不会影响实参的值；而函数参数进行引用传递后，改变形参的值，实参的值也会一同改变

# 值传递
def num(num1):
    num1 += num1  # 形参的值发生改变，不会影响实参的值
    print("形参值为:", num1)
num2 = 20
print("num2的值为:", num2)
num(num2)
print("实参值为:", num2)

# 引用传递
def num_list(num1):
    num1 += num1   #改变形参的值，实参的值也会一同改变
    print("形参值为:", num1)
num2 = [1, 2, 3, 4]
print("num2的值为:", num2)
num_list(num2)
print("实参值为:", num2)

4.6 函数的嵌套

在函数内部调用另一个函数

练习题
需求1

定义一个print_line 函数能够打印*组成的一条分隔线

需求2

定义一个函数能够打印 由任意字符组成 的分隔线

需求3

定义一个函数能够打印 任意字符和重复次数 的分割线

def print_char():
    print("*" * 50)
print_char()

def print_char(char):
    print(char * 50)
print_char("_")

def print_char(char,times):
    print(char * times)
print_char("*",100)

def print_char(char,times):
    print(char * times)

def print_lines(char,times):
    row = 0
    while row < 5:
        print_char(char,times)
        row +=1
print_lines("%",50)

4.7 函数的参数文档注释

点击代码选中前面的黄色灯泡选择insert这行添加文档 注释，自动添加灰色部分的格式，但是参数的具体作用自己补充

ctrl+Q查看添加的文档注释

（五）模块中的函数

模块是Python 程序架构的一个核心概念
模块就好比是工具包，要想使用这个工具包中的工具，就需要 导入import 这个模块
每一个以扩展名py 结尾的Python 源代码文件都是一个模块
在模块中定义的全局变量、函数都是模块能够提供给外界直接使用的工具

创建第一个文件dayinchar.py

def print_char(char,times):
    print(char * times)

def print_lines(char,times):
    row = 0
    while row < 5:
        print_char(char,times)
        row +=1
print_lines("%",50)
name = "xiaoming"

创建第二个模块调用文件tiyanchar.py

import tiyanchar
tiyanchar.print_char("*",50)
tiyanchar.print_chars("_",50)
print(tiyanchar.name)

体验小结
可以在一个Python文件中定义变量或者函数
然后在另外一个文件中使用 import 导入这个模块
导入之后，就可以使用模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数
模块可以让曾经编写过的代码 方便的被 复用!

模块名也是一个标识符
标示符可以由 字母、下划线 和 数字组成
不能以数字开头
不能与关键字重名
注意:如果在给Python文件起名时，以数字开头是无法在PyCharm 中通过导入这个模块的

（六）Pyc文件 (了解)

C是compiled 编译过的意思
操作步骤
1浏览程序目录会发现一个_pycache的目录
2.目录下会有一个 hm_10_分隔线模块cpython-35pyc 文件，cpython-35 表示 Python 解释器的版本3.这个pyc文件是由 Python 解释器将 模块的源码转换为字节码
Python 这样保存字节码是作为一种启动速度的优化
字节码
Python 在解释源程序时是分成两个步骤的
1.首先处理源代码，编译生成一个二进制 字节码
2.再对字节码进行处理，才会生成 CPU 能够识别的机器码
有了模块的字节码文件之后，下一次运行程序时，如果在 上次保存字节码之后 没有修改过源代码Python 将会加载pyc文件并跳过编译这个步骤
当Python 重编译时，它会自动检查源文件和字节码文件的时间截
如果你又修改了源代码，下次程序运行时，字节码将自动重新创建

6.1函数单步调试

利用单步执行查看函数执行的时机

name = "小明" 
#Python 解释器知道下方定义了一个函数
def Say_Hello():
    print("hello 1")
    print("hello 2")
    print("hello 3")
     
print(name)
#只有在程序中，主动调用函数，才会让函数执行
Say_Hello()
print(name)

小明
hello 1
hello 2
hello 3
小明

打开单步调式查看
python是自上而下顺序执行的，执行到def时知道是函数不会执行，继续向下，直到调用函数的语句出现，才会返回来执行函数体内部的代码

思考：能否将函数调用写在函数的上方

。不能!
。因为在使用函数名 调用函数之前，必须要保证 Python 已经知道函数的存在
。否则控制台会提示：
NameError: name’say_hello’is not defined (名称错误: say hello 这个名字没有被定)

6.2 pycharm使用小技巧

F8 Step Over 可以单步执行代码，会把函数整体调用看作是一行代码直接执行。
F7 Step Into 可以单步执行代码，如果执行的行是函数，会进入函数内部一点点执行，更有利于我们了解代码的运行

第十九章：函数的参数和返回值

目标

• 函数参数和返回值的作用
• 函数的返回值 进阶
• 函数的参数 进阶
• 递归函数

（一）函数参数和返回值的作用

函数根据 有没有参数 以及 有没有返回值，可以相互组合，一共有 4种 组合形式

• 1无参数，无返回值

• 2.无参数，有返回值

• 3.有参数，无返回值

• 4有参数，有返回值
  
  定义函数时，是否接收参数，或者是否返回结果，是根据实际的功能需求来决定的!

  1如果函数内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部
  2.如果希望一个函数 执行完成后，向外界汇报执行结果，就可以增加函数的返回值

（二）函数的返回值进阶

在程序开发中，有时候会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理

• 返回值是函数完成工作后，最后给调用者的一个结果
• 在函数中使用 return 关键字可以返回结果
• 调用函数一方，可以使用变量来接收 函数的返回结果

问题:一个函数执行后能否返回多个结果?
示例 – 温度和湿度测量
假设要开发一个函数能够同时返回当前的温度和湿度，完成返回的功能如下

在这里插入代码片

def measure():
	"“返回当前的温度”"
	print("开始测量...")
	temp = 39
	wetness = 50
	print("测量结束...")
	# 元组- 可以包含多个数据，因此可以使用元组让函数一次返回多个值
	# 如果函数返回的类型是元组，小括号可以省略社
	# return (temp, wetness)
	return temp, wetness
result = measure()
print(type(result))
print(result)

# 需要单独的处理温度或者湿度  需要记住下标--不方便
print(result[0])
print(result[1])

2.1 接收函数返回的多个值

如果函数返回的类型是元组，同时希望单独的处理元组中的元素，可以使用多个变量，一次接收函数的返回结果
注意:使用多个变量接收结果时，变量的个数应该和元组中元素的个数保持一致

gl_temp,gl_wetness = measure()
print(gl_temp)
print(gl_wetness)

开始测量...
测量结束...
<class 'tuple'>
(39, 50)

面试题 --交换两个数字
题目要求
1.有两个整数变量a=6,b = 100
2.不使用其他变量，交换两个变量的值

a = 1
b = 100
c = 0
# 解法1: -使用其他变量
c = a
a = b
b = c

#解法2: -不使用其他的变量
a = a + b
b = a - b
a = a - b
#解法3: -Python 专有
a,b = (b,a)
#提示: 等号右边是一个元组，只是把小括号省略了
a,b = b,a

print(a)
print(b)

（三）函数参数的进阶

问题1:在函数内部，针对参数使用 赋值语句，会不会影响调用函数时传递的实参变量?
答案：–不会!
无论传递的参数是 可变还是不可变
只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用

问题2:如果传递的参数是 可变类型在函数内部，使用方法修改了数据的内容，同样会影响到外部的数据

• 使用方法终改列表的内容
• 这里我们分两种情况，1.重新赋值的话，代表改变了原本传递进来的值的引用，相当于重新赋值了
• 不重新复制直接使用方法修改，相当于直接修改了外部变量的引用，因为函数的参数也是传值引用的，所以num_list记录的是gl_list的内存地址，
• 列表又是可变类型的变量，使用方法可以修改内存中的值但是不能改变的引用地址

def demo(num_list):
    print("函数内部的代码")
    # num_list = [7,6,8]
    num_list.append(9)  #使用方法修改了数据的内容
    print(num_list)
    print("函数执行完成")

gl_list = [1,2,3]   
demo(gl_list)   #传递的参数是 可变类型
print(gl_list)   # 影响到外部的数据

面试题 -= +=
在python 中，列表变量调用+=本质上是在执行列表变量的 extend 方法，不会修改变量的引用

def demo(num, num_list):
    print("函数开始")
    # num = num + num
    num += num
    num_list = num_list + num_list   #改变了引用
    # num_list += num_list
    # num_list.extend(num_list)   #没有改变引用 改变了值
    print(num)
    print(num_list)
    print("函数完成")

gl_num = 9
gl_list = [1,2,3]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)

函数开始
18
[1, 2, 3, 1, 2, 3]
函数完成
9
[1, 2, 3, 1, 2, 3]

3.1 位置参数

Python 调用函数时可使用的正式参数类型有四种，分别是位置参数、关键字参数、默认参数和可变长参数。

位置参数，也称必须参数，指的是必须按照正确的顺序将实际参数传到函数中，换句话说，调用函数时传入实际参数的数量和位置都必须和定义函数时的形式参数保持一致。

实参和形参数量必须一致
实参和形参位置必须一致

# 定义一个函数求梯形面积
def area_trapezoid(a, b, h):
    s = (a + b) * h / 2
    print(s)
area_trapezoid(1, 2, 6)

调用时必须传入参数，不然会出现语法错误

#可写函数说明
def printme(str):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不传入参数会报错
printme()

3.2 关键字参数

关键字参数是指使用形式参数的名字来确定输入的参数值。通过此方式指定函数实参时，不再需要与形参的位置完全一致，只要将参数名写正确即可。

不能在关键字参数后面使用非关键字参数
不能对通过一个参数进行多次赋值

# 定义一个函数求梯形面积
def area_trapezoid(a, b, h):
    s = (a + b) * h / 2
    print(s)
area_trapezoid(a=1, b=2, h=6)
area_trapezoid(b=2, h=6, a=1)
area_trapezoid(1, b=2, h=6)

3.3 缺省参数（默认参数）

• 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数，
• 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
• 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用

def 函数名(...形参名,形参名=默认值)：
    代码块

# 定义一个函数求梯形面积
def area_trapezoid(a, b, h=6):
    s = (a + b) * h / 2
    print(s)
area_trapezoid(a=1, b=2)
area_trapezoid(a=1, b=2, h=8)

例如:对列表排序的方法

gl_num_list = [6, 3, 9]
# 默认就是升序排序，因为这种应用需求更多
gl_num_list.sort()
print(gl_num_list)
# 只有当需要降序排序时，才需要传递reverse’ 参数   这就是缺省参数
gl_num_list.sort(reverse=True)
print(gl_num_list)

指定函数的缺省参数
在参数后使用赋值语句，可以指定参数的缺省值

def print_info(name,gender=True):
    """
    :param name: 班上同学的姓名
    :param gender: True 男生 False 女生
    """

    gender_text ="男生"

    if not gender:
        gender_text ="女生"
    print("%s 是 %s"% (name, gender_text))
# 假设班上的同学，男生居多!  可以设置为默认值
print_info("小明")
print_info("老王")
print_info("小美",False)

提示
1.缺省参数，需要使用最常见的值作为默认值!
2.如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递!
3.缺省参数的注意事项

缺省参数的定义位置，必须保证带有默认值的缺省参数在参数列表末尾，所以，以下定义是错误的!.

def print_info(name, gender=True, title) :

2.调用带有多个缺省参数的函数

在调用函数时，如果有多个缺省参数，需要指定参数名这样解释器才能够知道参数的对应关系!

def print_info(name,title,gender=True):
    """
    :param title: 职位
    :param name: 班上同学的姓名
    :param gender: True 男生 False 女生
    """

    gender_text ="男生"

    if not gender:
        gender_text ="女生"
    print("%s 是 %s"% (name, gender_text))
# 假设班上的同学，男生居多!  可以设置为默认值
print_info("小明")
print_info("老王")
print_info("小美",gender=False)   # 指定参数名

3.4 多值参数（可变长参数）

定义支持多值参数的函数，有时可能需要 一个函数 能够处理的参数 个数 是不确定的，这个时候，就可以使用 多值参数

python中有两种多值参数:

• 参数名前增加一个*可以接收 元组
• 参数名前增加 两个**可以接收字典

一般在给多值参数命名时，习惯使用以下两个名字

• *args–存放元组参数，前面有一个*
• **kwargs–存放字典参数，前面有两个**

args是arguments 的缩写，有变量的含义
kw 是keyword 的缩写，kwargs 可以记忆键值对参数

def demo(a, b, *args):
    print(a, b, args)
demo(1, 2, 3)
demo(1, 2, 3, 4, 5, 6)

def demo(a, b, **kwargs):
    print(a, b, kwargs)
demo(1, 2)
demo(1, 2, c=3)
demo(1,2,name="小明",age=18,gender=True)

def demo(num,*args,**kwargs):
    print(num)
    print(args)
    print(kwargs)

demo(1,2,3,4,5,name="小明",age=18,gender=True)

1
(2, 3, 4, 5)
{'name': '小明', 'age': 18, 'gender': True}

提示:多值参数的应用会经常出现在网络上一些大牛开发的框架中，知道多值参数，有利于我们能够读懂大牛的代码

多值参数案例 – 计算任意多个数字的和

需求

• 1.定义一个函数 sum_numbers，可以接收的任意多个整数
• 2.功能要求:将传递的 所有数字累加 并且返回累加结果

def sum(*args):    #推荐
    num = 0
    for i in args:
        num += i
    return num
result = sum(1,2,3,4,5,6,7,8,9,10)
print(result)

def sum(args):  #传递一个值，相当于传递一个元组
    num = 0
    for i in args:
        num += i
    return num
result = sum((1,2,3,4,5,6,7,8,9,10))  #调用是需要多加()  不方便
print(result)

可变长参数在实参的作用

def print_obj(*args):
    print(args)
print_obj("hello")
print_obj(*"hello")

('h', 'e', 'l', 'l', 'o')

3.5 元组和字典的拆包 (知道)

在调用带有多值参数的函数时，如果希望:

• 将一个 元组变量，直接传递给 args
• 将一个字典变量，直接传递给 kwargs

就可以使用拆包，简化参数的传递，拆包 的方式是

• 在元组变量前，增加一个*
• 在字典变量前，增加两个**

def demo(*args,**kwargs):
    print(args)
    print(kwargs)
# 元组变量/字典变量
gl_nums= (1,2,3)
gl_dict ={"age":18,"name":"小明"}
demo(gl_nums,gl_dict) 
demo(*gl_nums,**gl_dict)
demo

3.6 函数的递归

函数调用自身的编程技巧称为递归
递归函数的特点
特点
一个函数内部 调用自己
函数内部可以调用其他函数，当然在函数内部也可以调用自己
代码特点
1.函数内部的代码是相同的，只是针对 参数不同，处理的结果不同
2.当参数满足一个条件时，函数不再执行
这个非常重要，通常被称为递归的出口，否则会出现死循环!

def sum_number(num):
    print(num)
    # 递归的出口，当参数满足某个条件时，不再执行数
    if num == 1:   # 递归的出口
        return     #满足某个条件时，不再执行数
    #自己调用自己
    sum_number(num-1)
sum_number(3)

递归执行流程图

递归案例 --计算数字累加
需求
1.定义一个函数 sum_numbers
2.能够接收一个n 的整数参数
3.计算1+2+…num 的结果

#定义一个函数 sum numbers
# 能够接收一个 num 的整数参数
# 计算1+2+ ..num 的结果
def sum_numbers(num):
    #1.出口
    if num == 1:
        return 1
#2.数字的累如 num+(1...num -1)
# 假设 sum_numbers 能够正确的处理 1...num-1
    temp =sum_numbers(num-1)
    return num + temp
result =sum_numbers(3)
print(result)

提示:递归是一个编程技巧，初次接触递归会感觉有些吃力!在处理不确定的循环条件时，格外的有用，例如:遍历整个文件目录的结构

（四）闭包函数

比如，求比特币一个时间段的平均收盘价（6000、7000、8000…），分别采用定义普通函数和定义闭包函数的方式来求解。

# 采用定义普通函数的方式
list_obj = []         # 全局变量
def average_obj(money):
    list_obj.append(money)
    return sum(list_obj) / len(list_obj)
print(average_obj(6000))
print(average_obj(7000))
print(average_obj(8000))

执行以上代码，输出结果为：

6000.0
6500.0
7000.0

由以上程序可以看出，list_obj 为全局变量，可以在整个文件中修改，所以说该程序是不安全的，需要进一步升级，将全局变量 list_obj 放到函数内部，这就是闭包函数的定义形式。

在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。所以，闭包的构成调条件：

• 在函数嵌套（函数里面再定义函数）的前提下；
• 内部函数使用了外部函数的变量（还包括外部函数的参数）；
• 外部函数返回了内部函数。

# 采用定义闭包函数的方式
def average_obj():
    list_obj = []
    def inner(money):
        list_obj.append(money)
        return sum(list_obj) / len(list_obj)
    return inner
average = average_obj()
print(average(6000))
print(average(7000))
print(average(8000))

执行以上代码，输出结果为：

6000.0
6500.0
7000.0

（五）匿名函数 （lambda）

匿名函数，又称 lambda 函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替

def name([参数1 [,参数2,..参数n]]): 
    表达式
    return 表达式

# 普通函数
def addition1(a, b):
    c = a + b
    return c
print(addition1(1, 2))
# 匿名函数
f = lambda d, e: d + e
print(f(1, 2))

lambda 函数也可以设置多个参数，参数使用逗号 ,

x = lambda a : a + 10
print(x(5))

x = lambda a, b : a * b
print(x(5, 6))

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))