第十三章 进程与线程

第十三章 进程与线程

程序与进程的概念

程序：
英文单词为Program，是指一系列有序指令的集合，使用编程语言所编写，用于实现一定的功能。

进程：
进程则是指启动后的程序，系统会为进程分配内存空间。

在这里插入图片描述

函数式创建子进程

在Python中创建进程有两种方式：
第一种使用os模块中的fork函数，但该函数只适用于Unix、Linux和MacOS。
Windows只能使用第二种方式:使用 multiprocessing模块 中的 Process类 创建进程。

第二种方式创建进程的语法结构：

Process(group = None,target,name,args,kwargs)

参数说明：

  • group:表示分组，实际上不使用，值默认为None即可
  • target:表示子进程要执行的任务，支持函数名
  • name:表示子进程的名称
  • args:表示调用函数的位置参数，以元组的形式进行传递
  • kwargs:表示调用函数的关键字参数，以字典的形式进行传递

【注】：
target支持函数名，即函数可以作为这个参数传入(函数作为参数时不带小括号，函数调用时才带小括号)。如果target传入的函数有位置参数，就需要用args进行传入；如果target传入的函数有关键字参数，就需要用kwargs进行传入。

因此group，name可以不写；target必须写；args、kwargs有就写，没有就不写。

# 使用内置模块multiprocessing中的Process类创建进程
from multiprocessing import Process
import os, time# 函数中的代码是子进程要执行的代码
def test():print(f'我是子进程，我的PID是:{os.getpid()},我的父进程是:{os.getppid()}')time.sleep(1)if __name__ == '__main__':# main是主进程print('主进程开始执行')lst = []# 创建五个子进程for i in range(5):# 创建子进程p = Process(target=test)  # 函数作为参数时不加小括号，函数调用时才加小括号# 启动子进程p.start()# 启动中的进程添加到列表中lst.append(p)print('主进程执行结束')

在这里插入图片描述

这里会发现子进程还没执行结束时，主进程就已经执行结束了。

原因见下方图示：

在这里插入图片描述

那么怎么让所有子进程执行结束之后主进程再执行结束呢？——需要用到 join() 进行阻塞。

# 使用内置模块multiprocessing中的Process类创建进程
from multiprocessing import Process
import os, time# 函数中的代码是子进程要执行的代码
def test():print(f'我是子进程，我的PID是:{os.getpid()},我的父进程是:{os.getppid()}')time.sleep(1)if __name__ == '__main__':# main是主进程print('主进程开始执行')lst = []# 创建五个子进程for i in range(5):# 创建子进程p = Process(target=test)  # 函数作为参数时不加小括号，函数调用时才加小括号# 启动子进程p.start()# 启动中的进程添加到列表中lst.append(p)# 当所有子进程执行结束后主进程再执行结束--->使用join()阻塞主进程# 遍历lst,列表中五个子进程for item in lst:  # item的数据类型是Process类型# join()-->主进程和子进程在一起执行时，看到join()后主进程便不再执行了，先让子进程执行，子进程执行结束之后再去执行主进程item.join()  # join()是Process对象的方法，作用是阻塞主进程# 有了join()后主进程要等到所有子进程执行完毕之后，主进程才会执行结束print('主进程执行结束')

在这里插入图片描述

Process类常用的属性和方法

Process类中常用的属性和方法：

方法/属性名称功能描述
name当前进程实例别名，默认为Process-N
pid当前进程对象的PID值
is_alive()进程是否执行完，没执行完结果为True，否则为False
join(timeout)等待结束或等待timeout秒
start()启动进程
run()如果没有指定target参数，则启动进程后，会调用父类(Process)中的run()方法
terminate()强制终止进程
from multiprocessing import Process
import os, time# 函数中的代码是子进程要执行的代码
# 函数式方式创建子进程
def sub_process(name):print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')time.sleep(1)def sub_process2(name):print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')time.sleep(1)if __name__ == '__main__':# main是主进程print('主进程开始执行')for i in range(3):# 创建第一种子进程# sub_process()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式p1 = Process(target=sub_process, args=('lxl',))# 创建第二种子进程# sub_process2()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式p2 = Process(target=sub_process2, args=(18,))# 调用start()启动子进程p1.start()p2.start()print(p1.name, '是否处于活跃状态：', p1.is_alive())print(p2.name, '是否处于活跃状态：', p2.is_alive())print(p1.name, 'PID是：', p1.pid)print(p2.name, 'PID是：', p2.pid)# 阻塞主进程p1.join()  # 主进程要等待p1执行结束p2.join()  # 主进程要等待p2执行结束print(p1.name, '是否处于活跃状态：', p1.is_alive())print(p2.name, '是否处于活跃状态：', p2.is_alive())print('-' * 50)print('主进程执行结束')

在这里插入图片描述

如果将以下两句注释掉：

        # p1.join()  # 主进程要等待p1执行结束# p2.join()  # 主进程要等待p2执行结束

则会出现：
在这里插入图片描述
具体原因同上面一样。

 

from multiprocessing import Process
import os, time# 函数中的代码是子进程要执行的代码
# 函数式方式创建子进程
def sub_process(name):print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')time.sleep(1)def sub_process2(name):print(f'子进程PID:{os.getpid()},父进程PID是:{os.getppid()}----{name}')time.sleep(1)if __name__ == '__main__':# main是主进程print('主进程开始执行')for i in range(3):# 创建第一种子进程# 若没有给定target参数，则不会执行自己编写的函数中的代码，会调用执行Process类中run方法p1 = Process(target=sub_process, args=('lxl',))# 创建第二种子进程p2 = Process(target=sub_process2, args=(18,))# 调用start()启动子进程p1.start()  # 如果Process类创建对象时没有指定target参数，则会调用Process类中的run方法去执行p2.start()  # 如果Process类创建对象时指定了target参数，start()调用target指定的函数去执行# 强制终止进程p1.terminate()  # target指定的函数还没有执行，进程就会被终止p2.terminate()print('主进程执行结束')

在这里插入图片描述

继承式创建子进程

除了使用函数式创建子进程，亦可以使用Python面向对象中的继承创建子进程。

使用继承创建进程的语法结构：

class 子进程(Process):
  pass

即编写一个类，这个类继承Process类，然后重写Process类中的run()方法。

from multiprocessing import Process
import os, time# 自定义一个类
class SubProcess(Process):# 编写初始化方法def __init__(self, name):# 调用父类中的初始化方法super().__init__()self.name = name# 重写父类中的run()方法def run(self):print(f'子进程的名称：{self.name},PID:{os.getpid()},父进程的PID:{os.getppid()}')if __name__ == '__main__':print('主进程开始执行')lst = []for i in range(1, 6):p1 = SubProcess(f'进程:{i}')# 启动进程p1.start()  # SubProcess类中没有start()方法，实际上会去调用父类中的start()方法lst.append(p1)# 阻塞主进程for item in lst:item.join()print('主进程执行结束')

在这里插入图片描述

进程池的使用

当进程数量比较少时，可以使用上面的两种方法Process类或Process的子类创建进程。但如果要创建的进程数量很多，再使用上述的方法创建进程和销毁进程就会耗费大量时间，这时可以使用multiprocessing模块中的 Pool类 创建进程池。

进程池的原理：
创建一个进程池，并设置进程池中最大的进程数量。假设进程池中最大的进程数为3，现在有10个任务需要执行，那么进程池一次可以执行3个任务，4次即可完成全部任务的执行。

创建进程池的语法结构：

进程池对象 = Pool(N)

进程池对象的方法：

方法名功能描述
apply_async(func,args,kwargs)使用非阻塞方式调用函数func
apply(func,args,kwargs)使用阻塞方式调用函数func
close()关闭进程池，不再接收新任务
terminate()不管任务是否完成，立即终止
join()阻塞主进程，必须在terminate()或close()之后使用

使用进程池：非阻塞和阻塞方式调用函数func有什么区别：
先来看非阻塞方式：

from multiprocessing import Pool
import os, time# 编写函数(即要执行的任务)
def task(name):print(f'子进程的PID:{os.getppid()},执行的任务:{name}')time.sleep(1)# 使用进程池：非阻塞和阻塞方式调用函数func有什么区别
if __name__ == '__main__':# 主进程start = time.time()print('主进程开始执行')# 创建进程池p = Pool(3)# 创建任务for i in range(1, 11):# 以非阻塞方式# task()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式p.apply_async(func=task, args=(i,))  # 函数作为参数不带小括号，调用才带小括号p.close()  # 关闭进程池，不再接收新任务p.join()  # 阻塞父进程，等待所有的子进程执行完毕之后，才会执行父进程中的代码print('所有的子进程执行完毕，父进程执行结束')print(time.time() - start)

在这里插入图片描述

再来看阻塞方式(只需将 apply_async 方法改成 apply 方法即可)：

from multiprocessing import Pool
import os, time# 编写函数(即要执行的任务)
def task(name):print(f'子进程的PID:{os.getppid()},执行的任务:{name}')time.sleep(1)# 使用进程池：非阻塞和阻塞方式调用函数func有什么区别
if __name__ == '__main__':# 主进程start = time.time()print('主进程开始执行')# 创建进程池p = Pool(3)# 创建任务for i in range(1, 11):# 以阻塞方式# task()有一个位置参数，因此需要用args传入该函数的位置参数，以元组方式p.apply(func=task, args=(i,))  # 函数作为参数不带小括号，调用才带小括号p.close()  # 关闭进程池，不再接收新任务p.join()  # 阻塞父进程，等待所有的子进程执行完毕之后，才会执行父进程中的代码print('所有的子进程执行完毕，父进程执行结束')print(time.time() - start)

在这里插入图片描述

并发和并行的概念

并发：
是指两个或多个事件同一时间间隔发生，多个任务被交替轮换着执行。比如A事件是吃苹果，在吃苹果的过程中有快递员敲门让你收下快递，收快递就是B事件，那么收完快递继续吃没吃完的苹果。这就是并发。
在这里插入图片描述

并行：
指两个或多个事件在同一时刻发生，多个任务在同一时刻在多个处理器上同时执行。比如A事件是泡脚，B事件是打电话，C事件是记录电话内容，这三件事则可以在同一时刻发生，这就是并行。
在这里插入图片描述

进程之间数据是否共享

结论：
进程之间数据是不共享的。

from multiprocessing import Processa = 100def add():print('子进程1开始执行')global aa += 30print('a=', a)print('子进程1执行完毕')def sub():print('子进程2开始执行')global aa -= 50print('a=', a)print('子进程2执行完毕')if __name__ == '__main__':# 主进程print('主进程开始执行')print('a=', a)# 创建 加法 的子进程p1 = Process(target=add)# 创建 减法 的子进程p2 = Process(target=sub)# 启动子进程p1.start()p2.start()# 阻塞主进程p1.join()p2.join()print('主进程执行结束')print('a=', a)

在这里插入图片描述

图示分析：
在这里插入图片描述

队列的基本使用

前面说到进程之间的数据是不共享的，但是可以通过队列来实现进程之间的数据共享。

进程之间可以通过队列(Queue)进程通信，队列是一种先进先出(First In First Out)的数据结构。

在这里插入图片描述

创建队列的语法结构：

队列对象 = Queue(N)

在multiprocessing模块中有一个Queue类。

Queue类中的常用方法：

方法名称功能描述
qsize()获取当前队列包含的消息数量
empty()判断队列是否为空，为空结果为True，否则为False
full()判断队列是否满了，满结果为True，否则为False
get(block=True)获取队列中的一条消息，然后从队列中移除(出队)，block默认值为True
get_nowait()相当于get(block=False)，消息队列为空时，抛出异常
put(item,block=True)将item消息放入队列，block默认为True
put_nowait(item)相当于put(item,block=False)

注意：
在上面的方法中参数 block 表示 阻塞 的意思。使用get(block=True)【表示进行等待】，当队列为空并不会报错，而且会一直等待，等到队列中有消息时再取出一条消息。使用get_nowait()【相当于get(block=False)表示不进行等待】，当队列为空会报错。使用put(item,block=True)【表示进行等待】，当队列满时并不会报错，而且会一直等待，等到队列中有空位置时再入队。使用put_nowait(item)【put(item,block=False)表示不等待】，当队列满时会报错。
在这里插入图片描述

 

from multiprocessing import Queueif __name__ == '__main__':# 创建一个队列q = Queue(3)  # 最多可以接收3条信息print('队列是否为空：', q.empty())  # Trueprint('队列是否为满：', q.full())  # False# 向队列中添加消息q.put('hello')q.put('world')print('队列是否为空：', q.empty())  # Falseprint('队列是否为满：', q.full())  # Falseq.put('Python')print('队列是否为空：', q.empty())  # Falseprint('队列是否为满：', q.full())  # Trueprint('队列当中信息的个数：', q.qsize())# 出队print(q.get())print('队列当中信息的个数：', q.qsize())# 入队q.put_nowait('html')# q.put_nowait('sql')  # 报错，queue.Full# q.put('sql')  # 不报错，会一直等待，等到队列中有空位置在入队# 遍历if not q.empty():for i in range(q.qsize()):print(q.get_nowait())  # nowait() 不等待print('队列是否为空：', q.empty())  # Trueprint('队列是否为满：', q.full())  # Falseprint('队列当中信息的个数：', q.qsize())

在这里插入图片描述

使用队列实现进程之间的通信

前面说过使用put(item,block=True)【表示进行等待】，当队列满时并不会报错，而且会一直等待，等到队列中有空位置时再入队。
在这里插入图片描述

而事实上还有一个参数put(item,block=True,timeout=n)，timeout表示等待n秒后，若队列还没有空位置就抛异常 。

from multiprocessing import Queueif __name__ == '__main__':# 创建一个队列q = Queue(3)  # 最多可以接收3条信息# 向队列中添加元素(入队)q.put('hello')q.put('world')q.put('Python')q.put('html', block=True, timeout=2)  # 等待2秒之后，队列还没有空位置就抛异常

在这里插入图片描述

 
进程之间可以使用队列进行通信，实际上就是入队和出队操作，两个进程，一个进程负责入队，另一个进程负责出队即可。

下面例子，使用队列实现进程之间通信，去操作全局变量的值：

# 使用队列实现进程之间通信。注意这个队列应该是共享的，写和读用的是同一个队列
from multiprocessing import Queue, Process
import timea = 100def writ_msg(q):  # q队列global aif not q.full():for i in range(6):  # 写6条消息a -= 10q.put(a)  # 入队print('a入队时的值：', a)# 出队
def read_msg(q):time.sleep(1)while not q.empty():print('出队时a的值：', q.get())if __name__ == '__main__':print('父进程开始执行')q = Queue()  # 由父进程创建队列，没有指定参数，表示可接收的消息个数没有上限# 创建两个子进程p1 = Process(target=writ_msg, args=(q,))p2 = Process(target=read_msg, args=(q,))# 启动两个子进程p1.start()p2.start()# 等待写的进程执行结束，再去执行主进程p1.join()p2.join()print('父进程执行结束')

在这里插入图片描述

函数式创建线程

一个应用程序内多任务的方式采用的是多进程，一个进程内的多任务方式采用多线程。

线程：
线程是CPU可调度的最小单位，被包含在进程中，是进程中实际的运作单位。一个进程中可以拥有N多个线程并发执行，而每个线程并行执行不同的任务。

threading模块中有Thread类。

函数式创建线程的语法结构(类似进程)：

t = Thread(group,target,name,args,kwargs)

参数说明：

  • group:创建线程对象的进程组
  • target:创建的线程对象所要执行的目标函数
  • name:创建线程对象的名称，默认为“Thread-n”
  • args:用元组以位置参数的形式传入target对应函数的参数
  • kwargs:用字典以关键字参数的形式传入target对应函数的参数
import threading
from threading import Thread
import time# 编写函数
def test():for i in range(3):time.sleep(1)print(f'线程:{threading.current_thread().name}正在执行{i}')if __name__ == '__main__':start = time.time()print('主线程开始执行')# 创建两个线程，使用列表生成式lst = [Thread(target=test) for i in range(2)]for item in lst:  # item的数据类型是Thread类型# 启动线程item.start()# 阻塞主线程for item in lst:item.join()print(f'一共耗时{time.time() - start}')'''
多个线程并发执行，每个线程并行执行不同的任务。
该程序中共有一个进程(main)，三个线程(main,Thread-1,Thread-2)。三个线程并行执行的任务是：主线程负责执行main中的代码Thread-1线程执行test()三次循环Thread-2线程执行test()三次循环三个线程又是并发执行，Thread-1和Thread-2谁先执行不一定。
'''

在这里插入图片描述

继承式创建线程

使用Thread子类创建线程的操作步骤(类似进程)：

  1. 自定义类继承threading模块下的Thread类
  2. 重写run()方法
import threading
from threading import Thread
import timeclass SubThread(Thread):# 重写run()方法def run(self):for i in range(3):time.sleep(1)print(f'线程:{threading.current_thread().name}正在执行{i}')if __name__ == '__main__':print('主线程开始执行')# 继承式创建两个线程，使用列表生成式lst = [SubThread() for i in range(2)]for item in lst:  # item的数据类型是Thread类型# 启动线程item.start()# 阻塞主线程for item in lst:item.join()print('主线程执行结束')

在这里插入图片描述

线程之间数据共享

进程之间的数据不共享，线程之间的数据共享。这是因为线程之间会共享该进程中的资源。

from threading import Threada = 100  # 全局变量def add():print('加线程开始执行')global aa += 30print(f'a的值为：{a}')print('加的线程执行结束')def sub():print('减线程开始执行')global aa -= 50print(f'a的值为：{a}')print('减的线程执行结束')if __name__ == '__main__':print('主线程开始执行')print(f'全局变量a的值:{a}')# 线程add = Thread(target=add)sub = Thread(target=sub)# 启动add.start()sub.start()# 阻塞主线程add.join()  # 当加线程执行完毕主线程才能继续执行sub.join()  # 当减线程执行完毕主线程才能继续执行print(f'主线程执行结束，a的值:{a}')

在这里插入图片描述

图示分析：
在这里插入图片描述

多个线程共享数据带来的问题以及Lock锁的使用

在上一小节中知道线程共享该进程的资源，所以全局变量a，被这个进程中的所有线程共享。

又因为多个线程是并发执行的，执行顺序无法确定(由CPU调度决定)，所以这就可能造成数据错乱。

下面看一个多线程操作共享数据带来的安全性问题：

# 多线程操作共享数据的安全性问题
import threading
from threading import Thread
import timeticket = 50  # 全局变量。代表50张票def sale_ticket():global ticket# 每个排队窗口(线程)假设有100人for i in range(100):  # 每个线程要执行100次循环if ticket > 0:print(f'{threading.current_thread().name}正在出售第{ticket}张票')ticket -= 1time.sleep(1)if __name__ == '__main__':for i in range(3):  # 创建三个线程，代表3个排队窗口t = Thread(target=sale_ticket)t.start()  # 启动线程

在这里插入图片描述
在这里插入图片描述

解决这个问题可以采用Lock锁。

当线程A去操作共享数据时，对共享数据加一把锁，这时如果线程B想要操作共享数据就只能等待而不可以操作。只有当锁解开时才允许其他线程进行操作。

Lock对象的acquire()、release()方法：
在这里插入图片描述

使用Lock锁机制可以解决共享数据带来的安全性问题，那么如何锁，把锁上在什么地方呢?

在使用Lock锁时要把尽量少的、不耗时的代码放到锁中。

threading模块中的Lock类。

# 使用Lock锁解决多线程操作共享数据的安全性问题
import threading
from threading import Thread, Lock
import timeticket = 50  # 全局变量。代表50张票
lock_obj = Lock()  # 创建锁对象def sale_ticket():global ticket# 每个排队窗口(线程)假设有100人for i in range(100):  # 每个线程要执行100次循环lock_obj.acquire()  # 上锁if ticket > 0:print(f'{threading.current_thread().name}正在出售第{ticket}张票')ticket -= 1time.sleep(1)lock_obj.release()  # 释放锁if __name__ == '__main__':for i in range(3):  # 创建三个线程，代表3个排队窗口t = Thread(target=sale_ticket)t.start()  # 启动线程

在这里插入图片描述

使用Lock锁降低了并发度，但可以解决多线程操作共享数据的安全性问题。

生产者与消费者问题

生产者与消费者模式：
是线程模型中的经典问题，与编程语言无关。当程序中出现了明确的两类任务，一个任务负责生产数据，一个任务负责处理生产的数据时就可以使用该模式。
在这里插入图片描述

生产者与消费者问题会出现等待与唤醒问题，如果中间仓库满，生产者等待；如果中间仓库空，消费者等待。

使用Python实现生产者与消费者模式需要用到Python内置模块queue中的Queue类。【注意在进程通信中提到的队列是multiprocessing模块中的Queue类】

Python内置模块queue中的Queue类中常用的方法：

方法名称功能描述
put(item)向队列中放置数据，如果队列为满，则阻塞
get()从队列中取走数据，如果队列为空，则阻塞
join()如果队列不为空，则等待队列变为空
task_done()消费者从队列中取走一项数据，当队列变为空时，唤醒调用join()的线程
# 生产者与消费者模式
from queue import Queue
from threading import Thread
import time# 创建一个生产者类
class Producer(Thread):def __init__(self, name, queue):Thread.__init__(self, name=name)self.queue = queuedef run(self):for i in range(1, 6):print(f'{self.name}将产品{i}放入队列')self.queue.put(i)time.sleep(1)print('生产者完成了所有数据的存放')# 创建一个消费者类
class Consumer(Thread):def __init__(self, name, queue):Thread.__init__(self, name=name)self.queue = queuedef run(self):for i in range(5):value = self.queue.get()print(f'消费者线程{self.name}取出了{value}')time.sleep(1)print('消费者线程完成了所有数据的取出')if __name__ == '__main__':# 创建队列queue = Queue()  # 该队列表示中间仓库。# 创建生产者线程p = Producer('Producer', queue)# 创建消费者线程c = Consumer('Consumer', queue)# 启动线程p.start()c.start()# 阻塞主线程p.join()c.join()print('主线程执行结束')

在这里插入图片描述

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

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

相关文章

【PingPong_注册安全分析报告】

【PingPong_注册安全分析报告】

前言 由于网站注册入口容易被黑客攻击，存在如下安全问题： 暴力破解密码，造成用户信息泄露短信盗刷的安全问题，影响业务及导致用户投诉带来经济损失，尤其是后付费客户，风险巨大，造成亏损无底洞 …
阅读更多...
奶奶也能看懂的耦合协调度分析

奶奶也能看懂的耦合协调度分析

不会计算？跟着文献学起来~ 案例数据连接（复制链接后粘贴到浏览器中）： 耦合协调度数据​spssau.com/spssaudata.html?shareDataF363000CD033FF15E557BB75B9B0D412 假如你有这样一组数据： 如何进行计算分析耦合协调度…
阅读更多...
内网安全之证书模版的管理

内网安全之证书模版的管理

证书模板 Certificate templates 是 CA 证书颁发机构的一个组成部分，是证书策略中的重要元素，是用于证书注册、使用和管理的一组规则和格式。当 CA 收到对证书的请求时，必须对该请求应用一组规则和设置，以执行所请求的功能&#x…
阅读更多...
前端知识1-4：性能优化进阶

前端知识1-4：性能优化进阶

性能优化进阶 Navigation Timing API navigationStart / end 表示从上一个文档卸载结束时 > 如果没有上一个文档，这个值和fetchStart相等 unloadEventStart / end 标识前一个网页unload的时间点 redirectStart / end 第一个http重定向发生和结束的时间 fetch…
阅读更多...
Hadoop3：HDFS中DataNode与NameNode的工作流程

Hadoop3：HDFS中DataNode与NameNode的工作流程

一、DataNode中的数据情况 数据位置 /opt/module/hadoop-3.1.3/data/dfs/data/current/BP-823420375-192.168.31.102-1714395693863/current/finalized/subdir0/subdir0块信息 每个块信息，由两个文件保存，xxx.meta保存的是数据长度、校验和、时间戳&am…
阅读更多...
芝加哥大学最新研究：GPT-4与财务预测，重塑财务分析的未来

芝加哥大学最新研究：GPT-4与财务预测，重塑财务分析的未来

最近，芝加哥大学的研究团队发表了一篇突破性的研究，展示了大型语言模型（LLM），特别是 OpenAI 开发的 GPT-4，如何在财务报表分析领域取得了与专业分析师相匹配甚至超越的表现。这项研究不仅凸显了人工智能在高…
阅读更多...
GDPU Java 天码行空13

GDPU Java 天码行空13

（一）实验目的 1、掌握JAVA中与网络程序开发相关的知识点； 2、理解并掌握网络编程开发思想及方法； 3、熟悉项目开发的分包方法和依据； 4、实现聊天室中客服端和服务器端的实现方法； 5、熟悉多线程程序开发方…
阅读更多...
Kinetix5700罗克韦尔AB伺服驱动器维修2198-D020-ERS3

Kinetix5700罗克韦尔AB伺服驱动器维修2198-D020-ERS3

Allen-Bradley罗克韦尔运动控制/伺服驱动器维修Kinetix 5700/Kinetix 6000/Kinetix 5500等系列电机驱动器/运动控制系统维修。 AB驱动器的控制接口有两种类型： 类型1：脉冲接口 类型2：模拟量接口 大部分小型PLC和伺服驱动器的链接方式都是开…
阅读更多...
通过vlan实现同一网段下的网络隔离

通过vlan实现同一网段下的网络隔离

现有两个电脑通过交换机直接连接在一起 pc1&#xff1a; pc2&#xff1a; 正常状态下是可以ping成功的 现在先进入交换机命令行界面&#xff0c;创建两个vlan <Huawei>system-view Enter system view, return user view with CtrlZ. [Huawei]vlan 10 [Huawei-vlan10…
阅读更多...
2024年西安交通大学程序设计校赛

2024年西安交通大学程序设计校赛

A题 签到题 代码如下 //A #include<iostream> #include<algorithm> #define int long long #define endl \n #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0); using namespace std; signed main() {IOSint a,b,c,d;cin>>a>>b>>c…
阅读更多...
二叉树介绍及堆

二叉树介绍及堆

文章目录 树 概念及结构 二叉树 概念及结构 特殊的二叉树 完全二叉树 满二叉树 性质 储存 顺序存储 链式储存 堆 概念及结构 小堆 大堆 建堆 向上调整建堆 向下调整建堆 TOPK问题 法一&#xff1a; 法二&#xff1a; 树 概念及结构 树是一种非线性的数据…
阅读更多...
解决word里加入mathtype公式后行间距变大

解决word里加入mathtype公式后行间距变大

1.布局>页面设置>文档网格&#xff0c;网格栏选为无网格 2.固定间距
阅读更多...
探索标准差与方差的奥秘

探索标准差与方差的奥秘

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、标准差与方差的基础理解 代码案例 二、标准差与方差的计算方法 方差的计算 标准差的…
阅读更多...
QT——QSlider实现，QT滑动控件的使用

QT——QSlider实现，QT滑动控件的使用

目录 简介滑动块调节两种方法滑动条触发信号量理想滑动块运用&#xff08;参考&#xff09; 简介 QT中滑动条的控件叫QSlider&#xff0c;继承自QAbstractSlider类。 主要用途是通过滑块的滑动的方式在一定范围内调节某个值。根据调节的后得到的结果去执行一些处理&#xff0c…
阅读更多...
【AI基础】数据获取与整理、打标、增强方法、增强库imgaug

【AI基础】数据获取与整理、打标、增强方法、增强库imgaug

文章目录 常见的数据集网站爬虫工具使用搜索引起图片爬虫视频网站爬虫 数据整理数据检查和清洗数据去重数据集划分 数据标注数据标注工具 label studio 数据增强什么是数据增强单样本数据增强多样本数据增强样本生成方法数据增强imgaugimgaug 操作imgaug 使用 常见的数据集网站…
阅读更多...
这款AI绘画软件，带你快速生成高质量产品效果图！

这款AI绘画软件，带你快速生成高质量产品效果图！

前言 随着人工智能技术的飞速发展&#xff0c;AI在设计领域的应用越来越广泛&#xff0c;。今天&#xff0c;介绍的一款能够自动生成高质量产品效果图的AI绘画软件——STARTAI。这款软件以其强大的功能和便捷的操作&#xff0c;正在重新定义电商产品效果图的制作流程。 AI局部…
阅读更多...
RocketMQ .NET

RocketMQ .NET

RocketMQ 是一款由阿里巴巴集团开发并开源给Apache软件基金会的分布式消息及流处理平台。以其高吞吐量、低延迟、高可用性等特点而广受欢迎。支持Java&#xff0c;C, Python, Go, .NET等。 异步解耦&#xff1a;可以实现上游和下游业务系统的松耦合设计&#xff0c;使得服务部…
阅读更多...
小红书图文笔记怎么做？纯干货！

小红书图文笔记怎么做？纯干货！

小红书图文笔记的制作是一门艺术&#xff0c;它需要结合精美的图片和有价值的内容&#xff0c;以吸引和留住用户的注意力。伯乐网络传媒给大家分享制作小红书图文笔记的干货指南&#xff0c;包括准备、制作、发布和优化的各个环节。 一、准备阶段 确定目标受众&#xff1a;找到…
阅读更多...
【NumPy】权威指南：使用NumPy的percentile函数进行百分位数计算

【NumPy】权威指南：使用NumPy的percentile函数进行百分位数计算

&#x1f9d1; 博主简介&#xff1a;阿里巴巴嵌入式技术专家&#xff0c;深耕嵌入式人工智能领域&#xff0c;具备多年的嵌入式硬件产品研发管理经验。 &#x1f4d2; 博客介绍&#xff1a;分享嵌入式开发领域的相关知识、经验、思考和感悟&#xff0c;欢迎关注。提供嵌入式方向…
阅读更多...
研学活动报名二维码怎么制作？

研学活动报名二维码怎么制作？

在组织研学活动时&#xff0c;老师们经常面临报名流程繁琐、信息收集不全面、统计工作耗时等问题&#xff1f;如何高效地管理学生的报名信息&#xff0c;确保活动顺利进行呢&#xff1f; 现在我们有了更多的选择。老师们可以快速制作出研学活动的研学活动报名二维码怎么制作&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023