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是一种很容易上手，并便于维护的语言。