Python中的functools模块详解

news2024/10/6 12:30:25

大家好，我是海鸽。

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

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

项目实战：Qt监测操作系统物理网卡通断v1.1.0(支持windows、linux、国产麒麟系统）

项目实战：Qt监测操作系统物理网卡通断v1.1.0(支持windows、linux、国产麒麟系统）

若该文为原创文章&#xff0c;转载请注明出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/136276999 红胖子(红模仿)的博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬结…
阅读更多...
数据结构-列表LinkedList

数据结构-列表LinkedList

一,链表的简单的认识. 数组,栈,队列是线性数据结构,但都算不上是动态数据结构,底层都是依托静态数组,但是链表是确实真正意义上的动态数组. 为什么要学习链表? 1,链表时最简单的动态数据结构 2,掌握链表有助于学习更复杂的数据结构,例如,二叉树,trie. 3,学习链表有助于更深入…
阅读更多...
fpga_硬件加速引擎

fpga_硬件加速引擎

一 什么是硬件加速引擎 硬件加速引擎&#xff0c;也称硬件加速器&#xff0c;是一种采用专用加速芯片/模块替代cpu完成复杂耗时的大算力操作&#xff0c;其过程不需要或者仅需要少量cpu参与。 二 典型的硬件加速引擎 典型的硬件加速引擎有GPU&#xff0c;DSP&#xff0c;ISP&a…
阅读更多...
【Web】CTFSHOW 常用姿势刷题记录(全)

【Web】CTFSHOW 常用姿势刷题记录(全)

目录 web801 web802 web803 web804 web805 web806 web807 法一&#xff1a;反弹shell 法二&#xff1a;vps外带 web808 web809 web810 web811 web812 web813 web814 web815 web816 web817 web818 web819 web820 web821 web822 web823 web824 web825…
阅读更多...
python统计分析——单因素方差分析

python统计分析——单因素方差分析

参考资料&#xff1a;用python动手学统计学 方差分析&#xff1a;analysis of variance&#xff0c;缩写为ANOVA 1、背景知识 1.1 要使用方差分析&#xff0c;数据的总体必须服从正态分布&#xff0c;而且各个水平内部的方差必须相等。 1.2 反复检验导致显著性结果更易出现…
阅读更多...
专业130+总分410+上海交通大学819信号系统与信号处理考研上交电子信息通信生医电科，真题，大纲，参考书。

专业130+总分410+上海交通大学819信号系统与信号处理考研上交电子信息通信生医电科，真题，大纲，参考书。

今年考研顺利结束&#xff0c;我也完成了目前人生最大的逆袭&#xff0c;跨了两个层级跨入c9&#xff0c;专业课819信号系统与信息处理135&#xff0c;数一130总分410&#xff0c;考上上海交大&#xff0c;回想这一年经历了很多&#xff0c;也成长了很多。从周围朋友&#xff0…
阅读更多...
Mysql数据库学习之范式

Mysql数据库学习之范式

范式 范式简介 在关系型数据库中&#xff0c;关于数据表设计的基本原则、规则称为范式。可以理解为&#xff0c;一张数据表的设计结构需要满足的某种设计标准的级别&#xff0c;要想设计一个结构合理的关系型数据库&#xff0c;必须满足一定的范式。 范式都包含哪些 6种范式…
阅读更多...
在当前源文件的目录或生成系统路径中未找到文件

在当前源文件的目录或生成系统路径中未找到文件

vsqt中增加&#xff0c;减少文件&#xff0c;都必须要动一下cmakelist.txt,点一下换行或者保存 因为vsqt反应不过来 1。都必须要动一下cmakelist.txt,点一下换行或者保存 2.然后全部重新生成&#xff0c;或者重新扫描解决方案&#xff08;多扫几次&#xff09;
阅读更多...
SSM项目集成Spring Security 4.X版本 之 加入DWZ,J-UI框架实现登录和主页菜单显示

SSM项目集成Spring Security 4.X版本 之 加入DWZ,J-UI框架实现登录和主页菜单显示

目录 前言 一、加入DWZ J-UI框架 二、实现登录页面 三、实现主页面菜单显示 前言 大家好&#xff01;写文章之前先列出几篇相关文章。本文内容也在其项目中接续实现。 一. SSM项目集成Spring Security 4.X版本&#xff08;使用spring-security.xml 配置文件方式&#xff…
阅读更多...
IDEA中Vue的安装和使用【window10】

IDEA中Vue的安装和使用【window10】

一.准备工作 Vue是前端开发框架。搭建框架&#xff0c;首先要搭建环境。搭建Vue的环境工具&#xff1a;node.js&#xff08;JavaScript的运行环境&#xff09;&#xff0c;然后再用nodejs里面的npm&#xff08;包管理和分发工具&#xff09;来安装依赖包。二.安装node.js 下载…
阅读更多...
【办公类-22-07】周计划系列（2）“主题知识” （2024年调整版本）

【办公类-22-07】周计划系列（2）“主题知识” （2024年调整版本）

作品展示 调用原来的主题知识素材&#xff0c;制作下学期的19周的主题知识word 背景需求&#xff1a; 开学了&#xff0c;继续做周计划系列&#xff0c;在原有基础上&#xff0c;进行进一步代码优化 【办公类-22-02】周计划系列&#xff08;2&#xff09;-生成“主题知识”&…
阅读更多...
【Android】View 与 ViewGroup

【Android】View 与 ViewGroup

View 是 Android 所有控件的基类&#xff0c;我们平常所用的 TextView 和 ImageView 都是继承自 View 的&#xff0c;源码如下&#xff1a; public class TextView extends View implements ViewTreeObserver.OnPreDrawListener {... }public class ImageView extends View {.…
阅读更多...
升级加薪聊绩效过程中，如果我觉得自己受到了老板“不公正”的对待，该如何“怼”回去?...

升级加薪聊绩效过程中，如果我觉得自己受到了老板“不公正”的对待，该如何“怼”回去?...

老板与员工谈绩效 今天分享的主题是「职场的向上管理」 什么是向上管理&#xff1f; 向上管理是一种有自主意识的方法 通过与你的老板在目标上达成共识&#xff0c;并最终用这个目标满足你、你的老板、你的组织的最大利益 向上管理与你的老板无关&#xff0c;老板都没得选的&am…
阅读更多...
Java JDK 下载和配置

Java JDK 下载和配置

Java JDK 下载 下载网址&#xff1a;https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html jdk文件夹的目录介绍 bin: 主要存放的是Java的编译器、解析器等工具。 jre&#xff1a;Java runtime environment, Java 运行时环境。 jre/bin:Java平台…
阅读更多...
RuntimeError: CUDNN_STATUS_EXECUTION_FAILED

RuntimeError: CUDNN_STATUS_EXECUTION_FAILED

问题描述&#xff1a; 运行代码时候报错&#xff1a; 原因&#xff1a;pytorch与cuda版本不对&#xff0c;需要重新安装。不过我在复现代码的时候一般是要求特定的环境&#xff0c;不然会有其他错误&#xff0c;所以选择其他解决办法。 解决方案&#xff1a; 在train.py开头…
阅读更多...
【图论】【堆优化的单源路径】LCP 20. 快速公交

【图论】【堆优化的单源路径】LCP 20. 快速公交

作者推荐 【广度优先搜索】【网格】【割点】【 推荐】1263. 推箱子 LCP 20. 快速公交 小扣打算去秋日市集&#xff0c;由于游客较多&#xff0c;小扣的移动速度受到了人流影响&#xff1a; 小扣从 x 号站点移动至 x 1 号站点需要花费的时间为 inc&#xff1b; 小扣从 x 号站…
阅读更多...
MySQL--索引结构

MySQL--索引结构

索引-索引结构 1. 概述2. 二叉树3. B-Tree4. BTree5. Hash 1. 概述 MySQL的索引是在存储引擎层实现的&#xff0c;不同的存储引擎有不同的索引结构&#xff0c;主要包含以下几种&#xff1a; 上述是MySQL中所支持的所有的索引结构&#xff0c;下面展示不同的存储引擎对于索引…
阅读更多...
如何连接ACL认证的Redis

如何连接ACL认证的Redis

点击上方蓝字关注我 应用程序连接开启了ACL认证的Redis时与原先的方式有差别&#xff0c;本文介绍几种连接开启ACL认证的Redis的Redis的方法。 对于RedisACL认证相关内容&#xff0c;可以参考历史文章&#xff1a; Redis权限管理体系(一&#xff09;&#xff1a;客户端名及用户…
阅读更多...
计算机网络-网络互联

计算机网络-网络互联

文章目录 网络互联网络互联方法LAN-LAN&#xff1a;网桥及其互连原理使用网桥实现LAN-LAN使用交换机扩展局域网使用路由器连接局域网 LAN-WANWAN-WAN路由选择算法非自适应路由选择算法自适应路由选择算法广播路由选择算法&#xff1a;分层路由选择算法 网络互联 网络互联是指利…
阅读更多...
设备树详解

设备树详解

设备树（Device Tree）基本概念及作用 设备树（Device Tree）基本概念 在内核源码中，存在大量对板级细节信息描述的代码。这些代码充斥在/arch/arm/plat-xxx和/arch/arm/mach-xxx目录，对内核而言这些platform设备、resource、i2c_board_info、spi_board_info以及各种硬件的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023