【Python基础】进程

文章目录

    • @[toc]
      • 程序与进程的区别与联系
      • 同步任务
        • 示例
      • 并行任务
        • 示例
        • 进程调度的“随机性”
      • 进程属性与方法
        • process_object.start()方法
        • process_object.join()方法
        • process_object.daemon属性
          • 没有设置守护进程的情况
          • 设置守护进程的情况
        • process_object.current_process()方法
      • 进程通信
        • 队列的使用
          • put()方法与full()方法
          • get()方法与empty()方法
          • put_nowait()方法
          • get_nowait()方法
          • task_done()方法与join()方法
            • 队列内置计数器的值不为0
            • 队列内置计数器的值为0
        • 使用队列完成进程通信
      • 进程池
        • multiprocessing.Pool
        • ProcessPoolExecutor API
          • 进程池的创建
          • done()方法
          • cancel()方法
          • result()方法
          • as_completed()方法
          • map()方法
          • wait()方法
      • 自定义进程类
        • 示例

因上努力

个人主页：丷从心·

系列专栏：Python基础

学习指南：Python学习指南

果上随缘

程序与进程的区别与联系

  • 程序是指存储在磁盘或其他存储介质上的一组指令或代码，是静态文件
  • 进程是程序的执行实例，是一个动态的实体，具有独立的内存空间和系统资源

同步任务

  • 我们在此之前编写的代码都是同步代码，代码从上到下按顺序执行，如果前一个任务没有完成，那么不能运行之后的任务
示例
import timedef work_1():print('任务1...')time.sleep(2)def work_2():print('任务2...')time.sleep(2)start = time.time()work_1()
work_2()end = time.time()print(f'总共用时: {end - start} s')

任务1...
任务2...
总共用时: 4.020323038101196 s
  • 可以看到整个程序用时 4 4 4秒，work_2()需要等待work_1()运行结束后才能运行

并行任务

  • 使用进程来运行上面的代码，能够优化运行时间
示例
import time
import multiprocessingdef work_1():print('任务1...')time.sleep(2)def work_2():print('任务2...')time.sleep(2)# Windows 操作系统下进程任务必须拥有 main 入口
if __name__ == '__main__':# 通过 Process 类创建进程对象, 并使用 target 绑定进程对象要运行的任务p1 = multiprocessing.Process(target=work_1)p2 = multiprocessing.Process(target=work_2)start = time.time()# 运行进程p1.start()p2.start()p1.join()p2.join()end = time.time()print(f'总共用时: {end - start} s')

任务1...
任务2...
总共用时: 2.6914994716644287 s
  • 可以看到整个程序用时约 3 3 3秒，work_1()和work_2并行运行
进程调度的“随机性”
  • 下面的示例可以看到操作系统调度进程时的“随机性”
import time
import threadingdef work_1():for i in range(5):print('任务1...')time.sleep(2)def work_2():for i in range(5):print('任务2...')time.sleep(2)t1 = threading.Thread(target=work_1)
t2 = threading.Thread(target=work_2)t1.start()
t2.start()

任务2...
任务1...
任务1...
任务2...
任务2...
任务1...
任务1...
任务2...
任务2...
任务1...
  • 可以看到任务 1 1 1和任务 2 2 2的调度顺序是我们无法确定的，是由操作系统的调度算法决定的

进程属性与方法

  • 在学习进程方法之前，我们需要知道Python程序是如何被运行的
    • 一个Python文件被解释器运行时会在操作系统中创建一个进程
    • 然后该进程会创建一个线程来运行文件中的代码，这个程序最初创建的线程称为主线程
    • 当主线程运行到p = multiprocessing.Process()时会创建一个新的进程，称为子进程
    • 主进程与子进程由操作系统进行调度，并发地运行，具体如何调度进程由操作系统的调度算法决定
    • 子进程在运行时，主进程不会等待子进程，而是继续向下执行，直到执行到文件末尾没有代码时，主进程会等待子进程运行结束后再退出
process_object.start()方法

  • p = multiprocessing.Process()只是创建了一个进程，并不会运行进程代码

  • p.start()使进程p达到就绪状态，等待操作系统进行调度，具体何时调度由操作系统决定

  • 以上面的并行任务的代码为例，先注释掉p1.join()和p2.join()

import time
import multiprocessingdef work_1():print('任务1...')time.sleep(2)def work_2():print('任务2...')time.sleep(2)# Windows 操作系统下进程任务必须拥有 main 入口
if __name__ == '__main__':# 通过 Process 类创建进程对象, 并使用 target 绑定进程对象要运行的任务p1 = multiprocessing.Process(target=work_1)p2 = multiprocessing.Process(target=work_2)start = time.time()# 运行进程p1.start()p2.start()# p1.join()# p2.join()end = time.time()print(f'总共用时: {end - start} s')

总共用时: 0.012919902801513672 s
任务1...
任务2...
  • 可以看到主进程没有等待子进程，而是继续向下执行
  • 当执行到end = time.time()时，此时end记录的时间是主进程运行到这行代码的时间
  • 之后运行print(f'总共用时: {end - start} s')，输出时间0.012919902801513672 s，此时执行到了文件末尾没有其他代码，主进程会等待子进程运行结束后再退出
  • 为了能正确记录进程运行的时间，我们需要让主进程等待子进程
process_object.join()方法
  • p.join()使主进程等待子进程，子进程任务执行结束后主进程再继续向下执行
  • 仍然以上面的并行任务的代码为例，取消注释p1.join()和p2.join()
import time
import multiprocessingdef work_1():print('任务1...')time.sleep(2)def work_2():print('任务2...')time.sleep(2)# Windows 操作系统下进程任务必须拥有 main 入口
if __name__ == '__main__':# 通过 Process 类创建进程对象, 并使用 target 绑定进程对象要运行的任务p1 = multiprocessing.Process(target=work_1)p2 = multiprocessing.Process(target=work_2)start = time.time()# 运行进程p1.start()p2.start()p1.join()p2.join()end = time.time()print(f'总共用时: {end - start} s')

任务1...
任务2...
总共用时: 2.6913790702819824 s
  • 可以看到主进程等待子进程运行结束后才继续向下执行，正确记录了子进程运行的时间
process_object.daemon属性
  • 设置守护进程，需要在进程启动之前进行设置
  • 如果一个进程是守护进程，那么主进程运行到文件末尾后不论子进程任务是否结束都会自动退出
没有设置守护进程的情况
import time
import multiprocessingdef work():for i in range(5):print(i)time.sleep(1)if __name__ == '__main__':p = multiprocessing.Process(target=work)# p.daemon = Truep.start()print('主进程即将退出...')

主进程即将退出...
0
1
2
3
4
设置守护进程的情况
import time
import multiprocessingdef work():for i in range(5):print(i)time.sleep(1)if __name__ == '__main__':p = multiprocessing.Process(target=work)p.daemon = Truep.start()print('主进程即将退出...')

主进程即将退出...
  • 可以看到并没有输出 0 0 0、 1 1 1、 2 2 2、 3 3 3、 4 4 4，主进程就退出了
process_object.current_process()方法
  • process_object.current_process()方法用于获取当前进程对象的引用
  • 可以用来获取进程名称和进程号
import multiprocessing
import osdef work():pid = multiprocessing.current_process().pidppid = os.getppid()name = multiprocessing.current_process().nameprint(f'pid: {pid},\t ppid: {ppid}, name: {name}')if __name__ == '__main__':for i in range(5):t = multiprocessing.Process(target=work)t.name = f'进程-{i}'t.start()t.join()

pid: 16464,	 ppid: 23240, name: 进程-0
pid: 21140,	 ppid: 23240, name: 进程-1
pid: 7884,	 ppid: 23240, name: 进程-2
pid: 19412,	 ppid: 23240, name: 进程-3
pid: 6196,	 ppid: 23240, name: 进程-4
  • os.getppid()方法用于获取进程的父进程号

进程通信

队列的使用
put()方法与full()方法
  • put()方法用于将数据上传到队列
  • full()方法用于判断队列是否已满
from queue import Queuequeue = Queue(3)  # 设置队列最大容量为 3queue.put(1)
queue.put(2)
queue.put(3)print(queue.full())queue.put(4)  # 因为队列已满, 所以会导致阻塞, 直到队列重新有空闲空间时解阻塞

True
  • 当队列中已满时，使用put()方法会阻塞，直到队列重新重新有空闲空间时解阻塞
get()方法与empty()方法
  • get()方法用于从队列中读取数据
  • empty()方法用于判断队列是否为空
from queue import Queuequeue = Queue()queue.put(1)
queue.put(2)
queue.put(3)print(queue.get())
print(queue.get())
print(queue.get())
print(queue.get())  # 因为队列为空, 所以会导致阻塞, 直到队列重新有数据时解阻塞

1
2
3
  • 当队列中为空时，使用get()方法会阻塞，直到队列重新有数据时解阻塞
put_nowait()方法
  • put_nowait()方法用于向队列中上传数据，如果队列已满，则抛出异常
from queue import Queuequeue = Queue(3)  # 设置队列最大容量为 3queue.put(1)
queue.put(2)
queue.put(3)queue.put_nowait(4)  # 如果队列已满, 则抛出异常

Traceback (most recent call last):File "C:/Users/FOLLOW_MY_HEART/Desktop/Python Basics/【Python基础】进程/test.py", line 9, in <module>queue.put_nowait(4)  # 如果队列已满, 则抛出异常File "D:\Environment\anaconda\envs\py310\lib\queue.py", line 191, in put_nowaitreturn self.put(item, block=False)File "D:\Environment\anaconda\envs\py310\lib\queue.py", line 137, in putraise Full
queue.Full
get_nowait()方法
  • get_nowait()方法用于从队列中读取数据，如果队列为空，则抛出异常
from queue import Queuequeue = Queue()queue.put(1)
queue.put(2)
queue.put(3)print(queue.get())
print(queue.get())
print(queue.get())
print(queue.get_nowait())  # 如果队列为空, 则抛出异常

1
2
3
Traceback (most recent call last):File "C:/Users/FOLLOW_MY_HEART/Desktop/Python Basics/【Python基础】进程/test.py", line 12, in <module>print(queue.get_nowait())  # 如果队列为空, 则抛出异常File "D:\Environment\anaconda\envs\py310\lib\queue.py", line 199, in get_nowaitreturn self.get(block=False)File "D:\Environment\anaconda\envs\py310\lib\queue.py", line 168, in getraise Empty
_queue.Empty
task_done()方法与join()方法

  • queue.get()会使队列内置计数器的值加 1 1 1，而queue.get()不会使队列内置计数器的值减 1 1 1

  • task_done()方法用于将队列内置计数器的值减 1 1 1

  • join()方法用于判断队列内置计数器的值是否为 0 0 0，如果不为 0 0 0则会阻塞，直到队列内置计数器的值为 0 0 0时解阻塞

队列内置计数器的值不为0
from queue import Queuequeue = Queue()
queue.put(1)queue.get()queue.join()print('不能运行到这里...')
队列内置计数器的值为0
from queue import Queuequeue = Queue()
queue.put(1)queue.get()
queue.task_done()queue.join()print('能够运行到这里...')

能够运行到这里...
使用队列完成进程通信
from multiprocessing import Process, Queue, Event# 向队列中写入数据
def write(queue, event):for num in range(10):queue.put(num)event.set()print('正在上传...')queue.put('END')event.set()# 从队列中读取数据
def read(queue, event):while True:event.wait()num = queue.get()if num == 'END':breakprint(f'从队列中读取到的数据为: {num}')if __name__ == '__main__':# 创建队列对象queue = Queue()event = Event()p_write = Process(target=write, args=(queue, event))p_read = Process(target=read, args=(queue, event))p_write.start()p_read.start()p_write.join()p_read.join()print('任务完成...')

正在上传...
从队列中读取到的数据为: 0
正在上传...
从队列中读取到的数据为: 1
正在上传...
正在上传...
正在上传...
从队列中读取到的数据为: 2
正在上传...
从队列中读取到的数据为: 3
从队列中读取到的数据为: 4
从队列中读取到的数据为: 5
正在上传...
正在上传...
正在上传...
从队列中读取到的数据为: 6
从队列中读取到的数据为: 7
从队列中读取到的数据为: 8
正在上传...
从队列中读取到的数据为: 9
任务完成...

进程池

  • 进程对象的创建需要时间，在需要创建大量进程对象的时候会发生性能下降的情况
  • 使用进程池会创建出一定数量的进程对象，并且进程在执行完任务后不会被操作系统销毁，这样下一个任务可以重复使用之前创建的这些进程对象
multiprocessing.Pool
import time
import os
from multiprocessing import Pooldef get_html(page):time.sleep(1)pid = os.getpid()print(f'pid: {pid},\t Successfully obtained page {page}...')return pageif __name__ == '__main__':# 创建进程池对象pool = Pool(3)# 通过 apply_async 提交需要异步执行的函数到进程池中for i in range(10):pool.apply_async(get_html, args=(i,))pool.close()  # 关闭进程池提交pool.join()

pid: 20516,	 Successfully obtained page 1...
pid: 23224,	 Successfully obtained page 0...
pid: 15036,	 Successfully obtained page 2...
pid: 23224,	 Successfully obtained page 4...
pid: 20516,	 Successfully obtained page 3...
pid: 15036,	 Successfully obtained page 5...
pid: 20516,	 Successfully obtained page 7...
pid: 23224,	 Successfully obtained page 6...
pid: 15036,	 Successfully obtained page 8...
pid: 20516,	 Successfully obtained page 9...
ProcessPoolExecutor API
进程池的创建
import time
from concurrent.futures import ProcessPoolExecutordef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=2)# 通过 submit 提交需要执行的函数到进程池中task_1 = executor.submit(get_html, 1)task_2 = executor.submit(get_html, 2)

Successfully obtained page 1...
Successfully obtained page 2...
done()方法
  • done()方法用于判断某个任务是否完成
import time
from concurrent.futures import ProcessPoolExecutordef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=2)# 通过 submit 提交需要执行的函数到进程池中task_1 = executor.submit(get_html, 1)task_2 = executor.submit(get_html, 2)# done() 方法用于判断某个任务是否完成print(f'task_1 完成情况: {task_1.done()}')

task_1 完成情况: False
Successfully obtained page 1...
Successfully obtained page 2...
cancel()方法
  • cancel()方法用于取消未运行的任务，已经运行的任务无法被取消
import time
from concurrent.futures import ProcessPoolExecutordef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=1)# 通过 submit 提交需要执行的函数到进程池中task_1 = executor.submit(get_html, 1)task_2 = executor.submit(get_html, 2)# cancel() 方法用于取消未运行的任务, 已经运行的任务无法被取消print(f'task_2 任务取消: {task_2.cancel()}')

task_2 任务取消: True
Successfully obtained page 1...
  • 通过将max_workers的值修改为 1 1 1，使得task_2未能运行时就被取消
result()方法
  • submit()方法的返回值是一个future对象
  • 通过对future对象调用result()方法可以获取任务的返回值
import time
from concurrent.futures import ProcessPoolExecutordef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=2)# 通过 submit 提交需要执行的函数到进程池中task_1 = executor.submit(get_html, 1)task_2 = executor.submit(get_html, 2)# 通过对 future 对象调用 result() 方法获取任务的返回值print(f'task_1 返回结果: {task_1.result()}')print(f'task_2 返回结果: {task_2.result()}')

Successfully obtained page 1...
Successfully obtained page 2...
task_1 返回结果: 1
task_2 返回结果: 2
as_completed()方法
  • as_completed()方法用于获取已经执行成功的任务的返回值
import time
from concurrent.futures import ProcessPoolExecutor, as_completeddef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=2)page_list = [1, 2, 3, 4]# 批量提交任务并获取已经执行成功的任务的返回值all_tasks = [executor.submit(get_html, page) for page in page_list]# 只要进程任务执行完就能获取到返回值, 完成一个任务获取一个任务的返回值for future in as_completed(all_tasks):data = future.result()print(f'Get data {data}')

Successfully obtained page 1...
Successfully obtained page 2...
Successfully obtained page 3...
Get data 1
Successfully obtained page 4...
Get data 2
Get data 3
Get data 4
map()方法
  • map()方法用于提交任务并获取已经执行成功的任务的返回值
import time
from concurrent.futures import ProcessPoolExecutordef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=2)page_list = [1, 2, 3, 4]# map() 方法用于提交任务并获取已经执行成功的任务的返回值for data in executor.map(get_html, page_list):print(f'Get data {data}')  # 打印的返回值顺序与列表顺序一致

Successfully obtained page 1...
Successfully obtained page 2...
Successfully obtained page 3...
Successfully obtained page 4...
Get data 1
Get data 2
Get data 3
Get data 4
wait()方法
  • wait()方法用于使主进程堵塞，直到指定任务完成后，主进程才解堵塞
import time
from concurrent.futures import ProcessPoolExecutor, waitdef get_html(page):print(f'Successfully obtained page {page}...')time.sleep(1)return pageif __name__ == '__main__':# 创建进程池对象executor = ProcessPoolExecutor(max_workers=2)page_list = [1, 2, 3, 4]# 批量提交任务并获取已经执行成功的任务的返回值all_tasks = [executor.submit(get_html, page) for page in page_list]# wait() 方法用于使主进程堵塞, 直到指定任务完成后, 主进程才解堵塞wait(all_tasks)print('主进程解堵塞, 执行剩余代码...')

Successfully obtained page 1...
Successfully obtained page 2...
Successfully obtained page 3...
Successfully obtained page 4...
主进程解堵塞, 执行剩余代码...

自定义进程类

  • 自定义进程类需要继承Process类
  • 需要重写Process类中的run()方法，用于运行进程任务
示例
import requests
import multiprocessingclass ProcessSpider(multiprocessing.Process):def __init__(self, url):super().__init__()self.url = urldef run(self):response = requests.get(self.url).contentfile_name = self.url.split('/')[-1]with open(file_name, 'wb') as f:f.write(response)print('下载完成...')if __name__ == '__main__':url_list = ['http://pic.bizhi360.com/bbpic/98/10798.jpg','http://pic.bizhi360.com/bbpic/92/10792.jpg','http://pic.bizhi360.com/bbpic/86/10386.jpg']for url in url_list:process_spider = ProcessSpider(url)process_spider.start()

下载完成...
下载完成...
下载完成...

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/1411629.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

（三）Appdesigner-界面转换及数据导入和保存

（三）Appdesigner-界面转换及数据导入和保存

提示&#xff1a;文章为系列文章&#xff0c;可以在对应学习专栏里面进行学习。对应资源已上传 目录 前言 一、Appdesigner是什么&#xff1f; 二、界面切换 三、数据导入及保存 &#xff08;一&#xff09;数据导入 &#xff08;二&#xff09;数据保存 总结 前言 Appd…
阅读更多...
ZooKeeper数据模型你懂吗？

ZooKeeper数据模型你懂吗？

ZooKeeper数据节点你知道吗&#xff1f;那数据节点有什么类型&#xff1f;数据节点的版本呢&#xff1f;听说ZooKeeper还有事务ID&#xff0c;你知不知道啊&#xff1f;还有Watcher机制呢&#xff1f;ZooKeeper作为一个典型的分布式数据一致性的解决方案&#xff0c;ZooKeeper的…
阅读更多...
【Python项目】基于DJANGO的【医院体检预约系统】

【Python项目】基于DJANGO的【医院体检预约系统】

技术简介&#xff1a;使用Python技术、DJANGO框架、MYSQL数据库等实现。 系统简介&#xff1a;系统采用了在线预约和挂号的方式&#xff0c;用户可以通过网站进行预约和挂号操作。同时&#xff0c;系统还提供了医生的详细介绍和评价&#xff0c;方便用户选择医生。 研究背景&a…
阅读更多...
Django之单文件上传（以图片为例）

Django之单文件上传（以图片为例）

一&#xff0c;创建项目 初始化&#xff0c;数据迁移&#xff0c;创建superuser&#xff0c;创建app等 二&#xff0c;配置settings.py 1&#xff0c;配置数据库&#xff08;本作者使用的mysql&#xff09;&#xff0c;以前文章有提到 2&#xff0c;配置静态文件存放路径 STAT…
阅读更多...
关于YOLO8学习（五）安卓部署ncnn模型--视频检测

关于YOLO8学习（五）安卓部署ncnn模型--视频检测

前文 关于YOLO8学习（一）环境搭建，官方检测模型部署到手机 关于YOLO8学习（二）数据集收集，处理 关于YOLO8学习（三）训练自定义的数据集 关于YOLO8学习（四）模型转换为ncnn 简介 本文将会讲解： （1）使用前文生成的ncnn模型，部署到安卓端，并且实现视频中，人脸的检测…
阅读更多...
CSS精灵图、字体图标、HTML5新增属性、界面样式和网站 favicon 图标

CSS精灵图、字体图标、HTML5新增属性、界面样式和网站 favicon 图标

精灵图 为什么要使用精灵图 一个网页中往往会应用很多小的背景图像作为修饰&#xff0c;当网页中的图像过多时&#xff0c;服务器就会频繁地接收和发送请求图片&#xff0c;造成服务器请求压力过大&#xff0c;这将大大降低页面的加载速度,因此&#xff0c;为了有效地减少服务…
阅读更多...
农作物害虫检测数据集VOC+YOLO格式18975张97类别

农作物害虫检测数据集VOC+YOLO格式18975张97类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;18975 标注数量(xml文件个数)&#xff1a;18975 标注数量(txt文件个数)&#xff1a;18975 标…
阅读更多...
ARL资产侦察灯塔系统安装和使用(含实用配置说明)

ARL资产侦察灯塔系统安装和使用(含实用配置说明)

★★免责声明★★ 文章中涉及的程序(方法)可能带有攻击性&#xff0c;仅供安全研究与学习之用&#xff0c;读者将信息做其他用途&#xff0c;由Ta承担全部法律及连带责任&#xff0c;文章作者不承担任何法律及连带责任。 1、官方介绍 ARL全称&#xff1a;Asset Reconnaissance…
阅读更多...
C#图像:1.图像区域分割与提取

C#图像:1.图像区域分割与提取

&#xff08;1&#xff09;创建一个名为SplitImage的窗体的应用程序&#xff0c;将窗体改名为FormSplitImage。 &#xff08;2&#xff09;创建一个名为ImageProcessingLibrary的类库程序&#xff0c;为该工程添加名为ImageProcessing的静态类 &#xff08;3&#xff09;为Imag…
阅读更多...
智慧校园云平台源码，SaaS运营云平台（支持多学校、多校园使用）

智慧校园云平台源码，SaaS运营云平台（支持多学校、多校园使用）

智慧班牌系统&#xff0c;又称电子班牌系统&#xff0c;是一种基于互联网技术的综合管理工具。通过在教室内安装显示屏&#xff0c;并连接到学校管理系统&#xff0c;实现教学资源展示、信息发布、学生管理等多种功能的集成。该系统旨在加强学校班级文化建设和班级风采展示&…
阅读更多...
【自留】运行一个开源项目

【自留】运行一个开源项目

运行一个开源项目 首先是运行起来 1. 拿到地址 拿到你想要的项目的地址 2. 克隆 打开编辑器 VSCode &#xff0c;创建一个放项目的文件夹&#xff0c;控制台输入以下代码克隆项目 git clone 克隆地址gitee克隆地址在这看&#xff1a; github上项目的话&#xff0c;在这…
阅读更多...
python数据分析中数据可视化简单入门

python数据分析中数据可视化简单入门

1.折线图表 首先引入相关包pyecharts&#xff0c;如果没下载可以先下载 pip install pyecharts from pyecharts.charts import Lineline Line() # 添加x轴 line.add_xaxis([呱了个呱,羊村,牟多,蜂地,喵帕斯]) # 添加y轴 line.add_yaxis("GDP",[50,30,40,34,63,22])…
阅读更多...
第Y9周:重要模块解读

第Y9周:重要模块解读

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 | 接辅导、项目定制&#x1f680; 文章来源&#xff1a;K同学的学习圈子 目录 以con.py为例&#xff1a; 一、autopad 二、Conv 三、Focus 四、C2f 文件…
阅读更多...
记某APP登录逆向解密过程

记某APP登录逆向解密过程

最近在学习APP逆向相关的知识&#xff0c;刚好拿到了一个APP目标&#xff0c;该APP登录过程存在加密&#xff0c;所以记录下逆向破解的过程。流程 先介绍下拿到该APP后续所做的一些工作流程 选择相应版本安装到测试机当中进行抓包&#xff0c;查看数据包分析登录请求包&#x…
阅读更多...
分布式与一致性协议之一致哈希算法(二)

分布式与一致性协议之一致哈希算法(二)

一致哈希算法 使用哈希算法有什么问题 通过哈希算法&#xff0c;每个key都可以寻址到对应的服务器&#xff0c;比如&#xff0c;查询key是key-01,计算公式为hash(key-01)%3,警告过计算寻址到了编号为1的服务器节点A&#xff0c;如图所示。 但如果服务器数量发生变化&#x…
阅读更多...
二叉树的实现（详解，数据结构）

二叉树的实现（详解，数据结构）

目录 一&#xff0c;二叉树需要实现的功能 二&#xff0c;下面是各功能详解 0.思想&#xff1a; 1.创建二叉树结点&#xff1a; 2.通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树 3.二叉树销毁&#xff1a; 4.前序遍历&#xff1a; 5.中序遍历&#xff1a;…
阅读更多...
基于OpenCv的图像Harris角点检测

基于OpenCv的图像Harris角点检测

⚠申明&#xff1a; 未经许可&#xff0c;禁止以任何形式转载&#xff0c;若要引用&#xff0c;请标注链接地址。 全文共计3077字&#xff0c;阅读大概需要3分钟 &#x1f308;更多学习内容&#xff0c; 欢迎&#x1f44f;关注&#x1f440;【文末】我的个人微信公众号&#xf…
阅读更多...
【游戏行业】2024年电子游戏分类，国内游戏产业报告，发展趋势

【游戏行业】2024年电子游戏分类，国内游戏产业报告，发展趋势

文章目录 一、电子游戏分类1、传统游戏分类2、混合手游分类3、二次元、开放设计、调查问卷 二、游戏产业报告1、游戏产业数据2、游戏公司名单&#xff08;独角兽&#xff09;3、营收与利润&#xff08;对比互联网、国企&#xff09; 三、发展趋势1、游戏行业上下游2、游戏行业趋…
阅读更多...
Docker镜像仓库-在私有镜像仓库推送或拉取镜像

Docker镜像仓库-在私有镜像仓库推送或拉取镜像

推送镜像到私有仓库&#xff0c;要先让镜像打包 前缀为私有仓库地址的名字&#xff1a; 这里也是打包成功了:docker images 可以查看到 push推送镜像到镜像仓库: docker push 192.168.221.129:8080/nginx:1.0推送成功后在主机访问镜像仓库可以看到 这里已经有个镜像了。而且可…
阅读更多...
HTML_CSS学习：浮动

HTML_CSS学习：浮动

一、浮动简介 相关代码&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>浮动_简介</title><style>div{width: 600px;height: 400px;background-color: #1c80d9;}img{float:…
阅读更多...
最新文章

Copyright @ 2022~2023