Bottle框架详解：微型Web开发利器

需积分: 35 120 浏览量更新于2024-07-30 收藏 549KB PDF 举报

"Bottle Web框架是Python的一种轻量级、快速且简单的WSGI微型Web框架。它以单个文件模块的形式发布，除了Python标准库外没有其他依赖项。该框架提供请求到函数调用的映射（路由）、内置模板引擎以及对Mako、Jinja2和Cheetah模板的支持，并提供了方便的工具来处理表单数据、文件上传、cookie、头部和其他HTTP相关的元数据。" Bottle框架的核心特性包括： 1. **用户指南**： - **教程**：Bottle提供了一个逐步指导，帮助开发者快速上手，创建简单的Web应用。 - **请求路由**：Bottle允许开发者通过简单的定义URL模式来映射HTTP请求到相应的处理函数，支持动态URL，使得URL结构更加清晰。 - **简单模板引擎**：Bottle内建了一个快速、符合Python语法的模板引擎，使页面渲染更为简便。 - **API参考**：详尽的API文档提供了关于框架功能的详细说明。 - **插件**：Bottle支持一系列插件，以扩展其功能，如日志记录、缓存管理等。 2. **知识库**： - **教程：待办事项应用**：通过一个实际的待办事项应用教程，展示如何使用Bottle构建简单的Web应用。 - **异步应用程序**：Bottle也支持异步编程，使开发者能够处理高并发场景。 - **食谱**：包含了各种使用Bottle解决特定问题的方法或示例。 - **常见问题**：解答了在使用Bottle过程中可能遇到的问题，帮助开发者解决问题。 3. **开发与贡献**： - **发布说明和变更日志**：记录了每个版本的更新和改进，帮助开发者跟踪框架的发展。 - **开发者笔记**：提供了给开发者的指引，如何参与到Bottle的开发和贡献中。 - **插件开发指南**：为想要开发Bottle插件的开发者提供了详细的指导。 4. **许可证**：Bottle遵循特定的开源许可证，允许自由使用、修改和分发。此外，Bottle的轻量级特性使其适合小型项目或者作为大型应用的一部分。其简洁的设计使得代码易于理解和维护，而其全面的API和丰富的插件生态系统则提供了强大的扩展性。开发者可以利用Bottle轻松地构建RESTful API、静态文件服务器或完整的Web应用。通过Bottle，你可以快速原型设计，然后随着需求的增长逐渐添加复杂性。无论你是初学者还是经验丰富的Python开发者，Bottle都是一个值得考虑的Web开发工具。

Bottle Documentation, Release 0.11.dev

Response Header

Response headers such as Cache-Control or Location are deﬁned via Response.set_header(). This

method takes two parameters, a header name and a value. The name part is case-insensitive:

@route(’/wiki/<page>’)

def wiki(page):

response.set_header(’Content-Language’, ’en’)

...

Most headers are exclusive, meaning that only one header per name is send to the client. Some special

headers however are allowed to appear more than once in a response. To add an additional header, use

Response.add_header() instead of Response.set_header():

response.set_header(’Set-Cookie’, ’name=value’)

response.add_header(’Set-Cookie’, ’name2=value2’)

Please not that this is just an example. If you want to work with cookies, read ahead.

A cookie is a named piece of text stored in the user’s browser cache. You can access previously deﬁned cookies

via Request.get_cookie() and set new cookies with Response.set_cookie():

@route(’/hello’)

def hello_again(self):

if request.get_cookie("visited"):

return "Welcome back! Nice to see you again"

else:

response.set_cookie("visited", "yes")

return "Hello there! Nice to meet you"

The Response.set_cookie() method accepts a number of additional keyword arguments that control the

cookies lifetime and behavior. Some of the most common settings are described here:

• max_age: Maximum age in seconds. (default: None)

• expires: A datetime object or UNIX timestamp. (default: None)

• domain: The domain that is allowed to read the cookie. (default: current domain)

• path: Limit the cookie to a given path (default: /)

• secure: Limit the cookie to HTTPS connections (default: off).

• httponly: Prevent client-side javascript to read this cookie (default: off, requires Python 2.6 or newer).

If neither expires nor max_age is set, the cookie expires at the end of the browser session or as soon as the browser

window is closed. There are some other gotchas you should consider when using cookies:

• Cookies are limited to 4kb of text in most browsers.

• Some users conﬁgure their browsers to not accept cookies at all. Most search-engines ignore cookies, too.

Make sure that your application still works without cookies.

• Cookies are stored at client side and not encrypted in any way. Whatever you store in a cookie, the user can

read it. Worth than that, an attacker might be able to steal a user’s cookies through XSS vulnerabilities on

your side. Some viruses are known to read the browser cookies, too. Do not store conﬁdential information

in cookies, ever.

• Cookies are easily forged by malicious clients. Do not trust cookies.

10 Chapter 1. User’s Guide

Bottle Documentation, Release 0.11.dev

Signed Cookies

As mentioned above, cookies are easily forged by malicious clients. Bottle can cryptographically sign your cookies

to prevent this kind of manipulation. All you have to do is to provide a signature key via the secret keyword

argument whenever you read or set a cookie and keep that key a secret. As a result, Request.get_cookie()

will return None if the cookie is not signed or the signature keys don’t match:

@route(’/login’)

def login():

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

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

if check_user_credentials(username, password):

response.set_cookie("account", username, secret=’some-secret-key’)

return "Welcome %s! You are now logged in." % username

else:

return "Login failed."

@route(’/restricted’)

def restricted_area(self):

username = request.get_cookie("account", secret=’some-secret-key’)

if username:

return "Hello %s. Welcome back." % username

else:

return "You are not logged in. Access denied."

In addition, Bottle automatically pickles and unpickles any data stored to signed cookies. This allows you to store

any pickle-able object (not only strings) to cookies, as long as the pickled data does not exceed the 4kb limit.

Warning: Signed cookies are not encrypted (the client can still see the content) and not copy-protected (the

client can restore an old cookie). The main intention is to make pickling and unpickling safe and prevent

manipulation, not to store secret information at client side.

1.1.5 Request Data

Bottle provides access to HTTP related meta-data such as cookies, headers and POST form data through a global

request object. This object always contains information about the current request, as long as it is accessed from

within a callback function. This works even in multi-threaded environments where multiple requests are handled

at the same time. For details on how a global object can be thread-safe, see contextlocal.

Note: Bottle stores most of the parsed HTTP meta-data in FormsDict instances. These behave like normal

dictionaries, but have some additional features: All values in the dictionary are available as attributes. These

virtual attributes always return a unicode string, even if the value is missing. In that case, the string is empty.

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 MultiDict.getall() method returns a (possibly

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

The full API and feature list is described in the API section (see Request), but the most common use cases and

features are covered here, too.

Cookies are stored in BaseRequest.cookies as a FormsDict. The BaseRequest.get_cookie()

method allows access to signed cookies as described in a separate section. This example shows a simple cookie-

based view counter:

1.1. Tutorial 11

Bottle Documentation, Release 0.11.dev

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

HTTP Headers

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

WSGIHeaderDict and accessible through BaseRequest.headers. A WSGIHeaderDict is basically

a dictionary with case-insensitive keys:

from bottle import route, request

@route(’/is_ajax’)

def is_ajax():

if request.header.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 (a FormsDict) to access these values and the

BaseRequest.query_string attribute to get the whole string.

from bottle import route, request, response

@route(’/forum’)

def display_forum():

forum_id = request.query.id

page = request.query.page or ’1’

return ’Forum ID: %s (page %s)’ % (forum_id, page)

POST Form Data and File Uploads

The request body of POST and PUT requests may contain form data encoded in various formats. The

BaseRequest.forms dictionary contains parsed textual form ﬁelds, BaseRequest.files stores ﬁle up-

loads and BaseRequest.POST combines both dictionaries into one. All three are FormsDict instances and

created on demand. File uploads are saved as special cgi.FieldStorage objects along with some meta-data.

Finally, you can access the raw body data as a ﬁle-like object via BaseRequest.body.

Here is an example for a simple ﬁle upload form:

</form>

from bottle import route, request

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

def do_upload():

name = request.forms.name

data = request.files.data

if name and data and data.file:

raw = data.file.read() # This is dangerous for big files

filename = data.filename

12 Chapter 1. User’s Guide

Bottle Documentation, Release 0.11.dev

return "Hello %s! You uploaded %s (%d bytes)." % (name, filename, len(raw))

return "You missed a field."

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 "Your IP is: %s" % 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 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

1.1. Tutorial 13

剩余84页未读，继续阅读

zmule

粉丝: 5
资源: 1

Bottle框架详解：微型Web开发利器

python bottle v0.11中文文档

Python的Bottle框架中实现最基本的get和post的方法的教程

python框架bottle使用文档

bottle-api:在Bottle Web框架开发上构建WebAPI的有用装饰器

bottle-cork：Bottle和Flask Web框架的身份验证模块

appengine-bottle-example:使用 Bottle Python Web 框架快速引导 Google App Engine 项目的示例

简单介绍Python的轻便web框架Bottle

Python轻量级web框架bottle使用方法解析

bottle:一个学习型的web框架，自带

Python中最简单的Bottle框架构建的Web网站

最新资源