Cách tạo dữ liệu mô phỏng trong python

Động não một thuật toán mô phỏng

Trước khi bạn viết ra một dòng mã, điều quan trọng trước tiên là bạn phải hình dung quy trình của bạn sẽ chạy như thế nào trong cuộc sống thực. Điều này nhằm đảm bảo rằng, khi bạn chuyển nó vào máy, quy trình sẽ phản ánh chính xác những gì khách hàng sẽ thực sự trải nghiệm. Đây là cách bạn có thể nghĩ về các bước mà một người xem phim có thể thực hiện để viết ra thuật toán của bạn

1. Đến rạp, xếp hàng chờ mua vé
2. Mua vé từ phòng vé
3. Xếp hàng chờ kiểm tra vé
4. Nhận vé kiểm tra bởi một usher
5. Chọn có xếp hàng vào gian hàng nhượng quyền hay không
   • Nếu họ xếp hàng, thì họ mua thức ăn
   • Nếu họ không xếp hàng, thì họ bỏ qua bước cuối cùng
6. Đi tìm chỗ ngồi của họ

Đây là bước lặp lại từng bước dành cho khán giả mua vé tại phòng vé của nhà hát. Bạn đã có thể thấy phần nào của quy trình này có thể được kiểm soát. Bạn có thể ảnh hưởng đến thời gian chờ đợi của khách hàng bằng cách có nhiều nhân viên thu ngân hơn tại phòng vé

Cũng có những phần của quy trình không thể kiểm soát được, chẳng hạn như bước đầu tiên. Bạn không thể kiểm soát số lượng khách hàng sẽ đến hoặc họ sẽ đến nhanh như thế nào. Bạn có thể đoán, nhưng bạn không thể chỉ chọn một con số, vì đó sẽ phản ánh thực tế kém. Đối với tham số này, điều tốt nhất bạn có thể làm là sử dụng dữ liệu có sẵn để xác định thời gian đến phù hợp

Ghi chú. Sử dụng dữ liệu lịch sử đảm bảo rằng giải pháp bạn tìm thấy sẽ phản ánh chính xác những gì bạn có thể thấy trong cuộc sống thực

Với những điều này trong tâm trí, đã đến lúc xây dựng mô phỏng của bạn

Thiết lập môi trường

Trước khi bắt đầu xây dựng mô phỏng của mình, bạn cần đảm bảo rằng môi trường phát triển của mình được định cấu hình đúng cách. Điều đầu tiên bạn muốn làm là nhập các gói cần thiết. Bạn có thể làm điều này bằng cách khai báo các câu lệnh

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

________số 8

Đây là những thư viện chính mà bạn sẽ sử dụng để xây dựng kịch bản cho người quản lý rạp hát. Hãy nhớ rằng, mục tiêu là tìm số lượng nhân viên tối ưu để thời gian chờ đợi trung bình dưới 10 phút. Để làm điều này, bạn sẽ cần thu thập khoảng thời gian cần thiết để mỗi khán giả đến chỗ ngồi của họ. Bước tiếp theo là khai báo một danh sách để giữ những thời điểm này

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Danh sách này sẽ chứa tổng thời gian mà mỗi khán giả dành để di chuyển trong rạp chiếu phim, từ khi đến cho đến khi ngồi vào chỗ của họ. Bạn khai báo danh sách này ở đầu tệp để bạn có thể sử dụng nó bên trong bất kỳ chức năng nào bạn xác định sau này

Tạo môi trường. Định nghĩa lớp

Phần đầu tiên của mô phỏng mà bạn muốn xây dựng là bản thiết kế cho hệ thống. Đây sẽ là môi trường tổng thể bên trong nơi mọi thứ diễn ra và con người hoặc đồ vật di chuyển từ nơi này sang nơi khác. Hãy nhớ rằng, một môi trường có thể là một trong nhiều hệ thống khác nhau, chẳng hạn như ngân hàng, tiệm rửa xe hoặc trạm kiểm soát an ninh. Trong trường hợp này, môi trường là một rạp chiếu phim, vì vậy đó sẽ là tên lớp học của bạn

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Bây giờ là lúc để suy nghĩ về các bộ phận của rạp chiếu phim. Tất nhiên, có chính rạp hát, đó là cái mà bạn gọi là môi trường của mình. Sau đó, bạn sẽ khai báo rõ ràng rạp hát là một

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import simpy
import random
import statistics

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Được rồi, còn gì khác có thể có trong một nhà hát? . Khi một khán giả đến xem phim, họ sẽ phải xếp hàng tại phòng vé, nơi một nhân viên thu ngân sẽ chờ sẵn để giúp họ. Bây giờ bạn đã khám phá ra hai điều về môi trường sân khấu

1. Có thu ngân
2. Khán giả xem phim có thể mua vé từ họ

Nhân viên thu ngân là một nguồn tài nguyên mà rạp chiếu cung cấp cho khách hàng của mình và họ giúp khán giả xem phim trong quá trình mua vé. Ngay bây giờ, bạn không biết có bao nhiêu nhân viên thu ngân có sẵn trong nhà hát mô phỏng. Trên thực tế, đó chính là vấn đề mà bạn đang cố gắng giải quyết. Thời gian chờ đợi thay đổi như thế nào, tùy thuộc vào số lượng nhân viên thu ngân làm việc trong một đêm nhất định?

Bạn có thể tiếp tục và gọi biến chưa biết này là

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Tại đây, bạn thêm tham số mới

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Ghi chú. Trong

import simpy
import random
import statistics

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Còn một bước nữa mà bạn cần thực hiện. Một nhân viên thu ngân sẽ không mua vé cho chính họ, phải không? . Một lần nữa, bạn biết rằng quá trình mua vé này sẽ mất một khoảng thời gian nhất định. Nhưng chỉ cần bao nhiêu thời gian?

Giả sử bạn đã yêu cầu người quản lý cung cấp dữ liệu lịch sử về rạp hát, chẳng hạn như đánh giá hiệu suất của nhân viên hoặc biên lai mua vé. Dựa trên dữ liệu này, bạn đã biết được rằng trung bình mất từ ​​1 đến 2 phút để xuất vé tại phòng vé. Làm cách nào để bạn khiến

import simpy
import random
import statistics

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

import simpy
import random
import statistics

Thời gian này có thể là một phút, hai phút hoặc ba phút. Bạn muốn mỗi người xem phim dành một khoảng thời gian khác nhau tại quầy thu ngân. Để làm điều này, bạn sử dụng

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Hãy gói nó trong một hàm gọn gàng và thêm nó vào định nghĩa lớp

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Người bắt đầu sự kiện trong

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Ghi chú. Bạn sẽ thấy khán giả thực sự mua vé như thế nào trong phần tiếp theo

Đó là nó. Bạn đã chọn một tài nguyên có giới hạn thời gian, xác định quy trình liên quan của nó và hệ thống hóa điều này trong định nghĩa lớp của bạn. Đối với hướng dẫn này, có thêm hai tài nguyên bạn sẽ cần khai báo

1. Nhân viên kiểm tra vé
2. Máy chủ để bán thực phẩm

Sau khi kiểm tra dữ liệu mà người quản lý gửi đến, bạn xác định rằng các máy chủ mất khoảng từ 1 đến 5 phút để hoàn thành một đơn đặt hàng. Ngoài ra, người mở cửa rất nhanh trong việc kiểm tra vé, với tốc độ trung bình là 3 giây

Bạn sẽ cần thêm các tài nguyên này vào lớp của mình và xác định các hàm tương ứng

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

mô phỏng. pyHiện/Ẩn

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Xem kỹ các tài nguyên và chức năng mới. Lưu ý cách chúng tuân theo cùng một định dạng như được mô tả ở trên.

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Thời gian trễ của

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import simpy
import random
import statistics

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Di chuyển qua môi trường. Định nghĩa hàm

Được rồi, bạn đã thiết lập môi trường bằng cách định nghĩa một lớp. Bạn có tài nguyên và quy trình. Bây giờ bạn cần một

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Có ba đối số được truyền cho hàm này

1. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   22.

   import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39 sẽ được kiểm soát bởi môi trường, vì vậy bạn sẽ chuyển điều này làm đối số đầu tiên

2. import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39. Biến này theo dõi từng người khi họ di chuyển qua hệ thống

3. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   63. Tham số này cung cấp cho bạn quyền truy cập vào các quy trình bạn đã xác định trong định nghĩa lớp tổng thể

Bạn cũng khai báo một biến

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

import simpy
import random
import statistics

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Bạn sẽ muốn mỗi quy trình từ

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Xử lý trong

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Thu ngân là một tài nguyên được chia sẻ, có nghĩa là nhiều khán giả sẽ sử dụng cùng một thu ngân. Tuy nhiên, nhân viên thu ngân chỉ có thể giúp một người xem phim tại một thời điểm, vì vậy bạn sẽ cần đưa một số hành vi chờ đợi vào mã của mình. Đây là cách nó hoạt động

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Đây là cách mã này hoạt động

1. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   403.

   import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39 tạo yêu cầu sử dụng

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   11

2. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   406.

   import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39 đợi một

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   11 trở nên khả dụng nếu tất cả hiện đang được sử dụng. Để tìm hiểu thêm về từ khóa

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   409, hãy xem Cách sử dụng Trình tạo và năng suất trong Python

3. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   410.

   import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39 sử dụng một

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   11 có sẵn để hoàn thành quy trình đã cho. Trong trường hợp này, đó là mua vé bằng cách gọi tới số

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   413

Sau khi một tài nguyên được sử dụng, nó phải được giải phóng để tác nhân tiếp theo sử dụng. Bạn có thể làm điều này một cách rõ ràng với

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Khi nhân viên thu ngân rảnh rỗi,

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Ở đây, cấu trúc cho mã là như nhau

Sau đó, có một bước tùy chọn là mua thực phẩm từ quầy giảm giá. Bạn không thể biết liệu một người xem phim có muốn mua đồ ăn nhẹ và đồ uống hay không. Một cách để đối phó với sự không chắc chắn này là đưa một chút tính ngẫu nhiên vào hàm

Mỗi

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Câu lệnh điều kiện này sẽ trả về một trong hai kết quả

1. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   424.

   import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39 sẽ yêu cầu người phục vụ và gọi đồ ăn

2. Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   425. Thay vào đó,

   import statistics as stats
   
   
   class SimulationNumeric:
       """Runs a function that returns a number n times and prints stats
   
       Args:
           fnct_to_run (function): The function to run
           iterations (integer): The number of times to run it"""
   
       def __init__(self, fnct_to_run, iterations):
           self._fnct_to_run = fnct_to_run
           self._iterations = iterations
           self._results = []
           self.run()
   
       @property
       def mode(self):
           try:
               return stats.mode(self._results)
           except:
               return None
   
       def run(self):
           for i in range(self._iterations):
               result = self._fnct_to_run()
               self._results.append(result)
   
           self.report()
   
       def report(self):
           max_num = max(self._results)
           min_num = min(self._results)
           mean = stats.mean(self._results)
           median = stats.median(self._results)
           mode = self.mode
           std_dev = stats.stdev(self._results)
           variance = stats.variance(self._results)
           print(
               f"""Number of Simulations: {self._iterations:,}
   Max: {max_num}
   Min: {min_num}
   Mean: {mean}
   Median: {median}
   Mode: {mode}
   Standard Deviation: {std_dev}
   Variance: {variance}"""
           )
   
   
   die = Die()
   sim = SimulationNumeric(die.roll, 1000)
   

   39 sẽ đi tìm chỗ ngồi của họ mà không mua bất kỳ đồ ăn nhẹ nào

Bây giờ, hãy nhớ rằng mục tiêu của mô phỏng này là xác định số lượng nhân viên thu ngân, người phục vụ và người phục vụ nên có trong đội ngũ nhân viên để giữ thời gian chờ dưới 10 phút. Để làm được điều này, bạn cần biết một số

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Bạn sử dụng

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Ghi chú. Bạn có thể lưu trữ thời gian khởi hành trong một biến riêng biệt như

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Làm cho mọi việc xảy ra. Định nghĩa hàm

Bây giờ bạn sẽ cần xác định một chức năng để chạy mô phỏng.

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Vì đây là quá trình chính, bạn sẽ cần phải vượt qua tất cả các ẩn số mà bạn đã khai báo cho đến nay

• Number of Simulations: 1,000
  Max: 6
  Min: 1
  Mean: 3.522
  Median: 4.0
  Mode: 4
  Standard Deviation: 1.7018849586304041
  Variance: 2.8964124124124124

  46

• Number of Simulations: 1,000
  Max: 6
  Min: 1
  Mean: 3.522
  Median: 4.0
  Mode: 4
  Standard Deviation: 1.7018849586304041
  Variance: 2.8964124124124124

  444

• Number of Simulations: 1,000
  Max: 6
  Min: 1
  Mean: 3.522
  Median: 4.0
  Mode: 4
  Standard Deviation: 1.7018849586304041
  Variance: 2.8964124124124124

  445

Đây là tất cả các biến mà mô phỏng cần để tạo và kiểm soát môi trường, do đó, điều tối quan trọng là phải vượt qua tất cả. Sau đó, bạn xác định một biến

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Bạn cũng có thể muốn bắt đầu mô phỏng của mình với một vài khán giả đang đợi ở rạp chiếu phim. Có lẽ sẽ có một vài người sẵn sàng đi ngay khi cánh cửa mở ra. Người quản lý nói rằng sẽ có khoảng 3 khán giả xếp hàng sẵn sàng mua vé ngay khi phòng vé mở cửa. Bạn có thể yêu cầu mô phỏng tiếp tục và di chuyển qua nhóm ban đầu này như vậy

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Bạn sử dụng

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Bạn không biết sẽ mất bao lâu để khán giả mới đến rạp, vì vậy bạn quyết định xem xét dữ liệu trong quá khứ. Sử dụng biên lai được đánh dấu thời gian từ phòng vé, bạn biết rằng khán giả xem phim có xu hướng đến rạp trung bình cứ sau 12 giây. Bây giờ tất cả những gì bạn phải làm là yêu cầu chức năng đợi lâu như vậy trước khi tạo một người mới

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Lưu ý rằng bạn sử dụng số thập phân

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Sau khi chờ đợi, hàm sẽ tăng

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Đó là nó. Khi bạn gọi chức năng này, mô phỏng sẽ tạo ra 3 người xem phim bắt đầu và bắt đầu di chuyển họ qua rạp chiếu phim với

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Tính toán thời gian chờ đợi. Định nghĩa hàm

Tại thời điểm này, bạn nên có một danh sách

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import statistics as stats


class SimulationNumeric:
    """Runs a function that returns a number n times and prints stats

    Args:
        fnct_to_run (function): The function to run
        iterations (integer): The number of times to run it"""

    def __init__(self, fnct_to_run, iterations):
        self._fnct_to_run = fnct_to_run
        self._iterations = iterations
        self._results = []
        self.run()

    @property
    def mode(self):
        try:
            return stats.mode(self._results)
        except:
            return None

    def run(self):
        for i in range(self._iterations):
            result = self._fnct_to_run()
            self._results.append(result)

        self.report()

    def report(self):
        max_num = max(self._results)
        min_num = min(self._results)
        mean = stats.mean(self._results)
        median = stats.median(self._results)
        mode = self.mode
        std_dev = stats.stdev(self._results)
        variance = stats.variance(self._results)
        print(
            f"""Number of Simulations: {self._iterations:,}
Max: {max_num}
Min: {min_num}
Mean: {mean}
Median: {median}
Mode: {mode}
Standard Deviation: {std_dev}
Variance: {variance}"""
        )


die = Die()
sim = SimulationNumeric(die.roll, 1000)

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Hàm này lấy danh sách

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Vì bạn đang tạo một tập lệnh sẽ được sử dụng bởi người quản lý rạp chiếu phim, nên bạn sẽ muốn đảm bảo rằng người dùng có thể đọc được đầu ra một cách dễ dàng. Bạn có thể thêm một chức năng gọi là

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import simpy
import random
import statistics

Phần cuối của hàm sử dụng

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Lựa chọn thông số. Định nghĩa chức năng nhập của người dùng

Khi bạn xây dựng các hàm này, bạn đã gặp phải một số biến số chưa được xác định rõ ràng

• Number of Simulations: 1,000
  Max: 6
  Min: 1
  Mean: 3.522
  Median: 4.0
  Mode: 4
  Standard Deviation: 1.7018849586304041
  Variance: 2.8964124124124124

  46

• Number of Simulations: 1,000
  Max: 6
  Min: 1
  Mean: 3.522
  Median: 4.0
  Mode: 4
  Standard Deviation: 1.7018849586304041
  Variance: 2.8964124124124124

  444

• Number of Simulations: 1,000
  Max: 6
  Min: 1
  Mean: 3.522
  Median: 4.0
  Mode: 4
  Standard Deviation: 1.7018849586304041
  Variance: 2.8964124124124124

  445

Các biến này là các tham số mà bạn có thể thay đổi để xem mô phỏng thay đổi như thế nào. Nếu một bộ phim bom tấn có khách hàng xếp hàng quanh khu nhà, thì nên có bao nhiêu nhân viên thu ngân làm việc?

Ghi chú. Đó là vẻ đẹp của mô phỏng. Nó cho phép bạn thử những điều này để bạn có thể đưa ra quyết định tốt nhất có thể trong cuộc sống thực

Bất kỳ ai đang sử dụng mô phỏng của bạn đều cần có khả năng thay đổi giá trị của các tham số này để thử các kịch bản khác nhau. Cuối cùng, bạn sẽ tạo một hàm trợ giúp để nhận các giá trị này từ người dùng

import simpy
import random
import statistics

Hàm này chỉ đơn giản gọi hàm

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Hoàn thiện thiết lập. Định nghĩa chức năng chính

Chức năng cuối cùng bạn muốn tạo là

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

import simpy
import random
import statistics

Đây là cách hoạt động của

Number of Simulations: 1,000
Max: 6
Min: 1
Mean: 3.522
Median: 4.0
Mode: 4
Standard Deviation: 1.7018849586304041
Variance: 2.8964124124124124

1. Thiết lập môi trường của bạn bằng cách khai báo một hạt giống ngẫu nhiên. Điều này đảm bảo đầu ra của bạn sẽ giống như những gì bạn thấy trong hướng dẫn này
2. Truy vấn người dùng chương trình của bạn cho một số đầu vào
3. Tạo môi trường và lưu nó dưới dạng biến

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   22, sẽ di chuyển mô phỏng qua từng bước thời gian
4. Yêu cầu

   import simpy
   import random
   import statistics
   

   8 chạy quy trình

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   442, quy trình này tạo ra môi trường rạp chiếu phim và khiến khán giả di chuyển qua đó
5. Xác định thời gian bạn muốn mô phỏng chạy. Là một giá trị mặc định, mô phỏng được thiết lập để chạy trong 90 phút
6. Lưu trữ đầu ra của

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   454 trong hai biến,

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   473 và

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   474
7. Sử dụng

   Number of Simulations: 1,000
   Max: 6
   Min: 1
   Mean: 3.522
   Median: 4.0
   Mode: 4
   Standard Deviation: 1.7018849586304041
   Variance: 2.8964124124124124

   475 để hiển thị kết quả cho người dùng

Với điều này, thiết lập đã hoàn tất