Python Threading für Aufzug Simulation

Question

Ich versuche, eine Aufzugssimulation wegen eines interessanten Problems zu machen, das ich auf CareerCup sah. Mein Problem ist, dass ich möchte, dass der Fahrstuhl "Zeit braucht", um von einem Stockwerk zum nächsten zu gelangen. Im Moment wird es sofort in die nächste Etage in seiner Liste "zu Besuch" verschoben. Ich bin mir nicht sicher, wie ich es programmieren soll, damit "Abholungsanfragen" kommen können, während sich der Aufzug bewegt. Ich denke, das erfordert Threading und die Funktion time.sleep(). Wie mache ich einen Thread, der zufällige Anfragen an den Aufzug stellt, und einen anderen Thread, bei dem der Aufzug versucht, alle Anfragen zu erfüllen? Dies ist, was ich bisher habe:

import time 
from random import * 
import math 

class Elevator: 
    def __init__(self, num_floors): 
     self.going_up = False 
     self.going_down = False 
     self.docked = True 
     self.curr_floor = 0 
     self.num_floors = num_floors 
     self.floors_to_visit = [] 
     self.people_waiting = [] 

    def print_curr_status(self): 
     for i in range(self.num_floors): 
      if i == self.curr_floor: 
       print('. []') 
      else: 
       print('.') 
     print ("to_visit: ", self.floors_to_visit) 

    def handle_call_request(self, person): 
     if not self.going_up and not self.going_down: 
      self.floors_to_visit = [person.curr_floor] + self.floors_to_visit 
      self.going_up = True 
      self.docked = False 
      self.people_waiting.append(person) 
     else: 
      self.floors_to_visit.append(person.curr_floor) 
      self.people_waiting.append(person) 

    def handle_input_request(self, floor_num): 
     self.floors_to_visit.append(floor_num) 

    def go_to_next(self): 
     if not self.floors_to_visit: 
      self.print_curr_status() 
      return 
     self.curr_floor = self.floors_to_visit.pop(0) 
     for i,person in enumerate(self.people_waiting): 
      if person.curr_floor == self.curr_floor: 
       person.riding = True 
       person.press_floor_num() 
       self.people_waiting.pop(i) 
     return 


class Person: 
    def __init__(self, assigned_elevator, curr_floor): 
     self.curr_floor = curr_floor 
     self.desired_floor = math.floor(random() * 10) 
     self.assigned_elevator = assigned_elevator 
     self.riding = False 

    def print_floor(self): 
     print(self.desired_floor) 

    def call_elevator(self): 
     self.assigned_elevator.handle_call_request(self) 

    def press_floor_num(self): 
     self.assigned_elevator.handle_input_request(self.desired_floor) 


my_elevator = Elevator(20) 

while True: 
    for i in range(3): 
     some_person = Person(my_elevator, math.floor(random() * 10)) 
     some_person.call_elevator() 
    my_elevator.go_to_next() 
    my_elevator.print_curr_status() 
    time.sleep(1) 

Answer 1

Sie müssen zwei Threads auf einmal gehen müssen. Eine für die zufälligen Anfragen und eine für die Erfüllung dieser Anfragen. Dies ist in Python schwierig, da es sich um ein Single-Thread-Programm handelt. Sie können jedoch eine definierte Funktion haben, die auf die Anforderungen wartet und die Anforderungen dann in einer Datei speichert. Es führt dann eine andere definierte Aufgabe aus, die auf diese Anfragen antwortet. Wenn dann die Anforderungen behandelt werden, führt sie die andere definierte Funktion aus und wartet auf eine andere Anforderung.

Answer 2

Kein Threeding ist notwendig. Sie können 2 neue Variablen eingeben: eine, die die Zeit verfolgt, in der der Aufzug gestartet wurde, und eine für die Zeit, die eine Fahrt mit dem Aufzug dauern sollte. Dann überprüfe einfach, wann der Aufzug lange genug gelaufen ist. Sie können dies tun, indem Sie die Funktion time.time() aufrufen; es gibt die Zeit in Sekunden seit dem 1. Januar 1970 zurück (da Sie nur an dem Unterschied interessiert sind, spielt es keine Rolle; Sie brauchen nur eine Funktion, die in der Zeit erhöht wird). Obwohl diese Funktion oft keine genauere Zeitspanne als 1 Sekunde geben kann. Wenn Sie glauben, dass es auf Ihrem Computer ungenau ist, können Sie datetime verwenden.

class Elevator: 
    def __init__(self, num_floors): 
     self.start_time = 0 
     self.ride_duration = 1 
     ... 

    def call_elevator(self): 
     self.start_time = time.time() 
     self.assigned_elevator.handle_call_request(self) 

    def go_to_next(self): 
     if time.time() - self.start_time < self.ride_duration: 
      return # Do nothing. 
     else: 
      ... 

Sie werden wahrscheinlich den Code Refactoring müssen an Ihre Bedürfnisse anpassen und eine gewisse Logik auf hinzufügen, was zu tun ist, wenn der Aufzug in Betrieb ist, usw.