揭秘Python的魔法:装饰器的超能力大揭秘 ‍♂️✨

文章目录

  • Python进阶之装饰器详解
    • 1. 引言
      • 装饰器的概念与意义
      • 装饰器在Python编程中的作用
    • 2. 背景介绍
      • 2.1 函数作为对象
      • 2.2 高阶函数
    • 3. 装饰器基础
      • 3.1 理解装饰器
      • 3.2 装饰器的工作原理
    • 4. 带参数的装饰器
      • 4.1 为什么需要带参数
      • 4.2 实现带参数的装饰器
        • 使用函数包裹装饰器
        • 使用类实现装饰器
    • 5. 多装饰器应用
      • 5.1 多个装饰器叠加
        • 装饰器的执行顺序
        • 避免装饰器冲突的策略
      • 5.2 装饰器的组合
    • 6. 装饰器的最佳实践
      • 6.1 保持透明性
        • 保留原函数名与文档字符串
      • 6.2 类装饰器的运用
        • 类作为装饰器的优势
        • 实例绑定与类方法装饰
    • 7. 装饰器的高级话题
      • 7.1 装饰类方法
      • 7.2 动态装饰器
      • 7.3 装饰器性能考量
    • 8. 结论
      • 装饰器的核心价值总结
        • 代码复用与解耦
        • 增强函数功能
        • 提高代码可读性
      • 在项目中合理运用装饰器的建议

Python进阶之装饰器详解

1. 引言

装饰器的概念与意义

在Python的世界里,有这样一群神秘的存在,它们被称为“装饰器”。想象一下,你走进一家咖啡馆,点了一杯普通的拿铁,然后咖啡师问你:“要不要加点香草糖浆,或者来点肉桂粉?”这就是装饰器的精髓所在——它们给原本的代码添加一些额外的功能,就像给咖啡添加香草糖浆一样,让代码更加美味。

装饰器在Python编程中的作用,就像是生活中的小工具,它们小巧而实用。比如,你有一个函数,它负责打印“Hello, World!”。但突然有一天,你想让这个函数在打印之前先检查一下用户权限,或者在打印之后记录日志。这时候,装饰器就派上用场了。你不需要修改原有的函数代码,只需要简单地“装饰”一下,就能实现这些额外的功能。

装饰器在Python编程中的作用

装饰器在Python编程中的作用,就像是给你的代码穿上一件件的外衣。它们让代码更加灵活,易于扩展和维护。想象一下,如果你的代码是一栋房子,那么装饰器就是那些可以随时更换的装饰品,比如窗帘、地毯或者壁画。它们不会改变房子的结构,但却能让房子看起来更加漂亮,或者更适合居住。

在Python中,装饰器通常用于以下场景:

  • 日志记录:在函数执行前后添加日志记录。
  • 性能测试:测量函数执行时间。
  • 事务处理:确保数据库操作的原子性。
  • 权限校验:在执行函数前检查用户权限。
  • 缓存:缓存函数的结果,避免重复计算。

装饰器就像是Python编程中的瑞士军刀,多功能且强大。它们让你的代码更加模块化,易于理解和维护。而且,装饰器的使用非常灵活,你可以为同一个函数添加多个装饰器,就像给咖啡添加多种口味一样。

现在,让我们开始探索装饰器的奥秘,看看它们是如何工作的,以及如何在你的项目中合理运用它们。但别着急,就像品尝一杯好咖啡一样,我们需要一步一步来,慢慢享受这个过程。下一篇,我们将深入了解装饰器的背景和基础,揭开它们的神秘面纱。

在这里插入图片描述

2. 背景介绍

2.1 函数作为对象

在Python的魔法世界里,一切皆对象,包括我们日常打交道的函数。这就像是在哈利波特的霍格沃茨魔法学校,即使是最普通的羽毛笔,也能变成一支会飞的羽毛笔,拥有自己的魔力。在Python中,函数不仅仅是一段执行特定任务的代码,它们也可以像其他对象一样被赋值、传递和返回。

想象一下,你有一个名为print_greeting的函数,它的作用是打印一条欢迎信息。在Python中,你可以像传递任何其他对象一样,将这个函数传递给另一个函数,或者将它赋值给一个变量。这就像是将羽毛笔交给另一个巫师,或者将它放在你的魔法背包里。

def print_greeting(name):
    print(f"Hello, {name}! Welcome to the world of Python decorators!")

# 将函数赋值给一个变量
greet = print_greeting

# 通过变量调用函数
greet("Harry")

在这个例子中,我们创建了一个函数print_greeting,然后将其赋值给变量greet。之后,我们通过变量greet来调用这个函数,就像直接调用print_greeting一样。这就是函数作为对象的魔力所在。

2.2 高阶函数

在Python中,还有一种特殊的函数,它们被称为高阶函数。高阶函数是指可以接受其他函数作为参数,或者可以返回一个函数的函数。这就像是魔法世界中的魔杖,它不仅能施展魔法,还能根据情况变化出不同的魔法。

高阶函数的概念是装饰器的基础。它们允许我们编写更加灵活和强大的代码。想象一下,你有一个魔法药水配方,这个配方需要根据不同的情境来调整。高阶函数就像是这个配方,它可以根据传入的函数来定制化地施展魔法。

def repeat(operation, times):
    def inner():
        for _ in range(times):
            operation()
    return inner

# 使用高阶函数来重复执行另一个函数
def wave():
    print("Wave your magic wand!")

repeat(waving, 3)  # 这将打印 "Wave your magic wand!" 三次

在这个例子中,repeat是一个高阶函数,它接受一个操作operation和一个次数times作为参数,并返回一个新的函数inner。这个新的函数会重复执行传入的操作指定的次数。我们使用repeat来重复执行wave函数三次。

通过理解函数作为对象的概念以及高阶函数的强大功能,我们为探索装饰器的世界打下了坚实的基础。在下一章中,我们将深入装饰器的世界,学习如何定义它们,以及它们是如何工作的。就像学习魔法一样,我们需要从基础开始,一步步提升我们的魔法技能。准备好了吗?让我们继续前进,揭开装饰器的神秘面纱。

3. 装饰器基础

3.1 理解装饰器

装饰器,听起来是不是有点像家里的装饰品?其实在Python中,装饰器也是用来“装饰”的,不过它们装饰的是函数或方法,给它们添加一些额外的“花哨”功能。

想象一下,你有一个简单的函数,它的任务就是打印出“我要去跑步了!”。但生活总是需要一点仪式感,不是吗?你可能想在跑步前发个朋友圈打卡,或者跑步后记录一下时间。这时候,装饰器就能大显身手了。

首先,我们得知道装饰器其实就是一个函数,它接受一个函数作为参数,然后返回一个新的函数。这个新的函数会在执行原函数的基础上,加上一些额外的操作。就像给你的跑步加个计时器,或者加个打卡的动作。

def make_coffee():
    print("泡了一杯咖啡,准备开始编码!")

def with_cup(function):
    def wrapper():
        print("拿一个杯子")
        function()
        print("喝完咖啡,继续编码!")
    return wrapper

make_coffee = with_cup(make_coffee)
make_coffee()

在这个例子中,with_cup就是一个装饰器。它接收一个函数function作为参数,然后定义了一个内部函数wrapperwrapper函数会在执行function之前和之后分别打印一些额外的信息。最后,with_cup返回了wrapper函数。

当我们将make_coffee装饰成with_cup(make_coffee)时,实际上是用with_cup这个装饰器给make_coffee函数“穿上了一件衣服”。现在,每次调用make_coffee时,都会自动执行wrapper中的代码,也就是先拿一个杯子,然后泡咖啡,最后喝完咖啡继续编码。

3.2 装饰器的工作原理

装饰器的工作原理,其实就像是俄罗斯套娃。你把一个函数包在另一个函数里面,然后再包一层,层层叠加。这就是所谓的“函数嵌套”。

让我们用一个更具体的例子来说明。假设你是一个健身教练,你需要记录每个学员的锻炼时间。你可以创建一个装饰器来自动完成这个任务。

import time

def time_tracker(func):
    def wrapper(start, end):
        start_time = time.time()
        func(start, end)
        end_time = time.time()
        print(f"锻炼完成!用时 {end_time - start_time:.2f} 秒")
    return wrapper

def workout(start, end):
    print(f"从 {start} 锻炼到 {end}")

workout = time_tracker(workout)
workout("08:00", "09:00")

在这个例子中,time_tracker是一个装饰器,它接收一个函数func作为参数,并返回一个wrapper函数。wrapper函数记录了开始时间,执行了func,然后记录结束时间,并打印出锻炼用时。

当我们将workout装饰成time_tracker(workout)时,每次调用workout实际上调用的是wrapper函数。这样,我们就不需要手动修改workout函数来添加计时功能,装饰器帮我们自动完成了。

这就是装饰器的魔力——它们让我们的代码更加模块化,易于扩展和维护。而且,装饰器的使用非常灵活,你可以为同一个函数添加多个装饰器,就像给咖啡加不同的调料一样,让每一杯咖啡都有独特的风味。

在下一章中,我们将探索如何创建带参数的装饰器,这就像是给你的咖啡加糖,可以根据个人口味来调整。准备好了吗?让我们继续深入装饰器的世界,发现更多有趣的可能性。

4. 带参数的装饰器

4.1 为什么需要带参数

想象一下,你是一名厨师,每天为顾客准备各种美食。但是,顾客的口味千差万别,有的人喜欢辣,有的人喜欢甜,还有的人喜欢酸。如果每次顾客来,你都要问一遍他们的口味,岂不是很麻烦?这就是为什么我们需要带参数的装饰器——因为它们可以让我们根据不同的需求,定制化地“调味”我们的函数。

4.2 实现带参数的装饰器

使用函数包裹装饰器

就像我们的厨师可以根据顾客的口味来调整食谱一样,我们也可以创建一个带参数的装饰器,来根据不同的情况来调整函数的行为。

def repeater(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeater(times=3)
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

在这个例子中,我们创建了一个repeater装饰器工厂,它接受一个参数times,表示我们想要重复执行函数的次数。然后,repeater返回一个装饰器decorator,这个装饰器再返回一个包装函数wrapper。每次调用原始函数时,wrapper会重复执行指定的次数。

使用类实现装饰器

有时候,我们需要的不仅仅是重复执行,还可能需要更复杂的逻辑。这时候,我们可以使用类来实现装饰器,就像使用一个多功能的厨房设备,可以同时完成切菜、搅拌和烹饪的工作。

class Logger:
    def __init__(self, level):
        self.level = level

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            if self.level == "INFO":
                print(f"INFO: Calling {func.__name__}")
            result = func(*args, **kwargs)
            return result
        return wrapper

@Logger(level="INFO")
def make_breakfast():
    print("煎蛋、烤面包、准备咖啡...")

make_breakfast()

在这个例子中,Logger类就是一个带参数的装饰器。它接受一个level参数,用来设置日志的级别。__call__方法使得类的实例可以像函数一样被调用,这样就可以将类用作装饰器了。每次调用原始函数时,wrapper会根据日志级别打印一条信息。

通过使用带参数的装饰器,我们可以编写出更加灵活和强大的代码。就像在厨房里,有了多功能的设备,就可以根据不同的食谱来调整烹饪方式,满足各种不同的需求。

在下一章中,我们将探索如何将多个装饰器叠加在一起使用,这就像是将不同的调料混合在一起,创造出独特的风味。准备好了吗?让我们继续我们的Python烹饪之旅,发现更多有趣的装饰器组合。

在这里插入图片描述

5. 多装饰器应用

5.1 多个装饰器叠加

想象一下,你是一位厨师,正在准备一道大餐。你先给菜肴加上一层香草,然后又撒上一些辣椒粉,最后淋上一些柠檬汁。每一层调料都给菜肴增加了不同的风味,但它们共同作用,让整道菜变得美味无比。在Python中,多个装饰器的叠加也是类似的,它们可以给函数添加多层功能。

装饰器的执行顺序

装饰器的执行顺序是自内而外的,就像你穿衣服一样,先穿内衣,再穿衬衫,最后穿上外套。这意味着最内层的装饰器会最先执行,然后是第二层,依此类推。

def make_spicy(func):
    def wrapper(*args, **kwargs):
        print("加入辣椒粉")
        return func(*args, **kwargs)
    return wrapper

def add_vanilla(func):
    def wrapper(*args, **kwargs):
        print("撒上香草粉")
        return func(*args, **kwargs)
    return wrapper

@add_vanilla
@make_spicy
def prepare_dish():
    print("准备一道美味的菜肴")

prepare_dish()

输出结果:

加入辣椒粉
撒上香草粉
准备一道美味的菜肴

在这个例子中,prepare_dish函数被make_spicyadd_vanilla两个装饰器装饰。由于装饰器的执行顺序是自内而外的,所以首先执行的是make_spicy,然后才是add_vanilla

避免装饰器冲突的策略

有时候,装饰器之间可能会产生冲突,就像调料放多了可能会让菜肴变得难以下咽。为了避免这种情况,我们需要采取一些策略:

  1. 明确每个装饰器的作用:在添加装饰器之前,确保你清楚每个装饰器的作用,以及它们是否能够和谐地一起工作。
  2. 调整装饰器的顺序:有时候,改变装饰器的顺序可以解决冲突问题。
  3. 使用互斥锁:在一些并发编程的场景中,可以使用互斥锁来避免装饰器之间的冲突。

5.2 装饰器的组合

有时候,我们希望将多个装饰器组合起来,形成一个复合装饰器。这就像是将多种调料混合在一起,创造出一种新的调味品。

def combined_decorator(decorator1, decorator2):
    def combine(func):
        return decorator2(decorator1(func))
    return combine

@combined_decorator(make_spicy, add_vanilla)
def prepare_dish():
    print("准备一道美味的菜肴")

prepare_dish()

在这个例子中,我们定义了一个combined_decorator函数,它接受两个装饰器作为参数,并返回一个新的装饰器。这个新的装饰器将两个装饰器的功能组合在一起,使得它们可以同时应用于同一个函数。

通过合理地使用多个装饰器,我们可以编写出功能强大且高度模块化的代码。就像一位经验丰富的厨师,通过精心搭配各种调料,创造出令人难忘的美食。

在下一章中,我们将探讨装饰器的最佳实践,这就像是学习如何成为一名高级厨师,了解如何将各种技巧和调料运用得恰到好处。准备好了吗?让我们继续深入探索Python装饰器的奥秘。

6. 装饰器的最佳实践

6.1 保持透明性

装饰器虽然强大,但使用不当,它们也可能成为代码的“隐形斗篷”,让代码的本意变得模糊不清。就像在变魔术时,魔术师需要保持手法的透明性,让观众能够清楚地看到魔术的每一个细节,装饰器也应该保持代码的透明性。

保留原函数名与文档字符串

想象一下,你有一个魔术表演,观众期待看到的是“消失的硬币”。如果魔术师突然改变了节目单,观众可能会感到困惑。同样,在装饰器中,我们应该保留原函数的名字和文档字符串,这样其他开发者在阅读代码时,能够清楚地知道这个函数是做什么的。

幸运的是,Python为我们提供了一个非常方便的工具——functools.wraps,它可以帮助我们保持函数的透明度。

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def say_hello(name):
    """Greet someone by name."""
    print(f"Hello, {name}!")

print(say_hello.__name__)  # 输出:say_hello
print(say_hello.__doc__)  # 输出:Greet someone by name.

在这个例子中,my_decorator使用了functools.wraps来装饰内部的wrapper函数。这样,即使say_hellomy_decorator装饰,它仍然保留了自己的名称和文档字符串。

6.2 类装饰器的运用

类装饰器就像是我们的多功能厨房设备,它们不仅可以完成单一的任务,还可以提供更多的可能性。类装饰器允许我们在装饰器中使用更多的Python特性,比如属性和方法。

类作为装饰器的优势

类装饰器的一个主要优势是它们可以持有状态。这意味着你可以在装饰器中存储信息,或者根据需要修改行为。

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.calls = 0

    def __call__(self, *args, **kwargs):
        self.calls += 1
        print(f"{self.func.__name__} has been called {self.calls} times")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello(name):
    """Greet someone by name."""
    print(f"Hello, {name}!")

say_hello("Alice")
say_hello("Bob")

在这个例子中,CountCalls类被用作装饰器。每次调用say_hello函数时,CountCalls都会记录调用次数,并打印出来。

实例绑定与类方法装饰

类装饰器还可以与实例绑定和类方法结合使用,这为装饰器提供了更多的灵活性。

class TimingDecorator:
    def __init__(self, func):
        self.func = func
        self.execution_time = 0

    def __call__(self, *args, **kwargs):
        start_time = time.time()
        result = self.func(*args, **kwargs)
        self.execution_time = time.time() - start_time
        print(f"{self.func.__name__} executed in {self.execution_time:.4f} seconds")
        return result

@TimingDecorator
def long_running_task():
    time.sleep(2)  # 模拟耗时任务

long_running_task()

在这个例子中,TimingDecorator类不仅记录了函数的执行时间,还可以在之后的时间里访问这个信息,比如用于性能分析。

通过遵循这些最佳实践,我们可以确保装饰器的使用既强大又透明,让代码更加易于理解和维护。就像一位高级厨师,不仅能够创造出美味的菜肴,还能够清楚地向顾客解释每一道菜的制作过程和食材来源。

在下一章中,我们将探索装饰器的一些高级话题,这就像是学习一些高级烹饪技巧,让你的Python代码变得更加专业和高效。准备好了吗?让我们继续前进,探索装饰器的高级世界。

7. 装饰器的高级话题

7.1 装饰类方法

在Python中,类方法就像是家族中的传家宝,它们与特定的类紧密相连。装饰类方法就像是给这些传家宝加上一层保护膜,让它们在保持原有价值的同时,还能获得一些额外的保护。

想象一下,你有一个家族秘方,这个秘方被记录在一本古老的食谱中。每次使用这个秘方时,你都需要确保遵循特定的步骤,比如检查食材的新鲜度,或者记录下使用的次数。这就是装饰类方法的作用。

class FamilyRecipe:
    def __init__(self, name):
        self.name = name

    def make_recipe(self, *args, **kwargs):
        print(f"Making the {self.name} recipe...")

    @classmethod
    def decorate_recipe(cls, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"Preparing ingredients for {cls.__name__}.")
            return func(*args, **kwargs)
        return wrapper

    @decorate_recipe
    def cook(cls):
        print("Cooking the family recipe.")

FamilyRecipe.cook()

在这个例子中,FamilyRecipe类有一个类方法decorate_recipe,它被用作装饰器来装饰另一个类方法cook。这样,每次调用cook方法时,都会先打印出准备食材的信息。

在这里插入图片描述

7.2 动态装饰器

动态装饰器就像是魔法世界中的变形术,它们可以根据条件变化形态。在Python中,动态装饰器允许我们在运行时根据条件来决定是否应用某个装饰器。

想象一下,你是一名侦探,每次调查案件时,你都需要根据现场的情况来决定使用哪些工具。有时候,你可能需要放大镜来观察细节;有时候,你可能需要手电筒来照亮黑暗的角落。动态装饰器就是你的侦探工具箱,可以根据需要随时调整。

def conditional_decorator(condition):
    def actual_decorator(func):
        def wrapper(*args, **kwargs):
            if condition():
                print("Condition met, applying decorator.")
                return func(*args, **kwargs)
            else:
                print("Condition not met, skipping decorator.")
                return func(*args, **kwargs)
        return wrapper
    return actual_decorator

def is_night():
    # 假设这是检查当前时间是否为夜晚的函数
    return True  # 简化示例,假设总是夜晚

@conditional_decorator(is_night)
def night_shift():
    print("Working the night shift.")

night_shift()

在这个例子中,conditional_decorator是一个装饰器工厂,它接受一个条件函数condition作为参数,并返回一个实际的装饰器actual_decorator。这个装饰器会根据条件函数的返回值来决定是否应用装饰。

7.3 装饰器性能考量

装饰器虽然强大,但它们也可能影响代码的性能。就像在赛车比赛中,额外的装饰可能会增加车辆的重量,从而影响速度。因此,在使用装饰器时,我们需要考虑它们的性能影响。

  • 避免过度装饰:不要无谓地给函数添加多个装饰器,特别是在性能敏感的代码中。
  • 测试性能:在使用装饰器后,进行性能测试,确保它们没有对代码性能产生负面影响。
  • 简化装饰器:尽量保持装饰器的简洁,避免在装饰器中执行复杂的操作。

通过这些高级话题的探讨,我们可以看到装饰器不仅仅是代码的“调味品”,它们还可以是强大的工具,帮助我们编写更加灵活、安全和高效的代码。就像一位高级厨师,不仅要掌握烹饪技巧,还要了解食材的特性和搭配原则。

8. 结论

装饰器的核心价值总结

装饰器,这个听起来就像是给代码穿上了一件时尚外套的工具,其实远不止于此。它们是Python中的瑞士军刀,多功能且强大。装饰器让我们的代码更加模块化、灵活和易于维护。就像一位时尚设计师,不仅能够让衣服看起来更漂亮,还能够根据不同场合调整设计,让穿着者既舒适又得体。

代码复用与解耦

装饰器让我们能够将一些通用的功能抽象出来,避免在多个函数中重复相同的代码。这就像是拥有一个万能的调料包,无论做什么菜,都可以撒上一点,让味道更加丰富。通过装饰器,我们可以轻松地将这些功能应用到不同的函数上,而不需要修改函数本身,实现了代码的高度复用和解耦。

增强函数功能

装饰器能够在不修改原有函数代码的前提下,给函数增加额外的功能。这就像是给一辆普通的自行车加上电动马达,让它瞬间变成电动自行车,功能得到增强,但自行车的本质并没有改变。通过装饰器,我们可以轻松地为函数添加日志记录、性能测试、事务处理等额外功能。

提高代码可读性

通过使用装饰器,我们可以将一些复杂的逻辑从函数中抽离出来,让函数的主体代码更加简洁和清晰。这就像是在阅读一本书时,作者将一些复杂的背景知识放在了附录中,而不是直接插入到故事里,让读者能够更加顺畅地阅读故事本身。装饰器帮助我们保持了代码的整洁和可读性。

在项目中合理运用装饰器的建议

  1. 明确目的:在使用装饰器之前,明确你需要装饰器解决什么问题,它是否是最佳解决方案。
  2. 保持简洁:装饰器应该尽可能简单,避免在装饰器中执行复杂的逻辑。
  3. 考虑性能:在性能敏感的应用中,考虑装饰器可能带来的性能影响。
  4. 使用functools.wraps:保留原函数的名称和文档字符串,提高代码的可读性。
  5. 避免过度装饰:不要过度使用装饰器,特别是在同一个函数上叠加多个装饰器,可能会导致代码难以理解和维护。
  6. 编写文档:为你的装饰器编写清晰的文档,说明它的用途、参数和行为。

最后,装饰器就像是我们编程工具箱中的一把利器,用得好,它能够帮助我们编写出更加优雅、高效的代码。但和所有的工具一样,我们需要合理使用,避免滥用。记住,装饰器是为了简化我们的工作,而不是让工作变得更加复杂。

随着我们对装饰器的探索告一段落,希望你能够将这些知识应用到你的Python编程实践中,让你的代码像装饰过的蛋糕一样,既美观又美味。继续前进吧,Python的魔法世界还有更多奥秘等待你去发掘!

我是阿佑,一个专注于把晦涩的知识讲得有趣的中二青年,欢迎评论区留言~

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/639751.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

React开发环境配置详细讲解-04

React环境 前端随着规范化,可以说规范和环境插件配置满天飞,笔者最早接触的是jquery,那个开发非常简单,只要引入jquery就可以了,当时还写了一套UI框架,至今在做小型项目中还在使用,show一张效果…

小恐龙跳一跳源码

小恐龙跳一跳源码是前两年就火爆过一次的小游戏源码,不知怎么了今年有火爆了,所以今天就吧这个源码分享出来了!有喜欢的直接下载就行,可以本地单机直接点击index.html进行运行,又或者放在虚拟机或者服务器上与朋友进行…

FL Studio2025中文最新版本专业编曲软件有哪些新功能?

FL Studio 21,也被音乐制作爱好者亲切地称为“水果编曲软件”,是比利时的Image-Line公司研发的一款完整的音乐制作环境或数字音频工作站(DAW)。自从1990年代推出以来,FL Studio 以其直观的用户界面、丰富的插件支持和强…

PHP质量工具系列之php_CodeSniffer

PHP_CodeSniffer 是一组两个 PHP 脚本:主脚本 phpcs 对 PHP、JavaScript 和 CSS 文件进行标记,以检测是否违反定义的编码标准;第二个脚本 phpcbf 自动纠正违反编码标准的行为。PHP_CodeSniffer 是一个重要的开发工具,可以确保你的…

【电路笔记】-有源高通滤波器

有源高通滤波器 文章目录 有源高通滤波器1、概述2、有源高通滤波器3、有源高通滤波器示例4、二阶高通有源滤波器有源高通滤波器可以通过将无源 RC 滤波器网络与运算放大器相结合来创建,以产生具有放大功能的高通滤波器。 1、概述 有源高通滤波器 (HPF) 的基本操作与其等效 RC…

【Crypto】摩丝

文章目录 一、摩斯解题感悟 一、摩斯 很明显莫尔斯密码 iloveyou还挺浪漫 小小flag,拿下 解题感悟 莫尔斯密码这种题还是比较明显的

游戏安全防控有招了! MMO游戏安全场景解决方案

2024年4月10日,暴雪娱乐与网易共同宣布:停服442天后,那款曾经让数百万国内玩家为之痴迷的MMO游戏《魔兽世界》国服要重新回归了。 还记得服务器关闭倒计时15分钟开始的时候,素不相识的大家就在频道中互相告别,“愿风指…

spring boot集成Knife4j

文章目录 一、Knife4j是什么?二、使用步骤1.引入依赖2.新增相关的配置类3.添加配置信息4.新建测试类5. 启动项目 三、其他版本集成时常见异常1. Failed to start bean ‘documentationPluginsBootstrapper2.访问地址后报404 一、Knife4j是什么? 前言&…

微服务项目收获和总结---第4天(文章审核和保存)

文章审核以及APP端保存文章 业务流程: App端保存接口: 数据库表详情 文章的基本信息表:id,标题,作者id,频道id...... 文章的权限/配置表:存储文章是否可以评论,是否上架&#xff…

在docker中运行SLAM十四讲程序

《十四讲》的示例程序依赖比较多,而且系统有点旧。可以在容器中运行。 拉取镜像 docker pull ddhogan/slambook:v0.1这个docker对应的github:HomeLH/slambook2-docker 拉下来之后,假如是Windows系统,需要使用XLaunch用于提供X11…

番外篇 | YOLOv5-SPD:用最简单的方式完成低分辨率图像和小目标检测升级

前言:Hello大家好,我是小哥谈。论文提出了一个新的CNN构建模块称为SPD-Conv,用来替换每个步长卷转层和每个池化层(从而完全消除它们)。SPD-Conv由一个空间到深度(SPD)层和一个非步长卷积(Conv)层组成。本文详细介绍了如何在YOLOv5中引入SPD-Conv,助力助力低分辨率与小…

掌握代码注释:提升代码可读性的秘密武器

新书上架~👇全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我👆,收藏下次不迷路┗|`O′|┛ 嗷~~ 目录 一、为什么我们需要注释? 二、如何添加单行注释? 使用井号 # 添加单…

C++贪心算法(4)

过河的最短时间 #include<bits/stdc.h> using namespace std; int main() {int a[1010]{0};int n;cin>>n;for(int i0;i<n;i){cin>>a[i];}sort(a0,an);int xn-2;int yn-1;int tmpa[1];while(true){int tmp1a[0]a[y]a[1]a[1];int tmp2a[0]a[y]a[0]a[x];if(t…

Golang | Leetcode Golang题解之第110题平衡二叉树

题目&#xff1a; 题解&#xff1a; func isBalanced(root *TreeNode) bool {return height(root) > 0 }func height(root *TreeNode) int {if root nil {return 0}leftHeight : height(root.Left)rightHeight : height(root.Right)if leftHeight -1 || rightHeight -1 …

2024年收集搜索引擎蜘蛛大全以及浏览器模拟蜘蛛方法

对于做SEOer来说经常和搜索引擎蜘蛛打交道&#xff0c;下面整理收集了最全的搜索引擎蜘蛛大全。供有需要的朋友使用&#xff0c;建议收藏。 搜索引擎蜘蛛大全 "TencentTraveler", "Baiduspider", "BaiduGame", "bingbot",//必应蜘蛛…

MaxEnt模型文章中存在的问题和处理方法(050B更新)2024.5.24

目前多数MaxEnt文章中存在的问题和处理方案。 **问题一&#xff1a;**变量数据使用问题&#xff0c;很多文章把所有变量数据直接使用&#xff0c;但是温度和土壤、植被类型等属于不同数据类型&#xff0c;在数据使用时参数配置是不一样的&#xff0c;产生的结果文件也是不一样的…

Generative Action Description Prompts for Skeleton-based Action Recognition

标题&#xff1a;基于骨架的动作识别的生成动作描述提示 源文链接&#xff1a;https://openaccess.thecvf.com/content/ICCV2023/papers/Xiang_Generative_Action_Description_Prompts_for_Skeleton-based_Action_Recognition_ICCV_2023_paper.pdfhttps://openaccess.thecvf.c…

【openlayers系统学习】1.5交互-捕捉要素

五、捕捉要素 Snapping 捕捉 您可能已经注意到&#xff0c;很容易绘制与现有要素不完全对齐的要素。此外&#xff0c;在修改要素时&#xff0c;我们可能会破坏拓扑关系&#xff0c;导致原本相邻的多边形之间出现空隙。Snap 交互操作可以帮助在绘制和编辑要素时保持拓扑关系。…

vue 纵向滚动菜单, 点击滚动到选中菜单

1 背景 需要设计一个纵向滚动菜单&#xff0c;要求丝滑点&#xff0c;默认显示选中菜单 2 思路 给定一个容器&#xff0c;样式包含overflow:hidden&#xff0c;默认高宽足够显示一个菜单&#xff08;以下用图标代替菜单&#xff09;&#xff0c;鼠标悬浮时增大容器高度&#…

时代终结,微软宣布淘汰VBScript;Flink漏洞被广泛利用;Grandoreiro银行木马强势回归,1500多家银行成攻击目标 | 安全周报0524

揭秘SolarMarker恶意软件&#xff1a;多层次基础设施让清除工作陷入困境 Recorded Future的新发现表明&#xff0c;SolarMarker信息窃取恶意软件背后的持续威胁行为者已经建立了一个多层次的基础设施&#xff0c;以使执法部门的清除工作变得复杂。 该公司在上周发布的一份报告…