Làm cách nào để tạo đồng hồ bấm giờ trong Python?

Chức năng hẹn giờ Python

If you check out the built-in

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

Python 3. 7 introduced several new functions, like , as well as nanosecond versions of all the functions above, named with an

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

Return the value [in fractional seconds] of a performance counter, i. e. a clock with the highest available resolution to measure a short duration. []

First, you’ll use

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

Example. Download Tutorials

To better compare the different ways that you can add a Python timer to your code, you’ll apply different Python timer functions to the same code example throughout this tutorial. If you already have code that you’d like to measure, then feel free to follow the examples with that instead

The example that you’ll use in this tutorial is a short function that uses the

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

$ python -m pip install realpython-reader

Then, you can import the package as

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

You’ll store the example in a file named

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

• Line 3 imports

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  12 from

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  06. This module contains functionality for downloading tutorials from the
• Line 7 downloads the latest tutorial from Real Python. The number

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  14 is an offset, where

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  14 means the most recent tutorial,

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  16 is the previous tutorial, and so on
• Line 8 prints the tutorial to the console
• Line 11 calls

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  17 when you run the script

When you run this example, your output will typically look something like this

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

The code may take a little while to run depending on your network, so you might want to use a Python timer to monitor the performance of the script

Your First Python Timer

Now you’ll add a bare-bones Python timer to the example with

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

>>>

>>> import time
>>> time.perf_counter[]
32311.48899951

>>> time.perf_counter[]  # A few seconds later
32315.261320793

In this example, you made two calls to

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

You can now add a Python timer to the example code

 1# latest_tutorial.py
 2
 3import time
 4from reader import feed
 5
 6def main[]:
 7    """Print the latest tutorial from Real Python"""
 8    tic = time.perf_counter[]
 9    tutorial = feed.get_article[0]
10    toc = time.perf_counter[]
11    print[f"Downloaded the tutorial in {toc - tic:0.4f} seconds"]
12
13    print[tutorial]
14
15if __name__ == "__main__":
16    main[]

Note that you call

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

Ghi chú. Ở dòng 11,

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Để biết thêm thông tin về chuỗi f, hãy xem Chuỗi f của Python 3. Cú pháp định dạng chuỗi được cải thiện

Bây giờ, khi bạn chạy ví dụ, bạn sẽ thấy thời gian đã trôi qua trước phần hướng dẫn

$ python latest_tutorial.py
Downloaded the tutorial in 0.6721 seconds
# Python Timer Functions: Three Ways to Monitor Your Code

[ .. ]

Đó là nó. Bạn đã nắm được kiến ​​thức cơ bản về định thời gian cho mã Python của riêng mình. Trong phần còn lại của hướng dẫn, bạn sẽ học cách gói bộ đếm thời gian Python vào một lớp, trình quản lý ngữ cảnh và trình trang trí để làm cho nó nhất quán và thuận tiện hơn khi sử dụng

Understanding Classes in Python

Classes are the main building blocks of object-oriented programming. A class is essentially a template that you can use to create objects. While Python doesn’t force you to program in an object-oriented manner, classes are everywhere in the language. For quick proof, investigate the

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

>>>

>>> import time
>>> type[time]


>>> time.__class__

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

>>>

>>> type[3]


>>> type[None]


>>> type[print]


>>> type[type]

In Python, classes are great when you need to model something that needs to keep track of a particular state. In general, a class is a collection of properties, called attributes, and behaviors, called methods. For more background on classes and object-oriented programming, check out Object-Oriented Programming [OOP] in Python 3 or the official docs

Creating a Python Timer Class

Classes are good for tracking state. In a

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

A few different things are happening here, so take a moment to walk through the code step by step

In line 5, you define a

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

The definition of

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Note. The underscore [

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

When you call

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

On the other hand, when you call

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Here’s how you use

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

>>>

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Compare this to the where you used

 1# timer.py
 2
 3import time
 4
 5class TimerError[Exception]:
 6    """A custom exception used to report errors in use of Timer class"""
 7
 8class Timer:
 9    def __init__[self]:
10        self._start_time = None
11
12    def start[self]:
13        """Start a new timer"""
14        if self._start_time is not None:
15            raise TimerError[f"Timer is running. Use .stop[] to stop it"]
16
17        self._start_time = time.perf_counter[]
18
19    def stop[self]:
20        """Stop the timer, and report the elapsed time"""
21        if self._start_time is None:
22            raise TimerError[f"Timer is not running. Use .start[] to start it"]
23
24        elapsed_time = time.perf_counter[] - self._start_time
25        self._start_time = None
26        print[f"Elapsed time: {elapsed_time:0.4f} seconds"]

Using the Python Timer Class

Now apply

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Lưu ý rằng mã rất giống với mã bạn đã sử dụng trước đó. In addition to making the code more readable,

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Printing the elapsed time from

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Adding More Convenience and Flexibility

So far, you’ve learned that classes are suitable for when you want to encapsulate state and ensure consistent behavior in your code. In this section, you’ll add more convenience and flexibility to your Python timer

• Use adaptable text and formatting when reporting the time spent
• Apply flexible logging, either to the screen, to a log file, or other parts of your program
• Create a Python timer that can accumulate over several invocations
• Build an informative representation of a Python timer

First, see how you can customize the text used to report the time spent. In the previous code, the text

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

To add

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Note that the default text,

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Note. If you want to use an f-string to specify

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

One example would be

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

In

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

After this update to

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

>>>

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Next, assume that you don’t just want to print a message to the console. Maybe you want to save your time measurements so that you can store them in a database. You can do this by returning the value of

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Perhaps you want to integrate

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Instead of using

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Dưới đây là hai ví dụ cho thấy chức năng mới đang hoạt động

>>>

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

When you run these examples in an interactive shell, Python prints the return value automatically

The third improvement that you’ll add is the ability to accumulate time measurements. You may want to do this, for example, when you’re calling a slow function in a loop. Bạn sẽ thêm một chút chức năng dưới dạng bộ hẹn giờ được đặt tên với một từ điển theo dõi mọi bộ hẹn giờ Python trong mã của bạn

Giả sử rằng bạn đang mở rộng

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Đoạn mã lặp qua các số từ 0 đến 9 và sử dụng các số đó làm đối số bù cho

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Một vấn đề tế nhị với đoạn mã này là bạn đang đo không chỉ thời gian cần thiết để tải xuống các hướng dẫn mà còn cả thời gian Python dành để in các hướng dẫn lên màn hình của bạn. Điều này có thể không quan trọng vì thời gian dành cho in ấn không đáng kể so với thời gian tải xuống. Tuy nhiên, sẽ rất tốt nếu có một cách để tính thời gian chính xác cho những gì bạn đang theo đuổi trong những tình huống như thế này

Ghi chú. Thời gian tải xuống mười hướng dẫn bằng thời gian tải xuống một hướng dẫn. Đây không phải là một lỗi trong mã của bạn. Thay vào đó,

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Có một số cách mà bạn có thể giải quyết vấn đề này mà không thay đổi cách triển khai hiện tại của

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Trước tiên, bạn sẽ giới thiệu một từ điển có tên là

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Các biến lớp có thể được truy cập trực tiếp trên lớp hoặc thông qua một thể hiện của lớp

>>>

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Trong cả hai trường hợp, mã trả về cùng một từ điển lớp trống

Tiếp theo, bạn sẽ thêm tên tùy chọn vào bộ đếm thời gian Python của mình. You can use the name for two different purposes

1. Looking up the elapsed time later in your code
2. Accumulating timers with the same name

To add names to your Python timer, you need to make two more changes to

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Note that you use

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

>>>

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

You can now revisit

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Rerunning the script will give output similar to earlier, although now you’re only timing the actual download of the tutorials

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

The final improvement that you’ll make to

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

>>>

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

That last line is the default way that Python represents objects. While you can glean some information from it, it’s usually not very useful. Instead, it would be nice to see information like the name of

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

In Python 3. 7, data classes were added to the standard library. Chúng cung cấp một số tiện ích cho các lớp của bạn, bao gồm một chuỗi biểu diễn nhiều thông tin hơn

Ghi chú. Các lớp dữ liệu chỉ được bao gồm trong Python cho phiên bản 3. 7 trở lên. Tuy nhiên, có sẵn một backport trên PyPI cho Python 3. 6

Bạn có thể cài đặt nó bằng cách sử dụng

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Xem Các lớp dữ liệu trong Python 3. 7+ [Hướng dẫn] để biết thêm thông tin

Bạn chuyển đổi bộ đếm thời gian Python của mình thành một lớp dữ liệu bằng cách sử dụng trình trang trí

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Mã này thay thế phương pháp

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Bạn cần chú thích các biến của mình để sử dụng một lớp dữ liệu. Bạn có thể sử dụng chú thích này để thêm gợi ý loại vào mã của mình. Nếu bạn không muốn sử dụng gợi ý loại, thì thay vào đó, bạn có thể chú thích tất cả các biến bằng

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Dưới đây là một vài lưu ý về lớp dữ liệu

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

• Dòng 9. Trình trang trí

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  22 định nghĩa

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  28 là một lớp dữ liệu

• Dòng 11. Chú thích đặc biệt

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  30 là cần thiết cho các lớp dữ liệu để xác định rằng

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  06 là một biến lớp

• Dòng 12 đến 14.

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  32,

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  74 và

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  34 sẽ được định nghĩa là thuộc tính trên

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  28, có thể chỉ định giá trị của các giá trị này khi tạo phiên bản

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  28. Tất cả đều có các giá trị mặc định nhất định

• dòng 15. Nhớ lại rằng

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  37 là một thuộc tính đặc biệt được sử dụng để theo dõi trạng thái của bộ đếm thời gian Python, nhưng nó phải được ẩn khỏi người dùng. Sử dụng

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  38, bạn nói rằng nên loại bỏ

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  37 khỏi

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  48 và đại diện cho

   1# latest_tutorial.py
   2
   3from reader import feed
   4
   5def main[]:
   6    """Download and print the latest tutorial from Real Python"""
   7    tutorial = feed.get_article[0]
   8    print[tutorial]
   9
  10if __name__ == "__main__":
  11    main[]
  

  28

• Dòng 17 đến 20. Bạn có thể sử dụng phương pháp

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  42 đặc biệt cho bất kỳ lần khởi tạo nào mà bạn cần thực hiện ngoài việc thiết lập các thuộc tính thể hiện. Tại đây, bạn sử dụng nó để thêm bộ hẹn giờ đã đặt tên vào

  $ python latest_tutorial.py
  # Python Timer Functions: Three Ways to Monitor Your Code
  
  While many developers recognize Python as an effective programming language,
  pure Python programs may run more slowly than their counterparts in compiled
  languages like C, Rust, and Java. In this tutorial, you'll learn how to use
  a Python timer to monitor how quickly your programs are running.
  
  [ .. ]
  
  ## Read the full article at //realpython.com/python-timer/ »
  
  * * *
  

  06

Lớp dữ liệu

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

>>>

$ python latest_tutorial.py
# Python Timer Functions: Three Ways to Monitor Your Code

While many developers recognize Python as an effective programming language,
pure Python programs may run more slowly than their counterparts in compiled
languages like C, Rust, and Java. In this tutorial, you'll learn how to use
a Python timer to monitor how quickly your programs are running.

[ .. ]

## Read the full article at //realpython.com/python-timer/ »

* * *

Bây giờ bạn đã có một phiên bản khá gọn gàng của

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

Trước khi kết thúc phần này, hãy xem lại mã nguồn hoàn chỉnh của

 1# latest_tutorial.py
 2
 3from reader import feed
 4
 5def main[]:
 6    """Download and print the latest tutorial from Real Python"""
 7    tutorial = feed.get_article[0]
 8    print[tutorial]
 9
10if __name__ == "__main__":
11    main[]

>>> import time
>>> time.perf_counter[]
32311.48899951

>>> time.perf_counter[]  # A few seconds later
32315.261320793

Sử dụng một lớp để tạo bộ đếm thời gian Python có một số lợi ích

• khả năng đọc. Mã của bạn sẽ đọc tự nhiên hơn nếu bạn cẩn thận chọn tên lớp và phương thức
• Tính nhất quán. Mã của bạn sẽ dễ sử dụng hơn nếu bạn gói gọn các thuộc tính và hành vi thành các thuộc tính và phương thức
• Uyển chuyển. Mã của bạn sẽ có thể tái sử dụng nếu bạn sử dụng các thuộc tính có giá trị mặc định thay vì các giá trị được mã hóa cứng

Lớp này rất linh hoạt và bạn có thể sử dụng nó trong hầu hết mọi tình huống mà bạn muốn theo dõi thời gian cần để mã chạy. Tuy nhiên, trong các phần tiếp theo, bạn sẽ tìm hiểu về cách sử dụng trình quản lý ngữ cảnh và trình trang trí, điều này sẽ thuận tiện hơn cho việc định thời gian cho các khối mã và chức năng