Python小白教学系列 | 用函数实现模块化程序设计

爱被打了一巴掌 2022-02-24 14:06 398阅读 0赞

## 前言 ##

我们把实现某一功能的代码定义为一个函数，在需要使用时，随时调用，十分方便。对于函数，简单理解就是可以完成某功能的代码块，可反复使用！

## 一、函数的创建和调用 ##

**1、创建一个函数**

创建函数也可以理解为定义函数，可以理解为创建一个有某种功能的一个工具。使用def关键字实现。  
格式：

def functionname([parameterlist]):
    	"""comments"""
    	founctionbody
    #参数说明：
    #functionname：为函数名，可以自定义，在调用函数时使用。
    #parameterlist：为可选参数，用于指定向函数中传递的参数。如果有多个参数，各个参数间
    # 用逗号（，）隔开，如果不指定，则表示该函数没有参数。
    #comments：函数指定注释，注释内容为其功能，传递的参数的作用等，让人能快速了解该函数
    #founctionbody：为实现功能的语句块

如果想定义一个什么也不做的空函数，可以用pass语句作为占位符

*示例：*

def Empty_Function() :
    	pass			#占位

**2、调用函数**

调用函数也就是执行函数。

格式：

functionname([parameterlist])
    #参数说明：
    #functionname：要调用的函数名（已经建立好的）
    #parameterlist：用于指定各个参数的值，如果要传递多个参数值，各参数值用逗号隔开
    # 如果没有参数，直接写一对小括号即可

*示例：*

def Empty_Function():
        """ 这是一个用于测试的函数，执行后只能打印‘测试函数！’ """
        print('测试函数！')
    Empty_Function()
    
    运行结果：
    测试函数！

**3、pass 空语句**

在pathon中，pass语句表示空语句，啥都不做，一般起占位作用。

*示例*

def func()
    	pass			#占位

在python3.x中，可以用…来省略代码，而…啥都不做，可以替代pass

*示例：*

def func()
    	...			#替代pass

## 二、参数传递 ##

函数参数的作用是传递数据给函数使用，函数利用接收的数据进行具体的操作处理。

**1、区别形式参数和实际参数**

形式参数：简称形参，定义函数时写的参数叫形参。  
实际参数：简称实参，调用函数时写的参数。  
*示例：*

def func(形参)		#定义func函数
    	pass
    	
    func(实参)		#调用func函数

**2、位置参数**

位置参数也称为必备参数，必须按照正确的数量和顺序传到函数中。

*正确示例：*

def func(name,score):
        print(name+'的成绩为：'+score+'分')
    
    func('小李','98')
    
    运行结果：
    小李的成绩为：98分

a）数量不正确会直接报错

def func(name,score):
        print(name+'的成绩为：'+score+'分')
    
    func('小李')

运行结果：  
![在这里插入图片描述][2019040416403380.png]  
b）顺序不对—>报错/与预期结果不符

def func(name,score):
        print(name+'的成绩为：'+score+'分')
    
    func('100','小李')

运行结果：  
![在这里插入图片描述][20190404164209927.png]

**3、关键字参数**

关键值参数是指使用形参的名字来确定输入的参数值。

def func(name,score):
        print(name+'的成绩为：'+score+'分')
    
    func(score='100',name='小李')	#顺序并没有一致
    
    运行结果：
    小李的成绩为：100分

**4、为参数设定默认值**

调用函数时，如果没有指定某个参数将抛出异常，如果在定义函数时，直接指定形参的默认值，这样，当没有传入参数时，使用定义函数时的默认值。

*格式：*

def functionname(...,parameter1 = defaultvalue1):
    	functionbody
    
    #参数说明：
    #functionname：定义的函数名
    #parameter1 = defaultvalue1：用于指定传入参数的默认值（defaultvalue1）
    #functionbody：函数体

注意：指定默认形参必须在所有参数的后面，否则语法错误！

*示例：*

def func(name = 'none',score='none',):
        print(name+'的成绩为：'+score+'分')
    
    func()					#不传递任何参数
    func('小李')				#传递一个参数
    func('小李','100')		#传递所有参数
    
    运行结果：
    none的成绩为：none分
    小李的成绩为：none分
    小李的成绩为：100分

**5、可变参数**

可变参数也叫不定长参数，即传入的实参数可以是任意个。  
定义可变参数时，主要有两种形式：一种是\*parameter,另一种是\*\*parameter。

a）\*parameter

这种形式表示**接收任意多个实参**并将其放入一个**元组**中。

*示例：*

def func(*score):
        print('接收的参数有:',score)
        for item in score:
            print(item)
            
    li=['十分','八分']
    func(*li)			#传入列表
    func(1,2,3)			#传入多个参数
    func()				#传入0个参数
    
    运行结果:
    接收的参数有: ('十分', '八分')			#列表
    十分
    八分
    接收的参数有: (1, 2, 3)			#多个参数
    1
    2
    3
    接收的参数有: ()					#0个参数

b)\*\*parameter

这种形式接收**任意多个**显示**赋值的**实参,并将其**放入一个字典中**。

*示例：*

*用字典传入实参：*

def func(**tuple):
        print('接收的参数有:',tuple)
        for k,v in tuple.items():
            print(k+'的分数为：'+v+'分')
    
    dic={ '小李':'100','老王':'60'}
    func(**dic)
    
    运行结果：
    接收的参数有: { '小李': '100', '老王': '60'}
    小李的分数为：100分
    老王的分数为：60分

## 三、返回值 ##

在Python中，可以在函数体内使用**return语句**为函数指定返回值，**返回值可以是任意类型**，如果返回**多个值**，这些值会以一个**元组**的形式返回，如果没有return语句，默认返回为空。且无论return语句在任何位置，**只要执行，就会结束函数的执行**。

def func(name):
        Name = ''
        if name == '孙悟空':
            Name = '猴子'
        elif name == '猪八戒':
            Name = '二师兄'
        else:
            Name = '无法找到您输入的信息！'
        return Name
    
    
    while True:
        NAME = input('请输入您要查询的名称：')
        Return_name = func(NAME)
        print(NAME + '的绰号是：' + Return_name)

运行结果：

![在这里插入图片描述][20190404181328601.png]

## 四、变量的作用域 ##

变量的作用域指程序代码能访问该变量的区域，一般根据‘有效范围’，将变量分为“局部变量”和“全局变量”。

***全局变量尽量不要和局部变量重名***

**1、局部变量**

局部变量是指在函数内部定义并使用的变量，函数结束变量也就不复存在。

def func():
        test1='唯有在被追赶的时候，你才能真正奔跑！'
        print('局部变量：'+test1)
    print('局部变量：'+test1)

运行结果：  
![在这里插入图片描述][20190404201938782.png]  
**2、全局变量**

全局变量是能够作用于函数内外的变量。

a）定义在**函数外**的全局变量

test1 = '人生苦短，我学Python！'
    
    def func():
        test1 = '唯有在被追赶的时候，你才能真正奔跑！'
        print('全局变量：' + test1)
        print('局部变量：' + test1)
    
    func()
    print('全局变量：' + test1)
    
    运行结果：
    全局变量：人生苦短，我学Python！
    局部变量：唯有在被追赶的时候，你才能真正奔跑！
    全局变量：人生苦短，我学Python！

b）定义在**函数内**的全局变量

*下列代码可以看到函数内定义的局部变量一般不能改变全局变量*

test = '人生苦短，我学Python！'
    print('函数外：' + test)
    
    def func():
        test = '唯有在被追赶的时候，你才能真正奔跑！'
        print('函数内：' + test)
    
    func()
    print('函数外：' + test)
    
    运行结果：
    函数外：人生苦短，我学Python！
    函数内：唯有在被追赶的时候，你才能真正奔跑！
    函数外：人生苦短，我学Python！

*函数内定义全局变量*

global 变量名

test = '人生苦短，我学Python！'
    print('函数外：' + test)
    
    def func():
        global test
        test = '唯有在被追赶的时候，你才能真正奔跑！'
        print('函数内：' + test)
    
    func()
    print('函数外：' + test)
    
    运行结果：
    函数外：人生苦短，我学Python！
    函数内：唯有在被追赶的时候，你才能真正奔跑！
    函数外：唯有在被追赶的时候，你才能真正奔跑！

## 五、匿名函数 ##

匿名函数是指没有名字的函数，主要应用于在需要一个函数，又不想费神去想函数名的场合。使用lambda表达式创建匿名函数。

*格式：*

lambda 参数 : expression
    #参数说明
    #参数可以是多个参数
    #expression：指定一个实现具体功能的表达式（表达式只能有一个）

*示例：*

import math
    
    r = 4
    result = lambda r: math.pi * r * r
    print('半径为：', r, '的圆，面积为：', result(r))
    
    运行结果：
    半径为： 4 的圆，面积为： 50.26548245743669

在定义使用lambda表达式的时候，需要定义一个变量，用于调用该lambda表达式，否则输出类似结果：

print('半径为：', r, '的圆，面积为：', result)
    
    运行结果：
    半径为： 4 的圆，面积为： <function <lambda> at 0x7f9fcddd5e18>

## 六、高阶函数 ##

**1、abs()**  
简单来说abs的功能就是**求一个数的绝对值**

示例：

print(abs(6))
    print(abs(-6))
    
    运行结果：
    6
    6

特点：abs函数能赋值给变量，也能作为一个传递的参数

*示例：*

f = abs
    print(f(-6))
    
    运行结果：
    6
    ～～～～～～～～～～～～～～～～～～～～～～～～～
    def Abs(a, b, f):
        c = f(a) + f(b)
        return c
        
    print(Abs(6, -6, abs))
    
    运行结果：
    12

**2、map()**

map()函数接收两个参数，一个是函数，一个是序列  
map将传入的函数**依次作用**到**序列的每个**元素，并把**结果作为新的序列返回**

*示例：*

print(list(map(abs,[-9,8,-7])))
    
    运行结果：
    [9, 8, 7]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    def add(a):			#该函数只能接收一个参数
        a=a+1
        return a
    
    print(list(map(add,[1,2,3,4,5])))
    
    运行结果：
    [2, 3, 4, 5, 6]

**3、reduce**

***使用reduce时需要导入funtools包***

reduce:把一个函数作用在一个序列上，这个函数必须接收两个参数，一个函数，一个序列，**reduce把结果继续和序列的下一个元素做累积计算**

*示例：*

from functools import reduce
    
    def add(a,b):		#该函数必须接收两个参数
        return a+b
    
    print(reduce(add,range(1,6)))
    print(reduce(add,[1,2,3,4,5]))
    
    运行结果：
    15
    15

**4、filter()**

**和map()类似**，也接收一个函数和一个序列  
但fileter()把传入的函数**依次作用于每个元素，然后根据返回值**  
是**True或False**来决定**保留还是丢弃**该元素

def add(a):
        if a % 2 == 0:
            return True		#True保留
        else:
            return False	#False丢弃
    
    print(list(filter(add, [1, 2, 3, 4, 5])))
    
    运行结果：
    [2, 4]

**5、sorted()**

功能排序

import random
    
    li=list(random.randint(1,10) for i in range(5))
    print(li)
    print(sorted(li))
    
    运行结果：
    [6, 9, 1, 4, 4]
    [1, 4, 4, 6, 9]

info = { 
    	#商品名称 商品数量 商品价格
    	('apple1',200,32),
    	('apple2',30,12),
    	('apple3',40,2),
    	('apple4',1000,23),
    	('apple5',60,5),
    }
    
    def sorted_by_count(a): #按顺序排序
        return a[1]
    
    print(sorted(info,key=sorted_by_count))	#info为列表，key要依靠的函数
    
    运行结果：
    [('apple2', 30, 12), ('apple3', 40, 2), ('apple5', 60, 5), ('apple1', 200, 32), ('apple4', 1000, 23)]

[2019040416403380.png]: /images/20220224/9d8a3396e3fb4cd18d468e6a37c23922.png
[20190404164209927.png]: /images/20220224/36934cc0572d487b8974fa20b0ed6ef9.png
[20190404181328601.png]: /images/20220224/78868dbcdf47409caa30cd5b8730edda.png
[20190404201938782.png]: /images/20220224/18cc87bf387c4d4389f38cb86b09f1c2.png