file_object = open(file_name, access_mode='r', buffering=-1)

buffer=0 （无缓存）
buffer=1 表示行缓冲则在写入数据时遇到\n自动刷新缓冲区，即缓存一行写入一行
# 采用系统默认缓存需要缓冲区满后才能自动写入磁盘
# 无论什么缓冲，当程序结束后或者文件被关闭都会将缓冲区内容写入磁盘
# 通过调用flush()可以立刻刷新缓冲

创建套接字

sockfd=socket.socket(socket_family=AF_INET,socket_type=SOCK_STREAM,proto=0)
功能：创建套接字
参数：  socket_family  网络地址类型 AF_INET表示ipv4
    socket_type  套接字类型 SOCK_STREAM 流式SOCK_DGRAM 数据报
    proto  通常为0  选择子协议
返回值： 套接字对象

绑定地址

sockfd.bind(addr)
功能： 绑定本机网络地址
参数： 二元元组 (ip,port)  ('0.0.0.0',8888)

设置监听

sockfd.listen(n)
功能 ： 将套接字设置为监听套接字，确定监听队列大小
参数 ： 监听队列大小

等待处理客户端连接请求

connfd,addr = sockfd.accept()
功能： 阻塞等待处理客户端请求
返回值： connfd  客户端连接套接字
         addr  连接的客户端地址

消息收发

data = connfd.recv(buffersize)
功能 : 接受客户端消息
参数 ：每次最多接收消息的大小
返回值： 接收到的内容

n = connfd.send(data)
功能 : 发送消息
参数 ：要发送的内容  bytes格式
返回值： 发送的字节数

关闭套接字

sockfd.close()
功能：关闭套接字

"""
TCP套接字服务端
重点代码
"""
import socket

#  创建套接字
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#  绑定地址
sock.bind(("0.0.0.0", 8888))
#  设置监听
sock.listen(5)
while True:
    #  等待处理客户端连接
    print("Waiting for connect....")
    try:
        connfd, addr = sock.accept()
        print("Connect from:", addr)
    except KeyboardInterrupt:
        print("退出服务")
        break

    while True:
        #  收发消息
        data = connfd.recv(1024)
        #  得到空则退出循环
        if not data:
            break
        print("接受到消息：", data.decode())

        n = connfd.send(b"Receive your message")
        print("发生了%d个字节数据" % n)

    #  关闭套接字
    connfd.close()
sock.close()

1. 创建套接字

注意:只有相同类型的套接字才能进行通信

1. 请求连接

sockfd.connect(server_addr)
功能：连接服务器
参数：元组  服务器地址

1. 收发消息

注意： 防止两端都阻塞，recv send要配合

1. 关闭套接字

"""
TCP 客户端程序
重点代码
"""
from socket import *

#  创建套接字
sock = socket()
#  发起连接
server_addr = ("192.168.8.109", 8888)
sock.connect(server_addr)
while True:

    #  消息的收发
    msg = str(input(">>"))
    if not msg:
        break
    sock.send(msg.encode())
    data = sock.recv(1024)
    print("From server:", data.decode())
#  关闭
sock.close()

1. 创建数据报套接字

sockfd = socket(AF_INET,SOCK_DGRAM)

1. 绑定地址

sockfd.bind(addr)

1. 消息收发

“`python
data,addr = sockfd.recvfrom(buffersize)
功能： 接收UDP消息
参数： 每次最多接收多少字节
返回值： data 接收到的内容
addr 消息发送方地址

n = sockfd.sendto(data,addr)
功能： 发送UDP消息
参数： data 发送的内容 bytes格式
addr 目标地址
返回值：发送的字节数

4. 关闭套接字

python
sockfd.close()
“`

"""
UDP套接字
"""

from socket import *

# 创建数据报套接字
sock = socket(AF_INET, SOCK_DGRAM)

# 绑定地址
server_addr = ("0.0.0.0", 9999)
sock.bind(server_addr)

# 收发消息
while True:
    data, addr = sock.recvfrom(1024)
    print("收到消息：", data.decode())
    sock.sendto(b"Thanks", addr)

# 关闭套接字
sock.close()

1. 创建套接字
2. 收发消息
3. 关闭套接字

"""
udp-client
"""
from socket import *

# 服务器信息
HOST = "0.0.0.0"
PORT = 9999
ADDR = (HOST, PORT)
# 创建套接字
sockfd = socket(AF_INET, SOCK_DGRAM)

# 收发消息
while True:
    data = input(">??>")
    if not data:
        break
    sockfd.sendto(data.encode(), ADDR)

    msg, addr = sockfd.recvfrom(1024)
    print("From Server:", msg.decode())

sockfd.close()

# 广播接受

"""
1.创建udp套接字
2.选择接受端口
3.设置套接字为可以接受广播
"""
from socket import *

s = socket(AF_INET, SOCK_DGRAM)

# 让套接字可以接受广播
s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

s.bind(("0.0.0.0", 9999))

while True:
    try:
        msg,addr = s.recvfrom(1024)
    except KeyboardInterrupt:
        break
    else:
        print(msg.decode())

s.close()

# 广播发送

from socket import *
from time import sleep

# 广播地址
dest = ("192.168.8.255", 9999)

s = socket(AF_INET, SOCK_DGRAM)

s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

data = "蔡徐坤6666"
while True:
    sleep(2)
    s.sendto(data.encode(),dest)

s.close()

from socket import *


# 处理浏览器的http请求
def handle(connfd):
    print("Request from", connfd.getpeername())
    request = connfd.recv(4096)  # 接受http请求
    # 防止客户端断开
    if not request:
        return
    request_line = request.splitlines()[0].decode()  # 按照行进行分割
    # 获取请求内容
    info = request_line.split(" ")[1]
    if info == "/":
        f = open("index.html", "r")
        response = "HTTP/1.1 200 OK\r\n"
        response += "Content-Type: text/html\r\n"
        response += "\r\n"
        response += f.read()
    else:
        response = "HTTP/1.1 200 OK\r\n"
        response += "Content-Type: text/html\r\n"
        response += "\r\n"
        response += "<h1>Sorry 404 Not Found</h1>"

    # 想浏览器发送内容
    connfd.send(response.encode())
    print(info)


#  搭建tcp网络
def main():
    sockfd = socket()
    sockfd.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    sockfd.bind(("0.0.0.0", 8888))
    sockfd.listen(3)
    print("listen 8888")
    while True:
        connfd, addr = sockfd.accept()
        handle(connfd)  # 处理浏览器请求
        connfd.close()


if __name__ == "__main__":
    main()

"""
http客户端实现
"""
from socket import *

# 创建tcp套接字

s = socket(AF_INET, SOCK_STREAM)
s.bind(("0.0.0.0", 8888))
s.listen(3)

c, addr = s.accept()
data = c.recv(4096)
print(data.decode())
# http响应格式
data = """HTTP/1.1 200 OK
Content-Type:text/html

<h1>hello world</h1>
"""
c.send(data.encode("utf-8"))
fr = open("index.html", "r")
data = fr.read()
c.send(data.encode("utf-8"))

c.close()
s.close()

"""
struct信息接收端
"""
from socket import *
import struct

soc = socket(AF_INET, SOCK_DGRAM)

soc.bind(('0.0.0.0', 8888))

while True:
    try:
        msg, addr = soc.recvfrom(1024)
        st = struct.Struct("i32sif")
        msg = st.unpack(msg)
        info = "%d %s %d %.2f \n" % (msg[0], msg[1].decode(), msg[2], msg[3])
        if msg:
            fw = open("student_info.txt", "a+")
            fw.write(info)
        else:
            break
    except KeyboardInterrupt:
        break

fw.close()
soc.close()

"""
struct信息发送端
"""
from socket import *
import struct

HOST = "0.0.0.0"
PORT = 8888
ADDR = (HOST, PORT)
soc = socket(AF_INET, SOCK_DGRAM)

while True:
    try:
        id = int(input("请输入学生id>>"))
        name = input("请输入学生名字>>")
        age = int(input("请输入学生年纪>>"))
        score = float(input("请输入学生成绩>>"))
        st = struct.Struct("i32sif")
        data = st.pack(id, name.encode(), age, score)
        soc.sendto(data, ADDR)
    except KeyboardInterrupt:
        break
soc.close()