有关python的代码执行顺序以及多线程

函数的执行过程

从上往下执行，参考先执行函数名，不执行函数内部，只有函数被调用时才执行。

def f1():
    print("f1")
print("main函数")
def f2():
    print('f2')
f2()
print("main函数2")
f1()             
1
2
3
4
5
6
7
8

上面这段话会依次输出：
main函数
f2
main函数2
f1

类的执行是从上往下，先只执行函数名(其他部分顺序执行)
当实例化类对象时，会执行_init_，所以类的执行顺序是先执行__new__，再执行__init__，再执行普通方法，最后执行__del__

class People:
    print('出生')
    def run(self):
        print('跑')
    def __init__(self):
        print('1')
    def eat(self):
        print('eat')
print('生孩子')
baby=People()
baby.run()   
1
2
3
4
5
6
7
8
9
10
11

上面这段话会依次输出：
出生（注意，会先输出出生！！！）
生孩子
1
跑

有关多线程

主要是学习了threading.Thread()的使用方法

#创建Thread类的实例对象
thread=Thread(target=threadFun,args=(‘参数1’,‘参数2’))

#执行start方法就会创建新线程
thread.start()

#在主线程中执行join（），会等待thread对应的线程结束之后再执行后面的代码
thread.join()

#主线程只是一个比喻，执行.py文件，python编辑器就会创建一个线程
print('主线程执行代码')

from threading import Thread
from time import sleep

#定义一个函数，作为新线程执行的入口函数
def threadFun(arg1,arg2):
    print('子线程 开始')
    print(f'线程函数参数是{arg1},{arg2}')
    sleep(5)
    print('子线程 结束')

#创建Thread类的实例对象
thread=Thread(target=threadFun,args=('参数1','参数2'))

#执行start方法就会创建新线程
thread.start()

#在主线程中执行join（），会等待thread对应的线程结束之后再执行后面的代码
thread.join()

print('主线程结束')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

还有Lock函数会给数据加锁，让多线程先后访问数据
#操作共享数据前，申请获取锁
bankLock.acquire()
#操作完共享数据后，申请释放锁
bankLock.release()

from threading import Thread,Lock
from time import sleep

bank={
    'TeacherBu':0
}
bankLock=Lock()
def depoist(theadidx,amount):
    #操作共享数据前，申请获取锁
    bankLock.acquire()
    balance=bank['TeacherBu']
    sleep(0.1)#模拟操作所消耗的时间
    bank['TeacherBu']=balance+amount
    print(f'子线程{theadidx}存钱结束！')
    #操作完共享数据后，申请释放锁
    bankLock.release()
threadList=[]
for index in range(10):
    #实例化一个线程对象 index
    thread=Thread(target=depoist,args=(index,10))
    thread.start()
    threadList.append(thread)

for thread in threadList:
    thread.join()

print(f'主线程结束，最后账户余额为{bank["TeacherBu"]}')    

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