Hur man formaterar celler med Aspose.Cells FOSS i Python

Aspose.Cells FOSS for Python låter dig applicera teckensnittsstilar och bakgrundsfyllningar på enskilda celler med hjälp av the cell.style.font och cell.style.fill API:er. Färger uttrycks som 8-digit AARRGGBB hex strings; till exempel "FFFF0000" för ogenomskinlig röd, utan # prefix. All styling görs i ren Python utan beroende av Microsoft Excel eller något externt renderingsbibliotek.

Varför formatera celler med Aspose.Cells FOSS?

Ingen Excel krävs: Formatering körs helt i Python på vilket operativsystem som helst.
Konsekvent färgmodell: En enda 8-siffrig AARRGGBB-sträng täcker teckensnittsfärg och fyllningsfärg med samma format.
Läsbara egenskapsnamn: bold, italic, underline, strikethrough: ingen is_ prefix att komma ihåg.
Återanvändbara Font-objekt: Skapa en Font instans en gång och applicera den på många celler för konsekvent varumärkesprofil.

Steg-för-steg-guide

Steg 1: Installera Aspose.Cells FOSS för Python

pip install aspose-cells-foss

Inga ytterligare systempaket krävs. Importera de klasser du behöver från aspose.cells_foss:

from aspose.cells_foss import Workbook, Cell, Font, SaveFormat

Steg 2: Ange teckensnittsnamn och storlek

Kom åt en cell via ws.cells["address"] och skriv till cell.style.font.name och cell.style.font.size.

from aspose.cells_foss import Workbook

workbook = Workbook()
ws = workbook.worksheets[0]

ws.cells["A1"].value = "Styled Header"

cell = ws.cells["A1"]
cell.style.font.name = "Arial"
cell.style.font.size = 14

workbook.save("styled.xlsx")

Standardteckensnittet är Calibri i 11pt. Alla teckensnittsnamn som finns på systemet där filen öppnas kan användas; att ange ett teckensnitt som inte är installerat ger ingen fel, men kan visas med ett reservteckensnitt när filen öppnas.

Steg 3: Ange teckensnittsfärg med en AARRGGBB-hexsträng

Teckensnittsfärger sätts med en 8-digit hexadecimal string i AARRGGBB ordning (Alfa, Röd, Grön, Blå). Gör inte inkludera en # prefix.

from aspose.cells_foss import Workbook

workbook = Workbook()
ws = workbook.worksheets[0]

ws.cells["A1"].value = "Red text"
ws.cells["A1"].style.font.color = "FFFF0000"   # opaque red

ws.cells["A2"].value = "Blue text"
ws.cells["A2"].style.font.color = "FF0000FF"   # opaque blue

ws.cells["A3"].value = "Green text"
ws.cells["A3"].style.font.color = "FF00FF00"   # opaque green

workbook.save("colored_text.xlsx")

Vanlig AARRGGBB-färgreferens:

Färg	AARRGGBB-sträng	Anteckningar
Svart	`FF000000`	Standardteckensnittsfärg
Vit	`FFFFFFFF`	Använd på mörka bakgrunder
Röd	`FFFF0000`	Varning eller markera text
Blå	`FF0000FF`	Länkar eller betoning
Grön	`FF00FF00`	Positiva värden eller framgång
Orange	`FFFF8000`	Varningstext
Grå	`FF808080`	Dämpad eller inaktiverad text
Marinblå	`FF1E64C8`	Företags- / varumärkesblå

De två första hex-siffrorna är alfakanalen. Använd FF för helt ogenomskinlig. Värden under FF ger halvgenomskinliga resultat i renderare som stödjer alfablending.

Steg 4: Tillämpa fetstil, kursiv, understrykning och genomstrykning

Ställ in varje attribut direkt som en boolesk. Egenskapsnamnen är bold, italic, underline, och strikethrough; gör inte använd is_bold eller is_italic (de namnen finns inte i FOSS API:et och kommer att orsaka AttributeError).

from aspose.cells_foss import Workbook

workbook = Workbook()
ws = workbook.worksheets[0]

ws.cells["A1"].value = "Bold"
ws.cells["A1"].style.font.bold = True

ws.cells["A2"].value = "Italic"
ws.cells["A2"].style.font.italic = True

ws.cells["A3"].value = "Underline"
ws.cells["A3"].style.font.underline = True

ws.cells["A4"].value = "Strikethrough"
ws.cells["A4"].style.font.strikethrough = True

ws.cells["A5"].value = "Bold + Italic"
ws.cells["A5"].style.font.bold = True
ws.cells["A5"].style.font.italic = True

workbook.save("font_styles.xlsx")

Alla fyra flaggor har standardvärde False. De kan kombineras fritt i samma cell.

Steg 5: Ange en solid bakgrundsfyllnadsfärg

Använd cell.style.fill.set_solid_fill("AARRGGBB") för att applicera en bakgrundsfyllning. Färgsformatet är samma 8-siffriga AARRGGBB hex-sträng som teckensnittsfärgen.

För att ta bort en fyllning helt, anropa cell.style.fill.set_no_fill().

from aspose.cells_foss import Workbook

workbook = Workbook()
ws = workbook.worksheets[0]

ws.cells["A1"].value = "Navy background"
ws.cells["A1"].style.fill.set_solid_fill("FF1E64C8")   # opaque navy blue

ws.cells["A2"].value = "Light yellow background"
ws.cells["A2"].style.fill.set_solid_fill("FFFFFFCC")   # pale yellow

ws.cells["A3"].value = "No fill"
ws.cells["A3"].style.fill.set_no_fill()                 # remove any fill

workbook.save("cell_fills.xlsx")

set_solid_fill() och set_no_fill() är ömsesidigt uteslutande; att anropa den ena åsidosätter den andra på samma cell.

Steg 6: Kombinera flera stilar på en cell

Du kan kedja ett godtyckligt antal stil‑egenskaper på samma cellreferens. Det finns ingen gräns för hur många stilattribut som kan sättas innan du sparar.

from aspose.cells_foss import Workbook

workbook = Workbook()
ws = workbook.worksheets[0]

ws.cells["B2"].value = "Branded Header"

cell = ws.cells["B2"]

##Font
cell.style.font.name  = "Arial"
cell.style.font.size  = 16
cell.style.font.bold  = True
cell.style.font.color = "FFFFFFFF"      # white text

##Background
cell.style.fill.set_solid_fill("FF1E64C8")   # navy fill

workbook.save("branded_header.xlsx")
print("Branded header cell saved.")

Detta ger en vit, fet, 16 pt Arial‑etikett på en marinblå bakgrund, ett vanligt mönster för kolumnrubriker.

Steg 7: Använd Font‑konstruktorn för återanvändbara stilar

Klassen Font klass kan instansieras med alla dess egenskaper i ett anrop, och sedan tilldelas till flera celler. Detta är användbart när du vill ha en konsekvent husstil tillämpad över många celler utan att upprepa samma egenskapsinställningar.

from aspose.cells_foss import Workbook, Font

workbook = Workbook()
ws = workbook.worksheets[0]

##Define a reusable heading font
heading_font = Font(
    name="Arial",
    size=14,
    color="FF1E64C8",   # navy
    bold=True,
    italic=False,
    underline=False,
    strikethrough=False
)

##Define a reusable body font
body_font = Font(
    name="Calibri",
    size=11,
    color="FF000000",   # black (default)
    bold=False,
    italic=False,
    underline=False,
    strikethrough=False
)

##Apply heading font to header row
headers = ["Product", "SKU", "Price", "Stock"]
for col, header in enumerate(headers):
    addr = f"{chr(65 + col)}1"
    ws.cells[addr].value = header
    ws.cells[addr].style.font = heading_font
    ws.cells[addr].style.fill.set_solid_fill("FFE8EFF9")  # light blue tint

##Apply body font to data rows
data = [
    ("Widget A", "WGT-001", 9.99,  150),
    ("Widget B", "WGT-002", 14.99, 87),
    ("Widget C", "WGT-003", 4.49,  320),
]

for row_idx, (name, sku, price, stock) in enumerate(data, start=2):
    ws.cells[f"A{row_idx}"].value = name
    ws.cells[f"B{row_idx}"].value = sku
    ws.cells[f"C{row_idx}"].value = price
    ws.cells[f"D{row_idx}"].value = stock
    for col in "ABCD":
        ws.cells[f"{col}{row_idx}"].style.font = body_font

workbook.save("product_table.xlsx")
print("Product table with reusable fonts saved.")

Standardvärden för Font‑konstruktorn (alla parametrar är valfria):

Parameter	Standard
`name`	`"Calibri"`
`size`	`11`
`color`	`"FF000000"`
`bold`	`False`
`italic`	`False`
`underline`	`False`
`strikethrough`	`False`

Fullständigt fungerande exempel

Följande fristående skript skapar en arbetsbok med en stylad rubrikrad, färgade datarader och en sammanfattningscell som demonstrerar varje styling‑API som behandlats ovan:

from aspose.cells_foss import Workbook, Cell, Font, SaveFormat

workbook = Workbook()
ws = workbook.worksheets[0]
ws.name = "Sales Report"

##--- Header row (bold, white text on navy background) ---
headers = ["Region", "Q1", "Q2", "Q3", "Q4", "Total"]
for col, text in enumerate(headers):
    addr = f"{chr(65 + col)}1"
    ws.cells[addr].value = text
    ws.cells[addr].style.font.name  = "Arial"
    ws.cells[addr].style.font.size  = 12
    ws.cells[addr].style.font.bold  = True
    ws.cells[addr].style.font.color = "FFFFFFFF"            # white
    ws.cells[addr].style.fill.set_solid_fill("FF1E64C8")    # navy

##--- Data rows ---
data = [
    ("North", 42000, 47500, 53000, 61000),
    ("South", 31000, 28500, 35000, 39000),
    ("East",  55000, 62000, 58000, 71000),
    ("West",  27000, 30000, 33000, 41000),
]

for row_idx, (region, q1, q2, q3, q4) in enumerate(data, start=2):
    ws.cells[f"A{row_idx}"].value = region
    ws.cells[f"B{row_idx}"].value = q1
    ws.cells[f"C{row_idx}"].value = q2
    ws.cells[f"D{row_idx}"].value = q3
    ws.cells[f"E{row_idx}"].value = q4
    # Total formula
    ws.cells[f"F{row_idx}"] = Cell(None, f"=SUM(B{row_idx}:E{row_idx})")
    # Alternate row shading
    if row_idx % 2 == 0:
        for col in "ABCDEF":
            ws.cells[f"{col}{row_idx}"].style.fill.set_solid_fill("FFE8EFF9")

##--- Italic note in a footer cell ---
ws.cells["A7"].value = "All values in USD"
ws.cells["A7"].style.font.italic = True
ws.cells["A7"].style.font.color  = "FF808080"   # gray
ws.cells["A7"].style.font.size   = 9

##--- Strikethrough on a deprecated label ---
ws.cells["A8"].value = "Old metric (deprecated)"
ws.cells["A8"].style.font.strikethrough = True
ws.cells["A8"].style.font.color         = "FF808080"

workbook.save("sales_report_styled.xlsx", SaveFormat.XLSX)
print("Styled sales report saved.")

Vanliga problem

Fel färgformat: använder `#RRGGBB` istället för `AARRGGBB`

Ett inledande # (t.ex. "#FF0000") eller en 6-siffrig RGB-sträng kommer inte att ge den förväntade färgen. Egendomen förväntar sig exakt 8 hex digits with no prefix: "FFFF0000". De första två siffrorna är alfakanalen; använd FF för helt ogenomskinlig.

`AttributeError: 'Font' object has no attribute 'is_bold'`

FOSS API använder bold, italic, underline, och strikethrough som egenskapsnamn. Den is_bold / is_italic namngivningskonvention tillhör ett annat bibliotek och finns inte här. Ersätt alla is_bold referensen med bold.

Stiländringar syns inte efter sparning

Se till att du sätter stilegenskaper på cellobjektet innan anropar workbook.save(). Att sätta en egenskap på en cell efter spara-anropet har ingen effekt på den redan skrivna filen. Om du återanvänder en cell variabel, bekräfta att den fortfarande refererar till rätt celladress.

Fyllning och teckensnitt i samma cell krockar visuellt

Det finns ingen API-konflikt; du kan alltid sätta båda cell.style.font.color och cell.style.fill.set_solid_fill() oberoende. Se till att textfärgen har tillräcklig kontrast mot bakgrundsfärgen. Vit text (FFFFFFFF) på en mörk fyllning som marinblå (FF1E64C8) är en pålitlig kombination.

Vanliga frågor

Hur tar jag bort en bakgrundsfyllning och återställer en cell till ingen fyllning?

Anropa cell.style.fill.set_no_fill(). Detta tar bort eventuell tidigare inställd solid fyllning från cellen.

Hur återställer jag en cell till standardteckensnittet (Calibri 11pt svart)?

Tilldela standardvärdena explicit igen:

cell.style.font.name          = "Calibri"
cell.style.font.size          = 11
cell.style.font.color         = "FF000000"
cell.style.font.bold          = False
cell.style.font.italic        = False
cell.style.font.underline     = False
cell.style.font.strikethrough = False

Alternativt, skapa en Font() instans utan argument (alla standardvärden) och tilldela den: cell.style.font = Font().

Kan jag applicera samma teckensnittsstil på ett cellintervall i en loop?

Ja. Iterera över celladresserna och sätt samma egenskaper på var och en. Om du använder den Font konstruktorn för att skapa en delad Font objekt, tilldela det till varje cell med ws.cells[addr].style.font = my_font.

Påverkar styling cellvärden eller formler?

Nej. Formatering är enbart visuell metadata. cell.style.font och cell.style.fill rör inte .value eller .formula.

Vilka sparformat bevarar stilar?

Stilar bevaras helt när du sparar till SaveFormat.XLSX. Det SaveFormat.CSV, SaveFormat.TSV, SaveFormat.JSON, och SaveFormat.MARKDOWN format är rentext- eller strukturerad-textformat och innehåller ingen formateringsinformation.

Relaterade resurser:

Aspose.Cells FOSS for Python: Developer Guide
Kalkylbladsoperationer
Hur man laddar kalkylblad i Python
Hur man skapar diagram i Python
API-referens: Font, Fill, Style
Produktöversikt: Sammanfattning av funktioner och möjligheter
Blogg: Introducerar Aspose.Cells FOSS: Biblioteksöversikt och snabbstart