Python库reportLab用户手册+API_reportlab教程资源-CSDN文库

需积分: 2 186 浏览量 2023-07-09 00:23:56 上传评论收藏 2.07MB PDF 举报

资源推荐

资源详情

资源评论

Chapter 1: Introduction
Chapter 2: Graphics and text with pdfgen
Chapter 3: Fonts
Chapter 4: Features
Chapter 5: Platypus
Chapter 6: Paragraphs
Chapter 7: Tables
Chapter 8: Programming flowables
Chapter 9: Other useful flowables
Chapter 10: Writing Your Own flowables
Chapter 11: Graphics
Introduction
About this document
This document is an introduction to the ReportLab PDF library. Some previous programming experience is presumed and familiarity with the Python
Programming language is recommended. If you are new to Python, we tell you in the next section where to go for orientation.
This manual does not cover 100% of the features, but should explain all the main concepts and help you get started, and point you at other learning resources.
After working your way through this, you should be ready to begin writing programs to produce sophisticated reports.
In this chapter, we will cover the groundwork: - What is ReportLab all about, and why should I use it? - What is Python? - How do I get everything set up and
running?
We need your help to make sure this manual is complete and helpful. Please send any feedback to our user mailing list, which is signposted from
www.reportlab.com.
What is the ReportLab PDF Library?
This is a software library that lets you directly create documents in Adobe's Portable Document Format (PDF) using the Python programming language. It also
creates charts and data graphics in various bitmap and vector formats as well as PDF.
PDF is the global standard for electronic documents. It supports high-quality printing yet is totally portable across platforms, thanks to the freely available
Acrobat Reader. Any application which previously generated hard copy reports or driving a printer can benefit from making PDF documents instead; these can
be archived, emailed, placed on the web, or printed out the old-fashioned way. However, the PDF file format is a complex indexed binary format which is
impossible to type directly. The PDF format specification is more than 600 pages long and PDF files must provide precise byte offsets -- a single extra
character placed anywhere in a valid PDF document can render it invalid. This makes it harder to generate than HTML.
Most of the world's PDF documents have been produced by Adobe's Acrobat tools, or rivals such as JAWS PDF Creator, which act as 'print drivers'. Anyone
wanting to automate PDF production would typically use a product like Quark, Word or Framemaker running in a loop with macros or plugins, connected to
Acrobat. Pipelines of several languages and products can be slow and somewhat unwieldy.
The ReportLab library directly creates PDF based on your graphics commands. There are no intervening steps. Your applications can generate reports
extremely fast - sometimes orders of magnitude faster than traditional report-writing tools. This approach is shared by several other libraries - PDFlib for C,
iText for Java, iTextSharp for .NET and others. However, The ReportLab library differs in that it can work at much higher levels, with a full featured engine for
laying out documents complete with tables and charts.
In addition, because you are writing a program in a powerful general purpose language, there are no restrictions at all on where you get your data from, how you
transform it, and the kind of output you can create. And you can reuse code across whole families of reports.
The ReportLab library is expected to be useful in at least the following contexts:
Dynamic PDF generation on the web
High-volume corporate reporting and database publishing
An embeddable print engine for other applications, including a 'report language' so that users can customize their own reports. This is particularly
relevant to cross-platform apps which cannot rely on a consistent printing or previewing API on each operating system.
A 'build system' for complex documents with charts, tables and text such as management accounts, statistical reports and scientific papers
Going from XML to PDF in one step
ReportLab's commercial software
The ReportLab library forms the foundation of our commercial solution for PDF generation, Report Markup Language (RML). This is available for evaluation
on our web site with full documentation. We believe that RML is the fastest and easiest way to develop rich PDF workflows. You work in a markup language
at a similar level to HTML, using your favorite templating system to populate an RML document; then call our rml2pdf API function to generate a PDF. It's
what ReportLab staff use to build all of the solutions you can see on reportlab.com. Key differences:
Fully documented with two manuals, a formal specification (the DTD) and extensive self-documenting tests. (By contrast, we try to make sure the open
source documentation isn't wrong, but we don't always keep up with the code)
Work in high-level markup rather than constructing graphs of Python objects
Requires no Python expertise - your colleagues may thank you after you've left!'
Support for vector graphics and inclusion of other PDF documents

Many more useful features expressed with a single tag, which would need a lot of coding in the open source package

Commercial support is included

We ask open source developers to consider trying out RML where it is appropriate. You can register on our site and try out a copy before buying. The costs

are reasonable and linked to the volume of the project, and the revenue helps us spend more time developing this software.

What is Python?

Python is an interpreted, interactive, object-oriented programming language. It is often compared to Tcl, Perl, Scheme or Java.

Python combines remarkable power with very clear syntax. It has modules, classes, exceptions, very high level dynamic data types, and dynamic typing. There

are interfaces to many system calls and libraries, as well as to various windowing systems (X11, Motif, Tk, Mac, MFC). New built-in modules are easily written

in C or C++. Python is also usable as an extension language for applications that need a programmable interface.

Python is as old as Java and has been growing steadily in popularity for years; since our library first came out it has entered the mainstream. Many ReportLab

library users are already Python devotees, but if you are not, we feel that the language is an excellent choice for document-generation apps because of its

expressiveness and ability to get data from anywhere.

Python is copyrighted but freely usable and distributable, even for commercial use.

Acknowledgements

Many people have contributed to ReportLab. We would like to thank in particular (in alphabetical order): Albertas Agejevas, Alex Buck, Andre Reitz, Andrew

Cutler, Andrew Mercer, Ben Echols, Benjamin Dumke, Benn B, Chad Miller, Chris Buergi, Chris Lee, Christian Jacobs, Dinu Gherman, Edward Greve, Eric

Johnson, Felix Labrecque, Fubu @ bitbucket, Gary Poster, Germán M. Bravo, Guillaume Francois, Hans Brand, Henning Vonbargen, Hosam Aly, Ian

Stevens, James Martin-Collar, Jeff Bauer, Jerome Alet, Jerry Casiano, Jorge Godoy, Keven D Smith, Kyle MacFarlane, Magnus Lie Hetland, Marcel Tromp,

Marius Gedminas, Mark de Wit, Matthew Duggan, Matthias Kirst, Matthias Klose, Max M, Michael Egorov, Michael Spector, Mike Folwell, Mirko

Dziadzka, Moshe Wagner, Nate Silva, Paul McNett, Peter Johnson, PJACock, Publio da Costa Melo,

Randolph Bentson, Robert Alsina, Robert Hölzl, Robert Kern, Ron Peleg, Ruby Yocum, Simon King, Stephan Richter, Steve Halasz, Stoneleaf @ bitbucket, T

Blatter, Tim Roberts, Tomasz Swiderski, Ty Sarna, Volker Haas, Yoann Roman, and many more.

Special thanks go to Just van Rossum for his valuable assistance with font technicalities.

Moshe Wagner and Hosam Aly deserve a huge thanks for contributing to the RTL patch, which is not yet on the trunk.

Marius Gedminas deserves a big hand for contributing the work on TrueType fonts and we are glad to include these in the toolkit. Finally we thank Michal

Kosmulski for the DarkGarden font for and Bitstream Inc. for the Vera fonts.

Installation and Setup

There are a couple of ways to download and install, please check our installation page.

Getting Involved

ReportLab is an Open Source project. Although we are a commercial company we provide the core PDF generation sources freely, even for commercial

purposes, and we make no income directly from these modules. We also welcome help from the community as much as any other Open Source project. There

are many ways in which you can help:

General feedback on the core API. Does it work for you? Are there any rough edges? Does anything feel clunky and awkward?

New objects to put in reports, or useful utilities for the library. We have an open standard for report objects, so if you have written a nice chart or table

class, why not contribute it?

Snippets and Case Studies: If you have produced some nice output, register online on http://www.reportlab.com and submit a snippet of your output

(with or without scripts). If ReportLab solved a problem for you at work, write a little 'case study' and submit it. And if your web site uses our tools to

make reports, let us link to it. We will be happy to display your work (and credit it with your name and company) on our site!

Working on the core code: we have a long list of things to refine or to implement. If you are missing some features or just want to help out, let us know!

The first step for anyone wanting to learn more or get involved is to join the mailing list. To Subscribe visit http://two.pairlist.net/mailman/listinfo/reportlab-users.

From there you can also browse through the group's archives and contributions. The mailing list is the place to report bugs and get support.

The code now lives on our website (http://hg.reportlab.com/hg-public/reportlab) in a Mercurial repository, along with an issue tracker and wiki. Everyone

should feel free to contribute, but if you are working actively on some improvements or want to draw attention to an issue, please use the mailing list to let us

know.

Site Configuration

There are a number of options which most likely need to be configured globally for a site. The python script module reportlab/rl_config.py aggregates

the various settings files. You may want inspect the file reportlab/rl_settings.py which contains defaults for the currently used variables. There are

several overrides for rl_settings modules reportlab.local_rl_settings, reportlab_settings (a script file anywhere on the python path) and

finally the file ~/.reportlab_settings (note no .py). Temporary changes can be made using evironment variables which are the variables from

rl_settings.py prefixed with RL_ eg RL_verbose=1.

Useful rl_config variables

verbose: set to integer values to control diagnostic output.

shapeChecking: set this to zero to turn off a lot of error checking in the graphics modules

defaultEncoding: set this to WinAnsiEncoding or MacRomanEncoding.

defaultPageSize: set this to one of the values defined in reportlab/lib/pagesizes.py; as delivered it is set to pagesizes.A4; other values are pagesizes.letter

etc.

defaultImageCaching: set to zero to inhibit the creation of .a85 files on your hard-drive. The default is to create these preprocessed PDF compatible

image files for faster loading

T1SearchPath: this is a python list of strings representing directories that may be queried for information on Type 1 fonts

TTFSearchPath: this is a python list of strings representing directories that may be queried for information on TrueType fonts

CMapSearchPath: this is a python list of strings representing directories that may be queried for information on font code maps.

showBoundary: set to non-zero to get boundary lines drawn.

ZLIB_WARNINGS: set to non-zero to get warnings if the Python compression extension is not found.

pageCompression: set to non-zero to try and get compressed PDF.

allowtableBoundsErrors: set to 0 to force an error on very large Platypus table elements

emptyTableAction: Controls behaviour for empty tables, can be 'error' (default), 'indicate' or 'ignore'.

trustedHosts: if not None a list of glob patterns of trusted hosts; these may be used in places like <img> tags in paragraph texts.

trustedSchemes: a list of allowed URL schemes used with trustedHosts For the full list of variables see the file reportlab/rl_settings.py.

Other modifications

More complex modifications to the reportlab toolkit environment may be made using one of the modules rep[ortlab.local_rl_mods (.py script in reportlab

folder), reportlab_mods (.py file on the python path) or ~/.reportlab_mods (note no .py).

Learning More About Python

If you are a total beginner to Python, you should check out one or more from the growing number of resources on Python programming. The following are freely

available on the web:

Python Documentation. A list of documentation on the Python.org web site. http://www.python.org/doc

Python Tutorial. The official Python Tutorial , originally written by Guido van Rossum himself. http://docs.python.org/tutorial

Learning to Program. A tutorial on programming by Alan Gauld. Has a heavy emphasis on Python, but also uses other languages.

http://www.freenetpages.co.uk/hp/alan.gauld

Instant Python. A 6-page minimal crash course by Magnus Lie Hetland. https://folk.idi.ntnu.no/mlh/hetland_org/writing/instant-python.html

Dive Into Python. A free Python tutorial for experienced programmers. http://www.diveintopython.net

Goals of the 3.x release series

ReportLab 3.0 has been produced to help in the migration to Python 3.x. Python 3.x will be standard in future Ubuntu releases and is gaining popularity, and a

good proportion of major Python packages now run on Python 3.

Python 3.x compatibility. A single line of code should run on 3.6 and higher

init.py restricts to >=3.6

init.py allow the import of on optional reportlab.local_rl_mods to allow monkey patching etc.

rl_config now imports rl_settings, optionally local_rl_settings, reportlab_settings.py & finally ~/.reportlab_settings

ReportLab C extensions now live inside reportlab; _rl_accel is no longer required. All _rl_accel imports now pass through reportlab.lib.rl_accel

xmllib is gone, alongside the paraparser stuff that caused issues in favour of HTMLParser.

some obsolete C extensions (sgmlop and pyHnj) are gone

Improved support for multi-threaded systems to the _rl_accel C extension module.

Removed reportlab/lib/ para.py & pycanvas.py. These would better belong in third party packages, which can make use of the monkeypatching feature

above.

Add ability to output greyscale and 1-bit PIL images without conversion to RGB. (contributed by Matthew Duggan)

highlight annotation (contributed by Ben Echols)

full compliance with pip, easy_install, wheels etc

Detailed release notes are available at http://www.reportlab.com/software/documentation/relnotes/30

Graphics and Text with pdfgen

Basic Concepts

The pdfgen package is the lowest level interface for generating PDF documents. A pdfgen program is essentially a sequence of instructions for "painting" a

document onto a sequence of pages. The interface object which provides the painting operations is the pdfgen canvas.

The canvas should be thought of as a sheet of white paper with points on the sheet identified using Cartesian (X,Y) coordinates which by default have the

(0,0) origin point at the lower left corner of the page. Furthermore the first coordinate x goes to the right and the second coordinate y goes up, by default.

A simple example program that uses a canvas follows.

from reportlab.pdfgen import canvas

def hello(c):

c.drawString(100,100,"Hello World")

c = canvas.Canvas("hello.pdf")

hello(c)

c.showPage()

c.save()

The above code creates a canvas object which will generate a PDF file named hello.pdf in the current working directory. It then calls the hello function

passing the canvas as an argument. Finally the showPage method saves the current page of the canvas and the save method stores the file and closes the

canvas.

The showPage method causes the canvas to stop drawing on the current page and any further operations will draw on a subsequent page (if there are any

further operations -- if not no new page is created). The save method must be called after the construction of the document is complete -- it generates the PDF

document, which is the whole purpose of the canvas object.

More about the Canvas

Before describing the drawing operations, we will digress to cover some of the things which can be done to configure a canvas. There are many different settings

available. If you are new to Python or can't wait to produce some output, you can skip ahead, but come back later and read this!

First of all, we will look at the constructor arguments for the canvas:

def __init__(self,filename,

pagesize=(595.27,841.89),

bottomup = 1,

pageCompression=0,

encoding=rl_config.defaultEncoding,

verbosity=0

encrypt=None):

The filename argument controls the name of the final PDF file. You may also pass in any open binary stream (such as sys.stdout, the python process

standard output with a binary encoding) and the PDF document will be written to that. Since PDF is a binary format, you should take care when writing other

stuff before or after it; you can't deliver PDF documents inline in the middle of an HTML page!

The pagesize argument is a tuple of two numbers in points (1/72 of an inch). The canvas defaults to A4 (an international standard page size which differs from

the American standard page size of letter), but it is better to explicitly specify it. Most common page sizes are found in the library module

reportlab.lib.pagesizes, so you can use expressions like

from reportlab.lib.pagesizes import letter, A4

myCanvas = Canvas('myfile.pdf', pagesize=letter)

width, height = letter #keep for later

Note - if you have problems printing your document make sure you are using the right page size (usually either A4 or letter). Some printers do not work well

with pages that are too large or too small.

Very often, you will want to calculate things based on the page size. In the example above we extracted the width and height. Later in the program we may use

the width variable to define a right margin as width - inch rather than using a constant. By using variables the margin will still make sense even if the page

size changes.

The bottomup argument switches coordinate systems. Some graphics systems (like PDF and PostScript) place (0,0) at the bottom left of the page others (like

many graphical user interfaces [GUI's]) place the origin at the top left. The bottomup argument is deprecated and may be dropped in future

The pageCompression option determines whether the stream of PDF operations for each page is compressed. By default page streams are not compressed,

because the compression slows the file generation process. If output size is important set pageCompression=1, but remember that, compressed documents

will be smaller, but slower to generate. Note that images are always compressed, and this option will only save space if you have a very large amount of text

and vector graphics on each page.

The encoding argument is largely obsolete in version 2.0 and can probably be omitted by 99% of users. Its default value is fine unless you very specifically

need to use one of the 25 or so characters which are present in MacRoman and not in Winansi. A useful reference to these is here:

http://www.alanwood.net/demos/charsetdiffs.html.

The parameter determines which font encoding is used for the standard Type 1 fonts; this should correspond to the encoding on your system. Note that this is

the encoding used internally by the font; text you pass to the ReportLab toolkit for rendering should always either be a Python unicode string object or a

UTF-8 encoded byte string (see the next chapter)! The font encoding has two values at present: 'WinAnsiEncoding' or 'MacRomanEncoding'. The

variable rl_config.defaultEncoding above points to the former, which is standard on Windows, Mac OS X and many Unices (including Linux). If you are

Mac user and don't have OS X, you may want to make a global change: modify the line at the top of reportlab/pdfbase/pdfdoc.py to switch it over.

Otherwise, you can probably just ignore this argument completely and never pass it. For all TTF and the commonly-used CID fonts, the encoding you pass in

here is ignored, since the reportlab library itself knows the right encodings in those cases.

The demo script reportlab/demos/stdfonts.py will print out two test documents showing all code points in all fonts, so you can look up characters.

Special characters can be inserted into string commands with the usual Python escape sequences; for example \101 = 'A'.

The verbosity argument determines how much log information is printed. By default, it is zero to assist applications which want to capture PDF from standard

output. With a value of 1, you will get a confirmation message each time a document is generated. Higher numbers may give more output in future.

The encrypt argument determines if and how the document is encrypted. By default, the document is not encrypted. If encrypt is a string object, it is used as

the user password for the pdf. If encrypt is an instance of reportlab.lib.pdfencrypt.StandardEncryption, this object is used to encrypt the pdf. This

allows more finegrained control over the encryption settings. Encryption is covered in more detail in Chapter 4.

Drawing Operations

Suppose the hello function referenced above is implemented as follows (we will not explain each of the operations in detail yet).

eg(examples.testhello)

Examining this code notice that there are essentially two types of operations performed using a canvas. The first type draws something on the page such as a text

string or a rectangle or a line. The second type changes the state of the canvas such as changing the current fill or stroke color or changing the current font type

and size.

If we imagine the program as a painter working on the canvas the "draw" operations apply paint to the canvas using the current set of tools (colors, line styles,

fonts, etcetera) and the "state change" operations change one of the current tools (changing the fill color from whatever it was to blue, or changing the current

font to Times-Roman in 15 points, for example).

The document generated by the "hello world" program listed above would contain the following graphics.

About the demos in this document

This document contains demonstrations of the code discussed like the one shown in the rectangle above. These demos are drawn on a "tiny page" embedded

within the real pages of the guide. The tiny pages are %s inches wide and %s inches tall. The demo displays show the actual output of the demo code. For

convenience the size of the output has been reduced slightly. """ % (examplefunctionxinches, examplefunctionyinches))

The tools: the "draw" operations

This section briefly lists the tools available to the program for painting information onto a page using the canvas interface. These will be discussed in detail in later

sections. They are listed here for easy reference and for summary purposes.

Line methods

canvas.line(x1,y1,x2,y2)

canvas.lines(linelist)

The line methods draw straight line segments on the canvas.

Shape methods

canvas.grid(xlist, ylist)

canvas.bezier(x1, y1, x2, y2, x3, y3, x4, y4)

canvas.arc(x1,y1,x2,y2)

canvas.rect(x, y, width, height, stroke=1, fill=0)

canvas.ellipse(x1,y1, x2,y2, stroke=1, fill=0)

canvas.wedge(x1,y1, x2,y2, startAng, extent, stroke=1, fill=0)

canvas.circle(x_cen, y_cen, r, stroke=1, fill=0)

canvas.roundRect(x, y, width, height, radius, stroke=1, fill=0)

The shape methods draw common complex shapes on the canvas.

String drawing methods

canvas.drawString(x, y, text):

canvas.drawRightString(x, y, text)

canvas.drawCentredString(x, y, text)

The draw string methods draw single lines of text on the canvas.

The text object methods

剩余81页未读，继续阅读

评论收藏

内容反馈

who_am_i__

粉丝: 41
资源: 16

Python库reportLab用户手册+API

reportlab（python用户使用说明书）

reportlab-userguide.pdf

python reportlab中文手册

reportlab指南

Python ReportLab文档

reportlab中文手册.pdf

reportlab_python_pdf编程手册.pdf

详尽的reportLab开发手册.pdf

reportlab_userguide_pdf_高清含详细目录

利用python和reportlab在特定size的page上进行排版

Python库 | reportlab-3.5.5-cp34-cp34m-win32.whl

python绘图，采用reportlab工具包

ReportLab PDF Processing with Python 用Python处理PDF

Python库 | reportlab-3.5.48-cp36-cp36m-win32.whl

reportlab英文用户手册

reportlab-api-2022

reportlab-doc

python官方文档

reportlab-2.5（python2.5）

Python使用reportlab模块生成PDF格式的文档

Python库 | reportlab-3.5.32-cp35-cp35m-win_amd64.whl

python使用reportlab实现图片转换成pdf的方法

Python库 | reportlab-3.5.13-cp36-cp36m-win32.whl

Python库 | reportlab-3.5.64-cp39-cp39-manylinux1_x86_64.whl

python使用reportlab画图示例（含中文汉字）

Python库 | reportlab-3.5.63-cp39-cp39-win32.whl

Python库 | reportlab-3.4.0-cp35-cp35m-win32.whl

最新资源