第六章 Python函数

系列文章目录

第一章 Python 基础知识

第二章 python 字符串处理

第三章 python 数据类型

第四章 python 运算符与流程控制

第五章 python 文件操作

第六章 python 函数

第七章 python 常用内建函数

第八章 python 类(面向对象编程)

第九章 python 异常处理

第十章 python 自定义模块及导入方法

第十一章 python 常用标准库

第十二章 python 正则表达式

第十三章 python 操作数据库

---

文章目录

• 函数定义与调用
• 函数参数
• • 接受函数
  • 参数默认值
  • 接受任意数量参数
• 匿名函数(Lambda)
• 作用域
• 闭包
• 函数装饰器
• • 无参数
  • 带参数
• 总结

---

函数定义与调用

函数：是指一段可以直接被另一段程序或代码引用的程序或代码。

在编写代码时，常将一些常用的功能模块编写成函数，放在函数库中供公共使用，可减少重复编写程序段和简写代码结构

语法：

def 函数名称(参数1,参数2,...):

<代码块>

return <表达式>

# 示例
def hello():
    print("hello world!!!")
hello()  # 调用函数

def h2():
    return "123"
print(h2())

函数参数

接受函数

<示例：求和函数

def f(a, b):

return a + b

print(f(1,2)) # 按参数位置赋值

print(f(b=2,a=1)) # 按对应关系赋值

示例：生成序列列表

def seq(n):

result = []

x = 0

while x < n:

result.append(x)

x += 1

return result

print(seq(9))

# 传参
def h2(n):
    # return "hello %s" %{n}
    return f"hello {n}"
print(h2('wang'))
# 求和
def SUM(a,b):
    c = a+b
    return c
print(SUM(3,4))
print(SUM(a=1,b=2))
# 生成序列列表
def seq(n):
    result = []
    x = 0
    while x <= n:
        result.append(x)
        x += 1
    return result
print(seq(9))

参数默认值

参数默认值：预先给参数定义默认值，如果调用函数时没指定该值，则用默认值。

示例：

def f(a, b=2):

return a + b

print(f(1))

print(f(1,3))

# 求和
def SUM(a,b=2):
    c = a+b
    return c
print(SUM(3))
print(SUM(3,7))
print(SUM(a=1))

接受任意数量参数

前面学习的是固定参数数量，当不知道有多少个参数时可以再参数前面加 与 *，表示可接受任意多个参数

*name 接受任意多个参数，并放到一个元组中

**name 接受一个键值，并存储为字典

示例：传入多个参数，计算总和

def func(*seq):

x = 0

for n in seq:

x +=n

return x

print(func(1,2,3))

示例：传入多个键值，进行处理

def func(**computer):

for k,v in computer.items():

print("名称:%s\t价格:%s" %(k,v))

func(主机=5000,显示器=1000,鼠标=60,键盘=150)

# 参数默认值
def func(*sq):
    print(sq)
func(1,2,3,4,5,6)
print('==========')
def func(**sq):
    print(type(sq))
    print(sq)
func(a=1,b=2,c=3,d=4,e=5,f=6)
print('==========')
def func(*args,**kwargs):
    print(args)
    print(kwargs)
func(1,2,3,4,a=1,b=2,c=3)
print('==========')
def func(*seq):
    x = 0
    for n in seq:
        x +=n
    return x

print(func(1,2,3))
print('==========')
def func(**computer):
    for k,v in computer.items():
        print("名称:%s\t价格:%s" %(k,v))

func(主机=5000,显示器=1000,鼠标=60,键盘=150)

匿名函数(Lambda)

匿名函数：没有名字的函数，使用lambda关键字定义，一般仅用于单个表达式。

示例：求和函数

s = lambda a,b:a+b

print(s(1,2))

等价于：

def func(a,b)

return a+b

# 匿名函数(Lambda)
s= lambda a,b:a+b
print(s(6,7))

t = lambda x: "偶数" if x % 2 == 0 else "奇数"
print(t(7))
print(t(6))

作用域

作用域：限制一个变量或一段代码可用范围。好处是提高程序逻辑的局部性，减少名字冲突

• Local(局部作用域)：在函数中定义的变量
• Enclosed(嵌套作用域)：一般出现在函数中嵌套一个函数时，在外部函数中的作用域称为嵌套作用域(闭包常见)
• Global(全局作用域)：文件顶层定义的变量
• Built-in(内置作用域)：系统内解释器定义的变量，例如关键字

# 作用域
a = 2 # 全局变量
def func():
    b = 3 # 局部变量
    print(b)
    global c # 把C定义为了全局变量
    c = 4
func()
print(a)
print(c)

# 嵌套
x = 123
def outer():
    x = 456
    def inner():
        print(x)
    return inner()
outer()

# 内置变量
import builtins
print(dir(builtins))

闭包

闭包：你可以简单粗暴地理解为闭包就是一个定义在函数内部的函数，闭包使的变量即使脱离了该函数的作用域范围也依然能被访问到。像上面所说的嵌套函数也是闭包的一种形式(将内部嵌套定义的函数作为返回值)

示例：

def outer():

x = 1

def inner():

print(x) # 1

return inner # 不加括号，便是返回函数体

sf = outer()

sf() #调用，等同于outer()()

在一个外部函数内定义了一个函数，内部函数里引用外部函数的变量，并且外部函数的返回值是内函数的引用，这样就构成了一个闭包，并且满足了闭包的三个条件：

1.两层以上嵌套关系

2.内部函数调用外部函数定义的变量

3.外部函数返回内部函数体对象，而不是函数体结果(加括号)

# 闭包
x = 123
def outer():
    x = 456
    def inner():
        print(x)
    return inner
s = outer()
s()
outer()()

函数装饰器

函数装饰器作用：装饰器本质上是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象

应用场景：记录日志、性能测试、权限校验等

无参数

示例：装饰器使用

# 函数装饰器：无参数
def hello():
    print("我是原函数")
def decorator(func):
    def f():
        print("记录一下开始")
        func()
        print("记录一下结束")
    return f
dec = decorator(hello) # 装饰器传入函数
dec()                  # 调佣内部函数
# decorator(hello)()

Python提供一个更简洁引用装饰器的方法：语法糖"@"

示例：

@decorator

def hello():

print("我是原函数")

hello

# 函数装饰器：无参数
def decorator(func):
    def f():
        print("记录一下开始")
        func()
        print("记录一下结束")
    return f
@decorator
def hello():
    print("我是原函数")
hello()
print("==========")
@decorator
def hello2():
    print("hello word")
hello2()

带参数

示例：

def decorator(func):

def f(msg):

print("原函数开始执行了")

func(msg)

print("原函数执行结束了")

return f

@decorator

def hello(msg):

print(msg)

hello("我是原函数")

# 函数装饰器：无参数
def decorator(func):
    def f(*name,**msg):
        print("记录一下开始")
        func(*name,**msg)
        print("记录一下结束")
    return f
@decorator
def hello(*name,**msg):
    print(name,msg)
    print("我是原函数")
hello(1,2,3,4,5,6,7,a=1,b=2,c=3)
print("==========")
@decorator
def hello2():
    print("hello word")
hello2()

---

总结

以上就是今天学习的内容，本文仅仅简单介绍了python3 的函数的定义和调用，以及函数参数，作用域，闭包，函数装饰器。