Python3中最常用的5种线程锁你会用吗
moboyou 2025-06-07 16:56 24 浏览
前言
本章节将继续围绕threading模块讲解，基本上是纯理论偏多。
对于日常开发者来讲很少会使用到本章节的内容，但是对框架作者等是必备知识，同时也是高频的面试常见问题。
私信小编01即可获取大量Python学习资料
线程安全
线程安全是多线程或多进程编程中的一个概念，在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。
线程安全的问题最主要还是由线程切换导致的，比如一个房间（进程）中有10颗糖（资源），除此之外还有3个小人（1个主线程、2个子线程），当小人A吃了3颗糖后被系统强制进行休息时他认为还剩下7颗糖，而当小人B工作后又吃掉了3颗糖，那么当小人A重新上岗时会认为糖还剩下7颗，但是实际上只有4颗了。
上述例子中线程A和线程B的数据不同步，这就是线程安全问题，它可能导致非常严重的意外情况发生，我们按下面这个示例来进行说明。
下面有一个数值num初始值为0，我们开启2条线程：
- 线程1对num进行一千万次+1的操作
- 线程2对num进行一千万次-1的操作
结果可能会令人咋舌，num最后并不是我们所想象的结果0：
import threading
num = 0
def add():
global num
for i in range(10_000_000):
num += 1
def sub():
global num
for i in range(10_000_000):
num -= 1
if __name__ == "__main__":
subThread01 = threading.Thread(target=add)
subThread02 = threading.Thread(target=sub)
subThread01.start()
subThread02.start()
subThread01.join()
subThread02.join()
print("num result : %s" % num)
# 结果三次采集
# num result : 669214
# num result : -1849179
# num result : -525674上面这就是一个非常好的案例，想要解决这个问题就必须通过锁来保障线程切换的时机。
需要我们值得留意的是，在Python基本数据类型中list、tuple、dict本身就是属于线程安全的，所以如果有多个线程对这3种容器做操作时，我们不必考虑线程安全问题。
锁的作用
锁是Python提供给我们能够自行操控线程切换的一种手段，使用锁可以让线程的切换变的有序。
一旦线程的切换变的有序后，各个线程之间对数据的访问、修改就变的可控，所以若要保证线程安全，就必须使用锁。
threading模块中提供了5种最常见的锁，下面是按照功能进行划分：
- 同步锁：lock（一次只能放行一个）
- 递归锁：rlock（一次只能放行一个）
- 条件锁：condition（一次可以放行任意个）
- 事件锁：event（一次全部放行）
- 信号量锁：semaphore（一次可以放行特定个）
Lock() 同步锁
基本介绍
Lock锁的称呼有很多，如：
- 同步锁
- 互斥锁
它们是什么意思呢？如下所示：
- 互斥指的是某一资源同一时刻仅能有一个访问者对其进行访问，具有唯一性和排他性，但是互斥无法限制访问者对资源的访问顺序，即访问是无序的
- 同步是指在互斥的基础上（大多数情况），通过其他机制实现访问者对资源的有序访问
- 同步其实已经实现了互斥，是互斥的一种更为复杂的实现，因为它在互斥的基础上实现了有序访问的特点
下面是threading模块与同步锁提供的相关方法：
方法 | 描述 |
threading.Lock() | 返回一个同步锁对象 |
lockObject.acquire(blocking=True, timeout=1) | 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒 |
lockObject.release() | 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行 |
lockObject.locaked() | 判断该锁对象是否处于上锁状态，返回一个布尔值 |
使用方式
同步锁一次只能放行一个线程，一个被加锁的线程在运行时不会将执行权交出去，只有当该线程被解锁时才会将执行权通过系统调度交由其他线程。
如下所示，使用同步锁解决最上面的问题：
import threading
num = 0
def add():
lock.acquire()
global num
for i in range(10_000_000):
num += 1
lock.release()
def sub():
lock.acquire()
global num
for i in range(10_000_000):
num -= 1
lock.release()
if __name__ == "__main__":
lock = threading.Lock()
subThread01 = threading.Thread(target=add)
subThread02 = threading.Thread(target=sub)
subThread01.start()
subThread02.start()
subThread01.join()
subThread02.join()
print("num result : %s" % num)
# 结果三次采集
# num result : 0
# num result : 0
# num result : 0这样这个代码就完全变成了串行的状态，对于这种计算密集型I/O业务来说，还不如直接使用串行化单线程执行来得快，所以这个例子仅作为一个示例，不能概述锁真正的用途。
死锁现象
对于同步锁来说，一次acquire()必须对应一次release()，不能出现连续重复使用多次acquire()后再重复使用多次release()的操作，这样会引起死锁造成程序的阻塞，完全不动了，如下所示：
import threading
num = 0
def add():
lock.acquire() # 上锁
lock.acquire() # 死锁
# 不执行
global num
for i in range(10_000_000):
num += 1
lock.release()
lock.release()
def sub():
lock.acquire() # 上锁
lock.acquire() # 死锁
# 不执行
global num
for i in range(10_000_000):
num -= 1
lock.release()
lock.release()
if __name__ == "__main__":
lock = threading.Lock()
subThread01 = threading.Thread(target=add)
subThread02 = threading.Thread(target=sub)
subThread01.start()
subThread02.start()
subThread01.join()
subThread02.join()
print("num result : %s" % num)with语句
由于threading.Lock()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：
import threading
num = 0
def add():
with lock:
# 自动加锁
global num
for i in range(10_000_000):
num += 1
# 自动解锁
def sub():
with lock:
# 自动加锁
global num
for i in range(10_000_000):
num -= 1
# 自动解锁
if __name__ == "__main__":
lock = threading.Lock()
subThread01 = threading.Thread(target=add)
subThread02 = threading.Thread(target=sub)
subThread01.start()
subThread02.start()
subThread01.join()
subThread02.join()
print("num result : %s" % num)
# 结果三次采集
# num result : 0
# num result : 0
# num result : 0RLock() 递归锁
基本介绍
递归锁是同步锁的一个升级版本，在同步锁的基础上可以做到连续重复使用多次acquire()后再重复使用多次release()的操作，但是一定要注意加锁次数和解锁次数必须一致，否则也将引发死锁现象。
下面是threading模块与递归锁提供的相关方法：
方法 | 描述 |
threading.RLock() | 返回一个递归锁对象 |
lockObject.acquire(blocking=True, timeout=1) | 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒 |
lockObject.release() | 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行 |
lockObject.locaked() | 判断该锁对象是否处于上锁状态，返回一个布尔值 |
使用方式
以下是递归锁的简单使用，下面这段操作如果使用同步锁则会发生死锁现象，但是递归锁不会：
import threading
num = 0
def add():
lock.acquire()
lock.acquire()
global num
for i in range(10_000_000):
num += 1
lock.release()
lock.release()
def sub():
lock.acquire()
lock.acquire()
global num
for i in range(10_000_000):
num -= 1
lock.release()
lock.release()
if __name__ == "__main__":
lock = threading.RLock()
subThread01 = threading.Thread(target=add)
subThread02 = threading.Thread(target=sub)
subThread01.start()
subThread02.start()
subThread01.join()
subThread02.join()
print("num result : %s" % num)
# 结果三次采集
# num result : 0
# num result : 0
# num result : 0with语句
由于threading.RLock()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：
import threading
num = 0
def add():
with lock:
# 自动加锁
global num
for i in range(10_000_000):
num += 1
# 自动解锁
def sub():
with lock:
# 自动加锁
global num
for i in range(10_000_000):
num -= 1
# 自动解锁
if __name__ == "__main__":
lock = threading.RLock()
subThread01 = threading.Thread(target=add)
subThread02 = threading.Thread(target=sub)
subThread01.start()
subThread02.start()
subThread01.join()
subThread02.join()
print("num result : %s" % num)
# 结果三次采集
# num result : 0
# num result : 0
# num result : 0Condition() 条件锁
基本介绍
条件锁是在递归锁的基础上增加了能够暂停线程运行的功能。并且我们可以使用wait()与notify()来控制线程执行的个数。
注意：条件锁可以自由设定一次放行几个线程。
下面是threading模块与条件锁提供的相关方法：
方法 | 描述 |
threading.Condition() | 返回一个条件锁对象 |
lockObject.acquire(blocking=True, timeout=1) | 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒 |
lockObject.release() | 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行 |
lockObject.wait(timeout=None) | 将当前线程设置为“等待”状态，只有该线程接到“通知”或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行 |
lockObject.wait_for(predicate, timeout=None) | 将当前线程设置为“等待”状态，只有该线程的predicate返回一个True或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行。注意：predicate参数应当传入一个可调用对象，且返回结果为bool类型 |
lockObject.notify(n=1) | 通知一个当前状态为“等待”的线程继续运行，也可以通过参数n通知多个 |
lockObject.notify_all() | 通知所有当前状态为“等待”的线程继续运行 |
使用方式
下面这个案例会启动10个子线程，并且会立即将10个子线程设置为等待状态。
然后我们可以发送一个或者多个通知，来恢复被等待的子线程继续运行：
import threading
currentRunThreadNumber = 0
maxSubThreadNumber = 10
def task():
global currentRunThreadNumber
thName = threading.currentThread().name
condLock.acquire() # 上锁
print("start and wait run thread : %s" % thName)
condLock.wait() # 暂停线程运行、等待唤醒
currentRunThreadNumber += 1
print("carry on run thread : %s" % thName)
condLock.release() # 解锁
if __name__ == "__main__":
condLock = threading.Condition()
for i in range(maxSubThreadNumber):
subThreadIns = threading.Thread(target=task)
subThreadIns.start()
while currentRunThreadNumber < maxSubThreadNumber:
notifyNumber = int(
input("Please enter the number of threads that need to be notified to run："))
condLock.acquire()
condLock.notify(notifyNumber) # 放行
condLock.release()
print("main thread run end")
# 先启动10个子线程，然后这些子线程会全部变为等待状态
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3
# start and wait run thread : Thread-4
# start and wait run thread : Thread-5
# start and wait run thread : Thread-6
# start and wait run thread : Thread-7
# start and wait run thread : Thread-8
# start and wait run thread : Thread-9
# start and wait run thread : Thread-10
# 批量发送通知，放行特定数量的子线程继续运行
# Please enter the number of threads that need to be notified to run：5 # 放行5个
# carry on run thread : Thread-4
# carry on run thread : Thread-3
# carry on run thread : Thread-1
# carry on run thread : Thread-2
# carry on run thread : Thread-5
# Please enter the number of threads that need to be notified to run：5 # 放行5个
# carry on run thread : Thread-8
# carry on run thread : Thread-10
# carry on run thread : Thread-6
# carry on run thread : Thread-9
# carry on run thread : Thread-7
# Please enter the number of threads that need to be notified to run：1
# main thread run endwith语句
由于threading.Condition()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：
import threading
currentRunThreadNumber = 0
maxSubThreadNumber = 10
def task():
global currentRunThreadNumber
thName = threading.currentThread().name
with condLock:
print("start and wait run thread : %s" % thName)
condLock.wait() # 暂停线程运行、等待唤醒
currentRunThreadNumber += 1
print("carry on run thread : %s" % thName)
if __name__ == "__main__":
condLock = threading.Condition()
for i in range(maxSubThreadNumber):
subThreadIns = threading.Thread(target=task)
subThreadIns.start()
while currentRunThreadNumber < maxSubThreadNumber:
notifyNumber = int(
input("Please enter the number of threads that need to be notified to run："))
with condLock:
condLock.notify(notifyNumber) # 放行
print("main thread run end")Event() 事件锁
基本介绍
事件锁是基于条件锁来做的，它与条件锁的区别在于一次只能放行全部，不能放行任意个数量的子线程继续运行。
我们可以将事件锁看为红绿灯，当红灯时所有子线程都暂停运行，并进入“等待”状态，当绿灯时所有子线程都恢复“运行”。
下面是threading模块与事件锁提供的相关方法：
方法 | 描述 |
threading.Event() | 返回一个事件锁对象 |
lockObject.clear() | 将事件锁设为红灯状态，即所有线程暂停运行 |
lockObject.is_set() | 用来判断当前事件锁状态，红灯为False，绿灯为True |
lockObject.set() | 将事件锁设为绿灯状态，即所有线程恢复运行 |
lockObject.wait(timeout=None) | 将当前线程设置为“等待”状态，只有该线程接到“绿灯通知”或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行 |
使用方式
事件锁不能利用with语句来进行使用，只能按照常规方式。
如下所示，我们来模拟线程和红绿灯的操作，红灯停，绿灯行：
import threading
maxSubThreadNumber = 3
def task():
thName = threading.currentThread().name
print("start and wait run thread : %s" % thName)
eventLock.wait() # 暂停运行，等待绿灯
print("green light, %s carry on run" % thName)
print("red light, %s stop run" % thName)
eventLock.wait() # 暂停运行，等待绿灯
print("green light, %s carry on run" % thName)
print("sub thread %s run end" % thName)
if __name__ == "__main__":
eventLock = threading.Event()
for i in range(maxSubThreadNumber):
subThreadIns = threading.Thread(target=task)
subThreadIns.start()
eventLock.set() # 设置为绿灯
eventLock.clear() # 设置为红灯
eventLock.set() # 设置为绿灯
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3
# green light, Thread-1 carry on run
# red light, Thread-1 stop run
# green light, Thread-1 carry on run
# sub thread Thread-1 run end
# green light, Thread-3 carry on run
# red light, Thread-3 stop run
# green light, Thread-3 carry on run
# sub thread Thread-3 run end
# green light, Thread-2 carry on run
# red light, Thread-2 stop run
# green light, Thread-2 carry on run
# sub thread Thread-2 run endSemaphore() 信号量锁
基本介绍
信号量锁也是根据条件锁来做的，它与条件锁和事件锁的区别如下：
- 条件锁：一次可以放行任意个处于“等待”状态的线程
- 事件锁：一次可以放行全部的处于“等待”状态的线程
- 信号量锁：通过规定，成批地放行特定个处于“上锁”状态的线程
下面是threading模块与信号量锁提供的相关方法：
方法 | 描述 |
threading.Semaphore() | 返回一个信号量锁对象 |
lockObject.acquire(blocking=True, timeout=1) | 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒 |
lockObject.release() | 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行 |
使用方式
以下是使用示例，你可以将它当做一段限宽的路段，每次只能放行相同数量的线程：
import threading
import time
maxSubThreadNumber = 6
def task():
thName = threading.currentThread().name
semaLock.acquire()
print("run sub thread %s" % thName)
time.sleep(3)
semaLock.release()
if __name__ == "__main__":
# 每次只能放行2个
semaLock = threading.Semaphore(2)
for i in range(maxSubThreadNumber):
subThreadIns = threading.Thread(target=task)
subThreadIns.start()
# run sub thread Thread-1
# run sub thread Thread-2
# run sub thread Thread-3
# run sub thread Thread-4
# run sub thread Thread-6
# run sub thread Thread-5with语句
由于threading.Semaphore()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：
import threading
import time
maxSubThreadNumber = 6
def task():
thName = threading.currentThread().name
with semaLock:
print("run sub thread %s" % thName)
time.sleep(3)
if __name__ == "__main__":
semaLock = threading.Semaphore(2)
for i in range(maxSubThreadNumber):
subThreadIns = threading.Thread(target=task)
subThreadIns.start()锁关系浅析
上面5种锁可以说都是基于同步锁来做的，这些你都可以从源码中找到答案。
首先来看RLock递归锁，递归锁的实现非常简单，它的内部会维护着一个计数器，当计数器不为0的时候该线程不能被I/O操作和时间轮询机制切换。但是当计数器为0的时候便不会如此了：
def __init__(self):
self._block = _allocate_lock()
self._owner = None
self._count = 0 # 计数器而Condition条件锁的内部其实是有两把锁的，一把底层锁（同步锁）一把高级锁(递归锁)。
低层锁的解锁方式有两种，使用wait()方法会暂时解开底层锁同时加上一把高级锁，只有当接收到别的线程里的notfiy()后才会解开高级锁和重新上锁低层锁，也就是说条件锁底层是根据同步锁和递归锁的不断切换来进行实现的：
def __init__(self, lock=None):
if lock is None:
lock = RLock() # 可以看到条件锁的内部是基于递归锁，而递归锁又是基于同步锁来做的
self._lock = lock
self.acquire = lock.acquire
self.release = lock.release
try:
self._release_save = lock._release_save
except AttributeError:
pass
try:
self._acquire_restore = lock._acquire_restore
except AttributeError:
pass
try:
self._is_owned = lock._is_owned
except AttributeError:
pass
self._waiters = _deque()Event事件锁内部是基于条件锁来做的：
class Event:
def __init__(self):
self._cond = Condition(Lock()) # 实例化出了一个条件锁。
self._flag = False
def _reset_internal_locks(self):
# private! called by Thread._reset_internal_locks by _after_fork()
self._cond.__init__(Lock())
def is_set(self):
"""Return true if and only if the internal flag is true."""
return self._flag
isSet = is_setSemaphore信号量锁内部也是基于条件锁来做的：
class Semaphore:
def __init__(self, value=1):
if value < 0:
raise ValueError("semaphore initial value must be >= 0")
self._cond = Condition(Lock()) # 可以看到，这里是实例化出了一个条件锁
self._value = value基本练习题
条件锁的应用
需求：一个空列表，两个线程轮番往里面加值（一个加偶数，一个加奇数），最终让该列表中的值为 1 - 100 ，且是有序排列的。
import threading
lst = []
def even():
"""加偶数"""
with condLock:
for i in range(2, 101, 2):
# 判断当前列表的长度处于2是否能处尽
# 如果能处尽则代表需要添加奇数
# 否则就添加偶数
if len(lst) % 2 != 0:
# 添偶数
lst.append(i) # 先添加值
condLock.notify() # 告诉另一个线程，你可以加奇数了，但是这里不会立即交出执行权
condLock.wait() # 交出执行权，并等待另一个线程通知加偶数
else:
# 添奇数
condLock.wait() # 交出执行权，等待另一个线程通知加偶数
lst.append(i)
condLock.notify()
condLock.notify()
def odd():
"""加奇数"""
with condLock:
for i in range(1, 101, 2):
if len(lst) % 2 == 0:
lst.append(i)
condLock.notify()
condLock.wait()
condLock.notify()
if __name__ == "__main__":
condLock = threading.Condition()
addEvenTask = threading.Thread(target=even)
addOddTask = threading.Thread(target=odd)
addEvenTask.start()
addOddTask.start()
addEvenTask.join()
addOddTask.join()
print(lst)事件锁的应用
有2个任务线程来扮演李白和杜甫，如何让他们一人一句进行对答？文本如下：
杜甫：老李啊，来喝酒！
李白：老杜啊，不喝了我喝不下了！
杜甫：老李啊，再来一壶？
杜甫：...老李？
李白：呼呼呼...睡着了..
代码如下：
import threading
def libai():
event.wait()
print("李白：老杜啊，不喝了我喝不下了！")
event.set()
event.clear()
event.wait()
print("李白：呼呼呼...睡着了..")
def dufu():
print("杜甫：老李啊，来喝酒！")
event.set()
event.clear()
event.wait()
print("杜甫：老李啊，再来一壶？")
print("杜甫：...老李？")
event.set()
if __name__ == '__main__':
event = threading.Event()
t1 = threading.Thread(target=libai)
t2 = threading.Thread(target=dufu)
t1.start()
t2.start()
t1.join()
t2.join()相关推荐
- python新手学习常见数据类型——数字
-
Python支持三种不同的数值类型：整型(int)、浮点型(float)、复数(complex)创建数字：a=1b=2.7c=8+4j删除数字：a=1b=2.7c=8+4...
- 只用一个套路公式，给 Excel 中一列人员设置随机出场顺序
-
很多同学会觉得Excel单个案例讲解有些碎片化，初学者未必能完全理解和掌握。不少同学都希望有一套完整的图文教学，从最基础的概念开始，一步步由简入繁、从入门到精通，系统化地讲解Excel的各个知...
- Excel神技 TIME函数:3秒搞定时间拼接!职场人必学的效率秘籍
-
你是否经常需要在Excel中手动输入时间，或者从不同单元格拼接时、分、秒？今天我要揭秘一个超实用的Excel函数——TIME函数，它能让你3秒内生成标准时间格式，彻底告别繁琐操作！一、TIME函数基础...
- 销售算错数被批?97 Excel 数字函数救场，3 步搞定复杂计算
-
销售部小张被老板当着全部门骂。上季度销售额汇总，他把38652.78算成36852.78，差了1800块。财务对账时发现，整个部门的提成表都得重算。"连个数都算不对，还做什么销售？&...
- 如何使用Minitab 1分钟生成所需要的SPC数据
-
打开Minitab，“计算”-“随机数据”-“正太”，因为不好截图，使用的是拍照记录的方式.再要生产的行数中，填写125，可以按照要求，有些客户要求的是100个数据，就可以填写100...
- 验证码，除了 12306，我还没有服过谁
-
为了防止暴力注册或爬虫爬取等机器请求，需要验证操作者是人还是机器，便有了验证码这个设计。本文作者主要介绍了如何使用Axure来设计一个动态的图形验证码，一起来学习一下吧。在软件设计中，为了防止暴力...
- 零基础也能学会的9个Excel函数，小白进阶必备
-
今天给大家分享一些常用的函数公式，可以有效地解决Excel中办公所需，0基础也可以轻松学会。建议收藏，在需要的时候可以直接套用函数。1、计算排名根据总和，计算学生成绩排名。函数公式=RANK(E2,$...
- [office] excel表格数值如何设置_excel表格怎样设置数值
-
excel表格数值如何设置 因为电子表格应用程序是用来处理数值数据的，所以数值格式可能是工作表中最关键的部分，格式化数值数据的方式由用户决定，但在每个工作簿的工作表之间应使用一致的处理数字的方法。...
- Excel最常用的5个函数!会用最后一个才是高手
-
是不是在处理Excel数据时，面对繁琐的操作烦恼不已？手动操作不仅耗时费力，还容易出错。别担心，表姐这就为你揭秘Excel中几个超实用的函数，让数据处理变得轻松高效！表姐整理了552页《Office从...
- 新手必会的53个Excel函数_惊呆小伙伴的全套excel函数技能
-
（新手入门+进阶+新函数）一、新手入门级(24个)1、Sum函数：求和=Sum(区域)2、Average函数：求平均值=Average(区域)3、Count函数：数字个数=Count(区域)4、Cou...
- 打工人私藏的4个Excel函数秘籍，效率提升3.7%
-
小伙伴们好啊，今天咱们分享几个常用函数公式的典型应用。合并内容如下图，希望将B列的姓名，按照不同部门合并到一个单元格里。=TEXTJOIN(",",1,IF(A$2:A$15=D2,B...
- Excel偷偷更新的8个函数!原来高手都在用这些隐藏技能
-
领导突然要销售数据，你手忙脚乱筛选到眼花...同事3分钟搞定的报表，你折腾半小时还在填充公式...明明用了VLOOKUP，却总显示#N/A错误...别慌！今天教你的8个动态数组函数，就像给Excel装...
- Excel表格随机函数怎么用?讲解三种随机函数在不同场景的应用
-
excel随机函数，其特点是能够生成一组随机数字，根据不同需求，还能批量生成小数位和整数，及指定行数和列数，或指定区间范围内的数字。这里根据需求，作者设置了三个问题，第1个是随机生成0至1之间的数字...
- 单纯随机抽样该如何进行?_单纯随机抽样的适用范围及注意事项
-
在数据分析中，抽样是指从全部数据中选择部分数据进行分析，以发掘更大规模数据集中的有用信息。在收集数据过程中，绝大多数情况下，并不采取普查的方式获取总体中所有样本的数据信息，而是以各类抽样方法抽取其中若...
- 随机函数在Excel中的应用_随机函数在excel中的应用实例
-
【分享成果，随喜正能量】职场，如果你没有价值，那么你随时可能被取代;如果你的价值不如别人，那么社会也不会惯你，你将被无情地淘汰掉。不管什么时候，你一定要学会构建自己的价值。每个人都应该思考这个问题：我...
- 一周热门
- 最近发表
- 标签列表
-
- 外键约束 oracle (36)
- oracle的row number (32)
- 唯一索引 oracle (34)
- oracle in 表变量 (28)
- oracle导出dmp导出 (28)
- 多线程的创建方式 (29)
- 多线程 python (30)
- java多线程并发处理 (32)
- 宏程序代码一览表 (35)
- c++需要学多久 (25)
- css class选择器用法 (25)
- css样式引入 (30)
- css教程文字移动 (33)
- php简单源码 (36)
- php个人中心源码 (25)
- php小说爬取源码 (23)
- 云电脑app源码 (22)
- html画折线图 (24)
- docker好玩的应用 (28)
- linux有没有pe工具 (34)
- mysql数据库源码 (21)
- php开源万能表单系统源码 (21)
- 可以上传视频的网站源码 (25)
- match函数的功能是 (21)
- 随机函数如何生成小数点数字 (31)