随笔- 180  文章- 0  评论- 15 

一、python中socket简介

1、Socket 类型

套接字格式:

socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号(默认为0)来创建套接字。

 

socket类型

描述

socket.AF_UNIX

只能够用于单一的Unix系统进程间通信

socket.AF_INET

服务器之间网络通信

socket.AF_INET6

IPv6

socket.SOCK_STREAM

流式socket , for TCP

socket.SOCK_DGRAM

数据报式socket , for UDP

socket.SOCK_RAW

原始套接字,普通的套接字无法处理ICMP、IGMP等网络报文,而SOCK_RAW可以;其次,SOCK_RAW也可以处理特殊的IPv4报文;此外,利用原始套接字,可以通过IP_HDRINCL套接字选项由用户构造IP头。

socket.SOCK_SEQPACKET

可靠的连续数据包服务

创建TCP Socket

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

创建UDP Socket

s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)


2、Socket 函数

注意点:

1)TCP发送数据时,已建立好TCP连接,所以不需要指定地址。UDP是面向无连接的,每次发送要指定是发给谁。

2)服务端与客户端不能直接发送列表,元组,字典。需要字符串化repr(data)

 

socket函数

描述

服务端socket函数

s.bind(address)

将套接字绑定到地址, 在AF_INET下,以元组(host,port)的形式表示地址.

s.listen(backlog)

开始监听TCP传入连接。backlog指定在拒绝连接之前,操作系统可以挂起的最大连接数量。该值至少为1,大部分应用程序设为5就可以了。

s.accept()

接受TCP连接并返回(conn,address),其中conn是新的套接字对象,可以用来接收和发送数据。address是连接客户端的地址。

客户端socket函数

s.connect(address)

连接到address处的套接字。一般address的格式为元组(hostname,port),如果连接出错,返回socket.error错误。

s.connect_ex(adddress)

功能与connect(address)相同,但是成功返回0,失败返回errno的值。

公共socket函数

s.recv(bufsize[,flag])

接受TCP套接字的数据。数据以字符串形式返回,bufsize指定要接收的最大数据量。flag提供有关消息的其他信息,通常可以忽略。

s.send(string[,flag])

发送TCP数据。将string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字节大小。

s.sendall(string[,flag])

完整发送TCP数据。将string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功返回None,失败则抛出异常。

s.recvfrom(bufsize[.flag])

接受UDP套接字的数据。与recv()类似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址。

s.sendto(string[,flag],address)

发送UDP数据。将数据发送到套接字,address是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数。

s.close()

关闭套接字。

s.getpeername()

返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)。

s.getsockname()

返回套接字自己的地址。通常是一个元组(ipaddr,port)

s.setsockopt(level,optname,value)

设置给定套接字选项的值。

s.getsockopt(level,optname[.buflen])

返回套接字选项的值。

s.settimeout(timeout)

设置套接字操作的超时期,timeout是一个浮点数,单位是秒。值为None表示没有超时期。一般,超时期应该在刚创建套接字时设置,因为它们可能用于连接的操作(如connect()

s.gettimeout()

返回当前超时期的值,单位是秒,如果没有设置超时期,则返回None

s.fileno()

返回套接字的文件描述符。

s.setblocking(flag)

如果flag为0,则将套接字设为非阻塞模式,否则将套接字设为阻塞模式(默认值)。非阻塞模式下,如果调用recv()没有发现任何数据,或send()调用无法立即发送数据,那么将引起socket.error异常。

s.makefile()

创建一个与该套接字相关连的文件

二、python中编写简单client和server

TCP服务端:

创建套接字,绑定套接字到本地IP与端口

   # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()

开始监听连接                   #s.listen()

进入循环,不断接受客户端的连接请求              #s.accept()

然后接收传来的数据,并发送给对方数据         #s.recv() , s.sendall()

传输完毕后,关闭套接字                     #s.close()


TCP客户端:

创建套接字,连接远端地址

       # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()

连接后发送数据和接收数据          # s.sendall(), s.recv()

传输完毕后,关闭套接字          #s.close()

 

 

代码示例:

 1 #server.py
 2  
 3 import socket
 4  
 5 def Server():
 6     sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 7     sock.bind(('localhost',8080))
 8     sock.listen(1)
 9      
10     while True:
11         connection, address=sock.accept()
12         try:
13             connection.settimeout(1)
14             buf=connection.recv(1024)
15             if buf=='1':
16                 connection.send('Welcome to server!')
17             else:
18                 connection.send('Goodbye!')
19         except socket.timeout:
20             print 'socket timeout'
21         connection.close()       #注意connection.close()的结束位置。
22  
23 if __name__=='__main__':
24     Server()
25 
26  
27 #client.py
28  
29 import socket
30 import time
31  
32 def Client():
33     sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
34     sock.connect(('localhost',8080))
35     time.sleep(2)
36     sock.send('1')
37     print sock.recv(1024)
38     sock.close()
39      
40 if __name__=='__main__':
41     Client()

 

三、python通过socket传输对象

python可以通过send发送byte字节,其实可以利用send发送python中的对象,可以有两种方法(1)通过struct模块(2)通过pickle模块:

通过struct模块

 1 import socket
 2 import struct
 3  
 4 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 5 sock.connect(('localhost', 10000))
 6  
 7 values = (1, 'ab', 2.7)
 8 packer = struct.Struct('I 2s f')
 9 packed_data = packer.pack(*values)
10  
11 try:
12     sock.sendall(packed_data)
13 finally:
14     sock.close()

通过pickle方法:

try:
    import cPickle as pickle
except:
    import pickle
 
class AA():
    def a(self):
        print "123"
 
ddd = AA()
data = pickle.dumps(ddd)

注意采用pickle方法,接收时要采用pickle.loads(data)才行。load和loads,dump和dumps的区别就是一个读文件的,里面有readline,一个是读字符串的,没有readline。

python还有单独的库,提供了通过网络传输对象Pyro4 4.32库,但是由于不需要那么复杂,所以没有细看,网址:https://pypi.python.org/pypi/Pyro4

四、python接收不定长数据

python处理不定长数据可以通过简单的while True,然后不停接收就可以了。当最后一次接收时长度变成0就可以退出了。

同时还有另一种方法获取socket等信息。

     socket.getaddrinfo(host,  port, family=0, socktype=0, proto=0, flags=0) 

 自己编写程序部分代码示例(注意不可以直接运行,因为调用了我自己写的其他模块干别的事情):

 1 #server.py
 2 import socket  
 3 import sys  
 4 from CalculateSize import Calculator
 5 import cPickle as pickle
 6 
 7 HOST = None               # Symbolic name meaning all available interfaces  
 8 PORT = 8888              # Arbitrary non-privileged port  
 9 s = None  
10 for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,  
11                               socket.SOCK_STREAM, 0, socket.AI_PASSIVE):  
    1. #根据给定的参数host/port,相应的转换成一个包含用于创建socket对象的五元组,  
    2. #参数host为域名,以字符串形式给出代表一个IPV4/IPV6地址或者None.  
    3. #参数port如果字符串形式就代表一个服务名,比如“http”"ftp""email"等,或者为数字,或者为None  
    4. #参数family为地主族,可以为AF_INET  ,AF_INET6 ,AF_UNIX.  
    5. #参数socketype可以为SOCK_STREAM(TCP)或者SOCK_DGRAM(UDP)  
    6. #参数proto通常为0可以直接忽略  
    7. #参数flags为AI_*的组合,比如AI_NUMERICHOST,它会影响函数的返回值  
    8. #附注:给参数host,port传递None时建立在C基础,通过传递NULL。  
    9. #该函数返回一个五元组(family, socktype, proto, canonname, sockaddr),同时第五个参数sockaddr也是一个二元组(address, port) 
12     af, socktype, proto, canonname, sa = res  
13     try:  
14         s = socket.socket(af, socktype, proto)  
15     except socket.error, err_msg:  
16         print err_msg 
17         s = None  
18         continue  
19     try:  
20         s.bind(sa)  
21         s.listen(5)  
22     except socket.error, err_msg:  
23         print err_msg  
24         s.close()  
25         s = None  
26         continue  
27     break  
28 if s is None:  
29     print 'could not open socket'  
30     sys.exit(1)  
31  
32 while 1:
33     conn, addr = s.accept()
34     #conn.settimeout(10)
35     storage=Calculator()
36     storage.process()
37     ParttionSizeDict=storage.partitionsize
38     storagedata=pickle.dumps(ParttionSizeDict)
39     print 'Connected by', addr  
40     print  len(storagedata)
41     data = conn.recv(1024)
42     #if not data: break  
43     conn.send(storagedata)
44     conn.close()  
 1 #client.py
 2 import socket  
 3 import sys  
 4 import cPickle as pickle
 5 
 6 HOST = '127.0.0.1'    # The remote host  
 7 PORT = 8888              # The same port as used by the server  
 8 s = None  
 9 for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):  
10     af, socktype, proto, canonname, sa = res  
11     try:  
12         s = socket.socket(af, socktype, proto)  
13     except socket.error, msg:  
14         s = None  
15         continue  
16     try:  
17         s.connect(sa)  
18     except socket.error, msg:  
19         s.close()  
20         s = None  
21         continue  
22     break  
23 if s is None:  
24     print 'could not open socket'  
25     sys.exit(1)  
26       
27 s.sendall('Hello, world')
28 data =''
29 #s.settimeout(2)
30 #len=s.recv(1024)
31 while True:                   #注意如何处理不定长
32     data1 = s.recv(1024)
33     print len(data1)
34     data += data1
35     if len(data1)==0:
36         break
37 storageDataDick=pickle.loads(data)
38 
39 print storageDataDick
40 s.close()  
41 print 'Received'

 

 posted on 2015-01-19 16:43  zmlctt  阅读(1281)  评论(0编辑  收藏