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中，发送多少，接收多少就是多少，不会讲数据进行分块，是将数据作为一个包发送，至于客户端能接收到多少数据是不管的。
