REST是什么？如何实现RESTful

什么是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的区别，转换及共存

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进行数据分析笔记：3.1数据结构

元组是一种固定长度、不可变的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是啥意思啊

这篇文章翻译而来。

让我来给你们做一个非常简单的，适用的解释。

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用起来非常的简单。

在python下输入运算表达式，输出运算结果。

# -*- 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

网站栏目：rest函数python rest命令
URL标题：http://kswjz.com/article/dodoegc.html