数字¶

影片代码

import manimgx as m


class NumbersHero(m.Scene):
    def construct(self) -> None:
        number = m.DecimalNumber(0, num_decimal_places=2, font_size=96, color=m.YELLOW)
        variable = m.Variable(0, m.MathTex("x"), num_decimal_places=2).scale(1.5)
        tracker = variable.tracker
        m.VGroup(number, variable).arrange(m.DOWN, buff=1)

        def follow(mobject: m.DecimalNumber) -> None:
            mobject.set_value(tracker.get_value())

        number.add_updater(follow)
        self.add(number, variable)
        self.play(tracker.animate.set_value(3.14), run_time=2)
        self.wait()

数字是知道自身值的文本。set_value 在其位置显示另一个值，外观保持不变，因此数字可在场景播放时计数：通过在每个帧设置它的更新器，或通过 ChangeDecimalToValue。

DecimalNumber ¶

一个数字，以固定的小数位数书写：默认为白色且填充，除非另行设置样式。

其组成部分依次为各个字符，每个字符由 mob_class 排版：符号、数字、逗号和小数点；然后是"…"和单位（如果有的话）（若要求，则在所有这些之前有一个背景矩形）。所显示的数字经过舍入（舍入为零的负数会丢失其符号，复数的任一分量亦然），复数以 a+bi 形式书写。 set_value 显示另一个数字，同时保持字体大小、颜色以及边缘 edge_to_fix 不变：由值跟踪器或 ChangeDecimalToValue 驱动时，数字在屏幕上计数。

类型检查器会根据初始值的类型推断：默认为实数，复数初始值则为复数。使用 DecimalNumber[complex](0) 可从实数开始，之后再接受复数值。

m.DecimalNumber(number=0, num_decimal_places=2, mob_class=MathTex, include_sign=False, group_with_commas=True, digit_buff_per_font_unit=0.001, show_ellipsis=False, unit=None, unit_buff_per_font_unit=0, include_background_rectangle=False, edge_to_fix=LEFT, font_size=DEFAULT_FONT_SIZE, **kwargs)

number: 要显示的数字；也可以是复数。
num_decimal_places: 小数点后跟随的数字位数。
mob_class: 每个字符排版所用的类。
include_sign: 非负数是否带加号书写。
group_with_commas: 小数点前的数字是否按三位一组用逗号分组。
digit_buff_per_font_unit: 字符之间的间距，按字体大小单位计（0.001：在 48 时为 0.048 个场景单位）。
show_ellipsis: 数字后是否跟"…"。
unit: 数字后的单位，以 LaTeX 数学表示（"^\circ"、r"\text{ m}"）；以 "^" 开头的单位会提升到数字的顶部。
unit_buff_per_font_unit: 单位前的间距，超出字符间距之外的部分，按字体大小单位计。
include_background_rectangle: 数字后是否有背景矩形。
edge_to_fix: 当新值改变数字宽度时保持不动的边缘，以方向表示。
font_size: 字符的字体大小，以 mob_class 的度量方式计。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

还接受样式关键字。

源码

manimgx\mobjects\numbers.py

@prototype
def __init__(
    self,
    number: V = 0,
    num_decimal_places: int = 2,
    mob_class: type[ManimTextLabel] = MathTex,
    include_sign: bool = False,
    group_with_commas: bool = True,
    digit_buff_per_font_unit: float = 0.001,
    show_ellipsis: bool = False,
    unit: str | None = None,
    unit_buff_per_font_unit: float = 0,
    include_background_rectangle: bool = False,
    edge_to_fix: Vector3DLike = LEFT,
    font_size: float = DEFAULT_FONT_SIZE,
    **kwargs: Unpack[Style],
):
    if font_size <= 0:
        raise ValueError("font_size must be greater than 0.")
    super().__init__(**kwargs)
    self.number = number
    self.num_decimal_places = num_decimal_places
    self.include_sign = include_sign
    self.mob_class = mob_class
    self.group_with_commas = group_with_commas
    self.digit_buff_per_font_unit = digit_buff_per_font_unit
    self.show_ellipsis = show_ellipsis
    self.unit = unit
    self.unit_buff_per_font_unit = unit_buff_per_font_unit
    self.include_background_rectangle = include_background_rectangle
    self.edge_to_fix = edge_to_fix
    self._font_size = font_size
    self._set_submobjects_from_number(number)
    self.init_colors()

font_size ¶

数字的字体大小：创建时的大小乘以自此以后的缩放比例。将其设置为一个正值，可将数字缩放到该大小。

number.font_size

源码

manimgx\mobjects\numbers.py

def font_size(self) -> float:
    """数字的字体大小：创建时的大小乘以自此以后的缩放比例。将其设置为一个
    正值，可将数字缩放到该大小。"""
    return_value: float = self.height / self.initial_height * self._font_size
    return return_value

get_value ¶

所显示的数字，按给定值返回：未经舍入。

number.get_value()

源码

manimgx\mobjects\numbers.py

def get_value(self) -> V:
    """所显示的数字，按给定值返回：未经舍入。"""
    return self.number

increment_value ¶

显示数字加上 delta_t 后的值。

number.increment_value(delta_t=1)

delta_t: 要相加的值。

源码

manimgx\mobjects\numbers.py

def increment_value(self, delta_t: V = 1) -> Self:
    """显示数字加上 `delta_t` 后的值。

    Args:
        delta_t: 要相加的值。
    """
    return self.set_value(self.get_value() + delta_t)

set_value ¶

代码

import manimgx as m


class DecimalNumberSetValueExample(m.Scene):
    def construct(self) -> None:
        tracker = m.ValueTracker(0)
        number = m.DecimalNumber(0, font_size=144).shift(2 * m.LEFT)
        number.add_updater(lambda n: n.set_value(tracker.get_value()))
        self.add(number)
        self.play(tracker.animate.set_value(100), run_time=3)

显示另一个数字，保持外观不变：字体大小、边缘 edge_to_fix 的位置以及颜色——每个字符都取数字自身的颜色，因此赋予单个字符的颜色不会被保留。

number.set_value(number)

number: 要显示的数字。

源码

manimgx\mobjects\numbers.py

def set_value(self, number: V) -> Self:
    """显示另一个数字，保持外观不变：字体大小、边缘 `edge_to_fix` 的位置以及
    颜色——每个字符都取数字自身的颜色，因此赋予单个字符的颜色不会被保留。

    Args:
        number: 要显示的数字。

    Examples:
        ```python
        import manimgx as m


        class DecimalNumberSetValueExample(m.Scene):
            def construct(self) -> None:
                tracker = m.ValueTracker(0)
                number = m.DecimalNumber(0, font_size=144).shift(2 * m.LEFT)
                number.add_updater(lambda n: n.set_value(tracker.get_value()))
                self.add(number)
                self.play(tracker.animate.set_value(100), run_time=3)
        ```
    """
    # every glyph takes the number's own color, as CE's `init_colors` repaints them.
    # A number still as it was left showing the same string is left alone: its
    # members' geometry and paint are values, so "as it was left" is the same objects
    shown = self._get_num_string(number)
    key = self._row_key(shown)
    last = self._shown
    if last is not None and last[0] == key:
        family = self.get_family()
        if len(family) == len(last[1]) and all(
            m is was and m._geometry is g and m.paint is p
            for m, (was, g, p) in zip(family, last[1], strict=True)
        ):
            self.number = number
            return self
    old_font_size = self.font_size
    move_to_point = self.get_critical_point(self.edge_to_fix)
    key = self._set_submobjects_from_number(number)
    self.font_size = old_font_size
    self.move_to(move_to_point, self.edge_to_fix)
    self.init_colors()
    self._shown = (
        key,
        tuple((m, m._geometry, m.paint) for m in self.get_family()),
    )
    return self

Integer ¶

代码

import manimgx as m


class IntegerExample(m.Scene):
    def construct(self) -> None:
        count = m.Integer(0, font_size=144).shift(1.5 * m.LEFT)
        self.add(count)
        self.play(m.ChangeDecimalToValue(count, 1000), run_time=3)

一个整数：没有小数位的 DecimalNumber，默认为白色且填充，除非另行设置样式。

带小数部分的数字会舍入显示，且 get_value 也会对其舍入。

m.Integer(number=0, num_decimal_places=0, **kwargs)

number: 要显示的数字。
num_decimal_places: 小数点后跟随的数字位数：除非给定，否则为零。
mob_class: 每个字符排版所用的类（默认为 MathTex）。
include_sign: 非负数是否带加号书写（默认为 False）。
group_with_commas: 小数点前的数字是否按三位一组用逗号分组，如 12,345（默认为 True）。
digit_buff_per_font_unit: 字符之间的间距，按字体大小单位计：默认值 0.001 在字体大小 48 时为 0.048 个场景单位。
show_ellipsis: 数字后是否跟"…"，用于表示持续变化的值（默认为 False）。
unit: 数字后的单位，以 LaTeX 数学表示："^\circ" 表示度，r"\text{ m}" 表示米；以 "^" 开头的单位会提升到数字的顶部（默认为 None）。
unit_buff_per_font_unit: 单位前的间距，超出字符间距之外的部分，按字体大小单位计（默认为 0）。
include_background_rectangle: 数字后是否有背景矩形（默认为 False）。
edge_to_fix: 当新值改变数字宽度时保持不动的边缘，以方向表示（默认为 LEFT：向右生长）。
font_size: 字符的字体大小，以 mob_class 的度量方式计（默认为 48）。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

源码

manimgx\mobjects\numbers.py

def __init__(
    self,
    number: float = 0,
    num_decimal_places: int = 0,
    **kwargs: Unpack[NumberStyle],
) -> None:
    super().__init__(number=number, num_decimal_places=num_decimal_places, **kwargs)

get_value ¶

所显示的数字：将给定数字舍入为整数。

integer.get_value()

源码

manimgx\mobjects\numbers.py

def get_value(self) -> int:
    """所显示的数字：将给定数字舍入为整数。"""
    return int(np.round(super().get_value()))

Variable ¶

代码

import manimgx as m


class VariableExample(m.Scene):
    def construct(self) -> None:
        x = m.Variable(2.0, "x", num_decimal_places=3)
        y = m.Variable(4.0, "x^2", num_decimal_places=3)
        self.add(m.VGroup(x, y).arrange(m.DOWN, buff=0.5).scale(2))
        t = x.tracker
        y.add_updater(lambda v: v.tracker.set_value(t.get_value() ** 2))
        self.play(t.animate.set_value(5), run_time=3, rate_func=m.linear)

一个带名称的值：由一个标签、"=" 和一个显示值跟踪器值的数字组成。

其组成部分依次为它的 label，接着是 "="，以及它的 value——一个 DecimalNumber 或 Integer，在每一帧显示其 tracker 的值：对跟踪器进行动画，数字即开始计数。

m.Variable(var, label, var_type=DecimalNumber, num_decimal_places=2, **kwargs)

var: 起始值。
label: 标签：一个字符串，以数学形式排版（MathTex），或一个文本或数学 mobject。
var_type: 数字的类：DecimalNumber 或其子类，例如 Integer。
num_decimal_places: 小数点后跟随的数字位数。Integer 类使用其自身的精度默认值。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

还接受样式关键字。

源码

manimgx\mobjects\numbers.py

def __init__(
    self,
    var: float,
    label: str | MathTex | Text | SingleStringMathTex,
    var_type: type[DecimalNumber] = DecimalNumber,
    num_decimal_places: int = 2,
    **kwargs: Unpack[Style],
):
    self.label = MathTex(label) if isinstance(label, str) else label
    """标签，后接 "="，是其子对象之一。"""
    equals = MathTex("=").next_to(self.label, RIGHT)
    self.label.add(equals)
    self.tracker = ValueTracker(var)
    """数字所显示的值跟踪器：设置或对其动画以改变数字。"""
    self.value = (
        var_type(self.tracker.get_value())
        if issubclass(var_type, Integer)
        else var_type(
            self.tracker.get_value(), num_decimal_places=num_decimal_places
        )
    )
    """数字，在每一帧显示跟踪器的值。"""
    self.value.add_updater(self._update_value).next_to(self.label, RIGHT)
    super().__init__(**kwargs)
    self.add(self.label, self.value)

label ¶

标签，后接 "="，是其子对象之一。

tracker ¶

数字所显示的值跟踪器：设置或对其动画以改变数字。

value ¶

数字，在每一帧显示跟踪器的值。

计数至某个值¶

ChangeDecimalToValue ¶

代码

import manimgx as m


class ChangeDecimalToValueExample(m.Scene):
    def construct(self) -> None:
        number = m.DecimalNumber(0, font_size=144)
        self.add(number)
        self.play(m.ChangeDecimalToValue(number, 3.14, run_time=2))

将一个数字计数到某个值。

它从动画创建时所持有的值变化到 target_number，由速率函数缓动。

m.ChangeDecimalToValue(decimal_mob, target_number, **kwargs)

decimal_mob: 要改变的数字。
target_number: 它结束时所达到的值。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    decimal_mob: DecimalNumber[V],
    target_number: V,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    start = decimal_mob.number
    super().__init__(
        decimal_mob, lambda a: interpolate(start, target_number, a), **kwargs
    )

ChangingDecimal ¶

代码

import manimgx as m


class ChangingDecimalExample(m.Scene):
    def construct(self) -> None:
        number = m.DecimalNumber(0, font_size=144)
        self.add(number)
        self.play(m.ChangingDecimal(number, lambda a: 100 * a, run_time=3))

随动画进度改变一个数字所显示的值。

在每一帧，该数字显示 number_update_func 在进度（从 0 到 1，由速率函数缓动）处的取值。

m.ChangingDecimal(decimal_mob, number_update_func, **kwargs)

decimal_mob: 要改变的数字。
number_update_func: 从进度到要显示的值的函数。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    decimal_mob: DecimalNumber[V],
    number_update_func: Callable[[float], V],
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.number_update_func = number_update_func
    super().__init__(decimal_mob, **kwargs)