socket模块

大纲

1.基础知识

2.TCP

3.UDP

4.练习

5.作业

在网络编程中的一个基本组件就是套接字(socket).
1.有阻塞(同步网络编程)
2.有非阻塞(异步网络编程)
套接字基本上是两个端点的程序之间的"信息通道".程序可能分布在不同计算机上,通过套接字相互发送信息.

套接字包括两个:
     1.服务套接字
     创建一个服务套接字后:
          1.让它等待连接,这样它就在某个网络地址处(ip地址和端口号的组合)监听,直到有客户端套接字连接.
          连接完成后,两者就可以进行交互了.
          2.使用bind(host,port)方法后,再调用listen(只有一个参数,服务器未处理连接的长度(即允许排队等待的连接数目,
 在这些连接禁用之前))去监听某个特定位置的地址.
          3.服务端开始监听后,便可以接受客户端连接.这个步骤使用accept方法来完成.这个方法会阻塞(等待)
          直到客户连接,然后该方法返回一个格式为(client,address)的元组,
          4.服务器处理完一个与客户端连接后,再次调用accept方法开始等待下一个连接.这个过程通常是个无限循环
     2.客户机套接字
          1.客户机简单的连接,完成事务,断开连接.
          2.客户端使用connect(host,port)方法连接到服务器,
          3.client是客户端套接字,address是一个前面解释过的地址.

一个套接字就是socket模块中socket类的一个实例.
这个实例需要三个参数
1.地址族(默认是socket.AF_INET)
2.流(socket.SOCK_STREAM,默认值)或数据报(socket.SOCK_DGRAM)套接字
3.使用协议(默认是0,使用默认值即可)



套接字有两个方法
1.send发送
2.revc接收
用于接收,用于传输数据,revc参数用来选择最大字节数来接收1024是个好选择







socket参数的详解
socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)
创建socket对象的参数说明：
family    地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。
（AF_UNIX 域实际上是使用本地 socket 文件来通信）
type    套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。
SOCK_STREAM 是基于TCP的，有保障的（即能保证数据正确传送到对方）面向连接的SOCKET，多用于资料传送。 
SOCK_DGRAM 是基于UDP的，无保障的面向消息的socket，多用于在网络上发广播信息。
proto    协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。
fileno    如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。
与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。
这可能有助于使用socket.close()关闭一个独立的插座。

服务端
import socket    #导入模块
sk = socket.socket() #创建一个套接字实例
sk.bind(("127.0.0.1",8800))#绑定套接字
sk.listen()#监听
conn,addr = sk.accept()#等待连接
conn.send(b"hello")#发送
msg = conn.recv(1024)#接收
print(msg)
conn.close#关闭
sk.close()#关闭



客户端
import socket#导入模块
sk = socket.socket()#建立一个客户端类
sk.connect(("127.0.0.1",8800))#连接服务器
ret = sk.recv(1024)#接收
print(ret)
sk.send(b"111111")#发送
sk.close()

服务端
import socket    #导入模块
sk = socket.socket() #创建一个套接字实例
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind(("127.0.0.1",8800))#绑定套接字
sk.listen()#监听
while 1:
     conn,addr = sk.accept()#等待连接
     while 1:
          inp = input(">>>>")
          if inp =="q":
               conn.send(inp.encode("utf-8"))#发送
               break
          conn.send(inp.encode("utf-8"))#发送
          msg = conn.recv(1024)#接收
          if msg == b"q":break#退出
          print(msg.decode("utf-8"))
          conn.close#关闭
sk.close()#关闭




客户端
import socket#导入模块
sk = socket.socket()#建立一个客户端类
sk.connect(("127.0.0.1",8800))#连接服务器
while 1:
     ret = sk.recv(1024)#接收
     print(ret.decode("utf-8"))#解码方式打印到屏幕
     if ret == b"q":break#退出
     inp = input(">>>>")
     if inp == "q":#退出
          sk.send(inp.encod("utf-8"))#发送
          break
     sk.send(inp.encode("utf-8"))#否则继续发送信息
sk.close()

服务端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)#指定一个UDP协议的对象
sk.bind(("127.0.0.1",8888))#指定一个服务器

msg,addr = sk.recvfrom(1024)#指定一个接受消息的地址
print(msg,addr)
msg = b"hello"
sk.sendto(msg,addr)#发送消息

sk.close()


客户端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)

sk.sendto(b"111111",("127.0.0.1",8888))#直接给服务器发送信息
msg,addr = sk.recvfrom(1024)#接受信息
print(msg)
sk.close()

服务端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1',9090))
while True:
    msg,addr = sk.recvfrom(1024)
    print('来自[%s:%s]的消息--%s'%(addr[0],addr[1],msg.decode('utf-8')))

    inp = input('>>>')
    sk.sendto(inp.encode('utf-8'),addr)

sk.close()


客户端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
addr = ('127.0.0.1',9090)
while True:
    msg = input('>>>')
    sk.sendto(msg.encode('utf-8'),addr)
    msg_recv,addr = sk.recvfrom(1024)
    print(msg_recv.decode('utf-8'))
sk.close()

服务端
# 需求
    # 写一个时间同步的服务器
    # 服务端接收请求
    # 按照client端发送的时间格式,将服务器时间转换成对应格式
    # 发送给客户端

import time
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(("127.0.0.1",8808))
while 1:
    msg,addr = sk.recvfrom(1024)#收到信息
    time_format = msg.decode("utf-8")
    time_str = time.strftime(time_format)
    sk.sendto(time_str.encode("utf-8"),addr)
sk.close()



客户端
# client端每隔一段时间发送请求到服务端
# 发送时间的格式
# 客户端
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)

sk.sendto("%Y-%m".encode("utf-8"),("127.0.0.1",8808))

msg,addr = sk.recvfrom(1024)

print(msg.decode("utf-8"))
sk.close()

# 默写 TCP UDP 文件夹中的代码
# 完成一个上传和下载文件的小程序
    # server端 :根据客户端需求自定义
    # client端
        # 客户端启动之后
        # 选择 上传操作 还是 下载操作
        # 如果是上传操作 :  输入要上传的文件路径
                # 基础需求 :直接将文件上传到默认目录
                # 进阶需求 :将文件上传到指定目录
        # 如果是下载文件 : 输入要下载的文件路径
                # 基础需求 : 直接将文件下载到当前目录
                # 进阶需求 :将文件下载到指定目录
# 字符串
# 文件  -  读文件 转码 写文件

6. 进阶

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据
s.sendall()         发送TCP数据
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件