Bottle框架详解：微型Python Web开发指南

需积分: 19 33 浏览量更新于2024-07-18 收藏 447KB PDF 举报

"Bottle是一个基于Python的微型Web框架，它以简单高效著称，并且遵循WSGI标准。这个框架的特点是代码量小，只有一个文件，且不依赖任何第三方模块，只依赖Python标准库。Bottle提供了请求路由、模板引擎、配置管理等核心功能，适合快速开发小型Web应用。其官方文档包含了用户指南、知识库、开发与贡献指南以及许可证信息，覆盖了从入门教程到高级特性的详细内容，还支持一些常见的模板引擎如Mako、Jinja2和Cheetah。" Bottle框架的核心知识点包括： 1. **请求路由(Request Routing)**：Bottle通过简单的规则将HTTP请求映射到相应的处理函数，允许创建动态和清晰的URL。你可以定义URL模式，并指定当这些模式匹配时执行的函数。 2. **内置模板引擎(SimpleTemplateEngine)**：Bottle自带一个快速且符合Python语法的模板引擎，用于生成动态HTML或其他文本输出。此外，它还支持与其他流行的模板引擎如Mako、Jinja2和Cheetah的集成，使得视图渲染更为灵活。 3. **配置管理(Conﬁguration)**：虽然Bottle框架本身非常轻量，但依然提供了配置管理功能，允许开发者根据项目需求调整框架的行为。 4. **部署(Deployment)**：Bottle的文档中详细介绍了如何将应用部署到不同的服务器环境，如本地开发环境、生产服务器或云服务。 5. **API参考(API Reference)**：提供了框架所有功能的详细接口说明，帮助开发者了解并使用Bottle提供的各种工具和类。 6. **插件系统(Plugins)**：Bottle支持插件扩展，开发者可以利用插件来增强框架的功能，例如日志记录、会话管理、身份验证等。 7. **异步应用(Asynchronous Applications)**：Bottle虽然主要是为同步应用设计的，但文档中也介绍了一些关于构建异步应用的基础知识。 8. **知识库(Knowledge Base)**：包含了实用的教程、示例应用、常见问题解答和各种编程技巧，有助于开发者解决实际开发中的问题。 9. **开发与贡献指南(Development and Contribution)**：对于希望参与Bottle框架开发或者贡献代码的开发者，这部分提供了版本控制、变更日志、开发者笔记和插件开发指南等信息。 10. **许可证(License)**：Bottle框架使用特定的开源许可证，通常允许自由使用、修改和分发代码，具体条款需要查看文档的许可证部分。通过深入学习Bottle的文档，开发者可以快速上手并利用其强大的功能构建自己的Web应用，无论是简单的个人项目还是复杂的业务系统。Bottle的简洁性和灵活性使其成为Python Web开发领域中的一个优秀选择。

Bottle Documentation, Release 0.13-dev

Request Data

Cookies, HTTP header, HTML <form> ﬁelds and other request data is available through the global request object.

This special object always refers to the current request, even in multi-threaded environments where multiple client

connections are handled at the same time:

from bottle import request, route, template

@route('/hello')

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

12 Chapter 1. User’s Guide

Bottle Documentation, Release 0.13-dev

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

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.

1.1. Tutorial 13

Bottle Documentation, Release 0.13-dev

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>

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:

1.1. Tutorial 15

剩余102页未读，继续阅读

github_37320188

粉丝: 23
资源: 6

Bottle框架详解：微型Python Web开发指南

bottle文档PDF

bottle文档

bottle-docs

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

pytorch_API_docs.zip

Python web如何在IIS发布应用过程解析

nsdp-platform

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

Bottle框架详解与应用指南

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

最新资源