Python笔记(四)

最新推荐文章于 2024-09-11 11:08:16 发布
最新推荐文章于 2024-09-11 11:08:16 发布
阅读量1k 收藏 21
点赞数 16
分类专栏： Python 文章标签： python 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41878442/article/details/135437117
版权

1. 多任务

多任务是指同一时间内执行多个任务，例如电脑可以同时运行多个软件。
并发是一段时间交替执行任务。并行是同时一起执行多个任务。
实现多任务有两种方式，一种是多进程，另一种是多线程。

1.1 多进程

进程是操作系统进行资源分配和调度运行的基本单位，通俗的说，一个正在运行的程序就是一个进程。

1.1.1 进程创建的步骤

  1. 导入进程模块
  2. 创建进程对象
  3. 启动进程执行任务
import multiprocessing
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''


def playGame():
    for i in range(10):
        print("正在打游戏")
        time.sleep(1)


def listenMusic():
    for i in range(10):
        print("正在听音乐")
        time.sleep(0.5)


if __name__ == '__main__':
	# 创建进程对象
    pro_game = multiprocessing.Process(target=playGame)
    pro_music = multiprocessing.Process(target=listenMusic)
    # 启动进程
    pro_game.start()
    pro_music.start()

在这里插入图片描述

1.1.2 进程传参

创建进程对象的时候，要告诉进程执行的是哪个方法，所以需要添加target参数。
例如：pro_game = multiprocessing.Process(target=playGame)
如果方法需要传递参数，可以添加args或者kwargs来给方法传入参数。
args：通过元组的形式给任务名传递参数，要注意参数的传递顺序
kwargs：通过字典的方式给任务名传递参数，key值要和参数名对应。

import multiprocessing
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''


def playGame(name):
    for i in range(10):
        print(f"正在玩{name}")
        time.sleep(1)


def listenMusic(name):
    for i in range(10):
        print(f"正在听{name}")
        time.sleep(0.5)


if __name__ == '__main__':
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()

在这里插入图片描述

1.1.3 进程的执行顺序

在程序中创建两个进程后，执行顺序不固定，因为程序是自上而下运行的，所以首先会先执行前面的进程，然后执行后面的进程，但是后面执行进程的顺序就不固定了。

  1. 获取进程编号： os.getpid()
  2. 获取当前父进程编号：os.getppid()
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''


def playGame(name):
    for i in range(10):
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)


def listenMusic(name):
    for i in range(10):
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()

在这里插入图片描述

1.1.4 主、子进程相互独立，全局变量不共享

程序执行后，会默认启动一个主进程，然后主进程去创建和执行其余子进程。
程序创建的全局变量，主进程和子进程之间不共享。子进程和子进程之间的全局变量也不共享

import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()
    time.sleep(5)
    print(f"主进程的run_num的值为：{run_num}")

在这里插入图片描述

1.1.5 进程的结束

  1. 默认情况下，主进程会等待所有的子进程执行结束后，再结束。
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")
    print("game进程执行完毕")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")
    print("music进程执行完毕")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    pro_game.start()
    pro_music.start()
    time.sleep(3)
    print(f"主进程的run_num的值为：{run_num}")
    print("主进程执行完毕")

在这里插入图片描述

  1. 主进程结束后，立刻杀掉子进程，可以设置守护主进程，即主进程退出后，子进程直接销毁。例如：pro_game.daemon = True
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")
    print("game进程执行完毕")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")
    print("music进程执行完毕")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    # 设置守护主进程
    pro_game.daemon = True
    pro_music.daemon = True
    pro_game.start()
    pro_music.start()
    time.sleep(3)
    print(f"主进程的run_num的值为：{run_num}")
    print("主进程执行完毕")

在这里插入图片描述

  1. 除此设置守护主进程外，还可以在退出前，手动销毁子进程。例如：pro_game.terminate()
import multiprocessing
import os
import time

'''
进程创建的步骤：
1. 导入包
2. 创建进程对象
3. 启动进程执行任务
'''
# 定义全局变量
run_num = 0


def playGame(name):
    for i in range(10):
        global run_num
        print(f"正在玩{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.6)
        run_num += 1
        print(f"game进程的run_num的值为：{run_num}")
    print("game进程执行完毕")


def listenMusic(name):
    for i in range(10):
        global run_num
        print(f"正在听{name},进程编号是{os.getpid()},父进程编号是{os.getppid()}")
        time.sleep(0.5)
        run_num += 1
        print(f"music进程的run_num的值为：{run_num}")
    print("music进程执行完毕")


if __name__ == '__main__':
    # 获取当前进程的编号
    print(os.getpid())
    run_num = 1
    pro_game = multiprocessing.Process(target=playGame, args=('原神',))
    pro_music = multiprocessing.Process(target=listenMusic, kwargs={"name": "《留香》"})
    # 设置守护主进程
    # pro_game.daemon = True
    # pro_music.daemon = True
    pro_game.start()
    pro_music.start()
    time.sleep(3)
    print(f"主进程的run_num的值为：{run_num}")
    # 手动销毁子进程
    pro_game.terminate()
    pro_music.terminate()
    print("主进程执行完毕")

在这里插入图片描述

1.2 多线程

多线程是实现多任务的另一种方式。

1.2.1 什么是线程

线程是程序执行的最小单位，一个进程中最少有一个线程来负责执行程序。

1.2.2 创建线程的步骤

  1. 导入模块 threading
  2. 创建线程对象
    threading.Thread(target=任务名),其中任务名为函数或者是方法
  3. 启动线程
    线程对象.start()
import os
import threading
import time


def playGame():
    for i in range(10):
        print("正在玩游戏")
        time.sleep(0.6)


def listenMusic():
    for i in range(10):
        print("正在听音乐")
        time.sleep(0.3)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame)
    th_music = threading.Thread(target=listenMusic)
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述

1.2.3 线程的传参

参数传递有两种，分别是：

  1. args 元组的形式传递参数，但是要注意和参数顺序保持一致
  2. kwargs 字典的形式传递参数，要注意字典的key和参数要一一对应。
import os
import threading
import time


def playGame(cont):
    for i in range(10):
        print(f"正在玩{cont}")
        time.sleep(0.6)


def listenMusic(cont):
    for i in range(10):
        print(f"正在听{cont}")
        time.sleep(0.3)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame, args=("元梦之星", ))
    th_music = threading.Thread(target=listenMusic, kwargs={"cont": "《萤火飞光》"})
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述

1.2.4 线程的执行顺序

多个线程之间的执行是无顺序的，是由CPU调度决定的执行顺序。线程的结束顺序和进程类似，也是主线程等待子线程结束后才结束。所以也可以设置守护主线程让主线程结束时，子线程也结束。以下为设置的两种方法：

  1. th_game.daemon = True
  2. th_music.setDaemon(True)
import os
import threading
import time


def playGame(cont):
    for i in range(10):
        print(f"正在玩{cont}")
        time.sleep(0.6)


def listenMusic(cont):
    for i in range(10):
        print(f"正在听{cont}")
        time.sleep(0.3)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame, args=("元梦之星", ))
    th_music = threading.Thread(target=listenMusic, kwargs={"cont": "《萤火飞光》"})
    # 设置守护主线程
    th_game.daemon = True
    th_music.setDaemon(True)
    # 启动线程
    th_game.start()
    th_music.start()
    time.sleep(1)
    print("主线程结束")

在这里插入图片描述
查看当前的线程信息：threading.current_thread()

1.2.5 互斥锁

多个线程之间可以共享全局变量，但是这样会出现一个问题，就是实际产生的数据会和预期的产生偏差。解决方法为：要么合理优化时间，让程序交叉运行，要么使用互斥锁。
互斥锁是对共享数据进行锁定，保证同一时刻只有一个线程去操作。
互斥锁的使用方法：

  1. 创建互斥锁 my_lock = threadning.Lock()
  2. 上锁 my_lock.acquire()
  3. 释放锁 my_lock.relase()
    例如：创建两个线程，分别循环累加100万次，最后打印累加次数。
import threading
import time

# 定义全局变量
num = 0


def playGame():
    global num
    for i in range(1000000):
        num += 1
    print(num)


def listenMusic():
    global num
    for i in range(1000000):
        num += 1
    print(num)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame)
    th_music = threading.Thread(target=listenMusic)
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述
正常结果应该是打印2000000
使用互斥锁优化程序：

import threading
import time

# 定义全局变量
num = 0
# 创建锁
my_lock = threading.Lock()


def playGame():
    global num
    for i in range(1000000):
        # 上锁
        my_lock.acquire()
        num += 1
        # 释放锁
        my_lock.release()
    print(num)


def listenMusic():
    global num
    for i in range(1000000):
        # 上锁
        my_lock.acquire()
        num += 1
        # 释放锁
        my_lock.release()
    print(num)


if __name__ == '__main__':
    # 创建线程对象
    th_game = threading.Thread(target=playGame)
    th_music = threading.Thread(target=listenMusic)
    # 启动线程
    th_game.start()
    th_music.start()

在这里插入图片描述

1.2.6 死锁

死锁是指一直等待对方释放锁的情景，死锁会导致程序无法执行。所以在使用锁的时候，要合理的安排释放。

1.3 进程和线程的区别和联系

举个简单的小例子：ceyyen想和山石和海棠聊天。于是打开了两个聊天软件，这就是打开了两个进程。
第二天，ceyyen还是想和山石和海棠聊天，打开了聊天软件的两个窗口，这就是打开了两个线程。
上述例子中，线程明显节约资源。
进程和线程的联系和区别如下：

  1. 线程无法独立运行，线程依附于进程，没有进程就没有线程。
  2. 一个进程可以创建多个线程。
  3. 进程间不共享全局变量，线程之间共享，但是会有资源竞争，可以使用互斥锁解锁。
  4. 创建进程的开销比线程大。进程可以使用多核，线程不能使用。
  5. 进程是操作系统分配的基本单位，线程是CPU调度的基本单位。

2 网络和Socket编程

2.1 网络

网络是实现资源共享和信息传递的虚拟平台。
通过IP可以找到网络中唯一的一台设备，然后与之进行通信。
通过端口号可以找到网络设备种运行的应用程序。
IP地址类型分为IPV4和IPV6，目前使用的主要是IPV4。
在Linux中，可以通过ifconfig命令去查看网卡信息。还可以通过ping命令去检查网络是否连通，以及telnet去检查端口号是否连通。

ping www.baidu.com
telnet 127.0.0.1 8000

2.2 Socket

Socket是程序之间通信的一个工具，遵从TCP传输控制协议。
TCP是面向连接的、可靠的。基于字节流的传输层通信协议。
TCP通信步骤可以总结性的分为3步：

  1. 创建连接
  2. 传输数据
  3. 关闭连接

2.1 TCP客户端

创建一个TCP客户端主要分为以下5步：

  1. 创建客户端套接字对象
my_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 选择IPV4和TCP协议
  1. 和服务端套接字建立连接
my_client.connect(("127.0.0.1", 666))  # 以元组的形式传递连接地址和端口
  1. 发送数据
my_client.send(data.encode("utf-8"))  # 以字节的方式将信息转换
  1. 接收数据
recv_data = my_client.recv(1024).decode("utf-8")  # 将接收的数据转换成对应格式的数据
  1. 关闭套接字
my_client.close()

2.2 TCP服务端

创建一个TCP客户端主要分为以下几步：

  1. 创建服务端套接字对象
my_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  1. 设置端口复用
my_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
  1. 绑定IP和端口号
my_server.bind(("127.0.0.1", 666))
  1. 设置监听
my_server.listen(128)	# 128：代表服务端等待排队连接的最大数量
  1. 等待客户端的连接请求
conn, addr = my_server.accept()
  1. 接收数据
recv_data = con.recv(1024)
  1. 发送数据
con.send(data.encode("utf-8"))
  1. 关闭连接
con.close()
my_server.close()

2.3 聊天功能

利用TCP客户端和TCP服务端可以实现简单的聊天功能。
主要实现思路：

  1. 服务端循环等待客户端的连接请求
  2. 服务端/客户端收发信息全为手工输入
  3. 使用多线程去连接多个客户端
山石满棠
关注
专栏目录
python学习心得（2）多进程顺序执行
weixin_41950973的博客
05-22 970
参照我的上一篇多线程的顺序执行https://blog.csdn.net/weixin_41950973/article/details/106213436 今天，同一个问题用进程来解决。注意点是，进程之间是完全独立的，所以在用condition对象时，需要将condition对象作为参数传递到进程类中，其他都和我上一篇的多线程的解决方法一致。（开始没有注意到这一点，完全照搬多线程的做法，总是得不到想要的结果，郁闷了半天。。。） 问：生成5个进程按照顺序来输出1234512345... 。其中1为进程1
python多进程multiprocessing使用，看这篇就够了(二)
qq_38120851的博客
01-20 1179
通过继承来创建子进程、创建进程池
Python多任务执行：进程【①多进程执行顺序是无序的，由操作系统调度】、线程【①多线程执行顺序是无序的，由CPU调度；②主线程会等所有子线程执行结束后再结束；③线程间共享全局变量；④互斥锁；⑤死锁】
u013250861的博客
09-09 394
在Python程序中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。前面我们使用进程执行的任务是没有参数的，假如我们使用进程执行的任务带有参数，如何给函数传参呢?args 表示以元组的方式给执行任务传参kwargs 表示以字典方式给执行任务传参进程之间不共享全局变量主进程会等待所有的子进程执行结束再结束在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。
Python 中的多线程与多进程详解
最新发布
weixin_59113684的博客
09-11 1425
介绍Python多进程和多线程两种并发编程方式的优势和局限性
【工程实践】python实现多进程
Dong_ZH的博客
06-21 2767
Python中比较常见的并发方式主要有两种：多线程和多进程。多线程即在一个进程中启动多个线程执行任务。一般来说使用多线程可以达到并行的目的，但由于Python中使用了全局解释锁GIL的概念，导致Python中的多线程并不是并行执行，而是“交替执行”。类似于下图。所以Python中的多线程适合IO密集型任务，而不适合计算密集型任务。Python提供两组多线程接口，一是thread模块_thread，提供低等级接口。
Python多进程
NeilNiu
07-17 1199
为了保证子进程能够正常的运行，主进程会等所有的子进程执行完成以后再销毁，设置守护主进程的目的是主进程退出子进程销毁，不让主进程再等待子进程去执行。并发指的是，假如单核的cpu，要同时运行多个任务，这个时候就需要不断的切换任务，只是切换的比较快，没有分辨出来。并行，是假如是2核的cpu，有两个任务要运行，一个cpu执行一个任务，这个时候两个任务同时运行，就是并行。1、主进程默认会等待所有的子进程执行结束再结束，保证子进程都结束掉。2、子进程设置守护主进程，一旦主进程结束，所有的子进程自动销毁。...
python笔记四-运算符、条件控制、循环语句.xmind
06-22
思维导图梳理Python学习笔记（四）运算符、条件控制、循环语句部分。供学习参考，仅适合初学者。大佬请绕行
python核心笔记.pdf
03-26
【第三章 Python基础】和【第四章 Python对象】详细阐述了Python的基础语法，包括变量、数据类型、操作符、控制结构等。Python中的基础数据类型如数字（【第五章】）、序列（如字符串、列表和元组，【第六章】）、...
马哥python课堂笔记-马哥教育PYTHON相关基础笔记.pdf
06-14
在马哥教育的PYTHON相关基础笔记中，我们看到几个关键知识点： 1. **推荐书籍**：学习Python时，有几本经典教材值得参考，包括《Python Cookbook》、《Learn Python the Hard Way》、《Google's Python Class》以及...
小甲鱼python教程笔记
08-21
小甲鱼 Python 教程笔记 本教程笔记涵盖了 Python 的基础知识点，包括变量、字符串、列表、元组、布尔类型、逻辑运算符、循环结构、列表访问、成员资格运算符、is 运算符、引用和拷贝、列表推导式、元组的使用、...
Python笔记 ,python笔记全,Python源码.zip
10-15
这份“Python笔记全,Python源码”的压缩包很可能是为了帮助初学者或有经验的开发者深入理解Python语言的核心概念和实践技巧。以下是根据标题和描述可能包含的一些关键知识点： 1. **基础语法**：Python的基础包括...
线程与进程，并发与并行区别
qq_43751200的博客
10-03 1378
进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序就是一个进程从创建，运行到消亡的过程。 线程:线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少由一个线程。一个进程中是可以由多个线程的，这个应用程序也可以称之为多线程程序。 简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。 并发：指两个或多个事物在同一时间段内完成； 并行：指两个或多个事物在同一时
Python 多线程如何按照任务优先级顺序执行，并根据任务分配来申请线程锁
PittDing的博客
04-01 1199
python 多线程处理任务，并根据任务的优先级排序执行
Python_多进程_创建进程池
weixin_30872733的博客
08-10 180
多进程_创建进程池 一、进程池概括 1、进程池说明 2、进程池方法 二、获取cpu操作核数 import multiprocessing multiprocessing.cpu_count() 运行结果 三、多进程_进程池&单进程的效率比对 #coding:utf-8 importmultiprocessing import...
Python进程——multiprocessing.Event(）多进程执行顺序控制
weixin_43794311的博客
04-25 3667
参考：https://blog.csdn.net/HAH_HAH/article/details/105276221 总结 multiprocessing.Event()针对的是所有的进程，因此下面引用参考的代码的执行过程如下图 一个进程中解除另一个进程的阻塞。 import multiprocessing,time,random def restaurant_handle(event): #餐厅的处理进程 print("1、【餐厅】为食客安排座位，并在一旁等待食客点餐。。。") time
Python多进程代码示例
热门推荐
Ghjkku的博客
07-08 13万+
Python多进程代码示例
python多进程并行执行和顺序执行的时间测试
weixin_33904756的博客
02-21 435
#_*_coding:utf-8_*_ importtime frommultiprocessingimportPool fromthreadingimportThread deffunc1(fn): time.sleep(1) returnfn*fn if__name__=="__main__": a=[1,...
python3多进程执行循环_python多进程程序的执行次序
weixin_33805938的博客
03-01 274
这是我的程序：import os,timefrom multiprocessing import Processdef run_proc(name):print('child process %s (%s) running ...' %(name,os.getpid()))print('process will start'+name)time.sleep(5)print('end '+name...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值