Python-VBA函数之旅-property函数

news2024/11/27 4:24:15

目录

一、property函数的常见应用场景

二、property函数使用注意事项

三、如何用好property函数？

1、property函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客 

  

一、property函数的常见应用场景

        在Python中，property()函数(或更常见的是@property装饰器)的实际应用场景非常广泛，主要用于封装类的内部状态并提供对外的访问接口，常见的应用场景有：

1、隐藏内部实现细节：通过getter和setter方法，我们可以隐藏对象的内部状态，只暴露必要的接口给外部调用者，这有助于保护对象的状态不被随意修改，同时也使得代码更加易于理解和维护。

2、添加属性验证：在setter方法中，我们可以添加对属性值的验证逻辑。例如，我们可以确保一个年龄属性总是大于0，或者一个邮箱地址属性总是符合某种格式。

3、计算属性：有些属性可能不是直接存储在对象的状态中的，而是需要基于其他属性计算得出，通过使用property，我们可以将这样的属性表示为对象的一个“正常”属性，而无需调用一个方法来获取它。

4、延迟计算：对于某些计算成本较高的属性，我们可能希望在第一次访问时才进行计算，并将结果缓存起来，通过使用property和内部变量，我们可以实现这样的延迟计算。

5、访问控制： property()函数允许你控制对属性的访问权限。例如，你可以使属性只读，或者只允许在特定条件下修改属性。

6、简化接口：在某些情况下，你可能想要隐藏对象的内部复杂性，只向外部提供一个简洁的接口，使用property可以将内部方法(如getter、setter)暴露为看起来像普通属性的接口。

7、实现数据绑定：在更复杂的场景中，property可以与观察者模式(Observer Pattern)或数据绑定库结合使用，以实现当属性发生变化时自动触发某些操作或更新UI等效果。

8、线程安全：在多线程环境中，对属性的直接访问可能会导致数据竞争或其他并发问题，使用property可以确保在访问或修改属性时执行必要的同步操作，从而保证线程安全。

9、日志记录或监控：在获取或设置属性时，你可能想要记录一些信息(如访问时间、访问者等)，或者触发某些监控事件，通过property可以轻松实现这些功能。

10、惰性加载：对于某些需要大量计算或需要从外部资源(如数据库或网络)加载的属性，可以使用property实现惰性加载，这意味着属性只有在首次被访问时才会进行计算或加载，从而节省资源。

二、property函数使用注意事项

        在Python中，property()函数是一个内置函数，用于在新式类中返回属性值；property()函数允许你定义getter，setter和deleter方法，这些方法分别用于获取、设置和删除对象的属性。以下是在使用property()函数时需要注意的一些事项：

1、定义getter/setter/deleter方法：getter方法通常不需要任何参数，并返回属性的值；setter方法需要接收两个参数：self和要设置的值value；deleter方法只需要self参数。   

示例：
   class Circle:
       def __init__(self, radius=1.0):
           self._radius = radius

       @property
       def radius(self):
           return self._radius

       @radius.setter
       def radius(self, value):
           if value < 0:
               raise ValueError("Radius cannot be negative")
           self._radius = value

       @radius.deleter
       def radius(self):
           del self._radius

2、私有属性：当你使用@property装饰器时，通常建议将实际存储数据的属性设为私有(例如使用下划线前缀)，以避免直接访问和修改它们。

3、装饰器语法：你可以使用装饰器语法来定义getter，setter和deleter方法；另一种语法是使用property()函数直接返回getter，setter和deleter方法作为元组，但这种方法较少使用，因为它不够直观。

4、性能：虽然property()通常不会成为性能瓶颈，但在需要处理大量对象的场合中，频繁地调用getter或setter可能会产生一些开销，在这种情况下，你可能需要考虑其他方法，如使用@cached_property装饰器(来自cached_property库或类似库)来缓存getter方法的返回值。

5、线程安全：如果你在多线程环境中使用setter或deleter方法，并且这些方法可能会修改共享状态，那么你需要确保这些方法是线程安全的。

6、错误处理：在setter方法中，你可能需要添加错误处理逻辑来确保设置的值是有效的。

7、文档字符串：为getter，setter和deleter方法提供文档字符串是一个好习惯，这有助于其他开发者理解这些方法的作用和用法。

8、可读性：当使用property()函数时，确保你的getter，setter和deleter方法的命名清晰易懂，以便其他开发者能够轻松理解你的代码。

9、继承：虽然property()函数提供了更好的封装和抽象，但它也带来了一定的开销，因为每次访问属性时都会调用一个方法，然而，在大多数情况下，这种开销是可以接受的，因为Python方法调用的开销相对较低。

10、向后兼容性：如果你的类需要向后兼容Python 2，请注意property()函数在Python 2和Python 3中的行为可能略有不同：在Python 2中，property()是一个内置的工厂函数；而在Python 3中，它不仅是一个内置函数，也可以用作装饰器。

三、如何用好property函数？

        在Python中，property()函数是一个内置函数，用于创建只读的、可写的或可删除的属性，这提供了一种将方法作为属性访问的方式，从而简化了对对象属性的访问和修改。

property()函数的基本用法有三种：

1、只读属性：只需要定义一个getter方法。

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

obj = MyClass(10)
print(obj.value)  # 输出: 10

在这个例子中，`value` 是一个只读属性，只能通过 `obj.value` 来访问，但不能直接赋值。

2、可读写属性：除了getter方法，还需要定义一个setter方法。

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        if new_value < 0:
            raise ValueError("Value must be non-negative")
        self._value = new_value

obj = MyClass(10)
print(obj.value)  # 输出: 10
obj.value = 20
print(obj.value)  # 输出: 20
obj.value = -1    # 抛出 ValueError

在这个例子中，`value` 是一个可读写属性，可以通过 `obj.value` 来访问，也可以通过 `obj.value = new_value` 来修改，在setter方法中，我们还添加了一个简单的验证逻辑。

3、可删除属性：除了getter和setter方法，还需要定义一个deleter方法。

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value

    @value.deleter
    def value(self):
        del self._value
obj = MyClass(10)
print(obj.value)  # 输出: 10
obj.value = 20
print(obj.value)  # 输出: 20
del obj.value
# 尝试访问 obj.value 将引发 AttributeError

在这个例子中，`value` 是一个可删除的属性，可以使用 `del obj.value` 来删除它。

注意：虽然property()函数可以直接使用，但通常建议使用@property、@value.setter和 @value.deleter装饰器来定义属性，因为它们更加简洁和易读。

1、property函数：
1-1、Python：
# 1.函数：property
# 2.功能：用于创建属性实例，这些实例可以绑定到类的方法上，从而允许我们像访问数据属性一样访问类的方法
# 3.语法：property([fget=None[, fset=None[, fdel=None[, doc=None]]]])
# 4.参数：
# 4-1、fget：用于获取属性值的方法(getter)，它应该是一个不带参数的方法，并且返回一个值；如果省略，则属性为只读
# 4-2、fset：用于设置属性值的方法(setter)，它应该是一个接受一个参数(新值)的方法，并且不返回任何内容(或者返回None)；如果省略，则属性为只读
# 4-3、fdel：用于删除属性的方法(deleter)，它应该是一个不带参数的方法，并且不返回任何内容(或者返回None)；如果省略，则不能删除属性
# 4-4、doc：一个可选的字符串，作为属性的文档字符串，如果省略，则使用`fget`、`fset`或`fdel`方法中的文档字符串(如果存在的话)
# 5.返回值：返回类的属性
# 6.说明：
# 6-1、如果给出doc参数，doc将成为该property属性的文档字符串；否则该property将复制fget/fset/fdel等方法中的文档字符串(如果存在的话)
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(property))
# ['__class__', '__delattr__', '__delete__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__',
# '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__isabstractmethod__', '__le__', '__lt__',
# '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__set__', '__set_name__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', 'deleter', 'fdel', 'fget', 'fset', 'getter', 'setter']

# 用help()函数获取该函数的文档信息
help(property)

# 应用一：隐藏内部实现细节
class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        """Getter for radius."""
        return self._radius

    @radius.setter
    def radius(self, value):
        """Setter for radius, checks if value is positive."""
        if value < 0:
            raise ValueError("Radius cannot be negative.")
        self._radius = value

    @property
    def diameter(self):
        """Calculate and return the diameter."""
        return 2 * self._radius

    @property
    def area(self):
        """Calculate and return the area."""
        import math
        return math.pi * (self._radius ** 2)
# 注意：diameter和area是只读的，因为它们没有setter方法
# 使用Circle类
c = Circle(5)
print(c.radius)  # 访问radius属性
print(c.diameter)  # 访问diameter属性(只读)
print(c.area)  # 访问area属性(只读)
# 5
# 10
# 78.53981633974483

c.radius = 10  # 修改radius属性
print(c.radius)  # 再次访问radius属性，确认已修改
print(c.diameter)  # 再次访问diameter属性，确认已根据新的radius更新
print(c.area)  # 再次访问area属性，确认已根据新的radius更新
# 10
# 20
# 314.1592653589793

# 尝试设置直径或面积(这将失败，因为它们没有setter方法)
# c.diameter = 15  # 这会抛出一个 AttributeError
# c.area = 50      # 这也会抛出一个 AttributeError
# AttributeError: property 'diameter' of 'Circle' object has no setter

# 应用二：添加属性验证
class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = None
        self.age = age  # 使用setter方法进行初始化

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        """Getter for age."""
        return self._age

    @age.setter
    def age(self, value):
        """Setter for age, checks if value is a positive integer."""
        if not isinstance(value, int) or value < 0:
            raise ValueError("Age must be a positive integer.")
        self._age = value

    # 如果你想要一个deleter方法，可以添加如下：
    @age.deleter
    def age(self):
        raise AttributeError("Cannot delete the age attribute.")
# 使用 Person 类
try:
    p = Person("Myelsa", 18)
    print(p.name)  # 输出: Myelsa
    print(p.age)  # 输出: 18

    p.age = 42  # 修改age属性
    print(p.age)  # 输出: 42

    # 尝试设置不合法的age值
    p.age = -1  # 抛出 ValueError
    # p.age = "fourty two"  # 也会抛出ValueError
except ValueError as e:
    print(e)
# Myelsa
# 18
# 42
# Age must be a positive integer.

# 尝试删除age属性(如果已定义deleter)
del p.age  # 如果 deleter 存在且未抛出AttributeError，则会执行
# 否则，上面的代码会按原样运行，因为deleter抛出了AttributeError
# AttributeError: Cannot delete the age attribute.

# 应用三：计算属性
class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height

    @property
    def width(self):
        """Getter for width."""
        return self._width

    @width.setter
    def width(self, value):
        """Setter for width."""
        if value < 0:
            raise ValueError("Width cannot be negative.")
        self._width = value

    @property
    def height(self):
        """Getter for height."""
        return self._height

    @height.setter
    def height(self, value):
        """Setter for height."""
        if value < 0:
            raise ValueError("Height cannot be negative.")
        self._height = value

    @property
    def area(self):
        """Calculate and return the area."""
        return self._width * self._height

    @property
    def perimeter(self):
        """Calculate and return the perimeter."""
        return 2 * (self._width + self._height)

# 使用Rectangle类
rect = Rectangle(5, 10)
print(rect.area)  # 输出: 50 (宽度5乘以高度10)
print(rect.perimeter)  # 输出: 30 (两倍的(宽度5加高度10))

rect.width = 7
print(rect.area)  # 输出: 70 (新的宽度7乘以高度10)
print(rect.perimeter)  # 输出: 34 (两倍的(新的宽度7加高度10))
# 50
# 30
# 70
# 34

# 应用四：延迟计算
class Circle:
    def __init__(self, radius):
        self._radius = radius
        self._area = None
        self._circumference = None

    @property
    def radius(self):
        """Getter for radius."""
        return self._radius

    @radius.setter
    def radius(self, value):
        """Setter for radius."""
        if value < 0:
            raise ValueError("Radius cannot be negative.")
        self._radius = value
        # 当半径改变时，重置缓存的area和circumference
        self._area = None
        self._circumference = None

    @property
    def area(self):
        """Calculate and cache the area."""
        if self._area is None:
            self._area = 3.14159 * self._radius ** 2
        return self._area

    @property
    def circumference(self):
        """Calculate and cache the circumference."""
        if self._circumference is None:
            self._circumference = 2 * 3.14159 * self._radius
        return self._circumference
# 使用 Circle 类
circle = Circle(5)
print(circle.area)  # 首次访问，进行计算并缓存结果
print(circle.circumference)  # 首次访问，进行计算并缓存结果

# 再次访问，直接从缓存中获取结果
print(circle.area)  # 输出与之前相同，因为结果是缓存的
print(circle.circumference)  # 输出与之前相同，因为结果是缓存的

circle.radius = 7
print(circle.area)  # 半径改变，重新计算并缓存新的area
print(circle.circumference)  # 半径改变，重新计算并缓存新的circumference
# 78.53975
# 31.4159
# 78.53975
# 31.4159
# 153.93791
# 43.98226

# 应用五：访问控制
class AccessControlled:
    def __init__(self, value):
        self._value = value

    def get_value(self):
        """Getter for value."""
        # 在这里可以添加访问前的验证或逻辑
        print("Reading value...")
        return self._value

    def set_value(self, value):
        """Setter for value."""
        # 在这里可以添加设置前的验证或逻辑
        if value < 0:
            raise ValueError("Value cannot be negative.")
        print("Setting value...")
        self._value = value

    def del_value(self):
        """Deleter for value."""
        # 在这里可以添加删除前的验证或逻辑
        print("Deleting value...")
        del self._value
    # 使用property()将方法绑定到属性
    value = property(get_value, set_value, del_value, "This is a controlled access value.")
# 使用AccessControlled类
obj = AccessControlled(10)
# 读取属性值
print(obj.value)  # 输出: Reading value... 10
# 设置属性值
obj.value = 20
# 输出: Setting value...
# 尝试设置不合法的属性值
try:
    obj.value = -5
except ValueError as e:
    print(e)  # 输出: Value cannot be negative.
# 删除属性值
del obj.value
# 输出: Deleting value...
# 尝试访问已删除的属性值
try:
    print(obj.value)
except AttributeError:
    print("Value has been deleted.")  # 输出: Value has been deleted.
# Reading value...
# 10
# Setting value...
# Value cannot be negative.
# Deleting value...
# Reading value...
# Value has been deleted.

# 应用六：简化接口
class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height

    @property
    def width(self):
        """Getter for width."""
        return self._width

    @width.setter
    def width(self, value):
        """Setter for width."""
        if value < 0:
            raise ValueError("Width cannot be negative.")
        self._width = value

    @property
    def height(self):
        """Getter for height."""
        return self._height

    @height.setter
    def height(self, value):
        """Setter for height."""
        if value < 0:
            raise ValueError("Height cannot be negative.")
        self._height = value

    @property
    def area(self):
        """Calculate and return the area of the rectangle."""
        return self._width * self._height

    @property
    def perimeter(self):
        """Calculate and return the perimeter of the rectangle."""
        return 2 * (self._width + self._height)
# 使用 Rectangle 类
rect = Rectangle(5, 10)

# 访问属性，无需关心内部计算
print(rect.area)  # 输出: 50
print(rect.perimeter)  # 输出: 30

# 设置属性
rect.width = 7
rect.height = 8

# 再次访问属性
print(rect.area)  # 输出: 56
print(rect.perimeter)  # 输出: 30

# 尝试设置不合法的属性值
try:
    rect.width = -5
except ValueError as e:
    print(e)  # 输出: Width cannot be negative.
# 50
# 30
# 56
# 30
# Width cannot be negative.

# 应用七：实现数据绑定
class DataBinder:
    def __init__(self, initial_value, callback=None):
        self._value = initial_value
        self._callback = callback

    @property
    def value(self):
        """Getter for value."""
        return self._value

    @value.setter
    def value(self, new_value):
        """Setter for value. Triggers the callback if provided."""
        self._value = new_value
        if self._callback:
            self._callback(new_value)

# 定义一个回调函数来模拟数据绑定的效果
def on_value_change(new_value):
    print(f"Value has changed to: {new_value}")
# 使用 DataBinder 类并设置回调函数
binder = DataBinder(10, on_value_change)

# 访问属性值
print(binder.value)  # 输出: 10

# 修改属性值，这会触发回调函数
binder.value = 20
# 输出: Value has changed to: 20

# 再次修改属性值
binder.value = 30
# 输出: Value has changed to: 30

# 应用八：线程安全
import threading
class ThreadSafeClass:
    def __init__(self):
        self._value = 0
        self._lock = threading.Lock()

    @property
    def value(self):
        """线程安全的getter方法"""
        with self._lock:
            return self._value

    @value.setter
    def value(self, new_value):
        """线程安全的setter方法"""
        with self._lock:
            self._value = new_value
# 使用示例
if __name__ == "__main__":
    # 创建一个ThreadSafeClass的实例
    obj = ThreadSafeClass()
    # 假设我们有两个线程，它们将尝试同时访问和修改obj.value
    def worker(obj, name, increment):
        for _ in range(100000):  # 假设我们进行大量操作以突出线程安全问题
            with obj._lock:  # 在这里，我们只是为了演示而手动加锁，但在实际setter/getter中不需要
                old_value = obj.value
                new_value = old_value + increment
                obj.value = new_value
            print(f"{name}: Value after increment is {obj.value}")
    # 创建两个线程
    t1 = threading.Thread(target=worker, args=(obj, "Thread 1", 1))
    t2 = threading.Thread(target=worker, args=(obj, "Thread 2", -1))
    # 启动线程
    t1.start()
    t2.start()
    # 等待线程完成
    t1.join()
    t2.join()
    # 输出最终值(可能不是0，因为线程调度是随机的，但每次操作都是线程安全的)
    print(f"Final value: {obj.value}")

# 应用九：日志记录或监控
import logging
class LoggedPropertyClass:
    def __init__(self):
        self._value = None
        self._logger = logging.getLogger(__name__)
        self._logger.setLevel(logging.INFO)

        # 创建一个handler，用于写入日志文件
        fh = logging.FileHandler('property_log.log')
        fh.setLevel(logging.INFO)

        # 再创建一个handler，用于输出到控制台
        ch = logging.StreamHandler()
        ch.setLevel(logging.INFO)

        # 定义handler的输出格式
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        fh.setFormatter(formatter)
        ch.setFormatter(formatter)

        # 给logger添加handler
        self._logger.addHandler(fh)
        self._logger.addHandler(ch)

    @property
    def value(self):
        """Getter方法，用于访问_value属性，并添加日志记录"""
        self._logger.info("Accessing value: %s", self._value)
        return self._value

    @value.setter
    def value(self, new_value):
        """Setter方法，用于设置_value属性，并添加日志记录"""
        self._logger.info("Setting value to: %s", new_value)
        self._value = new_value

# 使用示例
if __name__ == "__main__":
    obj = LoggedPropertyClass()
    obj.value = 42  # 这将触发setter方法并记录日志
    print(obj.value)  # 这将触发getter方法并记录日志
# 42
# 2024-05-07 18:46:57,919 - __main__ - INFO - Setting value to: 42
# 2024-05-07 18:46:57,919 - __main__ - INFO - Accessing value: 42

# 应用十：惰性加载
class LazyLoadedClass:
    def __init__(self):
        # 初始化时，我们不立即加载数据，而是设置一个标记
        self._data = None
        self._loaded = False

    @property
    def data(self):
        """惰性加载的getter方法"""
        if not self._loaded:
            # 模拟数据加载过程，这里可以替换为实际的数据加载逻辑
            self._data = self._load_data()
            self._loaded = True
        return self._data

    def _load_data(self):
        """模拟的数据加载函数"""
        # 这里可以放置实际的加载逻辑，比如从数据库、文件或网络请求中获取数据
        # 这里我们只是简单地返回一个固定的值作为示例
        print("Loading data...")
        return "Loaded data"

# 使用示例
if __name__ == "__main__":
    obj = LazyLoadedClass()
    print(obj.data)  # 第一次访问，会加载数据并打印"Loading data..."，然后返回"Loaded data"
    print(obj.data)  # 第二次访问，因为数据已经被加载和缓存，所以不会再次加载，直接返回"Loaded data"
# Loading data...
# Loaded data
# Loaded data
1-2、VBA：
略，待后补。
2、推荐阅读：

2-1、Python-VBA函数之旅-open()函数

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页：神奇夜光杯-CSDN博客 

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

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

相关文章

【北京迅为】《iTOP-3588开发板源码编译手册》-第4章 Android12/Linux设备树简介

【北京迅为】《iTOP-3588开发板源码编译手册》-第4章 Android12/Linux设备树简介

RK3588是一款低功耗、高性能的处理器&#xff0c;适用于基于arm的PC和Edge计算设备、个人移动互联网设备等数字多媒体应用&#xff0c;RK3588支持8K视频编解码&#xff0c;内置GPU可以完全兼容OpenGLES 1.1、2.0和3.2。RK3588引入了新一代完全基于硬件的最大4800万像素ISP&…
阅读更多...
4.【Orangepi Zero2】Linux定时器(signal、setitimer)，软件PWM驱动舵机（SG90）

4.【Orangepi Zero2】Linux定时器(signal、setitimer)，软件PWM驱动舵机（SG90）

Linux定时器&#xff08;signal、setitimer&#xff09;&#xff0c;软件PWM驱动舵机&#xff08;SG90&#xff09; signalsetitimer示例 软件PWM驱动舵机&#xff08;SG90&#xff09; signal 详情请看Linux 3.进程间通信&#xff08;shmget shmat shmdt shmctl 共享内存、si…
阅读更多...
帆软报表实现填报报表

帆软报表实现填报报表

我们拿emp表举例 登记信息表 设计一个报表实现对emp表员工的登记 &#xff08;emp表为ORACLE自带用户scott下的一个表&#xff09; 首先&#xff0c;我们设计好填报界面&#xff0c;新建一个普通报表&#xff0c;将emp表中需要的输入一一回应填写进表中。 如下图所示&#xf…
阅读更多...
代码随想录Day 40|Leetcode|Python|139.单词拆分 ● 关于多重背包，你该了解这些！ ● 背包问题总结篇！

代码随想录Day 40|Leetcode|Python|139.单词拆分 ● 关于多重背包，你该了解这些！ ● 背包问题总结篇！

139.单词拆分 给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。 注意&#xff1a;不要求字典中出现的单词全部都使用&#xff0c;并且字典中的单词可以重复使用。 解题思路&#xff1a; 确定dp数组含义…
阅读更多...
如何去官网下载windows10操作系统iso镜像

如何去官网下载windows10操作系统iso镜像

文章目录 一、先从微软中国官网https://www.microsoft.com/zh-cn/进去二、然后按图示一步步点进去三、点击下载工具这个工具会帮你生成windows操作系统iso文件四、下载好后一步步按图示要求成功操作 一、先从微软中国官网https://www.microsoft.com/zh-cn/进去 二、然后按图示一…
阅读更多...
【牛客】排列计算

【牛客】排列计算

原题链接&#xff1a;登录—专业IT笔试面试备考平台_牛客网 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 如果直接涂色来计算单点权重&#xff0c;2e5*2e5必然超时。 所以用差分进行优化。 3. 代码实现 #include<bits/stdc.h> using name…
阅读更多...
【工作记录】openjdk-22基础镜像的构建

【工作记录】openjdk-22基础镜像的构建

背景 近期使用到的框架底层都用的是springboot3.0&#xff0c;要求jdk版本在17甚至更高。 于是决定制作一个基于openjdk22的基础镜像&#xff0c;本文对这一过程进行记录。 作为记录的同时也希望能够帮助到需要的朋友。 期望效果 容器内可以正常使用java相关命令且版本是2…
阅读更多...
vm虚拟机安装网络适配器驱动卡死/无响应/无限等待状态

vm虚拟机安装网络适配器驱动卡死/无响应/无限等待状态

大部分原因都是以前的vm没有卸载干净所导致的&#xff0c;只需要使用CCleaner清楚干净就好 使用控制面板里的卸载把VM卸载干净 使用CCleaner软件删除干净注册表&#xff0c;这个软件百度很容易找到&#xff0c;只有十兆左右 打开下载好的软件&#xff0c;不需要注册码&#xff…
阅读更多...
保研面试408复习 2——操作系统、计网

保研面试408复习 2——操作系统、计网

文章目录 1、操作系统一、进程、线程的概念以及区别&#xff1f;二、进程间的通信方式&#xff1f; 2、计算机网络一、香农准则二、协议的三要素1. 语法2. 语义3. 时序 标记文字记忆&#xff0c;加粗文字注意&#xff0c;普通文字理解。 1、操作系统 一、进程、线程的概念以及…
阅读更多...
Pycharm无法链接服务器环境（host is unresponsived）

Pycharm无法链接服务器环境（host is unresponsived）

困扰了很久的一个问题&#xff0c;一开始是在服务器ubuntu20.04上安装pycharm community&#xff0c;直接运行服务器上的pycharm community就识别不了anaconda中的环境 后来改用pycharm professional也无法远程连接上服务器的环境&#xff0c;识别不了服务器上的环境&#xff…
阅读更多...
ASP.NET网上鲜花销售系统的设计

ASP.NET网上鲜花销售系统的设计

摘 要 本系统实现了一般电子商务所具备的功能&#xff0c;如商品浏览、用户登录注册、网上与购物、结算、后台数据库管理等&#xff0c;利用这些功能可以对鲜花销售信息进行较好的管理。 网上鲜花销售系统的使用者主要是客户和销售管理者&#xff0c;对于客户来说&#xff0…
阅读更多...
小米手机miui14 android chrome如何取消网页自动打开app

小米手机miui14 android chrome如何取消网页自动打开app

搜索媒体打开应用 选择你要阻止打开的app&#xff0c;以github为例 取消勾选打开支持的链接。 参考&#xff1a;https://www.reddit.com/r/chrome/s/JBsGkZDkRZ
阅读更多...
期权怎么开户？

期权怎么开户？

今天期权懂带你了解期权怎么开户&#xff1f;近年来&#xff0c;随着股市的持续低迷&#xff0c;市场交易痛点越发明显的氛围中&#xff0c;所以有人看到了双向交易的期权。 期权怎么开户&#xff1f; 1、首先是证券账户内的资金需要满足50万保留20个交易日&#xff1b; 2、其…
阅读更多...
算法提高之树的最长路径

算法提高之树的最长路径

算法提高之树的最长路径 核心思想&#xff1a;树形dp 枚举路径的中间节点用f1[i] 表示i的子树到i的最长距离,f2[i]表示次长距离最终答案就是max(f1[i]f2[i]) #include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N …
阅读更多...
Python批量计算多张遥感影像的NDVI

Python批量计算多张遥感影像的NDVI

本文介绍基于Python中的gdal模块&#xff0c;批量基于大量多波段遥感影像文件&#xff0c;计算其每1景图像各自的NDVI数值&#xff0c;并将多景结果依次保存为栅格文件的方法。 如下图所示&#xff0c;现在有大量.tif格式的遥感影像文件&#xff0c;其中均含有红光波段与近红外…
阅读更多...
SQL server 数据库log日志过大，占用内存大解决办法

SQL server 数据库log日志过大，占用内存大解决办法

按照下面的截图操作即可。
阅读更多...
便捷的驾驶证识别API，简化工作流程

便捷的驾驶证识别API，简化工作流程

随着社会的发展和人们生活水平的提高&#xff0c;机动车的数量也越来越多。为了确保交通安全和减少违法行为&#xff0c;每个驾驶机动车的人都需要携带驾驶证。然而&#xff0c;识别驾驶证上的信息却是一个繁琐的过程。为了简化这个工作流程&#xff0c;提高工作效率&#xff0…
阅读更多...
echarts学习笔记：柱状图+雷达图+双环形图+地图可视化+数据传递关系图+关键词条图+数据总览图+AntV/G2/DataV

echarts学习笔记：柱状图+雷达图+双环形图+地图可视化+数据传递关系图+关键词条图+数据总览图+AntV/G2/DataV

GitHub - lgd8981289/imooc-visualization: https://www.bilibili.com/video/BV1yu411E7cm/?vd_source391a8dc379e0da60c77490e3221f097a 课程源码 国内echarts镜像站&#xff1a;ISQQW.COM x ECharts 文档&#xff08;国内同步镜像&#xff09; - 配置项 echarts图表集&…
阅读更多...
栈（使用顺序表构建）

栈（使用顺序表构建）

P. S.&#xff1a;以下代码均在VS2019环境下测试&#xff0c;不代表所有编译器均可通过。 P. S.&#xff1a;测试代码均未展示头文件stdio.h的声明&#xff0c;使用时请自行添加。 目录 1、栈的概念2、栈的数组构建方法2.1 前言2.2 正文2.2.1 栈的初始化2.2.2 栈的销毁2.2.3 压…
阅读更多...
Leetcode—289. 生命游戏【中等】

Leetcode—289. 生命游戏【中等】

2024每日刷题&#xff08;126&#xff09; Leetcode—289. 生命游戏 算法思想 实现代码 class Solution { public:void gameOfLife(vector<vector<int>>& board) {int rows board.size();int cols board[0].size();int neighbors[3] {0, 1, -1};vector<…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023