Question

我正在编写一个python模块，它应该包含一些常数，这些常数我目前正在一个类中进行分组，如下所示：

(myModule.py)

class Colors:
    PURPLE = (0.549,0.110,0.706)
    GREEN = (0.188,0.463,0.165)
    BLUE = (0.125,0.247,0.600)
    ORANGE = (0.961,0.533,0.114)

因此，在我的主程序中，我可以使用

(mainProgram.py)

import myModule as mm
niceColor = mm.Colors.PURPLE

到目前为止，很好。

现在，我想向此类的所有常量成员添加一个方法，以便可以这样调用它们：

brightColor = mm.Colors.PURPLE.lighten(0.8)
darkColor = mm.Colors.PURPLE.darken(0.6)

我知道如何编写函数lighten和darken，但是对于在哪里添加它们以获取所需的功能，我一无所知。

非常感谢

Answer 1

您需要为此准备一个课程。由于您处理元组，所以最好的解决方案可能是扩展tuple（甚至更好的namedtuple）：

from collections import namedtuple

class Color(namedtuple("RGB", ["r", "g", "b"])):
    def apply_function(self, function):
        return Color(*map(function, self))

    def lighten(self, value):
        return self.apply_function(lambda x: x*(1+value))

    def darken(self, value):
        return self.apply_function(lambda x: x/(1+value))

class Colors:
    PURPLE = Color(0.549,0.110,0.706)
    GREEN = Color(0.188,0.463,0.165)
    BLUE = Color(0.125,0.247,0.600)
    ORANGE = Color(0.961,0.533,0.114)

您可以执行以下操作：

>>> print(Colors.PURPLE)
Color(r=0.549, g=0.11, b=0.706)
>>> light_purple = Colors.PURPLE.lighten(0.8)
>>> print(light_purple)
Color(r=0.9882000000000001, g=0.198, b=1.2708)

如您所见，这还不完美，因为lighten和darken方法太简单了，您只需要更改传递给apply_function的lambda即可清洁器（例如使用min来限制可以增长的价值）。

拥有namedtuple的好处是您可以通过调用任何颜色从任何颜色直接访问r，g，b中的任何一个， light_purple.r。

Answer 2

您可以添加一个名为color的类，该类具有名为lighten的方法

class color:
    def __init__(self, color):
        self.color = color

    def lighten(self, light):
        pass

然后不做：

PURPLE = (0.549,0.110,0.706)

做

PURPLE = color((0.549,0.110,0.706))

这样，您应该可以从颜色类中调用该方法

Answer 3

要扩展@jotes答案-使其在不调用darken时仍像原来的元组一样工作，可以子类tuple并从那里添加功能。

class Color(tuple):
    def lighten(self):
        pass

    def darken(self):
        pass

class Colors:
    PURPLE = Color([0.549,0.110,0.706])
    # ...and so on

Answer 4

以下内容应为您提供所需的功能。 rgb是一个类属性，而lighten和darken是一个类方法，这意味着您不必在Colors对象的实例中创建即可进行变亮和变暗操作。

class Colors(object):

    @classmethod
    def lighten(cls, scale):
        return tuple([val * scale for val in cls.rgb]) # or whatever you need to do

    @classmethod
    def darken(cls, scale):
        return tuple([val * scale for val in cls.rgb]) # or whatever you need to do


class Purple(Colors):
    rgb = (0.549,0.110,0.706)


class Green(Colors):
    rgb = (0.188,0.463,0.165)


class Blue(Colors):
    rgb = (0.125,0.247,0.600)


class Orange(Colors):
    rgb = (0.961,0.533,0.114)

您可以使用以下内容进行测试：

print(Orange.lighten(0.5))
print(Orange.darken(1.5))

Answer 5

使用NamedTuple

from typing import NamedTuple


class Color(NamedTuple):
    r: float
    g: float
    b: float

    def lighten(self):
        """perform lightening logic here"""

具有常量和方法的类

5 个答案: