Mã Python đồng hồ bấm giờ

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

Nếu bạn kiểm tra mô-đun

 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"]

Trăn 3. 7 đã giới thiệu một số chức năng mới, như , cũng như các phiên bản nano giây của tất cả các chức năng trên, được đặt tên bằng hậu tố

 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"]

Note. In line 11, 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[]

For more information about f-strings, check out Python 3’s f-Strings. An Improved String Formatting Syntax

Now, when you run the example, you’ll see the elapsed time before the tutorial

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

[ .. ]

That’s it. You’ve covered the basics of timing your own Python code. In the rest of the tutorial, you’ll learn how you can wrap a Python timer into a class, a context manager, and a decorator to make it more consistent and convenient to use

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. Tiền tố gạch dướ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[]

 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[]

Khi bạn gọ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[]

 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[]

Mặt khác, khi bạn gọ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[]

 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[]

Đây là cách bạn 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[]

>>>

 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[]

So sánh điều này với nơi bạn đã sử dụng trực tiếp

 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[]

Notice that the code is very similar to what you used earlier. 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[]

Here are two examples that show the new functionality in action

>>>

 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. You’ll add a bit more functionality in the form of named timers with a dictionary that keeps track of every Python timer in your code

Assume that you’re expanding

 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[]

The code loops over the numbers from 0 to 9 and uses those as offset arguments to

$ 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[]

One subtle issue with this code is that you’re measuring not only the time it takes to download the tutorials, but also the time Python spends printing the tutorials to your screen. This might not be that important because the time spent printing should be negligible compared to the time spent downloading. Still, it would be good to have a way to precisely time what you’re after in these kinds of situations

Note. The time spent downloading ten tutorials is about the same as the time spent downloading one tutorial. This isn’t a bug in your code. Instead,

 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/ »

* * *

There are several ways that you can work around this without changing the current implementation of

$ 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/ »

* * *

First, you’ll introduce a dictionary called

$ 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/ »

* * *

Class variables can be accessed either directly on the class or through an instance of the class

>>>

$ 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/ »

* * *

In both cases, the code returns the same empty class dictionary

Next, you’ll add optional names to your Python timer. 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. These provide several conveniences to your classes, including a more informative representation string

Note. Các lớp dữ liệu chỉ được bao gồm trong Python cho phiên bản 3. 7 and later. However, there’s a backport available on PyPI for Python 3. 6

You can install it 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[]

$ 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/ »

* * *

See Data Classes in Python 3. 7+ [Guide] for more information

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 đặ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/ »
  
  * * *
  

  42 cho bất kỳ 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

Your new

 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/ »

* * *

Now you have a pretty neat version 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[]

Before ending this section, revisit the complete source code 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[]

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

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

Using a class to create a Python timer has several benefits

• Readability. Your code will read more naturally if you carefully choose class and method names
• Consistency. Your code will be easier to use if you encapsulate properties and behaviors into attributes and methods
• Flexibility. 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