Lägg till matematiska ekvationer i PowerPoint-presentationer i Python

Översikt

PowerPoint lagrar ekvationer som Office Math Markup Language (OMML). Med Aspose.Slides för Python via .NET kan du programatiskt skapa samma typ av matematiskt innehåll: bråk, radikaler, funktioner, gränsvärden, N-ary‑operatorer, matriser, arrayer och formaterade matteblock.

I PowerPoint lägger användare normalt till ekvationer via Insert > Equation:

PowerPoint‑fliken Infoga med kommandot Ekvation markerat

Resultatet är redigerbar matematiktext på bilden:

En PowerPoint‑bild som innehåller en redigerbar matematikekvation

Aspose.Slides bygger den matematiska texten genom tre huvudobjekt:

De flesta exempel nedan använder MathematicalText och de kedjade metoderna från MathElementBase för att hålla koden kort och läsbar.

För MathML‑exportscenarier, se Exportera matematiska ekvationer från presentationer i Python via .NET.

Skapa en ekvation

Det här exemplet använder add_math_shape för att skapa en matematikform och lägger till Pythagoras sats:

Ekvationen c² = a² + b²

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    equation = (
        math.MathematicalText("c")
        .set_superscript("2")
        .join("=")
        .join(math.MathematicalText("a").set_superscript("2"))
        .join("+")
        .join(math.MathematicalText("b").set_superscript("2"))
    )

    math_paragraph.add(equation)

    presentation.save("pythagorean-theorem.pptx", slides.export.SaveFormat.PPTX)

Kombinera matematikblock

När delar av en ekvation byggs oberoende som MathBlock‑objekt, använd join_block för att kombinera dem. Exemplet bygger c² = i det vänstra blocket och a² + b² i det högra blocket. set_superscript skapar redigerbara matematiska upphöjda index för alla tre potenser.

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    shape = slide.shapes.add_math_shape(20, 20, 600, 100)
    math_paragraph = shape.text_frame.paragraphs[0].portions[0].math_paragraph

    left_block = math.MathBlock()
    left_block.add(math.MathematicalText("c").set_superscript("2"))
    left_block.add(math.MathematicalText("="))

    right_block = math.MathBlock()
    right_block.add(math.MathematicalText("a").set_superscript("2"))
    right_block.add(math.MathematicalText("+"))
    right_block.add(math.MathematicalText("b").set_superscript("2"))

    combined_block = left_block.join_block(right_block)
    math_paragraph.add(combined_block)

    presentation.save("equation.pptx", slides.export.SaveFormat.PPTX)

join_block returnerar själv left_block, som nu innehåller båda delarna i ordning, och lämnar right_block tomt. Lägg till det kombinerade blocket i MathParagraph endast en gång. Efter att ha öppnat om equation.pptx innehåller stycket ett block som representerar c² = a² + b², där alla tre potenser bevaras som matematiska upphöjda index.

Att anropa add som left_block.add(right_block) försöker istället nästla ett block direkt inuti ett annat och kastar ett RuntimeError som omsluter ett .NET InvalidOperationException.

Lägg till bråk

Använd divide för att skapa ett bråk. Du kan välja en bråksstil med MathFractionTypes.

Ett snett matematiskt bråk som visar en delat med x

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    fraction = math.MathematicalText("1").divide("x", math.MathFractionTypes.SKEWED)

    math_paragraph.add(math.MathBlock(fraction))

    presentation.save("fraction.pptx", slides.export.SaveFormat.PPTX)

För ett staplat bråk, använd MathFractionTypes.BAR:

import aspose.slides.mathtext as math

stacked_fraction = math.MathematicalText("x + 1").divide("y - 1", math.MathFractionTypes.BAR)

Lägg till radikaler

Använd radical för att skapa en kvadratrot, kubikrot eller annan rot. Det aktuella elementet blir basen och argumentet blir graden.

Ett n‑te rotuttryck med x under radikaltecknet

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    radical = math.MathematicalText("x").radical("n")

    math_paragraph.add(math.MathBlock(radical))

    presentation.save("radical.pptx", slides.export.SaveFormat.PPTX)

Visa eller dölja graden av en kvadratrot

En kvadratrot kan visa en explicit 2 eller använda den konventionella √x‑notationen. hide_degree‑egenskapen för MathRadical styr vilken form som visas. Båda formerna behåller graden 2 och radikanden x i den redigerbara ekvationen.

Kvadratroten av x med graden 2 synlig till vänster och dold till höger

Exemplet sparar samma kvadratrot två gånger. 2 är synlig i visible-degree.pptx och dold i hidden-degree.pptx.

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    
    radical = math.MathematicalText("x").radical("2")

    shape = slide.shapes.add_math_shape(20, 20, 200, 100)
    portion = shape.text_frame.paragraphs[0].portions[0]
    portion.math_paragraph.add(math.MathBlock(radical))

    radical.hide_degree = False
    presentation.save("visible-degree.pptx", slides.export.SaveFormat.PPTX)

    radical.hide_degree = True
    presentation.save("hidden-degree.pptx", slides.export.SaveFormat.PPTX)

Lägg till funktioner och gränsvärden

Använd as_argument_of_function eller function för funktioner såsom sin(x), log(x) eller egna funktionsnamn. För gränsvärden, placera lim i ett MathLimit eller använd set_lower_limit.

Gränsvärdet för x när x närmar sig oändligheten

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    limit = (
        math.MathematicalText("lim")
        .set_lower_limit("x\u2192\u221E")
        .function("x")
    )

    math_paragraph.add(math.MathBlock(limit))

    presentation.save("functions-and-limits.pptx", slides.export.SaveFormat.PPTX)

För ett eget funktionsnamn, gör funktionsnamnet till det aktuella elementet och anropa function med dess argument:

import aspose.slides.mathtext as math

custom_function = math.MathematicalText("f").function("x + 1")

Lägg till N-ary‑operatorer och integraler

Använd nary för summor, föreningar, snitt och andra stora operatorer. Använd integral för integraler. Båda metoderna låter dig ange nedre och övre gränser.

En summa med nedre och övre gränser

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    summation_base = (
        math.MathematicalText("x")
        .set_superscript("k")
        .join(math.MathematicalText("a").set_superscript("n-k"))
    )

    summation = summation_base.nary(math.MathNaryOperatorTypes.SUMMATION, "k=0", "n")

    math_paragraph.add(math.MathBlock(summation))

    presentation.save("nary-operators.pptx", slides.export.SaveFormat.PPTX)

N-ary‑operatorer är för stora operatorer med valfria gränser. Enkla operatorer såsom +, - och = läggs vanligtvis till som MathematicalText och slås samman i uttrycket.

För en integral, använd integral:

import aspose.slides.mathtext as math

integral_base = math.MathematicalText("x").join(math.MathematicalText("dx").to_box())
integral = integral_base.integral(math.MathIntegralTypes.SIMPLE, "0", "1")

Lägg till matriser

Använd MathMatrix för rader och kolumner. Matriser inkluderar inte hakparenteser per standard, så kapsla in matrisen när du behöver parenteser, hakparenteser eller måsvingar.

En två‑radig matris med en tom cell

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    matrix = math.MathMatrix(2, 3)

    matrix[0, 0] = math.MathematicalText("1")
    matrix[0, 1] = math.MathematicalText("x")
    matrix[1, 0] = math.MathematicalText("x")
    matrix[1, 1] = math.MathematicalText("2")
    matrix[1, 2] = math.MathematicalText("y")
    math_paragraph.add(math.MathBlock(matrix))

    presentation.save("matrix.pptx", slides.export.SaveFormat.PPTX)

Redigera en befintlig matris

Anta att en lektion i linjär algebra börjar med koefficientmatrisen i matrix.pptx, sparad av föregående exempel. För nästa övning, behåll den första ekvationen, ersätt den andra med två nya ekvationer och revidera variabeluppsättningen. Åtkom den befintliga matrisen som en MathMatrix för att behålla de koefficienter som fortfarande gäller.

Ursprunglig två‑radig koefficientmatris med värdena 1, x och en tom cell i första raden samt x, 2 och y i andra raden

Rad‑ och kolumnindex startar på noll och refererar till matrisen i dess aktuella tillstånd vid varje anrop. Infogning av en rad före index 1 flyttar den ursprungliga andra raden till index 2. Infogning efter index 2 lägger sedan till en rad. Borttagning av rad 2 tar bort den ursprungliga andra ekvationen och flyttar den tillagda raden upp en position. Kolumner skiftar på samma sätt.

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation("matrix.pptx") as presentation:
    shape = presentation.slides[0].shapes[0]
    portion = shape.text_frame.paragraphs[0].portions[0]
    matrix = portion.math_paragraph[0][0]

    matrix.insert_row_before(1)
    matrix.insert_row_after(2)
    matrix.delete_row(2)

    matrix.insert_column_before(1)
    matrix.insert_column_after(3)
    matrix.delete_column(3)

    matrix[1, 0] = math.MathematicalText("12")
    matrix[1, 1] = math.MathematicalText("1")
    matrix[2, 2] = math.MathematicalText("10")
    matrix[2, 3] = math.MathematicalText("1")
    for row in range(matrix.row_count):
        for column in range(matrix.column_count):
            if matrix[row, column] is None:
                matrix[row, column] = math.MathematicalText("0")

    matrix.set_column_alignment(0, math.MathHorizontalAlignment.LEFT)
    matrix.set_columns_alignment(1, 3, math.MathHorizontalAlignment.RIGHT)

    presentation.save("updated-matrix.pptx", slides.export.SaveFormat.PPTX)

set_column_alignment justerar den första kolumnen åt vänster. set_columns_alignment justerar tre på varandra följande kolumner åt höger, med start på index 1. I updated-matrix.pptx har matrisen tre ekvationer och fyra variabler. De ursprungliga första‑radens koefficienter 1 och x visas nu i den första och tredje kolumnen.

Uppdaterad tre‑radig matris som visar raderna 1, 0, x, 0; 12, 1, 0, 0; och 0, 0, 10, 1

Lägg till ekvationsarrayer

Använd to_math_array när du behöver justerade ekvationer eller en vertikal stapel av uttryck.

En vertikal mattearray med x ovanför y

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 140)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    equation_array = (
        math.MathematicalText("x")
        .join("y")
        .to_math_array()
    )

    math_paragraph.add(math.MathBlock(equation_array))

    presentation.save("equation-array.pptx", slides.export.SaveFormat.PPTX)

Justera en array med omkringliggande element

MathArray.base_justification styr den vertikala justeringen av en array relativt de matematiska elementen bredvid den. Exemplet nedan jämför justering med den första raden, mitten av arrayen och den sista raden.

Följande exempel skapar tre identiska arrayer, var och en med tre rader och de närliggande elementen A= och =B. All matematisk text använder Cambria Math 24 punkter. Endast array‑justeringen ändras.

import aspose.slides as slides
import aspose.slides.mathtext as math


def create_text(value):
    text = math.MathematicalText(value)
    text.format.font_height = 24
    text.format.latin_font = slides.FontData("Cambria Math")
    return text


with slides.Presentation() as presentation:
    presentation.slide_size.set_size(780, 200, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]
    alignments = [math.MathVerticalAlignment.TOP, math.MathVerticalAlignment.CENTER, math.MathVerticalAlignment.BOTTOM]
    labels = ["Top", "Center", "Bottom"]

    for i, alignment in enumerate(alignments):
        label = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 20 + i * 260, 10, 240, 30)
        label.fill_format.fill_type = slides.FillType.NO_FILL
        label.line_format.fill_format.fill_type = slides.FillType.NO_FILL
        label.text_frame.text = labels[i]
        label_format = label.text_frame.paragraphs[0].portions[0].portion_format
        label_format.font_height = 16
        label_format.fill_format.fill_type = slides.FillType.SOLID
        label_format.fill_format.solid_fill_color.color = slides.Color.black

        math_shape = slide.shapes.add_math_shape(20 + i * 260, 60, 240, 130)
        math_shape.text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.TOP
        math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph
        math_paragraph.justification = math.MathJustification.LEFT_JUSTIFIED

        rows = [create_text("x+y=3"), create_text("x-y=1"), create_text("x=2")]
        equation_array = math.MathArray(rows)
        equation_array.base_justification = alignment
        left_text = create_text("A=")
        right_text = create_text("=B")
        equation = math.MathBlock(left_text).join(equation_array).join(right_text)
        math_paragraph.add(equation)

    presentation.save("equation-array-alignment.pptx", slides.export.SaveFormat.PPTX)

Jämförelsen visar den sparade presentationen i PowerPoint. Observera placeringen av A= och =B bredvid varje array.

Ekvationsarrayer i PowerPoint med topp-, mitten- och bottenjustering samt identiska intilliggande element

Konfigurera radavstånd

row_spacing_rule väljer avståndsregel för rader inom arrayen. row_spacing ger ett numeriskt värde för en explicit avståndsregel och ignoreras av förinställda regler.

För exakt avstånd mäts värdet i punkter. För proportionellt avstånd mäts det i halvlänkar: värdet 3 i exemplet motsvarar 1,5 linjer. Ställ in båda egenskaperna när du anger ett explicit värde; att bara ändra det numeriska värdet väljer inte en regel.

Exemplet nedan sparar fem presentationer med samma ekvationer, justering och teckensnitt. De första tre använder förinställningar; de två sista visar explicita värden.

import aspose.slides as slides
import aspose.slides.mathtext as math


def create_text(value):
    text = math.MathematicalText(value)
    text.format.font_height = 24
    text.format.latin_font = slides.FontData("Cambria Math")
    return text


settings = [
    (math.MathRowSpacingRule.SINGLE_LINE_GAP, 0),
    (math.MathRowSpacingRule.ONE_AND_A_HALF_LINE_GAP, 0),
    (math.MathRowSpacingRule.TWO_LINE_GAP, 0),
    (math.MathRowSpacingRule.EXACTLY, 20),
    (math.MathRowSpacingRule.MULTIPLE, 3)
]

for rule, spacing in settings:
    file_name = f"equation-array-{rule.name}.pptx"
    with slides.Presentation() as presentation:
        math_shape = presentation.slides[0].shapes.add_math_shape(20, 20, 600, 300)
        paragraph = math_shape.text_frame.paragraphs[0]
        paragraph.paragraph_format.space_before = 0
        paragraph.paragraph_format.space_after = 0
        math_paragraph = paragraph.portions[0].math_paragraph
        math_paragraph.justification = math.MathJustification.LEFT_JUSTIFIED

        rows = [create_text("x+y=3"), create_text("x-y=1"), create_text("x=2")]
        equation_array = math.MathArray(rows)
        equation_array.base_justification = math.MathVerticalAlignment.CENTER
        equation_array.row_spacing_rule = rule
        equation_array.row_spacing = spacing
        left_text = create_text("A=")
        right_text = create_text("=B")
        equation = math.MathBlock(left_text).join(equation_array).join(right_text)
        math_paragraph.add(equation)

        presentation.save(file_name, slides.export.SaveFormat.PPTX)

Array‑radavstånd är separat från styckeavstånd. space_before och space_after lägger till avstånd runt det omgivande stycket, inte mellan array‑rader. På samma sätt positionerar MathParagraph.justification hela matematikstycket horisontellt; det ersätter inte arrayens vertikala justeringsinställning.

Lägg till trigonometriska funktioner

Använd as_argument_of_function när argumentet är det aktuella elementet och funktionsnamnet är känt.

Den trigonometriska funktionen cos tillämpad på 2x

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    cosine = math.MathematicalText("2x").as_argument_of_function(
        math.MathFunctionsOfOneArgument.COS
    )

    math_paragraph.add(math.MathBlock(cosine))

    presentation.save("trigonometric-function.pptx", slides.export.SaveFormat.PPTX)

Lägg till nedsänkta och upphöjda

Använd hjälparfunktionerna för nedsänkta och upphöjda index för index och potenser. När indexen måste visas på vänster sida om basen, använd set_sub_superscript_on_the_left.

En stor bokstav Y med nedsänkt index 1 på vänster sida och upphöjt index n

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    scripts = math.MathematicalText("Y").set_sub_superscript_on_the_left("1", "n")

    math_paragraph.add(math.MathBlock(scripts))

    presentation.save("subscript-superscript.pptx", slides.export.SaveFormat.PPTX)

Justera högra nedsänkta och upphöjda

När båda skripten hör till samma bas, använd MathRightSubSuperscriptElement. Dess align_scripts‑egenskap styr deras horisontella positioner: False (standard) låter dem följa basens kontur, medan True justerar skripten horisontellt med varandra.

Detta exempel placerar två kopior av samma redigerbara uttryck sida vid sida. Båda använder matematiskt kursivt f (U+1D453), ett nedsänkt index 1, ett upphöjt index 2 och Cambria Math 72 punkter. Den lutande basen gör skillnaden synlig i PowerPoint. Installera Cambria Math innan du kör exemplet.

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    presentation.slide_size.set_size(900, 250, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]

    text_format = slides.PortionFormat()
    text_format.font_height = 72
    text_format.latin_font = slides.FontData("Cambria Math")

    for i in range(2):
        left = 40 + i * 440
        shape = slide.shapes.add_math_shape(left, 75, 380, 150)

        base_text = math.MathematicalText("\U0001D453", text_format)
        subscript = math.MathematicalText("1", text_format)
        superscript = math.MathematicalText("2", text_format)
        scripts = math.MathRightSubSuperscriptElement(base_text, subscript, superscript)
        scripts.align_scripts = i == 1

        portion = shape.text_frame.paragraphs[0].portions[0]
        portion.portion_format.font_height = text_format.font_height
        portion.portion_format.latin_font = text_format.latin_font
        portion.math_paragraph.add(math.MathBlock(scripts))

    presentation.save("aligned-scripts.pptx", slides.export.SaveFormat.PPTX)

Två redigerbara uttryck i PowerPoint med align_scripts satt till False till vänster och True till höger

Till vänster börjar det nedsänkta indexet längre åt vänster än det upphöjda, och följer basens kontur. Till höger justeras de två skripten horisontellt med varandra.

Lägg till avgränsare

Använd enclose för att placera ett uttryck inom avgränsare. Du kan även ange ett separat tecken för avgränsare som innehåller flera element.

Ett avgränsningsexpräs som innehåller x, y och z separerade med vertikala staplar

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    delimiter = (
        math.MathematicalText("x")
        .join("y")
        .join("z")
        .enclose("<", ">")
    )
    delimiter.separator_character = "|"

    math_paragraph.add(math.MathBlock(delimiter))

    presentation.save("delimiters.pptx", slides.export.SaveFormat.PPTX)

Storlek och justering av avgränsare

Sätt grow_to_match_operand_height till True för att låta parenteserna anpassa sig efter en hög operand, eller till False för att behålla normal storlek. delimiter_shape accepterar ett av två MathDelimiterShape‑värden. CENTERED centrerar parenteserna på matematikaxeln, som går genom mitten av likhetstecknet. MATCH justerar dem efter det omslutna innehållet. Båda inställningarna påverkar endast avgränsarna. Uttrycket inuti förblir oförändrat.

Exemplet placerar ett bråk i exponenten till x så att uttrycket sträcker sig längre ovanför baslinjen än under den. Alla fyra ekvationer använder samma parenteser och teckensnitt.

import aspose.slides as slides
import aspose.slides.mathtext as math


def add_expression(slide, left, top, grow, shape):
    fraction = math.MathematicalText("a + b").divide("c + d")
    power = math.MathematicalText("x").set_superscript(fraction)
    delimiter = power.enclose("(", ")")
    delimiter.grow_to_match_operand_height = grow
    delimiter.delimiter_shape = shape

    math_shape = slide.shapes.add_math_shape(left, top, 300, 100)
    portion = math_shape.text_frame.paragraphs[0].portions[0]
    portion.portion_format.font_height = 32
    equation = math.MathematicalText("y = ").join(delimiter)
    portion.math_paragraph.add(equation)


with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    add_expression(slide, 20, 20, True, math.MathDelimiterShape.CENTERED)
    add_expression(slide, 350, 20, True, math.MathDelimiterShape.MATCH)
    add_expression(slide, 20, 140, False, math.MathDelimiterShape.CENTERED)
    add_expression(slide, 350, 140, False, math.MathDelimiterShape.MATCH)

    presentation.save("delimiter-sizing.pptx", slides.export.SaveFormat.PPTX)

I PowerPoint, jämför raderna för att se effekt av tillväxt. På översta raden växer parenteserna för att omsluta exponenten och ser likadana ut för båda formerna. På nedersta raden är tillväxt avstängd. De mindre parenteserna till vänster (CENTERED) justeras med likhetstecknet, medan de till höger (MATCH) sitter högre kring uttrycket.

Fyra ekvationer i PowerPoint med avgränsargrökning aktiverad ovanför och inaktiverad nedan, samt Centered till vänster och Match till höger

Lägg till en ramruta

Anropa to_border_box på ett bråk för att rama in hela uttrycket. Den returnerade MathBorderBox visar som standard alla fyra sidor. Använd hide_top, hide_bottom, hide_left och hide_right för att ta bort enskilda sidor.

Exemplet placerar sex kopior av samma bråk på en bild. För att visa annullering, dölj alla fyra sidor och sätt strikethrough_bottom_left_to_top_right för en stigande diagonal (↗) eller strikethrough_top_left_to_bottom_right för en fallande diagonal (↘). Du kan även använda strikethrough_horizontal eller strikethrough_vertical med valfri kombination av synliga sidor.

import aspose.slides as slides
import aspose.slides.mathtext as math


def add_fraction(slide, x, y, hide_border=False):
    fraction = math.MathematicalText("x+1").divide("y+2")
    box = fraction.to_border_box()
    box.hide_top = box.hide_bottom = box.hide_left = box.hide_right = hide_border

    shape = slide.shapes.add_math_shape(x, y, 160, 90)
    portion = shape.text_frame.paragraphs[0].portions[0]
    portion.portion_format.font_height = 28
    portion.math_paragraph.add(math.MathBlock(box))
    return box


with slides.Presentation() as presentation:
    presentation.slide_size.set_size(540, 220, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]

    add_fraction(slide, 10, 10)

    partial = add_fraction(slide, 190, 10)
    partial.hide_top = True
    partial.hide_right = True

    add_fraction(slide, 370, 10, hide_border=True).strikethrough_bottom_left_to_top_right = True
    add_fraction(slide, 10, 120, hide_border=True).strikethrough_top_left_to_bottom_right = True
    add_fraction(slide, 190, 120, hide_border=True).strikethrough_horizontal = True
    add_fraction(slide, 370, 120).strikethrough_vertical = True

    presentation.save("border-box.pptx", slides.export.SaveFormat.PPTX)

Sex redigerbara bråk i PowerPoint. Övre raden: full ram, nedersta och vänstra sidorna, stigande diagonal. Nedre raden: fallande diagonal, horisontell stråklinje, vertikal stråklinje med full ram.

På detta bråk överlappar den horisontella stråklinjen bråkstrecket. Den vertikala stråklinjen korsar både täljare och nämnare medan den omgivande ramen förblir synlig. Dessa linjer dekorerar hela uttrycket. Vanlig textgenomstrykning gäller för tecken i en textrun. Efter att ha öppnat om presentationen i PowerPoint kan du fortfarande redigera täljare och nämnare var för sig.

Styr synlighet och layout med phantom‑element

Kapsla in ett uttryck i MathPhantom för att kontrollera dess synlighet och det utrymme det bidrar med i en ekvation oberoende av varandra. Dess egenskaper styr följande:

Egenskap Effekt
show Sätt till False för att dölja uttrycket. Dess dimensioner bidrar fortfarande till layouten om inte motsvarande egenskaper nedan är True.
zero_width Behandla uttryckets horisontella bredd som noll, så att närliggande element kan komma närmare varandra.
zero_asc Behandla dess uppstigning, höjden ovanför baslinjen, som noll. Detta kan minska utrymmet ovanför närliggande element.
zero_desc Behandla dess nedstigning, djupet under baslinjen, som noll. Detta kan föra en bråklinje eller annat innehåll under uttrycket närmare sina grannar.

Baslinjen är referenslinjen som vanliga matematiska tecken vilar på. Att dölja innehåll tar inte bort dess dimensioner, och att behandla en dimension som noll tar inte bort uttrycket. Det underliggande uttrycket är fortfarande tillgängligt via base. Sätt show tillbaka till True för att visa det igen; dimensionseinställningarna förblir oförändrade.

Exemplet nedan skapar fem varianter sida vid sida: ett synligt bråk, ett dolt bråk som reserverar utrymme och tre dolda bråk där en dimension behandlas som noll. Varje variant använder samma omgivande uttryck och Cambria Math 24 punkter. Alla ekvationsformer har samma topposition, markerad av den grå guiden. Att placera phantom‑elementet i täljaren av ett yttre bråk gör de vertikala layoutförändringarna lättare att se.

import aspose.slides as slides
import aspose.slides.mathtext as math


def create_text(value):
    text = math.MathematicalText(value)
    text.format.font_height = 24
    text.format.latin_font = slides.FontData("Cambria Math")
    return text


with slides.Presentation() as presentation:
    presentation.slide_size.set_size(1000, 180, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]
    labels = ["Visible", "Hidden: reserves space", "Hidden: ZeroWidth", "Hidden: ZeroAsc", "Hidden: ZeroDesc"]

    guide = slide.shapes.add_auto_shape(slides.ShapeType.LINE, 10, 60, 980, 0)
    guide.line_format.fill_format.fill_type = slides.FillType.SOLID
    guide.line_format.fill_format.solid_fill_color.color = slides.Color.light_gray

    for i, label_text in enumerate(labels):
        left = 10 + i * 200
        label = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, left, 10, 190, 30)
        label.fill_format.fill_type = slides.FillType.NO_FILL
        label.line_format.fill_format.fill_type = slides.FillType.NO_FILL
        label.text_frame.text = label_text
        label_format = label.text_frame.paragraphs[0].portions[0].portion_format
        label_format.font_height = 14
        label_format.fill_format.fill_type = slides.FillType.SOLID
        label_format.fill_format.solid_fill_color.color = slides.Color.black

        fraction_numerator = create_text("a+b")
        fraction_denominator = create_text("c+d")
        fraction = math.MathFraction(fraction_numerator, fraction_denominator)
        phantom = math.MathPhantom(fraction)
        phantom.show = i == 0
        phantom.zero_width = i == 2
        phantom.zero_asc = i == 3
        phantom.zero_desc = i == 4

        left_text = create_text("x+")
        right_text = create_text("+y")
        numerator = math.MathBlock(left_text).join(phantom).join(right_text)
        denominator = create_text("z")
        equation = math.MathFraction(numerator, denominator)

        shape = slide.shapes.add_math_shape(left, 60, 190, 100)
        shape.text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.TOP
        math_paragraph = shape.text_frame.paragraphs[0].portions[0].math_paragraph
        math_paragraph.add(math.MathBlock(equation))

    presentation.save("math-phantom.pptx", slides.export.SaveFormat.PPTX)

Fem ekvationer i PowerPoint som jämför ett synligt bråk, ett dolt bråk som reserverar utrymme, och dolda bråk med ZeroWidth, ZeroAsc eller ZeroDesc aktiverat

Gruppera termer

Använd group för att placera ett grupperingstecken ovanför eller nedanför ett uttryck. Lägg till en gräns för att märka de grupperade termerna.

Uttrycket x + y grupperat med etiketten någon text nedanför

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    grouped = (
        math.MathematicalText("x + y")
        .group(chr(0x23DF), math.MathTopBotPositions.BOTTOM, math.MathTopBotPositions.TOP)
        .set_lower_limit("any text")
    )

    math_paragraph.add(math.MathBlock(grouped))

    presentation.save("grouped-terms.pptx", slides.export.SaveFormat.PPTX)

Formatera matematikelement

Använd formateringshjälpare endast där de förtydligar formeln. Till exempel placerar overbar ett streck ovanför ett matematik­element.

Ett matematiskt uttryck ABC med ett överstreck

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    overbar = math.MathematicalText("ABC").overbar()

    math_paragraph.add(math.MathBlock(overbar))

    presentation.save("overbar.pptx", slides.export.SaveFormat.PPTX)

Formatera text i en befintlig ekvation

För att formatera text i en befintlig ekvation, gå igenom varje matematikblocks elementträd. MathElementBase.get_children returnerar endast de omedelbara barnen, så anropa det rekursivt för att nå text i bråk, skript, radikaler och andra nästlade strukturer. Kontrollera det aktuella elementet samt dess barn för att inkludera start‑elementet när det är MathematicalText.

Detta exempel antar att input.pptx innehåller en ekvation såsom z = xᵢ / ∛y, med ett bråk som har ett nedsänkt index i täljaren och en radikal i nämnaren. Att bara bearbeta blockets översta element skulle missa texten i bråket. Exemplet hittar matematiska portioner i bildtextramar, åtkommer deras block via MathPortion.math_paragraph, och sätter font_height till 28 punkter via varje textelements format‑egenskap.

import aspose.slides as slides
import aspose.slides.mathtext as math


def format_math_text(element):
    if isinstance(element, math.MathematicalText):
        element.format.font_height = 28

    for child in element.get_children():
        format_math_text(child)


with slides.Presentation("input.pptx") as presentation:
    for slide in presentation.slides:
        for shape in slide.shapes:
            if not isinstance(shape, slides.AutoShape) or shape.text_frame is None:
                continue

            for paragraph in shape.text_frame.paragraphs:
                for portion in paragraph.portions:
                    if isinstance(portion, math.MathPortion):
                        for block in portion.math_paragraph:
                            format_math_text(block)

    presentation.save("formatted-equations.pptx", slides.export.SaveFormat.PPTX)

Den sparade presentationen innehåller den uppdaterade textformateringen på varje nivå av varje bearbetad ekvation, samtidigt som dess textinnehåll och matematiska struktur bevaras.

Snabbreferens

Uppgift Huvudsakligt API
Skapa matematiktext MathematicalText
Kombinera element MathElementBase.join
Skapa bråk MathElementBase.divide
Lägg till upphöjt eller nedsänkt index set_superscript, set_subscript
Lägg till funktioner function, as_argument_of_function
Lägg till radikaler radical
Lägg till gränsvärden set_lower_limit, set_upper_limit
Lägg till skript på vänster sida set_sub_superscript_on_the_left
Lägg till summor och integraler nary, integral
Lägg till matriser MathMatrix
Lägg till ekvationsarrayer to_math_array
Lägg till avgränsare enclose
Lägg till staplar och ramar overbar, to_border_box
Gruppera termer group

FAQ

Kan jag redigera en befintlig PowerPoint‑ekvation?

Ja. Öppna presentationen, hitta formen som innehåller en MathPortion, hämta dess math_paragraph, och uppdatera matematikblocket i det stycket.

Sparas ekvationer som redigerbar PowerPoint‑matematik?

Ja. När du sparar till PPTX skriver Aspose.Slides ekvationen som redigerbart Office‑matematikinnehåll.

Kan jag exportera ekvationer till LaTeX?

Ja. Hämta ekvationens MathParagraph från dess MathPortion, och anropa MathParagraph.to_latex för att exportera den direkt. För ett komplett exempel, se Exportera matematiska ekvationer från presentationer i Python via .NET.