12. 闭包和装饰器

最新推荐文章于 2024-07-29 14:37:54 发布
最新推荐文章于 2024-07-29 14:37:54 发布
阅读量166 收藏
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41547423/article/details/121399557
版权

文章目录

1. 闭包

1. 闭包

1.1 闭包的介绍

前面已经学过了函数，当函数调用完，函数内定义的变量都销毁了，但是我们有时候需要保存函数内的这个变量，每次在这个变量的基础上完成一些列的操作，比如: 每次在这个变量的基础上和其它数字进行求和计算，那怎么办呢?

可以通过闭包来解决这个需求。

闭包的定义:

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

1.2 闭包的构成条件

通过闭包的定义，我们可以得知闭包的形成条件:

  1. 在函数嵌套(函数里面再定义函数)的前提下
  2. 内部函数使用了外部函数的变量(还包括外部函数的参数)
  3. 外部函数返回了内部函数
# 闭包的作用：可以保存外部函数的变量

# 闭包的形成条件
# 1. 函数嵌套
# 2. 内部函数使用了外部函数的变量或者参数
# 3. 外部函数返回内部函数， 这个使用了外部函数变量的内部函数称为闭包

1.3 简单闭包的示例代码

# 闭包的作用：可以保存外部函数的变量

# 闭包的形成条件
# 1. 函数嵌套
# 2. 内部函数使用了外部函数的变量或者参数
# 3. 外部函数返回内部函数， 这个使用了外部函数变量的内部函数称为闭包


# 1. 函数嵌套
def func_out():
    # 外部函数
    num1 = 10
    def func_inner(num2):
        # 内部函数
        # 2. 内部函数必须使用了外部函数的变量
        result = num1 + num2
        print("结果:", result)

    # 外部函数要返回内部函数，这个使用了外部函数变量的内部函数称为闭包
    return func_inner

if __name__ == '__main__':
    # 获取闭包对象 这个new_func就是闭包
    # 这里的new_func == func_inner
    new_func = func_out()
    new_func(10)

运行结果:

结果: 20

闭包执行结果的说明:

通过上面的输出结果可以看出闭包保存了外部函数内的变量num1，每次执行闭包都是在num1 = 1 基础上进行计算。

1.4 闭包的作用

  • 闭包可以保存外部函数内的变量，不会随着外部函数调用完而销毁。

注意点:

  • 由于闭包引用了外部函数的变量，则外部函数的变量没有及时释放，消耗内存。

1.5 小结

  1. 当返回的内部函数使用了外部函数的变量就形成了闭包

  2. 闭包可以对外部函数的变量进行保存

  3. 实现闭包的标准格式:

     # 外部函数
 def test1(a):
     b = 10
     # 内部函数
     def test2():
         # 内部函数使用了外部函数的变量或者参数
         print(a, b)
     # 返回内部函数, 这里返回的内部函数就是闭包实例
     return test2

2. 闭包的使用

2.1 案例

需求: 根据配置信息使用闭包实现不同人的对话信息，例如对话:

张三: 到北京了吗? 李四: 已经到了，放心吧。

2.2 实现步骤说明

  1. 定义外部函数接收不同的配置信息参数，参数是人名
  2. 定义内部函数接收对话信息参数
  3. 在内部函数里面把配置信息和对话信息进行拼接输出

2.3 功能代码的实现

# 外部函数接收姓名参数
def config_name(name):
    # 内部函数保存外部函数的参数，并且完成数据显示的组成
    def inner(msg):
        print(name + ":" + msg)

    print(id(inner))
    # 外部函数要返回内部函数
    return inner


# 创建tom闭包实例（对象）
tom = config_name("tom")
# 创建jerry闭包实例
jerry = config_name("jerry")
# 如果执行tom闭包，因为已经保存了name参数，那么以后在输入的时候都是,tom说:xxx
tom("play game！")
jerry("let's go")
tom("gogo")
jerry("go")

运行结果:

sudo+ssh://root@192.168.211.129:22/usr/bin/python3 -u /tmp/pycharm_project_819/day10/02.闭包的使用.py
139857264256624
139857136757488
tom:play game！
jerry:let's go
tom:gogo
jerry:go

Process finished with exit code 0

闭包案例说明:

  • 闭包还可以提高代码的可重用性，不需要再手动定义额外的功能函数。

  • 闭包不仅可以保存外部函数的变量还可以提高代码的可重用行。

3. 修改闭包内使用的外部变量

3.1 修改闭包内使用的外部变量

修改闭包内使用的外部变量的错误示例:

# 定义一个外部函数
def func_out(num1):

    # 定义一个内部函数
    def func_inner(num2):
        # 这里本意想要修改外部num1的值，实际上是在内部函数定义了一个局部变量num1
        num1 = 10
        # 内部函数使用了外部函数的变量(num1)
        result = num1 + num2
        print("结果是:", result)

    print(num1)
    func_inner(1)
    print(num1)

    # 外部函数返回了内部函数，这里返回的内部函数就是闭包
    return func_inner

# 创建闭包实例
f = func_out(1)
# 执行闭包
f(2)

修改闭包内使用的外部变量的错误示例:

# 定义一个外部函数
def func_out(num1):

    # 定义一个内部函数
    def func_inner(num2):
        # 这里本意想要修改外部num1的值，实际上是在内部函数定义了一个局部变量num1
        nonlocal num1  # 告诉解释器，此处使用的是 外部变量a
        # 修改外部变量num1
        num1 = 10
        # 内部函数使用了外部函数的变量(num1)
        result = num1 + num2
        print("结果是:", result)

    print(num1)
    func_inner(1)
    print(num1)

    # 外部函数返回了内部函数，这里返回的内部函数就是闭包
    return func_inner

# 创建闭包实例
f = func_out(1)
# 执行闭包
f(2)
  • 修改闭包内使用的外部函数变量使用 nonlocal 关键字来完成。

2. 装饰器

1. 装饰器

1.1 装饰器的定义

就是给已有函数增加额外功能的函数，它本质上就是一个闭包函数。

装饰器的功能特点:

  1. 不修改已有函数的源代码
  2. 不修改已有函数的调用方式
  3. 给已有函数增加额外的功能

1.2 装饰器的示例代码

# 添加一个登录验证的功能
def check(fn):
    def inner():
        print("请先登录....")
        fn()
    return inner


def comment():
    print("发表评论")

# 使用装饰器来装饰函数
comment = check(comment)
comment()

# 装饰器的基本雏形
# def decorator(fn): # fn:目标函数.
#     def inner():
#         '''执行函数之前'''
#         fn() # 执行被装饰的函数
#         '''执行函数之后'''
#     return inner

代码说明:

  • 闭包函数有且只有一个参数，必须是函数类型，这样定义的函数才是装饰器。
  • 写代码要遵循开放封闭原则，它规定已经实现的功能代码不允许被修改，但可以被扩展。

执行结果:

请先登录....
发表评论

1.3 装饰器的语法糖写法

如果有多个函数都需要添加登录验证的功能，每次都需要编写func = check(func)这样代码对已有函数进行装饰，这种做法还是比较麻烦。

Python给提供了一个装饰函数更加简单的写法，那就是语法糖，语法糖的书写格式是: @装饰器名字，通过语法糖的方式也可以完成对已有函数的装饰

"""
学习装饰器的目的：
    对已有的函数进行额外的功能扩展，装饰器本质上是一个闭包函数，也就是说他是一个函数嵌套

# 装饰器的特点：
1. 不修改已有函数的代码
2. 不修改已有函数的调用方式
3. 给以后函数添加额外的功能

"""


# 定义装饰器
# 如果闭包函数有且只有一个并且是函数类型，那么这个闭包函数称为装饰器
def decorator(func):
    def inner():
        # 在内部函数对已有的函数进行装饰
        print("已添加登录验证")
        func()
    return inner

# 装饰器的语法糖写法: @装饰器名称，装饰器的语法糖就是在装饰以后函数的时候写法更加简单
@decorator  # comment = decorator(comment) 装饰器语法糖对该代码进行了封装  comment=inner
def comment():
    print("发表评论")

comment()

D:\Python\python.exe E:/PythonResources/day10/05.装饰器.py
已添加登录验证
发表评论

Process finished with exit code 0

说明:

  • @decorator等价于 comment = decorator(comment)
  • 装饰器的执行时间是加载模块时立即执行。

执行结果:

请先登录....
发表评论

1.4 小结

  • 装饰器本质上就是一个闭包函数，它可以对已有函数进行额外的功能扩展。

  • 装饰器的语法格式:

    # 装饰器
# def decorator(fn): # fn:被装饰的目标函数.
#     def inner():
#         '''执行函数之前'''
#         fn() # 执行被装饰的目标函数
#         '''执行函数之后'''
#     return inner

  • 装饰器的语法糖用法: @装饰器名称，同样可以完成对已有函数的装饰操作。

2. 装饰器的使用

2.1 装饰器的使用场景

  1. 函数执行时间的统计
  2. 输出日志信息

2.2 装饰器实现已有函数执行时间的统计

import time

# 定义装饰器
def decorator(func):
    def inner():
        # 内部函数对已有函数进行装饰
        # 获取时间距离1970-1-1:0:0:1的时间差
        begin_time = time.time()
        print(begin_time)
        func()
        end_time = time.time()
        count_time = end_time - begin_time
        print("函数执行耗时:",count_time)
    return inner


@decorator
def work():
    for i in range(10000):
        print(i)

work()

执行结果:

...
9996
9997
9998
9999
函数执行耗时: 0.04464149475097656

2.3 小结

通过上面的示例代码可以得知装饰器的作用:

  • 在不改变已有函数源代码及调用方式的前提下，对已有函数进行功能的扩展。

3. 通用装饰器的使用

3.1 装饰带有参数的函数

# 通用的装饰器: 可以装饰任意类型的函数

# --------装饰带有参数的函数-----------

# 定义装饰器
def decorator(func):
    # 使用装饰器装饰已有函数的时候，内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(a, b):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")
        func(a, b)

    return inner


# 用装饰器语法糖方式装饰带有参数的函数
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(num1, num2):
    result = num1 + num2
    print("结果为:", result)

add_num(1, 2)

运行结果:

D:\Python\python.exe E:/PythonResources/day10/08.通用的装饰器.py
正在努力执行加法计算
结果为: 3

Process finished with exit code 0

3.2 装饰带有返回值的函数

# ------装饰带有参数和返回值的函数
def decorator(func):
    # 使用装饰器装饰已有函数的时候，内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(a, b):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")
        num = func(a, b)
        return num

    return inner


# 用装饰器语法糖方式装饰带有参数的函数
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(num1, num2):
    result = num1 + num2
    return result

result = add_num(1, 2)
print("结果为:", result)

运行结果:

D:\Python\python.exe E:/PythonResources/day10/08.通用的装饰器.py
正在努力执行加法计算
结果为: 3

Process finished with exit code 0

3.3 装饰带有不定长参数的函数

# ----装饰带有不定长参数和返回值的函数-------

# 该装饰器还可以成为是通用的装饰器
def decorator(func):
    # 使用装饰器装饰已有函数的时候，内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(*args, **kwargs):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")

        # *args: 把元组里面的每一个元素，按照位置参数的方式进行传参
        # **kwargs: 把字典里面的每一个键值对，按照关键字的方式进行传参
        # 这里对元组和字典进行拆包，仅限于结合不定长参数的函数使用
        num = func(*args, **kwargs)
        return num

    return inner

# 用装饰器语法糖方式装饰带有参数的函数
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(*args, **kwargs):
    result = 0

    # args: 元组类型
    # kwargs: 字典类型

    for value in args:
        result += value

    for value in kwargs.values():
        result += value

    return result

result = add_num(1, 2,3,4,5,6)
result = add_num(1,2)
print("结果为:", result)

运行结果:

--正在努力计算--
21
3

3.4 通用装饰器

可以配合pychram debug工具联合理解

# ----装饰带有不定长参数和返回值的函数-------

# 该装饰器还可以成为是通用的装饰器
def decorator(func):
    # 使用装饰器装饰已有函数的时候，内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(*args, **kwargs):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")

        # *args: 把元组里面的每一个元素，按照位置参数的方式进行传参
        # **kwargs: 把字典里面的每一个键值对，按照关键字的方式进行传参
        # 这里对元组和字典进行拆包，仅限于结合不定长参数的函数使用
        num = func(*args, **kwargs)
        return num

    return inner
#
#
@decorator  # show= decorator(show) show = inner
def show():
    return "哈哈"

result = show()
print(result)


# 用装饰器语法糖方式装饰带有参数的函数
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(*args, **kwargs):
    result = 0

    # args: 元组类型
    # kwargs: 字典类型

    for value in args:
        result += value

    for value in kwargs.values():
        result += value

    return result

result = add_num(1, 2,3,4,5,6)
print("结果为:", result)
result = add_num(1,2)
print("结果为:", result)

运行结果:

D:\Python\python.exe E:/PythonResources/day10/08.通用的装饰器.py
正在努力执行加法计算
哈哈
正在努力执行加法计算
结果为: 21
正在努力执行加法计算
结果为: 3

Process finished with exit code 0

3.5 小结

  • 通用装饰器的语法格式:

    # 通用装饰器
def logging(fn):
  def inner(*args, **kwargs):
      print("--正在努力计算--")
      result = fn(*args, **kwargs)
      return result

  return inner

4. 多个装饰器的使用

4.1 多个装饰器的使用示例代码

原理：装饰器装饰的过程时一个由内到外的过程，先执行内部的装饰器，再执行外部的装饰器

下边的例子make_div make_p，make_div在make_p之前，make_div会对他本身底下的代码进行一次装饰，但是make_p也是装饰器，他对自己本身下边的代码也进行装饰作用，所以可以想象成嵌套装饰。最外层的装饰器是make_div，内层的是make_p。代码执行过程中先执行的内部的装饰器，内部的装饰器执行完以后再去执行外部的装饰器。

# 定义装饰器
def make_div(func):
    print("make_div装饰器执行了")

    def inner():
        # 在内部函数对已有函数进行装饰
        result = "<div>" + func() + "</div>"
        return result

    return inner


# 定义装饰器
def make_p(func):
    print("make_p装饰器执行了")

    def inner():
        # 在内部函数对已有函数进行装饰
        result = "<p>" + func() + "</p>"
        return result

    return inner

# 多个装饰器的装饰过程: 由内到外的一个装饰过程，先执行内部的装饰器，在执行外部的装饰器
# 原理剖析: content = make_div(make_p(content))
# 分步拆解: content = make_p(content),内部装饰器装完成content=make_p.inner
#  content = make_div(make_p.inner)
@make_div
@make_p
def content():
    return "人生苦短，我用python!"

# 打印如下的格式：<p>人生苦短，我用python!</p>
result = content()
print(result)

D:\Python\python.exe E:/PythonResources/day10/09.多个装饰器的使用.py
make_p装饰器执行了
make_div装饰器执行了
<div><p>人生苦短，我用python!</p></div>

Process finished with exit code 0

代码说明:

  • 多个装饰器的装饰过程是: 离函数最近的装饰器先装饰，然后外面的装饰器再进行装饰，由内到外的装饰过程

  • 多个装饰器可以对函数进行多个功能的装饰，装饰顺序是由内到外的进行装饰

5. 带有参数的装饰器

5.1 带有参数的装饰器介绍

带有参数的装饰器就是使用装饰器装饰函数的时候可以传入指定参数，语法格式: @装饰器(参数,…)

5.2 错误写法

def decorator(fn, flag):
    def inner(num1, num2):
        if flag == "+":
            print("--正在努力加法计算--")
        elif flag == "-":
            print("--正在努力减法计算--")
        result = fn(num1, num2)
        return result
    return inner


@decorator('+')
def add(a, b):
    result = a + b
    return result

result = add(1, 3)
print(result)

执行结果:

Traceback (most recent call last):
  File "/home/python/Desktop/test/hho.py", line 12, in <module>
    @decorator('+')
TypeError: decorator() missing 1 required positional argument: 'flag'

代码说明:

  • 装饰器只能接收一个参数，并且还是函数类型。

5.3 正确写法

在装饰器外面再包裹上一个函数，让最外面的函数接收参数，返回的是装饰器，因为@符号后面必须是装饰器实例。

#
def return_decorator(flag):
    # 装饰器, 装饰器只能接收一个参数并且是函数类型
    def decorator(func):
        def inner(a, b):
            if flag == "+":
                print("正在努力执行加法计算")
            elif flag == "-":
                print("正在努力执行减法计算")
            func(a, b)
        return inner
    # 当调用函数的时候可以返回一个装饰器decorator
    return decorator


# 加法计算
@return_decorator("+")  # decorator = return_decorator("+"), @decorator => add_num=decorator(add_num)
def add_num(a, b):
    result = a + b
    print(result)

# add_num(1, 2)

# 减法计算
@return_decorator("-")
def sub_num(a, b):
    result = a - b
    print(result)

add_num(1, 2)
sub_num(1, 4)

# 带有参数的装饰器，其实就是定义了一个函数，让函数接收参数，在函数内部返回的是一个装饰器

D:\Python\python.exe E:/PythonResources/day10/10.带有参数的装饰器.py
正在努力执行加法计算
3
正在努力执行减法计算
-3

Process finished with exit code 0
  • 使用带有参数的装饰器，其实是在装饰器外面又包裹了一个函数，使用该函数接收参数，返回是装饰器，因为 @ 符号需要配合装饰器实例使用

6. 类装饰器的使用

6.1 类装饰器的介绍

装饰器还有一种特殊的用法就是类装饰器，就是通过定义一个类来装饰函数。

类装饰器示例代码:

# # 类装饰器: 使用类装饰已有函数
class MyDecorator(object):
    def __init__(self, func):
        self.__func = func

    # 实现__call__这个方法，让对象变成可调用的对象，可调用的对象能够像函数使用
    def __call__(self, *args, **kwargs):
        # 对已有函数进行封装
        print("========================")
        self.__func()


@MyDecorator  # @MyDecorator => show = MyDecorator(show)
def show():
    print("hello world")

# 执行show  # 执行MyDecorator类创建实例对象 -> show() => 对象()
show()


# 扩展： 函数之所有能够调用是因为函数内部使用__call__
def mytest():
    print("哈哈")

print(dir(mytest))

6.2 说明

  • @decorator 等价于 comment = decorator(comment), 所以需要提供一个init方法，并多增加一个fn参数。
  • 要想类的实例对象能够像函数一样调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用。
  • 在call方法里进行对func函数的装饰，可以添加额外的功能。

执行结果:

请先登陆...
发表评论

6.3 小结

  • 想要让类的实例对象能够像函数一样进行调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)
  • 类装饰器装饰函数功能在call方法里面进行添加
脑子是空的啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python闭包和装饰器的区别_python中闭包和装饰器
weixin_34431283的博客
02-11 2019
前言：编程语言发展的过程中，我们为了提高代码利用率，发明了函数式编程。函数将代码封装起来，我们需要用到此功能函数的时候，调用一下就可以了。但是使用的过程中，也遇到了一些问题，比如函数实现的功能不够，或者跟我们要实现的功能有些差别。肿么办呢？打开函数内部代码，重新写？可以吗？可以！但是这就违背了函数式编程思想的初衷，代码没有重复利用，而且还破坏了原有函数代码。怎么办？聪明的人类思想的灯泡再次闪亮，咔...
深入理解python中的闭包和装饰器
09-21
Python中的闭包和装饰器是两种非常重要的编程概念，它们都是基于函数的特性，特别是涉及到作用域和函数的嵌套。 闭包（Closure）在Python中是指一个内部函数引用了外部函数的局部变量，即使外部函数已经执行完毕，...
装饰器，闭包。
qq_33410381的博客
07-18 90
闭包 #外部函数outter def outter(): a = 10 # a为inner的外部作用域 #内部函数inner def inner(): print(a) return inner outter()() # 直接调用inner() # 输出为10 如果在内部函数inner中，有对外部作用域的一个引用(a=10)，那么内部函数就是一个闭...
浅谈闭包与装饰器
Pysonz的博客
05-11 675
#python一切皆对象(了解) https://blog.csdn.net/LRLZ_Python/article/details/49893103 #闭包 闭包:两个函数的嵌套,外部函数返回内部函数的引用,外部函数一定有参数 def 外部函数(参数): def 内部函数(): pass return 内部函数 他跟函数之间的区别: 1.格式两个函数嵌套 2.闭包外部函数的...
2 python闭包的使用
THE ORDER
02-05 212
1. 案例 需求: 根据配置信息使用闭包实现不同人的对话信息，例如对话: 张三: 到北京了吗? 李四: 已经到了，放心吧。 2. 实现步骤说明 定义外部函数接收不同的配置信息参数，参数是人名 定义内部函数接收对话信息参数 在内部函数里面把配置信息和对话信息进行拼接输出 3. 功能代码的实现 # 外部函数 def config_name(name): # 内部函数 def say_info(info): print(name + ": " + info) return
闭包的使用
IT之一小佬的博客
07-13 150
闭包的使用
如何去理解闭包&装饰器
Programmer's Way
07-27 1986
首先从概念上看“在python中， 函数本身也是对象” 1.python中一切皆对象 当执行： alist = [1, 2, 3] 时，你就创建了一个列表对象，并且用alist这个变量引用它。 也可以自己定义一个类： class House(object): def __init__(self, area, city): self.area ...
python基础 — 闭包和装饰器
个人博客
04-26 1447
百度百科：维基百科：注意：闭包并不只是一个python中的概念，在函数式编程语言中广泛应用。哈哈看完有没有感觉云里雾里的的，看不懂对了，下面我们来拿Python中的闭包实例来感受下到底什么事闭包，在回过头来理解闭包的概念。（1）Python中闭包的特点（2）创建一个简单的闭包（3）闭包的简单应用问题：使用闭包计算一个数的 n 次幂。相信到这里，我们已经可以判断是否是闭包，自定义闭包并简单的使用闭包了，下面我们来浅析闭包的一些特性原理。（4）闭包的一些特性原理pass拓展被装饰函数功能的一种函数，可以在不改变
简析Python的闭包和装饰器
09-21
Python中的闭包和装饰器是两种非常重要的编程概念，它们在函数式编程和面向对象编程中都有广泛应用。本文将深入探讨这两个主题，帮助你更好地理解和利用它们。 首先，我们来看看**装饰器**。装饰器是一种特殊类型的...
17-闭包和装饰器（python和linux高级编程阶段 代码和截图）
01-22
17-闭包和装饰器（python和linux高级编程阶段 代码和截图）17-闭包和装饰器（python和linux高级编程阶段 代码和截图）17-闭包和装饰器（python和linux高级编程阶段 代码和截图）17-闭包和装饰器（python和linux高级...
Python闭包和装饰器用法实例详解
09-19
Python中的闭包和装饰器是两种非常重要的编程概念，它们都是基于函数的特性来实现更高级别的抽象和功能增强。 闭包（Closure）是Python中一个核心的概念，它源自函数的局部作用域和引用。当一个内部函数引用了外部...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 927
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1025
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 624
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
Chapter 18 Python异常
2302_80253507的博客
07-28 1059
在Python中，异常是一种特定的对象，能够在程序运行过程中被抛出和处理。有效地管理异常不仅可以增强程序的稳定性，还可以提高用户体验，使程序能够优雅地处理错误情况。本章详细讲解了异常的基本概念以及如何捕获和处理异常。
loguru日志模块：简化Python自动化测试的日志管理！
最新发布
07-29 549
日志是软件开发中的关键组成部分，为开发和测试人员提供了调试和监控应用程序的重要手段。loguru 是一个第三方的 Python 日志库，以其简洁的 API 和自动化的功能脱颖而出。本文将探讨为什么项目中需要日志，loguru 为何受到青睐，以及如何封装和在接口自动化测试项目中使用 loguru，同时结合 Allure 生成丰富的测试报告。
安卓手机部署大模型实战
奇舞周刊
07-25 875
本文作者系360奇舞团前端开发工程师前言自ChatGPT发布以来，大语言模型（Large language model, LLM)就成了AI乃至整个计算机科学的话题中心。学术界，工业界围绕大语言模型本身及其应用展开了广泛的讨论，大量的新的实践层出不穷。由于LLM对计算资源的需求极大，有能力部署大语言模型的公司和实验室一般通过搭建集群，然后开放API或者网页demo的方式让用户可以使用模型。在人们纷...
Python(C++)大尺度分层边值时变图统计推理并行算法
跨学科知识视角展现
07-29 559
:dart:分层结构制定生成模型 | :dart:贝叶斯模型选择程序 | :dart:分层结构图的信息性 | :dart:分层模型适应实值边协变量的网络 | :dart:分层模型适应时变网络，划分层对应于检测变化点 | :dart:定义两种版本随机块模型：:pen:具有边缘协变量模型概率分布，分层图总似然 | :pen:独立分层模型分层图数学似然计算 | :dart:推理算法：大图形尺度并行计算算法，过滤暂时被遮蔽的节点和边
闭包和装饰器 python
05-24
好的，以下是关于闭包和装饰器的介绍： 闭包（Closure）是 Python 中的一个重要概念，它是一个能够访问另一个函数作用域的变量和状态的函数。在 Python 中，闭包通常是通过函数返回另一个函数的模式实现的。闭包...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

脑子是空的啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值