python | 自定义函数

目录

• 第1节 自定义函数
  • 1.1 函数的定义
  • 1.2 函数的调用
  • 1.3 函数的参数
  • 1.4 全局变量与局部变量
  • 1.5 lambda函数
  • 1.6 递归

第1节 自定义函数

1.1 函数的定义

函数是一段具备特定功能的、可复用的语句组。python中函数用函数名来表示，并经过函数名进行功能调用。它是一种功能抽象，与黑盒相似，因此只要了解函数的输入输出方式便可，不用深究内部实现原理。函数的最突出优势是：

• 实现代码复用：减小重复性工做
• 保证代码一致：只须要修改该函数代码，则全部调用均能受影响

在python中能够把函数分为：系统自带函数、第三方库函数、自定义函数。须要重点掌握的是「自定义函数」。

自定义函数

自定义函数语法：

def 函数名([参数列表]):
    函数体
    return语句

# 示例
def add1(x):
    x = x + 1
    return x

函数经过「参数」和「返回值」来传递信息，并经过「参数列表」和「return语句」实现对二者的控制，详见下图：

注意事项：

• 函数定义时无需声明形参类型（由调用时的实参类型肯定）；也无需指定返回值类型（由return语句肯定）
• 自定义函数即便没有任何参数，也必须保留一队空括号()
• 括号后面的冒号（:）必不可少
• 函数体相对于def关键字必须有缩进关系
• python容许嵌套定义函数
• return语句做用是结束函数调用，并将结果返回给调用者
  • return语句是可选的，能够出如今函数体任意位置
  • 无return语句、有return语句没有执行、有return语句而没有返回值三种状况，函数都返回None

1.2 函数的调用

在定义好函数以后，有两种方式对其进行调用：

• 从本文件调用：直接使用函数名 + 传入参数，如add1(9)
• 从其余文件调用：这种方法有两种实现手段
  • 先指定文件路径 + import 文件名，再用文件名.函数名(参数列表)调用
  • 先指定文件路径 + from 文件名 import 函数名，再用文件名.函数名(参数列表)调用

# 从本文件调用
def add1(x):
    x = x+2
    return x

add1(10)

# 从其余文件调用：从名为addx的文件调用已经定义好的add1函数
import os
os.chdir('D:\\data\\python_file') 

# 从其余文件调用方法1
import addx
addx.add1(4)

# 从其余文件调用方法2
from addx import add1
add1(9)

程序入口

如C、C++等语言都有一个main函数做为程序的入口，main去调用函数库，函数库之间不能相互调用（以下图A和B之间），即程序的运行是从main函数开始。而python是脚本语言，没有统一入口，函数库之间能够互相调用。

因此，python代码执行有两种状况：

• 状况1：直接做为脚本执行，即直接运行该模块
• 状况2：先import到其余python模块中再调用执行（模块重用），其实就是「第三方库」。

而python经过if__name__ == 'main' : 语句，控制这两种不一样状况下的代码执行。

if__name__ == 'main' : 模拟入口

基于python代码执行机理，可用if__name__ == 'main' : 语句模拟程序入口，实现对python代码执行的控制。

• 以脚本直接执行时，if__name__ == 'main': 后面语句会执行（该语句多为函数正确性验证语句）
• 被import到其余模块中执行时，if__name__ == 'main': 后面语句不会执行

# 直接做为脚本执行
def add1(x):
    x = x+2
    return x
add1(10)

# 模块重用执行
import os
os.chdir('D:\\data\\python_file') 
from addx import add1
add1(9)

因此，想运行以脚本直接执行时才执行的命令时，能够将这些命令语句放在if__name__ == 'main': 判断语句以后：

# 自定义一个函数add1
def add1(a):
    a=a+1
    return a
print(__name__)

if __name__ == "__main__":       # 脚本直接执行时，运行后面的语句；被import执行时，不运行后面的语句
    print(add1(2))               # 函数正确性验证和测试

1.3 函数的参数

1.3.1 形参与实参

从上面可知，函数最重要的三部分就是参数、函数体、返回值，而参数分为形参和实参：

• 形参：定义函数时，函数名后面圆括号中的变量
• 实参：调用函数时，函数名后面圆括号中的变量

注意事项：

1. 形参只在函数内部有效，一个函数能够没有形参，但必须有括号()
2. 一般修改形参不影响实参；但若是传递给函数的是「可变序列」(列表、字典、集合)，修改形参会影响实参

def printmax(a,b):       # a, b是形参
    if a>b:
        print(a)
 printmax(3,4)           # 3, 4是实参

# 形参修改不影响实参
def add2(x):
    x = x+2
    return x

x = 10
print(add2(x))  
print(x)

# 形参修改影响实参
def add2(x):              
    x.append(2)           
    return x

y = [1, 1]                # 实参y是变序列（列表、字典、集合）
print(add2(y))            # 函数返回值
print(y)                  # 修改形参影响实参

1.3.2 参数的传递

在定义函数时无需指定形参类型，在调用函数时，python会根据实参类型来自动推断。而定义函数和调用函数的过程，能够简化为下面图中三步，实质就是经过参数和返回值传递信息，而参数的传递发生在第一和第三步。

函数参数多种多样，根据参数传递发生的前后顺序，能够从两个角度学习常见的一些参数：

• 定义函数（形参）：默认值参数、可变参数
• 调用函数（实参）：位置参数、关键字参数、命名关键字参数

同时，这些参数能够组合使用（可变参数没法和关键字参数组合），且参数定义的顺序从左至右分别是：位置参数 >> 默认值参数 >> 可变参数 / 关键字参数 / 命名关键字参数。参数传递还有一种高级用法——参数传递的序列解包。

默认值参数

默认参数就是在调用函数的时候使用一些包含默认值的参数。

# 默认值参数b=5, c=10
def demo(a, b=5, c=10):
    print(a, b, c)

demo(1, 2)

注意事项：

• 默认值参数必须出如今参数列表最右端
• 调用带有默认值参数的函数时，能够对默认值参数进行赋值，也能够不赋值
• 默认值参数只能是不可变对象，使用可变序列做为参数默认值时，程序会有逻辑错误
• 可使用 “函数名.defaults” 查看该函数全部默认参数的当前值

可变参数

可变参数就是容许在调用参数的时候传入多个（≥0个）参数，可变参数分为两种状况：

• 可变位置参数：定义参数时，在前面加一个*，表示这个参数是可变的，能够接受任意多个参数，这些参数构成一个「元组」，只能经过位置参数传递
• 可变关键字参数：定义参数时，在前面加**，表示这个参数可变，能够接受任意多个参数，这些参数构成一个「字典」，只能经过关键字参数传递

# 可变位置参数
def demo(*p):
    print(p)
    
demo(1, 2, 3)                 # 参数在传入时被自动组装成一个元组

# 可变关键字参数
def demo(**p):
    print(p)

demo(b='2', c='5', a='1')     # 参数在传入时被自动组装成一个字典

位置参数

位置参数特色是调用函数时，要保证明参和形参的顺序一致、数量相同。

# 位置参数
def demo(a, b, c):
    print(a, b, c)

demo(1, 2, 3)

关键字参数

关键字参数容许在调用时以字典形式传入0个或多个参数，且在传递参数时用等号（=）链接键和值。关键字参数最大优势，就是使实参顺序能够和形参顺序不一致，但不影响传递结果。

# 关键参数
def demo(a, b, c):
    print(a, b, c)

demo(b=2, c=5, a=1)   # 改变参数顺序对结果不影响

命名关键字参数

命名关键字参数是在关键字参数的基础上，限制传入的的关键字的变量名。和普通关键字参数不一样，命名关键字参数须要一个用来区分的分隔符*，它后面的参数被认为是命名关键字参数。

# 这里星号分割符后面的city、job是命名关键字参数
def person_info(name, age, *, city, job):
    print(name, age, city, job)

person_info("Alex", 17, city="Beijing", job="Engineer")

参数传递的序列解包

参数传递的序列解包，是经过在实参序列前加星号（*）将其解包，而后按顺序传递给多个形参。根据解包序列的不一样，能够分为以下5种状况：

序列解包	示例
列表的序列解包	*[3,4,5]
元组的序列解包	*(3,4,5)
集合的序列解包	*{3,4,5}
字典的键的序列解包	若字典为dic={'a':1,'b':2,'c':3}，则解包代码为：*dic
字典的值的序列解包	若字典为dic={'a':1,'b':2,'c':3}，则解包代码为：*dic.values()

注意事项：

• 对实参序列进行序列解包后，获得的实参值就变成了位置参数，要和形参一一对应
• 当序列解包和位置参数同时使用时，序列解包至关于位置参数，且会优先处理
• 序列解包不能在关键字参数解包以后，不然报错

"""函数参数的序列解包"""
def demo(a, b, c):
    print(a+b+c)

demo(*[3, 4, 5])       # 列表的序列解包
demo(*(3, 4, 5))       # 元组的序列解包
demo(*{3, 4, 5})       # 集合的序列解包

dic = {'a': 1, 'b': 2, 'c': 3}
demo(*dic)             # 字典的键的序列解包              
demo(*dic.values())    # 字典的值的序列解包

"""位置参数和序列解包同时使用"""
def demo(a, b, c):  
    print(a, b, c)

demo(*(1, 2, 3))       # 元组的序列解包
demo(1, *(2, 3))       # 位置参数和序列解包同时使用
demo(c=1, *(2, 3))     # 序列解包至关于位置参数，优先处理，正确用法
demo(*(3,), **{'c': 1, 'b': 2})  # 序列解包必须在关键字参数解包以前，正确用法

1.4 全局变量与局部变量

变量起做用的代码范围称为「变量的做用域」。不一样做用域内变量名能够相同，但互不影响。从变量做用的范围分类，能够把变量分类为：

• 全局变量：指函数以外定义的变量，在程序执行全过程有效
• 局部变量：指在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在

须要特别指出的是，局部变量的引用比全局变量速度快，应考虑优先使用。

全局变量声明

有两种方式能够声明全局变量：

• 方式一：在函数外声明
• 方式二：在函数内部用global声明，又分为两种状况：
  • 状况1：变量已在函数外定义，使用global声明。若进行了从新赋值，则赋值结果会覆盖原变量值
  • 状况2：变量未在函数外定义，使用global在函数内部声明，它将增长为新的全局变量

特殊状况，若局部变量和全局变量同名，那么全局变量会在局部变量的做用域内被隐藏掉。

d = 2       # 全局变量
def func(a, b):
    c = a*b
    return c

func(2, 3)

def func(a, b):
    c = a*b
    d = 2   # 局部变量
    return c

func(2, 3)

"""声明的全局变量，已在函数外定义"""
n = 1
def func(a, b):
    global n
    n = b
    c = a*b
    return c

s = func("knock~", 2)
print(s, n)

"""声明的全局变量，未在函数外定义，则新增"""
def func(a, b):
    c = a*b
    global d  # 声明d为全局变量
    d = 2
    return c

func(2, 3)

"""局部变量和全局变量同名，则全局变量在函数内会被隐藏"""
d = 10                   # 全局变量d
def func(a, b):
    d = 3                # 局部变量d
    c = a+b+d
    return c

func(1, 2)
d

1.5 lambda函数

lambda函数，又称匿名函数，即没有函数名字临时使用的小函数。其语法以下：

lambda 函数参数:函数表达式

注意：
    - 匿名函数只能有一个表达式
    - 该表达式的结果，就是函数的返回值
    - 不容许包含其余复杂语句，但表达式中能够调用其余函数

lambda函数的使用场景，主要在两方面：

• 尤为适用于须要一个函数做为另外一个函数参数的场合，好比排序
• 把匿名函数赋值给一个变量，再利用变量来调用该函数

def f(x, y, z): 
    return x+y+z         # 位置参数
f(1, 2, 3)

def f1(x, y=10, z=10): 
    return x+y+z         # 默认值参数
f(1)

"""把匿名函数赋值给一个变量，再利用变量来调用该函数，做用等价于自定义函数"""
f=lambda x,y,z:x+y+z
f(y=1,x=2,z=3)           #关键值参数

L = ['ab', 'abcd', 'dfdfdg', 'a']
L.sort(key=lambda x: len(x))               # 按长度排序
L

L=[('小明',90,80),('小花',70,90),('小张',98,99)]
L.sort(key=lambda x:x[1],reverse=True)     # 降序排序
L

1.6 递归

在函数内部，能够调用其余函数。若是一个函数在内部调用自身自己，这个函数就是递归函数。但不是的函数调用本身都是递归，递归有其自身的特性：

• 必须有一个明确的递归结束条件，称为递归出口（基例）
• 相邻两次重复之间有紧密的联系，前一次要为后一次作准备（一般前一次的输出就做为后一次的输入）
• 每一次递归，总体问题都要比原来减少，而且递归到必定层次时，要能直接给出结果

从上图可知，递归过程是函数调用本身，本身再调用本身，...，当某个条件获得知足（基例）的时候就再也不调用，而后再一层一层地返回，直到该函数的第一次调用。递归函数的优势是逻辑简单清晰，缺点是过深的调用会致使栈溢出，在Python中，一般状况下，这个深度是1000层，超过将抛出异常。

案例：用递归实现阶乘

# 案例一：用递归实现阶乘
def fact(n):
    if n==0:
        return 1
    else:
        return n*fact(n-1)
fact(5)

# 案例二：实现字符串反转
# 方法1，先转成列表，调用列表的revers方法，再把列表转成字符串
s = 'abcde'
l = list(s)
l.reverse()
''.join(l)

# 方法2，切片的方法
s = 'abcde'
s[::-1]

# 方法3，递归的方法
s = 'abc'
def reverse1(s):
    if s == '':
        return s
    else:
        print(s)
        return reverse1(s[1:])+s[0]

reverse1(s)