固定输入规模下，如何计算代码的Big O时间复杂度？

我正在练习为选定的股票代码（ticker symbol）实现蒙特卡洛模拟（Monte Carlo Simulation），相关Python代码如下：

from numpy.random import randint
from datetime import date
from datetime import timedelta
import pandas as pd
import yfinance as yf
from math import log

# ticker symbol
ticker_input = "AAPL"  # change

# start day + endday for Yahoo Finance API, 5 years of data
start_date = date.today()
end_date = start_date - timedelta(days=1826)

# retrieve data from Yahoo Finance
data = yf.download(ticker_input, end_date,start_date)
yf_data = data.reset_index()

# dataframe : define columns
df = pd.DataFrame(columns=['date', "ln_change", 'open_price', 'random_num'])

open_price = []
date_historical = []

for column in yf_data:
    open_price = yf_data["Open"].values
    date_historical = yf_data["Date"].values  

# list order: descending
open_price[:] = open_price[::-1]
date_historical[:] = date_historical[::-1]

# Populate data into dataframe
for i in range(0, len(open_price)-1):
    # date
    day = date_historical[i]
    
    # ln_change
    lnc = log(open_price[i]/open_price[i+1], 2)

    # random number
    rnd = randint(1, 1258)

    # op = (open_price[i]) open price
    df.loc[i] = [day, open_price[i], lnc, rnd]

我的输入规模固定为最多1259个浮点数实例，且不会发生变化。想请教：在此类有限输入场景下，即便代码存在嵌套循环或指数复杂度，该如何计算代码复杂度？

解答 #

代码复杂度分析的核心是描述算法随输入规模增长的性能变化趋势，但当输入规模固定为常数（比如这里的1259）时，传统的渐近复杂度（大O符号）会直接退化为O(1)——因为无论代码包含多少循环，执行的操作总次数都是固定值，不会随输入规模的增长而变化。

如果要精准衡量这段固定输入下的实际执行成本，可以从以下几个角度入手：

• 实际操作计数：统计代码中各步骤的执行次数，比如你的代码：
  • 遍历yf_data列的循环：执行次数等于股价DataFrame的列数（固定值，通常为6左右）
  • 填充DataFrame的循环：最多执行1258次（len(open_price)-1，即1259-1）
  • 把所有固定次数的操作加总，就是这段代码的实际执行步数
• 单步操作的常数开销：进一步细化的话，要考虑不同操作的实际成本，比如df.loc[i]的赋值开销远大于普通列表赋值，因为Pandas DataFrame是带索引的结构化数据，这部分的常数成本需要纳入考量
• 多算法对比场景：即便输入固定，也可以通过统计实际执行时间、内存占用，或者操作次数来对比不同实现的优劣——比如同样处理1259个数据，A算法执行10000次操作，B算法执行20000次，显然A的效率更高

需要注意的是，传统的时间复杂度（如O(n²)、O(2ⁿ)）是用于预测输入规模变化时的性能表现，当输入规模完全固定时，这些渐近符号的参考意义不大，重点应放在实际操作次数和单步操作的具体开销上。

内容的提问来源于stack exchange，提问作者Jovica