Table#

Qualified name: manim.mobject.table.Table

class Table(table, row_labels=None, col_labels=None, top_left_entry=None, v_buff=0.8, h_buff=1.3, include_outer_lines=False, add_background_rectangles_to_entries=False, entries_background_color=ManimColor('#000000'), include_background_rectangle=False, background_rectangle_color=ManimColor('#000000'), element_to_mobject=<class 'manim.mobject.text.text_mobject.Paragraph'>, element_to_mobject_config={}, arrange_in_grid_config={}, line_config={}, **kwargs)[source]#

Bases: VGroup

A mobject that displays a table on the screen.

Parameters:

  • table (Iterable[Iterable[float | str | VMobject]]) – A 2D array or list of lists. Content of the table has to be a valid input for the callable set in element_to_mobject.

  • row_labels (Iterable[VMobject] | None) – List of VMobject representing the labels of each row.

  • col_labels (Iterable[VMobject] | None) – List of VMobject representing the labels of each column.

  • top_left_entry (VMobject | None) – The top-left entry of the table, can only be specified if row and column labels are given.

  • v_buff (float) – Vertical buffer passed to arrange_in_grid(), by default 0.8.

  • h_buff (float) – Horizontal buffer passed to arrange_in_grid(), by default 1.3.

  • include_outer_lines (bool) – True if the table should include outer lines, by default False.

  • add_background_rectangles_to_entries (bool) – True if background rectangles should be added to entries, by default False.

  • entries_background_color (ParsableManimColor) – Background color of entries if add_background_rectangles_to_entries is True.

  • include_background_rectangle (bool) – True if the table should have a background rectangle, by default False.

  • background_rectangle_color (ParsableManimColor) – Background color of table if include_background_rectangle is True.

  • element_to_mobject (Callable[[float | str | VMobject], VMobject]) – The Mobject class applied to the table entries. by default Paragraph. For common choices, see text_mobject/tex_mobject.

  • element_to_mobject_config (dict) – Custom configuration passed to element_to_mobject, by default {}.

  • arrange_in_grid_config (dict) – Dict passed to arrange_in_grid(), customizes the arrangement of the table.

  • line_config (dict) – Dict passed to Line, customizes the lines of the table.

  • kwargs – Additional arguments to be passed to VGroup.

Examples

Example: TableExamples

../_images/TableExamples-2.png 
from manim import *

class TableExamples(Scene):
    def construct(self):
        t0 = Table(
            [["This", "is a"],
            ["simple", "Table in \n Manim."]])
        t1 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        t1.add_highlighted_cell((2,2), color=YELLOW)
        t2 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")],
            top_left_entry=Star().scale(0.3),
            include_outer_lines=True,
            arrange_in_grid_config={"cell_alignment": RIGHT})
        t2.add(t2.get_cell((2,2), color=RED))
        t3 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")],
            top_left_entry=Star().scale(0.3),
            include_outer_lines=True,
            line_config={"stroke_width": 1, "color": YELLOW})
        t3.remove(*t3.get_vertical_lines())
        g = Group(
            t0,t1,t2,t3
        ).scale(0.7).arrange_in_grid(buff=1)
        self.add(g)

class TableExamples(Scene):
    def construct(self):
        t0 = Table(
            [["This", "is a"],
            ["simple", "Table in \n Manim."]])
        t1 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        t1.add_highlighted_cell((2,2), color=YELLOW)
        t2 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")],
            top_left_entry=Star().scale(0.3),
            include_outer_lines=True,
            arrange_in_grid_config={"cell_alignment": RIGHT})
        t2.add(t2.get_cell((2,2), color=RED))
        t3 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")],
            top_left_entry=Star().scale(0.3),
            include_outer_lines=True,
            line_config={"stroke_width": 1, "color": YELLOW})
        t3.remove(*t3.get_vertical_lines())
        g = Group(
            t0,t1,t2,t3
        ).scale(0.7).arrange_in_grid(buff=1)
        self.add(g)

Example: BackgroundRectanglesExample

../_images/BackgroundRectanglesExample-2.png 
from manim import *

class BackgroundRectanglesExample(Scene):
    def construct(self):
        background = Rectangle(height=6.5, width=13)
        background.set_fill(opacity=.5)
        background.set_color([TEAL, RED, YELLOW])
        self.add(background)
        t0 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            add_background_rectangles_to_entries=True)
        t1 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            include_background_rectangle=True)
        g = Group(t0, t1).scale(0.7).arrange(buff=0.5)
        self.add(g)

class BackgroundRectanglesExample(Scene):
    def construct(self):
        background = Rectangle(height=6.5, width=13)
        background.set_fill(opacity=.5)
        background.set_color([TEAL, RED, YELLOW])
        self.add(background)
        t0 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            add_background_rectangles_to_entries=True)
        t1 = Table(
            [["This", "is a"],
            ["simple", "Table."]],
            include_background_rectangle=True)
        g = Group(t0, t1).scale(0.7).arrange(buff=0.5)
        self.add(g)

Methods

add_background_to_entries

Adds a black BackgroundRectangle to each entry of the table.

add_highlighted_cell

Highlights one cell at a specific position on the table by adding a BackgroundRectangle.

create

Customized create-type function for tables.

get_cell

Returns one specific cell as a rectangular Polygon without the entry.

get_col_labels

Return the column labels of the table.

get_columns

Return columns of the table as a VGroup of VGroup.

get_entries

Return the individual entries of the table (including labels) or one specific entry if the parameter, pos, is set.

get_entries_without_labels

Return the individual entries of the table (without labels) or one specific entry if the parameter, pos, is set.

get_highlighted_cell

Returns a BackgroundRectangle of the cell at the given position.

get_horizontal_lines

Return the horizontal lines of the table.

get_labels

Returns the labels of the table.

get_row_labels

Return the row labels of the table.

get_rows

Return the rows of the table as a VGroup of VGroup.

get_vertical_lines

Return the vertical lines of the table.

scale

Scale the size by a factor.

set_column_colors

Set individual colors for each column of the table.

set_row_colors

Set individual colors for each row of the table.

Attributes

animate

Used to animate the application of any method of self.

animation_overrides

color

depth

The depth of the mobject.

fill_color

If there are multiple colors (for gradient) this returns the first one

height

The height of the mobject.

n_points_per_curve

sheen_factor

stroke_color

width

The width of the mobject.
_add_horizontal_lines()[source]#

Adds the horizontal lines to the table.

Return type:

Table

_add_labels(mob_table)[source]#

Adds labels to an in a grid arranged VGroup.

Parameters:

mob_table (VGroup) – An in a grid organized class:~.VGroup.

Returns:

Returns the mob_table with added labels.

Return type:

VGroup

_add_vertical_lines()[source]#

Adds the vertical lines to the table

Return type:

Table

_organize_mob_table(table)[source]#

Arranges the VMobject of table in a grid.

Parameters:

table (Iterable[Iterable[VMobject]]) – A 2D iterable object with VMobject entries.

Returns:

The VMobject of the table in a VGroup already arranged in a table-like grid.

Return type:

VGroup

_original__init__(table, row_labels=None, col_labels=None, top_left_entry=None, v_buff=0.8, h_buff=1.3, include_outer_lines=False, add_background_rectangles_to_entries=False, entries_background_color=ManimColor('#000000'), include_background_rectangle=False, background_rectangle_color=ManimColor('#000000'), element_to_mobject=<class 'manim.mobject.text.text_mobject.Paragraph'>, element_to_mobject_config={}, arrange_in_grid_config={}, line_config={}, **kwargs)#

Initialize self. See help(type(self)) for accurate signature.

Parameters:

  • table (Iterable[Iterable[float | str | manim.mobject.types.vectorized_mobject.VMobject]]) –

  • row_labels (Optional[Iterable[VMobject]]) –

  • col_labels (Optional[Iterable[VMobject]]) –

  • top_left_entry (manim.mobject.types.vectorized_mobject.VMobject | None) –

  • v_buff (float) –

  • h_buff (float) –

  • include_outer_lines (bool) –

  • add_background_rectangles_to_entries (bool) –

  • entries_background_color (Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]) –

  • include_background_rectangle (bool) –

  • background_rectangle_color (Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]) –

  • element_to_mobject (Callable[[float | str | manim.mobject.types.vectorized_mobject.VMobject], VMobject]) –

  • element_to_mobject_config (dict) –

  • arrange_in_grid_config (dict) –

  • line_config (dict) –

_table_to_mob_table(table)[source]#

Initilaizes the entries of table as VMobject.

Parameters:

table (Iterable[Iterable[float | str | manim.mobject.types.vectorized_mobject.VMobject]]) – A 2D array or list of lists. Content of the table has to be a valid input for the callable set in element_to_mobject.

Returns:

List of VMobject from the entries of table.

Return type:

List

add_background_to_entries(color=ManimColor('#000000'))[source]#

Adds a black BackgroundRectangle to each entry of the table.

Parameters:

color (Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]) –

Return type:

Table

add_highlighted_cell(pos=(1, 1), color=ManimColor('#FFFF00'), **kwargs)[source]#

Highlights one cell at a specific position on the table by adding a BackgroundRectangle.

Parameters:

  • pos (Sequence[int]) – The position of a specific entry on the table. (1,1) being the top left entry of the table.

  • color (Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]) – The color used to highlight the cell.

  • kwargs – Additional arguments to be passed to BackgroundRectangle.

Return type:

Table

Examples

Example: AddHighlightedCellExample

../_images/AddHighlightedCellExample-1.png 
from manim import *

class AddHighlightedCellExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.add_highlighted_cell((2,2), color=GREEN)
        self.add(table)

class AddHighlightedCellExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.add_highlighted_cell((2,2), color=GREEN)
        self.add(table)
create(lag_ratio=1, line_animation=<class 'manim.animation.creation.Create'>, label_animation=<class 'manim.animation.creation.Write'>, element_animation=<class 'manim.animation.creation.Create'>, entry_animation=<class 'manim.animation.fading.FadeIn'>, **kwargs)[source]#

Customized create-type function for tables.

Parameters:
Returns:

AnimationGroup containing creation of the lines and of the elements.

Return type:

AnimationGroup

Examples

Example: CreateTableExample 

from manim import *

class CreateTableExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")],
            include_outer_lines=True)
        self.play(table.create())
        self.wait()

class CreateTableExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")],
            include_outer_lines=True)
        self.play(table.create())
        self.wait()
get_cell(pos=(1, 1), **kwargs)[source]#

Returns one specific cell as a rectangular Polygon without the entry.

Parameters:

  • pos (Sequence[int]) – The position of a specific entry on the table. (1,1) being the top left entry of the table.

  • kwargs – Additional arguments to be passed to Polygon.

Returns:

Polygon mimicking one specific cell of the Table.

Return type:

Polygon

Examples

Example: GetCellExample

../_images/GetCellExample-1.png 
from manim import *

class GetCellExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        cell = table.get_cell((2,2), color=RED)
        self.add(table, cell)

class GetCellExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        cell = table.get_cell((2,2), color=RED)
        self.add(table, cell)
get_col_labels()[source]#

Return the column labels of the table.

Returns:

VGroup containing the column labels of the table.

Return type:

VGroup

Examples

Example: GetColLabelsExample

../_images/GetColLabelsExample-1.png 
from manim import *

class GetColLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        lab = table.get_col_labels()
        for item in lab:
            item.set_color(random_bright_color())
        self.add(table)

class GetColLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        lab = table.get_col_labels()
        for item in lab:
            item.set_color(random_bright_color())
        self.add(table)
get_columns()[source]#

Return columns of the table as a VGroup of VGroup.

Returns:

VGroup containing each column in a VGroup.

Return type:

VGroup

Examples

Example: GetColumnsExample

../_images/GetColumnsExample-2.png 
from manim import *

class GetColumnsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.add(SurroundingRectangle(table.get_columns()[1]))
        self.add(table)

class GetColumnsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.add(SurroundingRectangle(table.get_columns()[1]))
        self.add(table)
get_entries(pos=None)[source]#

Return the individual entries of the table (including labels) or one specific entry if the parameter, pos, is set.

Parameters:

pos (Optional[Sequence[int]]) – The position of a specific entry on the table. (1,1) being the top left entry of the table.

Returns:

VGroup containing all entries of the table (including labels) or the VMobject at the given position if pos is set.

Return type:

Union[VMobject, VGroup]

Examples

Example: GetEntriesExample

../_images/GetEntriesExample-2.png 
from manim import *

class GetEntriesExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        ent = table.get_entries()
        for item in ent:
            item.set_color(random_bright_color())
        table.get_entries((2,2)).rotate(PI)
        self.add(table)

class GetEntriesExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        ent = table.get_entries()
        for item in ent:
            item.set_color(random_bright_color())
        table.get_entries((2,2)).rotate(PI)
        self.add(table)
get_entries_without_labels(pos=None)[source]#

Return the individual entries of the table (without labels) or one specific entry if the parameter, pos, is set.

Parameters:

pos (Optional[Sequence[int]]) – The position of a specific entry on the table. (1,1) being the top left entry of the table (without labels).

Returns:

VGroup containing all entries of the table (without labels) or the VMobject at the given position if pos is set.

Return type:

Union[VMobject, VGroup]

Examples

Example: GetEntriesWithoutLabelsExample

../_images/GetEntriesWithoutLabelsExample-1.png 
from manim import *

class GetEntriesWithoutLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        ent = table.get_entries_without_labels()
        colors = [BLUE, GREEN, YELLOW, RED]
        for k in range(len(colors)):
            ent[k].set_color(colors[k])
        table.get_entries_without_labels((2,2)).rotate(PI)
        self.add(table)

class GetEntriesWithoutLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        ent = table.get_entries_without_labels()
        colors = [BLUE, GREEN, YELLOW, RED]
        for k in range(len(colors)):
            ent[k].set_color(colors[k])
        table.get_entries_without_labels((2,2)).rotate(PI)
        self.add(table)
get_highlighted_cell(pos=(1, 1), color=ManimColor('#FFFF00'), **kwargs)[source]#

Returns a BackgroundRectangle of the cell at the given position.

Parameters:

  • pos (Sequence[int]) – The position of a specific entry on the table. (1,1) being the top left entry of the table.

  • color (Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]) – The color used to highlight the cell.

  • kwargs – Additional arguments to be passed to BackgroundRectangle.

Return type:

BackgroundRectangle

Examples

Example: GetHighlightedCellExample

../_images/GetHighlightedCellExample-1.png 
from manim import *

class GetHighlightedCellExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        highlight = table.get_highlighted_cell((2,2), color=GREEN)
        table.add_to_back(highlight)
        self.add(table)

class GetHighlightedCellExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        highlight = table.get_highlighted_cell((2,2), color=GREEN)
        table.add_to_back(highlight)
        self.add(table)
get_horizontal_lines()[source]#

Return the horizontal lines of the table.

Returns:

VGroup containing all the horizontal lines of the table.

Return type:

VGroup

Examples

Example: GetHorizontalLinesExample

../_images/GetHorizontalLinesExample-1.png 
from manim import *

class GetHorizontalLinesExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.get_horizontal_lines().set_color(RED)
        self.add(table)

class GetHorizontalLinesExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.get_horizontal_lines().set_color(RED)
        self.add(table)
get_labels()[source]#

Returns the labels of the table.

Returns:

VGroup containing all the labels of the table.

Return type:

VGroup

Examples

Example: GetLabelsExample

../_images/GetLabelsExample-1.png 
from manim import *

class GetLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        lab = table.get_labels()
        colors = [BLUE, GREEN, YELLOW, RED]
        for k in range(len(colors)):
            lab[k].set_color(colors[k])
        self.add(table)

class GetLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        lab = table.get_labels()
        colors = [BLUE, GREEN, YELLOW, RED]
        for k in range(len(colors)):
            lab[k].set_color(colors[k])
        self.add(table)
get_row_labels()[source]#

Return the row labels of the table.

Returns:

VGroup containing the row labels of the table.

Return type:

VGroup

Examples

Example: GetRowLabelsExample

../_images/GetRowLabelsExample-1.png 
from manim import *

class GetRowLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        lab = table.get_row_labels()
        for item in lab:
            item.set_color(random_bright_color())
        self.add(table)

class GetRowLabelsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        lab = table.get_row_labels()
        for item in lab:
            item.set_color(random_bright_color())
        self.add(table)
get_rows()[source]#

Return the rows of the table as a VGroup of VGroup.

Returns:

VGroup containing each row in a VGroup.

Return type:

VGroup

Examples

Example: GetRowsExample

../_images/GetRowsExample-2.png 
from manim import *

class GetRowsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.add(SurroundingRectangle(table.get_rows()[1]))
        self.add(table)

class GetRowsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.add(SurroundingRectangle(table.get_rows()[1]))
        self.add(table)
get_vertical_lines()[source]#

Return the vertical lines of the table.

Returns:

VGroup containing all the vertical lines of the table.

Return type:

VGroup

Examples

Example: GetVerticalLinesExample

../_images/GetVerticalLinesExample-1.png 
from manim import *

class GetVerticalLinesExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.get_vertical_lines()[0].set_color(RED)
        self.add(table)

class GetVerticalLinesExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")])
        table.get_vertical_lines()[0].set_color(RED)
        self.add(table)
scale(scale_factor, **kwargs)[source]#

Scale the size by a factor.

Default behavior is to scale about the center of the mobject.

Parameters:

  • scale_factor (float) – The scaling factor \(\alpha\). If \(0 < |\alpha| < 1\), the mobject will shrink, and for \(|\alpha| > 1\) it will grow. Furthermore, if \(\alpha < 0\), the mobject is also flipped.

  • kwargs – Additional keyword arguments passed to apply_points_function_about_point().

Returns:

self

Return type:

Mobject

Examples

Example: MobjectScaleExample

../_images/MobjectScaleExample-2.png 
from manim import *

class MobjectScaleExample(Scene):
    def construct(self):
        f1 = Text("F")
        f2 = Text("F").scale(2)
        f3 = Text("F").scale(0.5)
        f4 = Text("F").scale(-1)

        vgroup = VGroup(f1, f2, f3, f4).arrange(6 * RIGHT)
        self.add(vgroup)

class MobjectScaleExample(Scene):
    def construct(self):
        f1 = Text("F")
        f2 = Text("F").scale(2)
        f3 = Text("F").scale(0.5)
        f4 = Text("F").scale(-1)

        vgroup = VGroup(f1, f2, f3, f4).arrange(6 * RIGHT)
        self.add(vgroup)

See also

move_to()

set_column_colors(*colors)[source]#

Set individual colors for each column of the table.

Parameters:

colors (Iterable[Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]]) – An iterable of colors; each color corresponds to a column.

Return type:

Table

Examples

Example: SetColumnColorsExample

../_images/SetColumnColorsExample-2.png 
from manim import *

class SetColumnColorsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")]
        ).set_column_colors([RED,BLUE], GREEN)
        self.add(table)

class SetColumnColorsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")]
        ).set_column_colors([RED,BLUE], GREEN)
        self.add(table)
set_row_colors(*colors)[source]#

Set individual colors for each row of the table.

Parameters:

colors (Iterable[Union[ManimColor, int, str, Tuple[int, int, int], Tuple[float, float, float], Tuple[int, int, int, int], Tuple[float, float, float, float], ndarray[Any, dtype[int64]], ndarray[Any, dtype[float64]]]]) – An iterable of colors; each color corresponds to a row.

Return type:

Table

Examples

Example: SetRowColorsExample

../_images/SetRowColorsExample-2.png 
from manim import *

class SetRowColorsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")]
        ).set_row_colors([RED,BLUE], GREEN)
        self.add(table)

class SetRowColorsExample(Scene):
    def construct(self):
        table = Table(
            [["First", "Second"],
            ["Third","Fourth"]],
            row_labels=[Text("R1"), Text("R2")],
            col_labels=[Text("C1"), Text("C2")]
        ).set_row_colors([RED,BLUE], GREEN)
        self.add(table)