除了序列的操作函数，比如len()来求字符串长度之外，Python还为字符串提供丰富到可以写个编辑器的API.
首先，下面的查找API都是为了查找位置，或者查一共有几次这样的操作。
如果只是想判断一个字符串是不是另一个字符串的子串的话，使用序列的in运算符就可以了。
例：
原型：str.count(sub[, start[, end]])
字符串的count函数可以数出来有多少次匹配，我们看个例子，有5个ha和3个hei
输出为5和2.
haha只能匹配两次。
再加上扩展参数：
find函数的行为是，如果能找到，则返回在序列中的坐标，如果找不到，则返回-1. rfind是从右向左查找。我们来看例子：
输出值为0和6.
找不到的例子：
输出值都是-1.
完整形式：
index和rindex的功能与find和rfind基本上一致，除了在找不到时会抛出ValueError异常而不是返回-1.
例：
所以我们需要加try...except语句来处理之：
有时候，我们希望做从头匹配或者匹配尾部。这时候就要用到startswith函数和endswith函数。例：
这两个返回值均为True.
如果需要更复杂的匹配，还是需要正则表达式。与Java等语言不同，Python中的正则表达式有专门的模块，字符串的API不负责这个事情。
使用 Python 和 Flask 设计 RESTful API
近些年来 REST (REpresentational State Transfer) 已经变成了 web services 和 web APIs 的标配。
在本文中我将向你展示如何简单地使用 Python 和 Flask 框架来创建一个 RESTful 的 web service。
什么是 REST？
六条设计规范定义了一个 REST 系统的特点:
客户端-服务器: 客户端和服务器之间隔离，服务器提供服务，客户端进行消费。
无状态: 从客户端到服务器的每个请求都必须包含理解请求所必需的信息。换句话说， 服务器不会存储客户端上一次请求的信息用来给下一次使用。
可缓存: 服务器必须明示客户端请求能否缓存。
分层系统: 客户端和服务器之间的通信应该以一种标准的方式，就是中间层代替服务器做出响应的时候，客户端不需要做任何变动。
统一的接口: 服务器和客户端的通信方法必须是统一的。
按需编码: 服务器可以提供可执行代码或脚本，为客户端在它们的环境中执行。这个约束是唯一一个是可选的。
什么是一个 RESTful 的 web service？
REST 架构的最初目的是适应万维网的 HTTP 协议。
RESTful web services 概念的核心就是“资源”。 资源可以用 URI 来表示。客户端使用 HTTP 协议定义的方法来发送请求到这些 URIs，当然可能会导致这些被访问的”资源“状态的改变。
HTTP 标准的方法有如下:
========== ===================== ==================================HTTP 方法 行为 示例
========== ===================== ==================================
GET 获取资源的信息 http://example.com/api/orders
GET 获取某个特定资源的信息 http://example.com/api/orders/123
POST 创建新资源 http://example.com/api/orders
PUT 更新资源 http://example.com/api/orders/123
DELETE 删除资源 http://example.com/api/orders/123
========== ====================== ==================================
REST 设计不需要特定的数据格式。在请求中数据可以以 JSON 形式, 或者有时候作为 url 中查询参数项。
设计一个简单的 web service
坚持 REST 的准则设计一个 web service 或者 API 的任务就变成一个标识资源被展示出来以及它们是怎样受不同的请求方法影响的练习。
比如说，我们要编写一个待办事项应用程序而且我们想要为它设计一个 web service。要做的第一件事情就是决定用什么样的根 URL 来访问该服务。例如，我们可以通过这个来访问:
http://[hostname]/todo/api/v1.0/
在这里我已经决定在 URL 中包含应用的名称以及 API 的版本号。在 URL 中包含应用名称有助于提供一个命名空间以便区分同一系统上的其它服务。在 URL 中包含版本号能够帮助以后的更新，如果新版本中存在新的和潜在不兼容的功能，可以不影响依赖于较旧的功能的应用程序。
下一步骤就是选择将由该服务暴露(展示)的资源。这是一个十分简单地应用，我们只有任务，因此在我们待办事项中唯一的资源就是任务。
我们的任务资源将要使用 HTTP 方法如下:
========== =============================================== =============================HTTP 方法 URL 动作
========== =============================================== ==============================
GET http://[hostname]/todo/api/v1.0/tasks 检索任务列表
GET http://[hostname]/todo/api/v1.0/tasks/[task_id] 检索某个任务
POST http://[hostname]/todo/api/v1.0/tasks 创建新任务
PUT http://[hostname]/todo/api/v1.0/tasks/[task_id] 更新任务
DELETE http://[hostname]/todo/api/v1.0/tasks/[task_id] 删除任务
========== ================================================ =============================
我们定义的任务有如下一些属性:
id: 任务的唯一标识符。数字类型。
title: 简短的任务描述。字符串类型。
description: 具体的任务描述。文本类型。
done: 任务完成的状态。布尔值。
目前为止关于我们的 web service 的设计基本完成。剩下的事情就是实现它！
Flask 框架的简介
如果你读过 Flask Mega-Tutorial 系列，就会知道 Flask 是一个简单却十分强大的 Python web 框架。
在我们深入研究 web services 的细节之前，让我们回顾一下一个普通的 Flask Web 应用程序的结构。
我会首先假设你知道 Python 在你的平台上工作的基本知识。 我将讲解的例子是工作在一个类 Unix 操作系统。简而言之，这意味着它们能工作在 Linux，Mac OS X 和 Windows(如果你使用Cygwin)。 如果你使用 Windows 上原生的 Python 版本的话，命令会有所不同。
让我们开始在一个虚拟环境上安装 Flask。如果你的系统上没有 virtualenv，你可以从https://pypi.python.org/pypi/virtualenv 上下载:
$ mkdir todo-api$ cd todo-api
$ virtualenv flask
New python executable in flask/bin/python
Installing setuptools............................done.
Installing pip...................done.
$ flask/bin/pip install flask
既然已经安装了 Flask，现在开始创建一个简单地网页应用，我们把它放在一个叫 app.py 的文件中:
#!flask/bin/pythonfrom flask import Flaskapp = Flask(__name__)@app.route('/')def index():return "Hello, World!"if __name__ == '__main__':
app.run(debug=True)
为了运行这个程序我们必须执行 app.py:
$ chmod a+x app.py$ ./app.py
* Running on http://127.0.0.1:5000/
* Restarting with reloader
现在你可以启动你的网页浏览器，输入 http://localhost:5000 看看这个小应用程序的效果。
简单吧？现在我们将这个应用程序转换成我们的 RESTful service！
使用 Python 和 Flask 实现 RESTful services
使用 Flask 构建 web services 是十分简单地，比我在 Mega-Tutorial 中构建的完整的服务端的应用程序要简单地多。
在 Flask 中有许多扩展来帮助我们构建 RESTful services，但是在我看来这个任务十分简单，没有必要使用 Flask 扩展。
我们 web service 的客户端需要添加、删除以及修改任务的服务，因此显然我们需要一种方式来存储任务。最直接的方式就是建立一个小型的数据库，但是数据库并不是本文的主体。学习在 Flask 中使用合适的数据库，我强烈建议阅读 Mega-Tutorial。
这里我们直接把任务列表存储在内存中，因此这些任务列表只会在 web 服务器运行中工作，在结束的时候就失效。 这种方式只是适用我们自己开发的 web 服务器，不适用于生产环境的 web 服务器， 这种情况一个合适的数据库的搭建是必须的。
我们现在来实现 web service 的第一个入口:
#!flask/bin/pythonfrom flask import Flask, jsonifyapp = Flask(__name__)tasks = [{
'id': 1,
'title': u'Buy groceries',
'description': u'Milk, Cheese, Pizza, Fruit, Tylenol',
'done': False
},
{
'id': 2,
'title': u'Learn Python',
'description': u'Need to find a good Python tutorial on the web',
'done': False
}]@app.route('/todo/api/v1.0/tasks', methods=['GET'])def get_tasks():
return jsonify({'tasks': tasks})if __name__ == '__main__':
app.run(debug=True)
正如你所见，没有多大的变化。我们创建一个任务的内存数据库，这里无非就是一个字典和数组。数组中的每一个元素都具有上述定义的任务的属性。
取代了首页，我们现在拥有一个 get_tasks 的函数，访问的 URI 为 /todo/api/v1.0/tasks，并且只允许 GET 的 HTTP 方法。
这个函数的响应不是文本，我们使用 JSON 数据格式来响应，Flask 的 jsonify 函数从我们的数据结构中生成。
使用网页浏览器来测试我们的 web service 不是一个最好的注意，因为网页浏览器上不能轻易地模拟所有的 HTTP 请求的方法。相反，我们会使用 curl。如果你还没有安装 curl 的话，请立即安装它。
通过执行 app.py，启动 web service。接着打开一个新的控制台窗口，运行以下命令:
$ curl -i http://localhost:5000/todo/api/v1.0/tasksHTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 294
Server: Werkzeug/0.8.3 Python/2.7.3
Date: Mon, 20 May 2013 04:53:53 GMT
{
"tasks": [
{
"description": "Milk, Cheese, Pizza, Fruit, Tylenol",
"done": false,
"id": 1,
"title": "Buy groceries"
},
{
"description": "Need to find a good Python tutorial on the web",
"done": false,
"id": 2,
"title": "Learn Python"
}
]
}
我们已经成功地调用我们的 RESTful service 的一个函数！
现在我们开始编写 GET 方法请求我们的任务资源的第二个版本。这是一个用来返回单独一个任务的函数:
from flask import [email protected]('/todo/api/v1.0/tasks/<int:task_id>', methods=['GET'])def get_task(task_id):task = filter(lambda t: t['id'] == task_id, tasks)
if len(task) == 0:
abort(404)
return jsonify({'task': task[0]})
第二个函数有些意思。这里我们得到了 URL 中任务的 id，接着 Flask 把它转换成 函数中的 task_id 的参数。
我们用这个参数来搜索我们的任务数组。如果我们的数据库中不存在搜索的 id，我们将会返回一个类似 404 的错误，根据 HTTP 规范的意思是 “资源未找到”。
如果我们找到相应的任务，那么我们只需将它用 jsonify 打包成 JSON 格式并将其发送作为响应，就像我们以前那样处理整个任务集合。
调用 curl 请求的结果如下:
$ curl -i http://localhost:5000/todo/api/v1.0/tasks/2HTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 151
Server: Werkzeug/0.8.3 Python/2.7.3
Date: Mon, 20 May 2013 05:21:50 GMT
{
"task": {
"description": "Need to find a good Python tutorial on the web",
"done": false,
"id": 2,
"title": "Learn Python"
}
}
$ curl -i http://localhost:5000/todo/api/v1.0/tasks/3
HTTP/1.0 404 NOT FOUND
Content-Type: text/html
Content-Length: 238
Server: Werkzeug/0.8.3 Python/2.7.3
Date: Mon, 20 May 2013 05:21:52 GMT
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<title>404 Not Found</title>
<h1>Not Found</h1>
<p>The requested URL was not found on the server.</p><p>If you entered the URL manually please check your spelling and try again.</p>
当我们请求 id #2 的资源时候，我们获取到了，但是当我们请求 #3 的时候返回了 404 错误。有关错误奇怪的是返回的是 HTML 信息而不是 JSON，这是因为 Flask 按照默认方式生成 404 响应。由于这是一个 Web service 客户端希望我们总是以 JSON 格式回应，所以我们需要改善我们的 404 错误处理程序:
from flask import [email protected](404)def not_found(error):return make_response(jsonify({'error': 'Not found'}), 404)
我们会得到一个友好的错误提示:
$ curl -i http://localhost:5000/todo/api/v1.0/tasks/3HTTP/1.0 404 NOT FOUND
Content-Type: application/json
Content-Length: 26
Server: Werkzeug/0.8.3 Python/2.7.3
Date: Mon, 20 May 2013 05:36:54 GMT
{
"error": "Not found"
}
接下来就是 POST 方法，我们用来在我们的任务数据库中插入一个新的任务:
from flask import [email protected]('/todo/api/v1.0/tasks', methods=['POST'])def create_task():if not request.json or not 'title' in request.json:
abort(400)
task = {
'id': tasks[-1]['id'] + 1,
'title': request.json['title'],
'description': request.json.get('description', ""),
'done': False
}
tasks.append(task)
return jsonify({'task': task}), 201
添加一个新的任务也是相当容易地。只有当请求以 JSON 格式形式，request.json 才会有请求的数据。如果没有数据，或者存在数据但是缺少 title 项，我们将会返回 400，这是表示请求无效。
接着我们会创建一个新的任务字典，使用最后一个任务的 id + 1 作为该任务的 id。我们允许 description 字段缺失，并且假设 done 字段设置成 False。
我们把新的任务添加到我们的任务数组中，并且把新添加的任务和状态 201 响应给客户端。
使用如下的 curl 命令来测试这个新的函数:
$ curl -i -H "Content-Type: application/json" -X POST -d '{"title":"Read a book"}' http://localhost:5000/todo/api/v1.0/tasksHTTP/1.0 201 Created
Content-Type: application/json
Content-Length: 104
Server: Werkzeug/0.8.3 Python/2.7.3
Date: Mon, 20 May 2013 05:56:21 GMT
{
"task": {
"description": "",
"done": false,
"id": 3,
"title": "Read a book"
}
}
注意：如果你在 Windows 上并且运行 Cygwin 版本的 curl，上面的命令不会有任何问题。然而，如果你使用原生的 curl，命令会有些不同:
curl -i -H "Content-Type: application/json" -X POST -d "{"""title""":"""Read a book"""}" http://localhost:5000/todo/api/v1.0/tasks当然在完成这个请求后，我们可以得到任务的更新列表:
$ curl -i http://localhost:5000/todo/api/v1.0/tasksHTTP/1.0 200 OK
Content-Type: application/json
Content-Length: 423
Server: Werkzeug/0.8.3 Python/2.7.3
Date: Mon, 20 May 2013 05:57:44 GMT
{
"tasks": [
{
"description": "Milk, Cheese, Pizza, Fruit, Tylenol",
"done": false,
"id": 1,
"title": "Buy groceries"
},
{
"description": "Need to find a good Python tutorial on the web",
"done": false,
"id": 2,
"title": "Learn Python"
},
{
"description": "",
"done": false,
"id": 3,
"title": "Read a book"
}
]
}
剩下的两个函数如下所示:
@app.route('/todo/api/v1.0/tasks/<int:task_id>', methods=['PUT'])def update_task(task_id):task = filter(lambda t: t['id'] == task_id, tasks)
if len(task) == 0:
abort(404)
if not request.json:
abort(400)
if 'title' in request.json and type(request.json['title']) != unicode:
abort(400)
if 'description' in request.json and type(request.json['description']) is not unicode:
abort(400)
一：用C API为Python写C语言函数，以方便Python中调用1. 首先实现一个特定原型的函数，用Python C API来实现的话，所有函数必须是这种原型。必须是类似这样的
PyObject *Fun(PyObject *self, PyObject *args)
self应该是在用类的时候才会用到（我没有用到），args就是函数的参数。因为args是一个PyObject*类型（可以代表Python语言中的任何类型）
2. 将参数转换成C 语言表示的内容，用PyArg_ParseTuple函数。
3. 执行完需要的操作后，也必须返回一个PyObject*类型的值。通过Py_BuildValue函数来构建。
这里要说的是，假如希望返回一个Tuple类型的值，可以先用
PyObject *tuple = Py_BuildValue("(iis)", 1, 2, "three")
形式来构建，假如很多的话，可以用下面的方式来构建
PyObject *t
t = PyTuple_New(3)
PyTuple_SetItem(t, 0, PyLong_FromLong(1L))
PyTuple_SetItem(t, 1, PyLong_FromLong(2L))
PyTuple_SetItem(t, 2, PyString_FromString("three"))
这一点在刚开始开工的时候迷惑了很久。
4. 将要输出的所有函数放入一个数组中，数组的结构是：
struct PyMethodDef {
const char*ml_name /* The name of the built-in function/method */
PyCFunction ml_meth /* The C function that implements it */
int ml_flags/* Combination of METH_xxx flags, which mostly
describe the args expected by the C func */
const char*ml_doc /* The __doc__ attribute, or NULL */
}
数组以{NULL, NULL}结束
5. 构造一个Python import时初始化的函数
类似
PyMODINIT_FUNC
initexample(void)
{
Py_InitModule("example", example_methods)
}
这里有个特别需要注意的是，初始化函数名字有严格要求，init后面必须跟模块名，否则Python找不到确定的函数会报没有初始化函数的错误
扩展模块写完后，编译成动态库（Python要求此动态库名字为pyd,实际就是改个后缀而已）。就可以直接在Python脚本中用import的方式加载了，对于使用来说，根本不需要知道此库是用C API扩展写的还是直接用Python语句写的（这点Lua做的也是一样好）
最后，python的源代码中附带了一个叫做example_nt的例子，可以参考一样，完整的扩展代码如下：
#include "Python.h"
static PyObject *
ex_foo(PyObject *self, PyObject *args)
{
printf("Hello, world/n")
Py_INCREF(Py_None)
return Py_None
}
static PyMethodDef example_methods[] = {
{"foo", ex_foo, METH_VARARGS, "foo() doc string"},
{NULL, NULL}
}
PyMODINIT_FUNC
initexample(void)
{
Py_InitModule("example", example_methods)
}
二．C语言中调用Python语句
首先，void Py_Initialize()用来初始化，void Py_Finalize()用来结束Python的调用，这是必须要的。
燃火分两种情况，假如仅仅是几条语句的话，那么以PyRun_为前缀的一些函数都很好用，比如
int PyRun_SimpleString(const char *command)
函数就可以直接执行一条char*的Python语句。
需要获得返回值得话
PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
也很好用，以上两个函数用来处理Python源代码已经读入内存的情况，在文件中的时候
int PyRun_SimpleFile(FILE *fp, const char *filename)
PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
使用类似。不多讲了。
假如是个模块的话（比如一个函数），希望在C语言中调用的话那么使用起来就稍微复杂了一点。这种情况的需要在于你可以从C语言中向Python函数中传入参数并且执行，然后获取结果。
此处又分为几种情况：
在文件中，在内存中，编译过的，源代码。
在文件中都很好解决，和上面一样。这里主要讲在内存中的情况。（事实上我工作中需要并且耗费了很长时间才找到解决方法的就是这种情况）
未编译时：（也就是源代码）
1.通过
PyObject* Py_CompileString(const char *str, const char *filename, int start)
API首先编译一次。此API的参数我说明一下，str就是内存中的源代码，filename主要是出错时报错误用的，事实测试证明，你随意给个字符串也没有关系，但给NULL参数在运行时必然报错。start我一般用的是Py_file_input，因为的确是从文件中读取过来的，相对的还有Py_single_input用来表示一条语句，Py_eval_input的用法我也不是太清楚。
源代码通过此函数调用后，获得编译后的PyObject*,（其实假如跟进源代码中去看，是一个PyCodeObject结构）假设命名为lpCode。
2.此时再调用API
PyObject* PyImport_ExecCodeModule(char *name, PyObject *co)
导入模块。参数也说明一下，name为导入的模块名，co就是前面编译过的代码对象（lpCode）。返回的就是模块对象了，假设命名为lpMod。
3.再调用API
PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
获得函数对象。o就是模块对象（lpMod）,attr_name就是你想要调用的函数名了，假设叫main的函数，就是”main”，然后返回的就是函数对象，假设命名为lpFun。
4.此时可以用API
int PyCallable_Check(PyObject *o)
去检查一下是不是获得了一个函数。假如确定的话，就可以直接用
PyObject_Call开头的一族函数调用lpFun了。这些函数包括很多，一般就是输入参数的不同，但是效果都是一样的，就是调用函数而已。参数一般可以通过前面说过的build函数来获得，返回值也是获得一个PyObject*,可以通过PyArg_那个函数来获取，但是好像不太好，那是分析参数用的。推荐用确定类型（假设为type）的类似Py[type]_As的函数来获取。
比如：
long PyLong_AsLong(PyObject *pylong)获取long
double PyLong_AsDouble(PyObject *pylong)获取double
这里想说的是，应该有直接从源代码中获取函数调用对象的方式，但是我本人没有试出来，有人知道请一定赐教！
编译过的代码：
对于编译过的代码和上面就是获得编译后的PyCodeObject对象,当然在源代码中表示还是PyObject*的方法不同（上例中的lpCode）。
当然要想以后获得一个编译后的lpCode,自然要先编译一下啦。但是纯粹编译成pyc结尾的文件后，直接读入内存，我没有找到将其转化为PyCodeObject对象的方法（也希望有人知道能告诉我！）
我找到的方法是先用
PyObject* PyMarshal_WriteObjectToString(PyObject *value, int version)
void PyMarshal_WriteLongToFile(long value, FILE *file, int version)
两个函数先把PyCodeObject对象(lpCode)序列化到文件或者内存中。
再在需要的时候用函数
PyObject* PyMarshal_ReadObjectFromFile(FILE *file)
PyObject* PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len)
读出来，读出来的PyObject*其实就是想要的PyCodeObject对象了(lpCode)。接下来的步骤与未编译时的步骤一样。
光是这个扭曲的方法我还是参考老总给的半边资料反复研究出来的。而真正直接有效的方法我还是没有找到。
