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:

Resultatet är redigerbar matematiktext på bilden:

Aspose.Slides bygger den matematiska texten genom tre huvudobjekt:
- En matematikform, skapad med add_math_shape, är formen som innehåller ekvationen.
- MathPortion lagrar matematikinnehåll i formens textramar.
- MathParagraph innehåller ett eller flera MathBlock‑objekt.
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:

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)
Obs
add_math_shape skapar en form som redan innehåller ett matematikstycke. Hämta den första MathPortion, få dess math_paragraph, och lägg till matematikblock eller matematik‑element i den.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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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)

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.

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.

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)

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)

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.

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 matematikelement.

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.