python高阶--网络编程、socket套接字、多进程多线程

欢迎观看，欢迎指正，共同学习

1、网络编程

三要素：
	1、IP地址:表示网络中设备的一个地址
	2、端口:传输数据的通道
	3、协议:遵循的规则
httpS对应百度端口号443
http对应百度端口号80
SSH端口号22
输入IP,优先在本地hosts文件找，找到了就使用，不会继续了，本地找不到，就去公共的DNS(域名解析系统)找对应ip
ncpa.cpl:快速计入网络连接(cmd窗口输入)
网络：实现资源共享和信息传递的虚拟平台

知名端口号:众所周知的端口号   范围0-1023
动态端口号:范围1024-65535
TCP协议:必须先建立连接，再传输数据（安全）
3次握手:建立连接
4次挥手:断开连接

2、socket套接字

定义:进程之间通信的一个工具
进程之间想要进行网络通信需要基于socket
程序：提前写好的，具有特定功能的可执行的文件
进程：正在运行中的程序
功能:进程之间传输内容
AF_INET：特指IPv4
SOCK_STREAM：特指TCP协议
encode编码
decode解码

''默认接受本地地址

#tcp客户端开发
import socket
client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client_socket.connect(('192.168.34.63',8080))
client_socket.send('123646464646'.encode('utf8'))
data = client_socket.recv(1024)
print(data.decode('utf8'))
client_socket.close()

2.1、客户端开发

# 1.导包
import socket
# 2.创建客户端套接字对象
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 3.客户端套接字对象连接服务器
client_socket.connect(('127.0.0.1', 8081))
# 4.客户端套接字对象发送数据给服务器
client_socket.send('你好,服务器'.encode('utf-8'))
# 5.客户端套接字对象接收服务器发送的数据
data = client_socket.recv(1024)
print('接收到服务器发来的消息为:',data.decode('utf-8'))
# 6.关闭客户客户端套接字对象
client_socket.close()

2.2、服务端开发

# 1.导包
import socket

# 2.创建服务器套接字对象
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('未接通的服务器对象:', server_socket)
# 3.服务器套接字对象绑定地址和端口  TODO 地址和端口要封装成元组,且地址可以简写为''
server_socket.bind(('127.0.0.1', 8080))
# 4.服务器套接字对象设置监听数(最大连接数)
server_socket.listen(128)
# 5.服务器套接字对象等待客户端连接 TODO 直到客户端连接为止,然后直接拆包接收新的服务器对象和客户端信息
new_server_socket, client_addr = server_socket.accept()
print('已接通的服务器对象:', new_server_socket)
print('获取到客户端信息为:', client_addr)
# 6.服务器套接字对象接收客户端连接
data = new_server_socket.recv(1024)
print('接收到客户发来的消息为:', data.decode('utf-8'))
# 7.服务器套接字对象接收客户端发送的数据
new_server_socket.send('你好,客户端'.encode('utf-8'))
# 8.关闭服务器套接字对象
new_server_socket.close()
server_socket.close()

2.3、客户端和服务端对话流程步骤：

1、创建服务器对象
2、绑定自己的ip和端口号
3、设置监听器
4、一直等待客户端发送请求
5、创建客户端对象
6、客户连接（服务器ip和端口号）
7、建立连接获取连接后的服务器对象和客户端信息
8、客户端发送信息（编码）
9、服务端接收客户端消息（解码）
服务器端：关闭和客户端1、客户端2、客户端n的链接套接字（不主动关闭）
服务器端：关闭被动套接字（不主动关闭）

3、多任务–Python进程与线程

多任务优势:利用cpu资源，提高执行效率
单任务：一个任务接一个任务执行
多任务：同时执行多任务
多任务的两种表现形式：
	并发：在一段时间内，交替执行任务
	并行：在一段时间内，真正的同时一起执行多个任务

3.1、进程

	
进程（Process）:运行中的程序（cpu资源分配的最小单位）
注意:一个程序运行后至少有一个进程

多进程工作原理：默认创建一个进程（主进程---入口），在主进程可已创建子进程

线程:依附于进程

多进程必须添加main判断创建对象和使用进程对象
注意：
	1、多进程之间不共享全局变量
	2、主进程会等待所有的子进程执行结束再结束
	3、多进程之间是无序的
让子进程跟着主进程一起结束的两种方式
方式一:开启子进程前提前设置守护主进程--daemon=True
方式二:主进程结束强制终止子进程--terminate()
group: 进程组，目前只能使用None
target: 执行的目标任务名
args: 以元组的方式给执行任务传参，元组方式传参一定要和目标任务函数参数的顺序保持一致。
kwargs: 以字典方式给执行任务传参，字典方式传参字典中的key一定要和参数的顺序保持一致
name: 进程名，一般不用设置

def music():
    for i in range(1,6):
        print(f'共5首音乐,正在播放第{i}首音乐')
        time.sleep(0.2)
if __name__ == '__main__':
    print(f'---------主进程:{multiprocessing.current_process().name}第一行代码开始执行------------')
    p = multiprocessing.Process(target=music)
    p.daemon = True
    p.start()
    time.sleep(0.7)
    # p.terminate()
    print(f'---------主进程:{multiprocessing.current_process().name}最后一行代码开始执行------------')

3.2、os模块

os.getpid:获取当前进程的id
os.getppid:获取父进程id
os.kill(进程id,9):强制停止进程

# 导包
import multiprocessing
import os

def code():
    print(f"code子进程:{os.getpid()}")
    print(f"code父进程main:{os.getppid()}")


# 定义一个听音乐任务
def music():
    print(f"music子进程:{os.getpid()}")
    print(f"music父进程main:{os.getppid()}")


if __name__ == '__main__':
    print(f"main主进程:{os.getpid()}")
    print(f"main主进程的父进程pycharm:{os.getppid()}")
    # 创建进程对象
    p1 = multiprocessing.Process(target=code)
    p2 = multiprocessing.Process(target=music)
    # 使用进程对象
    p1.start()
    p2.start()
    
# # 导包
import os
# 去任务管理器查找pycharm或者飞秋的进程id,传参即可
os.kill(27052, 9)

3.3、线程

定义:依附于进程执行，是CPU调度的基本单元
作用:用来实现多任务编程
线程创建步骤：
	1、导入线程模块
	2、通过线程类创建线程对象
	3、启动线程执行任务
线程对象=threading.Thread([group [, target [, name [, args [, kwargs]]]]])
group: 线程组，目前只能使用None
target: 执行的目标任务名
args: 以元组的方式给执行任务传参，元组方式传参一定要和目标任务函数参数的顺序保持一致。
kwargs: 以字典方式给执行任务传参，字典方式传参字典中的key一定要和参数的顺序保持一致
name: 线程名，一般不用设置
多线程
线程传参的两种方式：args，kwargs
注意：
	1. 线程之间执行是无序的
	2. 主线程会等待所有的子线程执行结束再结束
	3. 线程之间共享全局变量
	4. 线程之间共享全局变量数据出现错误问题

全局变量数据错误的解决办法:
	线程同步: 保证同一时刻只能有一个线程去操作全局变量(线程同步的方式:锁)

# 导包
import threading
import time
def coding(num,name):
    for i in range(num):
        print(f'{name}正在编写第{i}行代码...')
def music(count,name):
    for i in range(count):
        print(f'{name}正在听第{i}首歌')
        time.sleep(0.2)
if __name__ == '__main__':
    coding_thread = threading.Thread(target=coding,args=(3,'小明'))
    music_thread = threading.Thread(target=music,kwargs={'name':'小明',"count":3})
    coding_thread.start()
    music_thread.start()

3.3.1、互斥锁

定义: 对共享数据进行锁定，保证同一时刻只有一个线程去操作。
 注意：互斥锁是多个线程一起去抢
 使用流程：
 	1、互斥锁的创建
 	2、上锁
 	3、释放锁

3.3.2、死锁

定义:一直等待对方释放锁的情景就是死锁。
原因:未在合适的地方释放锁
结果: 会造成应用程序的停止响应,应用程序无法再继续往下执行了

3.4、区别

进程线程区别：
    1. 进程之间不共享全局变量
    2. 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁
    3. 创建进程的资源开销要比创建线程的资源开销要大
    4. 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
    5. 线程不能够独立执行，必须依存在进程中
    6. Python中多进程开发比单进程多线程开发稳定性要强
多进程与多线程的区别：
	1、多进程不能共享全局变量
	2、多线程可以共享全局变量
	3、多进程相对线程来说是稳定的
	4、多进程可以真正实现同时操作,提升效率
	5、多线程充分利用cpu资源,多线程快速交替执行任务