python `網絡編程`和其他語言都是一樣的，服務器這塊步驟為：

`1. 創建套接字`

`2. 綁定地址`

`3. 監聽該描述符的所有請求`

`4. 有新的請求到了調用accept處理請求`

Python Web服務器網關接口(Python Web Server Gateway Interface，簡稱`“WSGI”`)，可以保證同一個服務器響應不同應用框架的請求，WSGI的出現，讓開發者可以將網絡框架與網絡服務器的選擇分隔開來，例如，你可以使用Gunicorn或Nginx/uWSGI或Waitress服務器來運行Django、Flask或Pyramid應用。下面簡單實現一個機遇WSGI協議的服務器。

import socket

from io import StringIO

import sys

class WSGIServer(object):

address_family = socket.AF_INET

socket_type = socket.SOCK_STREAM

request_queue_size = 1

def __init__(self, server_address):

# Create a listening socket

self.listen_socket = listen_socket = socket.socket(

self.address_family,

self.socket_type

)

# Allow to reuse the same address

listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# Bind

listen_socket.bind(server_address)

# Activate

listen_socket.listen(self.request_queue_size)

# Get server host name and port

host, port = self.listen_socket.getsockname()[:2]

self.server_name = socket.getfqdn(host)

self.server_port = port

# Return headers set by Web framework/Web application

self.headers_set = []

定義了一個WSGIServer類，并且在類的init函數完成了套接字的創建、綁定、監聽等。

下面實現WSGIServer的輪詢檢測新的連接并處理連接：

defset_app(self, application):

self.application=applicationdefserve_forever(self):

listen_socket=self.listen_socketwhileTrue:#New client connection

self.client_connection, client_address =listen_socket.accept()#Handle one request and close the client connection. Then#loop over to wait for another client connection

self.handle_one_request()

實現處理請求的函數

defhandle_one_request(self):

self.request_data= request_data = self.client_connection.recv(1024)#Print formatted request data a la 'curl -v'

print(''.join('< {line}\n'.format(line=line)for line inrequest_data.splitlines()

))

self.parse_request(request_data)#Construct environment dictionary using request data

env =self.get_environ()#It's time to call our application callable and get#back a result that will become HTTP response body

result =self.application(env, self.start_response)#Construct a response and send it back to the client

self.finish_response(result)

解析請求

defparse_request(self, text):

request_line=text.splitlines()[0]

request_line= request_line.rstrip('\r\n')#Break down the request line into components

(self.request_method, #GET

self.path, #/hello

self.request_version #HTTP/1.1

) = request_line.split()

返回當前服務器wsgi版本等信息

defget_environ(self):

env={}

env['wsgi.version'] = (1, 0)

env['wsgi.url_scheme'] = 'http'env['wsgi.input'] =StringIO.StringIO(self.request_data)

env['wsgi.errors'] =sys.stderr

env['wsgi.multithread'] =False

env['wsgi.multiprocess'] =False

env['wsgi.run_once'] =False#Required CGI variables

env['REQUEST_METHOD'] = self.request_method #GET

env['PATH_INFO'] = self.path #/hello

env['SERVER_NAME'] = self.server_name #localhost

env['SERVER_PORT'] = str(self.server_port) #8888

return env

填寫app所需的回調函數

def start_response(self, status, response_headers, exc_info=None):#Add necessary server headers

server_headers =[

('Date', 'Tue, 31 Mar 2015 12:54:48 GMT'),

('Server', 'WSGIServer 0.2'),

]

self.headers_set= [status, response_headers +server_headers]#To adhere to WSGI specification the start_response must return

#a 'write' callable. We simplicity's sake we'll ignore that detail

#for now.

#return self.finish_response

發送數據并且關閉連接

deffinish_response(self, result):try:

status, response_headers=self.headers_set

response= 'HTTP/1.1 {status}\r\n'.format(status=status)for header inresponse_headers:

response+= '{0}: {1}\r\n'.format(*header)

response+= '\r\n'

for data inresult:

response+=data#Print formatted response data a la 'curl -v'

print(''.join('> {line}\n'.format(line=line)for line inresponse.splitlines()

))

self.client_connection.sendall(response)finally:

self.client_connection.close()

主函數和參數解析，創建服務器

SERVER_ADDRESS = (HOST, PORT) = '', 8888

defmake_server(server_address, application):

server=WSGIServer(server_address)

server.set_app(application)returnserverif __name__ == '__main__':if len(sys.argv) < 2:

sys.exit('Provide a WSGI application object as module:callable')

app_path= sys.argv[1]

module, application= app_path.split(':')

module= __import__(module)

application=getattr(module, application)

httpd=make_server(SERVER_ADDRESS, application)print('WSGIServer: Serving HTTP on port {port} ...\n'.format(port=PORT))

httpd.serve_forever()

將上面的文件保存為webserver.py

下面搭建虛擬環境，并且安裝Pyramid、Flask和Django等框架開發的網絡應用。

$ [sudo] pip install virtualenv

$ mkdir~/envs

$ virtualenv~/envs/lsbaws/$ cd~/envs/lsbaws/$ ls

bin include lib

$ source bin/activate

(lsbaws) $ pip install pyramid

(lsbaws) $ pip install flask

(lsbaws) $ pip install django

編寫pyramidapp.py，主要是調用pyramidapp接口生成app

from pyramid.config importConfiguratorfrom pyramid.response importResponsedefhello_world(request):returnResponse('Hello world from Pyramid!\n',

content_type='text/plain',

)

config=Configurator()

config.add_route('hello', '/hello')

config.add_view(hello_world, route_name='hello')

app= config.make_wsgi_app()

可以通過自己開發的網絡服務器來啟動上面的Pyramid應用。

`python webserver.py pyramidapp:app`

同樣可以創建Flask應用

from flask import Flask

from flask import Response

flask_app = Flask('flaskapp')

@flask_app.route('/hello')

def hello_world():

return Response(

'Hello world from Flask!\n',

mimetype='text/plain'

)

app = flask_app.wsgi_app

上述代碼的工作原理：

`1 網絡框架提供一個命名為application的可調用對象`。

`2 服務器每次從HTTP客戶端接收請求之后，調用application。它會向可調用對象傳遞一個名叫environ的字典作為參數，其中包含了WSGI/CGI的諸多變量，以及一個名為start_response的可調用對象`。

`3 框架/應用生成HTTP狀態碼以及HTTP響應報頭(HTTP response headers)，然后將二者傳遞至start_response，等待服務器保存。此外，框架/應用還將返回響應的正文。

服務器將狀態碼、響應報頭和響應正文組合成HTTP響應，并返回給客戶端`。

可以采用多進程的方式處理多個客戶端請求,將上述代碼稍作修改

import errno

import os

import signal

import socket

SERVER_ADDRESS = (HOST, PORT) = '', 8888

REQUEST_QUEUE_SIZE = 1024

def grim_reaper(signum, frame):

while True:

try:

pid, status = os.waitpid(

-1, # Wait for any child process

os.WNOHANG # Do not block and return EWOULDBLOCK error

)

except OSError:

return

if pid == 0: # no more zombies

return

def handle_request(client_connection):

request = client_connection.recv(1024)

print(request.decode())

http_response = b"""\

HTTP/1.1 200 OK

Hello, World!

"""

client_connection.sendall(http_response)

def serve_forever():

listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

listen_socket.bind(SERVER_ADDRESS)

listen_socket.listen(REQUEST_QUEUE_SIZE)

print('Serving HTTP on port {port} ...'.format(port=PORT))

signal.signal(signal.SIGCHLD, grim_reaper)

while True:

try:

client_connection, client_address = listen_socket.accept()

except IOError as e:

code, msg = e.args

# restart 'accept' if it was interrupted

if code == errno.EINTR:

continue

else:

raise

pid = os.fork()

if pid == 0: # child

listen_socket.close() # close child copy

handle_request(client_connection)

client_connection.close()

os._exit(0)

else: # parent

client_connection.close() # close parent copy and loop over

if __name__ == '__main__':

serve_forever()

grim_reaper 函數為捕捉子進程退出的回調函數，父進程等待所有子進程退出后再退出，避免僵尸進程。由于子進程退出父進程捕獲到消息，調用grim_reaper處理，由于父進程之前阻塞在accept上，捕獲子進程銷毀消息后，父進程accept失敗，所以增加了errno.EINTR錯誤判斷，如果是由于信號中斷導致accept失敗，就讓父進程繼續調用accept即可。

謝謝關注我的微信公眾平臺：

總結

以上是生活随笔為你收集整理的python网络平台_python学习(九) 网络编程学习--简易网站服务器的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。