【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.mzph.cn/news/831959.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

数仓开发：DIM层数据处理

数仓开发：DIM层数据处理

一、了解DIM层 这个就是数仓开发的分层架构 我们现在是在DIM层&#xff0c;从ods表中数据进行加工处理&#xff0c;导入到dwd层&#xff0c;但是记住我们依然是在DIM层&#xff0c;而非是上面的ODS和DWD层。 二、处理维度表数据 ①先确认hive的配置 -- 开启动态分区方案 -- …
阅读更多...
c++:优先级队列(priority queue)使用及底层详解,附带仿函数初步使用

c++:优先级队列(priority queue)使用及底层详解,附带仿函数初步使用

文章目录 优先级队列的使用大堆小堆**注意** 优先级队列的模拟实现pushpopsizeemptytop 仿函数仿函数是什么pushpop 仿函数结合优先级队列的优势 优先级队列的使用 优先级队列本质是就是完全二叉树,是个堆.我们可以用优先级队列来取出一段序列中的前N个最大值. priority_queue…
阅读更多...
Postman的一些使用技巧

Postman的一些使用技巧

Postman 是一个流行的 API 开发工具&#xff0c;用于设计、开发、测试、发布和监控 API。在现代web开发中使用非常广泛。后端开发必备而且必会的工具。 目录 1.配置环境变量 2.动态变量 3.脚本 4.测试 5.模拟 6.监控 7.集合运行器 8.响应保存 9.请求历史 10.同步请求…
阅读更多...
嵌入式Linux编辑器vi

嵌入式Linux编辑器vi

一、vi是什么 vi是Linux系统的第一个全屏幕交互式编辑工具。 vi与vim vi 和 vim 是 Linux 和 Unix 系统上非常流行的文本编辑器。尽管 vi 是最初的版本&#xff0c;但 vim&#xff08;Vi IMproved&#xff09;是它的一个增强版本&#xff0c;提供了更多的功能和易用性。 vi 是一…
阅读更多...
使用ESP8266连接EMQX完成数据上传

使用ESP8266连接EMQX完成数据上传

国庆期间在家里窝着哪里也没去&#xff0c;到处都是人。打算自己捣鼓点小玩意&#xff0c;相信大家对STM32ESP8266ONENET这种组合已经见怪不怪了&#xff0c;这次不走寻常路&#xff0c;咱们搞点不一样的。正巧自己也一直有做一套网关系统的想法&#xff0c;因此就有了下面这篇…
阅读更多...
【论文阅读笔记】关于“二进制函数相似性检测”的调研（Security 22）

【论文阅读笔记】关于“二进制函数相似性检测”的调研（Security 22）

个人博客链接 注&#xff1a;部分内容参考自GPT生成的内容 [Security 22] 关于”二进制函数相似性检测“的调研&#xff08;个人阅读笔记&#xff09; 论文&#xff1a;《How Machine Learning Is Solving the Binary Function Similarity Problem》&#xff08;Usenix Securi…
阅读更多...
算法提高之背包问题背包问题求具体方案

算法提高之背包问题背包问题求具体方案

算法提高之背包问题背包问题求具体方案 核心思想&#xff1a;01背包 dp输出方案 因为求字典序最小的方案 所以当取第i个物品时 下一步要求的就是i1 ~ n的最大方案 所以f意义改变 变成了第i个元素到最后一个元素总容量为j的最优解 之前是前i个物品总容量为j的最优解 这样在之…
阅读更多...
[AIGC] MVCC 是怎么实现的

[AIGC] MVCC 是怎么实现的

InnoDB 实现的MVCC&#xff0c;是通过 ReadView Undo Log 实现的&#xff0c;Undo Log 保存了历史快照&#xff0c;ReadView可见性规则帮助判断当前版本的数据是否可见。 具体操作时&#xff1a; SELECT InnoDB会根据以下两个条件检查每行记录&#xff1a; a. InnoDB只查找版本…
阅读更多...
leetCode71. 简化路径

leetCode71. 简化路径

leetCode71. 简化路径 代码 // 化简&#xff1a;就是把所有的., .. // 去掉弄成进入想进的目录&#xff0c;且结果最后不能有/ // 实现思路&#xff1a; 本质上是一个栈&#xff0c;就是进栈出栈的一个模拟实现 class Solution { public:string simplifyPath(string path) {//…
阅读更多...
面试算法-链表-反转链表(golang、c++)

面试算法-链表-反转链表(golang、c++)

目录 1、题目 2、解题思路 2.1 遍历、迭代 2.2 递归 3、源代码 3.1 c 3.2 golang 4、复杂度分析 4.1 遍历、迭代法 4.2 迭代法 1、题目 链表是一种常用的数据结构&#xff0c;链表的特点是插入、删除节点的效率非常高&#xff0c;因为他不需要移动其他任何元素&…
阅读更多...
Linux——守护进程化（独立于用户会话的进程）

Linux——守护进程化（独立于用户会话的进程）

目录 前言 一、进程组ID与会话ID 二、setsid() 创建新会话 三、daemon 守护进程 前言 在之前&#xff0c;我们学习过socket编程中的udp通信与tcp通信&#xff0c;但是当时我们服务器启动的时候&#xff0c;都是以前台进程的方式启动的&#xff0c;这样很不优雅&#xff0c…
阅读更多...
数据分析：基于DESeq2的转录组功能富集分析

数据分析：基于DESeq2的转录组功能富集分析

介绍 DESeq2常用于识别差异基因&#xff0c;它主要使用了标准化因子标准化数据&#xff0c;再根据广义线性模型判别组间差异&#xff08;组间残差是否显著判断&#xff09;。在获取差异基因结果后&#xff0c;我们可以进行下一步的富集分析&#xff0c;常用方法有基于在线网站…
阅读更多...
银行智能化数据安全分类分级实践分享

银行智能化数据安全分类分级实践分享

文章目录 前言一、数据安全智能分类分级平台建设背景二、数据安全分类分级建设思路和实践1、做标签– 数据安全标签体系2、打标签– 鹰眼智能打标平台 3.03、用标签– 全行统一“数据安全打标签结果”服务提供前言 随着国家对数据安全的高度重视，以及相关法律法规的出台，数据…
阅读更多...
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])…
阅读更多...
01 JVM --

01 JVM --

JVM (Java Virtual Machine) 是一个虚拟机HotSpot 是 JVM 概念的一个实现。HotSpot 虚拟机通过即时编译 (JIT) 技术将 Java 字节码转换为本地机器码&#xff0c;以提高程序的执行效率。OpenJDK 是一个项目名&#xff0c;它在 HotSpot 的基础上开发了 HotSpot 的开源实现方法区是…
阅读更多...
Redhat Linux忘记密码解决方案

Redhat Linux忘记密码解决方案

1、重启系统 2、将光标移动到要启动的内核 3、按e编辑当前条目 4、将光标移动以Linux开头的行&#xff0c;此为内核命令行 5、在末尾添加人的rd.break 6、按ctrlx继续启动&#xff0c;如果发现输入的rd.break不能进入到伪系统&#xff0c;那么改为 rd.break consoletty0 (按ctr…
阅读更多...
设计模式-03 设计模式-工厂模式factory-内部工厂

设计模式-03 设计模式-工厂模式factory-内部工厂

设计模式-03 设计模式-工厂模式factory-内部工厂 目录 设计模式-03 设计模式-工厂模式factory-内部工厂 1.定义 2.内涵 3.案例对比 4.特点 4.总结 1.定义 内部工厂模式是一种创建类对象的方式&#xff0c;其中工厂方法被封装在类内部&#xff0c;客户端只能通过类的公共…
阅读更多...
epoll的LT和ET模式介绍

epoll的LT和ET模式介绍

目录 1.epoll的LT和ET模式介绍 2.epoll的ET模式如何处理 2.1 epoll的ET模式编程读取数据的处理方式 2.2 将描述符设置为非阻塞模式的方法 3.ET模式的总结 4.epoll的LT模式和ET模式总结 5.IO复用总结 1.epoll的LT和ET模式介绍 epoll对文件描述符有两种操作模式: LT(Leve…
阅读更多...
Linux(openEuler、CentOS8)常用的IP修改方式（文本配置工具nmtui+配置文件+nmcli命令）

Linux(openEuler、CentOS8)常用的IP修改方式（文本配置工具nmtui+配置文件+nmcli命令）

----本实验环境为openEuler系统<以server方式安装>&#xff08;CentOS类似&#xff0c;可参考本文&#xff09;---- 一、知识点 &#xff08;一&#xff09;文本配置工具nmtui(openEuler已预装) nmtui&#xff08;NetworkManager Text User Interface&#xff09;是一…
阅读更多...
关于apache+php用户验证

关于apache+php用户验证

一.直接在apache配置配置用户信息 1.apache配置可以参考外部文档 https://developer.aliyun.com/article/507049 2.上面配置好在php获取用户信息&#xff08;登录apache会拦截&#xff09; $userName $_SERVER[PHP_AUTH_USER];$password $_SERVER[PHP_AUTH_PW]; 二.上面直…
阅读更多...
最新文章

Copyright @ 2022~2023