精华内容
下载资源
问答
  • python给word文档添加标题

    千次阅读 2019-09-25 23:27:32
    import docxdoc=docx....整数 1 到 45是不同的标题层次,是主要的标题, 45是最低层的子标题doc.add_heading('标题0',0)doc.add_heading('标题1',1)doc.add_heading('标题2',2)doc.add_heading('标题3',3)doc...

    import docx
    doc=docx.Document()
    #整数 0 表示标题是 Title 样式,这用于文档的顶部。整数 1 到 45是不同的标题层次,是主要的标题, 45是最低层的子标题
    doc.add_heading('标题0',0)
    doc.add_heading('标题1',1)
    doc.add_heading('标题2',2)
    doc.add_heading('标题3',3)
    doc.add_heading('标题4',4)
    doc.add_heading('标题5',5)
    doc.save('example3.docx')

    转载于:https://www.cnblogs.com/shunguo/p/11399305.html

    展开全文
  • word文档编辑技巧

    2014-05-20 13:39:32
    Word文档精确“减肥”五小招 68 如何用Word实现在网上开会 72 七种办法减少Word容量 74 隐藏在word汉字里面的玄机 75 Word技巧:一次特殊的查找和替换 78 在Word中为三位数字设置带圈字符 80 巧用Word输入生僻字 81...
  • python Word 文档

    千次阅读 2018-09-21 13:44:35
    利用 python-docx 模块, Python 可以创建和修改 Word 文档,它带有.docx 文件扩展名。运行 pip install python-docx,可以安装该模块。 注意:OSI 参考模型最初是在 1983 年由国际标准化组织出版,标准号为 ISO ...

    利用 python-docx 模块, Python 可以创建和修改 Word 文档,它带有.docx 文件扩展名。运行 pip install python-docx,可以安装该模块。

    注意:OSI 参考模型最初是在 1983 年由国际标准化组织出版,标准号为 ISO 7498。在第一次用 pip 安装 python-docx 时,注意要安装 python-docx,而不是 docx。安装名称 docx 是指另一个模块,本书没有介绍。但是,在导入 python-docx 模块时,需要执行 import docx,而不是 import python-docx。

    如果你没有 Word 软件, LibreOffice Writer 和 OpenOffice Writer 都是免费的替代软件,它们可以在 Windows、 OS X 和 Linux 上打开.docx 文件。可以分别从https://www.libreoffice.org 和 http://openoffice.org 下载它们。 python-docx 的完整文档在 https://python-docx.readthedocs.org/。尽管有针对 OS X 平台的 Word 版本, 但本章将使用 Windows 平台的 Word。和纯文本相比, .docx 文件有很多结构。这些结构在 python-docx 中用 3 种不同的类型来表示。在最高一层, Document 对象表示整个文档。 Document 对象包含一个 Paragraph 对象的列表,表示文档中的段落(用户在 Word 文档中输入时,如果按下回车,新的段落就开始了)。每个 Paragraph 对象都包含一个 Run 对象的列表。图 13-4 中的单句段落有 4 个 Run 对象。

    Word 文档中的文本不仅仅是字符串。它包含与之相关的字体、大小、颜色和其他样式信息。在 Word 中,样式是这些属性的集合。一个 Run 对象是相同样式文本的延续。当文本样式发生改变时,就需要一个新的 Run 对象。
     

    读取 Word 文档
    让我们尝试使用 python-docx 模块。从 http://nostarch.com/automatestuff/下载demo.docx,并将它保存在当前工作目录中。然后在交互式环境中输入以下代码:

    >>> import docx
    >>> doc = docx.Document('demo.docx')
    >>> len(doc.paragraphs)
    7
    >>> doc.paragraphs[0].text
    'Document Title'
    >>> doc.paragraphs[1].text
    'A plain paragraph with some bold and some italic'
    >>> len(doc.paragraphs[1].runs)
    4
    >>> doc.paragraphs[1].runs[0].text
    'A plain paragraph with some '
    >>> doc.paragraphs[1].runs[1].text
    'bold'
    >>> doc.paragraphs[1].runs[2].text
    ' and some '
    >>> doc.paragraphs[1].runs[3].text
    'italic'

    在1行,我们在 Python 中打开了一个.docx 文件,调用 docx.Document(),传入文件名 demo.docx。这将返回一个 Document 对象,它有 paragraphs 属性,是 Paragraph对象的列表。如果我们对 doc.paragraphs 调用 len(),将返回 7。这告诉我们,该文档有 7 个 Paragraph 对象。每个 Paragraph 对象都有一个 text 属性,包含该段中文本的字符串(没有样式信息)。这里,第一个 text 属性包含'DocumentTitle',第二个包含'A plain paragraph with some bold and some italic'。每个 Paragraph 对象也有一个 runs 属性,它是 Run 对象的列表。 Run 对象也有一个 text 属性,包含那个延续中的文本。我们看看第二个 Paragraph 对象中的 text属性, 'A plain paragraph with some bold and some italic'。对这个 Paragraph 对象调用 len(),结果告诉我们有 4 个 Run 对象。第一个对象包含'A plain paragraph with some '。然后,文本变为粗体样式,所以’bold’开始了一个新的 Run 对象。在这之后,文本又回到了非粗体的样式,这导致了第三个 Run 对象, ' and some '。最后,第四个对象包含'italic',是斜体样式。有了 python-docx, Python 程序就能从.docx 文件中读取文本,像其他的字符串值一样使用它。
     

    从.docx 文件中取得完整的文本
    如果你只关心 Word 文档中的文本,不关心样式信息,就可以利用 getText()函数。它接受一个.docx 文件名,返回其中文本的字符串。打开一个新的文件编辑器窗口,输入以下代码,并保存为 readDocx.py:

    !# python3
    
    import docx
    
    def getText(filename):
    	doc = docx.Document(filename)
    	fullText = []
    	for para in doc.paragraphs:
    		fullText.append(para.text)
    	return '\n'.join(fullText)

    getText()函数打开了 Word 文档,循环遍历 paragraphs 列表中的所有 Paragraph对象,然后将它们的文本添加到 fullText 列表中。循环结束后, fullText 中的字符串连接在一起,中间以换行符分隔。readDocx.py 程序可以像其他模块一样导入。现在如果你只需要 Word 文档中的文本,就可以输入以下代码:

    >>> import readDocx
    >>> print(readDocx.getText('demo.docx'))
    Document Title
    A plain paragraph with some bold and some italic
    Heading, level 1
    Intense quote
    first item in unordered list
    first item in ordered list

    也可以调整 getText(),在返回字符串之前进行修改。例如,要让每一段缩进,就将文件中的 append()调用替换为:

    fullText.append(' ' + para.text)

    要在段落之间增加空行,就将 join()调用代码改成

    return '\n\n'.join(fullText)

    可以看到,只需要几行代码,就可以写出函数,读取.docx 文件,根据需要返回它的内容字符串。
     

    设置 Paragraph 和 Run 对象的样式

    Windows 平台的 Word 中,你可以按下 Ctrl-Alt-Shift-S,显示样式窗口并查看样式,如图 13-5 所示。在 OS X 上,可以点击 ViewStyles 菜单项,查看样式窗口。Word 和其他文字处理软件利用样式,保持类似类型的文本在视觉展现上一致,并易于修改。 例如,也许你希望将内容段落设置为 11 点, Times New Roman,左对齐,右边不对齐的文本。可以用这些设置创建一样式,将它赋给所有的文本段落。然后,如果稍后想改变文档中所有内容段落的展现形式,只要改变这种样式,所有段落都会自动更新。

    对于 Word 文档,有 3 种类型的样式:段落样式可以应用于 Paragraph 对象,字符样式可以应用于 Run 对象,链接的样式可以应用于这两种对象。可以将 Paragraph 和Run 对象的 style 属性设置为一个字符串,从而设置样式。这个字符串应该是一种样式的名称。如果 style 被设置为 None,就没有样式与 Paragraph 或 Run 对象关联。默认 Word 样式的字符串如下

    在设置 style 属性时,不要在样式名称中使用空格。例如,样式名称可能是 SubtleEmphasis,你应该将属性设置为字符串'SubtleEmphasis',而不是'Subtle Emphasis'。包含空格将导致 Word 误读样式名称,并且应用失败。如果对 Run 对象应用链接的样式,需要在样式名称末尾加上'Char'。例如,对Paragraph 对象设置 Quote 链接的样式,应该使用 paragraphObj.style = 'Quote'。 但对于Run 对象,应该使用 runObj.style = 'QuoteChar'。在当前版本的 python-docx (0.7.4)中,只能使用默认的 Word 样式,以及打开的文件中已有的样式,不能创建新的样式,但这一点在将来的模块版本中可能会改变。
     

    创建带有非默认样式的 Word 文档
    如果想要创建的 Word文档使用默认样式以外的样式,就需要打开一个空白 Word文档,通过点击样式窗口底部的 New Style 按钮,自己创建样式(图 13-6 展示了Windows 平台上的情形)。

    这将打开“Creat New Style from Formatting”对话框,在这里可以输入新样式。然后,回到交互式环境,用 docx.Document()打开这个空白 Word 文档,利用它作为Word 文档的基础。这种样式的名称现在就可以被 python-docx 使用了

    Run 属性

    通过 text 属性, Run 可以进一步设置样式。每个属性都可以被设置为 3 个值之一: True(该属性总是启用,不论其他样式是否应用于该 Run)、 False(该属性总是禁用)或 None(默认使用该 Run 被设置的任何属性)。表 13-1 列出了可以在 Run 对象上设置的 text 属性。

    例如,为了改变 demo.docx 的样式,在交互式环境中输入以下代码:

    >>> doc = docx.Document('demo.docx')
    >>> doc.paragraphs[0].text
    'Document Title'
    >>> doc.paragraphs[0].style
    'Title'
    >>> doc.paragraphs[0].style = 'Normal'
    >>> doc.paragraphs[1].text
    'A plain paragraph with some bold and some italic'
    >>> (doc.paragraphs[1].runs[0].text, doc.paragraphs[1].runs[1].text, doc.
    paragraphs[1].runs[2].text, doc.paragraphs[1].runs[3].text)
    ('A plain paragraph with some ', 'bold', ' and some ', 'italic')
    >>> doc.paragraphs[1].runs[0].style = 'QuoteChar'
    >>> doc.paragraphs[1].runs[1].underline = True
    >>> doc.paragraphs[1].runs[3].underline = True
    >>> doc.save('restyled.docx')

    这里,我们使用了 text 和 style 属性,以便容易地看到文档的段落中有什么。我们可以看到,很容易将段落划分成 Run,并单独访问每个 Run。所以我们取得了第二段中的第一、第二和第四个 Run,设置每个 Run 的样式,将结果保存到一个新文档。文件顶部的单词 Document Title 将具有 Normal 样式,而不是 Title 样式。针对文本 A plain paragraph 的 Run 对象,将具有 QuoteChar 样式。针对单词 bold 和 italic的两个 Run 对象,它们的 underline 属性设置为 True。图 13-7 展示了文件中段落和Run 的样式看起来的样子。

    访问 https://python-docx.readthedocs.org/en/latest/user/styles.html,你可以看到,python-docx 使用样式的更完整文档。
     

    写入 Word 文档
    在交互式环境中输入以下代码:

    >>> import docx
    >>> doc = docx.Document()
    >>> doc.add_paragraph('Hello world!')
    <docx.text.Paragraph object at 0x0000000003B56F60>
    >>> doc.save('helloworld.docx')

    要创建自己的.docx 文件,就调用 docx.Document(),返回一个新的、空白的 WordDocument 对象。 Document 对象的 add_paragraph()方法将一段新文本添加到文档中,并返回添加的 Paragraph 对象的引用。在添加完文本之后,向 Document 对象的 save()方法传入一个文件名字符串,将 Document 对象保存到文件。这将在当前工作目录中创建一个文件,名为 helloworld.docx。如果打开它,就像图 13-8 的样子。

    可以用新的段落文本,再次调用 add_paragraph()方法,添加段落。或者,要在已有段落的末尾添加文本,可以调用 Paragraph 对象的 add_run()方法,向它传入一个字符串。在交互式环境中输入以下代码:=

    >>> import docx
    >>> doc = docx.Document()
    >>> doc.add_paragraph('Hello world!')
    <docx.text.Paragraph object at 0x000000000366AD30>
    >>> paraObj1 = doc.add_paragraph('This is a second paragraph.')
    >>> paraObj2 = doc.add_paragraph('This is a yet another paragraph.')
    >>> paraObj1.add_run(' This text is being added to the second paragraph.')
    <docx.text.Run object at 0x0000000003A2C860>
    >>> doc.save('multipleParagraphs.docx')

    得到的文本如图 13-9 所示。请注意,文本 This text is being added to the secondparagraph.被添加到 paraObj1 中的 Paragraph 对象中,它是添加到 doc 中的第二段。add_paragraph()和 add_run()分别返回 Paragraph 和 Run 对象,这样你就不必多花一步来提取它们。

    要记住,对于 python-docx 的 0.5.3 版本,新的 Paragraph 对象只能添加在文档的末尾,新的 Run 对象只能添加在 Paragraph 对象的末尾。可以再次调用 save()方法,保存所做的变更。add_paragraph()和 add_run()都接受可选的第二个参数,它是表示 Paragraph 或Run 对象样式的字符串。例如:

    >>> doc.add_paragraph('Hello world!', 'Title')

    这一行添加了一段,文本是 Hello world!,样式是 Title。
     

    添加标题
    调用 add_heading()将添加一个段落,并使用一种标题样式。在交互式环境中输入以下代码

    >>> doc = docx.Document()
    >>> doc.add_heading('Header 0', 0)
    <docx.text.Paragraph object at 0x00000000036CB3C8>
    >>> doc.add_heading('Header 1', 1)
    <docx.text.Paragraph object at 0x00000000036CB630>
    >>> doc.add_heading('Header 2', 2)
    <docx.text.Paragraph object at 0x00000000036CB828>
    >>> doc.add_heading('Header 3', 3)
    <docx.text.Paragraph object at 0x00000000036CB2E8>
    >>> doc.add_heading('Header 4', 4)
    <docx.text.Paragraph object at 0x00000000036CB3C8>
    >>> doc.save('headings.docx')

    add_heading()的参数, 是一个标题文本的字符串,以及一个从 0 到 4 的整数。 整数 0 表示标题是 Title 样式,这用于文档的顶部。整数 1 到 4 是不同的标题层次, 1是主要的标题, 4 是最低层的子标题。 add_heading()返回一个 Paragraph 对象,让你不必多花一步从 Document 对象中提取它。得到的 headings.docx 文件如图 13-10 所示。

    添加换行符和换页符
    要添加换行符(而不是开始一个新的段落),可以在 Run 对象上调用 add_break()方法,换行符将出现在它后面。如果希望添加换页符,可以将 docx.enum.text.WD_BREAK.PAGE作为唯一的参数,传递给 add_break(),就像下面代码中间所做的一样:

    >>> doc = docx.Document()
    >>> doc.add_paragraph('This is on the first page!')
    <docx.text.paragraph.Paragraph object at 0x0000023AC76E1CC0>
    >>> doc.paragraphs[0].runs[0].add_break(docx.enum.text.WD_BREAK.PAGE)
    >>> doc.add_paragraph('This is on the second page!')
    <docx.text.paragraph.Paragraph object at 0x0000023AC76E1F60>
    >>> doc.save('towPage.docx')

    这创建了一个两页的 Word 文档,第一页上是 This is on the first page!,第二页上是 This is on the second page!。虽然在文本 This is on the first page!之后,第一页还有大量的空间,但是我们在第一段的第一个 Run 之后插入分页符,强制下一段落出现在新的页面中。

    添加图像
    Document 对象有一个 add_picture()方法,让你在文档末尾添加图像。假定当前工作目录中有一个文件 zophie.png,你可以输入以下代码,在文档末尾添加 zophie.png,宽度为 1 英寸,高度为 4 厘米(Word 可以同时使用英制和公制单位):

    >>> doc.add_picture('zophie.png', width=docx.shared.Inches(1),
    height=docx.shared.Cm(4))
    <docx.shape.InlineShape object at 0x00000000036C7D30>

    第一个参数是一个字符串,表示图像的文件名。可选的 width 和 height 关键字参数,将设置该图像在文档中的宽度和高度。如果省略,宽度和高度将采用默认值,即该图像的正常尺寸。你可能愿意用熟悉的单位来指定图像的高度和宽度,诸如英寸或厘米。所以在指定 width 和 height 关键字参数时,可以使用 docx.shared.Inches()和 docx.shared.Cm()函数。
     

    展开全文
  • word文档中如何添加目录

    千次阅读 2018-08-03 14:28:23
    如果word文档的内容较多、结构复杂,那么在文档首页设置一个目录链接是非常有必要的。本文将介绍如何添加此目录。 1.设置标题。 在文档中选择将在目录中显示的内容,将之设置为“标题1”、“标题2”或“标题3”等。...

    如果word文档的内容较多、结构复杂,那么在文档首页设置一个目录链接是非常有必要的。本文将介绍如何添加此目录。

    1.设置标题。
    在文档中选择将在目录中显示的内容,将之设置为“标题1”、“标题2”或“标题3”等。其中“标题1”代表一级标题,应为顶级目录,“标题2”为二级标题,层次在一级标题之下,而“标题3”又在二级标题之下,以下级别以此类推。
    注:各类标题的样式可以随意修改,方法是选中已设置为标题的文本,修改其字体即可。
    2.插入目录。
    将光标定位在你想要显示目录的位置,一般显示在首页。
    依次选择菜单:插入->引用->索引和目录...->“目录”选项卡。选择“使用超链接而不使用页码”,这样可保证按住Ctrl+单击目录中的内容,将会跳到相应的页面,即开启了"链接"功能。
    “显示级别”默认为3,如果文档中设置了多于3级标题的话,请将此数值改大。
    点击“确定”即可插入目录。

    展开全文
  • docx4j操作word文档: 动态生成表格行数并填充数据 单元格内填充图片 合并多个word文档(包含页码,纸张方向等等) 1.动态生成表格行数并填充数据 首先创建模板文件.docx,如图: 代码如下: import ...

    docx4j操作word文档:

    1. 动态生成表格行数并填充数据
    2. 单元格内填充图片
    3. 合并多个word文档(包含页码,纸张方向等等)

    1.动态生成表格行数并填充数据

    首先创建模板文件.docx,如图:
    在这里插入图片描述
    代码如下:

    import com.bootdo.common.utils.Docx4jUtils;
    
    import org.docx4j.model.datastorage.migration.VariablePrepare;
    import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
    import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
    import org.docx4j.wml.Tbl;
    import org.docx4j.wml.Tr;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class Docx4jDemo2 {
    
        public static void main(String[] args) {
    
            Map<String, String> data = new HashMap<>();
            data.put("companyName", "阿里巴巴网络技术有限公司");
            data.put("number1", "100");
            data.put("number2", "100");
            data.put("address", "中国杭州");
            data.put("capital", "59690万美元");
            data.put("legalPerson", "马云");
            //模拟开发部数据
            List<String[]> dataList = new ArrayList<>();
            for (int i = 0; i <= 100; i++) {
                //按照模板中单元格顺序添加数据
                dataList.add(new String[]{"张三", "男", "员工", "24", "13666666666", "zhangsan@163.com"});
            }
            //模拟销售部数据
            List<String[]> dataList2 = new ArrayList<>();
            for (int i = 0; i <= 100; i++) {
                dataList2.add(new String[]{"李四", "女", "员工", "22", "13888888888", "88888888@qq.com"});
            }
           //合并文档
            WordprocessingMLPackage wordMLPackage=null;
            WordprocessingMLPackage wordMLPackage2 =null;
            InputStream templateInputStream =null;
            try {
                //docx4j生成的文档
                wordMLPackage = replaceData(data, dataList, dataList2);
                //加载本地的word文档
                templateInputStream = new FileInputStream("D://1.docx");
                wordMLPackage2= WordprocessingMLPackage.load(templateInputStream);
            } catch (Exception e) {
                e.printStackTrace();
            }
            List<WordprocessingMLPackage> wordList = new ArrayList<>();
            wordList.add(wordMLPackage);
            wordList.add(wordMLPackage2);
            wordList.add(wordMLPackage);
            wordList.add(wordMLPackage2);
            try {
                mergeWord(wordList);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 加载模板并替换数据
         *
         * @param data
         * @return
         * @throws Exception
         */
        public static void replaceData(Map<String, String> data, List<String[]> dataList, List<String[]> dataList2) throws Exception {
            final String TEMPLATE_NAME = "D://2.docx";
            InputStream templateInputStream = new FileInputStream(TEMPLATE_NAME);
            //加载模板文件并创建WordprocessingMLPackage对象
            WordprocessingMLPackage wordMLPackage = WordprocessingMLPackage.load(templateInputStream);
            MainDocumentPart documentPart = wordMLPackage.getMainDocumentPart();
            VariablePrepare.prepare(wordMLPackage);
            documentPart.variableReplace(data);
    
            List<Tbl> tbls = Docx4jUtils.getAllTbl(wordMLPackage);
            //获取表格对象
            Tbl firstTbl = tbls.get(0);
            List<Object> trObjList = firstTbl.getContent();
            Tr tr = null;
            //替换开发部数据
            if (dataList != null && !dataList.isEmpty()) {
                int index1 = 6;
                //获取需要填数据的行
                tr = (Tr) trObjList.get(index1);
                //填数据
                Docx4jUtils.replaceTrData(firstTbl, tr, dataList, index1);
            }
    
            //替换销售部数据
            if (dataList2 != null && !dataList2.isEmpty()) {
                //重新获取表格
                trObjList = firstTbl.getContent();
                //获取填数据的行的下标(从0开始)
                int index2 = 5 + dataList.size() + 2;
                tr = (Tr) trObjList.get(index2);
                Docx4jUtils.replaceTrData(firstTbl, tr, dataList2, index2);
            }
    
            //合并单元格
            Docx4jUtils.mergeCellsVertically(firstTbl, 0, 5, 5 + dataList.size());
            Docx4jUtils.mergeCellsVertically(firstTbl, 0, 5 + dataList.size() + 1, 5 + dataList.size() + dataList2.size() + 1);
    		
            //插入图片
            File file = new File("D://logo.jpg");
            Docx4jUtils.insertImgToTbl(file,wordMLPackage,1,3);
    		
    		 //生成页脚以及页码
            Relationship relationship = Docx4jUtils.createFooterPart(wordMLPackage);
            Docx4jUtils.createFooterReference(wordMLPackage, relationship);
     
            OutputStream os = new FileOutputStream(new File("D://test.docx"));
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            wordMLPackage.save(outputStream);
            outputStream.writeTo(os);
            os.close();
            outputStream.close();
            templateInputStream.close();
        }
    }
    

    2.单元格内填充图片

    填充图片可以实现,但是图片自适用大小比较难,而且,生成文档用WPS和Office打开会有差异。可以参照下述链接:
    使用docx4j根据书签自动替换word中的文本和图片,图片自适应大小

    3.合并word文档

    为了达到演示效果,示例采用两个word文档,一个是上面生成的(纸张方向为横向),一个是已经存在的(纸张方向为纵向)。
    因为把文档生成到了本地,现在演示文档合并,又要从本地加载,避免麻烦,所以修改返参为WordprocessingMLPackage。然后合并是直接利用。

        /**
         * 合并文件
         * @param list
         * @throws Exception
         */
        public static void mergeWord(List<WordprocessingMLPackage> list) throws Exception{
            List<BlockRange> blockRanges = new ArrayList<BlockRange>();
            HashMap<String, Object> result = new HashMap<>();
            if (list != null && !list.isEmpty()) {
                for (int i = 0; i < list.size(); i++) {
                    WordprocessingMLPackage wordMLPackage = list.get(i);
                    BlockRange block = new BlockRange(wordMLPackage);
                    blockRanges.add(block);
                    if (i == 2) {
                        //是否重新开始页码
                        block.setRestartPageNumbering(true);
                    } else {
                        block.setRestartPageNumbering(false);
                    }
    //            block.setStyleHandler(BlockRange.StyleHandler.USE_EARLIER);
                    block.setNumberingHandler(BlockRange.NumberingHandler.ADD_NEW_LIST);
                    block.setHeaderBehaviour(BlockRange.HfBehaviour.DEFAULT);
                    block.setFooterBehaviour(BlockRange.HfBehaviour.DEFAULT);
                    //设置分节符(下一页)
                    block.setSectionBreakBefore(BlockRange.SectionBreakBefore.NEXT_PAGE);
                }
    //         Perform the actual merge
                DocumentBuilder documentBuilder = new DocumentBuilder();
                WordprocessingMLPackage output = documentBuilder.buildOpenDocument(blockRanges);
    
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                output.save(outputStream);
                OutputStream os = new FileOutputStream(new File("D://test2.docx"));
                outputStream.writeTo(os);
                os.close();
                outputStream.close();
            }
        }
    

    工具类代码如下:

    import org.docx4j.XmlUtils;
    import org.docx4j.dml.wordprocessingDrawing.Inline;
    import org.docx4j.jaxb.Context;
    
    import org.docx4j.model.structure.SectionWrapper;
    import org.docx4j.openpackaging.exceptions.InvalidFormatException;
    import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
    import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
    import org.docx4j.openpackaging.parts.WordprocessingML.FooterPart;
    import org.docx4j.openpackaging.parts.WordprocessingML.MainDocumentPart;
    import org.docx4j.openpackaging.parts.relationships.Namespaces;
    import org.docx4j.relationships.Relationship;
    import org.docx4j.wml.*;
    import org.docx4j.wml.R;
    
    import javax.xml.bind.JAXBElement;
    import javax.xml.namespace.QName;
    import java.io.*;
    import java.math.BigInteger;
    import java.util.*;
    
    
    public class Docx4jUtils {
        public static ObjectFactory factory = Context.getWmlObjectFactory();
    
        //替换tr数据,其他插入
        public static void replaceTrData(Tbl tbl, Tr tr, List<String[]> dataList, int trIndex) throws Exception {
    
            TrPr trPr = XmlUtils.deepCopy(tr.getTrPr());
            String tcContent = null;
            String[] tcMarshaArr = getTcMarshalStr(tr);
            String[] dataArr = null;
            for (int i = 0, iLen = dataList.size(); i < iLen; i++) {
                dataArr = dataList.get(i);
                Tr newTr = null;
                Tc newTc = null;
                if (i == 0) {
                    newTr = tr;
                } else {
                    newTr = factory.createTr();
                    if (trPr != null) {
                        newTr.setTrPr(trPr);
                    }
                    newTc = factory.createTc();
                    newTr.getContent().add(newTc);
                }
                for (int j = 0, jLen = dataArr.length; j < jLen; j++) {
                    tcContent = tcMarshaArr[j];
                    if (tcContent != null) {
                        tcContent = tcContent.replaceAll("(<w:t>)(.*?)(</w:t>)", "<w:t>" + dataArr[j] + "</w:t>");
                        newTc = (Tc) XmlUtils.unmarshalString(tcContent);
                    } else {
                        newTc = factory.createTc();
                        setNewTcContent(newTc, dataArr[j]);
                    }
                    // 新增tr
                    if (i != 0) {
                        newTr.getContent().add(newTc);
                    } else {
                        // 替换
                        newTr.getContent().set(j + 1, newTc);
                    }
                }
                if (i != 0) {
                    tbl.getContent().add(trIndex + i, newTr);
                }
            }
        }
    
        /**
         * 获取单元格字符串
         *
         * @param tr 行对象
         * @return 字符数组
         */
        public static String[] getTcMarshalStr(Tr tr) {
            List<Object> tcObjList = tr.getContent();
            String[] marshaArr = new String[7];
            // 跳过层次
            for (int i = 1, len = tcObjList.size(); i < len; i++) {
                marshaArr[i - 1] = XmlUtils.marshaltoString(tcObjList.get(i), true, false);
            }
            return marshaArr;
        }
    
        /**
         * 设置单元格内容
         *
         * @param tc      单元格
         * @param content 内容
         */
        public static void setNewTcContent(Tc tc, String content) {
            P p = factory.createP();
            tc.getContent().add(p);
            R run = factory.createR();
            p.getContent().add(run);
            if (content != null) {
                String[] contentArr = content.split("\n");
                Text text = factory.createText();
                text.setSpace("preserve");
                text.setValue(contentArr[0]);
                run.getContent().add(text);
    
                for (int i = 1, len = contentArr.length; i < len; i++) {
                    Br br = factory.createBr();
                    run.getContent().add(br);// 换行
                    text = factory.createText();
                    text.setSpace("preserve");
                    text.setValue(contentArr[i]);
                    run.getContent().add(text);
                }
            }
        }
    
        /**
         * 跨行合并
         *
         * @param tbl     表名
         * @param col     列数
         * @param fromRow 起始行数
         * @param toRow   结束行数
         */
        public static void mergeCellsVertically(Tbl tbl, int col, int fromRow, int toRow) {
            if (col < 0 || fromRow < 0 || toRow < 0) {
                return;
            }
            for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
                Tc tc = getTc(tbl, rowIndex, col);
                if (tc == null) {
                    break;
                }
                TcPr tcPr = getTcPr(tc);
                TcPrInner.VMerge vMerge = tcPr.getVMerge();
                if (vMerge == null) {
                    vMerge = factory.createTcPrInnerVMerge();
                    tcPr.setVMerge(vMerge);
                }
                if (rowIndex == fromRow) {
                    vMerge.setVal("restart");
                } else {
                    vMerge.setVal("continue");
                }
            }
        }
    
        /**
         * @param tc
         * @return
         */
        public static TcPr getTcPr(Tc tc) {
            TcPr tcPr = tc.getTcPr();
            if (tcPr == null) {
                tcPr = new TcPr();
                tc.setTcPr(tcPr);
            }
            return tcPr;
        }
    
    
        //得到指定类型的元素
        public static List<Object> getAllElementFromObject(Object obj,
                                                           Class<?> toSearch) {
            List<Object> result = new ArrayList<Object>();
            if (obj instanceof JAXBElement) {
                obj = ((JAXBElement<?>) obj).getValue();
            }
            if (obj.getClass().equals(toSearch)) {
                result.add(obj);
            } else if (obj instanceof ContentAccessor) {
                List<?> children = ((ContentAccessor) obj).getContent();
                for (Object child : children) {
                    result.addAll(getAllElementFromObject(child, toSearch));
                }
            }
            return result;
        }
    
        //得到所有的表格
        public static List<Tbl> getAllTbl(WordprocessingMLPackage wordMLPackage) {
            MainDocumentPart mainDocPart = wordMLPackage.getMainDocumentPart();
            List<Object> objList = Docx4jUtils.getAllElementFromObject(mainDocPart, Tbl.class);
            if (objList == null) {
                return null;
            }
            List<Tbl> tblList = new ArrayList<Tbl>();
            for (Object obj : objList) {
                if (obj instanceof Tbl) {
                    Tbl tbl = (Tbl) obj;
                    tblList.add(tbl);
                }
            }
            return tblList;
        }
    
        //得到指定位置的单元格
        public static Tc getTc(Tbl tbl, int row, int cell) {
            if (row < 0 || cell < 0) {
                return null;
            }
            List<Tr> trList = getTblAllTr(tbl);
            if (row >= trList.size()) {
                return null;
            }
            List<Tc> tcList = getTrAllCell(trList.get(row));
            if (cell >= tcList.size()) {
                return null;
            }
            return tcList.get(cell);
        }
    
        //得到表格所有的行
        public static List<Tr> getTblAllTr(Tbl tbl) {
            List<Object> objList = getAllElementFromObject(tbl, Tr.class);
            List<Tr> trList = new ArrayList<Tr>();
            if (objList == null) {
                return trList;
            }
            for (Object obj : objList) {
                if (obj instanceof Tr) {
                    Tr tr = (Tr) obj;
                    trList.add(tr);
                }
            }
            return trList;
        }
    
        //获取某一行的单元格
        public static List<Tc> getTrAllCell(Tr tr) {
            List<Object> objList = getAllElementFromObject(tr, Tc.class);
            List<Tc> tcList = new ArrayList<Tc>();
            if (objList == null) {
                return tcList;
            }
            for (Object tcObj : objList) {
                if (tcObj instanceof Tc) {
                    Tc objTc = (Tc) tcObj;
                    tcList.add(objTc);
                }
            }
            return tcList;
        }
    
        /**
         * @Description:设置单元格内容,content为null则清除单元格内容
         */
        public void setTcContent(Tc tc, RPr rpr, String content) {
            List<Object> pList = tc.getContent();
            P p = null;
            if (pList != null && pList.size() > 0) {
                if (pList.get(0) instanceof P) {
                    p = (P) pList.get(0);
                }
            } else {
                p = new P();
                tc.getContent().add(p);
            }
            R run = null;
            List<Object> rList = p.getContent();
            if (rList != null && rList.size() > 0) {
                for (int i = 0, len = rList.size(); i < len; i++) {
                    // 清除内容(所有的r
                    p.getContent().remove(0);
                }
            }
            run = new R();
            p.getContent().add(run);
            if (content != null) {
                String[] contentArr = content.split("\n");
                Text text = new Text();
                text.setSpace("preserve");
                text.setValue(contentArr[0]);
                run.setRPr(rpr);
                run.getContent().add(text);
    
                for (int i = 1, len = contentArr.length; i < len; i++) {
                    Br br = new Br();
                    run.getContent().add(br);// 换行
                    text = new Text();
                    text.setSpace("preserve");
                    text.setValue(contentArr[i]);
                    run.setRPr(rpr);
                    run.getContent().add(text);
                }
            }
        }
    
        //向表格插入图片
        public static void insertImgToTbl(File file, WordprocessingMLPackage wordMLPackage, int rowIndex, int colIndex) throws Exception {
            factory = Context.getWmlObjectFactory();
            List<Tbl> tbls = getAllTbl(wordMLPackage);
            Tbl tbl = tbls.get(0);
            Tr tr = getTblAllTr(tbl).get(rowIndex);
            Tc tc = getTc(tbl, rowIndex, colIndex);
    
            Inline newInline = createInlineImage(file, wordMLPackage);
            P paragraphWithImage = addInlineImageToParagraph(newInline);
            PPr pPr = factory.createPPr();
            PPrBase.Spacing spacing = new PPrBase.Spacing();
            spacing.setBefore(BigInteger.valueOf(0));
            spacing.setAfter(BigInteger.valueOf(0));
            spacing.setLine(BigInteger.valueOf(0));
            pPr.setSpacing(spacing);
            paragraphWithImage.setPPr(pPr);
            tc.getContent().add(paragraphWithImage);
            //tr.getContent().add(tc);
    
        }
    
    
        /**
         * 我们将文件转换成字节数组, 并用它创建一个内联图片.
         *
         * @param file
         * @return
         * @throws Exception
         */
        private static Inline createInlineImage(File file, WordprocessingMLPackage wordMLPackage) throws Exception {
            byte[] bytes = convertImageToByteArray(file);
    
            BinaryPartAbstractImage imagePart = BinaryPartAbstractImage.createImagePart(wordMLPackage, bytes);
    
            int docPrId = 1;
            int cNvPrId = 2;
    
            return imagePart.createImageInline("Filename hint", "Alternative text", docPrId, cNvPrId, false, 1800);
        }
    
    
        /**
         * 将图片从文件转换成字节数组.
         *
         * @param file
         * @return
         * @throws FileNotFoundException
         * @throws IOException
         */
        private static byte[] convertImageToByteArray(File file) throws FileNotFoundException, IOException {
            InputStream is = new FileInputStream(file);
            long length = file.length();
            // You cannot create an array using a long, it needs to be an int.
            if (length > Integer.MAX_VALUE) {
                System.out.println("File too large!!");
            }
            byte[] bytes = new byte[(int) length];
            int offset = 0;
            int numRead = 0;
            while (offset < bytes.length && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
                offset += numRead;
            }
            // Ensure all the bytes have been read
            if (offset < bytes.length) {
                System.out.println("Could not completely read file " + file.getName());
            }
            is.close();
            return bytes;
        }
    
        /**
         * 向新的段落中添加内联图片并返回这个段落
         *
         * @param inline
         * @return
         */
        private static P addInlineImageToParagraph(Inline inline) {
            // Now add the in-line image to a paragraph
            ObjectFactory factory = new ObjectFactory();
            P paragraph = factory.createP();
            R run = factory.createR();
            paragraph.getContent().add(run);
            Drawing drawing = factory.createDrawing();
            run.getContent().add(drawing);
            drawing.getAnchorOrInline().add(inline);
            return paragraph;
        }
    
        /**
         * @Description: 设置页面大小及纸张方向 landscape横向
         */
        public static void setDocumentSize(WordprocessingMLPackage wordPackage,
                                           ObjectFactory factory, String width, String height,
                                           STPageOrientation stValue) {
    
            SectPr sectPr = getDocSectPr(wordPackage);
    
            SectPr.PgSz pgSz = sectPr.getPgSz();
            //System.out.println(pgSz.getH().toString()+"-"+pgSz.getW().toString()+"-"+pgSz.getOrient().value());
            if (pgSz == null) {
                pgSz = factory.createSectPrPgSz();
                sectPr.setPgSz(pgSz);
            }
            if (StringUtils.isNotBlank(width)) {
                pgSz.setW(new BigInteger(width));
            }
            if (StringUtils.isNotBlank(height)) {
                pgSz.setH(new BigInteger(height));
            }
            if (stValue != null) {
                pgSz.setOrient(stValue);
            }
            // System.out.println(pgSz.getCode().toString()+"-"+pgSz.getH().toString()+"-"+pgSz.getW().toString()+"-"+pgSz.getOrient().value());
    
        }
    
        /**
         * @Description: 设置分节符 nextPage:下一页 continuous:连续 evenPage:偶数页 oddPage:奇数页
         */
        public static void setDocSectionBreak(WordprocessingMLPackage wordPackage, ObjectFactory factory, String sectValType) {
            P p = factory.createP();
            PPr pPr = factory.createPPr();
            SectPr sectPr = factory.createSectPr();
            SectPr.Type sectType = factory.createSectPrType();
            sectType.setVal(sectValType);
            sectPr.setType(sectType);
            pPr.setSectPr(sectPr);
            p.setPPr(pPr);
            wordPackage.getMainDocumentPart().addObject(p);
    
        }
    
        public static SectPr getDocSectPr(WordprocessingMLPackage wordPackage) {
            SectPr sectPr = wordPackage.getDocumentModel().getSections().get(0).getSectPr();
            return sectPr;
        }
    
        /**
         * 创建分页符
         *
         * @return
         */
        public static P getPageBreak() {
            P p = new P();
            R r = new R();
            org.docx4j.wml.Br br = new org.docx4j.wml.Br();
            br.setType(STBrType.PAGE);
            r.getContent().add(br);
            p.getContent().add(r);
            return p;
        }
    
    
        //添加页脚并添加页码
    
        /**
         * 创建页脚的组件
         *
         * @return
         * @throws InvalidFormatException
         */
        public static Relationship createFooterPart(WordprocessingMLPackage wordMLPackage) throws InvalidFormatException {
            FooterPart footerPart = new FooterPart();
            footerPart.setPackage(wordMLPackage);
            footerPart.setJaxbElement(createFooterWithPageNr());
            return wordMLPackage.getMainDocumentPart().addTargetPart(footerPart);
        }
    
        /**
         * First we retrieve the document sections from the package. As we want to add
         * a footer, we get the last section and take the section properties from it.
         * The section is always present, but it might not have properties, so we check
         * if they exist to see if we should create them. If they need to be created,
         * we do and add them to the main document part and the section.
         * Then we create a reference to the footer, give it the id of the relationship,
         * set the type to header/footer reference and add it to the collection of
         * references to headers and footers in the section properties.
         * 创建页脚引用关系
         *
         * @param relationship
         */
        public static void createFooterReference(WordprocessingMLPackage wordMLPackage, Relationship relationship) {
            List<SectionWrapper> sections = wordMLPackage.getDocumentModel().getSections();
    
            SectPr sectionProperties = sections.get(sections.size() - 1).getSectPr();
            // There is always a section wrapper, but it might not contain a sectPr
            if (sectionProperties == null) {
                sectionProperties = factory.createSectPr();
                wordMLPackage.getMainDocumentPart().addObject(sectionProperties);
                sections.get(sections.size() - 1).setSectPr(sectionProperties);
            }
    
            FooterReference footerReference = factory.createFooterReference();
            footerReference.setId(relationship.getId());
            footerReference.setType(HdrFtrRef.DEFAULT);
            sectionProperties.getEGHdrFtrReferences().add(footerReference);
        }
    
    
        /**
         * As in the previous example, we create a footer and a paragraph object. But
         * this time, instead of adding text to a run, we add a field. And just as with
         * the table of content, we have to add a begin and end character around the
         * actual field with the page number. Finally we add the paragraph to the
         * content of the footer and then return it.
         * 生成页码
         *
         * @return
         */
        public static Ftr createFooterWithPageNr() {
            Ftr ftr = factory.createFtr();
            P paragraph = factory.createP();
    
            addFieldBegin(paragraph);
            addPageNumberField(paragraph);
            addFieldEnd(paragraph);
    
            ftr.getContent().add(paragraph);
            return ftr;
        }
    
        /**
         * Creating the page number field is nearly the same as creating the field in
         * the TOC example. The only difference is in the value. We use the PAGE
         * command, which prints the number of the current page, together with the
         * MERGEFORMAT switch, which indicates that the current formatting should be
         * preserved when the field is updated.
         *
         * @param paragraph
         */
        public static void addPageNumberField(P paragraph) {
            R run = factory.createR();
            Text txt = new Text();
            txt.setSpace("preserve");
            txt.setValue(" PAGE   \\* MERGEFORMAT ");
            run.getContent().add(factory.createRInstrText(txt));
            paragraph.getContent().add(run);
    
    //        STNumberFormat.DECIMAL_FULL_WIDTH_2; //双字节阿拉伯数字
    //        STNumberFormat.DECIMAL_HALF_WIDTH;//单字节阿拉伯数字
        }
    
        /**
         * Every fields needs to be delimited by complex field characters. This method
         * adds the delimiter that precedes the actual field to the given paragraph.
         *
         * @param paragraph
         */
        public static void addFieldBegin(P paragraph) {
            R run = factory.createR();
            FldChar fldchar = factory.createFldChar();
            fldchar.setFldCharType(STFldCharType.BEGIN);
            run.getContent().add(fldchar);
            paragraph.getContent().add(run);
        }
    
        /**
         * Every fields needs to be delimited by complex field characters. This method
         * adds the delimiter that follows the actual field to the given paragraph.
         *
         * @param paragraph
         */
        public static void addFieldEnd(P paragraph) {
            FldChar fldcharend = factory.createFldChar();
            fldcharend.setFldCharType(STFldCharType.END);
            R run3 = factory.createR();
            run3.getContent().add(fldcharend);
            paragraph.getContent().add(run3);
        }
    
        /**
         * Adds a page break to the document.
         *
         * @param documentPart
         */
        public static void addPageBreak(MainDocumentPart documentPart) {
            Br breakObj = new Br();
            breakObj.setType(STBrType.PAGE);
    
            P paragraph = factory.createP();
            paragraph.getContent().add(breakObj);
            documentPart.getJaxbElement().getBody().getContent().add(paragraph);
        }
    
    
        //生成目录
    
        /**
         * 将目录表添加到文档.
         * <p>
         * 首先我们创建段落. 然后添加标记域开始的指示符, 然后添加域内容(真正的目录表), 接着添加域
         * 结束的指示符. 最后将段落添加到给定文档的JAXB元素中.
         *
         * @param documentPart
         */
        public static void addTableOfContent(MainDocumentPart documentPart) {
            P paragraph = factory.createP();
    
            addFieldBegin2(paragraph);
            addTableOfContentField(paragraph);
            addFieldEnd2(paragraph);
    
            documentPart.getJaxbElement().getBody().getContent().add(paragraph);
        }
    
        public static void addTableOfContentField(P paragraph) {
            R run = factory.createR();
            Text txt = new Text();
            txt.setSpace("preserve");
            txt.setValue("TOC \\o \"1-3\" \\h \\z \\u");
            run.getContent().add(factory.createRInstrText(txt));
            paragraph.getContent().add(run);
        }
    
        private static void addFieldBegin2(P paragraph) {
            R run = factory.createR();
            FldChar fldchar = factory.createFldChar();
            fldchar.setFldCharType(STFldCharType.BEGIN);
            fldchar.setDirty(true);
            run.getContent().add(getWrappedFldChar(fldchar));
            paragraph.getContent().add(run);
        }
    
        private static void addFieldEnd2(P paragraph) {
            R run = factory.createR();
            FldChar fldcharend = factory.createFldChar();
            fldcharend.setFldCharType(STFldCharType.END);
            run.getContent().add(getWrappedFldChar(fldcharend));
            paragraph.getContent().add(run);
        }
    
        public static JAXBElement getWrappedFldChar(FldChar fldchar) {
            return new JAXBElement(new QName(Namespaces.NS_WORD12, "fldChar"), FldChar.class, fldchar);
        }
    }
    

    总结

    至此,已经实现了动态生成表格行数,单元格插入图片,以及合并多个word文档,同时设置纸张方向、分页符、页脚和页码等等。目录的生成在工具类里也有,本人亲测可用。
    提示:文档中的各种样式,包括字体,颜色,表格边框等等都可以在模板中设置好,也可以用java代码实现,具体api网上有许多,这里就不写了。生成目录时,一定要在模板中的文档标题设置大纲级别,因为目录的生成会依靠这个
    jar包:
    合并文件时用到了Plutext-Enterprise-3.3.0.6.jar这个包,但是在Maven仓库找不到,百度云链接如下:
    https://pan.baidu.com/s/1k5TraeDfA_bpDoQxMmY5RA
    提取码:mabl

    展开全文
  • 同时,样式还能使文档结构化,指定不同「标题层次的样式后,即可快速生成目录。 但样式有时也会带来麻烦。例如,需要将别人传过来的多份 Word 文档进行整合、统一其格式时,他人文档中预设的样式可能会给排版造成...
  • 当我们需要用Word编辑一个长文档时,如果没有层次感,文字看起来就很散乱,缺乏条理性,文档的二次编辑和修订也会因此造成很多不必要的麻烦。 说到此,不知勾起多少孩纸写毕业论文时的惨痛回忆哦…… 理想的长文档...
  • 用好Word文档结构图

    千次阅读 2009-09-11 12:01:00
    编辑或者阅读长文章往往需要不停地使用...“文档结构图”是一个独立的窗格,能够显示文档标题列表。如图1,就是本篇文章的文档结构图。 图1单击“文档结构图”中的标题后,Word 就会跳转到文档中的相应标题,并将该
  • 一共用了3级标题,每级标题里面的内容都进行了重新编号。 在这里插入图片描述 很简单,直接右键标题,进行修改样式就好了。 详细设置方法: 步骤一:点击修改标题样式。 步骤二:找到编号设置。 步骤三:在多级编号...
  • 标题1到标题9可以选择,最好是根据默认的几个标题进行修改,而不是自己增加样式。 技巧: 设置样式,如果格式一样, 有两种方法加快速度: 1)可以右击选择格式相似的文字。 2)用替换功能,高级,格式替换。 格式刷...
  • word文档排版技巧

    2014-05-06 23:19:00
    简介 市场部经常要出各种分析报告,一写就是洋洋...制作目录也是出力不讨好的事,尽管小王知道Word中有插入目录的功能,可是尝试了几次就弃之不用了,原因是系统总是提示有错误。现在只能手工输入目录,加班加点...
  • Javascript利用VBA编辑Word文档

    千次阅读 热门讨论 2014-03-30 23:24:39
    在做人事系统过程中,发现网上关于... 先向大家介绍一些简单应用,比如JS创建Word文档、在Word中打印文字、添加表格,填充表格、合并表格 var wdapp = new ActiveXObject("Word.Application"); //引用word wdapp
  • 基本概念:word文档(.docx文件)的三层结构:最高一层Document对象表示整个文档,Document对象包含一个paragraph 对象的列表,表示文档中的段落(用户在word文档输入时,如果按下回车则表示新段落开始)。每个...
  • 前言用Word编辑长文档(比如学位论文、标书、项目总结报告)是件非常耗时耗力的活儿,主要体现在内容的创作(及复制粘贴和组合)上,但后期的排版也会让不少人困扰,无法流畅地排出自己想要的版式。经过多年的间歇性主动...
  • tab键是低一层次的 shift+tab键是回到上一层次
  • 使用Jacob来处理Word文档 Word或Excel程序是以一种COM组件形式存在的。如果能够在Java中调用Word的COM组件,就 能使用它的方法来获取Word文档中的文本信息。目前网上有许多提供这样的工具。 1 Jacob的下载 ...
  • word长篇文档编辑技巧

    2017-11-28 21:47:00
    以下内容是应某杂志编辑要求所写。主要是word长篇文档的编辑技巧。 可以利用在论文、计划、总结等方面。 一、版面规划: ...新建一个Word文档,选择菜单“文件”--“页面设置”,在“页面设置”...
  • Word文档结构图内容“越界”问题 如果经常需要使用Microsoft Office Word软件撰写几百上千页的长文档,一种比较好的文档浏览方式是利用文档结构图。通过使用该功能,在Word窗口左侧的结构图列表中,可以看到一...
  • 案例:用python中文翻译的和英文原文合成新的word文档 一 问题的形成 需求的描述:一个英语翻译专业的研究生同学有一个期末作业。老师给了一个英文的文档,需要同学们翻译成中文。老师给的文档是格式如下图一所示,这...
  • python读写word、pdf文档

    千次阅读 2018-08-16 15:45:40
    处理PDF和Word文档 用于处理PDF的模块是PyPDF2。 处理Word文档是python-docx模块,要安装python-docx,但是导入模块时是写import docx。 1.从PDF提取文本 import PyPDF2 pdfFileObj = open('meetingminutes.pdf...
  • 今天小编给大家分享 Ghost Win7系统 在excel中添加word文档结构图的方法,有时候在编辑excel表格时,为了数据能够更加直观展示,会在excel中添加word文档结构图,这样显示的内容会更加丰富。但是问题来了,很多用户...
  • 从菜单选择【视图】|【文档结构图】命令,可在文档左侧显示文档层次结构,如图所示。在其中的标题上单击,即可快速定位到相应位置。再次从菜单选择【视图】|【文档结构图】命令,即可取消文档结构图。如果文章中有...
  • 大纲级别就是段落所处层次的级别编号,Word提供9级大纲级别,对应9种标题样式。标题样式的设计我们在前面的文章中已经介绍过(本文下方有文章链接),这里只介绍自动提取目录的方法。(1) 按论文格式要求...
  • 文档啊,最重要的还是层次

    千次阅读 2017-07-30 22:55:49
    你看,这是word中的文档结构图。 这是pdf的书签。 还有我最喜爱的markdown也是一个十分方便呈现逻辑结构的编辑工具。 此外,对于开发者来说,甚至细微到了代码更新日志,也需要认真地来勾勒金字塔...
  • WordXP中大文档如何提取目录(转) 设置标题 假设文档初稿已整理完毕,标题之间的层次关系为:全文共分为8章,每章分为若干小节,每个小节又包含若干部分内容。我们分两步完成标题的设置: 1. 定义标题的样式。依次...
  • Word长篇文档排版技巧

    万次阅读 2005-08-06 15:51:00
    最头疼的是上司看完报告后让他修改,整篇文档的排版弄不好就要重来一遍。制作目录也是出力不讨好的事,尽管小王知道Word中有插入目录的功能,可是尝试了几次就弃之不用了,原因是系统总是提示有错误。现在只能手工...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,847
精华内容 3,138
关键字:

word文档显示标题层次