13518219792
什么是REST？
在大足等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都做网站、网站建设 网站设计制作按需设计网站,公司网站建设,企业网站建设,成都品牌网站建设,成都全网营销,成都外贸网站建设公司,大足网站建设费用合理。
REST (REpresentation State Transfer) 描述了一个架构样式的网络系统，比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中，他是 HTTP 规范的主要编写者之一。REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。
Web 应用程序最重要的 REST 原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。客户端可以缓存数据以改进性能。
在服务器端，应用程序状态和功能可以分为各种资源。资源是一个有趣的概念实体，它向客户端公开。资源的例子有：应用程序对象、数据库记录、算法等等。每个资源都使用 URI (Universal Resource Identifier) 得到一个惟一的地址。所有资源都共享统一的界面，以便在客户端和服务器之间传输状态。使用的是标准的 HTTP 方法，比如 GET、PUT、POST 和 DELETE。Hypermedia 是应用程序状态的引擎，资源表示通过超链接互联。
另一个重要的 REST 原则是分层系统，这表示组件无法了解它与之交互的中间层以外的组件。通过将系统知识限制在单个层，可以限制整个系统的复杂性，促进了底层的独立性。
当 REST 架构的约束条件作为一个整体应用时，将生成一个可以扩展到大量客户端的应用程序。它还降低了客户端和服务器之间的交互延迟。统一界面简化了整个系统架构，改进了子系统之间交互的可见性。REST 简化了客户端和服务器的实现。
RESTful的实现：RESTful Web 服务与 RPC 样式的 Web 服务
了解了什么是什么是REST，我们再看看RESTful的实现。最近，使用 RPC 样式架构构建的基于 SOAP 的 Web 服务成为实现 SOA 最常用的方法。RPC 样式的 Web 服务客户端将一个装满数据的信封（包括方法和参数信息）通过 HTTP 发送到服务器。服务器打开信封并使用传入参数执行指定的方法。方法的结果打包到一个信封并作为响应发回客户端。客户端收到响应并打开信封。每个对象都有自己独特的方法以及仅公开一个 URI 的 RPC 样式 Web 服务，URI 表示单个端点。它忽略 HTTP 的大部分特性且仅支持 POST 方法。
由于轻量级以及通过 HTTP 直接传输数据的特性，Web 服务的 RESTful 方法已经成为最常见的替代方法。可以使用各种语言（比如 Java 程序、Perl、Ruby、Python、PHP 和 Javascript[包括 Ajax]）实现客户端。RESTful Web 服务通常可以通过自动客户端或代表用户的应用程序访问。但是，这种服务的简便性让用户能够与之直接交互，使用它们的 Web 浏览器构建一个 GET URL 并读取返回的内容。
在 REST 样式的 Web 服务中，每个资源都有一个地址。资源本身都是方法调用的目标，方法列表对所有资源都是一样的。这些方法都是标准方法，包括 HTTP GET、POST、PUT、DELETE，还可能包括 HEADER 和 OPTIONS。
在 RPC 样式的架构中，关注点在于方法，而在 REST 样式的架构中，关注点在于资源 —— 将使用标准方法检索并操作信息片段（使用表示的形式）。资源表示形式在表示形式中使用超链接互联。
Leonard Richardson 和 Sam Ruby 在他们的著作 RESTful Web Services 中引入了术语 REST-RPC 混合架构。REST-RPC 混合 Web 服务不使用信封包装方法、参数和数据，而是直接通过 HTTP 传输数据，这与 REST 样式的 Web 服务是类似的。但是它不使用标准的 HTTP 方法操作资源。它在 HTTP 请求的 URI 部分存储方法信息。好几个知名的 Web 服务，比如 Yahoo 的 Flickr API 和 del.icio.us API 都使用这种混合架构。
RESTful的实现：RESTful Web 服务的 Java 框架
有两个 Java 框架可以帮助构建 RESTful Web 服务。erome Louvel 和 Dave Pawson 开发的 Restlet（见 参考资料）是轻量级的。它实现针对各种 RESTful 系统的资源、表示、连接器和媒体类型之类的概念，包括 Web 服务。在 Restlet 框架中，客户端和服务器都是组件。组件通过连接器互相通信。该框架最重要的类是抽象类 Uniform 及其具体的子类 Restlet，该类的子类是专用类，比如 Application、Filter、Finder、Router 和 Route。这些子类能够一起处理验证、过滤、安全、数据转换以及将传入请求路由到相应资源等操作。Resource 类生成客户端的表示形式。
JSR-311是 Sun Microsystems 的规范，可以为开发 RESTful Web 服务定义一组 Java API。Jersey是对 JSR-311 的参考实现。
JSR-311 提供一组注释，相关类和接口都可以用来将 Java 对象作为 Web 资源展示。该规范假定 HTTP 是底层网络协议。它使用注释提供 URI 和相应资源类之间的清晰映射，以及 HTTP 方法与 Java 对象方法之间的映射。API 支持广泛的 HTTP 实体内容类型，包括 HTML、XML、JSON、GIF、JPG 等。它还将提供所需的插件功能，以允许使用标准方法通过应用程序添加其他类型。
RESTful的实现：构建 RESTful Web 服务的多层架构
RESTful Web 服务和动态 Web 应用程序在许多方面都是类似的。有时它们提供相同或非常类似的数据和函数，尽管客户端的种类不同。例如，在线电子商务分类网站为用户提供一个浏览器界面，用于搜索、查看和订购产品。如果还提供 Web 服务供公司、零售商甚至个人能够自动订购产品，它将非常有用。与大部分动态 Web 应用程序一样，Web 服务可以从多层架构的关注点分离中受益。业务逻辑和数据可以由自动客户端和 GUI 客户端共享。惟一的不同点在于客户端的本质和中间层的表示层。此外，从数据访问中分离业务逻辑可实现数据库独立性，并为各种类型的数据存储提供插件能力。
图 1 展示了自动化客户端，包括 Java 和各种语言编写的脚本，这些语言包括 Python、Perl、Ruby、PHP 或命令行工具，比如 curl。在浏览器中运行且作为 RESTful Web 服务消费者运行的 Ajax、Flash、JavaFX、GWT、博客和 wiki 都属于此列，因为它们都代表用户以自动化样式运行。自动化 Web 服务客户端在 Web 层向 Resource Request Handler 发送 HTTP 响应。客户端的无状态请求在头部包含方法信息，即 POST、GET、PUT 和 DELETE，这又将映射到 Resource Request Handler 中资源的相应操作。每个请求都包含所有必需的信息，包括 Resource Request Handler 用来处理请求的凭据。
从 Web 服务客户端收到请求之后，Resource Request Handler 从业务逻辑层请求服务。Resource Request Handler 确定所有概念性的实体，系统将这些实体作为资源公开，并为每个资源分配一个惟一的 URI。但是，概念性的实体在该层是不存在的。它们存在于业务逻辑层。可以使用 Jersey 或其他框架（比如 Restlet）实现 Resource Request Handler，它应该是轻量级的，将大量职责工作委托给业务层。
Ajax 和 RESTful Web 服务本质上是互为补充的。它们都可以利用大量 Web 技术和标准，比如 HTML、JavaScript、浏览器对象、XML/JSON 和 HTTP。当然也不需要购买、安装或配置任何主要组件来支持 Ajax 前端和 RESTful Web 服务之间的交互。RESTful Web 服务为 Ajax 提供了非常简单的 API 来处理服务器上资源之间的交互。
图 1 中的 Web 浏览器客户端作为 GUI 的前端，使用表示层中的 Browser Request Handler 生成的 HTML 提供显示功能。Browser Requester Handler 可以使用 MVC 模型（JSF、Struts 或 Spring 都是 Java 的例子）。它从浏览器接受请求，从业务逻辑层请求服务，生成表示并对浏览器做出响应。表示供用户在浏览器中显示使用。表示不仅包含内容，还包含显示的属性，比如 HTML 和 CSS。
业务规则可以集中到业务逻辑层，该层充当表示层和数据访问层之间的数据交换的中间层。数据以域对象或值对象的形式提供给表示层。从业务逻辑层中解耦 Browser Request Handler 和 Resource Request Handler 有助于促进代码重用，并能实现灵活和可扩展的架构。此外，由于将来可以使用新的 REST 和 MVC 框架，实现它们变得更加容易，无需重写业务逻辑层。
数据访问层提供与数据存储层的交互，可以使用 DAO 设计模式或者对象-关系映射解决方案（如 Hibernate、OJB 或 iBATIS）实现。作为替代方案，业务层和数据访问层中的组件可以实现为 EJB 组件，并取得 EJB 容器的支持，该容器可以为组件生命周期提供便利，管理持久性、事务和资源配置。但是，这需要一个遵从 Java EE 的应用服务器（比如 JBoss），并且可能无法处理 Tomcat。该层的作用在于针对不同的数据存储技术，从业务逻辑中分离数据访问代码。数据访问层还可以作为连接其他系统的集成点，可以成为其他 Web 服务的客户端。
数据存储层包括数据库系统、LDAP 服务器、文件系统和企业信息系统（包括遗留系统、事务处理系统和企业资源规划系统）。使用该架构，您可以开始看到 RESTful Web 服务的力量，它可以灵活地成为任何企业数据存储的统一 API，从而向以用户为中心的 Web 应用程序公开垂直数据，并自动化批量报告脚本。
python2和python3的区别
1.性能
Py3.0运行 pystone benchmark的速度比Py2.5慢30%。Guido认为Py3.0有极大的优化空间，在字符串和整形操作上可以取得很好的优化结果。
Py3.1性能比Py2.5慢15%，还有很大的提升空间。
2.编码
Py3.X源码文件默认使用utf-8编码，这就使得以下代码是合法的：
中国 = 'china'
print(中国)
china
3. 语法
1）去除了，全部改用!=
在Python 2里，为了得到一个任意对象的字符串表示，有一种把对象包装在反引号里(比如`x`)的特殊语法。在Python 3里，这种能力仍然存在，但是你不能再使用反引号获得这种字符串表示了。你需要使用全局函数repr()。
Notes
Python 2
Python 3
①
`x` repr(x)
②
`'PapayaWhip' + `2`` repr('PapayaWhip'+ repr(2))
Note:x可以是任何东西 — 一个类，函数，模块，基本数据类型，等等。repr()函数可以使用任何类型的参数。
2）去除``，全部改用repr()
3）关键词加入as 和with，还有True,False,None
4）整型除法返回浮点数，要得到整型结果，请使用//
由于人们常常会忽视Python 3在整数除法上的改动（写错了也不会触发Syntax Error），所以在移植代码或在Python 2中执行Python 3的代码时，需要特别注意这个改动。
所以，我还是会在Python 3的脚本中尝试用float(3)/2或 3/2.0代替3/2，以此来避免代码在Python 2环境下可能导致的错误（或与之相反，在Python 2脚本中用from __future__ import division来使用Python 3的除法）。
Python 2
print '3 / 2 =', 3 / 2 print '3 // 2 =', 3 // 2 print '3 / 2.0 =', 3 / 2.0 print '3 // 2.0 =', 3 // 2.0
3 / 2 = 1 3 // 2 = 1 3 / 2.0 = 1.5 3 // 2.0 = 1.0
默认，如果两个操作数都是整数，Python 2 自动执行整型计算。
Python 3
print('3 / 2 =', 3 / 2) print('3 // 2 =', 3 // 2) print('3 / 2.0 =', 3 / 2.0) print('3 // 2.0 =', 3 // 2.0)
3 / 2 = 1.5 3 // 2 = 1 3 / 2.0 = 1.5 3 // 2.0 = 1.0
Note: 需要注意的是“双划线”（//）操作符将一直执行整除，而不管操作数的类型，这就是为什么 5.0//2.0 值为 2.0。Python 3 中，/ 操作符是做浮点除法，而 // 是做整除（即商没有余数，比如 10 // 3 其结果就为 3，余数会被截除掉，而 (-7) // 3 的结果却是 -3。这个算法与其它很多编程语言不一样，需要注意，它们的整除运算会向0的方向取值。而在 Python 2 中，/ 就是整除，即和 Python 3 中的 // 操作符一样。
5）加入nonlocal语句。使用noclocal x可以直接指派外围（非全局）变量
6）print
去除print语句，加入print()函数实现相同的功能。同样的还有 exec语句，已经改为exec()函数
在Python 2里，print是一个语句。无论你想输出什么，只要将它们放在print关键字后边就可以。
Python 3里，print()是一个函数。就像其他的函数一样，print()需要你将想要输出的东西作为参数传给它。
例如：
2.X: print "The answer is", 2*2
3.X: print("The answer is", 2*2)
2.X: print x, # 使用逗号结尾禁止换行
3.X: print(x, end=" ") # 使用空格代替换行
在Python 2里，如果你使用一个逗号(,)作为print语句的结尾，它将会用空格分隔输出的结果，然后在输出一个尾随的空格(trailing space)，而不输出回车(carriage return)。在Python 3里，通过把end=' '作为一个关键字参数传给print()可以实现同样的效果。参数end的默认值为'\n'，所以通过重新指定end参数的值，可以取消在末尾输出回车符。
2.X: print # 输出新行
3.X: print() # 输出新行
2.X: print sys.stderr, "fatal error"
3.X: print("fatal error", file=sys.stderr)
在Python 2里，你可以通过使用pipe_name语法，把输出重定向到一个管道，比如sys.stderr。在Python 3里，你可以通过将管道作为关键字参数file的值传递给print()来完成同样的功能。参数file的默认值为std.stdout，所以重新指定它的值将会使print()输出到一个另外一个管道。
2.X: print (x, y) # 输出repr((x, y))
3.X: print((x, y)) # 不同于print(x, y)!
exec语句
exec()函数使用一个包含任意Python代码的字符串作为参数，然后就像执行语句或者表达式一样执行它。exec()跟eval()是相似的，但是exec()更加强大并更具有技巧性。eval()函数只能执行单独一条表达式，但是exec()能够执行多条语句，导入(import)，函数声明 — 实际上整个Python程序的字符串表示也可以。
Notes
Python 2
Python 3
①
exec codeString exec(codeString)
②
exec codeString in a_global_namespace exec(codeString, a_global_namespace)
③
exec codeString in a_global_namespace, a_local_namespace exec(codeString, a_global_namespace, a_local_namespace)
在最简单的形式下，因为exec()现在是一个函数，而不是语句，2to3会把这个字符串形式的代码用括号围起来。
Python 2里的exec语句可以指定名字空间，代码将在这个由全局对象组成的私有空间里执行。Python 3也有这样的功能；你只需要把这个名字空间作为第二个参数传递给exec()函数。
更加神奇的是，Python 2里的exec语句还可以指定一个本地名字空间(比如一个函数里声明的变量)。在Python 3里，exec()函数也有这样的功能。
execfile语句
就像以前的exec语句，Python 2里的execfile语句也可以像执行Python代码那样使用字符串。不同的是exec使用字符串，而execfile则使用文件。在Python 3里，execfile语句已经被去掉了。如果你真的想要执行一个文件里的Python代码(但是你不想导入它)，你可以通过打开这个文件，读取它的内容，然后调用compile()全局函数强制Python解释器编译代码，然后调用新的exec()函数。
Notes
Python 2
Python 3
execfile('a_filename') exec(compile(open('a_filename').read(),'a_filename','exec'))
7）输入函数改变了，删除了raw_input，用input代替： Python 2有两个全局函数，用来在命令行请求用户输入。第一个叫做input()，它等待用户输入一个Python表达式(然后返回结果)。第二个叫做raw_input()，用户输入什么它就返回什么。这让初学者非常困惑，并且这被广泛地看作是Python语言的一个“肉赘”(wart)。Python 3通过重命名raw_input()为input()，从而切掉了这个肉赘，所以现在的input()就像每个人最初期待的那样工作。
2.X:guess = int(raw_input('Enter an integer : ')) # 读取键盘输入的方法
3.X:guess = int(input('Enter an integer : '))
Note:如果你真的想要请求用户输入一个Python表达式，计算结果，可以通过调用input()函数然后把返回值传递给eval()。
I/O方法xreadlines()
在Python 2里，文件对象有一个xreadlines()方法，它返回一个迭代器，一次读取文件的一行。这在for循环中尤其有用。事实上，后来的Python 2版本给文件对象本身添加了这样的功能。
在Python 3里，xreadlines()方法不再可用了。2to3可以解决简单的情况，但是一些边缘案例则需要人工介入。
Notes
Python 2
Python 3
①
for line in a_file.xreadlines(): for line in a_file:
②
for line in a_file.xreadlines(5): no change (broken)
如果你以前调用没有参数的xreadlines()，2to3会把它转换成文件对象本身。在Python 3里，这种转换后的代码可以完成前同样的工作：一次读取文件的一行，然后执行for循环的循环体。
如果你以前使用一个参数(每次读取的行数)调用xreadlines()，2to3不能为你完成从Python 2到Python 3的转换，你的代码会以这样的方式失败：AttributeError: '_io.TextIOWrapper' object has no attribute 'xreadlines'。你可以手工的把xreadlines()改成readlines()以使代码能在Python 3下工作。(readline()方法在Python 3里返回迭代器，所以它跟Python 2里的xreadlines()效率是不相上下的。)
8）改变了顺序操作符的行为，例如xy，当x和y类型不匹配时抛出TypeError而不是返回随即的 bool值
9）去除元组参数解包。不能def(a, (b, c)):pass这样定义函数了
10）新式的8进制字变量，相应地修改了oct()函数。
2.X的方式如下：
0666
438
oct(438)
'0666'
3.X这样：
0666
SyntaxError: invalid token (pyshell#63, line 1)
0o666
438
oct(438)
'0o666'
11）增加了 2进制字面量和bin()函数
bin(438)
'0b110110110'
_438 = '0b110110110'
_438
'0b110110110'
12）扩展的可迭代解包。在Py3.X 里，a, b, *rest = seq和 *rest, a = seq都是合法的，只要求两点：rest是list对象和seq是可迭代的。
13）新的super()，可以不再给super()传参数，
class C(object):
def __init__(self, a):
print('C', a)
class D(C):
def __init(self, a):
super().__init__(a) # 无参数调用super()
D(8)
C 8
__main__.D object at 0x00D7ED90
14）支持class decorator。用法与函数decorator一样：
def foo(cls_a):
def print_func(self):
print('Hello, world!')
cls_a.print = print_func
return cls_a
@foo
class C(object):
pass
C().print()
Hello, world!
class decorator可以用来玩玩狸猫换太子的大把戏。更多请参阅PEP 3129
4. 字符串和字节串
Python 2有两种字符串类型：Unicode字符串和非Unicode字符串。Python 2有基于ASCII的str()类型，其可通过单独的unicode()函数转成unicode类型，但没有byte类型。
而在Python 3中，终于有了Unicode（utf-8）字符串，以及两个字节类：bytes和bytearrays。Python 3只有一种类型：Unicode字符串(Unicode strings)。只有str一种类型，但它跟2.x版本的unicode几乎一样。
Notes
Python 2
Python 3
①
u'PapayaWhip' 'PapayaWhip'
②
ur'PapayaWhip\foo' r'PapayaWhip\foo'
Python 2里的Unicode字符串在Python 3里即普通字符串，因为在Python 3里字符串总是Unicode形式的。
Unicode原始字符串(raw string)(使用这种字符串，Python不会自动转义反斜线"\")也被替换为普通的字符串，因为在Python 3里，所有原始字符串都是以Unicode编码的。
全局函数unicode()
Python 2有两个全局函数可以把对象强制转换成字符串：unicode()把对象转换成Unicode字符串，还有str()把对象转换为非Unicode字符串。
Python 3只有一种字符串类型，Unicode字符串，所以str()函数即可完成所有的功能。(unicode()函数在Python 3里不再存在了。)
Notes
Python 2
Python 3
unicode(anything) str(anything)
5.数据类型
1）Python 2有为非浮点数准备的int和long类型。int类型的最大值不能超过sys.maxint，而且这个最大值是平台相关的。可以通过在数字的末尾附上一个L来定义长整型，显然，它比int类型表示的数字范围更大。
在Python 3里，只有一种整数类型int，大多数情况下，它很像Python 2里的长整型。
Note:检查一个变量是否是整型，获得它的数据类型，并与一个int类型(不是long)的作比较。你也可以使用isinstance()函数来检查数据类型；再强调一次，使用int，而不是long，来检查整数类型。
sys.maxint
由于长整型和整型被整合在一起了，sys.maxint常量不再精确。但是因为这个值对于检测特定平台的能力还是有用处的，所以它被Python 3保留，并且重命名为sys.maxsize。
Notes
Python 2
Python 3
①
from sys import maxint from sys import maxsize
②
元组是一种固定长度、不可变的Python对象序列。创建元组最简单的办法是用逗号分隔序列值：
tuple 函数将任意序列或迭代器转换为元组：
中括号 [] 可以获取元组的元素， Python中序列索引从0开始 ：
元组一旦创建，各个位置上的对象是无法被修改的，如果元组的一个对象是可变的，例如列表，你可以在它内部进行修改：
可以使用 + 号连接元组来生成更长的元组：
元组乘以整数，则会和列表一样，生成含有多份拷贝的元组：
将元组型的表达式赋值给变量，Python会对等号右边的值进行拆包：
拆包的一个常用场景就是遍历元组或列表组成的序列：
*rest 用于在函数调用时获取任意长度的位置参数列表：
count 用于计量某个数值在元组中出现的次数：
列表的长度可变，内容可以修改。可以使用 [] 或者 list 类型函数来定义列表：
append 方法将元素添加到列表尾部：
insert 方法可以将元素插入到指定列表位置：
（ 插入位置范围在0到列表长度之间 ）
pop 是 insert 的反操作，将特定位置的元素移除并返回：
remove 方法会定位第一个符合要求的值并移除它：
in 关键字可以检查一个值是否在列表中；
not in 表示不在：
+ 号可以连接两个列表：
extend 方法可以向该列表添加多个元素：
使用 extend 将元素添加到已经存在的列表是更好的方式，比 + 快。
sort 方法可以对列表进行排序：
key 可以传递一个用于生成排序值的函数，例如通过字符串的长度进行排序：
bisect.bisect 找到元素应当被插入的位置，返回位置信息
bisect.insort 将元素插入到已排序列表的相应位置保持序列排序
bisect 模块的函数并不会检查列表是否已经排序，因此对未排序列表使用bisect不会报错，但是可能导致不正确结果
切片符号可以对大多数序列类型选取子集，基本形式是 [start:stop]
起始位置start索引包含，结束位置stop索引不包含
切片还可以将序列赋值给变量：
start和stop可以省略，默认传入起始位置或结束位置，负索引可以从序列尾部进行索引：
步进值 step 可以在第二个冒号后面使用， 意思是每隔多少个数取一个值：
对列表或元组进行翻转时，一种很聪明的用法时向步进值传值-1：
dict(字典)可能是Python内建数据结构中最重要的，它更为常用的名字是 哈希表 或者 关联数组 。
字典是键值对集合，其中键和值都是Python对象。
{} 是创建字典的一种方式，字典中用逗号将键值对分隔：
你可以访问、插入或设置字典中的元素,:
in 检查字典是否含有一个键：
del 或 pop 方法删除值， pop 方法会在删除的同时返回被删的值，并删除键：
update 方法将两个字典合并：
update方法改变了字典元素位置，对于字典中已经存在的键，如果传给update方法的数据也含有相同的键，则它的值将会被覆盖。
字典的值可以是任何Python对象，但键必须是不可变的对象，比如标量类型（整数、浮点数、字符串）或元组（且元组内对象也必须是不可变对象）。
通过 hash 函数可以检查一个对象是否可以哈希化（即是否可以用作字典的键）：
集合是一种无序且元素唯一的容器。
set 函数或者是用字面值集与大括号，创建集合：
union 方法或 | 二元操作符获得两个集合的联合即两个集合中不同元素的并集：
intersection 方法或 操作符获得交集即两个集合中同时包含的元素：
常用的集合方法列表：
和字典类似，集合的元素必须是不可变的。如果想要包含列表型的元素，必须先转换为元组：
这篇文章翻译而来。
让我来给你们做一个非常简单的，适用的解释。
REST是一套用来创建Web Service的方法。
REST式的Web Service的主旨是让事情尽量的简单化。
REST式的Web Service使用HTTP里的方法：GET， POST， DELETE， PUT。你不需要使用URL或请求的内容来指定这个方法。
REST式的Web Service使用HTTP状态码作为返回值。
REST式的Web Service调用产生的HTTP请求内容只是用于服务数据不是用来指明调用方法，目标对象或返回值的。
使用REST方法来开发Web Service的关键点是利用HTTP协议的简单性，而不是去扩展这个协议。你的Web Service调用最终应该是非常的简单而且非常的易于理解。
下面是一个调用REST式的Web Service的例子。用的是一个Javascript函数，它从Web Service里取回一个任务对象。
functionsendGetTaskRequest(packet, template, task, handler){//这一行创建一个Web请求
requestGetTask=newXMLHttpRequest();//这一行指明请求的HTTP方法和URL。//注意这个URL是一个简单的对象的路径。
requestGetTask.open(GET, baseUrl+/v1/packets/+ packet +/templates/+ template +/tasks/+ task);//这一行调用一个方法来处理响应的数据
requestGetTask.onreadystatechange=handler;//这一行用来发送请求
requestGetTask.send();}为了获取一个任务，你只要对这个任务的URL发送一个GET请求。为了添加一个任务，你只需要向这个任务的URL发送一个POST请求。REST使Web Service用起来非常的简单。
# -*- coding:utf-8 -*-
binaryDic={'+':float.__add__,
'-':float.__sub__,
'*':float.__mul__,
'/':float.__truediv__,
'%':float.__mod__,
'**':float.__pow__,}
unaryDic={'-':float.__neg__,
'+':float.__pos__,}
priorDic=dict((('**',3),('*',2),('/',2),('%',2),('+',1),('-',1)))
def is_float(s):
'判断是否浮点数字符'
return s.isdigit() or s=='.'
def is_prior(firOpf,secOpf):
'判断运算符的优先级'
if secOpf=='**':
return False
return priorDic[firOpf]=priorDic[secOpf]
def wipe_brace(s,start=0):
's是以左括号开头的字符串'
'此函数将消去括号,求出括号内的值,并返回剩余字符'
pos=s.find(')',start)
if s[1:pos].count('(')==s[1:pos].count(')'):
return s[pos+1:] ,ieval(s[1:pos])
return wipe_brace(s,pos+1)
def get_Longest_number(s,num=''):
's是以左括号或数字开头的字符串'
'返回s首位开始的最长连续数字串和剩余字符串'
if not s :
return s,num
if s[0]=='(':
return wipe_brace(s)
if is_float(s[0]):
return get_Longest_number(s[1:],num+s[0])
return s,num
def get_val(fir='',opf='',sec=''):
'智能求值函数.能进行一元,二元或纯值运算'
if opf:
if sec:
return str(binaryDic[opf](float(fir),float(sec)))
return str(unaryDic[opf](float(fir)))
return fir
def get_safeSec(s,cmpOpf='**',neg='',safeSec='',):
'比较s的第一个二元运算符和cmpOpf的优先级'
'以便获得安全的第二个值'
if not s:
return s,get_val(safeSec,neg)
if not safeSec:
if s[0]=='+':
return get_safeSec(s[1:],cmpOpf,neg)
if s[0]=='-':
return get_safeSec(s[1:],cmpOpf,'' if neg=='-' else '-')
if is_float(s[0]) or s[0]=='(':
rest,safeSec=get_Longest_number(s)
return get_safeSec(rest,cmpOpf,neg,safeSec)
opfNum= 2 if s[:2]=='**' else 1
if is_prior(cmpOpf,s[:opfNum]):
return s,get_val(safeSec,neg)
rest,safeNum=get_safeSec(s[opfNum:],s[:opfNum])
return get_safeSec(rest,cmpOpf,neg,get_val(safeSec,s[:opfNum],safeNum))
def ieval(s='',fir='',opf='',sec=''):
'控制整个解析流程'
if not s:
return get_val(fir,opf,sec)
if not fir:
if s[0]=='-':
return ieval(s[1:],fir,'' if opf=='-' else '-')
if s[0]=='+':
return ieval(s[1:],fir,opf)
if is_float(s[0]) or s[0]=='(':
return ieval(*get_Longest_number(s),opf=opf)
if not sec:
if not opf:
opfNum= 2 if s[:2]=='**' else 1
rest,sec=get_safeSec(s[opfNum:],s[:opfNum])
return ieval(rest,fir,s[:opfNum],sec)
if s[:2]!='**':
return ieval(s,get_val(fir,opf))
rest,sec=get_safeSec(s[2:])
return ieval(rest,get_val(fir,'**',sec),opf)
return ieval(s,get_val(fir,opf,sec))
if __name__=='__main__':
test=['1+2*3*4*5+20',
'1+2*3',
'1.1+20.02+300.003',
'-2**2',
'(-2)**2',
'1+2*3**-2**(2-3)*2',
'-2**-2**-2**-2',
'(1+2)*(2+3)/(1-3)',
'((9+3)/2)',
'((1234)-1)',
'1-3*--+++-2**--+++((-2))**--+++-(1-2)**--+++-2*2+1*2**6%9',
'((1+3*(-2)**2)*((2%3+((3+3)*2**3+1))*(1-3)*(1+2)+5*6)*4)']
for x in test:
print(ieval(x),'___',eval(x))
结果:
141.0 ___ 141
7.0 ___ 7
321.123 ___ 321.123
-4.0 ___ -4
4.0 ___ 4
3.309401076758503 ___ 3.309401076758503
-0.5582965649524321 ___ -0.5582965649524321
-7.5 ___ -7.5
6.0 ___ 6.0
1233.0 ___ 1233
6.242640687119286 ___ 6.242640687119286
-14352.0 ___ -14352
