Python中的functools模块详解

大家好，我是海鸽。

函数被定义为一段代码，它接受参数，充当输入，执行涉及这些输入的一些处理，并根据处理返回一个值（输出）。当一个函数将另一个函数作为输入或返回另一个函数作为输出时，这些函数称为高阶函数。

map() 、reduce() 和 filter() 都是高阶函数。

函数式编程强调将函数作为头等对象。今天我们解读下 functools 库中用于创建和修改函数的几个高阶函数。

初识 functools 模块

functools模块是Python的标准库的一部分，它是为高阶函数而实现的，用于增强函数功能。

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42

import functools
from loguru import logger

logger.info(functools)
logger.info(functools.__doc__)
logger.info(dir(functools))

这些信息表明 functools 模块提供了一系列用于处理函数和可调用对象的工具。

以下是 functools 模块中包含的主要方法的详细说明：

  1. cached_property: 一个装饰器，用于将方法转换为只读属性，第一次访问时计算值并缓存。

  2. cmp_to_key: 用于在比较函数中将老式比较函数转换为关键字函数的工具。

  3. cache: 一个装饰器，提供了一个带有缓存的函数装饰器，用于缓存函数的结果以提高性能。

  4. lru_cache: 一个装饰器，提供了一个带有最近最少使用（LRU）缓存的函数装饰器，用于缓存函数的结果以提高性能。

  5. partial: 一个函数，用于部分应用一个函数的参数，并返回一个新的函数，使得可以在原函数的基础上预先设置一部分参数。

  6. partialmethod: 与 partial 类似，但专门用于部分应用类方法的参数。

  7. reduce: 一个函数，对序列中的元素进行累积运算，通常与二元函数结合使用。

  8. singledispatch: 一个装饰器，用于创建基于单个分派泛型函数的多分派泛型函数，根据不同的参数类型调用不同的函数实现。

  9. singledispatchmethod: 与 singledispatch 类似，但专门用于类方法。

  10. total_ordering: 一个类装饰器，可以根据一个类的一组方法（__eq__, __lt__, __le__, __gt__, __ge__, __ne__）自动生成所有比较运算。

  11. update_wrapper: 一个函数，用于更新一个函数对象的特性，例如 __doc__、__name__ 和 __module__，以便被包装函数更好地模拟原函数。

  12. wraps: 一个装饰器，用于将一个装饰器应用到一个函数上，并保留原函数的元数据。

这些工具可以帮助 Python 开发者在处理函数时提高效率和灵活性。

functools.cached_property

这个函数将类的方法转换为一个属性，该属性在第一次计算后会被缓存，并在实例的生命周期内作为常规属性使用。

它类似于 property()，但添加了缓存功能，对于高计算资源消耗的实例特性属性来说，这个函数非常有用，因为它们在其他情况下实际上是不可变的。

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
from functools import cached_property

from loguru import logger


def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


class MyClass:
    @cached_property
    def expensive_calculation(self):
        # 这是一个昂贵的计算，我们只希望它执行一次并进行缓存
        logger.info('计算 expensive_calculation')
        return fibonacci(20)


# 使用：
obj = MyClass()
logger.info(obj.expensive_calculation)  # 计算结果将被缓存
logger.info(obj.expensive_calculation)  # 计算结果将被缓存

输出结果：

functools.cached_property 在 Python 3.8 及更高版本中可用，允许您缓存类属性。评估属性后，将不会再次评估。

functools.cache

functools.cache用作装饰器，能够根据输入缓存函数的返回值。它在 Python 3.9 及更高版本中可用。

缓存大小是无限制的。

from functools import cache
 
 
@cache
def fibonacci(n):
    if n < 2:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)
 
 
print(fibonacci(3))
print(fibonacci(10))

functools.lru_cache

functools.lru_cache 允许您将递归函数调用缓存在最近最少使用的缓存中。这可以通过多个递归调用（如斐波那契数列）优化函数。

@lru_cache(maxsize=10) 表示缓存中将只保留 10 个最近使用最少的条目。当新条目到达时，最早的缓存条目将被丢弃。

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
from loguru import logger
from functools import lru_cache

# 定义一个全局变量来记录函数被调用的次数
call_count = 0


@lru_cache(maxsize=10)
def fibonacci(n):
    global call_count  # 使用全局变量
    call_count += 1  # 每次调用增加计数

    if n in [0, 1]:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


logger.info(fibonacci(4))
logger.info(f"Total function called {call_count} times.")  # 记录函数被调用的总次数

logger.info("第二次调用 fibonacci(1)，此时应该命中缓存")
logger.info(fibonacci(1))
logger.info(f"Total function called {call_count} times.")

输出结果为：

该装饰器会将不同的调用结果缓存在内存中，因此需要注意内存占用问题。

functools.cmp_to_key()

functools.cmp_to_key 是一个函数，用于将比较函数（cmp函数）转换为一个key函数。在Python 2中，比较函数被广泛用于排序和相关操作，但是在Python 3中，由于删除了cmp参数，比较函数的使用受到了限制。为了在Python 3中仍然能够使用比较函数进行排序，可以使用functools.cmp_to_key 来将比较函数转换为key函数，然后将其传递给排序函数。

比较函数是任何接受两个参数，对它们进行比较，并在结果为小于时返回一个负数，相等时返回零，大于时返回一个正数的可调用对象。

以下是一个示例，演示了如何使用 functools.cmp_to_key：

import functools

# 定义一个比较函数（在Python 2中可以直接用作排序函数）
def custom_cmp(x, y):
    return (x > y) - (x < y)

# 将比较函数转换为键函数
key_func = functools.cmp_to_key(custom_cmp)

# 使用转换后的键函数进行排序
sorted_list = sorted([3, 1, 4, 1, 5, 9], key=key_func)

print(sorted_list)  # Output: [1, 1, 3, 4, 5, 9]

在这个示例中，custom_cmp 是一个比较函数，它接受两个参数并返回-1、0或1以表示它们的大小关系。然后，使用functools.cmp_to_key将该比较函数转换为一个key函数key_func。最后，通过将key_func传递给sorted函数，可以使用该key函数对列表进行排序。

也就是说，排序时会先对每个元素调用 key 所指定的函数，然后再排序。cmp_to_key函数就是用来将老式的比较函数转化为key函数。用到key参数的函数还有sorted(), min(), max(), heapq.nlargest(), itertools.groupby()等。

functools.total_ordering

total_ordering 装饰器用于定义能够实现各种比较运算的算子类，适用于 numbers.Number 的子类和半数值型类。

functools.total_ordering 是一个装饰器，它允许您在定义类时只定义一小部分比较方法，然后它会自动为您补全其余的比较方法。这样，您可以轻松地定义一个完整的序列化类，而无需手动实现所有的比较方法。

这个装饰器要求类中至少定义了一个 __lt__、__le__、__gt__ 或 __ge__ 中的一个方法，并且还必须定义 __eq__ 方法。

以下是一个示例，演示了如何使用 functools.total_ordering 装饰器：

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
from functools import total_ordering

from loguru import logger


@total_ordering
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def __eq__(self, other):
        return self.grade == other.grade

    def __lt__(self, other):
        return self.grade < other.grade


# 使用示例
alice = Student("Alice", 85)
bob = Student("Bob", 75)

logger.info(alice > bob)  # True，因为 Alice 的成绩更高
logger.info(alice == bob)  # False

在这个示例中，我们定义了一个 Student 类，并使用 total_ordering 装饰器装饰它。我们只定义了 __eq__ 和 __lt__ 方法，而没有定义其他比较方法。然后，total_ordering 装饰器自动为我们补全了 __le__、__gt__ 和 __ge__ 方法。这样，我们就可以使用所有的比较运算符来比较 Student 对象的成绩了。

如果没有定义 __eq__ 方法，那么无法确定两个对象是否相等，这会导致在使用 total_ordering 装饰器时产生意外行为。因此，为了确保类的行为符合预期，必须提供 __eq__ 方法，不等比较方法__ne__()默认基于__eq__()生成。

functools.partial

它的作用是固定这个函数中的一部分参数。

即一般用于：基于旧函数及其部分参数
生成的新函数

举个简单的例子。

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
from functools import partial

from loguru import logger


def power(base, exponent):
    return base ** exponent


# 创建一个新函数，将 exponent 参数预设为 2
square = partial(power, exponent=2)

# 使用新函数
result = square(base=3)  # 相当于 power(3, 2)，返回 9
logger.info(result)

# 继续创建一个新函数，将 base 参数预设为 2
square_two = partial(power, base=2)

# 使用新函数
result_two = square_two(exponent=3)  # 相当于 power(2, 3)，返回 8
logger.info(result_two)

partial() 函数主要用于 “冻结” 函数的部分参数，返回一个参数更少、使用更简单的函数对象。

应用场景：函数在执行时，要带上所有必要的参数进行调用，但是有的参数可以在函数被调用之前提前获知，这种情况下，提前获知的函数参数可以提前用上，以便函数能用更少的参数进行调用。

示例：

urlunquote = functools.partial(urlunquote, encoding='latin1')

当调用 urlunquote(args, *kargs)，相当于 urlunquote(args, *kargs, encoding='latin1')

很实用的例子：

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
# 导入必要的模块和函数
import json
import datetime
from functools import partial


# 定义 json_serial_fallback 函数
from loguru import logger


def json_serial_fallback(obj):
    """JSON serializer for objects not serializable by default json code"""
    if isinstance(obj, (datetime.datetime, datetime.date)):
        return str(obj)
    if isinstance(obj, bytes):
        return obj.decode("utf-8")
    raise TypeError(f"{obj} is not JSON serializable")


# 定义 json_dumps 函数
json_dumps = partial(json.dumps, default=json_serial_fallback)

# 创建一个包含日期时间和字节串的字典
data = {
    "timestamp": datetime.datetime.now(),
    "binary_data": b"example binary data"
}

# 将字典转换为 JSON 格式的字符串
json_string = json_dumps(data)
logger.info(json_string)  # {"timestamp": "2024-02-24 11:16:25.016089", "binary_data": "example binary data"}

functools.partialmethod

functools.partialmethod 是 Python 标准库中的一个函数，用于创建可部分应用的方法。它与 functools.partial 类似，不同之处在于它用于部分应用方法而不是函数。

部分应用是一种函数式编程的概念，允许你在调用函数时固定一部分参数，从而创建一个新的函数，这个新函数会在后续调用中使用这些固定的参数。functools.partialmethod 在面向对象编程中扮演着同样的角色，但是它是用于部分应用方法的。

以下是 functools.partialmethod 的一个简单示例：

import functools


class Greeter:
    def __init__(self, greeting):
        self.greeting = greeting

    def greet(self, name, *args):
        return f"{self.greeting}, {name} {''.join(args)}"

    # 创建一个部分应用的方法
    greet_hello = functools.partialmethod(greet, 'Hello')


# 创建一个 Greeter 实例
greeter = Greeter('Bonjour')

# 正确调用部分应用的方法
print(greeter.greet_hello("Alice!"))  # 输出: Bonjour, HelloAlice!

在这个示例中，Greeter 类定义了一个 greet 方法，用于向给定的名字打招呼。然后使用 functools.partialmethod 创建了一个部分应用的方法 greet_hello，将 'Hello' 作为固定参数传递给 greet 方法，从而创建了一个新的方法。当调用 greeter.greet_hello('Alice') 时，实际上是调用了 greeter.greet('Hello', "Alice!")，因此会输出 Bonjour, Hello Alice!。

functools.reduce

函数的作用是将一个序列归纳为一个输出reduce(function, sequence, startValue)

from loguru import logger

from functools import reduce

alist = range(1, 50)
logger.info(reduce(lambda x, y: x + y, alist))  # 1225

注意functools.reduce方法初始值的重要性

设置初始值的方式对于 map()函数和
reduce()函数都非常重要。

初始值在使用 functools.reduce 函数时具有重要性，特别是在处理空序列时。让我们通过一个例子来说明其重要性：

假设我们有一个列表，我们想计算列表中所有元素的累积乘积。

from functools import reduce

numbers = [1, 2, 3, 4, 5]

# 计算累积乘积
result = reduce(lambda x, y: x * y, numbers)
print(result)

在这个例子中，我们没有提供初始值，reduce 函数将使用列表的第一个元素作为初始累积值。因此，计算过程如下：

  1. 初始化累积值为列表的第一个元素：accumulator = 1
  2. 对于列表中的每个元素，将其乘以累积值：accumulator = 1 * 2 = 2
  3. 继续对剩余元素进行累积乘积：accumulator = 2 * 3 = 6，accumulator = 6 * 4 = 24，accumulator = 24 * 5 = 120

因此，最终的结果为 120。

现在，让我们考虑一个情况，当我们有一个空列表时会发生什么。

from functools import reduce

numbers = []

# 计算累积乘积
result = reduce(lambda x, y: x * y, numbers)
print(result)

在这个例子中，由于列表为空，reduce 函数将无法确定初始累积值。如果没有提供初始值，将会导致 TypeError: reduce() of empty sequence with no initial value 错误。

为了避免这个错误，我们可以提供一个初始值，例如 1，以确保在处理空列表时也能够正常工作：

from functools import reduce

numbers = []

# 计算累积乘积，初始值为 1
result = reduce(lambda x, y: x * y, numbers, 1)
print(result)  # 输出：1

在这个例子中，我们提供了初始值 1，即使列表为空，reduce 函数也可以正确地返回初始值作为结果。这说明了在使用 reduce 函数时提供初始值的重要性，特别是在处理空序列时。

如果不设置初始值， reduce()函数使用序列的第一个值作为初始值，这个值就不会传递给卷积函数，导致计算错误。

下面通过 reduce()高阶函数定义一些内置的归约函数。

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
from typing import Callable, Any, Union

from loguru import logger

from functools import reduce

# 示例数据列表
data = [1, 2, 3, 4, 5]
data2 = []

# 计算平方和
sum_of_squares: Callable[[Any], int] = lambda iterable: reduce(lambda x, y: x + y ** 2, iterable, 0)
logger.info(f"Sum of squares: {sum_of_squares(data)}")  # 输出: Sum of squares: 55
logger.info(f"Sum of squares: {sum_of_squares(data2)}")  # 输出: Sum of squares: 0


# 计算总和
total_sum: Callable[[Any], int] = lambda iterable: reduce(lambda x, y: x + y, iterable, 0)
logger.info(f"Total sum: {total_sum(data)}")  # 输出: Total sum: 15
logger.info(f"Total sum: {total_sum(data2)}")  # 输出: Total sum: 0


# 计数
count_elements: Callable[[Any], Union[int, Any]] = lambda iterable: reduce(lambda x, y: x + 1, iterable, 0)
logger.info(f"Count of elements: {count_elements(data)}")  # 输出: Count of elements: 5
logger.info(f"Count of elements: {count_elements(data2)}")  # 输出: Count of elements: 0


# 找出最小值
minimum_value: Callable[[Any], Any] = lambda iterable: reduce(lambda x, y: x if x < y else y,
                                                              iterable) if iterable else None

logger.info(f"Minimum value: {minimum_value(data)}")  # 输出: Minimum value: 1
logger.info(f"Minimum value: {minimum_value(data2)}")  # 输出: Minimum value: None


# 找出最大值
maximum_value: Callable[[Any], Any] = lambda iterable: reduce(lambda x, y: x if x > y else y,
                                                              iterable) if iterable else None
logger.info(f"Maximum value: {maximum_value(data)}")  # 输出: Maximum value: 5
logger.info(f"Maximum value: {maximum_value(data2)}")  # 输出: Maximum value: None

functools.update_wrapper

functools.update_wrapper 是一个函数，用于手动更新一个包装器函数的特性以匹配被包装函数的特性。它通常与自定义装饰器一起使用，以确保包装器函数与原始函数的行为和元数据一致。

下面是一个示例，演示了 functools.update_wrapper 的用法：

# -*- coding:utf-8 _*-
# __author__：lianhaifeng
# __time__：2024/2/23 22:42
import functools


def another_decorator(func):
    def wrapper(*args, **kwargs):
        print("Another thing is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Another thing is happening after the function is called.")
        return result

    # 使用 update_wrapper 来更新 wrapper 函数的特性以匹配 func 函数的特性
    functools.update_wrapper(wrapper, func)
    return wrapper


@another_decorator
def say_hello():
    """一个简单的打招呼函数。"""
    print("你好！")


say_hello()
print(say_hello.__name__)  # 输出：say_hello
print(say_hello.__doc__)  # 输出：一个简单的打招呼函数。

say_hello()
print(say_hello.__name__)  # Output: say_hello
print(say_hello.__doc__)  # Output: 一个简单的打招呼函数。

在这个示例中，another_decorator 是一个装饰器，它没有使用 functools.wraps 装饰器来保留原始函数的元数据。相反，它使用了 functools.update_wrapper 函数来手动更新 wrapper 函数的属性以匹配 func 函数的属性，从而保留了原始函数的元数据。

wraps 函数是为了在装饰器中方便的拷贝被装饰函数的签名，而对 update_wrapper 做的一个包装

functools.wraps

functools.wraps 是 Python 的 functools 模块中的一个装饰器，用于创建行为良好的装饰器。装饰器是用来修改其他函数或方法行为的函数。当你将装饰器应用到一个函数或方法时，原始函数的元数据，比如名称、文档字符串和参数列表，可能会丢失或被修改。functools.wraps 帮助保留了这些元数据。

以下是 functools.wraps 的使用示例：

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("在调用函数之前做一些事情。")
        result = func(*args, **kwargs)
        print("在调用函数之后做一些事情。")
        return result
    return wrapper

@my_decorator
def say_hello():
    """一个简单的打招呼函数。"""
    print("你好！")

say_hello()
print(say_hello.__name__)  # 输出：say_hello
print(say_hello.__doc__)   # 输出：一个简单的打招呼函数。

在这个示例中，my_decorator 是一个装饰器，用来装饰函数 say_hello。如果没有使用 functools.wraps，访问 say_hello.__name__ 或 say_hello.__doc__ 将不会得到预期的结果，因为它们会反映 wrapper 函数的元数据，而不是 say_hello 的元数据。但是，通过使用 @functools.wraps(func)，原始函数 say_hello 的元数据被保留下来，使得装饰器的行为符合预期。

functools.singledispatch

singledispatch 装饰器用于函数重载，装饰器将函数转换为单调度泛型函数。

调度发生在第一个参数的类型上

from functools import singledispatch
from loguru import logger


@singledispatch
def func(arg1, arg2):
    logger.info(f"default implementation of func - {arg1, arg2}")


@func.register
def func_impl_1(arg1: str, arg2):
    logger.info(f"【func_impl_1】with first argument as string - {arg1, arg2}")


@func.register
def func_impl_2(arg1: int, arg2):
    logger.info(f"【func_impl_2】with first argument as int - {arg1, arg2}")


func(1.34, "hi")
func("test", "hello")
func(1, "hello")

logger.info(func.registry)
logger.info(func.registry.keys())

我们看些执行结果：

functools.singleDispatchMethod

将方法转换为单个调度泛型函数。

使用 @singledispatchmethod 定义函数时，请注意，调度发生在第一个 non-self 或 non-cls 参数的类型上

from functools import singledispatchmethod


class Sum:

    @singledispatchmethod
    def sum_method(self, arg1, arg2):
        print("Default implementation with arg1 = %s and arg2 = %s" % (arg1, arg2))

    @sum_method.register
    def sum_method_int(self, arg1: int, arg2: int):
        print("Sum with arg1 as integer. %s + %s = %s" % (arg1, arg2, arg1 + arg2))

    @sum_method.register
    def sum_method_float(self, arg1: float, arg2: float):
        print("Sum with arg1 as float. %s + %s = %s" % (arg1, arg2, arg1 + arg2))


s = Sum()
s.sum_method(2, 3)
s.sum_method(2.1, 3.4)
s.sum_method("hi", 3.4)

"""
输出：
Sum with arg1 as integer. 2 + 3 = 5
Sum with arg1 as float. 2.1 + 3.4 = 5.5
Default implementation with arg1 = hi and arg2 = 3.4
"""

重载类方法：

from functools import singledispatchmethod


class Educative:

    @singledispatchmethod
    @classmethod
    def new_print(cls, arg):
        print("Default implementation. arg - %s" % (arg,))

    @new_print.register(int)
    @classmethod
    def int_impl(cls, arg: int):
        print("Integer implementation. arg - %s" % (arg,))

    @new_print.register(bool)
    @classmethod
    def bool_impl(cls, arg):
        print("Boolean implementation. arg - %s" % (arg,))


Educative.new_print(4)
Educative.new_print(True)
Educative.new_print("hi")

"""
Integer implementation. arg - 4
Boolean implementation. arg - True
Default implementation. arg - hi
"""

最后

如果你觉得文章还不错，请大家点赞、分享、关注下，因为这将是我持续输出更多优质文章的最强动力！

参考

更多functools知识请阅读官方文档！

https://docs.python.org/3/library/functools.html

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

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

相关文章

JAVA算法和数据结构

JAVA算法和数据结构

一、Arrays类 1.1 Arrays基本使用 我们先认识一下Arrays是干什么用的&#xff0c;Arrays是操作数组的工具类&#xff0c;它可以很方便的对数组中的元素进行遍历、拷贝、排序等操作。 下面我们用代码来演示一下&#xff1a;遍历、拷贝、排序等操作。需要用到的方法如下 public…
阅读更多...
26.HarmonyOS App(JAVA)列表对话框

26.HarmonyOS App(JAVA)列表对话框

列表对话框的单选模式&#xff1a; //单选模式 // listDialog.setSingleSelectItems(new String[]{"第1个选项","第2个选项"},1);//单选 // listDialog.setOnSingleSelectListener(new IDialog.ClickedListener() { // Override …
阅读更多...
互联网加竞赛 机器视觉opencv答题卡识别系统

互联网加竞赛 机器视觉opencv答题卡识别系统

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 答题卡识别系统 - opencv python 图像识别 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff0c;学长非常推荐&#xff01; &#x1f947;学长这里给一个题目综合评分(每项满分5分…
阅读更多...
C++中的左值和右值

C++中的左值和右值

目录 一. 左值和右值的概念 1. 左值 1.1 可修改的的左值 1.2 不可修改的左值 右值 二. 左值引用和右值引用 1. 左值引用 2. 右值引用 主要用途 1. 移动语义 2. 完美转发 2.1 引用折叠 2.2 std::forward 一. 左值和右值的概念 什么是左值和右值 1. 左值 左值是一个表示…
阅读更多...
Unity3D 使用 Proto

Unity3D 使用 Proto

一. 下载与安装 这里下载Google Protobuff下载 1. 源码用来编译CSharp 相关配置 2. win64 用于编译 proto 文件 二. 编译 1. 使用VS 打开 2. 点击最上面菜单栏 工具>NuGet 包管理器>管理解决方案的NuGet 管理包 版本一定要选择咱们一开始下载的对应版本否则不兼容&am…
阅读更多...
使用免费的L53巧解Freenom域名失效问题

使用免费的L53巧解Freenom域名失效问题

进入2月份以来&#xff0c;不少小伙伴纷纷收到Freenom提供的域名失效&#xff0c;状态由正常变成了Pending。 失效后&#xff0c;域名无法使用&#xff0c;免费的午餐没有了&#xff0c;而现在域名的价格也是水涨船高&#xff0c;真是XXX。很多做外贸的小伙伴表示 难 啊&#x…
阅读更多...
树状数组与线段树＜2＞——线段树初步

树状数组与线段树＜2＞——线段树初步

这个系列终于更新了(主要因为树状数组初步比较成功) 话不多说&#xff0c;切入正题。 什么是线段树&#xff1f; 线段树是一种支持单点修改区间查询(树状数组也行) and 区间修改单点查询(树状数组不行) and 区间修改区间查询(树状数组更不行)的高级数据结构&#xff0c;相当…
阅读更多...
Chiplet技术与汽车芯片(二)

Chiplet技术与汽车芯片(二)

目录 1.回顾 2.Chiplet的优势 2.1 提升芯片良率、降本增效 2.2 设计灵活&#xff0c;降低设计成本 2.3 标准实行&#xff0c;构建生态 3.Chiplet如何上车 1.回顾 上一篇&#xff0c;我们将来芯粒到底是什么东西&#xff0c;本篇我们来看芯粒技术的优势&#xff0c;以及它…
阅读更多...
5.1 Ajax数据爬取之初介绍

5.1 Ajax数据爬取之初介绍

目录 1. Ajax 数据介绍 2. Ajax 分析 2.1 Ajax 例子 2.2 Ajax 分析方法 &#xff08;1&#xff09;在网页页面右键&#xff0c;检查 &#xff08;2&#xff09;找到network&#xff0c;ctrl R刷新 &#xff08;3&#xff09;找 Ajax 数据包 &#xff08;4&#xff09;…
阅读更多...
多线程相关（4）

多线程相关（4）

线程安全-下 使用层面锁优化减少锁的时间&#xff1a;减少锁的粒度&#xff1a;锁粗化&#xff1a;使用读写锁&#xff1a;使用CAS&#xff1a; 系统层面锁优化自适应自旋锁锁消除锁升级偏向锁轻量级锁重量级锁 ThreadLocal原理ThreadLocal简介原理ThreadLocal内存泄漏 HashMap…
阅读更多...
VMware使用虚拟机，开启时报错：无法连接虚拟设备 0:0，因为主机上没有相应的设备。——解决方法

VMware使用虚拟机，开启时报错：无法连接虚拟设备 0:0，因为主机上没有相应的设备。——解决方法

检查虚拟机配置文件并确保物理设备已正确连接。 操作&#xff1a; 选中虚拟机&#xff0c;打开设置&#xff0c;点击CD/DVD。在连接处选择使用ISO镜像文件
阅读更多...
fpga_硬件加速引擎

fpga_硬件加速引擎

一 什么是硬件加速引擎 硬件加速引擎&#xff0c;也称硬件加速器&#xff0c;是一种采用专用加速芯片/模块替代cpu完成复杂耗时的大算力操作&#xff0c;其过程不需要或者仅需要少量cpu参与。 二 典型的硬件加速引擎 典型的硬件加速引擎有GPU&#xff0c;DSP&#xff0c;ISP&a…
阅读更多...
【二分查找】【浮点数的二分查找】【二分答案查找】

【二分查找】【浮点数的二分查找】【二分答案查找】

文章目录 前言一、二分查找&#xff08;Binary Search&#xff09;二、浮点数的二分查找三、二分答案总结 前言 今天记录一下基础算法之二分查找 一、二分查找&#xff08;Binary Search&#xff09; 二分查找&#xff08;Binary Search&#xff09;是一种在有序数组中查找目…
阅读更多...
1 Nacos数据持久化方式

1 Nacos数据持久化方式

Nacos 支持两种数据持久化方式&#xff0c;一种是利用内置的数据库&#xff0c;另一种是利用外置的数据源。 1、内置数据库支持 Nacos 默认内置了一些数据存储解决方案&#xff0c;如内嵌的 Derby 数据库。 这种内置方式主要用于轻量级或测试环境。 2、外置数据库支持 对于生…
阅读更多...
【RN】学习使用 Reactive Native内置UI组件

【RN】学习使用 Reactive Native内置UI组件

简言 当把导航处理好后&#xff0c;就可以学习使用ui组件了&#xff08;两者没有先后关系&#xff0c;个人习惯&#xff09;。 在 Android 和 iOS 开发中&#xff0c;一个视图是 UI 的基本组成部分&#xff1a;屏幕上的一个小矩形元素、可用于显示文本、图像或响应用户输入。甚…
阅读更多...
如何使用逻辑回归处理多标签问题？

如何使用逻辑回归处理多标签问题？

逻辑回归处理多分类 1、背景描述2、One vs One3、One vs Rest4、从Sigmoid到Softmax的推导 1、背景描述 逻辑回归本身只能用于二分类问题&#xff0c;如果实际情况是多分类的&#xff0c;那么就需要对模型进行一些改动。下面介绍三种常用的将逻辑回归用于多分类的方法 2、One …
阅读更多...
目标跟踪之KCF详解

目标跟踪之KCF详解

High-Speed Tracking with Kernelized Correlation Filters 使用内核化相关滤波器进行高速跟踪 大多数现代跟踪器的核心组件是判别分类器&#xff0c;其任务是区分目标和周围环境。为了应对自然图像变化&#xff0c;此分类器通常使用平移和缩放的样本补丁进行训练。此类样本集…
阅读更多...
用Python实现创建十二星座数据分析图表

用Python实现创建十二星座数据分析图表

下面小编提供的代码中&#xff0c;您已经将pie.render()注释掉&#xff0c;并使用了pie.render_to_file(十二星座.svg)来将饼状图渲染到一个名为十二星座.svg的文件中。这是一个正确的做法&#xff0c;如果您想在文件中保存图表而不是在浏览器中显示它。 成功创建图表&#xf…
阅读更多...
嵌入式软件分层设计的思想分析

嵌入式软件分层设计的思想分析

“嵌入式开发&#xff0c;点灯一路发” 那今天我们就以控制LED闪烁为例&#xff0c;来聊聊嵌入式软件分层: ——————————— | | | P1.1 |-----I<|--------------<| | | | P2.1 |-------------/ ---------…
阅读更多...
MyBatis的⾼级映射及延迟加载

MyBatis的⾼级映射及延迟加载

MyBatis的⾼级映射及延迟加载 一、多对一1.方式一&#xff1a;级联属性映射2.方式二&#xff1a;association3.方式三&#xff1a;分步查询 二、一对多1.方式一&#xff1a;collection2.方式二&#xff1a;分步查询 三、延迟加载&#xff08;懒加载&#xff09;1.分步查询的优点…
阅读更多...
最新文章

Copyright @ 2022~2023