Bottle框架官方文档：快速简单轻量级的WSGI微型Web框架

需积分: 9 45 浏览量更新于2024-07-21 收藏 622KB PDF 举报

"bottle-docs 是一份关于 Bottle 框架的文档，涵盖了从用户指南、知识库到开发和贡献的多个方面，适用于 IT/计算机领域的专业人士。Bottle 是一个快速、简单且轻量级的 Python WSGI 微型Web框架，其特点是作为一个单文件模块，对Python标准库之外没有依赖。文档包括教程、配置、请求路由、模板引擎、部署、API参考、插件列表等，旨在帮助开发者理解和使用Bottle进行Web应用开发。" Bottle 框架是Python世界中的一款微服务框架，它设计简洁，易于上手，且运行高效。主要特性包括： 1. **路由（Routing）**：Bottle 提供了请求到函数调用的映射功能，支持清晰和动态的URL设计。开发者可以通过简单的装饰器将HTTP请求方法（如GET、POST）与处理函数关联起来，实现灵活的路由规则。 2. **模板引擎（Templates）**：内置的模板引擎允许开发者快速生成HTML页面，同时Bottle也支持与其他流行的模板引擎如Mako、Jinja2和Cheetah集成，使得视图层的开发更加便捷和可定制化。 3. **配置（Conﬁguration）**：尽管Bottle本身足够轻量，但文档中提到的配置部分（DRAFT）可能包含了如何设置和管理应用的配置信息，这对于在不同环境或有特定需求的应用来说非常重要。 4. **请求路由（Request Routing）**：这部分详细解释了如何定义和处理HTTP请求，包括URL模式匹配、参数提取以及如何根据请求类型分发到相应的处理函数。 5. **简单部署（Deployment）**：Bottle的部署章节将指导开发者如何将本地开发的应用部署到生产环境，可能包括WSGI服务器的配置、环境变量的设置等。 6. **API参考（API Reference）**：这部分提供了Bottle框架所有核心组件的详细API文档，是开发者日常编码的重要参考资料。 7. **插件系统（Plugins）**：Bottle支持插件扩展，开发者可以利用插件来增强框架的功能，文档中列出了可用的插件以及开发指南，有助于构建更丰富的应用生态。 8. **知识库（Knowledge Base）**：包含了一些教程、示例应用、异步应用的初级介绍以及常见问题解答，帮助开发者深入理解和实践Bottle。 9. **开发与贡献（Development and Contribution）**：这部分面向想要参与Bottle框架开发和维护的社区成员，包含了版本日志、贡献者列表、开发者注意事项和插件开发指南。通过这份详尽的Bottle文档，无论是初学者还是经验丰富的Python开发者，都能找到所需的信息，从而有效地使用Bottle构建自己的Web应用程序。

Bottle Documentation, Release 0.13-dev

def hello():

name = request.cookies.username or ’Guest’

return template(’Hello {{name}}’, name=name)

The request object is a subclass of BaseRequest and has a very rich API to access data. We only cover the most

commonly used features here, but it should be enough to get started.

Introducing FormsDict

Bottle uses a special type of dictionary to store form data and cookies. FormsDict behaves like a normal dictionary,

but has some additional features to make your life easier.

Attribute access: All values in the dictionary are also accessible as attributes. These virtual attributes return unicode

strings, even if the value is missing or unicode decoding fails. In that case, the string is empty, but still present:

name = request.cookies.name

# is a shortcut for:

name = request.cookies.getunicode(’name’) # encoding=’utf-8’ (default)

# which basically does this:

try:

name = request.cookies.get(’name’, ’’).decode(’utf-8’)

except UnicodeError:

name = u’’

Multiple values per key: FormsDict is a subclass of MultiDict and can store more than one value per key. The

standard dictionary access methods will only return a single value, but the getall() method returns a (possibly

empty) list of all values for a speciﬁc key:

for choice in request.forms.getall(’multiple_choice’):

do_something(choice)

WTForms support: Some libraries (e.g. WTForms) want all-unicode dictionaries as input.

FormsDict.decode() does that for you. It decodes all values and returns a copy of itself, while preserv-

ing multiple values per key and all the other features.

Note: In Python 2 all keys and values are byte-strings. If you need unicode, you can call

FormsDict.getunicode() or fetch values via attribute access. Both methods try to decode the string (default:

utf8) and return an empty string if that fails. No need to catch UnicodeError:

>>> request.query[’city’]

’G\xc3\xb6ttingen’ # A utf8 byte string

>>> request.query.city

u’Göttingen’ # The same string as unicode

In Python 3 all strings are unicode, but HTTP is a byte-based wire protocol. The server has to decode the byte

strings somehow before they are passed to the application. To be on the safe side, WSGI suggests ISO-8859-1 (aka

latin1), a reversible single-byte codec that can be re-encoded with a different encoding later. Bottle does that for

FormsDict.getunicode() and attribute access, but not for the dict-access methods. These return the unchanged

values as provided by the server implementation, which is probably not what you want.

>>> request.query[’city’]

’GÃ¶ttingen’ # An utf8 string provisionally decoded as ISO-8859-1 by the server

>>> request.query.city

’Göttingen’ # The same string correctly re-encoded as utf8 by bottle

12 Chapter 1. User’s Guide

Bottle Documentation, Release 0.13-dev

If you need the whole dictionary with correctly decoded values (e.g. for WTForms), you can call

FormsDict.decode() to get a re-encoded copy.

Cookies are small pieces of text stored in the clients browser and sent back to the server with each request. They

are useful to keep some state around for more than one request (HTTP itself is stateless), but should not be used for

security related stuff. They can be easily forged by the client.

All cookies sent by the client are available through BaseRequest.cookies (a FormsDict). This example shows

a simple cookie-based view counter:

from bottle import route, request, response

@route(’/counter’)

def counter():

count = int( request.cookies.get(’counter’, ’0’) )

count += 1

response.set_cookie(’counter’, str(count))

return ’You visited this page %d times’ % count

The BaseRequest.get_cookie() method is a different way do access cookies. It supports decoding signed

cookies as described in a separate section.

HTTP Headers

All HTTP headers sent by the client (e.g. Referer, Agent or Accept-Language) are stored in a

WSGIHeaderDict and accessible through the BaseRequest.headers attribute. A WSGIHeaderDict is ba-

sically a dictionary with case-insensitive keys:

from bottle import route, request

@route(’/is_ajax’)

def is_ajax():

if request.headers.get(’X-Requested-With’) == ’XMLHttpRequest’:

return ’This is an AJAX request’

else:

return ’This is a normal request’

Query Variables

The query string (as in /forum?id=1&page=5) is commonly used to transmit a small number of key/value pairs

to the server. You can use the BaseRequest.query attribute (a FormsDict) to access these values and the

BaseRequest.query_string attribute to get the whole string.

from bottle import route, request, response, template

@route(’/forum’)

def display_forum():

forum_id = request.query.id

page = request.query.page or ’1’

return template(’Forum ID: {{id}} (page {{page}})’, id=forum_id, page=page)

HTML <form> Handling

Let us start from the beginning. In HTML, a typical <form> looks something like this:

1.1. Tutorial 13

Bottle Documentation, Release 0.13-dev

Username: <input name="username" type="text" />

Password: <input name="password" type="password" />

</form>

The action attribute speciﬁes the URL that will receive the form data. method deﬁnes the HTTP method

to use (GET or POST). With method="get" the form values are appended to the URL and available through

BaseRequest.query as described above. This is considered insecure and has other limitations, so we use

method="post" here. If in doubt, use POST forms.

Form ﬁelds transmitted via POST are stored in BaseRequest.forms as a FormsDict. The server side code may

look like this:

from bottle import route, request

@route(’/login’)

def login():

return ’’’

Username: <input name="username" type="text" />

Password: <input name="password" type="password" />

</form>

’’’

@route(’/login’, method=’POST’)

def do_login():

username = request.forms.get(’username’)

password = request.forms.get(’password’)

if check_login(username, password):

return "<p>Your login information was correct.</p>"

else:

return "<p>Login failed.</p>"

There are several other attributes used to access form data. Some of them combine values from different sources for

easier access. The following table should give you a decent overview.

Attribute GET Form ﬁelds POST Form ﬁelds File Uploads

BaseRequest.query yes no no

BaseRequest.forms no yes no

BaseRequest.files no no yes

BaseRequest.params yes yes no

BaseRequest.GET yes no no

BaseRequest.POST no yes yes

File uploads

To support ﬁle uploads, we have to change the <form> tag a bit. First, we tell the browser to encode the form data in

a different way by adding an enctype="multipart/form-data" attribute to the <form> tag. Then, we add

<input type="file" /> tags to allow the user to select a ﬁle. Here is an example:

Category: <input type="text" name="category" />

Select a file: <input type="file" name="upload" />

</form>

14 Chapter 1. User’s Guide

Bottle Documentation, Release 0.13-dev

Bottle stores ﬁle uploads in BaseRequest.files as FileUpload instances, along with some metadata about

the upload. Let us assume you just want to save the ﬁle to disk:

@route(’/upload’, method=’POST’)

def do_upload():

category = request.forms.get(’category’)

upload = request.files.get(’upload’)

name, ext = os.path.splitext(upload.filename)

if ext not in (’.png’,’.jpg’,’.jpeg’):

return ’File extension not allowed.’

save_path = get_save_path_for_category(category)

upload.save(save_path) # appends upload.filename automatically

return ’OK’

FileUpload.filename contains the name of the ﬁle on the clients ﬁle system, but is cleaned up and normalized

to prevent bugs caused by unsupported characters or path segments in the ﬁlename. If you need the unmodiﬁed name

as sent by the client, have a look at FileUpload.raw_filename.

The FileUpload.save method is highly recommended if you want to store the ﬁle to disk. It prevents some

common errors (e.g. it does not overwrite existing ﬁles unless you tell it to) and stores the ﬁle in a memory efﬁcient

way. You can access the ﬁle object directly via FileUpload.file. Just be careful.

JSON Content

Some JavaScript or REST clients send application/json content to the server. The BaseRequest.json

attribute contains the parsed data structure, if available.

The raw request body

You can access the raw body data as a ﬁle-like object via BaseRequest.body. This is a BytesIO buffer or a

temporary ﬁle depending on the content length and BaseRequest.MEMFILE_MAX setting. In both cases the body

is completely buffered before you can access the attribute. If you expect huge amounts of data and want to get direct

unbuffered access to the stream, have a look at request[’wsgi.input’].

WSGI Environment

Each BaseRequest instance wraps a WSGI environment dictionary. The original is stored in

BaseRequest.environ, but the request object itself behaves like a dictionary, too. Most of the interesting data is

exposed through special methods or attributes, but if you want to access WSGI environ variables directly, you can do

so:

@route(’/my_ip’)

def show_ip():

ip = request.environ.get(’REMOTE_ADDR’)

# or ip = request.get(’REMOTE_ADDR’)

# or ip = request[’REMOTE_ADDR’]

return template("Your IP is: {{ip}}", ip=ip)

1.1.6 Templates

Bottle comes with a fast and powerful built-in template engine called SimpleTemplate Engine. To render a template

you can use the template() function or the view() decorator. All you have to do is to provide the name of the

1.1. Tutorial 15

Bottle Documentation, Release 0.13-dev

template and the variables you want to pass to the template as keyword arguments. Here’s a simple example of how to

render a template:

@route(’/hello’)

@route(’/hello/<name>’)

def hello(name=’World’):

return template(’hello_template’, name=name)

This will load the template ﬁle hello_template.tpl and render it with the name variable set. Bottle will look

for templates in the ./views/ folder or any folder speciﬁed in the bottle.TEMPLATE_PATH list.

The view() decorator allows you to return a dictionary with the template variables instead of calling template():

@route(’/hello’)

@route(’/hello/<name>’)

@view(’hello_template’)

def hello(name=’World’):

return dict(name=name)

Syntax

The template syntax is a very thin layer around the Python language. Its main purpose is to ensure correct indentation

of blocks, so you can format your template without worrying about indentation. Follow the link for a full syntax

description: SimpleTemplate Engine

Here is an example template:

%if name == ’World’:

<h1>Hello {{name}}!</h1>

%else:

<h1>Hello {{name.title()}}!</h1>

%end

Caching

Templates are cached in memory after compilation. Modiﬁcations made to the template ﬁles will have no affect until

you clear the template cache. Call bottle.TEMPLATES.clear() to do so. Caching is disabled in debug mode.

1.1.7 Plugins

New in version 0.9.

Bottle’s core features cover most common use-cases, but as a micro-framework it has its limits. This is where “Plugins”

come into play. Plugins add missing functionality to the framework, integrate third party libraries, or just automate

some repetitive work.

We have a growing List of available Plugins and most plugins are designed to be portable and re-usable across appli-

cations. The chances are high that your problem has already been solved and a ready-to-use plugin exists. If not, the

Plugin Development Guide may help you.

The effects and APIs of plugins are manifold and depend on the speciﬁc plugin. The SQLitePlugin plugin for

example detects callbacks that require a db keyword argument and creates a fresh database connection object every

time the callback is called. This makes it very convenient to use a database:

16 Chapter 1. User’s Guide

剩余100页未读，继续阅读

挨踢网管

粉丝: 8
资源: 11

Bottle框架官方文档：快速简单轻量级的WSGI微型Web框架

Python库bottle-marshmallow-1.0.2安装与使用教程

Bottle框架用户会话实现指南：bottle-login使用教程

Bottle框架详解与应用指南

python bottle-docs

PyPI 官网下载 | bottle-neck-1.14.tar.gz

pytorch_API_docs.zip

nsdp-platform

hikari-no-kobin：光の小びん

PyPI 官网下载 | pcottlepipexample-0.0.4.tar.gz

Bottle框架的第三方插件汇总及其开发指南

最新资源