Bottle：轻量级Python微Web框架，单一文件设计

bottle

需积分: 10 90 浏览量更新于2024-07-20 收藏 445KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

Bottle是一款轻量级的Python Web开发框架，以其简洁和高效著称。它被设计为单文件模块，这使得其安装和集成过程非常简单，仅依赖于标准Python库，无需额外安装其他第三方库。它的核心功能包括： 1. **路由机制**：Bottle提供了一种灵活的请求路由系统，允许开发者根据函数定义将URL映射到相应的处理程序。它支持干净且动态的URL设计，使得路由清晰易读。 2. **模板引擎**：框架内置了一个快速且Python风格的模板引擎，支持Mako、Jinja2和Chameleon等流行的模板语言，使得开发者可以方便地构建用户界面，实现视图与数据的分离。 3. **工具集**：除了基础的路由和模板，Bottle还提供了一系列实用工具，如便利的访问控制和数据处理功能，有助于简化日常开发工作流程。 4. **部署与扩展**：文档中提到的"Deployment"部分可能涵盖了部署指南，帮助开发者在各种环境中（如服务器、容器或微服务架构）部署应用。同时，"List of available Plugins"表明框架支持插件系统，开发者可以通过第三方插件来增强框架的功能。 5. **学习资源**：文档包含了丰富的教程，如Todo-List Application示例，帮助初学者快速上手。此外，还有介绍如何构建异步应用的教程，以及解决问题的常见问题解答，对开发者的学习和实践非常有帮助。 6. **开发与贡献**：对于开发者来说，文档提供了详细的开发指南，包括版本历史、贡献者名单、开发者笔记和插件开发教程。此外，文档还给出了联系方式，以便社区成员交流和报告问题。 7. **版权与授权**：最后，文档结尾处列出了许可证信息，确保了框架的开源性质和使用规范。 Bottle凭借其小巧的体积和强大的功能，适合快速搭建原型或小型项目，同时也为扩展和定制提供了足够的灵活性。无论你是Python新手还是经验丰富的开发者，Bottle都能为你提供一个高效、简洁的Web开发平台。

资源详情

资源推荐

Bottle Documentation, Release 0.13-dev

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

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.

12 Chapter 1. User’s Guide

Bottle Documentation, Release 0.13-dev

>>> 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.

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)

1.1. Tutorial 13

Bottle Documentation, Release 0.13-dev

HTML <form> Handling

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

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:

14 Chapter 1. User’s Guide

Bottle Documentation, Release 0.13-dev

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:

@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. Tutorial 15

Bottle Documentation, Release 0.13-dev

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

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.

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.

16 Chapter 1. User’s Guide

剩余102页未读，继续阅读

vopfly

粉丝: 4
资源: 41

Bottle：轻量级Python微Web框架，单一文件设计

Cylindrical Medicine Bottle's Character Recognition

nanomorph ：:-实际DOM节点的超快速扩散算法

yolov5 bottleneck

深度学习 Bottleneck layer / Bottleneck feature

Bottleneck Transformer Block

pandas与bottleneck

resnet50的bottleneck

yolov8Bottleneck模块

No module named 'bottle'

yolov8中Bottleneck块

bottle框架的使用

conda安装bottleneck

Bottle 设置模版目录

bottleneck的作用

Bottleneck Transformer替换C3

yolov8 bottleneck

那bottle如何使用

bottleneck transformer的优势

最新资源