在前一天的Day 24 - Shiaoji.Login踩坑經驗及修正中，談到在執行login動作時，未考慮要等待contract fetch動作完成，導致所抓的資料內容不完整。這次的踩坑經驗，也讓我重新去思考Day 23 - 重覆呼叫shioaji.Shioaji()產生的記憶體問題中，是否也會因為相同的問題，影響測試的結果。
所以，我把當時測試的程式碼，改為以下方式：

import os, psutil, gc, time
import shioaji as sj
from dotenv import load_dotenv

load_dotenv('D:\\python\\shioaji\\.env') #讀取.env中的環境變數

process = psutil.Process(os.getpid())
print(os.getppid())
print(f'mem usage as start: {process.memory_info()[0]/float(2 ** 20)}MB')
for i in range(5):
    api = sj.Shioaji(simulation=True)
    print(f'({i})mem usage at api initial: {process.memory_info()[0]/float(2 ** 20)}MB')
    start_time = time.time()
    # api.login(
    #     person_id=os.getenv('YOUR_PERSON_ID'), 
    #     passwd=os.getenv('YOUR_PASSWORD'),
    #     contracts_timeout=10000
    # )
    api.login(
        person_id='PAPIUSER01',
        passwd='2222'
    )
    print(api.Contracts) #增加此行，等待所有的Contract資料fetch完成後，才繼續
    print(f'contract exe time:{time.time()-start_time}')
    print(f'({i})mem usage at api.login: {process.memory_info()[0]/float(2 ** 20)}MB')
    api.logout()
    del api

gc.collect()
print(f'mem usage after del api: {process.memory_info()[0]/float(2 ** 20)}MB')

這次的程式中，在login後增加一行print(api.Contracts)，確保所有的Contract資料都fetch完成後，才繼續後續的動作；另外在記憶體計算部份，因為換算時是除以2的20次方，所以單位是MB而不是KB。而這一次的測試，也一併測試Contract fetch所需要的時間，以便與優化後做比較。

修正後的測試結果

本次的測試，也依照上次的4個不同場景做測試，測試結果如下：

優化方式及差異

在上次那篇有談到，記憶體使用量優化的方式，這裡就說明程式碼調整內容，以及優化後的測試結果
優化的分別程式碼如下：

將sj.Shioaji()移至外層，不重覆執行

import os, psutil, time
import shioaji as sj
from dotenv import load_dotenv

load_dotenv('D:\\python\\shioaji\\.env')

process = psutil.Process(os.getpid())
print(os.getppid())
print(f'mem usage as start: {process.memory_info()[0]/float(2 ** 20)}MB')
process_start_time = time.time()
api = sj.Shioaji() #api宣告移至最外層，不重覆執行
for i in range(5):
    print(f'({i})mem usage at api initial: {process.memory_info()[0]/float(2 ** 20)}MB')
    start_time = time.time()
    api.login(
        person_id=os.getenv('YOUR_PERSON_ID'), 
        passwd=os.getenv('YOUR_PASSWORD')
    )
    print(api.Contracts)
    print(f'({i})contract fetch time:{time.time()-start_time}')
    print(f'({i})mem usage at api.login: {process.memory_info()[0]/float(2 ** 20)}MB')
    api.logout()

print(f'process total exe time:{time.time()-process_start_time}')

僅第一次執行時，執行contract fetch並將Contracts資料儲存

import os, psutil, time
import shioaji as sj
from dotenv import load_dotenv

load_dotenv('D:\\python\\shioaji\\.env')

process = psutil.Process(os.getpid())
print(os.getppid())
print(f'mem usage as start: {process.memory_info()[0]/float(2 ** 20)}MB')
process_start_time = time.time()
my_contract = None #宣告my_contract物件

for i in range(5):
    api = sj.Shioaji()
    print(f'({i})mem usage at api initial: {process.memory_info()[0]/float(2 ** 20)}MB')
    start_time = time.time()
    # 當my_contract為None時，執行contract fetch動作
    if my_contract is None:
        api.login(
            person_id=os.getenv('YOUR_PERSON_ID'), 
            passwd=os.getenv('YOUR_PASSWORD')
        )
        print(api.Contracts) #等待Contract fetch完成
        my_contract = api.Contracts #將my_contract指向api.Contracts
    else:
        print('fetch_contract=False...')
        api.login(
            person_id=os.getenv('YOUR_PERSON_ID'), 
            passwd=os.getenv('YOUR_PASSWORD'),
            fetch_contract=False #設為False，表示login後不執行contract fetch
        )
        print(my_contract)
    print(f'({i})contract fetch time:{time.time()-start_time}')
    print(f'({i})mem usage at api.login: {process.memory_info()[0]/float(2 ** 20)}MB')
    api.logout()

print(f'process total exe time:{time.time()-process_start_time}')

將sj.Shioaji()移至外層，不重覆執行，以及僅第一次執行fetch動作

import os, psutil, time
import shioaji as sj
from dotenv import load_dotenv

load_dotenv('D:\\python\\shioaji\\.env') #讀取.env中的環境變數

process = psutil.Process(os.getpid())
print(os.getppid())
print(f'mem usage as start: {process.memory_info()[0]/float(2 ** 20)}MB')
process_start_time = time.time()
api = sj.Shioaji() #api宣告移至最外層，不重覆執行

for i in range(5):
    print(f'({i})mem usage at api initial: {process.memory_info()[0]/float(2 ** 20)}MB')
    start_time = time.time()
    # 當api.Contracts為None時，執行contract fetch動作
    if api.Contracts is None:
        api.login(
            person_id=os.getenv('YOUR_PERSON_ID'), 
            passwd=os.getenv('YOUR_PASSWORD')
        )
    else:
        print('fetch_contract=False...')
        api.login(
            person_id=os.getenv('YOUR_PERSON_ID'), 
            passwd=os.getenv('YOUR_PASSWORD'),
            fetch_contract=False #設為False，表示login後不執行contract fetch
        )
    print(api.Contracts)
    print(f'({i})contract fetch time:{time.time()-start_time}')
    print(f'({i})mem usage at api.login: {process.memory_info()[0]/float(2 ** 20)}MB')
    api.logout()

print(f'process total exe time:{time.time()-process_start_time}')

測試結果

程式點 | sj.Shioaji()移至外層 | 僅第一次執行時，執行contract fetch並將Contracts資料儲存 | sj.Shioaji()移至外層+僅第一次fetch
------------- | ------------- | -------------
start | 34.0390625 | 33.9765625 | 33.9765625
0-initial | 37.97265625 | 37.84765625 | 38.01171875
0-login | 226.421875 | 226.765625 | 226.22265625
0-contract fetch time | 6.864650726318359 | 7.08452582359314 | 6.8395609855651855
1-initial | 226.4453125 | 226.91015625 | 226.16015625
1-login | 247.984375 | 227.140625 | 226.31640625
1-contract fetch time | 1.8755991458892822 | 1.5779919624328613 | 1.5284152030944824
2-initial | 249.35546875 | 227.18359375 | 226.265625
2-login | 250.640625 | 227.34765625 | 226.4375
2-contract fetch time | 2.2606329917907715 | 1.7178151607513428 | 1.3352644443511963
3-initial | 259.97265625 | 227.33203125 | 226.39453125
3-login | 273.60546875 | 227.5 | 226.5625
3-contract fetch time | 2.4294867515563965 | 1.4267780780792236 | 1.6401028633117676
4-initial | 274.13671875 | 227.48828125 | 226.5078125
4-login | 276.0234375 | 227.6484375 | 226.671875
4-contract fetch time | 2.1341898441314697 | 1.4912939071655273 | 1.2037618160247803
process total exe time | 16.376935720443726 | 13.961941003799438 | 12.832036018371582
可以看到，這三種優化方式，從第二次登入後的測試結果，記憶體使用量或是contract fetch time，都跟優化前的有很明顯示的改善。