Python魔法之旅-魔法方法(08)

目录

一、概述

1、定义

2、作用

二、应用场景

1、构造和析构

2、操作符重载

3、字符串和表示

4、容器管理

5、可调用对象

6、上下文管理

7、属性访问和描述符

8、迭代器和生成器

9、数值类型

10、复制和序列化

11、自定义元类行为

12、自定义类行为

13、类型检查和转换

14、自定义异常

三、学习方法

1、理解基础

2、查阅文档

3、编写示例

4、实践应用

5、阅读他人代码

6、参加社区讨论

7、持续学习

8、练习与总结

9、注意兼容性

10、避免过度使用

四、魔法方法

26、__getstate__方法

26-1、语法

26-2、参数

26-3、功能

26-4、返回值

26-5、说明

26-6、用法

27、__gt__方法

27-1、语法

27-2、参数

27-3、功能

27-4、返回值

27-5、说明

27-6、用法

28、__setstate__方法

28-1、语法

28-2、参数

28-3、功能

28-4、返回值

28-5、说明

28-6、用法

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页
​​​​​​​

一、概述

1、定义

        魔法方法(Magic Methods/Special Methods，也称特殊方法或双下划线方法)是Python中一类具有特殊命名规则的方法，它们的名称通常以双下划线(`__`)开头和结尾。

        魔法方法用于在特定情况下自动被Python解释器调用，而不需要显式地调用它们，它们提供了一种机制，让你可以定义自定义类时具有与内置类型相似的行为。

2、作用

        魔法方法允许开发者重载Python中的一些内置操作或函数的行为，从而为自定义的类添加特殊的功能。

二、应用场景

1、构造和析构

1-1、__init__(self, [args...])：在创建对象时初始化属性。
1-2、__new__(cls, [args...])：在创建对象时控制实例的创建过程(通常与元类一起使用)。
1-3、__del__(self)：在对象被销毁前执行清理操作，如关闭文件或释放资源。

2、操作符重载

2-1、__add__(self, other)、__sub__(self, other)、__mul__(self, other)等：自定义对象之间的算术运算。
2-2、__eq__(self, other)、__ne__(self, other)、__lt__(self, other)等：定义对象之间的比较操作。

3、字符串和表示

3-1、__str__(self)：定义对象的字符串表示，常用于print()函数。
3-2、__repr__(self)：定义对象的官方字符串表示，用于repr()函数和交互式解释器。

4、容器管理

4-1、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key)：用于实现类似列表或字典的索引访问、设置和删除操作。
4-2、__len__(self)：返回对象的长度或元素个数。

5、可调用对象

5-1、__call__(self, [args...])：允许对象像函数一样被调用。

6、上下文管理

6-1、__enter__(self)、__exit__(self, exc_type, exc_val, exc_tb)：用于实现上下文管理器，如with语句中的对象。

7、属性访问和描述符

7-1、__getattr__, __setattr__, __delattr__：这些方法允许对象在访问或修改不存在的属性时执行自定义操作。
7-2、描述符(Descriptors)是实现了__get__, __set__, 和__delete__方法的对象，它们可以控制对另一个对象属性的访问。

8、迭代器和生成器

8-1、__iter__和__next__：这些方法允许对象支持迭代操作，如使用for循环遍历对象。
8-2、__aiter__, __anext__：这些是异步迭代器的魔法方法，用于支持异步迭代。

9、数值类型

9-1、__int__(self)、__float__(self)、__complex__(self)：定义对象到数值类型的转换。
9-2、__index__(self)：定义对象用于切片时的整数转换。

10、复制和序列化

10-1、__copy__和__deepcopy__：允许对象支持浅复制和深复制操作。
10-2、__getstate__和__setstate__：用于自定义对象的序列化和反序列化过程。

11、自定义元类行为

11-1、__metaclass__(Python 2)或元类本身(Python 3)：允许自定义类的创建过程，如动态创建类、修改类的定义等。

12、自定义类行为

12-1、__init__和__new__：用于初始化对象或控制对象的创建过程。
12-2、__init_subclass__：在子类被创建时调用，允许在子类中执行一些额外的操作。

13、类型检查和转换

13-1、__instancecheck__和__subclasscheck__：用于自定义isinstance()和issubclass()函数的行为。

14、自定义异常

14-1、你可以通过继承内置的Exception类来创建自定义的异常类，并定义其特定的行为。

三、学习方法

        要学好Python的魔法方法，你可以遵循以下方法及步骤：

1、理解基础

        首先确保你对Python的基本语法、数据类型、类和对象等概念有深入的理解，这些是理解魔法方法的基础。

2、查阅文档

        仔细阅读Python官方文档中关于魔法方法的部分，文档会详细解释每个魔法方法的作用、参数和返回值。你可以通过访问Python的官方网站或使用help()函数在Python解释器中查看文档。

3、编写示例

        为每个魔法方法编写简单的示例代码，以便更好地理解其用法和效果，通过实际编写和运行代码，你可以更直观地感受到魔法方法如何改变对象的行为。

4、实践应用

        在实际项目中尝试使用魔法方法。如，你可以创建一个自定义的集合类，使用__getitem__、__setitem__和__delitem__方法来实现索引操作。只有通过实践应用，你才能更深入地理解魔法方法的用途和重要性。

5、阅读他人代码

        阅读开源项目或他人编写的代码，特别是那些使用了魔法方法的代码，这可以帮助你学习如何在实际项目中使用魔法方法。通过分析他人代码中的魔法方法使用方式，你可以学习到一些新的技巧和最佳实践。

6、参加社区讨论

        参与Python社区的讨论，与其他开发者交流关于魔法方法的使用经验和技巧，在社区中提问或回答关于魔法方法的问题，这可以帮助你更深入地理解魔法方法并发现新的应用场景。

7、持续学习

        Python语言和其生态系统不断发展，新的魔法方法和功能可能会不断被引入，保持对Python社区的关注，及时学习新的魔法方法和最佳实践。

8、练习与总结

        多做练习，通过编写各种使用魔法方法的代码来巩固你的理解，定期总结你学到的知识和经验，形成自己的知识体系。

9、注意兼容性

        在使用魔法方法时，要注意不同Python版本之间的兼容性差异，确保你的代码在不同版本的Python中都能正常工作。

10、避免过度使用

        虽然魔法方法非常强大，但过度使用可能会导致代码难以理解和维护，在编写代码时，要权衡使用魔法方法的利弊，避免滥用。

        总之，学好Python的魔法方法需要不断地学习、实践和总结，只有通过不断地练习和积累经验，你才能更好地掌握这些强大的工具，并在实际项目中灵活运用它们。

四、魔法方法

26、__getstate__方法

26-1、语法
__getstate__(self, /)
    Helper for pickle
26-2、参数

26-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。 

26-2-2、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

26-3、功能

        用于返回对象的状态，这样该对象就可以被pickle模块序列化为字节流，以便之后可以通过pickle.loads()反序列化回原始对象。

26-4、返回值

        返回一个可以被pickle模块序列化的对象，通常是一个字典，其中包含了重构对象所需的所有状态信息。

26-5、说明

        如果你的类有动态生成的属性或者使用了__slots__来限制实例属性，那么你可能需要更仔细地编写__getstate__和__setstate__方法来确保所有必要的信息都被正确地序列化和反序列化。

26-6、用法
# 026、__getstate__方法：
# 1、基本示例
import pickle
class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __getstate__(self):
        return {'x': self.x, 'y': self.y}
    def __setstate__(self, state):
        self.x = state['x']
        self.y = state['y']
if __name__ == '__main__':
    # 序列化和反序列化
    obj = MyClass(10, 24)
    serialized_obj = pickle.dumps(obj)
    deserialized_obj = pickle.loads(serialized_obj)
    print(deserialized_obj.x, deserialized_obj.y)  # 输出: 10 24

# 2、忽略某些属性
class Person:
    def __init__(self, name, age, password):
        self.name = name
        self.age = age
        self._password = password  # 不想在序列化中包含密码
    def __getstate__(self):
        return {'name': self.name, 'age': self.age}
    def __setstate__(self, state):
        self.name = state['name']
        self.age = state['age']
        self._password = None  # 假设在反序列化时重置密码

# 3、自定义序列化格式
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __getstate__(self):
        return (self.x, self.y)  # 使用元组而不是字典
    def __setstate__(self, state):
        self.x, self.y = state

# 4、处理不可序列化的属性
import socket
class Connection:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.socket = socket.socket()  # 不可序列化
    def __getstate__(self):
        # 不包括 socket 对象
        return {'host': self.host, 'port': self.port}
    def __setstate__(self, state):
        self.host = state['host']
        self.port = state['port']
        self.socket = socket.socket()  # 在反序列化时重新创建 socket

# 5、序列化和反序列化时执行额外操作
class LoggedClass:
    def __init__(self, data):
        self.data = data
    def __getstate__(self):
        print("Serializing...", self.data)
        return {'data': self.data}
    def __setstate__(self, state):
        print("Deserializing...", state['data'])
        self.data = state['data']

# 6、处理集合类型
class SetExample:
    def __init__(self, items):
        self.items = set(items)
    def __getstate__(self):
        return {'items': list(self.items)}  # 将集合转换为列表
    def __setstate__(self, state):
        self.items = set(state['items'])  # 将列表转换回集合

# 7、嵌套对象
class Inner:
    def __init__(self, value):
        self.value = value
class Outer:
    def __init__(self, inner):
        self.inner = inner
    def __getstate__(self):
        return {'inner': self.inner.__getstate__()}  # 嵌套对象也需要序列化
    def __setstate__(self, state):
        self.inner = Inner.__new__(Inner)  # 创建新实例
        self.inner.__setstate__(state['inner'])  # 反序列化嵌套对象

# 8、带有文件和文件描述符的对象
import os
class FileHandler:
    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename, 'rb')
    def __getstate__(self):
        # 关闭文件描述符，只保存文件名
        self.file.close()
        return {'filename': self.filename}
    def __setstate__(self, state):
        self.filename = state['filename']
        self.file = open(self.filename, 'rb')

# 9、带有循环引用的对象
class Node:
    def __init__(self, value, next_node=None):
        self.value = value
        self.next_node = next_node
    def __getstate__(self):
        # 处理循环引用，通常使用弱引用或特殊标记
        # 这里简化处理，只保存值和下一个节点的ID（如果可用）
        if self.next_node is not None:
            next_id = id(self.next_node)
        else:
            next_id = None
        return {'value': self.value, 'next_id': next_id}
    def __setstate__(self, state):
        self.value = state['value']
        self.next_node = None  # 初始为空
        # 在这里，你可能需要一个节点ID到节点的映射来恢复循环引用

# 10、带有线程或进程的对象
import threading
class ThreadedClass:
    def __init__(self):
        self.thread = threading.Thread(target=self.run)
        self.thread.start()
    def run(self):
        # 模拟线程运行
        pass
    def __getstate__(self):
        # 线程不能序列化，所以只保存其他数据（如果有的话）
        # 这里假设没有其他数据可保存，所以返回空字典
        return {}
    def __setstate__(self, state):
        # 在反序列化时，重新创建线程（如果需要的话）
        # 但通常不推荐这样做，因为线程状态难以恢复
        pass
        # 注意：线程和进程状态通常不能序列化，因为它们与特定执行环境紧密相关

27、__gt__方法

27-1、语法
__gt__(self, other, /)
    Return self > other
27-2、参数

27-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。 

27-2-2、other(必须)：表示与self进行比较的另一个对象。

27-2-3、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

27-3、功能

        用于定义对象之间的“大于”(greater than)比较操作。

27-4、返回值

        返回一个布尔值(True或False)，如果self大于other，则返回True；反之，则返回False。

27-5、说明

        如果self.value大于other.value，则方法返回True；否则，你可以根据需要选择返回False或者抛出一个异常。

27-6、用法
# 027、__gt__方法：
# 1、比较两个数字类
class Number:
    def __init__(self, value):
        self.value = value
    def __gt__(self, other):
        if isinstance(other, Number):
            return self.value > other.value
        return NotImplemented
if __name__ == '__main__':
    a = Number(5)
    b = Number(3)
    print(a > b)  # True

# 2、比较两个字符串长度
class StringLength:
    def __init__(self, string):
        self.string = string
    def __gt__(self, other):
        if isinstance(other, StringLength):
            return len(self.string) > len(other.string)
        return NotImplemented
if __name__ == '__main__':
    s1 = StringLength("hello")
    s2 = StringLength("world")
    print(s1 > s2)  # False

# 3、比较两个日期对象
from datetime import date
class DateWrapper:
    def __init__(self, year, month, day):
        self.date = date(year, month, day)

    def __gt__(self, other):
        if isinstance(other, DateWrapper):
            return self.date > other.date
        return NotImplemented
if __name__ == '__main__':
    d1 = DateWrapper(2024, 3, 13)
    d2 = DateWrapper(2024, 6, 1)
    print(d1 > d2)  # False

# 4、比较两个自定义分数类
from fractions import Fraction
class MyFraction:
    def __init__(self, numerator, denominator):
        self.fraction = Fraction(numerator, denominator)
    def __gt__(self, other):
        if isinstance(other, MyFraction):
            return self.fraction > other.fraction
        return NotImplemented
if __name__ == '__main__':
    f1 = MyFraction(3, 2)
    f2 = MyFraction(1, 1)
    print(f1 > f2)  # True

# 5、比较两个点的坐标(二维空间)
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __gt__(self, other):
        if isinstance(other, Point):
            # 比较x坐标，如果相等则比较y坐标
            if self.x == other.x:
                return self.y > other.y
            return self.x > other.x
        return NotImplemented
if __name__ == '__main__':
    p1 = Point(3, 6)
    p2 = Point(5, 11)
    print(p1 > p2)  # False

# 6、比较两个矩形的面积
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    @property
    def area(self):
        return self.width * self.height
    def __gt__(self, other):
        if isinstance(other, Rectangle):
            return self.area > other.area
        return NotImplemented
if __name__ == '__main__':
    r1 = Rectangle(3, 6)
    r2 = Rectangle(5, 11)
    print(r1 > r2)  # False

# 7、 比较两个列表的长度
class ListWrapper:
    def __init__(self, lst):
        self.lst = lst
    def __gt__(self, other):
        if isinstance(other, ListWrapper):
            return len(self.lst) > len(other.lst)
        return NotImplemented
if __name__ == '__main__':
    lw1 = ListWrapper([1, 2, 3])
    lw2 = ListWrapper([1, 2])
    print(lw1 > lw2)  # True

# 8、比较两个字典的键的数量

class DictWrapper:
    def __init__(self, dct):
        self.dct = dct
    def __gt__(self, other):
        if isinstance(other, DictWrapper):
            return len(self.dct.keys()) > len(other.dct.keys())
        return NotImplemented
if __name__ == '__main__':
    dw1 = DictWrapper({'a': 1, 'b': 2})
    dw2 = DictWrapper({'a': 1})
    print(dw1 > dw2) # True

# 9、比较两个自定义员工类的薪资
class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
    def __gt__(self, other):
        if isinstance(other, Employee):
            return self.salary > other.salary
        return NotImplemented
if __name__ == '__main__':
    emp1 = Employee('Myelsa', 50000)
    emp2 = Employee('Jimmy', 48000)
    print(emp1 > emp2)  # True

# 10、比较两个自定义时间段的时长
from datetime import timedelta
class TimePeriod:
    def __init__(self, start, end):
        self.start = start
        self.end = end
    @property
    def duration(self):
        return self.end - self.start
    def __gt__(self, other):
        if isinstance(other, TimePeriod):
            return self.duration > other.duration
        return NotImplemented
if __name__ == '__main__':
    tp1 = TimePeriod(timedelta(hours=2), timedelta(hours=3))
    tp2 = TimePeriod(timedelta(hours=1), timedelta(hours=2))
    print(tp1 > tp2)  # False
    # 注意：这里的timedelta对象不能直接相减，这里的示例仅用于展示结构

# 11、比较两个自定义成绩类的分数
class Grade:
    def __init__(self, score):
        self.score = score
    def __gt__(self, other):
        if isinstance(other, Grade):
            return self.score > other.score
        return NotImplemented
if __name__ == '__main__':
    g1 = Grade(90)
    g2 = Grade(85)
    print(g1 > g2)  # True

# 12、比较两个自定义商品的价格
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def __gt__(self, other):
        if isinstance(other, Product):
            return self.price > other.price
        return NotImplemented
if __name__ == '__main__':
    p1 = Product('Laptop', 1000)
    p2 = Product('Phone', 800)
    print(p1 > p2)  # True

28、__setstate__方法

28-1、语法
__setstate__(self, state, /)
    Set state information for unpickling
28-2、参数

28-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。 

28-2-2、state(必须)：一个对象(通常是一个字典)，包含了在序列化时由 __getstate__ 方法返回的状态信息。

28-2-3、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

28-3、功能

        使用传入的state参数(通常是一个字典或其他数据结构)来重新构造对象的内部状态。

28-4、返回值

        没有返回值，即返回None。

28-5、说明

        在__setstate__方法内部，你可以根据state中的数据来设置对象的属性、调用其他方法或执行其他必要的操作，以确保对象在反序列化后具有与序列化时相同的状态。

28-6、用法
# 028、__setstate__方法：
# 1、基本示例
import pickle
class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __getstate__(self):
        return {'x': self.x, 'y': self.y}
    def __setstate__(self, state):
        self.x = state['x']
        self.y = state['y']
if __name__ == '__main__':
    # 序列化和反序列化
    obj = MyClass(10, 24)
    serialized_obj = pickle.dumps(obj)
    deserialized_obj = pickle.loads(serialized_obj)
    print(deserialized_obj.x, deserialized_obj.y)  # 输出: 10 24

# 2、忽略某些属性
class Person:
    def __init__(self, name, age, password):
        self.name = name
        self.age = age
        self._password = password  # 不想在序列化中包含密码
    def __getstate__(self):
        return {'name': self.name, 'age': self.age}
    def __setstate__(self, state):
        self.name = state['name']
        self.age = state['age']
        self._password = None  # 假设在反序列化时重置密码

# 3、自定义序列化格式
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __getstate__(self):
        return (self.x, self.y)  # 使用元组而不是字典
    def __setstate__(self, state):
        self.x, self.y = state

# 4、处理不可序列化的属性
import socket
class Connection:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.socket = socket.socket()  # 不可序列化
    def __getstate__(self):
        # 不包括 socket 对象
        return {'host': self.host, 'port': self.port}
    def __setstate__(self, state):
        self.host = state['host']
        self.port = state['port']
        self.socket = socket.socket()  # 在反序列化时重新创建 socket

# 5、序列化和反序列化时执行额外操作
class LoggedClass:
    def __init__(self, data):
        self.data = data
    def __getstate__(self):
        print("Serializing...", self.data)
        return {'data': self.data}
    def __setstate__(self, state):
        print("Deserializing...", state['data'])
        self.data = state['data']

# 6、处理集合类型
class SetExample:
    def __init__(self, items):
        self.items = set(items)
    def __getstate__(self):
        return {'items': list(self.items)}  # 将集合转换为列表
    def __setstate__(self, state):
        self.items = set(state['items'])  # 将列表转换回集合

# 7、嵌套对象
class Inner:
    def __init__(self, value):
        self.value = value
class Outer:
    def __init__(self, inner):
        self.inner = inner
    def __getstate__(self):
        return {'inner': self.inner.__getstate__()}  # 嵌套对象也需要序列化
    def __setstate__(self, state):
        self.inner = Inner.__new__(Inner)  # 创建新实例
        self.inner.__setstate__(state['inner'])  # 反序列化嵌套对象

# 8、带有文件和文件描述符的对象
import os
class FileHandler:
    def __init__(self, filename):
        self.filename = filename
        self.file = open(filename, 'rb')
    def __getstate__(self):
        # 关闭文件描述符，只保存文件名
        self.file.close()
        return {'filename': self.filename}
    def __setstate__(self, state):
        self.filename = state['filename']
        self.file = open(self.filename, 'rb')

# 9、带有循环引用的对象
class Node:
    def __init__(self, value, next_node=None):
        self.value = value
        self.next_node = next_node
    def __getstate__(self):
        # 处理循环引用，通常使用弱引用或特殊标记
        # 这里简化处理，只保存值和下一个节点的ID（如果可用）
        if self.next_node is not None:
            next_id = id(self.next_node)
        else:
            next_id = None
        return {'value': self.value, 'next_id': next_id}
    def __setstate__(self, state):
        self.value = state['value']
        self.next_node = None  # 初始为空
        # 在这里，你可能需要一个节点ID到节点的映射来恢复循环引用

# 10、带有线程或进程的对象
import threading
class ThreadedClass:
    def __init__(self):
        self.thread = threading.Thread(target=self.run)
        self.thread.start()
    def run(self):
        # 模拟线程运行
        pass
    def __getstate__(self):
        # 线程不能序列化，所以只保存其他数据（如果有的话）
        # 这里假设没有其他数据可保存，所以返回空字典
        return {}
    def __setstate__(self, state):
        # 在反序列化时，重新创建线程（如果需要的话）
        # 但通常不推荐这样做，因为线程状态难以恢复
        pass
        # 注意：线程和进程状态通常不能序列化，因为它们与特定执行环境紧密相关

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

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

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

相关文章

安装VS2017后，离线安装Debugging Tools for Windows（QT5.9.2使用MSVC2017 64bit编译器）

安装VS2017后，离线安装Debugging Tools for Windows（QT5.9.2使用MSVC2017 64bit编译器）

1、背景 安装VS2017后，Windows Software Development Kit - Windows 10.0.17763.132的Debugging Tools for Windows默认不会安装，如下图。这时在QT5.9.2无法使用MSVC2017 64bit编译器。 2、在线安装 如果在线安装参考之前的文章： Qt5.9.2初…
阅读更多...
vue3简单快速实现主题切换功能

vue3简单快速实现主题切换功能

⛰️个人主页: 蒾酒 🔥系列专栏：《vue3实战》 目录 内容概要 实现步骤 1.定义不同主题的css样式变量 2.入口main.ts中引入这个样式文件 3.主题样式css变量引用 4.设置默认主题样式 5.实现点击按钮主题切换 总结 最近发现了一个巨牛的人工智…
阅读更多...
学习Python之后，可以做哪些兼职？月收入能有多少？一篇文章带你认识一下

学习Python之后，可以做哪些兼职？月收入能有多少？一篇文章带你认识一下

学习Python之后，可以从事多种兼职工作。以下是一些可能的兼职方向及其相关描述： 兼职岗位： Python讲师：负责在线1对1授课，根据学员情况制定个性化教案，并定期汇报备课情况和教学进度。爬虫工程师&#xff1…
阅读更多...
Linux上部署和安装MinIO

Linux上部署和安装MinIO

🍁 作者：知识浅谈，CSDN签约讲师，CSDN博客专家，华为云云享专家，阿里云专家博主 📌 擅长领域：全栈工程师、爬虫、ACM算法，大数据，深度学习 💒 公众号…
阅读更多...
反向传播算法的详细推导

反向传播算法的详细推导

反向传播算法的详细推导
阅读更多...
FV悬浮球，安卓真正小而美的神器，满足你的一切需求。

FV悬浮球，安卓真正小而美的神器，满足你的一切需求。

如果你问安卓最强软件有哪些，不同的人可能会有不同的答案，但如果是问我，那我的答案中一定会有他。 FV悬浮球 他是ES文件浏览器，原作者的新作品，经过几年的开发，拥有了超过400项功能，但大小只有…
阅读更多...
软件开发步骤详解

软件开发步骤详解

一、引言 随着信息技术的迅猛发展，软件已成为现代社会不可或缺的一部分。无论是企业运营、个人生活还是科学研究，都离不开各种软件的支持。因此，掌握软件开发的步骤和技巧对于IT从业者来说至关重要。本文旨在详细介绍软件开发的整个流程&…
阅读更多...
杂项——STM32ZET6要注意的一些问题——高级定时器问题和PB3,PB4引脚问题

杂项——STM32ZET6要注意的一些问题——高级定时器问题和PB3,PB4引脚问题

ZET6可能会用到定时器，高级定时器要输出PWM要加上这样一行代码，否则无法正常输出PWM波 TIM_CtrlPWMOutputs(TIM8, ENABLE); // 主输出使能，当使用的是通用定时器时，这句不需要 ZET6中PB3,PB4引脚默认功能是JTDO和NJTRST,如果想将…
阅读更多...
Day06-Mybatis

Day06-Mybatis

1. Mybatis介绍 2. Mybatis连接数据库并返回数据事例 连接oracle数据的设置方式 spring.application.namespringboot-mybatis spring.datasource.driver-class-nameoracle.jdbc.OracleDriver spring.datasource.urljdbc:oracle:thin:192.168.100.66:1521:orcl spring.datasour…
阅读更多...
创新视频剪辑技巧揭秘：批量垂直翻转轻松上手，瞬间提升视频品质与视觉吸引力

创新视频剪辑技巧揭秘：批量垂直翻转轻松上手，瞬间提升视频品质与视觉吸引力

视频已成为我们记录生活、分享故事的重要载体。然而，如何让你的视频在众多作品中脱颖而出，成为众人瞩目的焦点呢？今天，我们将为你揭秘一种创新的视频剪辑技巧——批量垂直翻转，让你轻松提升视频品质与视觉吸引力&#…
阅读更多...
rust安装

rust安装

目录 一、安装1.1 在Windows上安装1.2 在Linux下安装 二、包管理工具三、Hello World3.1 安装IDE3.2 输出Hello World 一、安装 1.1 在Windows上安装 点击页面 安装 Rust - Rust 程序设计语言 (rust-lang.org)，选择"下载RUSTUP-INIT.EXE(64位）&qu…
阅读更多...
crossover软件安装显示程序错误 crossover中文字体下载失败 运行exe乱码 crossover怎么运行软件

crossover软件安装显示程序错误 crossover中文字体下载失败 运行exe乱码 crossover怎么运行软件

虽然Mac用户一直在不断的增加，但是很多人因为习惯了使用Windows系统上的软件，让他们在使用Mac时，也想照常使用Windows上的软件。借助系统兼容工具CrossOver，则可以便捷地在Mac中跨系统使用Windows系统下的应用和文件。 CrossOver…
阅读更多...
Jmeter安装教程

Jmeter安装教程

1 Jmeter下载 Jmeter下载地址：https://jmeter.apache.org/download_jmeter.cgi，选择需要的版本点击下载 解压jmeter安装包 解压后的安装包如下： 2 配置Jmeter环境变量 进入环境变量配置页面：计算机->属性->高级系统设置-&…
阅读更多...
如何学习ai agent？

如何学习ai agent？

如何学习Agent，推荐阅读《动手做AI Agent》这本书。 推荐理由： 1：一本书能够全方位了解并探索Agent的奥秘！ （1）Agent的发展进程。 （2）可以帮我们做哪些事：自动办公&am…
阅读更多...
充电宝怎么选？充电宝目前什么牌子质量好耐用？盘点好用充电宝

充电宝怎么选？充电宝目前什么牌子质量好耐用？盘点好用充电宝

充电宝怎么选？是不是很多朋友在选充电宝上非常的纠结？在买充电宝上面还是非常有讲究的！市面上的充电宝虽然多，但是不排除很多存在安全隐患的，如果稍微没有挑选好充电宝的话，买来的充电宝极大可能是存在非常…
阅读更多...
自然语言处理学习路线

自然语言处理学习路线

学习目标 NLP 系统知识（从入门到入土） 学习内容 NLP的基本流程：（待更）文本预处理（标点符号处理、繁体转简体、分词Tokenizer）：（待更）词袋模型（TF…
阅读更多...
threejs的三维前端项目用THREEPlaneGeometry创建平面几何体对象的方法

threejs的三维前端项目用THREEPlaneGeometry创建平面几何体对象的方法

在 Three.js 中，可以使用THREE.PlaneGeometry类来创建平面几何体对象。THREE.PlaneGeometry类用于创建一个具有指定宽度和高度的平面几何体。 艾斯视觉作为行业ui设计与前端开发服务商很高兴能在这里与你共同探讨：以下是一个示例代码，展示了如…
阅读更多...
SJ705B-II 安全帽紫外线老化箱

SJ705B-II 安全帽紫外线老化箱

一、主要用途 根据GB/T2812-2006《安全帽测试方法》、GB 2811-2019 《安全帽》等最新国家标准设计，主要用于安全帽紫外线预处理试验。 1、主体结构：测试箱采用全不锈钢箱体，有效保护试验安全及延长使用寿命。内部配件采用金属或聚四氟件&…
阅读更多...
免费，C++蓝桥杯等级考试真题--第4级

免费，C++蓝桥杯等级考试真题--第4级

C蓝桥杯等级考试真题--第4级
阅读更多...
现代易货：以物换物，发现物品新价值

现代易货：以物换物，发现物品新价值

在消费浪潮涌动的现代社会，交换文化逐渐崭露头角，一种新颖的交易模式——现代易货模式，正在悄然流行。它不仅仅是对古老“以物换物”交易方式的传承，更是对物品价值和交换方式的全新诠释。 现代易货模式，顾名思义&…
阅读更多...
最新文章

Copyright @ 2022~2023