目录

属性

Properties 类在创建 EventDispatcher 时使用。

警告

Kivy 的 Properties 不要与 Python 的 properties（即 @property 装饰器和 <property> 类型）混淆。

Kivy 的属性类支持：

值检查 / 验证

当你为属性赋予新值时，该值会经过验证约束的检查。例如，对 OptionProperty 的验证会确保该值位于预定义的可能性列表中。对 NumericProperty 的验证则会检查你的值是否为数值类型。这能在早期避免许多错误。

观察者模式

您可以指定当属性值发生变化时应执行的操作。您可以将自己的函数绑定为对 Property 变化的回调。例如，如果您希望在某个控件的 pos 属性变化时调用一段代码，您可以将一个函数 bind 到该属性上。

更好的内存管理

同一个属性的实例会在多个控件实例之间共享。

Python 与 Kivy 的对比

基础示例

让我们通过创建一个以'a'为浮点属性的Python类来比较Python和Kivy的属性：

class MyClass(object):
    def __init__(self, a=1.0):
        super(MyClass, self).__init__()
        self.a = a

使用Kivy，你可以做到：：

class MyClass(EventDispatcher):
    a = NumericProperty(1.0)

正在跟踪深度。

只有嵌套对象的“顶层”会被跟踪。例如：：

my_list_prop = ListProperty([1, {'hi': 0}])
# Changing a top level element will trigger all `on_my_list_prop` callbacks
my_list_prop[0] = 4
# Changing a deeper element will be ignored by all `on_my_list_prop` callbacks
my_list_prop[1]['hi'] = 4

所有容器类型的Kivy属性同样适用此规则。

值检查

如果你想为某个属性添加最小/最大允许值的检查，这里有一个可能的Python实现：

class MyClass(object):
    def __init__(self, a=1):
        super(MyClass, self).__init__()
        self.a_min = 0
        self.a_max = 100
        self.a = a

    def _get_a(self):
        return self._a
    def _set_a(self, value):
        if value < self.a_min or value > self.a_max:
            raise ValueError('a out of bounds')
        self._a = value
    a = property(_get_a, _set_a)

缺点是这些工作得由你自己完成。如果你有很多属性，这会变得繁琐且复杂。而使用 Kivy，你可以简化这一过程：

class MyClass(EventDispatcher):
    a = BoundedNumericProperty(1, min=0, max=100)

就这样！

错误处理

如果设置一个值通常会引发ValueError，你可以在属性中有两种选项来优雅地处理该错误。第一种选项是使用`errorvalue`参数。`errorvalue`是无效值的替代值:

# simply returns 0 if the value exceeds the bounds
bnp = BoundedNumericProperty(0, min=-500, max=500, errorvalue=0)

第二种选择是使用errorhandler参数。errorhandler是一个可调用对象（单参数函数或lambda），它可以返回一个有效的替代值:

# returns the boundary value when exceeded
bnp = BoundedNumericProperty(0, min=-500, max=500,
    errorhandler=lambda x: 500 if x > 500 else -500)

关键字参数与__init__()

在使用继承时，即对于继承自 EventDispatcher 的对象（例如 Widget）的 __init__() 方法，这些属性可以保护你免受 Python 3 对象错误的影响。当通过 super() 调用将 kwargs 传递给 object 实例时，会出现此错误。

class MyClass(EventDispatcher):
    def __init__(self, **kwargs):
        super(MyClass, self).__init__(**kwargs)
        self.my_string = kwargs.get('my_string')

print(MyClass(my_string='value').my_string)

虽然在Python 2中此错误会被静默忽略，但在Python 3中它将导致应用程序停止，具体如下:

TypeError: object.__init__() takes no parameters

从逻辑上讲，要修复这个问题，你可以在 __init__() 定义中直接将 my_string 作为必需参数，或者作为带有默认值的可选关键字参数，即：：

class MyClass(EventDispatcher):
    def __init__(self, my_string, **kwargs):
        super(MyClass, self).__init__(**kwargs)
        self.my_string = my_string

or:

class MyClass(EventDispatcher):
    def __init__(self, my_string='default', **kwargs):
        super(MyClass, self).__init__(**kwargs)
        self.my_string = my_string

或者，你可以在调用 super() 之前，从 kwargs 字典中弹出该键值对：：

class MyClass(EventDispatcher):
    def __init__(self, **kwargs):
        self.my_string = kwargs.pop('my_string')
        super(MyClass, self).__init__(**kwargs)

Kivy 属性更加灵活，并在后台自动执行所需的 kwargs.pop()`（在调用 `super() 到 EventDispatcher 时），以避免这种干扰：：

class MyClass(EventDispatcher):
    my_string = StringProperty('default')
    def __init__(self, **kwargs):
        super(MyClass, self).__init__(**kwargs)

print(MyClass(my_string='value').my_string)

结论

Kivy 属性比标准属性更易于使用。下一章将提供使用示例，敬请期待 :)

观察属性变化

正如我们一开始所说，Kivy 的 Properties 实现了 观察者模式。这意味着你可以 bind() 到一个属性，并在值变化时调用你自己的函数。

有多种方式可以观察这些变化。

使用bind()进行观察

您可以在类外部使用bind()方法来观察属性的变化：：

class MyClass(EventDispatcher):
    a = NumericProperty(1)

def callback(instance, value):
    print('My callback is call from', instance)
    print('and the a value changed to', value)

ins = MyClass()
ins.bind(a=callback)

# At this point, any change to the a property will call your callback.
ins.a = 5    # callback called
ins.a = 5    # callback not called, because the value did not change
ins.a = -1   # callback called

备注

Property 对象位于类级别，并管理附加到实例上的值。在类级别重新赋值会移除该 Property。例如，继续使用上述代码，MyClass.a = 5 会将属性对象替换为一个简单的整数。

使用 on_<propname> 进行观察

如果你自己定义了该类，可以使用 on_<propname> 回调：：

class MyClass(EventDispatcher):
    a = NumericProperty(1)

    def on_a(self, instance, value):
        print('My property a changed to', value)

警告

请注意 on_<propname> 的使用。如果你在继承的属性上创建此类回调，切勿忘记同时调用父类的函数。

绑定到属性的属性。

当绑定到一个属性的属性时，例如绑定到保存在对象属性中的对象的数值属性，将对象属性更新为指向新对象不会重新绑定数值属性到新对象。例如：

<MyWidget>:
    Label:
        id: first
        text: 'First label'
    Label:
        id: second
        text: 'Second label'
    Button:
        label: first
        text: self.label.text
        on_press: self.label = second

点击按钮时，尽管标签对象的属性已更改为第二个控件，按钮文本不会改变，因为它直接绑定到了第一个标签的文本属性上。

在`1.9.0`版本中，引入了``rebind``选项，该选项允许在``label``发生变化时自动更新``text``，前提是该选项已启用。参见:class:ObjectProperty。

class kivy.properties.AliasProperty(getter, setter=None, rebind=False, watch_before_use=True, **kwargs)

基类：Property

如果你没有找到符合需求的Property类，你可以通过创建自定义的Python getter和setter方法来制作自己的Property类。

来自kivy/uix/widget.py的示例，其中`x`和`width`是:class:`NumericProperty`的实例:

def get_right(self):
    return self.x + self.width
def set_right(self, value):
    self.x = value - self.width
right = AliasProperty(get_right, set_right, bind=['x', 'width'])

如果 x 不是 Kivy 属性，则必须在 setter 中返回 True 以分发 right 的新值：：

def set_right(self, value):
    self.x = value - self.width
    return True

通常，bind 列表应包含 getter 方法中使用的所有 Kivy 属性。如果返回 True，则会触发一次分发，这是在属性值发生变化时应执行的操作。但请注意，如果在 setter 中设置了别名属性所绑定的 Kivy 属性，该属性可能已经分发了变化的值，此时若 setter 返回 True，则会导致第二次分发。

如果你想缓存 getter 返回的值，请传入 cache=True。这样，getter 只会在设置新值或绑定的属性发生变化时被调用。在这两种情况下，别名属性的新值都会被再次缓存。

要使属性只读，将 None 作为 setter 传入。这样，每次尝试设置属性时都会引发 AttributeError：：

right = AliasProperty(get_right, None, bind=['x', 'width'], cache=True)
参数:
getter：函数

用作属性获取器的函数。

setter：函数

用作属性设置器的函数。当属性被设置时（例如 right = 10），绑定到别名属性的回调不会被调用，除非设置器返回 True。

bind：列表/元组

要观察的属性名称字符串列表。这些属性值的变化将触发别名属性的值分发。

cache：布尔值

如果为 True，该值将被缓存，直到某个绑定的元素发生变化，或者 setter 返回 True。

rebind：布尔值，默认为 False

详见 ObjectProperty。

watch_before_use: bool，默认为 True

bind 属性是否在此属性以任何方式使用之前被跟踪（绑定）。

默认情况下，当``bind``属性更新或属性值（除非已缓存）被读取时，会调用getter。作为加速控件创建的优化措施，当``watch_before_use``为False时，我们仅在属性以任何方式被使用（即被绑定、被设置/读取等）后，才跟踪其绑定的属性。

属性值的读取/设置/绑定在两种情况下都会如预期般正确。唯一的区别在于，当设置为 False 时，来自 getter 的任何副作用将不会发生，直到该属性以任何方式被交互，因为 getter 不会被提前调用。

在 1.9.0 版本发生变更: rebind 已被引入。

在 1.4.0 版本发生变更: 已添加参数 cache。

get(self, EventDispatcher obj)
rebind

rebind: 'int'

set(self, EventDispatcher obj, value)
trigger_change(self, EventDispatcher obj, value)
class kivy.properties.BooleanProperty(defaultvalue=True, **kw)

基类：Property

参数:
defaultvalue：布尔值

指定属性的默认值。

class kivy.properties.BoundedNumericProperty(*largs, **kw)

基类：Property

最大边界——在数值范围内。

参数:
default：数值型

指定属性的默认值。

**kwargs：关键字参数列表

如果包含了 min 参数，则指定可接受的最小数值。如果包含了 max 参数，则指定可接受的最大数值。

bounds

返回数值的最小值/最大值。

在 1.0.9 版本加入.

get_max(self, EventDispatcher obj)

返回 obj 中 BoundedNumericProperty 可接受的最大值。如果未设置最大值，则返回 None。用法示例请参阅 get_min。

在 1.1.0 版本加入.

get_min(self, EventDispatcher obj)

返回 obj 中 BoundedNumericProperty 可接受的最小值。如果未设置最小值，则返回 None:

class MyWidget(Widget):
    number = BoundedNumericProperty(0, min=-5, max=5)

widget = MyWidget()
print(widget.property('number').get_min(widget))
# will output -5

在 1.1.0 版本加入.

set_max(self, EventDispatcher obj, value)

更改BoundedNumericProperty可接受的最大值，仅针对`obj`实例。若想禁用，请设为None。用法示例请参阅:attr:set_min。

警告

更改边界不会重新验证当前值。

在 1.1.0 版本加入.

set_min(self, EventDispatcher obj, value)

仅针对`obj`实例，更改BoundedNumericProperty可接受的最小值。若想禁用此限制，请设为None:

class MyWidget(Widget):
    number = BoundedNumericProperty(0, min=-5, max=5)

widget = MyWidget()
# change the minimum to -10
widget.property('number').set_min(widget, -10)
# or disable the minimum check
widget.property('number').set_min(widget, None)

警告

更改边界不会重新验证当前值。

在 1.1.0 版本加入.

class kivy.properties.ColorProperty(defaultvalue=0, **kw)

基类：Property

  • 一组3或4个介于0-1之间的浮点数值（Kivy默认）

  • 格式为#rrggbb或#rrggbbaa的字符串

  • 表示颜色名称的字符串（例如：'red'、'yellow'、'green'）

对象 colormap 用于根据颜色名称获取颜色，颜色名称的定义可在以下 链接 中找到。颜色可以以不同格式赋值，但最终会以 ObservableList 的形式返回，包含4个浮点元素，值介于0-1之间。

参数:
defaultvalue：列表或字符串，默认为 [1.0, 1.0, 1.0, 1.0]

指定属性的默认值。

在 1.10.0 版本加入.

在 2.0.0 版本发生变更: 通过索引或切片设置颜色值时，颜色值将被分发，但使用切片设置时，必须确保切片包含4个介于0-1之间的浮点数分量。现在支持将颜色名称作为值进行赋值。属性允许将值`None`作为默认值。

class kivy.properties.ConfigParserProperty(defaultvalue, section, key, config, **kw)

基类：Property

用于绑定 ConfigParser 的值，同时也能将 ConfigParser 的值与其他属性进行绑定。

ConfigParser 由多个节（sections）组成，每个节包含若干键（keys）及与这些键关联的值。ConfigParserProperty 允许您根据其他 Kivy 属性自动监听并更改指定键的值。

例如，假设我们想要一个TextInput自动将其值（以整数表示）写入ConfigParser的`info`部分。同时，这些TextInput应该从ConfigParser的字段中更新其值。最后，它们的值应显示在一个标签中。在py::中

class Info(Label):

    number = ConfigParserProperty(0, 'info', 'number', 'example',
                                  val_type=int, errorvalue=41)

    def __init__(self, **kw):
        super(Info, self).__init__(**kw)
        config = ConfigParser(name='example')

上述代码创建了一个属性，该属性与名为`example`的ConfigParser中`info`部分的`number`键相连接。最初，这个ConfigParser并不存在。然后，在`__init__`中，创建了一个名为`example`的ConfigParser，它会自动与该属性关联。接着在kv中：

BoxLayout:
    TextInput:
        id: number
        text: str(info.number)
    Info:
        id: info
        number: number.text
        text: 'Number: {}'.format(self.number)

你会注意到我们必须使用 text: str(info.number)，这是因为该属性的值始终是整数，因为我们指定了 int 作为 val_type。然而，我们可以向该属性赋任何值，例如 number: number.text 会赋一个字符串，因为它会立即通过 val_type 回调进行转换。

备注

如果已使用 read() 为这个 ConfigParser 打开了文件，那么每次属性变化时都会调用 write()，以保持文件更新。

警告

建议在kv树构建完成后，再将配置解析器对象赋值给属性（例如，在init中安排到下一帧执行）。这是因为kv树及其属性在构建时，会按照自身的顺序进行评估，因此，解析器中的任何初始值可能会被其绑定的对象覆盖。所以，在上述示例中，TextInput可能初始为空，如果`number: number.text`在`text: str(info.number)`之前被评估，配置值将被（空的）文本值覆盖。

参数:
default：对象类型

指定该键的默认值。如果与此属性关联的解析器没有该节或键，则会使用当前值（初始为默认值）创建它们。

section：字符串类型

必须在ConfigParser中指定键/值将被写入的部分。必须提供该部分。如果该部分不存在，它将被创建。

key：字符串类型

在`section`部分中，值将被写入的键。必须提供。如果该键不存在，它将被创建并写入当前值，否则将使用其现有值。

config：字符串或 ConfigParser 实例。

如果该属性不为None，则关联此属性的ConfigParser实例。如果它是一个字符串，将使用其:attr:`~kivy.config.ConfigParser.name`等于`config`值的ConfigParser实例。如果尚不存在这样的解析器，则每当创建具有此名称的ConfigParser时，它将自动链接到此属性。

每当一个ConfigParser与某个属性关联时，如果该部分或键不存在，则会使用当前属性值来创建该键；否则，将使用现有的键值作为属性值，覆盖其当前值。如果此处使用了字符串，您可以通过更改现有或新ConfigParser实例的:attr:`~kivy.config.ConfigParser.name`来更改与此属性关联的ConfigParser。或者通过:meth:`set_config`方法实现。

**kwargs：关键字参数列表
val_type：一个可调用对象

键值在ConfigParser中以字符串形式保存。当内部读取ConfigParser值并赋给属性，或用户直接更改属性值时，如果`val_type`不为None，则会以新值作为输入调用它，并应返回转换为该属性接受类型的值。例如，如果属性表示整数，val_type`可以简单地设为`int。

如果 val_type 回调抛出 ValueError，且提供了 errorvalue 或 errorhandler，则会使用它们。提示：此处使用 ConfigParser 的 getboolean 函数可能也有助于转换为布尔类型。

verify：一个可调用对象

可用于限制属性允许的值。当为属性赋值时，如果指定了此参数，则会使用新值调用`verify`，若其返回`True`，则接受该值；否则，若提供了`errorvalue`或`errorhandler`，将使用它们，否则会抛出`ValueError`异常。

在 1.9.0 版本加入.

set(self, EventDispatcher obj, value)
set_config(self, config)

设置此属性所使用的ConfigParser对象。通常，在使用`config`参数初始化Property时，ConfigParser会被设置。

参数:
config：一个 ConfigParser 实例。

用于监听和保存属性值更改的实例。如果为None，则断开当前使用的`ConfigParser`。

class MyWidget(Widget):
    username = ConfigParserProperty('', 'info', 'name', None)

widget = MyWidget()
widget.property('username').set_config(ConfigParser())
class kivy.properties.DictProperty(defaultvalue=0, rebind=False, **kw)

基类：Property

参数:
defaultvalue：字典，默认为 {}

指定属性的默认值。

rebind：布尔值，默认为 False

详见 ObjectProperty。

在 1.9.0 版本发生变更: rebind 已被引入。

警告

与 ListProperty 类似，当将字典赋值给 DictProperty 时，属性中存储的字典是该字典的浅拷贝，而非原始字典。详见 ListProperty。

rebind

rebind: 'int'

set(self, EventDispatcher obj, value)
class kivy.properties.ListProperty(defaultvalue=0, **kw)

基类：Property

参数:
defaultvalue：列表，默认值为 []

指定属性的默认值。

警告

当将一个列表赋值给 ListProperty 时，属性中存储的列表是该列表的浅拷贝，而非原始列表。这可以通过以下示例来演示:

>>> class MyWidget(Widget):
>>>     my_list = ListProperty([])

>>> widget = MyWidget()
>>> my_list = [1, 5, {'hi': 'hello'}]
>>> widget.my_list = my_list
>>> print(my_list is widget.my_list)
False
>>> my_list.append(10)
>>> print(my_list, widget.my_list)
[1, 5, {'hi': 'hello'}, 10] [1, 5, {'hi': 'hello'}]

然而，对嵌套级别的修改同样会影响该属性，因为该属性使用的是my_list的浅拷贝。

>>> my_list[2]['hi'] = 'bye'
>>> print(my_list, widget.my_list)
[1, 5, {'hi': 'bye'}, 10] [1, 5, {'hi': 'bye'}]
set(self, EventDispatcher obj, value)
class kivy.properties.NumericProperty(defaultvalue=0, **kw)

基类：Property

它仅接受int或float数值数据类型，或如下所示可转换为数字的字符串。对于其他数值类型，请使用ObjectProperty或使用错误处理器将其转换为int/float。

它不支持numpy数字，因此必须手动将其转换为int/float。例如，``widget.num = np.arange(4)[0]``会引发异常。Numpy数组完全不受支持，即使通过ObjectProperty也不行，因为它们的比较不会返回布尔值。但如果必须使用Kivy属性，请使用带有``comparator``设置为``np.array_equal``的ObjectProperty。例如:

>>> class A(EventDispatcher):
...     data = ObjectProperty(comparator=np.array_equal)
>>> a = A()
>>> a.bind(data=print)
>>> a.data = np.arange(2)
<__main__.A object at 0x000001C839B50208> [0 1]
>>> a.data = np.arange(3)
<__main__.A object at 0x000001C839B50208> [0 1 2]
参数:
defaultvalue：整数或浮点数，默认为0

指定属性的默认值。

>>> wid = Widget()
>>> wid.x = 42
>>> print(wid.x)
42
>>> wid.x = "plop"
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   File "properties.pyx", line 93, in kivy.properties.Property.__set__
   File "properties.pyx", line 111, in kivy.properties.Property.set
   File "properties.pyx", line 159, in kivy.properties.NumericProperty.check
 ValueError: NumericProperty accept only int/float

在 1.4.1 版本发生变更: NumericProperty 现在可以接受自定义文本和元组值来指示单位类型，如 "in"、"pt"、"px"、"cm"、"mm"，格式为：'10pt' 或 (10, 'pt')。

get_format(self, EventDispatcher obj)

返回用于数值计算的格式。默认值为px（表示该值完全未被更改）。否则，它可以是'in'、'pt'、'cm'、'mm'之一。

class kivy.properties.ObjectProperty(defaultvalue=None, rebind=False, **kw)

基类：Property

参数:
defaultvalue：对象类型

指定属性的默认值。

rebind：布尔值，默认为 False

当kv规则中使用此对象作为中间属性时，此对象发生变化时，绑定的属性是否会更新。

标准行为是，如果存在kv规则``text: self.a.b.c.d``，其中``a``、b``和``c``是``rebind``为``False``的属性，而``d``是一个:class:`StringProperty`。那么当规则被应用时，``text``仅绑定到``d。如果``a``、b``或``c``发生变化，``text``仍然保持绑定到``d。此外，如果在规则初次评估时其中任何一个为``None``，例如``b``为``None``；那么``text``会绑定到``b``，即使``b``后来被改为非``None``，也不会再绑定到``d``。

然而，通过将 rebind 设置为 True，当中间属性发生变化时，规则将被重新评估，所有属性都会重新绑定。例如，在上述示例中，每当 b 发生变化，或者如果之前为 None 而现在不再为 None 时，text 会被重新评估并重新绑定到 d。总体结果是，text 现在绑定到了 a、b 或 c 中所有设置了 rebind 为 True 的属性。

**kwargs：关键字参数列表
baseclass

如果 kwargs 中包含 baseclass 参数，则该值将用于验证：isinstance(value, kwargs['baseclass'])。

警告

要将属性标记为已更改，您必须重新分配一个新的Python对象。

在 1.9.0 版本发生变更: rebind 已被引入。

在 1.7.0 版本发生变更: 已添加 baseclass 参数。

rebind

rebind: 'int'

class kivy.properties.OptionProperty(*largs, **kw)

基类：Property

选项。

如果属性中设置的字符串不在有效选项列表（在属性创建时传入）中，将引发 ValueError 异常。

参数:
default：选项列表中的任意有效类型

指定属性的默认值。

**kwargs：关键字参数列表

应包含一个`options`参数，该参数指定一个有效选项的列表（而非元组）。

例如:

class MyWidget(Widget):
    state = OptionProperty("None", options=["On", "Off", "None"])
options

返回可用的选项。

在 1.0.9 版本加入.

class kivy.properties.Property(defaultvalue, **kw)

基类：object

该类负责处理所有基本的设置器和获取器、None类型处理、观察者列表以及存储初始化。此类不应被直接实例化。

默认情况下，一个 Property 总是采用一个默认值:

class MyObject(Widget):

    hello = Property('Hello world')

默认值必须与Property类型一致。例如，你不能将一个列表设置为:class:`StringProperty`的默认值，因为StringProperty会检查默认值。

None 是一个特殊情况：你可以将属性的默认值设置为 None，但之后不能将 None 赋给该属性。如果你确实需要这样做，必须在声明属性时使用 allownone=True:

class MyObject(Widget):

    hello = ObjectProperty(None, allownone=True)

# then later
a = MyObject()
a.hello = 'bleh' # working
a.hello = None # working too, because allownone is True.
参数:
default：

指定属性的默认值。

**kwargs：

如果参数中包含 errorhandler，它应当是一个可调用对象，该对象必须接受单个参数并返回一个有效的替代值。

如果参数中包含 errorvalue，它应该是一个对象。如果设置了该值，它将替换无效的属性值（覆盖 errorhandler）。

如果参数中包含 force_dispatch，它应为布尔值。若为 True，则不进行值比较，即使新值与旧值相同也会触发属性事件（默认情况下，为避免双向绑定中的无限递归，相同值不会触发事件）。请注意，此选项仅适用于高级用法。

comparator：可调用对象或 None

当不为None时，它会被调用并传入两个待比较的值。该函数返回它们是否被视为相同。

deprecated: bool

若设为 True，则在访问或设置该属性时会记录一条警告日志。默认值为 False。

在 1.4.2 版本发生变更: 参数errorhandler和errorvalue已添加。

在 1.9.0 版本发生变更: 新增参数 force_dispatch。

在 1.11.0 版本发生变更: 参数已弃用，已添加。

bind(self, EventDispatcher obj, observer)

添加一个新的观察者，仅在值发生变化时调用。

defaultvalue

默认值：对象

dispatch(self, EventDispatcher obj)

将值变更分发给所有观察者。

在 1.1.0 版本发生变更: 该方法现在可以从Python中访问。

这可用于强制派发属性，即使值未发生变化：：

button = Button()
# get the Property class instance
prop = button.property('text')
# dispatch this property on the button instance
prop.dispatch(button)
fbind(self, EventDispatcher obj, observer, int ref, tuple largs=(), dict kwargs={})

与bind类似，但不检查观察者是否已存在。它还会展开并将largs和kwargs转发给回调函数。解绑时应调用funbind或unbind_uid。它返回一个唯一的正数uid，用于与unbind_uid配合使用。

funbind(self, EventDispatcher obj, observer, tuple largs=(), dict kwargs={})

从我们的widget观察者列表中移除通过fbind绑定的观察者。它会移除找到的第一个匹配项，与搜索所有匹配项的unbind相反。

get(self, EventDispatcher obj)

返回属性的值。

将实例与其真实名称关联起来。

警告

仅供内部使用。

当定义一个widget并使用:class:`Property`类时，属性对象的创建会发生，但实例并不知道其在widget类中的名称:

class MyWidget(Widget):
    uid = NumericProperty(0)

在这个例子中，uid 将是一个 NumericProperty() 实例，但该属性实例并不知道自己的名称。这就是为什么在 Widget.__new__ 中使用 link 方法的原因。link 函数还用于为该特定 widget 实例创建属性的存储空间。

set(self, EventDispatcher obj, value)

为属性设置一个新值。

set_name(self, EventDispatcher obj, unicode name)
unbind(self, EventDispatcher obj, observer, int stop_on_first=0)

从我们的部件观察者列表中移除该观察者。

unbind_uid(self, EventDispatcher obj, uid)

使用uid将观察者从通过fbind绑定的widget观察者列表中移除。

class kivy.properties.ReferenceListProperty(*largs, **kw)

基类：Property

例如，如果 x 和 y 是 NumericProperty 属性，我们可以为 pos 创建一个 ReferenceListProperty。如果你更改 pos 的值，它将自动相应地更改 x 和 y 的值。如果你读取 pos 的值，它将返回一个包含 x 和 y 值的元组。

例如:

class MyWidget(EventDispatcher):
    x = NumericProperty(0)
    y = NumericProperty(0)
    pos = ReferenceListProperty(x, y)
get(self, EventDispatcher obj)
set(self, EventDispatcher obj, _value)
setitem(self, EventDispatcher obj, key, value)
trigger_change(self, EventDispatcher obj, value)
class kivy.properties.StringProperty(defaultvalue='', **kw)

基类：Property

参数:
defaultvalue：字符串，默认值为 ''

指定属性的默认值。

class kivy.properties.VariableListProperty(defaultvalue=None, length=4, **kw)

基类：Property

列表项，并将其扩展至所需的列表大小。

例如，GridLayout 的 padding 过去只接受一个数值，该值会均匀地应用于 GridLayout 的左侧、顶部、右侧和底部。现在，padding 可以接受一个、两个或四个值，这些值会被扩展为长度为四的列表 [left, top, right, bottom]，并存储在属性中。

参数:
default：默认值列表

指定列表的默认值。

length：整数，取值为2或4。

指定最终列表的长度。default 列表将被扩展以匹配此长度的列表。

**kwargs：关键字参数列表

目前未使用。

请记住，default 列表会被扩展为长度为4的列表，以下是一些关于如何处理 VariableListProperty 的示例。

  • VariableListProperty([1]) 表示 [1, 1, 1, 1]。

  • VariableListProperty([1, 2]) 表示 [1, 2, 1, 2]。

  • VariableListProperty(['1px', (2, 'px'), 3, 4.0]) 表示 [1, 2, 3, 4.0]。

  • VariableListProperty(5) 表示 [5, 5, 5, 5]。

  • VariableListProperty(3, length=2) 表示 [3, 3]。

在 1.7.0 版本加入.

length

长度：'int'

« 解析器工具 资源管理 »