这里前面的linux基础就不补充了，只写一些比较高级的
目录
一、文件查找
1.按照名字查找
find 查找目录 -name 文件名字
2.通配符
*匹配多个字符
?匹配单个字符
3.文件大小查找
find 文件目录 -size [+,-]长度查找当前目录以及子目录下大于4K的文件
find . -size +4k查找当前目录以及子目录下小于4K的文件
find . -size -4k二、压缩和打包
1.zip
zip
unzip
2.gzip
gzip使用
解压
gzip -d
3.tar命令
常用
打包
tar cvf
压缩
所以说压缩一个文件分两步，先打包，后压缩
tar命令也可以一步到位
tar zcvf
相应的解包也可以一步到位
tar xcvf
或者tart xvf先解压，-C执行解压到的目录
三、权限管理
rwx-rwx-rwx
四、多进程
1.创建进程
import multiprocessing
import time
def task1():
for i in range(10):
print('A -- ',i + 1)
time.sleep(1)
def task2():
for i in range(10):
print('B -- ',i + 1)
time.sleep(1)
if __name__ == '__main__':
p1 = multiprocessing.Process(target=task1)
p2 = multiprocessing.Process(target=task2)
p1.start()
p2.start()2.获取进程id
获取进程ID和进程的父ID，进程名
这两个进程都是同一个父进程拉起来的
import multiprocessing
import time
import os
def task1():
mp = multiprocessing.current_process()
print("task1: ", mp)
print(f"任务1的PID：{os.getpid()} 父进程的PID是{os.getppid()}")
time.sleep(1)
def task2():
mp = multiprocessing.current_process()
print("task2: ", mp)
print(f"任务2的PID：{os.getpid()} 父进程的PID是{os.getppid()}")
time.sleep(1)
if __name__ == '__main__':
print(f"主进程的PID：{os.getpid()} 父进程的PID是{os.getppid()}")
#获取当前进程对象
mp = multiprocessing.current_process()
print("main: ",mp)
p1 = multiprocessing.Process(target=task1,name='p1')
p2 = multiprocessing.Process(target=task2,name='p2')
print(p1)
print(p2)
p1.start()
p2.start()
print(p1)
print(p2)
3.进程传参
必须要传入可迭代参数
import multiprocessing
import time
def task(count):
for i in range(count):
print("任务执行中。。。")
time.sleep(0.2)
else:
print("任务执行完成")
if __name__ == '__main__':
#因为参数
sub_process = multiprocessing.Process(target=task,args=5)
sub_process.start()
import multiprocessing
import time
def task(count):
for i in range(count):
print("任务执行中。。。")
time.sleep(0.2)
else:
print("任务执行完成")
if __name__ == '__main__':
sub_process = multiprocessing.Process(target=task,kwargs={"count": 4})
sub_process.start()
字典必须要要与参数名相同
import multiprocessing
import time
def task(count):
for i in range(count):
print("任务执行中。。。")
time.sleep(0.2)
else:
print("任务执行完成")
if __name__ == '__main__':
#因为参数
sub_process = multiprocessing.Process(target=task,kwargs={'a':2})
sub_process.start()
4.进程不共享全局变量
import multiprocessing
import time
g_list = list()
def add_data():
for i in range(6):
g_list.append(i)
print("add: ",i)
time.sleep(0.2)
print("add_data: ",g_list)
def read_data():
print("read_data",g_list)
if __name__ == '__main__':
# 创建添加数据的子进程
add_data_process = multiprocessing.Process(target=add_data)
# 创建读取数据的子进程
read_data_process = multiprocessing.Process(target=read_data)
#启动子进程执行对应的任务
add_data_process.start()
#阻塞函数，add_data_process执行完才会继续向下执行
add_data_process.join()
#全局变量不共享
read_data_process.start()
5.守护进程
5.1.方式1
import multiprocessing
import time
g_list = list()
def add_data():
for i in range(6):
g_list.append(i)
print("add: ",i)
time.sleep(0.2)
print("add_data: ",g_list)
def read_data():
print("read_data",g_list)
if __name__ == '__main__':
# 创建添加数据的子进程
add_data_process = multiprocessing.Process(target=add_data)
# 创建读取数据的子进程
read_data_process = multiprocessing.Process(target=read_data)
#启动子进程执行对应的任务
add_data_process.start()
#阻塞函数，add_data_process执行完才会继续向下执行
add_data_process.join()
#主进程结束之前，手动调用方法结束子进程
add_data_process.terminate()
print("add_data terminate")
#全局变量不共享
read_data_process.start()
5.2.方式2
import multiprocessing
import time
g_list = list()
def add_data():
for i in range(6):
g_list.append(i)
print("add: ",i)
time.sleep(0.2)
print("add_data: ",g_list)
def read_data():
print("read_data",g_list)
if __name__ == '__main__':
# 创建添加数据的子进程
add_data_process = multiprocessing.Process(target=add_data)
# 创建读取数据的子进程
read_data_process = multiprocessing.Process(target=read_data)
#锁
add_data_process.daemon = True
#启动子进程执行对应的任务
add_data_process.start()
#阻塞函数，add_data_process执行完才会继续向下执行
add_data_process.join()
#全局变量不共享
read_data_process.start()
五、线程
1.线程创建
import threading
import time
def task1():
t = threading.currentThread()
print("task1: ",t)
for i in range(5):
print(" Task A ", i+1)
time.sleep(0.5)
def task2():
t = threading.currentThread()
print("task2: ",t)
for i in range(5):
print(" Task B ", i+1)
time.sleep(0.5)
#创建线程
if __name__ == '__main__':
t1 = threading.Thread(target=task1,name='t1')
t2 = threading.Thread(target=task2,name='t2')
print(t1)
print(t2)
#创建好线程后，线程并不会被执行
#必须启动线程
t1.start()
t2.start()
print(t1)
print(t2)
print("Main Thread")
2.线程执行带有参数的任务
import threading
import time
def task(count):
for i in range(count):
print("任务执行中。。。")
time.sleep(0.2)
else:
print("任务执行完成")
def task1(content , count):
for i in range(count):
print(content,'--',i+1)
time.sleep(0.5)
if __name__ == '__main__':
sub_thread = threading.Thread(target=task,args=(5,))
sub_thread2 = threading.Thread(target=task1,args=('Python',5))
sub_thread.start()
sub_thread2.start()
3.线程的无序性
import threading
import time
def task():
t = threading.current_thread()
for i in range(10):
print(t.name)
time.sleep(0.5)
if __name__ == '__main__':
for i in range(5):
t = threading.Thread(target=task)
t.start()
4.守护主线程
没有守护线程，主线程会随即执行
import threading
import time
def task():
t = threading.current_thread()
for i in range(5):
print(t.name)
time.sleep(0.5)
if __name__ == '__main__':
t1 = threading.Thread(target=task,name='t1')
t2 = threading.Thread(target=task,name='t2')
t1.start()
t2.start()
print("main over") 
方法1
这个方法主线程不等待子线程所以会出现问题
import threading
import time
def task():
t = threading.current_thread()
for i in range(5):
print(t.name)
time.sleep(0.5)
if __name__ == '__main__':
t1 = threading.Thread(target=task,name='t1',daemon=True)
t2 = threading.Thread(target=task,name='t2',daemon=True)
t1.start()
t2.start()
print("main over")
方法2
import threading
import time
def task():
t = threading.current_thread()
for i in range(5):
print(t.name)
time.sleep(0.5)
if __name__ == '__main__':
t1 = threading.Thread(target=task,name='t1')
t2 = threading.Thread(target=task,name='t2')
t1.setDaemon(True)
t2.setDaemon(True)
t1.start()
t2.start()
print("main over")
5.阻塞线程
import threading
import time
def task():
t = threading.current_thread()
for i in range(5):
print(t.name)
time.sleep(0.5)
if __name__ == '__main__':
t1 = threading.Thread(target=task,name='t1')
t2 = threading.Thread(target=task,name='t2')
t1.setDaemon(True)
t2.setDaemon(True)
t1.start()
t2.start()
t1.join()
t2.join()
print("main over")
6.线程间共享全局变量
import threading
import time
c_list = []
def add_data():
for i in range(5):
c_list.append(i)
print(c_list)
time.sleep(0.5)
def read_data():
print("read: ",c_list)
if __name__ == '__main__':
add_t = threading.Thread(target=add_data)
read_t = threading.Thread(target=read_data)
add_t.start()
read_t.start()
7.多线程中共享变量的资源竞争问题
import threading
import time
g_num = 0
def sum_num1():
for i in range(1000000000):
global g_num
g_num += 1
print("sum1: ",g_num)
if __name__ == '__main__':
f_t = threading.Thread(target=sum_num1)
f_t2 = threading.Thread(target=sum_num1)
f_t.start()
f_t2.start()
time.sleep(3)
print("main",g_num)
转存失败重新上传取消
时间片轮转的问题
8.使用线程同步解决
线程等待（阻塞）
import threading
import time
g_num = 0
def sum_num1():
for i in range(1000000000):
global g_num
g_num += 1
print("sum1: ",g_num)
if __name__ == '__main__':
f_t = threading.Thread(target=sum_num1)
f_t2 = threading.Thread(target=sum_num1)
f_t.start()
#阻塞
f_t.join()
f_t2.start()
f_t2.join()
time.sleep(3)
print("main",g_num)
转存失败重新上传取消
9.互斥锁
上锁
原子操作
解锁
import threading
import time
#创建一个实例锁
metax_lock = threading.Lock()
g_num = 0
def sum_num1():
t = threading.current_thread()
for i in range(1000000000):
metax_lock.acquire()
global g_num
g_num += 1
print(t.name,"=------=",g_num)
metax_lock.release()
print("sum1: ",g_num)
if __name__ == '__main__':
f_t = threading.Thread(target=sum_num1)
f_t2 = threading.Thread(target=sum_num1)
f_t.start()
f_t2.start()
time.sleep(3)
print("main",g_num)
注意不要变成同步锁，一般都是异步执行
10.死锁
这个函数就有个死锁
import multiprocessing
import threading
import time
c_list = [1,2,3,4325]
lock = threading.Lock()
def get_value(index):
#锁
lock.acquire()
t = threading.current_thread()
if index >= len(c_list):
print(f'{index} 下界太大，导致下标越界')
return
print(t.name,"取得第",index,'个值，值为',c_list[index])
lock.release()
if __name__ == '__main__':
for i in range(5):
t = threading.Thread(target=get_value,args=(i,))
t.start()
我们解决掉他
import multiprocessing
import threading
import time
c_list = [1,2,3,4325]
lock = threading.Lock()
def get_value(index):
#锁
lock.acquire()
t = threading.current_thread()
if index >= len(c_list):
print(f'{index} 下界太大，导致下标越界')
lock.release()
return
print(t.name,"取得第",index,'个值，值为',c_list[index])
lock.release()
if __name__ == '__main__':
for i in range(5):
t = threading.Thread(target=get_value,args=(i,))
t.start()但这里其实还有问题，我们后面讨论
11.死锁哲学家问题
import multiprocessing
import threading
import time
lock_a = threading.Lock()
lock_b = threading.Lock()
def PersonA():
for i in range(100):
lock_a.acquire()
print("A抢到第一个筷子，加一个锁")
lock_b.acquire()
print("A加第二个锁，强盗第二根筷子，吃一口饭")
lock_b.release()
print("A释放锁，放下第二根筷子")
lock_a.release()
print("A加第一个锁，抢到第一根筷子")
def PersonB():
for i in range(100):
lock_a.acquire()
print("B抢到第一个筷子，加一个锁")
lock_b.acquire()
print("B加第二个锁，强盗第二根筷子，吃一口饭")
lock_b.release()
print("B释放锁，放下第二根筷子")
lock_a.release()
print("B加第一个锁，抢到第一根筷子")
if __name__ == '__main__':
pa = threading.Thread(target=PersonA)
pb = threading.Thread(target=PersonB)
pa.start()
pb.start()
结语
python的部分快要结束了，后面要更新linux服务器和k8s的笔记，希望大家多多👍
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
