python socket模块

  1 import socket  # module
  2 import threading
  3 import time
  4 
  5 """
  6 FUNCTIONS
  7     create_connection(address, timeout=<object object at 0x000000000059D120>, source_address=None)
  8         Connect to *address* and return the socket object.
  9 
 10         Convenience function.  Connect to *address* (a 2-tuple ``(host,
 11         port)``) and return the socket object.  Passing the optional
 12         *timeout* parameter will set the timeout on the socket instance
 13         before attempting to connect.  If no *timeout* is supplied, the
 14         global default timeout setting returned by :func:`getdefaulttimeout`
 15         is used.  If *source_address* is set it must be a tuple of (host, port)
 16         for the socket to bind as a source address before making the connection.
 17         A host of '' or port 0 tells the OS to use the default.
 18 
 19     dup(...)
 20         dup(integer) -> integer
 21 
 22         Duplicate an integer socket file descriptor.  This is like os.dup(), but for
 23         sockets; on some platforms os.dup() won't work for socket file descriptors.
 24 
 25     fromfd(fd, family, type, proto=0)
 26         fromfd(fd, family, type[, proto]) -> socket object
 27 
 28         Create a socket object from a duplicate of the given file
 29         descriptor.  The remaining arguments are the same as for socket().
 30 
 31     fromshare(info)
 32         fromshare(info) -> socket object
 33 
 34         Create a socket object from the bytes object returned by
 35         socket.share(pid).
 36 
 37     getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)
 38         Resolve host and port into list of address info entries.
 39 
 40         Translate the host/port argument into a sequence of 5-tuples that contain
 41         all the necessary arguments for creating a socket connected to that service.
 42         host is a domain name, a string representation of an IPv4/v6 address or
 43         None. port is a string service name such as 'http', a numeric port number or
 44         None. By passing None as the value of host and port, you can pass NULL to
 45         the underlying C API.
 46 
 47         The family, type and proto arguments can be optionally specified in order to
 48         narrow the list of addresses returned. Passing zero as a value for each of
 49         these arguments selects the full range of results.
 50 
 51     getdefaulttimeout(...)
 52         getdefaulttimeout() -> timeout
 53 
 54         Returns the default timeout in seconds (float) for new socket objects.
 55         A value of None indicates that new socket objects have no timeout.
 56         When the socket module is first imported, the default is None.
 57 
 58     getfqdn(name='')
 59         Get fully qualified domain name from name.
 60 
 61         An empty argument is interpreted as meaning the local host.
 62 
 63         First the hostname returned by gethostbyaddr() is checked, then
 64         possibly existing aliases. In case no FQDN is available, hostname
 65         from gethostname() is returned.
 66 
 67     gethostbyaddr(...)
 68         gethostbyaddr(host) -> (name, aliaslist, addresslist)
 69 
 70         Return the true host name, a list of aliases, and a list of IP addresses,
 71         for a host.  The host argument is a string giving a host name or IP number.
 72 
 73     gethostbyname(...)
 74         gethostbyname(host) -> address
 75 
 76         Return the IP address (a string of the form '255.255.255.255') for a host.
 77 
 78     gethostbyname_ex(...)
 79         gethostbyname_ex(host) -> (name, aliaslist, addresslist)
 80 
 81         Return the true host name, a list of aliases, and a list of IP addresses,
 82         for a host.  The host argument is a string giving a host name or IP number.
 83 
 84     gethostname(...)
 85         gethostname() -> string
 86 
 87         Return the current host name.
 88 
 89     getnameinfo(...)
 90         getnameinfo(sockaddr, flags) --> (host, port)
 91 
 92         Get host and port for a sockaddr.
 93 
 94     getprotobyname(...)
 95         getprotobyname(name) -> integer
 96 
 97         Return the protocol number for the named protocol.  (Rarely used.)
 98 
 99     getservbyname(...)
100         getservbyname(servicename[, protocolname]) -> integer
101 
102         Return a port number from a service name and protocol name.
103         The optional protocol name, if given, should be 'tcp' or 'udp',
104         otherwise any protocol will match.
105 
106     getservbyport(...)
107         getservbyport(port[, protocolname]) -> string
108 
109         Return the service name from a port number and protocol name.
110         The optional protocol name, if given, should be 'tcp' or 'udp',
111         otherwise any protocol will match.
112 
113     htonl(...)
114         htonl(integer) -> integer
115 
116         Convert a 32-bit integer from host to network byte order.
117 
118     htons(...)
119         htons(integer) -> integer
120 
121         Convert a 16-bit integer from host to network byte order.
122 
123     inet_aton(...)
124         inet_aton(string) -> bytes giving packed 32-bit IP representation
125 
126         Convert an IP address in string format (123.45.67.89) to the 32-bit packed
127         binary format used in low-level network functions.
128 
129     inet_ntoa(...)
130         inet_ntoa(packed_ip) -> ip_address_string
131 
132         Convert an IP address from 32-bit packed binary format to string format
133 
134     inet_ntop(...)
135         inet_ntop(af, packed_ip) -> string formatted IP address
136 
137         Convert a packed IP address of the given family to string format.
138 
139     inet_pton(...)
140         inet_pton(af, ip) -> packed IP address string
141 
142         Convert an IP address from string format to a packed string suitable
143         for use with low-level network functions.
144 
145     ntohl(...)
146         ntohl(integer) -> integer
147 
148         Convert a 32-bit integer from network to host byte order.
149 
150     ntohs(...)
151         ntohs(integer) -> integer
152 
153         Convert a 16-bit integer from network to host byte order.
154 
155     setdefaulttimeout(...)
156         setdefaulttimeout(timeout)
157 
158         Set the default timeout in seconds (float) for new socket objects.
159         A value of None indicates that new socket objects have no timeout.
160         When the socket module is first imported, the default is None.
161 
162     socketpair(family=<AddressFamily.AF_INET: 2>, type=<SocketKind.SOCK_STREAM: 1>, proto=0)
163         socketpair([family[, type[, proto]]]) -> (socket object, socket object)
164         Create a pair of socket objects from the sockets returned by the platform
165         socketpair() function.
166         The arguments are the same as for socket() except the default family is AF_UNIX
167         if defined on the platform; otherwise, the default is AF_INET.
168 """
169 
170 # 1、socket类方法
171 """
172     class socket(_socket.socket)
173      |  accept(self)
174      |      accept() -> (socket object, address info)
175      |      
176      |      Wait for an incoming connection.  Return a new socket
177      |      representing the connection, and the address of the client.
178      |      For IP sockets, the address info is a pair (hostaddr, port).
179      |      接受连接请求，返回新的描述符和客户端地址，tcp服务端使用
180      |     
181      |  close(self)
182      |      close()
183      |      
184      |      Close the socket.  It cannot be used after this call.
185      |  
186      |  detach(self)
187      |      detach() -> file descriptor
188      |      
189      |      Close the socket object without closing the underlying file descriptor.
190      |      The object cannot be used after this call, but the file descriptor
191      |      can be reused for other purposes.  The file descriptor is returned.
192      |      关闭socket对象，但不关闭底层的文件描述符
193      |      这个socket对象不能够再恢复了，但是这个文件描述符可以另做他用
194      |      返回这个文件描述符
195      |
196      |  dup(self)
197      |      dup() -> socket object
198      |      
199      |      Duplicate the socket. Return a new socket object connected to the same
200      |      system resource. The new socket is non-inheritable.
201      |      复制这个socket对象
202      |      返回一个新的sonket对象连接相同的系统资源
203      |      这个新的socket对象是不可以继承的
204      |
205      |  get_inheritable(self)
206      |      Get the inheritable flag of the socket
207      |  
208      |  makefile(self, mode='r', buffering=None, *, encoding=None, errors=None, newline=None)
209      |      makefile(...) -> an I/O stream connected to the socket
210      |      
211      |      The arguments are as for io.open() after the filename, except the only
212      |      supported mode values are 'r' (default), 'w' and 'b'.
213      |  
214      |  sendfile(self, file, offset=0, count=None)
215      |      sendfile(file[, offset[, count]]) -> sent
216      |      
217      |      Send a file until EOF is reached by using high-performance
218      |      os.sendfile() and return the total number of bytes which
219      |      were sent.
220      |      *file* must be a regular file object opened in binary mode.
221      |      If os.sendfile() is not available (e.g. Windows) or file is
222      |      not a regular file socket.send() will be used instead.
223      |      *offset* tells from where to start reading the file.
224      |      If specified, *count* is the total number of bytes to transmit
225      |      as opposed to sending the file until EOF is reached.
226      |      File position is updated on return or also in case of error in
227      |      which case file.tell() can be used to figure out the number of
228      |      bytes which were sent.
229      |      The socket must be of SOCK_STREAM type.
230      |      Non-blocking sockets are not supported.
231      |  
232      |  set_inheritable(self, inheritable)
233      |      Set the inheritable flag of the socket
234      |  
235      |  ----------------------------------------------------------------------
236      |  Methods inherited from _socket.socket:
237      |   
238      |  bind(...)
239      |      bind(address)
240      |      
241      |      Bind the socket to a local address.  For IP sockets, the address is a
242      |      pair (host, port); the host must refer to the local host. For raw packet
243      |      sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])
244      |      绑定一个本地地址，addr=(host, port)，服务端使用
245      |
246      |  connect(...)
247      |      connect(address)
248      |      
249      |      Connect the socket to a remote address.  For IP sockets, the address
250      |      is a pair (host, port).
251      |      连接到远程的addr，tcp客户端使用
252      |
253      |  connect_ex(...)
254      |      connect_ex(address) -> errno
255      |      
256      |      This is like connect(address), but returns an error code (the errno value)
257      |      instead of raising an exception when an error occurs.
258      |      同connect，不抛出异常，返回异常码
259      |  
260      |  fileno(...)
261      |      fileno() -> integer
262      |      
263      |      Return the integer file descriptor of the socket.
264      |      底层的文件描述符
265      |
266      |  getpeername(...)
267      |      getpeername() -> address info
268      |      
269      |      Return the address of the remote endpoint.  For IP sockets, the address
270      |      info is a pair (hostaddr, port).
271      |      查看远程地址，tcp使用，因为udp不发生连接，按照地址直接发送
272      |
273      |  getsockname(...)
274      |      getsockname() -> address info
275      |      
276      |      Return the address of the local endpoint.  For IP sockets, the address
277      |      info is a pair (hostaddr, port).
278      |      查看本地地址
279      |
280      |  getsockopt(...)
281      |      getsockopt(level, option[, buffersize]) -> value
282      |      
283      |      Get a socket option.  See the Unix manual for level and option.
284      |      If a nonzero buffersize argument is given, the return value is a
285      |      string of that length; otherwise it is an integer.
286      |  
287      |  gettimeout(...)
288      |      gettimeout() -> timeout
289      |      
290      |      Returns the timeout in seconds (float) associated with socket 
291      |      operations. A timeout of None indicates that timeouts on socket 
292      |      operations are disabled.
293      |  
294      |  ioctl(...)
295      |      ioctl(cmd, option) -> long
296      |      
297      |      Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are
298      |      SIO_RCVALL:  'option' must be one of the socket.RCVALL_* constants.
299      |      SIO_KEEPALIVE_VALS:  'option' is a tuple of (onoff, timeout, interval).
300      |      SIO_LOOPBACK_FAST_PATH: 'option' is a boolean value, and is disabled by default
301      |  
302      |  listen(...)
303      |      listen([backlog])
304      |      
305      |      Enable a server to accept connections.  If backlog is specified, it must be
306      |      at least 0 (if it is lower, it is set to 0); it specifies the number of
307      |      unaccepted connections that the system will allow before refusing new
308      |      connections. If not specified, a default reasonable value is chosen.
309      |      开始监听，tcp服务端使用
310      |
311      |  recv(...)
312      |      recv(buffersize[, flags]) -> data
313      |      
314      |      Receive up to buffersize bytes from the socket.  For the optional flags
315      |      argument, see the Unix manual.  When no data is available, block until
316      |      at least one byte is available or until the remote end is closed.  When
317      |      the remote end is closed and all data is read, return the empty string.
318      |      返回读到的数据
319      |      从socket对象中读取buflen大小的数据
320      |      没有数据的时候阻塞
321      |      远程关闭的时候，返回empty string
322      |      tcp使用，连接之后，通信不需要用到地址
323      |
324      |  recv_into(...)
325      |      recv_into(buffer, [nbytes[, flags]]) -> nbytes_read
326      |      
327      |      A version of recv() that stores its data into a buffer rather than creating 
328      |      a new string.  Receive up to buffersize bytes from the socket.  If buffersize 
329      |      is not specified (or 0), receive up to the size available in the given buffer.
330      |      
331      |      See recv() for documentation about the flags.
332      |      返回读到的字节数
333      |      从socket对象中读取nbytes大小的数据，当nbytes没有指定或者为零，nbytes=bufferlen
334      |
335      |  recvfrom(...)
336      |      recvfrom(buffersize[, flags]) -> (data, address info)
337      |      
338      |      Like recv(buffersize, flags) but also return the sender's address info.
339      |      返回数据和发送数据方的地址，(data, address info)
340      |      其他同recv
341      |      udp使用，每次发送数据的时候要指定地址
342      |
343      |  recvfrom_into(...)
344      |      recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)
345      |      
346      |      Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.
347      |      返回(nbytes, address info)
348      |      其他同recv_into
349      |
350      |  send(...)
351      |      send(data[, flags]) -> count
352      |      
353      |      Send a data string to the socket.  For the optional flags
354      |      argument, see the Unix manual.  Return the number of bytes
355      |      sent; this may be less than len(data) if the network is busy.
356      |      返回发送的字节数量
357      |      如果网络忙的话发送的长度有可能小于len(data)
358      |      tcp使用
359      |
360      |  sendall(...)
361      |      sendall(data[, flags])
362      |      
363      |      Send a data string to the socket.  For the optional flags
364      |      argument, see the Unix manual.  This calls send() repeatedly
365      |      until all data is sent.  If an error occurs, it's impossible
366      |      to tell how much data has been sent.
367      |      重复调用send()，直到全部发送
368      |      如果出错，会告诉你已经发送了多少字节
369      |      tcp使用
370      |
371      |  sendto(...)
372      |      sendto(data[, flags], address) -> count
373      |      
374      |      Like send(data, flags) but allows specifying the destination address.
375      |      For IP sockets, the address is a pair (hostaddr, port).
376      |      返回发送的字节数量
377      |      可以指定地址
378      |      udp使用
379      |
380      |  setblocking(...)
381      |      setblocking(flag)
382      |      
383      |      Set the socket to blocking (flag is true) or non-blocking (false).
384      |      setblocking(True) is equivalent to settimeout(None);
385      |      setblocking(False) is equivalent to settimeout(0.0).
386      |  
387      |  setsockopt(...)
388      |      setsockopt(level, option, value: int)
389      |      setsockopt(level, option, value: buffer)
390      |      setsockopt(level, option, None, optlen: int)
391      |      
392      |      Set a socket option.  See the Unix manual for level and option.
393      |      The value argument can either be an integer, a string buffer, or 
394      |      None, optlen.
395      |  
396      |  settimeout(...)
397      |      settimeout(timeout)
398      |      
399      |      Set a timeout on socket operations.  'timeout' can be a float,
400      |      giving in seconds, or None.  Setting a timeout of None disables
401      |      the timeout feature and is equivalent to setblocking(1).
402      |      Setting a timeout of zero is the same as setblocking(0).
403      |  
404      |  share(...)
405      |      share(process_id) -> bytes
406      |      
407      |      Share the socket with another process.  The target process id
408      |      must be provided and the resulting bytes object passed to the target
409      |      process.  There the shared socket can be instantiated by calling
410      |      socket.fromshare().
411      |      进程间socket对象的共享
412      |  
413      |  shutdown(...)
414      |      shutdown(flag)
415      |      
416      |      Shut down the reading side of the socket (flag == SHUT_RD), the writing side
417      |      of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).
418      |      关闭socket的读写功能
419 """
420 
421 
422 # 2、udp的通信
423 def udp_server():
424     # 1. 创建套接字
425     udp_fd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
426 
427     # 2. 绑定本地的相关信息
428     bind_address = ('192.168.99.156', 7789)
429     udp_fd.bind(bind_address)
430 
431     while True:
432         # 3. 等待接收对方发送的数据
433         receive_data, receive_address = udp_fd.recvfrom(1024)
434         # 4. 将接收到的数据再发送给对方
435         udp_fd.sendto(receive_data, receive_address)
436         # 5. 统计信息
437         print('server: %s, %s' % (receive_data.decode(encoding='utf-8'), receive_address))
438 
439     #5. 关闭套接字
440     udp_fd.close()
441 
442 
443 def udp_client():
444     # 1. 创建套接字
445     udp_fd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
446     # 2. 准备接收方的地址
447     send_address = ('192.168.99.156', 7789)
448     while True:
449         # 3. 从键盘获取数据
450         send_data = input("请输入要发送的数据:")
451         # 4. 发送数据到指定的电脑上
452         udp_fd.sendto(send_data.encode(encoding='utf-8'), send_address)
453         # 5、接收返回的信息
454         receive_data, receive_address = udp_fd.recvfrom(1024)
455         print('client: %s, %s' % (receive_data.decode(encoding='utf-8'), receive_address))
456     # 6. 关闭套接字
457     udp_fd.close()
458 
459 
460 t1 = threading.Thread(target=udp_server)
461 t2 = threading.Thread(target=udp_client)
462 t1.start()
463 t2.start()
464 t1.join()
465 t2.join()
466 
467 
468 # 3、tcp的通信
469 def tcp_server():
470     # 1、创建套接字
471     tcp_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
472     # 2、绑定本地信息
473     address = ('192.168.99.156', 7788)
474     tcp_fd.bind(address)
475     # 3、使用socket创建的套接字默认的属性是主动的，使用listen将其变为被动的，这样就可以接收别人的链接了
476     tcp_fd.listen(5)
477 
478     while True:
479         # 4、如果有新的客户端来链接服务器，那么就产生一个新的套接字专门为这个客户端服务器
480         # newSocket用来为这个客户端服务
481         # tcpSerSocket就可以省下来专门等待其他新客户端的链接
482         new_fd, client_address = tcp_fd.accept()
483         # 5、接收对方发送过来的数据，最大接收1024个字节
484         receive_data = new_fd.recv(1024)
485         print('server: 接收到的数据为:', receive_data.decode(encoding='utf-8'))
486         # 6、发送一些数据到客户端
487         new_fd.send(b"thank you !")
488         # print(new_fd.getpeername())
489         # print(new_fd.getsockname())
490         # 7、关闭为这个客户端服务的套接字，只要关闭了，就意味着为不能再为这个客户端服务了，如果还需要服务，只能再次重新连接
491         new_fd.close()
492 
493     # 关闭监听套接字，只要这个套接字关闭了，就意味着整个程序不能再接收任何新的客户端的连接
494     tcp_fd.close()
495 
496 
497 def tcp_client(num):
498     # 1、创建socket
499     tcp_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
500     # 2、链接服务器
501     server_address = ('192.168.99.156', 7788)
502     tcp_fd.connect(server_address)
503     # 3、发送数据
504     tcp_fd.send(b'hello world.')
505     # 4、接收对方发送过来的数据，最大接收1024个字节
506     receive_data = tcp_fd.recv(1024)
507     print('client-%s接收到的数据为:' % num, receive_data.decode(encoding='utf-8'))
508     # 5、关闭套接字
509     # print(tcp_fd.getpeername())
510     # print(tcp_fd.getsockname())
511     tcp_fd.close()
512 
513 
514 t1 = threading.Thread(target=tcp_server)
515 t1.start()
516 th = []
517 for i in range(5):
518     t = threading.Thread(target=tcp_client, args=(i,))
519     t.start()
520     time.sleep(1)
521     th.append(t)
522 for t in th:
523     t.join()
524 
525 
526 # 4、tcp与udp的区别
527 # (1)、 tcp是面向连接的，而udp是无连接，
528 #     在服务器端的反应就是，tcp需要做很多的设置工作，例如要进行监听listen，然后监听之后，进行接收客户端的连接，
529 #     也就是accept，当接收到连接之后，传递过来的是客户端的socket对象，然后利用这个socket对象进行发送接收消息。
530 #     而在udp中，不需要设置这些，只要绑定了地址和端口即可，在接收数据之后，得到客户端的地址和端口，
531 #     然后服务器端的udp对象将信息发送到对应的地址。
532 # (2)、在传输数据的方面，tcp是安全的，会将大量的数据进行分块然后进行发送，不会造成数据丢失；
533 #     而在udp中，发送多少，接收多少就是多少，不会讲数据进行分块，是将数据作为一个包发送，至于客户端能接收到多少数据是不管的。