Python [2.7]：ValueError：閉じたファイルに対する入出力操作

Question

私はここで同様の問題を検索していますが、私の問題に対する解決策は見つかりませんでした。 ランダムに生成されたパケットをスケジュールするネットワークシミュレーションをコーディングしています。私はグラフを作成するためにNetworkXを使用しています。シミュレーションは無作為にパケットを作成し、min cutアルゴリズムでパスを見つけ、キュー内のパケットをスケジューリングし、平均減速と平均遅延などの統計を計算します。 私はいくつかのシミュレーションを実行した後、実行中に異なるエラータイプで停止するため、この問題は私が書いたアルゴリズム機能にあると思います。一度そのValueError：閉じたファイルのI/O操作と私にKeyError：3またはKeyError：2を与えるもう一つの時間 どこに問題があるのか​​わかりません。

私のコードは本当に長いですが、私は解決策を見つけるより良い機会のためにそれを付けますGraphMinCut関数でいくつかの実行後にエラーが常に表示されることを念頭に置いてくださいうまくいけば、これらのエラーの理由を明らかにする。

# -*- coding: utf-8 -*- 

import networkx as nx 
import random 
import matplotlib.pyplot as plt 
from operator import itemgetter 
NewG=nx.Graph() #this is going to be a connected graph 
num_node=5 
num_edges=(num_node*(num_node-1))/2 
RTrange=10 #release time range 
FlowRange=3 

nodelist=[] 
for i in range(0,num_node): 
    nodelist.append(i) 

NewG.add_nodes_from(nodelist) 
for i in range(0,num_node): 
    for j in range(0,num_node): 
     if i<>j:    
      if not NewG.has_edge(i,j) and not NewG.has_edge(j,i): 
       NewG.add_edge(i,j,weight=1.0) 

print (" the new graph have %d number of nodes and %d edges" % 
         (NewG.number_of_nodes(),NewG.number_of_edges())) 

pos=nx.spring_layout(NewG) 
colors=range(num_edges) 
nx.draw(NewG,pos,node_color='#A0CBE2',edge_color='#A0BF11',width=4, 
            edge_cmap=plt.cm.Blues,with_labels=True) 
plt.savefig("edge_colormap.png") # save as png 
plt.show() # display 
runs=250 
num_pack=10 
# ------------begining of mincut function------- 
def GraphMincut(G,source,sink,mylist,queue,t,removeEdge): 
    pointer=queue.head 

    addEdge=[] 

    if removeEdge:  # any previous unavalable edges need to be 
         #linked back as long as it hasn't been added to mylist 
     for x in removeEdge: 
      a=x[0] 
      b=x[1] 
      if (a,b) not in mylist and (b,a) not in mylist: 
       if not G.has_edge(a,b): 
        e=(a,b) 
        addEdge.append(e) 

    while removeEdge: 
     removeEdge.pop() 

    while pointer.time<t and pointer.next<>None: 
     pointer=pointer.next 

    if pointer.time==t: 
     if pointer.data: 
      for x in pointer.data: 
       removeEdge.append(x) 

    if addEdge: 
     for x in addEdge: 
      if not G.has_edge(x[0],x[1]): 
       G.add_edge(x[0],x[1],weight=1.0) 

    if removeEdge: 
     G.remove_edges_from(removeEdge)   
    print "source and sink",source,sink 
    if nx.edge_connectivity(G,source,sink)==0: 
     return mylist 
    else: 
     MyEdgeList=[] 
     MyNodeList=[] 
     MyEdgeList=sorted(nx.minimum_edge_cut(G,source,sink)) 
     MyNodeList=nx.minimum_node_cut(G,source,sink) 
     print("edge list:",str(MyEdgeList)) 
     print("node list:",str(MyNodeList)) 
     temp=[]  
     for j in MyEdgeList: 
      print"j weight:",G[j[0]][j[1]]['weight'] 
      temp.append(G[j[0]][j[1]]['weight']) 
     v=min(temp)  
     print "v:",v 

     new_sink=None 
     new_source=None 
     for j in MyEdgeList: 
      print "J:",j 
      print"weight:",G[j[0]][j[1]]['weight'] 
      if v==G[j[0]][j[1]]['weight']: 
       if j[0] in MyNodeList or j[1] in MyNodeList or (source in (j[0],j[1]) and sink in (j[0],j[1])): 
        print"j in if 1",j 
        if (source in (j[0],j[1])) or (sink in (j[0],j[1])): 
         mylist.append((j[0],j[1])) 
         break 
        else: 
         print("j[1]newsourec",j[1]) 
         print("j[0]newsink",j[0]) 
         new_source=j[1] 
         new_sink=j[0] 
         mylist.append((j[0],j[1])) 
         G.remove_edges_from(MyEdgeList) 
         mylist=GraphMincut(G,new_source,sink,mylist,queue, 
                  t+1,removeEdge) 
         mylist=GraphMincut(G,source,new_sink,mylist,queue, 
                  t+1,removeEdge)    

     if source in (j[0],j[1]) and sink in (j[0],j[1]): 
      return mylist 

     for i in MyNodeList: 
      print"i ",i 
      print"j[0]j[1]",(j[0],j[1]) 
      if i in (j[0],j[1]): 
       if source in (j[0],j[1]): 
        new_source=i 
        new_sink=sink 
        break 
       else: 
        new_sink=i 
        new_source=source 
        break 

     G.remove_edges_from(MyEdgeList) 
     print"before call --new source and sink:",new_source,new_sink 
     mylist=GraphMincut(G,new_source,new_sink,mylist,queue,t+1,removeEdge) 

     return mylist 

# ------------------end mincut function------------------ 
#-------------------packet generator ------------------- 

def GeneratePacket(source): 
    Packet={}  
    Packet['source']=source 
    sink_choice=nodelist 
    sink_choice.remove(source) 
    Packet['sink']= random.choice(sink_choice) 
    nodelist.append(source) 
    nodelist.sort() 
    Packet['weight']=1.0   #random.randrange(2,10) 
    Packet['computation_time_MC']=0 #initialized Time To Serve variable  
    Packet['MC_path']=[] 
    Packet['release_time']=random.randrange(0,RTrange) 
    Packet['rescheduledTime']=0 # to count the number of times it was 
         #rescheduled due to unavailable edge at release time 
    Packet['flow']=random.randrange(1,FlowRange) 
    return Packet 

#-------------------End packet generator ----------------- 
def Rearrange_Path(path,s): 
    newpath=[] 
    length=path.__len__() 
    for i in range(0,length): 
     temp=s 

     for (a,b) in path: 
      if temp == a: 
       s=b 
       newpath.append((a,b)) 
       path.remove((a,b)) 
      else: 
       if temp==b: 
        s=a    
        newpath.append((b,a)) 
        path.remove((a,b)) 
    return newpath 
# ------------------ Print packet details ----------------- 

def ShowPacket(Packet,i): 
    print "Packet %d has :" %i 
    print "source :",Packet['source'], "destination :", Packet['sink'] 
    print "release time = :",Packet['release_time'] 
    print "number of flows =",Packet['flow'] 
    print "MC path :",Packet['MC_path'] 
    print "computation time is :",Packet['computation_time_MC'] 

    print "-"*20 

# ------------------ End procedure ---------------  

# ------------------list classes ----------- 
class Node(object): 

    def __init__(self, prev, next): 
     self.data = [] 
     self.prev = prev 
     self.next = next 
     self.time=0 
     self.packetID=[] 

class DoubleList(object): 

    head = None 
    tail = None 

    def __init__(self): 
     self.head=None 

    def size(self): 
     current = self.head 
     count = 0 
     while current != None: 
      count = count + 1 
      current = current.next 

     return count 

    def append_newNode(self, data,position): 
     new_node = Node(None, None) 
     if self.head is None: 
      self.head = self.tail = new_node 
      new_node.data.append(data) 
      new_node.time=position 
     else: 
      new_node.prev = self.tail 
      new_node.next = None 
      self.tail.next = new_node 
      self.tail = new_node 
      new_node.time=position 
      new_node.data.append(data) 

    def append_packet(self, pID,Rtime): 
     new_node = Node(None, None) 
     if self.head is None: 
      self.head = self.tail = new_node 
      new_node.packetID.append(pID) 
      new_node.time=Rtime 

     else: 
      new_node.prev = self.tail 
      new_node.next = None 
      self.tail.next = new_node 
      self.tail = new_node 
      new_node.packetID.append(pID) 
      new_node.time=Rtime 

    def append_MiddleNode(self,pID,edge,Rtime,top,bottom): 
     new_node = Node(None, None) 
     new_node.prev=top 
     new_node.next=bottom 
     top.next=new_node 
     bottom.prev=new_node 
     if edge: 
      new_node.data.append(edge) 
     new_node.time=Rtime 
     if pID: 
      new_node.packetID.append(pID) 

    def show_all(self): 
     current_node=self.head 
     print "Show all scheduled items in event queue :" 
     while current_node is not None: 
      print current_node.time , current_node.packetID, 
                str(current_node.data) 
      current_node = current_node.next 
     print "*"*50 

# ------------------begin simulation ------------- 
with open ("resultFile.csv","w") as RF: 
    RF.write(str(date)) 
    RF.write("\n ") 
    RF.write("run#,Mean WT MC,Mean WT SPF,Mean SlowD MC, Mean SlowD SPF, Mean THr MC,Mean THr SPF") 
    RF.write("\n")     


with open ("Result.csv","w") as DF: #contains detailed results 
    DF.write(str(date)) 
    DF.write("\n") 
    DF.write("run#,original RT, Rescheduled T, current RT, source, sink") 
    DF.write(",Computation T,#of flows, Start, Finish,Wait \n") 


for r in range(0,runs): #simulation run r times   
    with open ("resultFile.csv","a") as RF: 
     with open ("Result.csv","a") as DF: #contains detailed results 

      Packets=[] 
      for i in range(0,num_pack):#create random packets for the whole    
             # network 
       Packets.append({}) 
       packet_Source=random.randrange(0,num_node) 
       Packets[i]=GeneratePacket(packet_Source) 
       ShowPacket(Packets[i],i) 
      # sort packets minimum release time first 
      Packets.sort(key=itemgetter('release_time')) 

      print "Packets after sorting by earlist release time -----" 
      for i in range(0,num_pack): 
       ShowPacket(Packets[i],i) 
      # ----- create queue event for (MC)------- 
      EventQueue = DoubleList() 
      # initilize statistics parameters 
      Mean_wait_t_MC=0    
      Mean_slowdown_MC=0 
      Mean_Throughput_MC=0 
      MC_delay_rate=0 
      MCThroughput=0 
      MC_slowdown=0  

     #---inser packets in order in my eventQueue for MC ------------ 
      for i in range(0,num_pack): 
       R=int(Packets[i]['release_time']) 
       if EventQueue.size()==0: 
        EventQueue.append_packet(i,R) 
        EventQueue.show_all() 
       else: 
        current=EventQueue.head 
        appended= False 
        for n in range(0,EventQueue.size()): 
         if current.time==R: 
          current.packetID.append(i) 
          EventQueue.show_all() 
          appended= True 
          break 
         else: 
          current=current.next 
        if appended==False: 
         EventQueue.append_packet(i,R) 
         EventQueue.show_all() 

       # --------------------------------- 
      current_Packet=[] 
      Time_pointer=EventQueue.head 
      counter=num_pack 

      while (counter > 0): 
       if not current_Packet:  
        while not Time_pointer.packetID and Time_pointer.next<>None: 
         Time_pointer=Time_pointer.next 
        current_Packet=Time_pointer.packetID 

       while current_Packet: 
        myGraph=nx.Graph() 
        print"mygraph..initialized" 
        nx.draw(myGraph) 
        plt.show(myGraph) 
        myGraph=NewG.copy() 
        print"mygraph..after copy" 
        nx.draw(myGraph) 
        plt.show(myGraph) 
        packet_path=[]   
        x=int(Packets[current_Packet[0]]['source']) 
        y=int(Packets[current_Packet[0]]['sink']) 
        ReleaseT=int(Packets[current_Packet[0]]['release_time']) 
        removeEdge=[]   
        # here we get the path from Mincut function 
        GraphMincut(myGraph,x,y,packet_path,EventQueue,ReleaseT,removeEdge) 
        packet_path=Rearrange_Path(packet_path,x) 
        p=current_Packet[0] 
# incase the packet path was empty list due to unavailable edges at this time 
# reschedule the flow by delaying it one time unit 
        if not packet_path:   
         print "no available edges at this time release.. delay one time unit" 
         Packets[p]['release_time']+=1 
         print "p=",p 
         R=int(Packets[p]['release_time']) 
         Packets[p]['rescheduledTime']+=1 
         current=EventQueue.head 
         appended= False 
         for n in range(0,EventQueue.size()): 
          if current.time==R: 
           current.packetID.append(p) 
           current.packetID.sort()      
           current_Packet.remove(p) 
           EventQueue.show_all() 
           appended= True 
           break 
          else: 
           if current.time<R and current.next<> None: 
            current=current.next 
           if current.time>R: 
            EventQueue.append_MiddleNode(p,[],R,current.prev,current) 
            current_Packet.remove(p)       
            EventQueue.show_all() 
            appended= True 
            break 
         if appended==False: 
          EventQueue.append_packet(p,R) 
          EventQueue.show_all() 
          current_Packet.remove(p) 
         break 
        length= packet_path.__len__() 
        print"path:",packet_path 
        print"length: ",length 
        flow=int(Packets[p]['flow'])    
        Packets[p]['computation_time_MC']=length+flow-1 
        Packets[p]['MC_path']=packet_path 
        original_RT=ReleaseT-int(Packets[p]['rescheduledTime'])    
        DF.write(" %s," %str(r)) 
        DF.write(" %s," %str(original_RT)) 
        DF.write(" %s," %str(Packets[p]['rescheduledTime'])) 
        DF.write(" %s," %str(Packets[p]['release_time'])) 
        DF.write(" %s," %str(Packets[current_Packet[0]] ['source'])) 
        DF.write(" %s," %str(Packets[current_Packet[0]]['sink'])) 
        DF.write(" %s," %str(length)) 
        DF.write(" %s," %str(flow)) 
        #initilize time variables for MC 
        Finish_time=0 
        Start_time=ReleaseT #just to make sure it doesn't start  
             # b4 it is released 
        current=EventQueue.head 
        start= False 
        counter -=1 
        end=False 
        while current.time <Time_pointer.time: 
         current=current.next 
        #----begin scheduling events for MC path -------- 
        for i in range(0,flow): # loop to schedule every flow 
         position=ReleaseT +i 
         if current.time<>position: 
          current=EventQueue.head 
          while current.time <position and current.next<>None: 
           current=current.next 
         for j in packet_path: 
          for k in range(0,EventQueue.size()): 
           if position==current.time: 
            a=j[0] 
            b=j[1] 
            if (a,b) not in current.data and (b,a)not in current.data: 
             current.data.append(j) 
             EventQueue.show_all() 
             position+=1     
             if start==False: 
              start=True 
              Start_time=current.time 
              DF.write(" %s,",%str(Start_time)) 
             if current.next <> None:       
              current=current.next 
             else: 
              end=True 
             break 
            else: 
             if current.next==None: 
              position+=1 
              EventQueue.append_newNode(j,position) 
              current=current.next 
              end=True 
              break 
             current=current.next 
             position+=1   
           else: 
            if (position<current.time): 
             EventQueue.append_MiddleNode([],j,position,current.prev,current) 
             EventQueue.show_all() 
             position+=1     
             if start==False: 
              start=True 
              Start_time=current.time 
              DF.write(" %s,",%str(Start_time)) 
             break 
            if (position >current.time): 
             EventQueue.append_newNode(j,position) 
             EventQueue.show_all() 
             position+=1    
             if start==False: 
              start=True 
              Start_time=current.time 
              DF.write(" %s,"   %str(Start_time)) 
             current=current.next 
             end=True 
             break 
        if end==False: 
         current=current.prev 

        Calculate_TT= length + flow -1 # Calculate travel time 
           #is used to measure travel time between nodes 
        print "current time is=",current.time 
        Finish_time=current.time+1 
        MCThroughput =MCThroughput + (Finish_time - original_RT) 
        Wait= (Finish_time - original_RT - Calculate_TT) 
        MC_delay_rate= MC_delay_rate+ Wait    
        MC_slowdown= MC_slowdown + ((Finish_time - 
                original_RT)/Calculate_TT) 
        DF.write(" %s," %str(Finish_time)) 
        DF.write(" %s" %str(Wait)) 
        DF.write("\n ") 
        print " Start time is ", Start_time    
        print "Finish time is", Finish_time 
        print "Computation time is ", Calculate_TT 
        print " wait time is ",Wait 
     # now we need to put back the time of release and reschedule to their 
     #original state to be used again by SPF scheduling (later step) 
        Packets[p]['rescheduledTime']=0 
        Packets[p]['release_time']=original_RT 
        current_Packet.remove(current_Packet[0]) 
        if not Time_pointer.packetID: 
         for g in range(0,EventQueue.size()): 
          if not Time_pointer.packetID and 
                Time_pointer.next<>None: 
           Time_pointer=Time_pointer.next 
          else: 
           break 

      #------------end scheduling events for MC path 

      Mean_wait_t_MC= float(MC_delay_rate)/ num_pack 
      Mean_slowdown_MC= float(MC_slowdown)/num_pack 
      Mean_Throughput_MC= float(MCThroughput)/num_pack 
      RF.write(" %s," %str(r)) 
      RF.write(" %s," %str(Mean_wait_t_MC)) 
      RF.write(" %s," %str(Mean_slowdown_MC)) 
      RF.write(" %s," %str(Mean_Throughput_MC)) 
      RF.write("\n")     
      del EventQueue 

Answer 1

私はちょうど私が私がPyChromeでそれを実行し、それは私がStackOverflowのへようこそ