python開發api

① 對於開發恆生交易API的python封裝有什麼建議

因為一些不可抗力的原因，前一段時間開發的LTS API的Python封裝暫時用不上，目前證券API這邊剩下相對靠譜的選擇只剩恆生了，同樣是准備基於C++版本的API開發Python封裝。現在的一個問題是，恆生的API風格上和國內大多數其他API非常不同，他的請求操作和數據推送需要用戶自己發送和接收數據包並進行解析（類CTP的API會直接幫你處理好，用戶只需傳入結構體指針）。題主面臨兩個選擇：直接對恆生API進行封裝，提供數據包操作的Python介面。對恆生API進行類CTP封裝後，再封裝為Python介面，好處是可以和之前類CTP的API通用，缺點可能會損失部分恆生API獨有的功能。這個API最後同樣會整合到題主的vn.py框架中，這樣對於很多大型券商（中信、海通、招商等等），用戶也會多一個可以用Python進行量化開發的選擇。恆生的介面應用應該是最普遍的，但是用恆生介面一般都需要券商給認證文件才能使用，大多數人應該都參與不了這個項目。可以參考quantbox和wind，先在框架上統一。最好先把ctp期貨和證券做出來，畢竟興業也在用，lts也是類ctp的。恆生的介面應用應該是最普遍的，但是用恆生介面一般都需要券商給認證文件才能使用，大多數人應該都參與不了這個項目。能做到封裝後python API和現有vn.py已存在的lts和ctp的介面兼容，那就極好

② 如何使用Ansible 2的API做python開發

Ansible 和 SaltStack 都提供了 Python 直接調用的API, 這方便了 Pythoner 對這些軟體進行二次開發和整合, 此功能著實方便了不少, 比起 Python 代碼中調用 shell 也略顯專業!
然而 Ansible 在2.0版本後重構了大部分的代碼邏輯, 啟用了2.0版本之前的 Runner 和 Playbook 類, 使得廣大同學之前的代碼運行錯誤. 擇日不如撞日, 今天中午對照 官方的文檔 , 結合源代碼, 對2.0版本之後的 Python API 做了下探究
Adhoc
adhoc 其實就是執行 Ansible 模塊, 通過 adhoc 我們可以方便快捷的完成一些臨時的運維操作.
2.0 之前的調用
import ansible.runner
import json
runner = ansible.runner.Runner(
mole_name='ping', # 模塊名
mole_args='', # 模塊參數
pattern='all', # 目標機器的pattern
forks=10
)
datastructure = runner.run()
data = json.mps(datastructure,indent=4)

當然這里會去載入默認的 inventory
如果不想使用 inventory 文件或者想使用動態的 inventory, 則可以使用 host_list 參數代替
import ansible.runner
import json
runner = ansible.runner.Runner(
host_list=["10.10.0.1"], # 這里如果明確指定主機需要傳遞一個列表, 或者指定動態inventory腳本
mole_name='ping', # 模塊名
mole_args='', # 模塊參數
extra_vars={"ansible_ssh_user":"root","ansible_ssh_pass":"xx"},
forks=10
)
datastructure = runner.run()
data = json.mps(datastructure,indent=4)

2.0 之後的調用
import json
from ansible.parsing.dataloader import DataLoader
from ansible.vars import VariableManager
from ansible.inventory import Inventory
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.executor.playbook_executor import PlaybookExecutor

loader = DataLoader() # 用來載入解析yaml文件或JSON內容,並且支持vault的解密
variable_manager = VariableManager() # 管理變數的類,包括主機,組,擴展等變數,之前版本是在 inventory 中的
inventory = Inventory(loader=loader, variable_manager=variable_manager)
variable_manager.set_inventory(inventory) # 根據 inventory 載入對應變數

class Options(object):
'''
這是一個公共的類,因為ad-hoc和playbook都需要一個options參數
並且所需要擁有不同的屬性,但是大部分屬性都可以返回None或False
因此用這樣的一個類來省去初始化大一堆的空值的屬性
'''
def __init__(self):
self.connection = "local"
self.forks = 1
self.check = False

def __getattr__(self, name):
return None

options = Options()

def run_adhoc():
variable_manager.extra_vars={"ansible_ssh_user":"root" , "ansible_ssh_pass":"xxx"} # 增加外部變數
# 構建pb, 這里很有意思, 新版本運行ad-hoc或playbook都需要構建這樣的pb, 只是最後調用play的類不一樣
# :param name: 任務名,類似playbook中tasks中的name
# :param hosts: playbook中的hosts
# :param tasks: playbook中的tasks, 其實這就是playbook的語法, 因為tasks的值是個列表,因此可以寫入多個task
play_source = {"name":"Ansible Ad-Hoc","hosts":"10.10.0.1","gather_facts":"no","tasks":[{"action":{"mole":"shell","args":"w"}}]}
play = Play().load(play_source, variable_manager=variable_manager, loader=loader)
tqm = None
try:
tqm = TaskQueueManager(
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=None,
stdout_callback='minimal',
run_tree=False,
)
result = tqm.run(play)
print result
finally:
if tqm is not None:
tqm.cleanup()

if __name__ == '__main__':
run_adhoc()

Playbook
playbook 則類似於 SaltStack 中的 state
2.0 之前的調用
from ansible import callbacks
from ansible import utils
from ansible.playbook import PlayBook

stats = callbacks.AggregateStats()
callback = callbacks.PlaybookCallbacks()
runner_callbacks = callbacks.PlaybookRunnerCallbacks(stats)
pb = ansible.playbook.PlayBook(
playbook="tasks.yml",
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
check=True
)
pb.run()

2.0 之後的調用
import json
from ansible.parsing.dataloader import DataLoader
from ansible.vars import VariableManager
from ansible.inventory import Inventory
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.executor.playbook_executor import PlaybookExecutor

loader = DataLoader() # 用來載入解析yaml文件或JSON內容,並且支持vault的解密
variable_manager = VariableManager() # 管理變數的類,包括主機,組,擴展等變數,之前版本是在 inventory 中的
inventory = Inventory(loader=loader, variable_manager=variable_manager)
variable_manager.set_inventory(inventory) # 根據 inventory 載入對應變數

class Options(object):
'''
這是一個公共的類,因為ad-hoc和playbook都需要一個options參數
並且所需要擁有不同的屬性,但是大部分屬性都可以返回None或False
因此用這樣的一個類來省去初始化大一堆的空值的屬性
'''
def __init__(self):
self.connection = "local"
self.forks = 1
self.check = False

def __getattr__(self, name):
return None

options = Options()

def run_playbook():
playbooks=['task.yaml'] # 這里是一個列表, 因此可以運行多個playbook
variable_manager.extra_vars={"ansible_ssh_user":"root" , "ansible_ssh_pass":"xxx"} # 增加外部變數
pb = PlaybookExecutor(playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None)
result = pb.run()
print result

if __name__ == '__main__':
run_playbook()

③ python基礎教程

python基礎教程：

階段一：Python開發基礎：Python全棧開發與人工智慧之Python開發基礎知識學習內容包括：Python基礎語法、數據類型、字元編碼、文件操作、函數、裝飾器、迭代器、內置方法、常用模塊等。

階段二：Python高級編程和資料庫開發：Python全棧開發與人工智慧之Python高級編程和資料庫開發知識學習內容包括：面向對象開發、Socket網路編程、線程、進程、隊列、IO多路模型、Mysql資料庫開發等。

階段三：前端開發：Python全棧開發與人工智慧之前端開發知識學習內容包括：Html、CSS、JavaScript開發、Jquery&bootstrap開發、前端框架VUE開發等。

階段四：WEB框架開發：Python全棧開發與人工智慧之WEB框架開發學習內容包括：Django框架基礎、Django框架進階、BBS+Blog實戰項目開發、緩存和隊列中間件、Flask框架學習、Tornado框架學習、Restful API等。

階段五：爬蟲開發：Python全棧開發與人工智慧之爬蟲開發學習內容包括：爬蟲開發實戰。

階段六：全棧項目實戰：Python全棧開發與人工智慧之全棧項目實戰學習內容包括：企業應用工具學習、CRM客戶關系管理系統開發、路飛學城在線教育平台開發等。

階段七：數據分析：Python全棧開發與人工智慧之數據分析學習內容包括：金融量化分析。

階段八：人工智慧：Python全棧開發與人工智慧之人工智慧學習內容包括：機器學習、圖形識別、無人機開發、無人駕駛等。

④ 如何用python 快速做出一個api服務

python 輕量級的框架flask
可以讓你在兩分鍾內，搭建出一個簡單的
api介面服務
輕量級不代表功能簡單，容易上手
它的優勢是，模塊化，易擴展，定製性強
比如：一個最簡單api介面2 分鍾搞定
加入你需要加入登錄驗證功能
加入頁面跳轉功能呢
如果想要渲染載入前段頁面呢
flask框里有你意想不到的插件，讓你完成最夠強大
的功能，怎麼樣，趕緊來試試吧

⑤ python後端開發需要學什麼

第一階段：Python語言基礎

主要學習Python最基礎知識，如Python3、數據類型、字元串、函數、類、文件操作等。階段課程結束後，學員需要完成Pygame實戰飛機大戰、2048等項目。

第二階段：Python語言高級

主要學習Python庫、正則表達式、進程線程、爬蟲、遍歷以及MySQL資料庫。

第三階段：Pythonweb開發

主要學習HTML、CSS、JavaScript、jQuery等前端知識，掌握python三大後端框架(Django、 Flask以及Tornado)。需要完成網頁界面設計實戰;能獨立開發網站。

第四階段：Linux基礎

主要學習Linux相關的各種命令，如文件處理命令、壓縮解壓命令、許可權管理以及Linux Shell開發等。

第五階段：Linux運維自動化開發

主要學習Python開發Linux運維、Linux運維報警工具開發、Linux運維報警安全審計開發、Linux業務質量報表工具開發、Kali安全檢測工具檢測以及Kali 密碼破解實戰。

第六階段：Python爬蟲

主要學習python爬蟲技術，掌握多線程爬蟲技術，分布式爬蟲技術。

第七階段：Python數據分析和大數據

主要學習numpy數據處理、pandas數據分析、matplotlib數據可視化、scipy數據統計分析以及python 金融數據分析;Hadoop HDFS、python Hadoop MapRece、python Spark core、python Spark SQL以及python Spark MLlib。

第八階段：Python機器學習

主要學習KNN演算法、線性回歸、邏輯斯蒂回歸演算法、決策樹演算法、樸素貝葉斯演算法、支持向量機以及聚類k-means演算法。

關於python後端開發需要學什麼的內容，青藤小編就和您分享到這里了。如果您對python編程有濃厚的興趣，希望這篇文章可以為您提供幫助。如果您還想了解更多關於python編程的技巧及素材等內容，可以點擊本站的其他文章進行學習。

⑥ 如何使用Ansible 2的API做python開發

在ansible1.9的時候，API是一個非常簡單的東西。官方說「it's pretty simple」，真是又pretty又simple。

import ansible.runner

runner = ansible.runner.Runner(
mole_name='ping',
mole_args='',
pattern='web*',
forks=10
)
datastructure = runner.run()

到了ansible2.0以後，是「a bit more complicated」，Oh my，簡直讓人難受。

簡潔和靈活是魚和熊掌。

ansible2.0 API怎麼用？

ansible2.0更貼近於ansible cli的常用命令執行方式，不同於上一版本只能發送單個命令或playbook；而更推薦用戶在調用ansibleAPI的時候，將playbook的每個task拆分出來，獲取每個task的結果。能夠跟靈活處理在執行批量作業過程中的各種反饋。

將執行操作的隊列模型，包含各類環境參數設置，歸結到「ansible.executor.task_queue_manager」類中

將執行過程中的各個task的設置，或者說playbook中的編排內容，歸結到「ansible.playbook.play」中

上述兩個東西，幾乎囊括了可以在執行過程中設置的所有參數，足夠靈活，也讓人抓狂，相當於需要自己寫一個1.9版本中的runner。
他們的確也都是原生類，並非專用於外部調用。

ansible.executor.task_queue_manager

這是ansible的一個內部模塊（ansible/executor/task_queue_manager.py）。初始化的源碼如下：

class TaskQueueManager:

'''
This class handles the multiprocessing requirements of Ansible by
creating a pool of worker forks, a result handler fork, and a
manager object with shared datastructures/queues for coordinating
work between all processes.

The queue manager is responsible for loading the play strategy plugin,
which dispatches the Play's tasks to hosts.
'''

def __init__(self, inventory, variable_manager, loader, options, passwords, stdout_callback=None, run_additional_callbacks=True, run_tree=False):

self._inventory = inventory
self._variable_manager = variable_manager
self._loader = loader
self._options = options
self._stats = AggregateStats()
self.passwords = passwords
self._stdout_callback = stdout_callback
self._run_additional_callbacks = run_additional_callbacks
self._run_tree = run_tree

self._callbacks_loaded = False
self._callback_plugins = []
self._start_at_done = False
self._result_prc = None

……

創建時，需要的主要參數包括：

inventory --> 由ansible.inventory模塊創建，用於導入inventory文件

variable_manager --> 由ansible.vars模塊創建，用於存儲各類變數信息

loader --> 由ansible.parsing.dataloader模塊創建，用於數據解析

options --> 存放各類配置信息的數據字典

passwords --> 登錄密碼，可設置加密信息

stdout_callback --> 回調函數

ansible.playbook.play

ansible.playbook是一個原生模塊，既用於CLI也用於API。從源碼可以看出來：

try:
from __main__ import display
except ImportError:
from ansible.utils.display import Display
display = Display()

ansible.playbook.play（ansible/playbook/play.py）。初始化源碼的介紹如下：

__all__ = ['Play']

class Play(Base, Taggable, Become):

"""
A play is a language feature that represents a list of roles and/or
task/handler blocks to execute on a given set of hosts.

Usage:

Play.load(datastructure) -> Play
Play.something(...)
"""

最後，用task_queue_manager(play)來執行，老規矩，源碼的官方解釋。

def run(self, play):
'''
Iterates over the roles/tasks in a play, using the given (or default)
strategy for queueing tasks. The default is the linear strategy, which
operates like classic Ansible by keeping all hosts in lock-step with
a given task (meaning no hosts move on to the next task until all hosts
are done with the current task).
'''

一個完整的例子

# -*- coding:utf-8 -*-
# !/usr/bin/env python
#
# Author: Shawn.T
# Email: [email protected]
#
# this is the Interface package of Ansible2 API
#

from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.vars import VariableManager
from ansible.inventory import Inventory
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from tempfile import NamedTemporaryFile
import os

class AnsibleTask(object):
def __init__(self, targetHost):
Options = namedtuple(
'Options', [
'listtags', 'listtasks', 'listhosts', 'syntax', 'connection','mole_path',
'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args',
'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user',
'verbosity', 'check'
]
)

# initialize needed objects
self.variable_manager = VariableManager()

self.options = Options(
listtags=False, listtasks=False, listhosts=False, syntax=False, connection='smart',
mole_path='/usr/lib/python2.7/site-packages/ansible/moles', forks=100,
remote_user='root', private_key_file=None, ssh_common_args=None, ssh_extra_args=None,
sftp_extra_args=None, scp_extra_args=None, become=False, become_method=None, become_user='root',
verbosity=None, check=False
)
self.passwords = dict(vault_pass='secret')
self.loader = DataLoader()

# create inventory and pass to var manager
self.hostsFile = NamedTemporaryFile(delete=False)
self.hostsFile.write(targetHost)
self.hostsFile.close()
self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.hostsFile.name)
self.variable_manager.set_inventory(self.inventory)

def ansiblePlay(self, action):
# create play with tasks
args = "ls /"
play_source = dict(
name = "Ansible Play",
hosts = 'all',
gather_facts = 'no',
tasks = [
dict(action=dict(mole='shell', args=args), register='shell_out'),
dict(action=dict(mole='debug', args=dict(msg='{{shell_out.stdout}}')))
]
)
play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)

# run it
tqm = None
try:
tqm = TaskQueueManager(
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords,
stdout_callback='default',
)
result = tqm.run(play)
finally:
# print result
if tqm is not None:
tqm.cleanup()
os.remove(self.hostsFile.name)
self.inventory.clear_pattern_cache()
return result

寫一個ansibleTask類，創建了上述的各類必要的配置信息對象，最後使用ansibleTask.ansiblePlay()函數執行。

inventory文件的動態生成

寫上面的代碼的過程中，碰到一個問題：inventory對象創建時需要一個實體的hosts文件，而文件需要動態生成。
生成的方法參考了這篇牛逼閃閃的文章。使用tempfile.NamedTemporaryFile這個方法來創建一個有名稱的臨時文件，可以選擇關閉後刪除或保留。上面的處理辦法是：不刪除，在執行完畢之後，通過os.remove(self.hostsFile.name)進行刪除。

ps.經YiChenWang指出，inventory的創建參數host_list可以使列表。使用以下方式創建inventory也是可以的：

self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=['xx.xx.xx.xx', 'xx.xx.xx.xx'])

不過，源碼中指出，採用list格式參數是無法載入inventory data的。如果需要載入，還是得使用臨時文件的辦法。

⑦ Telegram-API開發使用系列教程Python(前言)

       Telegram是什麼？接觸的人可能知道，沒接觸的人肯定不知道（廢話，呵呵），它是一個俄羅斯人開發的，為了防止被監視，就想開發一個完全加密的即時通訊軟體，有著想法他就做了，而且還做的不錯。因為這個軟體可以規避別人的監視，尤其是某些政府的，所以在某些特需的人那裡非常流行，據說中東kb分子就是使用這個交流的。

        但是當時這個畢竟是小眾使用，根本無法推廣出去，不過開發的人可能也沒有想著推廣，畢竟使用的人多了，樹大招風，可能會帶來許多不便。不過事與願違，因為前幾年加密貨幣非常火，全球各個政府對於這個新興的事物無從下手，因為加密貨幣本質屬性就是抗政府的（去中心化），所以最後索性大部分政府把加密貨幣給禁掉了，在這期間，由於Telegram與加密貨幣具有相同的屬性，都是去中心化和強加密的，所以一拍即合，Telegram借著加密貨幣的東風，為大眾所知曉。現在不單單是在加密貨幣市場被廣泛使用，在其他一些隱蔽的場景也被使用，這里就不多說了。

        Telegram已經發展了七八年了，到現在功能已經是非常強大了，它是去中心化的，你甚至可以搭建自己Telegram伺服器，它是強加密的，別人不會監聽到你消息，它還有強大的機器人BOT機制，它可以定製開發，可以按照自己的意圖完成一些重復的功能，這依託於它具有健全的API功能。

        現在Telegram是被牆的，如果要使用，請自行架梯子。

        Telegram官方Python版本，叫Telethon，API文檔地址是： API官方地址 ，還有一個Telegram-API的項目，也是Python版本的，叫Pyrogram，其API文檔地址為： Pyrogram文檔地址 ，我使用了一段時間Pyrogram，可能是個人習慣的原因，用不慣Pyrogram，所有又換回Telethon。

        下一篇我們就開始一起學習官方版的Telethon。

⑧ 使用推特開發者api獲取推文【Python – Status object in Tweepy】

Twitter 是一個流行的社交網路，用戶在其中分享稱為推文的消息。 Twitter 允許我們使用 Twitter API 或 Tweepy 挖掘任何用戶的數據。獲取用戶發布的推文，首先要做的是從twitter developer那裡獲得consumer key, consumer secret, access key and access secret。這些密鑰將幫助 API 進行身份驗證。

Status

status對象是tweepy庫返回的推文對象

這里羅列一下status中常用的屬性：

例如這個推文的信息：

得到的結果為：

⑨ 如何使用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/tasks


• HTTP/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/2


• HTTP/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/3


• HTTP/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/tasks


• HTTP/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/tasks


• HTTP/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)
•