Arbeiten Sie mit Spalten und Zeilen
Um mehr Kontrolle über die Funktionsweise von Tabellen zu erhalten, erfahren Sie, wie Sie Spalten und Zeilen bearbeiten.
Suchen des Tabellenelementindex
Spalten, Zeilen und Zellen werden verwaltet, indem auf den ausgewählten Dokumentknoten über seinen Index zugegriffen wird. Um den Index eines beliebigen Knotens zu finden, müssen alle untergeordneten Knoten des Elementtyps vom übergeordneten Knoten erfasst und dann mithilfe der IndexOf-Methode der Index des gewünschten Knotens in der Sammlung ermittelt werden.
Den Index einer Tabelle in einem Dokument finden
Manchmal müssen Sie möglicherweise Änderungen an einer bestimmten Tabelle in einem Dokument vornehmen. Dazu können Sie über ihren Index auf eine Tabelle verweisen.
Das folgende Codebeispiel zeigt, wie der Index einer Tabelle in einem Dokument abgerufen wird:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table() | |
all_tables = doc.get_child_nodes(aw.NodeType.TABLE, True) | |
table_index = all_tables.index_of(table) |
Den Index einer Zeile in einer Tabelle finden
Ebenso müssen Sie möglicherweise Änderungen an einer bestimmten Zeile in einer ausgewählten Tabelle vornehmen. Dazu können Sie eine Zeile auch über ihren Index referenzieren.
Das folgende Codebeispiel zeigt, wie der Index einer Zeile in einer Tabelle abgerufen wird:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
row_index = table.index_of(table.last_row) |
Ermitteln des Index einer Zelle in einer Zeile
Schließlich müssen Sie möglicherweise Änderungen an einer bestimmten Zelle vornehmen, und Sie können dies auch über den Zellindex tun.
Das folgende Codebeispiel zeigt, wie der Index einer Zelle in einer Zeile abgerufen wird:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
cell_index = row.index_of(row.cells[4]) |
Arbeiten Sie mit Spalten
Im Aspose.Words Document Object Model (DOM) besteht der Table-Knoten aus Row-Knoten und dann aus Cell-Knoten. Daher gibt es im Document
-Objektmodell von Aspose.Words, wie auch in Word-Dokumenten, kein Konzept einer Spalte.
Die Tabellenzeilen in Microsoft Word und Aspose.Words sind konstruktionsbedingt völlig unabhängig und die grundlegenden Eigenschaften und Operationen sind nur in den Zeilen und Zellen der Tabelle enthalten. Dies gibt Tabellen die Möglichkeit, einige interessante Attribute zu haben:
- Jede Tabellenzeile kann eine völlig unterschiedliche Anzahl von Zellen haben
- Vertikal können die Zellen jeder Zeile unterschiedliche Breiten haben
- Es ist möglich, Tabellen mit unterschiedlichen Zeilenformaten und Zellenanzahlen zu verbinden
Alle an Spalten ausgeführten Operationen sind eigentlich “Abkürzungen”, die die Operation ausführen, indem sie Zeilenzellen gemeinsam so ändern, dass es aussieht, als würden sie auf Spalten angewendet. Das heißt, Sie können Operationen an Spalten ausführen, indem Sie einfach über denselben Zellenindex der Tabellenzeile iterieren.
Das folgende Codebeispiel vereinfacht solche Vorgänge, indem es eine Fassadenklasse beweist, die die Zellen sammelt, aus denen eine “Spalte” einer Tabelle besteht:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
class Column: | |
"""Represents a facade object for a column of a table in a Microsoft Word document.""" | |
def __init__(self, table: aw.tables.Table, column_index: int): | |
if table is None: | |
raise ValueError("table") | |
self.table = table | |
self.column_index = column_index | |
def index_of(self, cell: aw.tables.Cell): | |
"""Returns the index of the given cell in the column.""" | |
return self.get_column_cells().index(cell) | |
def insert_column_before(self): | |
"""Inserts a brand new column before this column into the table.""" | |
column_cells = self.get_column_cells() | |
if len(column_cells) == 0: | |
raise ValueError("Column must not be empty") | |
# Create a clone of this column. | |
for cell in column_cells: | |
cell.parent_row.insert_before(cell.clone(False), cell) | |
# This is the new column. | |
column = self.__class__(column_cells[0].parent_row.parent_table, self.column_index) | |
# We want to make sure that the cells are all valid to work with (have at least one paragraph). | |
for cell in column.get_column_cells(): | |
cell.ensure_minimum() | |
# Increase the index which this column represents since there is now one extra column in front. | |
self.column_index += 1 | |
return column | |
def remove(self): | |
"""Removes the column from the table.""" | |
for cell in self.get_column_cells(): | |
cell.remove() | |
def to_txt(self): | |
"""Returns the text of the column.""" | |
return "".join(cell.to_string(aw.SaveFormat.TEXT) for cell in self.get_column_cells()) | |
def get_column_cells(self): | |
"""Provides an up-to-date collection of cells which make up the column represented by this facade.""" | |
column_cells = [] | |
for row in self.table.rows: | |
cell = row.as_row().cells[self.column_index] | |
if cell is not None: | |
column_cells.append(cell) | |
return column_cells | |
Das folgende Codebeispiel zeigt, wie man eine leere Spalte in eine Tabelle einfügt:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
doc = aw.Document(MY_DIR + "Tables.docx") | |
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table() | |
column = self.Column(table, 0) | |
# Print the plain text of the column to the screen. | |
print(column.to_txt()) | |
# Create a new column to the left of this column. | |
# This is the same as using the "Insert Column Before" command in Microsoft Word. | |
new_column = column.insert_column_before() | |
for cell in new_column.get_column_cells(): | |
cell.first_paragraph.append_child(aw.Run(doc, "Column Text " + str(new_column.index_of(cell)))) |
Das folgende Codebeispiel zeigt, wie eine Spalte aus einer Tabelle in einem Dokument entfernt wird:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
doc = aw.Document(MY_DIR + "Tables.docx") | |
table = doc.get_child(aw.NodeType.TABLE, 1, True).as_table() | |
column = self.Column(table, 2) | |
column.remove() |
Geben Sie Zeilen als Kopfzeilen an
Sie können die erste Zeile in der Tabelle als Kopfzeile nur auf der ersten Seite oder auf jeder Seite wiederholen, wenn die Tabelle in mehrere geteilt ist. In Aspose.Words können Sie die Kopfzeile mithilfe der HeadingFormat-Eigenschaft auf jeder Seite wiederholen.
Sie können auch mehrere Kopfzeilen markieren, wenn diese am Anfang der Tabelle hintereinander stehen. Dazu müssen Sie die HeadingFormat-Eigenschaften auf diese Zeilen anwenden.
Das folgende Codebeispiel zeigt, wie eine Tabelle erstellt wird, die Kopfzeilen enthält, die sich auf nachfolgenden Seiten wiederholen:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
doc = aw.Document() | |
builder = aw.DocumentBuilder(doc) | |
builder.start_table() | |
builder.row_format.heading_format = True | |
builder.paragraph_format.alignment = aw.ParagraphAlignment.CENTER | |
builder.cell_format.width = 100 | |
builder.insert_cell() | |
builder.writeln("Heading row 1") | |
builder.end_row() | |
builder.insert_cell() | |
builder.writeln("Heading row 2") | |
builder.end_row() | |
builder.cell_format.width = 50 | |
builder.paragraph_format.clear_formatting() | |
for _ in range(50): | |
builder.insert_cell() | |
builder.row_format.heading_format = False | |
builder.write("Column 1 Text") | |
builder.insert_cell() | |
builder.write("Column 2 Text") | |
builder.end_row() | |
doc.save(ARTIFACTS_DIR + "WorkingWithTables.repeat_rows_on_subsequent_pages.docx") |
Verhindern Sie, dass Tabellen und Zeilen seitenübergreifend umbrechen
Es gibt Zeiten, in denen der Inhalt einer Tabelle nicht auf mehrere Seiten aufgeteilt werden sollte. Wenn beispielsweise ein Titel über einer Tabelle steht, sollten Titel und Tabelle immer zusammen auf derselben Seite bleiben, um das richtige Erscheinungsbild zu gewährleisten.
Es gibt zwei verschiedene Techniken, die zum Erreichen dieser Funktionalität nützlich sind:
Allow row break across pages
, das auf Tabellenzeilen angewendet wirdKeep with next
, das auf Absätze in Tabellenzellen angewendet wird
Standardmäßig sind die oben genannten Eigenschaften deaktiviert.
Verhindern Sie, dass eine Zeile seitenübergreifend umbricht
Dabei wird verhindert, dass Inhalte innerhalb der Zellen einer Zeile auf eine Seite aufgeteilt werden. In Microsoft Word ist dies unter “Tabelleneigenschaften” als Option “Zeilenumbruch über Seiten hinweg zulassen” zu finden. In Aspose.Words ist dies unter dem RowFormat-Objekt eines Row als Eigenschaft RowFormat.AllowBreakAcrossPages zu finden.
Das folgende Codebeispiel zeigt, wie Sie den seitenübergreifenden Zeilenumbruch für jede Zeile in einer Tabelle deaktivieren:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
doc = aw.Document(MY_DIR + "Table spanning two pages.docx") | |
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table() | |
# Disable breaking across pages for all rows in the table. | |
for row in table.rows: | |
row.as_row().row_format.allow_break_across_pages = False | |
doc.save(ARTIFACTS_DIR + "WorkingWithTables.row_format_disable_break_across_pages.docx") |
Verhindern Sie, dass eine Tabelle über mehrere Seiten bricht
Um zu verhindern, dass die Tabelle auf mehrere Seiten aufgeteilt wird, müssen wir angeben, dass der in der Tabelle enthaltene Inhalt zusammen bleiben soll.
Zu diesem Zweck verwendet Aspose.Words eine Methode, die es Benutzern ermöglicht, eine Tabelle auszuwählen und den KeepWithNext-Parameter für jeden Absatz innerhalb der Tabellenzellen in true zu aktivieren. Die Ausnahme bildet der letzte Absatz in der Tabelle, der auf false eingestellt werden sollte.
Das folgende Codebeispiel zeigt, wie man eine Tabelle so einrichtet, dass sie zusammen auf derselben Seite bleibt:
# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git. | |
doc = aw.Document(MY_DIR + "Table spanning two pages.docx") | |
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table() | |
# We need to enable KeepWithNext for every paragraph in the table to keep it from breaking across a page, | |
# except for the last paragraphs in the last row of the table. | |
for cell in table.get_child_nodes(aw.NodeType.CELL, True): | |
cell = cell.as_cell() | |
cell.ensure_minimum() | |
for para in cell.paragraphs: | |
para = para.as_paragraph() | |
if not (cell.parent_row.is_last_row and para.is_end_of_cell): | |
para.paragraph_format.keep_with_next = True | |
doc.save(ARTIFACTS_DIR + "WorkingWithTables.keep_table_together.docx") |