python連接伺服器

A. 我現在有一套在網站上爬取數據的程序(用python寫的)如何在伺服器運行

用xshell之類的軟體連接到伺服器上，然後用其帶的比如xftp工具將代碼傳上去，在伺服器上安裝python之後再去跑代碼就行了

B. Python多進程運行——Multiprocessing基礎教程2

上篇文章簡單介紹了multiprocessing模塊，本文將要介紹進程之間的數據共享和信息傳遞的概念。

在多進程處理中，所有新創建的進程都會有這兩個特點：獨立運行，有自己的內存空間。

我們來舉個例子展示一下：

這個程序的輸出結果是：

在上面的程序中我們嘗試在兩個地方列印全局列表result的內容：

我們再用一張圖來幫助理解記憶不同進程間的數據關系：

如果程序需要在不同的進程之間共享一些數據的話，該怎麼做呢？不用擔心，multiprocessing模塊提供了Array對象和Value對象，用來在進程之間共享數據。

所謂Array對象和Value對象分別是指從共享內存中分配的ctypes數組和對象。我們直接來看一個例子，展示如何用Array對象和Value對象在進程之間共享數據：

程序輸出的結果如下：

成功了！主程序和p1進程輸出了同樣的結果，說明程序中確實完成了不同進程間的數據共享。那麼我們來詳細看一下上面的程序做了什麼：

在主程序中我們首先創建了一個Array對象：

向這個對象輸入的第一個參數是數據類型：i表示整數，d代表浮點數。第二個參數是數組的大小，在這個例子中我們創建了包含4個元素的數組。

類似的，我們創建了一個Value對象：

我們只對Value對象輸入了一個參數，那就是數據類型，與上述的方法一致。當然，我們還可以對其指定一個初始值（比如10），就像這樣：

隨後，我們在創建進程對象時，將剛創建好的兩個對象：result和square_sum作為參數輸入給進程：

在函數中result元素通過索引進行數組賦值，square_sum通過 value 屬性進行賦值。

注意：為了完整列印result數組的結果，需要使用 result[:] 進行列印，而square_sum也需要使用 value 屬性進行列印：

每當python程序啟動時，同時也會啟動一個伺服器進程。隨後，只要我們需要生成一個新進程，父進程就會連接到伺服器並請求它派生一個新進程。這個伺服器進程可以保存Python對象，並允許其他進程使用代理來操作它們。

multiprocessing模塊提供了能夠控制伺服器進程的Manager類。所以，Manager類也提供了一種創建可以在不同流程之間共享的數據的方法。

伺服器進程管理器比使用共享內存對象更靈活，因為它們可以支持任意對象類型，如列表、字典、隊列、值、數組等。此外，單個管理器可以由網路上不同計算機上的進程共享。

但是，伺服器進程管理器的速度比使用共享內存要慢。

讓我們來看一個例子：

這個程序的輸出結果是：

我們來理解一下這個程序做了什麼：首先我們創建了一個manager對象

在with語句下的所有行，都是在manager對象的范圍內的。接下來我們使用這個manager對象創建了列表（類似的，我們還可以用 manager.dict() 創建字典）。

最後我們創建了進程p1（用於在records列表中插入一條新的record）和p2（將records列印出來），並將records作為參數進行傳遞。

伺服器進程的概念再次用下圖總結一下：

為了能使多個流程能夠正常工作，常常需要在它們之間進行一些通信，以便能夠劃分工作並匯總最後的結果。multiprocessing模塊支持進程之間的兩種通信通道：Queue和Pipe。

使用隊列來回處理多進程之間的通信是一種比較簡單的方法。任何Python對象都可以使用隊列進行傳遞。我們來看一個例子：

上面這個程序的輸出結果是：

我們來看一下上面這個程序到底做了什麼。首先我們創建了一個Queue對象：

然後，將這個空的Queue對象輸入square_list函數。該函數會將列表中的數平方，再使用 put() 方法放入隊列中：

隨後使用 get() 方法，將q列印出來，直至q重新稱為一個空的Queue對象：

我們還是用一張圖來幫助理解記憶：

一個Pipe對象只能有兩個端點。因此，當進程只需要雙向通信時，它會比Queue對象更好用。

multiprocessing模塊提供了 Pipe() 函數，該函數返回由管道連接的一對連接對象。 Pipe() 返回的兩個連接對象分別表示管道的兩端。每個連接對象都有 send() 和 recv() 方法。

我們來看一個例子：

上面這個程序的輸出結果是：

我們還是來看一下這個程序到底做了什麼。首先創建了一個Pipe對象：

與上文說的一樣，該對象返回了一對管道兩端的兩個連接對象。然後使用 send() 方法和 recv() 方法進行信息的傳遞。就這么簡單。在上面的程序中，我們從一端向另一端發送一串消息。在另一端，我們收到消息，並在收到END消息時退出。

要注意的是，如果兩個進程(或線程)同時嘗試從管道的同一端讀取或寫入管道中的數據，則管道中的數據可能會損壞。不過不同的進程同時使用管道的兩端是沒有問題的。還要注意，Queue對象在進程之間進行了適當的同步，但代價是增加了計算復雜度。因此，Queue對象對於線程和進程是相對安全的。

最後我們還是用一張圖來示意：

Python的multiprocessing模塊還剩最後一篇文章：多進程的同步與池化

敬請期待啦！

C. python怎麼連接websocket

websocket是一個瀏覽器和伺服器通信的新的協議，一般而言，瀏覽器和伺服器通信最常用的是http協議，但是http協議是無狀態的，每次瀏覽器請求信息，伺服器返回信息後這個瀏覽器和伺服器通信的信道就被關閉了，這樣使得伺服器如果想主動給瀏覽器發送信息變得不可能了，伺服器推技術在http時代的解決方案一個是客戶端去輪詢，或是使用comet技術，而websocket則和一般的socket一樣，使得瀏覽器和伺服器建立了一個雙工的通道。
具體的websocket協議在rfc6455裡面有，這里簡要說明一下。websocket通信需要先有個握手的過程，使得協議由http轉變為webscoket協議，然後瀏覽器和伺服器就可以利用這個socket來通信了。

首先瀏覽器發送握手信息，要求協議轉變為websocket

GET / HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin:
伺服器接收到信息後，取得其中的Sec-WebSocket-Key，將他和一個固定的字元串258EAFA5-E914-47DA-95CA-C5AB0DC85B11做拼接，得到的字元串先用sha1做一下轉換，再用base64轉換一下，就得到了回應的字元串，這樣伺服器端發送回的消息是這樣的

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
這樣握手就完成了，用python來實現這段握手過程的話就是下面這樣。

def handshake(conn):
key =None
data = conn.recv(8192)
if not len(data):
return False
for line in data.split('\r\n\r\n')[0].split('\r\n')[1:]:
k, v = line.split(': ')
if k =='Sec-WebSocket-Key':
key =base64.b64encode(hashlib.sha1(v +'258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest())
if not key:
conn.close()
return False
response ='HTTP/1.1 101 Switching Protocols\r\n'\
'Upgrade: websocket\r\n'\
'Connection: Upgrade\r\n'\
'Sec-WebSocket-Accept:'+ key +'\r\n\r\n'
conn.send(response)
return True
握手過程完成之後就是信息傳輸了，websocket的數據信息格式是這樣的。

+-+-+-+-+-------+-+-------------+-------------------------------+
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| | Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
值得注意的是payload len這項，表示數據的長度有多少，如果小於126，那麼payload len就是數據的長度，如果是126那麼接下來2個位元組是數據長度，如果是127表示接下來8個位元組是數據長度，然後後面會有四個位元組的mask，真實數據要由payload data和mask做異或才能得到，這樣就可以得到數據了。發送數據的格式和接受的數據類似，具體細節可以去參考rfc6455，這里就不過多贅述了。

Python的Websocket客戶端：Websocket-Client

Websocket-Client 是 Python 上的 Websocket 客戶端。它只支持 hybi-13，且所有的 Websocket API 都支持同步。

Installation
This mole is tested on Python 2.7 and Python 3.x.
Type "python setup.py install" or "pip install websocket-client" to install.
Caution!
from v0.16.0, we can install by "pip install websocket-client" for python 3.
This mole depend on
six
backports.ssl_match_hostname for Python 2.x

Python通過websocket與js客戶端通信示例分析

這里，介紹如何使用 Python 與前端 js 進行通信。
websocket 使用 HTTP 協議完成握手之後，不通過 HTTP 直接進行 websocket 通信。
於是，使用 websocket 大致兩個步驟：使用 HTTP 握手，通信。
js 處理 websocket 要使用 ws 模塊； Python 處理則使用 socket 模塊建立 TCP 連接即可，比一般的 socket ，只多一個握手以及數據處理的步驟。

包格式
js 客戶端先向伺服器端 python 發送握手包，格式如下：
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin:
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13

伺服器回應包格式：
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol: chat

其中， Sec-WebSocket-Key 是隨機的，伺服器用這些數據構造一個 SHA-1 信息摘要。
方法為： key+migic ， SHA-1 加密， base-64 加密

Python 中的處理代碼:
MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
res_key = base64.b64encode(hashlib.sha1(sec_key + MAGIC_STRING).digest())

握手完整代碼
js 端
js 中有處理 websocket 的類，初始化後自動發送握手包，如下：
var socket = new WebSocket('ws://localhost:3368');
Python 端
Python 用 socket 接受得到握手字元串，處理後發送
HOST = 'localhost'
PORT = 3368
MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING = "HTTP/1.1 101 Switching Protocols\r\n" \
"Upgrade:websocket\r\n" \
"Connection: Upgrade\r\n" \
"Sec-WebSocket-Accept: {1}\r\n" \
"WebSocket-Location: ws://{2}/chat\r\n" \
"WebSocket-Protocol:chat\r\n\r\n"

def handshake(con):
#con為用socket，accept()得到的socket

headers = {}
shake = con.recv(1024)

if not len(shake):
return False

header, data = shake.split('\r\n\r\n', 1)
for line in header.split('\r\n')[1:]:
key, val = line.split(': ', 1)
headers[key] = val

if 'Sec-WebSocket-Key' not in headers:
print ('This socket is not websocket, client close.')
con.close()
return False

sec_key = headers['Sec-WebSocket-Key']
res_key = base64.b64encode(hashlib.sha1(sec_key + MAGIC_STRING).digest())

str_handshake = HANDSHAKE_STRING.replace('{1}', res_key).replace('{2}', HOST + ':' + str(PORT))
print str_handshake
con.send(str_handshake)
return True

通信
不同版本的瀏覽器定義的數據幀格式不同， Python 發送和接收時都要處理得到符合格式的數據包，才能通信。
Python 接收
Python 接收到瀏覽器發來的數據，要解析後才能得到其中的有用數據。

固定位元組：
（ 1000 0001 或是 1000 0002 ）這里沒用，忽略
包長度位元組：
第一位肯定是 1 ，忽略。剩下 7 個位可以得到一個整數 (0 ~ 127) ，其中
（ 1-125 ）表此位元組為長度位元組，大小即為長度；
（126）表接下來的兩個位元組才是長度；
（127）表接下來的八個位元組才是長度；
用這種變長的方式表示數據長度，節省數據位。
mark 掩碼：
mark 掩碼為包長之後的 4 個位元組，之後的兄弟數據要與 mark 掩碼做運算才能得到真實的數據。
兄弟數據：
得到真實數據的方法：將兄弟數據的每一位 x ，和掩碼的第 i%4 位做 xor 運算，其中 i 是 x 在兄弟數據中的索引。

完整代碼
def recv_data(self, num):
try:
all_data = self.con.recv(num)
if not len(all_data):
return False
except:
return False
else:
code_len = ord(all_data[1]) & 127
if code_len == 126:
masks = all_data[4:8]
data = all_data[8:]
elif code_len == 127:
masks = all_data[10:14]
data = all_data[14:]
else:
masks = all_data[2:6]
data = all_data[6:]
raw_str = ""
i = 0
for d in data:
raw_str += chr(ord(d) ^ ord(masks[i % 4]))
i += 1
return raw_str
js 端的 ws 對象，通過 ws.send(str) 即可發送
ws.send(str)

Python 發送
Python 要包數據發送，也需要處理
固定位元組：固定的 1000 0001( 『 \x81 ′ )
包長：根據發送數據長度是否超過 125 ， 0xFFFF(65535) 來生成 1 個或 3 個或 9 個位元組，來代表數據長度。
def send_data(self, data):
if data:
data = str(data)
else:
return False
token = "\x81"
length = len(data)
if length < 126:
token += struct.pack("B", length)
elif length <= 0xFFFF:
token += struct.pack("!BH", 126, length)
else:
token += struct.pack("!BQ", 127, length)
#struct為Python中處理二進制數的模塊，二進制流為C，或網路流的形式。
data = '%s%s' % (token, data)
self.con.send(data)
return True

D. python ftp連接指定伺服器，並下載指定文件

ftp客戶端一般只有顯示、上傳、下載，並沒有打開文件的操作，所以你得先下載相應配置文件，在本地解析後，再繼續用相關參數下載後續文件。

E. Python TCP連接 伺服器(Server)如何指定埠發送信息

一般來說伺服器的埠需要是固定的，否則無法發起連接。客戶端的埠可以是隨機的。

F. 如何使用Python連接遠程Windows伺服器

在伺服器的電腦上添加第二塊網卡，用於連接Internet。用域管理員賬戶在遠程訪問伺服器上登錄。為第二塊網卡添加公網IP地址
在遠程訪問伺服器上，從「管理工具」中打開，「伺服器管理器」窗口，選中「角色」，單擊「添加角色」，打開「添加角色向導」窗口。
在彈出來的「開始之前」窗口中點擊「是」按鈕。
單擊「下一步」「進入選擇伺服器角色」」窗口，選擇「網路策略和訪問服務」單擊「下一步」。
在「網路策略和訪問服務」簡介窗口單擊「下一步」，在「選擇角色服務」窗口選擇「路由和遠程訪問服務」。
接下來會顯示安裝進度
等安裝好了以後，點擊關閉就可以了。

G. python怎麼連接websocket

以下有一個例子，是基於python27版本的，先要pip安裝websocket-client。

大概流程如下，具體的傳輸的數據，還是要知道client和server之間的消息通訊規定，改成自己需要的

#-*-encoding:utf-8-*-

importsys
fromsocketimport*
importjson,time,threading
fromwebsocketimportcreate_connection
reload(sys)
sys.setdefaultencoding("utf8")

#config={
#'HOST':'127.0.0.1',
#'PORT':10086
#}
#pipinstallwebsocket-client

classClient():
def__init__(self):
#調用create_connection方法，建立一個websocket鏈接
#鏈接地址請修改成你自己需要的
self.ws=create_connection("ws://47.93.91.89:10086/name/hehe")
#建一個線程，監聽伺服器發送給客戶端的數據
self.trecv=threading.Thread(target=self.recv)
self.trecv.start()

#發送方法，聊天輸入語句時調用，此處默認為群聊ALL
defsend(self,content):
#這里定義的消息體要換成你自己的消息體，變成你需要的。
msg={
"type":"POST",
"username":"hehe",
"sendto":"ALL",
"content":content

}
msg=json.mps(msg)
self.ws.send(msg)

#接收服務端發送給客戶的數據，只要ws處於連接狀態，則一直接收數據
defrecv(self):
try:
whileself.ws.connected:
result=self.ws.recv()
print"receivedmsg:"+str(result)
exceptException,e:
pass


#關閉時，發送QUIT方法，退出ws鏈接
defclose(self):
#具體要知道你自己退出鏈接的消息體是什麼，如果沒有，可以不寫這個方法
msg={
"type":"QUIT",
"username":"johanna",
"content":"byebye,everyone"
}
msg=json.mps(msg)
self.ws.send(msg)


if__name__=='__main__':

c=Client()
#當輸入非exit時，則持續ws鏈接狀態，如果exit，則關閉鏈接
whileTrue:
content=raw_input("pleaseinput(inputexittoexit):")
ifcontent=="exit":
c.close()
break
else:
c.send(content)
time.sleep(1)

H. python伺服器一個客戶端轉發到另一個客戶端

伺服器端創建2個soket對象分別綁定不同的埠用於和A,B連接， 然後將recv到A的數據send給B。
python實現一個客戶端與服務端的通信 Socket對象方法: 服務端: 使用socket函數來創建一個socket對象,並設置一個socket服務。
Python是一種解釋型腳本語言，其在設計上也堅持了清晰劃一的風格，這使得Python成為易讀、易維護的語言。相比於其他語言，Python中的語言語法和語義要簡單得多，而且代碼也具有可讀性。在大多數情況下，為了解決某一特定的問題，Python編寫所需代碼，要比其他流行語言所需的代碼少得多。因此，對於新手來說，Python是一種很容易上手，並便於維護的語言。