当前位置：首页 > news >正文

函数参数及数据结构说明

news 2025/6/30 9:39:02

所有参数的输入及输出示例，数据结构构成，部分重复内容数据类型可以网页全局搜索查看有问题交流

def GetOriginData(fileAddr)

fileAddr = " .xlsx"

Flight columns = ["flightId", "date", "isDomestic", "flightNo", "startAirport", "endAirport", "startDateTime", "endDateTime", "airplaneId", "airplaneType", "importRatio"]

AirplaneLimitation columns = ["startAirport", "endAirport", "airplaneId"]

AirportClose columns = ["airport", "beginCloseTime", "endCloseTime", "beginDate", "endDate"]

Scene columns = ["startDateTime", "endDateTime", "type", "airport"]

TravelTime columns = ["airplaneType", "startAirport", "endAirport", "travelTime"]

return Flight, AirplaneLimitation, AirportClose, Scene, TravelTime

def IsAirportClose(AirportCloseD, airport, DateTime)

AirportCloseD AirportCloseD = {} # 构建一个字典（AirportCloseD），用于存储机场关闭时间段信息。键为机场名称，值为一个列表，包含该机场的所有关闭时间段。

airport airport = AirportClose.loc[i, 'airport']

DateTime 时间参数类似这种 datetime.timedelta(hours = 1)

return False/True

def GetInitialSolution(Flight, Scene, AirportCloseD, hour)

Flight Flight = pd.DataFrame(excel_data['航班'][1:] 见航班调度优化 -CSDN博客

航班ID (flightId) 日期 (date) 国际/国内 (isDomestic) 航班号 (flightNo) 起飞机场 (startAirport) 降落机场 (endAirport) 起飞时间 (startDateTime) 降落时间 (endDateTime) 飞机ID (airplaneId) 机型 (airplaneType) 重要系数 (importRatio)

Scene columns = ["startDateTime", "endDateTime", "type", "airport"]

hour 初始延时时间参数

FlightD[flightId] = [
# 索引内容类型说明
0, # needArriveTime datetime 需要到达的时间
1, # isJoint int 是否为联程航班(0/1)
2, # starttime datetime 航班起飞时间
3, # endtime datetime 航班到达时间
4, # startAirport int 起始机场代码
5, # endAirport int 目的机场代码
6, # importRatio float 航班重要性系数
7, # airplaneType int 飞机型号
8, # isCancel int 是否取消(0/1)
9, # jointFlight int 联程航班ID(如果有)
10, # status int 航班状态(0:正常)
]

# FlightExecuteList = [
# [
# [ 0 airplaneId, 1 airplaneType, 2 startAirport, 3 0是否为尾班航班标志], # 航班基本信息
# [flight1, flight2, ...] # 该飞机执行的航班序列 id
# ],
# # 更多飞机的航班序列...
# ]

FlightDismissList = [
# 第一组取消航班
[
[1, "B737", 1, "PEK"], # 使用1号B737飞机,1是尾班,在北京结束
[101, 102, 103] # 取消的航班ID是101,102,103
],

# 第二组取消航班
[
[2, "A320", 0, "CAN"], # 使用2号A320飞机,不是尾班,在广州结束
[201, 202] # 取消的航班ID是201,202
]
]

initialCost 损失

delayD = {
101: datetime.timedelta(hours=2, minutes=30), # Flight 101 delayed by 2 hours and 30 minutes
102: datetime.timedelta(minutes=45), # Flight 102 delayed by 45 minutes
103: datetime.timedelta(hours=1), # Flight 103 delayed by 1 hour
}

Flight Flight = pd.DataFrame(excel_data['航班'][1:] 见航班调度优化 -CSDN博客

DomesticJoint[Flight['flightId'][i]] = Flight['flightId'][i + 1] # 记录联程航班对：当前航班ID → 下一航班ID

delayDcompare = {0: 0}

delayDcompare[Flight['flightId'][j]] = Scene.iloc[0][1] - Flight['endDateTime'][j] # 计算与台风场景开始时间的延迟差值

return FlightD, FlightExecuteList, FlightDismissList, initialCost, delayD, Flight, DomesticJoint, delayDcompare

def GetSets(Flight, TravelTime, AirplaneLimitation, AirportClose)

Flight 如上

TravelTime = pd.DataFrame(excel_data['飞行时间'][1:], 飞行时间数据

AirplaneLimitation = pd.DataFrame(excel_data['航线-飞机限制'][1:],

AirportClose = pd.DataFrame(excel_data['机场关闭限制'][1:],

DomesticSet = set() #构建一个包含所有国内航班起降机场的集合（DomesticSet）

DomesticSet.add(Flight['startAirport'][i])
DomesticSet.add(Flight['endAirport'][i])

FlytimeD 飞行时间字典 FlytimeD[(row["airplaneType"], row["startAirport"], row["endAirport"])] = row["travelTime"]

AirplaneLimit = set() AirplaneLimit.add(tuple(AirplaneLimitation.loc[i])) # 将每行数据转为元组并加入集合

AirportCloseD = {} # 构建一个字典（AirportCloseD）用于存储机场关闭时间段信息。键为机场名称，值为一个列表，包含该机场的所有关闭时间段。

if airport in AirportCloseD:
AirportCloseD[airport].append(data) # 追加新的关闭时间段
else:
AirportCloseD[airport] = [data] # 追加新的关闭时间段

return DomesticSet, FlytimeD, AirplaneLimit, AirportCloseD

#转换时间格式，用于生成最终结果用

def transTime(time)

str(time.year): 获取 time 对象的年份，并将其转换为字符串。
str(time.month): 获取 time 对象的月份，并将其转换为字符串。
str(time.day): 获取 time 对象的日期，并将其转换为字符串。
str(time.hour): 获取 time 对象的小时，并将其转换为字符串。
str_minute[-2:]:
str_minute 是通过 str(time.minute) 转换的分钟字符串，并在前面补充了一个 0（例如，"05"）。
[-2:] 表示取字符串的最后两位，确保分钟始终是两位数（例如，"05" 或 "30"）

return str(time.year) + "/" + str(time.month) + "/" + str(time.day) + " " + str(time.hour) + ":" + str_minute[-2:]

def generateResult(Flight)

Flight 如上

ResultFlight['startDateTime'] = startDateTime
ResultFlight['endDateTime'] = endDateTime
ResultFlight['isCancel'] = isCancel
ResultFlight['isFerry'] = isFerry

return ResultFlight

def findFlightCycle(FlightD, FlightList):

#FlightList = ef[1] ef = FlightExecuteList[i]

FlightCycle.append(FlightList[temp[i]: temp[j]]) # 将找到的航班环（可以联程的数据）添加到 FlightCycle 列表中有一个例子在CSDN笔记中可以研究了解

return FlightCycle

#获得两个航班列表中，具有相同起始机场与结束机场的航班串
def findSameStartEnd(FlightD, FlightList1, FlightList2):

samestring = findSameStartEnd(FlightD, ef[1], ef2[1])

res = []
for key in d1:
        if key in d2:
                for list1 in d1[key]:
                        for list2 in d2[key]:
                                res.append([list1, list2])

return res

#寻找两个航班列表中，具有相同起始机场的航班尾串
def findSameStartport(FlightD, FlightList1, FlightList2):

return res

#当航班列表中有不满足飞机-航线限制时，返回True
def IsAirLimit(airplaneId, FlightList, FlightD, AirplaneLimit):
        for flight in FlightList:
                if (FlightD[flight][4], FlightD[flight][5], airplaneId) in AirplaneLimit:
                        return True
        return False

#0代表起飞，1代表降落 可以起飞且降落
def IsTimeSameRange(time1, time2, mode, Scene):

return False #如果两个时间不满足上述条件，则返回 False。

#判断一个航班串延迟一段时间是否可以运行
def GetNewDelayD(delaytime, FlightList1, delayD, FlightD, AirportCloseD, Scene):

delaytime = FlightD[ef[1][efstartindex - 1]][3] + delayD.get(ef[1][efstartindex - 1], datetime.timedelta(minutes = 0)) - (FlightD[df[1][dfstartindex]][2] + delayD.get(df[1][dfstartindex], datetime.timedelta(minutes = 0)) - datetime.timedelta(minutes = 50))

FlightList1 如上

AirportCloseD = {} # 构建一个字典（AirportCloseD）用于存储机场关闭时间段信息。键为机场名称，值为一个列表，包含该机场的所有关闭时间段。

if airport in AirportCloseD:
AirportCloseD[airport].append(data) # 追加新的关闭时间段
else:
AirportCloseD[airport] = [data] # 追加新的关闭时间段

Scene 如上

delayDcopy = delayD.copy() #复制原始延迟时间字典 delayD，用于存储更新后的延迟时间。

return delayDcopy

#GRASP算法的一次操作，算法的最核心部分
def GRASPOnce(FlightExecuteList, FlightDismissList, initialCost, delayD, FlightD, AirplaneLimit, Scene, num, FlyD, FlyDEnable, DownEnable, delayMaxhour, delayDcompare, AirportCloseD, Israndom):

# FlyDEnable: 控制是否需要重新生成航班连接字典的标志
# 0: 需要重新生成航班连接字典
# 1: 可以使用现有的航班连接字典

# DownEnable: 控制是否继续在当前搜索方向上寻找更优解的标志
# 1: 继续在当前方向搜索更优解
# 0: 需要改变搜索方向或策略

其他如上

#DownRCL：存储导致总成本下降的解精英种群的概念 DownRCL = [[initialCost, FlightExecuteList, FlightDismissList, delayD]]

UpRCL = [] #这段代码设置了两个日期时间变量，用作时间范围的边界值：

return DownRCL, UpRCL

#生成csv文件
def GetResult(Flight, minSolution, FlightD, delayD, DomesticJoint):

Flight, minSolution, FlightD, delayD, DomesticJoint 如上

res = generateResult(Flight)
res = res.sort_values('flightId')
print("航班拉直数量：", l)
print("最终取消航班数量为：", Flight[Flight['isCancel'] != 0].shape[0])
res.to_csv('res.csv', index = False, header = False)

return res

#求时间交集
def TimeInter(time1, time2):

for time1 in time1list:

tmp = TimeInter(time1, time2)

return [minTime, maxTime]

#求时间差集
def TimeSub(time1list, time2):

ferryMinstarttime = starttime + datetime.timedelta(minutes = 50)
ferryMaxstarttime = endtime - flytime - datetime.timedelta(minutes = 50)

InitialTime = [[ferryMinstarttime, ferryMaxstarttime]]

SubTimeSet.append([beginCloseTime - flytime, endCloseTime - flytime])

InitialTime = TimeSub(InitialTime, subtime)

return res

#获得调机开始与结束时间，starttime为前一航班落地时间，endtime为后一航班开始时间
def GetFerryTime(starttime, endtime, airtype, startport, endport, AirportCloseD, FlytimeD, Scene):

Ferrystarttime, Ferryendtime = GetFerryTime(FlightD[ef[1][j]][3] + delayD.get(ef[1][j], datetime.timedelta(minutes = 0)), maxTime, ef[0][1], FlightD[ef[1][j]][5], endport, AirportCloseD, FlytimeD, Scene)

if InitialTime:
if InitialTime[-1][0].year != 2017:
return InitialTime[-1][1], InitialTime[-1][1] + flytime
else:
return InitialTime[-1][0], InitialTime[-1][0] + flytime
return None, None

#寻找调机方案（快速）
def findferryplan(nums):

ferrysolution = findferryplan(FerryMat)

#构造调机可行矩阵
FerryMat = [[0 for i in range(l)] for j in range(l)]

minloc = [0, 0]

res.append(minloc)

return res[:-1]

#寻找调机方案（DFS，成本最少）
def findferryplan2(nums, pairnum, tmp, res, cost, costs):

findferryplan2(nums_copy, pairnum + 1, tmp + [[i, j]], res, cost_new, costs)
return res[1]

#得到调机方案（成本较高，但有解可能性较高）
def GetFerryPlan(Flight, FlightExecuteList, FlightDismissList, delayD, DomesticSet, FlightD, AirportCloseD, FlytimeD, Scene, AirplaneLimit):

直接修改数组内容？

return True ？？？？

#根据FlyD得到调机方案（成本最低，但可能无解）
def GetFerryPlan2(Flight, FlightExecuteList, FlightDismissList, delayD, DomesticSet, FlightD, AirportCloseD, FlytimeD, Scene, AirplaneLimit)

if not endports:
return FlightExecuteListcopy, FlightDismissListcopy, Flightcopy

#检查方案是否全局基地平衡，测试用
def check(oldFlight, FlightExecuteList, FlightDismissList):

#整理FlightDismissList，把零散的变为长串这段代码的核心是通过合并航班串，减少零散的航班调度问题。它会检查每个航班串的结束时间和结束机场，
# 寻找可以连接的取消航班串，并将其合并，最终形成更长的航班串以优化调度。这里也可以是正常航班
def sortSolution(FlightD, FlightDismissList, delayD, Scene):

return FlightDismissList

#将Solution分割为单个航班或者联程航班为单位
def splitSolution(FlightD, FlightDismissList):

return NewFlightDismissList

#创建航班起始终止机场航班字典
def CreateflyD(FlightD, Scene, FlightDismissList, delayD):

d = {}

return d

#创建航班起始终止机场航班字典（允许机型互换）
def CreateflyD2(FlightD, Scene, FlightDismissList, delayD):

d = {}

return d

#得到可以通过推迟10小时内运行的航班，返回一个新的DF表与一个延迟时间字典
def GetExtraFlight(delayDinput, FlightD, FlightDismissList, AirportCloseD, Scene):

DF = copy.deepcopy(FlightDismissList)

return DF, delayD

#将联程航班拉直
def Straightflight(DomesticJoint, FlytimeD, FlightD, FlightExecuteList, FlightDismissList, delayD):

DF = copy.deepcopy(FlightDismissList)

return FlightExecuteList, FlightDismissList, delayD, FlightD

#GRASP算法，下降方向采取最大下降方向
def GRASP(FlightExecuteList, FlightDismissList, delayD, initialCost, FlightD, AirplaneLimit, Scene, mode, delayMaxhour, KTimes, period, delayDcompare, AirportCloseD, Israndom):

return mincost, minSolution

查看全文

http://www.lqws.cn/news/568855.html