python删除列的操作怎么操作的呢？

Posted 2023-04-23

参考技术A

具体操作步骤如下：

1、首先，来了解下以下两个函数，可以使用这两个函数来进行删除所有零行或全部列的操作。如下图所示，然后进入下一步。

2、其次，创建一个a  = [1,2,4; 0,0,0; 1,3,5;  [0,0,0]矩阵，可以看到此矩阵中有两行是全0行，如下图所示，然后进入下一步。

3、接着，键入all（a  == 0，2），这将返回一个列向量，并且可以检测所有零行的位置，因为使用了a =  0，所以返回的是0表示非零元素，返回1表示所有零行，如下图所示，然后进入下一步。

4、然后，键入以下代码：a（all（a  == 0,2），:) = []，来删除所有0行，如下图所示，然后进入下一步。

5、最后，按Enter确认，可以看到矩阵的两行全0行就被删除了，如下图所示。这样，问题就解决了。

python-进程线程

一、解释：

   相信百分之百的同学都会用到操作系统，别说不用，不用的话特么你怎么看的我的博客，而我们的操作系统你可以一遍看着我写的博客，又一遍听着音乐，说到音乐给大家推荐一首叫做"Shape of You",而我就是边听着音乐边写博客，哈哈.....；那么这里我们就要想了，我们的计算机又是怎么来运算的呢？怎么同时开启这么多任务的呢？而且还有好多任务偷偷的在后台运行着呢，只是桌面上没有显示而已。

   而现在多核心多线程的计算机已经很普及，是的，这样计算的并发可以更多更快，但是在计算机刚流行的时候，很多单核CPU又怎么执行多任务的呢？毕竟CPU执行代码都是按照顺序执行的；而答案就是计算机上的操作系统轮流让各个任务交替执行，任务A执行0.01秒，切换到任务B上执行0.01秒，再切换到任务3上，这样反复下去，表面上看每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

  所以，我们在日常运行的环境中，并行执行多任务只能在多核心多线程的CPU上实现，但是我们有的时候任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。 

   对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

  有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。
  由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

  总结：

   应用程序--->进程--->线程  

   应用程序最少有一个进程，而一个进程最后有一个主线程，而一个程序可以启多个进程，一个进程可以启动多个线程，而它们都有自己的主进程和主线程，而进程和线程都是有CPU来运算，运算方式就是来回切换运算。

线程和进程Python与其它开发语言的不同，其它语言线程之间可以在多个CPU之间切换，而Python不支持多线程，只能多进程（前提是被CPU调用），所以出现了以下应用场景

 应用场景：

   IO密集型：多线程

   计算密集型：多进程

 GIL，全局解释器锁，保证同一个进程中只有一个线程同时被调用

二、线程的使用

  看代码

 

import threading    #导入线程的模块
import time
def task(a):    #进程的函数
    time.sleep(1)    #等待一秒
    print(a)
for i in range(30):   #同时启动30个线程
    t = threading.Thread(target=task,args=[i,])   #创建了进程，target表示要创建的进程
    t.start()                #进程启动，表示开始工作
print("end")     #启动主进程

 

setDaemon的用法

 说明:setDaemon 设置主进程是否等待子线程结束了，再结束自己，默认选项为(False)

 例子： (默认选项)

import threading    #导入线程的模块
import time
def task(a):    #进程的函数
    time.sleep(1)    #等待一秒
    print(a)
for i in range(5):
    t = threading.Thread(target=task,args=[i,])   #创建了进程，target表示要创建的进程
    t.setDaemon(False)    #主进程是否等待子线程，False 是等待 True是不等待
    t.start()                #进程启动
print("end")     #启动主进程
###输出如下：
C:\Python35\python.exe D:/linux/python/day-test/day9/test1.py
end
0
2
1
3
4

非默认选项(True)

import threading    #导入线程的模块
import time
def task(a):    #进程的函数
    time.sleep(1)    #等待一秒
    print(a)
for i in range(5):
    t = threading.Thread(target=task,args=[i,])   #创建了进程，target表示要创建的进程
    t.setDaemon(True)    #主进程是否等待子线程，False 是等待 True是不等待
    t.start()                #进程启动
print("end")     #启动主进程

输出如下:

import threading    #导入线程的模块
import time
def task(a):    #进程的函数
    time.sleep(1)    #等待一秒
    print(a)
for i in range(5):
    t = threading.Thread(target=task,args=[i,])   #创建了进程，target表示要创建的进程
    t.setDaemon(True)    #主进程是否等待子线程，False 是等待 True是不等待
    t.start()                #进程启动
print("end")     #启动主进程

##下面没有等子线程就结束
C:\Python35\python.exe D:/linux/python/day-test/day9/test1.py
end

Process finished with exit code 0

join用法

import threading    #导入线程的模块
import time
def task(a):    #进程的函数
    time.sleep(3)    #等待一秒
    print(a)
for i in range(5):
    t = threading.Thread(target=task,args=[i,])   #创建了进程，target表示要创建的进程
    t.setDaemon(False)    #主进程是否等待子线程，False 是等待 True是不等待
    t.start()                #进程启动
    t.join()       #等待的最大时间，等待的是子线程的运行时间，默认为一直等
print("end")     #启动主进程
#输出：
C:\Python35\python.exe D:/linux/python/day-test/day9/test1.py
0
1
2
3
4
end

线程的锁

 单个锁

import threading
import time
v = 10
#1、只能一个人使用锁
#lock = threading.Lock()  #此锁只能锁一次
lock = threading.RLock()  #此锁可以锁多层
def task(arg):
    time.sleep(2)
    #申请使用锁，其他人等待
    lock.acquire()
    lock.acquire()
    lock.acquire()
    global v
    v -= 1
    print(v)
    #释放
    lock.release()
    lock.release()
    lock.release()
for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()

多个人的锁

import threading
import time
v = 10
#1、多个人使用锁

lock = threading.BoundedSemaphore(3)  #此锁可以被多人使用3代表3个人同时使用
def task(arg):
   # time.sleep(2)
    #申请使用锁，其他人等待
    lock.acquire()
    time.sleep(1)
    global v
    v -= 1
    print(v)
    #释放
    lock.release()
for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()

事件锁

import requests
import threading
import time

lock = threading.Event()  #进程锁的方式
def task(arg):
    time.sleep(1)
    lock.wait()  #进程等候命令，开锁
    print(arg)
for i in range(5):
    t = threading.Thread(target=task,args=(i,))
    t.start()
while True:
    value = input(">>>>>")
    if value == "1":
        lock.set()   #开锁

#输出：
C:\Python35\python.exe D:/linux/python/day-test/day9/事件锁.py
>>>>>
>>>>>2
>>>>>1    #输入1之后开锁
>>>>>0
4
3
1
2

自定义锁，自己设置线程的锁的个数

import threading
import time
lock = threading.Condition()
def task(arg):
    time.sleep(1)
    #锁住所有线程
    lock.acquire()    #获得锁
    lock.wait()       #锁等候
    #申请使用锁，其他人等待
    print("线程",arg)
    lock.release()  #释放锁
for i in range(10):
    t = threading.Thread(target=task,args=(i,))
    t.start()
while True:
    value = input(">>>>>>>>")
    lock.acquire()        #获得锁
    lock.notify(int(value))  #设置释放的线程，你写几个上面线程释放几个
    lock.release()  #释放锁

输出：

>>>>>>>>6
>>>>>>>>线程 2
线程 4
线程 3
线程 1
线程 0
线程 8