python socket 交互通信

sk.bind(address)　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。sk.listen(backlog)　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。 backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
这个值不能无限大，因为要在内核中维护连接队列sk.setblocking(bool)　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。sk.accept()　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。　　接收TCP 客户的连接（阻塞式）等待连接的到来sk.connect(address)　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。sk.connect_ex(address)　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061sk.close()　　关闭套接字sk.recv(bufsize[,flag])　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。sk.recvfrom(bufsize[.flag])　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。sk.send(string[,flag])　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。sk.sendall(string[,flag])　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。 内部通过递归调用send，将所有内容发送出去。sk.sendto(string[,flag],address)　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。sk.settimeout(timeout)　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）sk.getpeername()　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。sk.getsockname()　　返回套接字自己的地址。通常是一个元组(ipaddr,port)sk.fileno()　　套接字的文件描述符事例1：
服务端：

#!/usr/bin/env python
# encoding: utf-8

"""
@version: ??
@author: phpergao
@license: Apache Licence
@file: socket_server.py
@time: 2016-05-22 19:22
"""

import socket
ip_port=("127.0.0.1",9999)
sk=socket.socket()
sk.bind(ip_port)
sk.listen(5)
while True:
print("server waiting")
conn,addr=sk.accept()
client_data=conn.recv(1024)
print(str(client_data,encoding="utf-8"))
conn.sendall(bytes("不要回答,我不想被占领",encoding="utf-8"))
conn.close()

客户端：

import socket
ip_port=("127.0.0.1",9999)
sk=socket.socket()
sk.connect(ip_port)

sk.sendall(bytes("请求占领地球",encoding="utf-8"))
sk.sendall(bytes("\n我要开始侵略占领地球了",encoding="utf-8"))
server_reply=sk.recv(1024)
print(str(server_reply,encoding="utf-8"))
sk.close()

事例2：
服务端：

import socket
ip_port=("127.0.0.1",9999)
sk=socket.socket()
sk.bind(ip_port)
sk.listen(5)
while True:

print("server waiting")
conn,addr=sk.accept()
client_data=conn.recv(1024)
print(str(client_data,encoding="utf-8"))
conn.sendall(bytes("不要回答,我不想被占领",encoding="utf-8"))
while True:
try:
client_data=conn.recv(1024)
print(str(client_data,encoding="utf-8"))
except Exception:
print("client close.")
break
conn.send(client_data)
conn.close()

客户端：

import socket
ip_port=("127.0.0.1",9999)
sk=socket.socket()
sk.connect(ip_port)

sk.sendall(bytes("请求占领地球",encoding="utf-8"))
sk.sendall(bytes("\n我要开始侵略占领地球了",encoding="utf-8"))
server_reply=sk.recv(1024)
print(str(server_reply,encoding="utf-8"))
while True:
enter=input("enter:")
sk.send(bytes(enter,encoding="utf-8"))
sk.close()

在Linux服务端：

import socket
ip_port=("127.0.0.1",9999)
sk=socket.socket()
sk.bind(ip_port)
sk.listen(5)
while True:

print("server waiting")
conn,addr=sk.accept()
client_data=conn.recv(1024)
print(str(client_data,encoding="utf-8"))
conn.sendall(bytes("不要回答,我不想被占领",encoding="utf-8"))
while True:

client_data=conn.recv(1024)
print(str(client_data,encoding="utf-8"))

if not client_data:
break
conn.send(client_data)
conn.close()

使用socket写一个远程的ssh工具：
服务端代码如下:

import socket,subprocess

ip_port = ('localhost',55554)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)

while True:
print('server waiting...')
conn,addr = sk.accept()
client_data = conn.recv(1024)
print(str(client_data,encoding='utf-8'))
conn.sendall(bytes('不要回答,不要回答,不要回答',encoding='utf-8'))

while True:

print("客户端{}已经连接,等待客户端传输命令... ...".format(conn.getpeername()))
try:
client_data=conn.recv(1024)
print(str(client_data,encoding="utf-8"))
except Exception:
print("client close.")
break
obj=subprocess.Popen(str(client_data,encoding="utf-8"),stdout=subprocess.PIPE,shell=True).stdout.read()
print(type(obj))
print(str(obj,encoding="gbk"))
if len(obj)>0:#   判断结果是不是为空,为空说明用户传过来的命令,本服务器无法执行.
conn.send(bytes(obj))
else:
conn.send(bytes("cmd error:",'utf8')) #  提示命令不对

conn.close()

客户端代码如下：

socket
ip_port = (,)

sk = socket.socket()
sk.connect(ip_port)

sk.sendall((,=))
server_reply = sk.recv()
((server_reply,=))
:
user_input = ().strip()
(user_input)==:sk.send((user_input,=))
server_reply = sk.recv()
((server_reply,))
sk.close()

那么问题来了，client端在接收设置中用到了sk.recv(1024)，设置了每次最大收1024个字节，当你执行一个ifconfig命令，字节将大于1024，客户端就会一次收不完，这些数据，会怎样。这些数据已经被服务端通过socket发送过来了。你再次调用sk.recv(1024)时，继续接收余下的数据。那么怎样才能继续接收呢？目前的代码是循环到下次输入命令时会接收ifconfig命令结果的后续。那它这次的命令就又要排队到后面了。
那么如何进行循环接收呢？当然是在本次执行命令中，在sk.recv(1024)代码前加while 循环。
问题又来了。默认是死循环，while True，那么本次命令循环接收sk.recv(1024)结束条件怎么设置呢。
先说明：这里处理方法只有一种，就是在服务端传给客户端字符串前，先把传输的字节数告诉客户端。客户端循环接收字节，并把接收到的字节数累加统计，然后拿接收到的字节总数和服务端发来的做比较。如果小于继续循环。
但是： 老师给我们理清了思路，尝试了3种测试的方法，通过这3次尝试，让我们渐渐的了解socket传输的内部原理。

尝试方案1：　　客户端在接收调用sk.recv(1024)方法，我们可以尝试调大这个数值，看看结果。是可以，每次多收一些，但是，如果你一个字符串有100*1024bytes，你不能把接收数值调整到100M吧，那内存还不爆掉。并且socket官方建议最大不能超过8192，所以此方案不可行。并且一般设置500即可。尝试方案2:　　　我们在接收哪里直接while True，一直接收，直到接收不到数据时就退出break服务端不改动：

客户端代码如下：

#!/usr/bin/env python3.5
#''''当服务端发送过来的字符串字节数过大,一次接收不完,客户端通过判断服务器端是不是发送完,来作为循环接收的依据。'''
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket()
sk.connect(ip_port)
# sk.sendall(bytes("请求占领地球",'utf8'))#
# server_reply = sk.recv(1024)
# print(str(server_reply,'utf8'))
while True:
input_cmd = input("cmd:").strip()               # 用户输入命令
if input_cmd == 'q':break                       # 用户如果输入的是q,退出输入命令的循环
if not input_cmd:continue                       # 用户如果直接按了回车,既为空,则进行下次循环
print(input_cmd)                                 # 打印此次用户输入的命令
sk.send(bytes(input_cmd,'utf8'))                 # 将用户的命令通过socket发送给服务器端
res = bytes('','utf8')
while True:
cmd_exec_data = sk.recv(500)                    # 接收服务器执行命令后返回的结果
res += cmd_exec_data
if not cmd_exec_data :　　　　　　　　　　　　＃这里判断，当接收不到数据时，就退出循环
break
print(str(res,'utf8'))
sk.close()

：此方式不可行。原因是cmd_exec_data = sk.recv(500) 这里在接收完本次命令执行的所有结果后，会一直阻塞在这里。不会退出循环，此时客户端就卡死了。总结：sk.recv()和sk.send()都会阻塞方案3:　　在客户端判断服务端的数据是不是传完了，如果没传完，则继续循环接收。　　服务端不改动 不需要改动　　client.py　代码如下：

#!/usr/bin/env python3.5
'''当服务端发送过来的字符串字节数过大,一次接收不完,客户端通过判断服务器端是不是发送完,来作为循环接收的依据.
如何判断服务器端是不是发送完成?
我们认为,客户端每次接收的最大值500字节.那么如果最后一次传过来的数据长度没有500字节,那么我们是不是就可以说这次就是最后一次传输来.
所以while 循环中判断接收到的数据长度小于500,就退出循环接收.
代码如下:'''import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket()
sk.connect(ip_port)# sk.sendall(bytes("请求占领地球",'utf8'))#
# server_reply = sk.recv(1024)# print(str(server_reply,'utf8'))while True:
input_cmd = input("cmd:").strip()               # 用户输入命令
if input_cmd == 'q':break                       # 用户如果输入的是q,退出输入命令的循环
if not input_cmd:continue                       # 用户如果直接按了回车,既为空,则进行下次循环
print(input_cmd)                                 # 打印此次用户输入的命令
sk.send(bytes(input_cmd,'utf8'))                 # 将用户的命令通过socket发送给服务器端
res = bytes('','utf8')    while True:
cmd_exec_data = sk.recv(500)                    # 接收服务器执行命令后返回的结果
res += cmd_exec_data
if len(cmd_exec_data) < 500:　　　　　　　　　　　　＃当接收到的字节小于500就判断已经接收完了。            break
print(str(res,'utf8'))
sk.close()

这里我们执行命令，得到一些数据量还没有那么大的字符串时没有问题，担当字符串相当大时，就出现之前的那种错误了，原因是我们最初认为的客户端每次都是按最大500字节接收（这个观点错了）。两个因素导致单次接收可能没有500字节。　　因素1，服务端发送会因为网络状态发送数据。如果网络不稳定，传个10几个bytes也是可能的。　　因素2，客户端接收也可能因为网络或者性能，导致这次接收延迟了几百毫秒（内部缓冲机制时间限制也许只有100毫秒）。从而导致本次接收不到500字节。总结：客户端不是每次接收都是按照最大限额的字节接收的。这样我们的代码：

while True:
cmd_exec_data = sk.recv(500)                    # 接收服务器执行命令后返回的结果
res += cmd_exec_data
if len(cmd_exec_data) < 500:　　　　　　　　＃这里就会在没接收完时，就退出了本次命令执行结果接收呢。            break

多并发服务端代码



多并发客户端代码

Python:从socket开始，搭建一个最基本功能的FTP服务器 - OPEN 开发经验库

http://www.open-open.com/lib/view/open1359698814230.html
一小时学会用Python Socket 开发可并发的FTP服务器！！ - alex3714 - 51CTO技术博客 http://3060674.blog.51cto.com/3050674/1687308