基于tcp协议的套接字编程

######################################链接循环############################################
# 1. 实例化对象socket
import socket

# 2. 得到对象
# 2.1. 如果不传参数，代表的是TCP协议：SOCK_STREAM
# 2.2 type=socket.SOCK_DGRAM => UDP协议

# server = socket.socket(type=socket.SOCK_STREAM)
server = socket.socket()

# 3. 绑定
server.bind(('127.0.0.1', 8002))

# 4. 监听, 数字代表的是半连接池
server.listen(3)

print('服务端开始接收客户端消息了：')
# 5.
# sock: 当前连接的客户端对象
# addr: 客户端的地址
while True:
    sock, addr = server.accept()

    # 6. 接收客户段发送的消息
    # 1024代表的是字节数，接收数据的最大字节数
    # 粘包现象
    data = sock.recv(1024)  # hello
    print('客户端数据：', data)

    # 7. 给客户端返回数据
    sock.send(data.upper()) # HELLO

    # 8. 断开连接
    sock.close()

# 9. 关门
server.close()


################################客户端##################################################
# 1. 实例化对象
import socket
client = socket.socket()


# 2. 连接
client.connect(('127.0.0.1', 8002))

# 3. 给服务端发送数据,发送的数据类型必须是字节类型
client.send('hello1111'.encode('utf-8'))

# 4. 接收服务端发送过来的数据
data = client.recv(1024)
print('服务端的数据：', data)

# 5. 断开连接
client.close()

加上通信循环

# 1. 实例化对象socket
import socket

# 2. 得到对象
# 2.1. 如果不传参数，代表的是TCP协议：SOCK_STREAM
# 2.2 type=socket.SOCK_DGRAM => UDP协议

# server = socket.socket(type=socket.SOCK_STREAM)
server = socket.socket()

# 3. 绑定
server.bind(('127.0.0.1', 8002))

# 4. 监听, 数字代表的是半连接池
server.listen(3)

print('服务端开始接收客户端消息了：')
# 5.
# sock: 当前连接的客户端对象
# addr: 客户端的地址
while True:

    sock, addr = server.accept()

    # 6. 接收客户段发送的消息
    # 1024代表的是字节数，接收数据的最大字节数
    # 粘包现象
    while True:
        try:

            data = sock.recv(1024)  # hello
            if len(data) == 0:
                continue
            print('客户端数据：', data)

            # 7. 给客户端返回数据
            sock.send(data.upper()) # HELLO

        except Exception as e:
            print(e)
            break


    # 8. 断开连接
    sock.close()

# 9. 关门
server.close()
#########################################服务端#############################################
# 1. 实例化对象
import socket
client = socket.socket()


# 2. 连接
client.connect(('127.0.0.1', 8002))

while True:
    input_data = input('请输入要发送的数据：')

    # 3. 给服务端发送数据,发送的数据类型必须是字节类型
    client.send(input_data.encode('utf-8'))

    # 4. 接收服务端发送过来的数据
    data = client.recv(1024)
    print('服务端的数据：', data)

# 5. 断开连接
client.close()

基于udp协议的套接字编程

#################服务端############################
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议-》UDP
server.bind(('127.0.0.1', 8080))

while True:
    data, client_addr = server.recvfrom(1024)
    print('===>', data, client_addr)
    server.sendto(data.upper(), client_addr)

server.close()

#####################客户端########################################
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议-》UDP

while True:
    msg = input('>>: ').strip()  # msg=''
    client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
    data, server_addr = client.recvfrom(1024)
    print(data)

client.close()
进程的理论
程序：一堆代码，没有生命周期
进程：动态的，是有生命周期的
eg：
    菜谱就是程序，做菜的过程就是进程
    
线程：真正干活的人，而进程不是真正干活的人
一个进程中可以开多个线程
'''一个进程中至少要有一个线程'''

# 进程和线程全部都是有操作系统来调度的
ps: 协程（程序员来调度的）

# 进程   >>>   线程    >>> 协程

补充：
    '''
        CPU的工作机制：
            1. 当程序遇到i/o的时候，cpu会自动剥夺执行权限
                i/o：
                    又称为i/o密集型，i: input, o:output
                    import time
                    print(123)
                    time.sleep(3)
                    print(1)
                    
                计算密集型：需要消耗CPU资源
            2. 当程序占用时间过长的时候，也会剥夺执行权限    
                    
    '''

进程的并行和并发

并行：是同一时刻，执行任务
并发：在一段时间内，看似同时执行

1. 单核CPU能不能实现并行?
    肯定不行。
2. 在双十一时，淘宝的大量用户佣金网站，是并行还是并发？
    并发
# 总结：要想实现并行，CPU必须具备多核。

高并发：在一段极小的时间段内，佣金大量的任务。

阻塞和非阻塞，同步和异步

同步和异步关注的是消息通信机制 

四种状态：
    1. 同步阻塞：效率最低的
    2. 同步非阻塞
    3. 异步阻塞
    4. 异步非阻塞：效率是最高的

如何开启进程

from multiprocessing import Process


def write_file():
    with open('a.txt', 'w', encoding='utf-8') as f:
        f.write('hello')


# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    # 1. 开启进程
    p = Process(target=write_file)

    # 2. 真正的开启进程
    p.start()

Process类中的参数使用

from multiprocessing import Process


def write_file(a, b, c, name, age):
    # with open('a.txt', 'w', encoding='utf-8') as f:
    #     f.write('hello')
    print('a: ', a)
    print('name: ', name)

# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    # 1. 开启进程

    '''
        name=None, 用来修改进程名称
        args=(), kwargs={}
    '''
    p = Process(target=write_file, name='aaaaaa', args=(1, 2, 3), kwargs={'name':'ly', 'age':19})

    # 2. 真正的开启进程
    p.start()

    print(p.name) # Process-1  进程名称

Process类的属性和方法

from multiprocessing import Process


def write_file(a, b, c, name, age):
    # with open('a.txt', 'w', encoding='utf-8') as f:
    #     f.write('hello')
    import time

    time.sleep(100)
    print('a: ', a)
    print('name: ', name)

# 主动开启进程执行这个任务

'''注意事项：在windows系统中，开启进程必要要写在__main__中'''
if __name__ == '__main__':
    # 1. 开启进程

    '''
        name=None, 用来修改进程名称
        args=(), kwargs={}
    '''
    p = Process(target=write_file, name='aaaaaa', args=(1, 2, 3), kwargs={'name':'ly', 'age':19})

    # 2. 真正的开启进程
    p.start()

    # print(p.name) # Process-1  进程名称
    print(p.pid)

搜索

复制