(转载)Python 浅析线程(threading模块)和进程(process)
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务
进程与线程
什么是线程(threading)?
A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions.
Suppose you're reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you stopped. One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.
If you have a roommate, and she's using the same technique, she can take the book while you're not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.
Threads work in the same way. A CPU is giving you the illusion that it's doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation. Just like you can share a book with your friend, many tasks can share a CPU.
On a more technical level, an execution context (therefore a thread) consists of the values of the CPU's registers.
Last: threads are different from processes. A thread is a context of execution, while a process is a bunch of resources associated with a computation. A process can have one or many threads.
Clarification: the resources associated with a process include memory pages (all the threads in a process have the same view of the memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process).
线程的出现是为了降低上下文切换的消耗,提高系统的并发性,并突破一个进程只能干一样事的缺陷,使到进程内并发成为可能。
假设,一个文本程序,需要接受键盘输入,将内容显示在屏幕上,还需要保存信息到硬盘中。若只有一个进程,势必造成同一时间只能干一样事的尴尬(当保存时,就不能通过键盘输入内容)。若有多个进程,每个进程负责一个任务,进程A负责接收键盘输入的任务,进程B负责将内容显示在屏幕上的任务,进程C负责保存内容到硬盘中的任务。这里进程A,B,C间的协作涉及到了进程通信问题,而且有共同都需要拥有的东西——-文本内容,不停的切换造成性能上的损失。若有一种机制,可以使任务A,B,C共享资源,这样上下文切换所需要保存和恢复的内容就少了,同时又可以减少通信所带来的性能损耗,那就好了。是的,这种机制就是线程。
线程也叫轻量级进程,它是一个基本的CPU执行单元,也是程序执行过程中的最小单元,由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销,提高了操作系统的并发性能。线程没有自己的系统资源。
什么是进程(process)?
An executing instance of a program is called a process.
Each process provides the resources needed to execute a program. A process has a virtual address space, executable code, open handles to system objects, a security context, a unique process identifier, environment variables, a priority class, minimum and maximum working set sizes, and at least one thread of execution. Each process is started with a single thread, often called the primary thread, but can create additional threads from any of its threads.
进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成;数据集则是程序在执行过程中所需要使用的资源;进程控制块用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感知进程存在的唯一标志。
举一例说明进程:
想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱,厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中,做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(cpu),而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来,说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态),然后拿出一本急救手册,按照其中的指示处理蛰伤。这里,我们看到处理机从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治),每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后,这位计算机科学家又回来做蛋糕,从他离开时的那一步继续做下去。
进程与线程之间的区别?
A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions.
Suppose you're reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you stopped. One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.
If you have a roommate, and she's using the same technique, she can take the book while you're not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.
Threads work in the same way. A CPU is giving you the illusion that it's doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation. Just like you can share a book with your friend, many tasks can share a CPU.
On a more technical level, an execution context (therefore a thread) consists of the values of the CPU's registers.
Last: threads are different from processes. A thread is a context of execution, while a process is a bunch of resources associated with a computation. A process can have one or many threads.
Clarification: the resources associated with a process include memory pages (all the threads in a process have the same view of the memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process).
进程是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。或者说进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。
线程则是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。
进程和线程的关系:
(1)一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程。
(2)资源分配给进程,同一进程的所有线程共享该进程的所有资源。
(3)CPU分给线程,即真正在CPU上运行的是线程。
并行与并发
并行处理(Parallel Processing)是计算机系统中能同时执行两个或者更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面,并行处理的主要目的是节省大型和复杂问题的解决时间。
并发处理(concurrency Processing)是指一个时间段中有几个程序都处于已经启动运行到运行完毕之间,而且这几个程序都是在同一处理机(CPU)上运行,但任意时刻点上只有一个程序在处理机(CPU)上运行
并发的关键在于你有处理多个任务的能力,不一定同时,并行的关键是你有同时处理多个任务的能力,所以说,并行是并发的子集
同步与异步
在计算机领域,同步就是指一个进程在执行某个请求的时候,若该请求需要一段时间才能返回信息,那么这个进程将会一直等待下去,直到收到返回信息才继续执行下去;异步是指进程不需要一直等下去,而是继续执行下面的操作,不管其他进程的状态。当有消息返回时系统会通知进程进行处理,这样可以提高执行的效率。举个例子,打电话时就是同步通信,发短息时就是异步通信。
线程(Thread)类的实例方法
join和Daemon
join():在子线程完成运行之前,这个子线程的父线程将一直被阻塞。
setDaemon(True):
将线程声明为守护线程,必须在start() 方法调用之前设置, 如果不设置为守护线程程序会被无限挂起。这个方法基本和join是相反的。当我们 在程序运行中,执行一个主线程,如果主线程又创建一个子线程,主线程和子线程 就分兵两路,分别运行,那么当主线程完成想退出时,会检验子线程是否完成。如 果子线程未完成,则主线程会等待子线程完成后再退出。但是有时候我们需要的是 只要主线程完成了,不管子线程是否完成,都要和主线程一起退出,这时就可以 用setDaemon方法啦
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
# join():在子线程完成运行之前,这个子线程的父线程将一直被阻塞。 # setDaemon(True): ''' 将线程声明为守护线程,必须在start() 方法调用之前设置,如果不设置为守护线程程序会被无限挂起。 当我们在程序运行中,执行一个主线程,如果主线程又创建一个子线程,主线程和子线程 就分兵两路,分别运行,那么当主线程完成 想退出时,会检验子线程是否完成。如果子线程未完成,则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程 完成了,不管子线程是否完成,都要和主线程一起退出,这时就可以 用setDaemon方法啦''' import threading from time import ctime,sleep import time def Music(name): print ( "Begin listening to {name}. {time}" . format (name = name,time = ctime())) sleep( 3 ) print ( "end listening {time}" . format (time = ctime())) def Blog(title): print ( "Begin recording the {title}. {time}" . format (title = title,time = ctime())) sleep( 5 ) print ( 'end recording {time}' . format (time = ctime())) threads = [] t1 = threading.Thread(target = Music,args = ( 'FILL ME' ,)) t2 = threading.Thread(target = Blog,args = ('',)) threads.append(t1) threads.append(t2) if __name__ = = '__main__' : #t2.setDaemon(True) for t in threads: #t.setDaemon(True) #注意:一定在start之前设置 t.start() #t.join() #t1.join() #t2.join() # 考虑这三种join位置下的结果? print ( "all over %s" % ctime()) |
1
2
3
4
5
6
7
8
9
10
|
daemon A boolean value indicating whether this thread is a daemon thread ( True ) or not ( False ). This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False . The entire Python program exits when no alive non - daemon threads are left. 当daemon被设置为 True 时,如果主线程退出,那么子线程也将跟着退出, 反之,子线程将继续运行,直到正常退出。 daemon |
其他方法
1
2
3
4
5
6
7
8
9
|
Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。 threading模块提供的一些方法: # threading.currentThread(): 返回当前的线程变量。 # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。 # threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。 |
python GIL(global Interper Lack)是什么?
GIL的概念
GIL全称是全局解释器锁,来源是python设计之初的考虑,为了数据安全所做的决定
每个CPU在同一时期只能执行一个线程(在单核CPU下的多线程其实都只是并发的,不是并行,并行和并发从宏观上来讲都是同时处理多路请求的概念。但是并发和并行又有区别,并行是指两个或者多个事件在同一时刻发生;而并发是指两个或者多个事件在同一时间间隔内发生)
CPython implementation detail: In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.
GIL的早期设计
Python支持多线程,而解决多线程之间数据完整性和状态同步的最简单方法自然就是加锁。 于是有了GIL这把超级大锁,而当越来越多的代码库开发者接受了这种设定后,他们开始大量依赖这种特性(即默认python内部对象是thread-safe的,无需在实现时考虑额外的内存锁和同步操作)。慢慢的这种实现方式被发现是蛋疼且低效的。但当大家试图去拆分和去除GIL的时候,发现大量库代码开发者已经重度依赖GIL而非常难以去除了。有多难?做个类比,像MySQL这样的“小项目”为了把Buffer Pool Mutex这把大锁拆分成各个小锁也花了从5.5到5.6再到5.7多个大版为期近5年的时间,并且仍在继续。MySQL这个背后有公司支持且有固定开发团队的产品走的如此艰难,那又更何况Python这样核心开发和代码贡献者高度社区化的团队呢?
GIL的影响
在python多线程下,每个线程的执行方式:
(1)获取GIL
(2)执行代码直到sleep或者是python虚拟机将其挂起
(3)释放GIL
可见,某个线程想要执行,必须先拿到GIL,我们可以将GIL看作是“通行证”,并且在一个python进程中,GIL只有一个,拿不到通行证的线程,就不允许进入CPU执行。
而每次释放GIL锁,线程进行锁竞争,切换线程,会消耗资源。并且由于GIL锁存在,python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行),这就是为什么在多核CPU上,python的多线程效率并不高的原因。
那么是不是python的多线程就完全没有作用了呢?
在这里我们分类讨论:
(1):CPU密集型代码:又称计算密集型任务,是指CPU计算占主要的任务,CPU一直处于满负荷的状态,比如在一个很大的列表中查找元素(当然这不合理),复杂的加减乘除等
(各种循环处理,计数等等),在这种情况下,ticks计数很快会达到阙值,然后触发GIL的释放与再竞争(多个线程来回切换当然是需要消耗资源的),所以python下的多线程对CPU密集型代码并不友好。
(2):IO密集型代码:指磁盘IO,网络IO占主要的任务,计算量很小。比如请求网页,读取文件等,当然我们可以在python中可以利用sleep达到IO密集型任务的目的
(文件处理,网络爬虫等),多线程能够有效的提升效率(单线程下有IO操作会进行IO等待,造成不必要的时间浪费,而开启多线程能在线程A等待的时候,自动切换到线程B,可以不浪费CPU资源,从而能提升程序代码执行效率),所以python的多线程对IO密集型代码比较友好。
在python3.x中GIL不适用ticks计数,改为使用计时器(执行时间达到阙值后,当前线程释放GIL),这样对CPU密集型程序更加友好,但是依然没有解决GIL导致的同一时间只能执行一个线程的问题,所以效率依然不尽人意
多核多线程比单核多线程更差,原因是单核下多线程,每次释放GIL,唤醒的那个线程都能获取到GIL锁,所以能够无缝执行,但是在多核下导致其他几个COU上被唤醒后的线程会醒着等待到切换时间后又进入到待调度状态,这样会造成线程颠簸,导致效率更低。
所以说“python下想要充分使用多核CPU,就要利用多进程”的原因是什么呢?
每个进程都有各自独立的GIL,互不干扰,这样就可以真正意义上并行执行,所以在python中,多进程的执行效率优于多线程,(仅仅针对多核CPU)
故我们得出结论:多核下,想要并行提升效率,比较通用的方法是使用多进程,能够有效的提高执行效率。
多进程
多进程的概念
multiprocessing
is a package that supports spawning processes using an API similar to the threading
module. The multiprocessing
package offers both local and remote concurrency,effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads. Due to this, the multiprocessing
module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows.
由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing,只需要定义一个函数,Python会完成其他所有事情。借助这个包,可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。
multiprocessing包是Python中的多进程管理包。与threading.Thread类似,它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同,也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样,通过参数传递给各个进程),用以同步进程,其用法与threading包中的同名类一致。所以,multiprocessing的很大一部份与threading使用同一套API,只不过换到了多进程的情境。
但在使用这些共享API的时候,我们要注意以下几点:
- 在UNIX平台上,当某个进程终结之后,该进程需要被其父进程调用wait,否则进程成为僵尸进程(Zombie)。所以,有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说,由于只有一个进程,所以不存在此必要性。
- multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue),效率上更高。应优先考虑Pipe和Queue,避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。
- 多进程应该避免共享资源。在多线程中,我们可以比较容易地共享资源,比如使用全局变量或者传递参数。在多进程情况下,由于每个进程有自己独立的内存空间,以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度,并因为同步的需要而降低了程序的效率。
Process.PID中保存有PID,如果进程中还没有start(),则PID为None。
windows系统下,需要注意的是想要启动一个子进程必须加上
1
|
if __name__ = "__main__" |
进程相关要写在上面这句语句下面。
举个例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
from multiprocessing import Process import time def f(name): time.sleep( 1 ) print ( 'hello' , name,time.ctime()) if __name__ = = '__main__' : p_list = [] for i in range ( 3 ): p = Process(target = f, args = ( 'alvin' ,)) p_list.append(p) p.start() for i in p_list: p.join() print ( 'end' ) |
类式调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
from multiprocessing import Process import time class MyProcess(Process): def __init__( self ): super (MyProcess, self ).__init__() #self.name = name def run( self ): time.sleep( 1 ) print ( 'hello' , self .name,time.ctime()) if __name__ = = '__main__' : p_list = [] for i in range ( 3 ): p = MyProcess() p.start() p_list.append(p) for p in p_list: p.join() print ( 'end' ) |
Process类
构造方法
Process([group [, target [, name [, args [, kwargs]]]]])
group: 线程组,目前还没有实现,库引用中提示必须是None;
target: 要执行的方法;
name: 进程名;
args/kwargs: 要传入方法的参数。
实例方法
is_alive():返回进程是否在运行。
join([timeout]):阻塞当前上下文环境的进程程,直到调用此方法的进程终止或到达指定的timeout(可选参数)。
start():进程准备就绪,等待CPU调度
run():strat()调用run方法,如果实例进程时未制定传入target,这star执行t默认run()方法。
terminate():不管任务是否完成,立即停止工作进程
属性
authkey
daemon:和线程的setDeamon功能一样
exitcode(进程在运行时为None、如果为–N,表示被信号N结束)
name:进程名字。
pid:进程号。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import time from multiprocessing import Process def foo(i): time.sleep( 1 ) print (p.is_alive(),i,p.pid) time.sleep( 1 ) if __name__ = = '__main__' : p_list = [] for i in range ( 10 ): p = Process(target = foo, args = (i,)) #p.daemon=True p_list.append(p) for p in p_list: p.start() # for p in p_list: # p.join() print ( 'main process end' ) |
进程间通讯
不同进程间内存是不共享的,要想实现两个进程间的数据交换,可以用以下方法:
——进程队列Queues(使用方法跟threading里的queue类似:)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
from multiprocessing import Process, Queue def f(q,n): q.put([ 42 , n, 'hello' ]) if __name__ = = '__main__' : q = Queue() p_list = [] for i in range ( 3 ): p = Process(target = f, args = (q,i)) p_list.append(p) p.start() print (q.get()) print (q.get()) print (q.get()) for i in p_list: i.join() |
——管道Pipe
1
2
3
4
5
6
7
8
9
10
11
12
|
from multiprocessing import Process, Pipe def f(conn): conn.send([ 42 , None , 'hello' ]) conn.close() if __name__ = = '__main__' : parent_conn, child_conn = Pipe() p = Process(target = f, args = (child_conn,)) p.start() print (parent_conn.recv()) # prints "[42, None, 'hello']" p.join() |
——managers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
from multiprocessing import Process, Manager def f(d, l,n): d[n] = '1' d[ '2' ] = 2 d[ 0.25 ] = None l.append(n) print (l) if __name__ = = '__main__' : with Manager() as manager: d = manager. dict () l = manager. list ( range ( 5 )) p_list = [] for i in range ( 10 ): p = Process(target = f, args = (d, l,i)) p.start() p_list.append(p) for res in p_list: res.join() print (d) print (l) |
进程同步
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
from multiprocessing import Process, Lock def f(l, i): l.acquire() try : print ( 'hello world' , i) finally : l.release() if __name__ = = '__main__' : lock = Lock() for num in range ( 10 ): Process(target = f, args = (lock, num)).start() |
进程池
进程池内部维护一个进程序列,当使用时,去进程池中获取一个进程,如果进程池序列中没有可供使用的进程,那么程序就会等待,直到进程池中有可用进程为止。
进程池中有以下几个主要方法:
- apply:从进程池里取一个进程并执行
- apply_async:apply的异步版本
- terminate:立刻关闭线程池
- join:主进程等待所有子进程执行完毕,必须在close或terminate之后
- close:等待所有进程结束后,才关闭线程池
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
from multiprocessing import Process,Pool import time def Foo(i): time.sleep( 2 ) return i + 100 def Bar(arg): print ( '-->exec done:' ,arg) pool = Pool( 5 ) for i in range ( 10 ): pool.apply_async(func = Foo, args = (i,),callback = Bar) #pool.apply(func=Foo, args=(i,)) print ( 'end' ) pool.close() pool.join() |
https://www.cnblogs.com/wj-1314/p/8263328.html
(转载)Python 浅析线程(threading模块)和进程(process)的更多相关文章
- Python:使用threading模块实现多线程编程
转:http://blog.csdn.net/bravezhe/article/details/8585437 Python:使用threading模块实现多线程编程一[综述] Python这门解释性 ...
- Python多线程(threading模块)
线程(thread)是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. ...
- python多线程与threading模块
python多线程与_thread模块 中介绍了线程的基本概念以及_thread模块的简单示例.然而,_thread模块过于简单,使得我们无法用它来准确地控制线程,本文介绍threading模块,它提 ...
- Python 浅析线程(threading模块)和进程(process)
线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务 进程与线程 什么 ...
- python成长之路【第十一篇】:网络编程之线程threading模块
一.threading模块介绍 threading 模块建立在 _thread 模块之上.thread 模块以低级.原始的方式来处理和控制线程,而 threading 模块通过对 thread 进行二 ...
- Python开发——14.threading模块和multiprocess模块
一.threading模块 1.threading类的两种创建方法 (1)直接创建 import time import threading def Hi(num): print("hell ...
- Python:多线程threading模块
目录 Thread对象 Lock对象 local对象 Thread对象: 多任务可以由多进程完成,也可以由一个进程内的多线程完成.进程是由至少1个线程组成的. threading模块在较低级的模块 _ ...
- python中的threading模块使用说明
这段时间使用python做串口的底层库,用到了多线程,对这部分做一下总结.实际用完了后再回过头去看python的官方帮助文档,感觉受益匪浅,把里面的自己觉得有用的一些关键点翻译出来,留待后续查验.th ...
- [转载]Python中的sys模块
#!/usr/bin/python # Filename: cat.py import sys def readfile(filename): '''Print a file to the stand ...
- [转载]python 详解re模块
原文地址:python 详解re模块作者:Rocky 正则表达式的元字符有. ^ $ * ? { [ ] | ( ) .表示任意字符 []用来匹配一个指定的字符类别,所谓的字符类别就是你想匹配的一个字 ...
随机推荐
- vue 收藏
html: //收藏 <el-table-column prop="isOpen" label=""> <te ...
- QDateEdit
self.dateEdit.setCalendarPopup(True) # 日历增加 # 日历转化位str类型begintime = self.dateEdit.dateTime().toStrin ...
- vue原理
1. Vue 响应式原理 核心实现类: Observer : 它的作用是给对象的属性添加 getter 和 setter,用于依赖收集和派发更新 Dep : 用于收集当前响应式对象的依赖关系,每个响应 ...
- Unity3D发布Android注意事项
当你制作完一款游戏,准备发布Android平台时,需要进行一些设置.如下: 一.设置AndroidSDK路级和JDK路径 AndroidSDK目录可以通过AndroidStudio查看,如下: 这个路 ...
- 056_Connect or Sync to your Salesforce database by using an external database
Integrate Salesforce with an External database: https://help.salesforce.com/articleView?id=000109985 ...
- create-react-app卸载与升级
用create-react-app 创建项目发现报错 You are running `create-react-app` 4.0.3, which is behind the latest rele ...
- [转]Selenium私房菜系列1 -- Selenium简介
一.Selenium是什么? Selenium是ThroughtWorks公司一个强大的开源Web功能测试工具系列,本系列现在主要包括以下4款: 1.Selenium Core:支持DHTML的测试案 ...
- 数据结构(C语言)_链表
//单链表按序号查找节点的值 LNode* GetElem(LinkList L, int i) { int j = 1; LNode* p = L->next; if (i == 0) ret ...
- Ubuntu ROOT默认密码设置
Ubuntu默认密码设置 Ubuntu默认是不设置ROOT密码的,如果需要安装一些包则需要从普通用户调转至ROOT用户,这个时候就需要设置一下密码了. 下面这种情况 chen@chen:~/Deskt ...
- 批处理执行指定文件jar包并输出日志
jar包运行,每次都要手动执行命令.这么机械的操作当然要由脚本来完成. @echo off rem 按当天日期输出日志 set today=%date:~0,4%-%date:~5,2%-%date: ...