When I’m debugging time-sensitive behavior or building anything that logs events, I always start with one basic check: can I print the exact time right now, down to the microsecond? It sounds simple, but that tiny detail quickly surfaces real issues—like out-of-order log lines, inconsistent timestamps across services, or clock drift between machines. You don’t need a huge library to solve this. You need a clear mental model of how Python’s time APIs behave, where the values come from, and what “microsecond” actually means on a real system.
In the next few sections I’ll show you the most direct way to print hour, minute, second, and microsecond using datetime, then I’ll expand to time module patterns, formatting approaches, and edge cases that bite people in production. I’ll also show how I use modern workflows in 2026—linting, tests, and AI-assisted refactors—to keep time handling predictable. By the end, you’ll have runnable snippets, guidance on when each approach is best, and a few pitfalls you can avoid before they show up in your logs.
The fastest path: datetime.now() and attributes
If you just need the current local time broken into pieces, datetime.now() is the cleanest choice. I use it when I need readable values or I’m printing or logging local time directly. It creates a datetime object that already contains hour, minute, second, and microsecond as integer fields, so extracting them is a single attribute lookup.
Here is the most direct, runnable example:
from datetime import datetime
now = datetime.now()
print("Current hour:", now.hour)
print("Current minute:", now.minute)
print("Current second:", now.second)
print("Current microsecond:", now.microsecond)
If you print these in a tight loop, each call will return a new snapshot of the local clock. I usually avoid calling datetime.now() four times because that can give you a mix of times if the second flips between calls. Grabbing it once, then reading attributes, keeps all values consistent.
A small but important detail: those numbers are local time, not UTC. If your script runs on multiple servers, “current hour” can mean different values. In my experience, the safest approach is to log in UTC and display in local time for humans. If you want UTC in the same style, you can use datetime.utcnow() or the timezone-aware approach shown later.
Why this is O(1)
This is a constant-time operation. You’re just reading attributes from a struct-backed object. It’s effectively O(1) for time and O(1) for space. That matters if you’re stamping every log line, but it won’t be a performance issue in any normal script.
Real-world use
I typically wrap this in a small helper when writing CLI tools:
from datetime import datetime
def currenttimeparts():
now = datetime.now()
return now.hour, now.minute, now.second, now.microsecond
hour, minute, second, microsecond = currenttimeparts()
print(f"{hour:02d}:{minute:02d}:{second:02d}.{microsecond:06d}")
That formatting line pads values with zeros and ensures the microsecond field always shows six digits. The padding matters when you read logs or export to CSV.
Formatting a human-readable string without losing precision
Sometimes you don’t want the raw integers. You want a readable time string that still contains microseconds. I usually use strftime for the hour, minute, and second, and then append the microseconds. The standard strftime in Python doesn’t provide a portable microsecond token on every platform, so I treat microseconds explicitly.
Here is the pattern I recommend:
from datetime import datetime
now = datetime.now()
time_str = now.strftime("%H:%M:%S")
print(f"Time now: {time_str}.{now.microsecond:06d}")
If you want each field separately while still using strftime, you can do this:
from datetime import datetime
now = datetime.now()
hour = now.strftime("%H")
minute = now.strftime("%M")
second = now.strftime("%S")
microsecond = f"{now.microsecond:06d}"
print(f"Current hour: {hour}")
print(f"Current minute: {minute}")
print(f"Current second: {second}")
print(f"Current microsecond: {microsecond}")
I prefer this approach when the output is meant for humans or logs that need fixed-width fields. The trade-off is that strftime returns strings, so if you need numeric values for arithmetic, stick to attributes.
Simple analogy
Think of datetime.now() as taking a photo of a clock. The attributes are the hour and minute on the clock face. strftime is you writing that photo onto a postcard. Both are the same moment, but the postcard is formatted for people.
The time module: when you want raw seconds
There are cases where I use the time module instead of datetime. It’s lower-level and gives you seconds since the Unix epoch. It’s ideal when you need a timestamp for performance measurements or you want to integrate with systems that already use epoch seconds.
Here is a complete example that prints hour, minute, second, and microsecond using time:
import time
current_time = time.time()
localtime = time.localtime(currenttime)
hour = localtime.tmhour
minute = localtime.tmmin
second = localtime.tmsec
microsecond = int((currenttime - int(currenttime)) * 1000000)
print("Current hour:", hour)
print("Current minute:", minute)
print("Current second:", second)
print("Current microsecond:", microsecond)
This approach is still O(1), but there’s a catch: the microseconds are derived from the fractional seconds of time.time(). That fraction depends on the system clock resolution, which can vary. On some systems you’ll see jumps or repeated values, especially in tight loops.
When I choose time over datetime
- I’m measuring elapsed time or durations.
- I need a float or integer epoch for storage.
- I’m interfacing with a system that expects epoch seconds.
When I avoid it
- I need timezone-aware values.
- I want clean formatting or easy component access.
- I’m working with calendar logic (dates, month boundaries, DST).
Precision vs accuracy: microseconds in real systems
A lot of engineers assume that “microsecond” implies exact microsecond precision. It doesn’t. It’s the shape of the value, not the guarantee. On many machines, the clock resolution is around 1ms to 15ms, even if you see a microsecond field. That means you can get repeated microsecond values, or values that jump in chunks.
Here’s how I think about it:
- Precision: how many digits are shown (microseconds = six digits).
- Accuracy: how close those digits are to the real time.
- Resolution: the smallest step the clock can actually detect.
If you are logging events, microseconds are still useful for ordering events within the same second, but don’t treat them as exact timing. If you need true high-resolution elapsed time, use time.perf_counter() for measurements and keep datetime for wall-clock time. In real services, I keep both: a wall-clock timestamp for human-readable logs and a monotonic timer for performance traces.
A brief note on timezone-aware timestamps
If you work across multiple machines, you should prefer timezone-aware timestamps. Python’s standard library supports this directly:
from datetime import datetime, timezone
now_utc = datetime.now(timezone.utc)
print("UTC hour:", now_utc.hour)
print("UTC minute:", now_utc.minute)
print("UTC second:", now_utc.second)
print("UTC microsecond:", now_utc.microsecond)
This avoids confusion when a machine moves across time zones or daylight saving time changes. I usually keep UTC in logs and only convert to local time in dashboards or UI layers.
Traditional vs modern ways I structure this in 2026
I still see plenty of scripts that call datetime.now() four times or parse strings to get time parts. That works for a quick snippet, but modern practice favors clarity, tests, and reproducibility. Here’s a high-level comparison based on how I approach this today.
Traditional pattern
Why it matters
—
—
datetime.now() per field
now = datetime.now() once Consistent snapshot
Manual string concatenation
f"{hour:02d}" padding Readable, fixed width
Ignored or dropped
:06d padding Precise ordering
Local-only
Cross-machine clarity
No tests
Regression control
In modern teams, I also use AI-assisted review tools to scan for repeated datetime.now() calls, subtle formatting inconsistencies, and timezone mistakes. These tools don’t replace reasoning, but they do catch easy-to-miss issues.
Common mistakes I see and how I avoid them
I’ve made every one of these at some point. The important thing is recognizing them early.
1) Calling datetime.now() multiple times
If you do this:
from datetime import datetime
print(datetime.now().hour)
print(datetime.now().minute)
print(datetime.now().second)
print(datetime.now().microsecond)
You might capture four different moments. If the second rolls over between calls, the values can be inconsistent. I always store the value once and read attributes from that object.
2) Dropping leading zeros
minute=5 is fine, but if you build a time string without padding, you get 8:5:3 instead of 08:05:03. This is ugly and hard to parse. Use f"{value:02d}" or strftime for consistent width.
3) Mixing local time and UTC unintentionally
I’ve seen logs where one service writes local time and another writes UTC. The results look out of order even when the events are correct. Decide early whether you log local time or UTC, and stick to it. I recommend UTC for any multi-service setup.
4) Expecting microsecond accuracy
You might see microseconds change, but the underlying clock may tick every few milliseconds. If precise timing is required, use time.perf_counter() for duration measurement and use datetime for wall-clock stamps.
5) Confusing time.time() and datetime.now() values
time.time() returns seconds since the epoch as a float. datetime.now() returns a structured object. Don’t mix them unless you know how to convert correctly.
When to use each approach—and when not to
I don’t want you to guess here, so here’s my direct guidance:
Use datetime.now() when
- You need human-readable fields right away.
- You want direct access to hour, minute, second, microsecond.
- You’re logging events or showing time to a user.
Don’t use datetime.now() when
- You’re measuring elapsed time for performance benchmarks.
- You need a monotonic clock that won’t jump backward.
Use time.time() when
- You’re storing epoch timestamps.
- You need raw seconds for cross-language consistency.
Don’t use time.time() when
- You need timezone awareness or calendar logic.
- You need a clear human-readable format without extra work.
Practical scenarios I see in production
Here are a few real patterns I see in active codebases, and how I structure them.
Logging with precise ordering
I often need to sort events that happen within the same second. I use a fixed format with microseconds:
from datetime import datetime, timezone
now = datetime.now(timezone.utc)
timestamp = f"{now:%Y-%m-%d %H:%M:%S}.{now.microsecond:06d}Z"
print(timestamp)
That gives me a sortable timestamp like 2026-01-19 14:03:22.123456Z. The Z makes it obvious this is UTC.
CLI tools that show live time
When I build command-line tools, I print the parts directly and show an explanation if needed:
from datetime import datetime
now = datetime.now()
print(f"Hour: {now.hour}")
print(f"Minute: {now.minute}")
print(f"Second: {now.second}")
print(f"Microsecond: {now.microsecond}")
Scheduling and cron-like scripts
If a script runs every minute, you may still want to verify the sub-second time for debugging. I keep it simple:
from datetime import datetime
def emittimeparts():
now = datetime.now()
return now.hour, now.minute, now.second, now.microsecond
hour, minute, second, microsecond = emittimeparts()
print(f"{hour:02d}:{minute:02d}:{second:02d}.{microsecond:06d}")
Performance considerations without overthinking it
Retrieving the current time and printing it is fast. On typical desktops and cloud VMs, the total runtime is usually in the 0.1–5 ms range for a single print cycle, depending on stdout buffering and the environment. The time retrieval itself is much faster; the printing can dominate in tight loops.
If you need to call this in high-frequency contexts, reduce I/O. I usually batch logs or use a buffered logger rather than print() on every event.
Testing your time formatting safely
Time-based code is tricky to test because the values change every call. I use a simple pattern: I inject a datetime object into the function, then test with a fixed value.
from datetime import datetime
def formattimeparts(dt: datetime) -> str:
return f"{dt.hour:02d}:{dt.minute:02d}:{dt.second:02d}.{dt.microsecond:06d}"
Example usage
fixed = datetime(2026, 1, 19, 9, 7, 5, 123456)
print(formattimeparts(fixed)) # 09:07:05.123456
This makes your tests stable and predictable. I also add tests to check that microseconds always have six digits and that the output remains zero-padded.
A short, practical checklist I use
When I add time stamps to a script or service, I run through this list:
- Capture
datetime.now()once per event. - Choose UTC unless I have a strong reason for local time.
- Format with padding for readability and sorting.
- Treat microseconds as ordering help, not exact timing.
- Add a small unit test if the format matters for logs or APIs.
Closing: what I want you to remember
If you only take one idea from this, let it be this: grab a single time snapshot, then read hour, minute, second, and microsecond from that same object. That keeps your time values consistent, your logs sortable, and your debugging sessions calm. In my experience, most “time bugs” in small scripts come from tiny inconsistencies—a second rollover between calls, a missing zero in formatting, or a mix of local and UTC timestamps. You can avoid all of those with a few deliberate choices.
If you need human-readable fields, I recommend datetime.now() and attribute access. If you need raw epoch seconds, go with the time module and convert carefully. When you work across machines, switch to timezone-aware UTC timestamps so you never guess which clock you’re reading. And if you’re measuring duration, don’t reuse wall-clock time at all—use a monotonic timer and keep those concerns separate.
Finally, treat microseconds as a precise label, not a promise.
The anatomy of a datetime object: what you’re actually reading
When you access now.hour or now.microsecond, you’re reading fields stored on the datetime object itself. That matters because it implies consistency: every attribute is derived from the same captured instant. I like to think of datetime as a snapshot struct with multiple convenient lenses—hour, minute, second, microsecond, date, and timezone info all stored together.
Here’s a small introspection snippet I sometimes use when teaching this:
from datetime import datetime
now = datetime.now()
print(type(now))
print(now)
print(now.year, now.month, now.day, now.hour, now.minute, now.second, now.microsecond)
Even though the code prints more than just time, it helps you see the shape of the object. The microsecond value is always an integer between 0 and 999999, never larger. That property makes formatting predictable and makes it safe to zero-pad to six digits.
Why datetime.utcnow() feels tempting but can be misleading
datetime.utcnow() gives you a UTC timestamp, but it creates a naive datetime object (no timezone info). That can be a trap because downstream code may assume naive values are local. I still see this in logs: timestamps labeled as UTC but interpreted as local time elsewhere. If you choose UTC, I recommend datetime.now(timezone.utc) so the timezone offset travels with the value.
H2: Two quick micro-optimizations that actually matter
I don’t micro-optimize time printing unless the code path is extremely hot, but there are two small choices that pay off in real projects.
1) Capture once and reuse everywhere
I already covered this, but it’s worth repeating: capture once per event and pass the object into formatting or logging functions. This prevents inconsistent timestamps and reduces system calls.
from datetime import datetime
def log_event(message: str, now: datetime) -> str:
return f"{now:%H:%M:%S}.{now.microsecond:06d} | {message}"
now = datetime.now()
print(log_event("startup", now))
2) Avoid repeated conversions in tight loops
If you’re printing time for each iteration of a tight loop, you can reduce conversions by precomputing the formatted prefix when possible. For example, in a loop that logs multiple events within the same second, I sometimes compute the HH:MM:SS prefix once and only append microseconds per event. This is a small savings but can help when you’re logging high-frequency data streams.
from datetime import datetime
now = datetime.now()
base = now.strftime("%H:%M:%S")
print(f"{base}.{now.microsecond:06d}")
H2: Getting microseconds right in formatted strings
It’s easy to accidentally drop microseconds or lose padding. I always use :06d when formatting microseconds because it ensures fixed width and lexical ordering in logs. Here’s a compact helper that I reuse:
from datetime import datetime
def timewithmicroseconds(dt: datetime) -> str:
return f"{dt:%H:%M:%S}.{dt.microsecond:06d}"
print(timewithmicroseconds(datetime.now()))
That helper returns values like 09:07:05.003210. If the microsecond value is 3210, the string still shows 003210, which keeps log columns aligned and makes sorting reliable.
A quick caution about strftime and %f
Python’s strftime supports %f for microseconds in the standard library, and it’s commonly available. But I still prefer to append dt.microsecond explicitly, especially when portability matters or when I want to control zero padding. The explicit approach is more obvious and makes unit tests straightforward.
H2: Local time, UTC, and the “naive vs aware” decision
This is one of the most common sources of time bugs. A datetime object can be naive (no timezone info) or aware (has tzinfo). If you’re working across servers or saving timestamps to a database, pick a strategy and be consistent.
My default strategy
- Use timezone-aware UTC timestamps for logs and storage.
- Convert to local time only for display.
- Keep timezone conversion at the edges of the system.
Here’s a simple pattern for this:
from datetime import datetime, timezone
now_utc = datetime.now(timezone.utc)
print(f"UTC time: {nowutc:%H:%M:%S}.{nowutc.microsecond:06d}")
Displaying local time in a user-facing script
If you want to show local time but still keep the format consistent, do it in one function that formats the components clearly:
from datetime import datetime
def localtimestring() -> str:
now = datetime.now()
return f"{now.hour:02d}:{now.minute:02d}:{now.second:02d}.{now.microsecond:06d}"
print(localtimestring())
That avoids mixing local and UTC in a single output.
H2: Microseconds and ordering in distributed logs
Microseconds are often used as a tie-breaker when events happen within the same second. But in distributed systems, clock skew can still reorder events across machines. I avoid relying on microseconds alone for event ordering across hosts. Instead, I log microseconds for readability, but I also rely on system-wide tracing IDs or monotonic timers for ordering inside a process.
If you’re writing a small script, you don’t need to overthink this. But if you’re building a service, it helps to remember that microseconds are a local ordering hint, not a universal truth.
H2: A minimal, reusable utility function
I like to keep a tiny utility that returns the time parts in a predictable form. This makes integration with CLI tools and tests easy.
from datetime import datetime
from typing import Tuple
def currenttimeparts() -> Tuple[int, int, int, int]:
now = datetime.now()
return now.hour, now.minute, now.second, now.microsecond
hour, minute, second, microsecond = currenttimeparts()
print(hour, minute, second, microsecond)
If you prefer strings instead of integers (for example, in a CSV export), you can adapt it:
from datetime import datetime
from typing import Tuple
def currenttimeparts_str() -> Tuple[str, str, str, str]:
now = datetime.now()
return (
f"{now.hour:02d}",
f"{now.minute:02d}",
f"{now.second:02d}",
f"{now.microsecond:06d}",
)
print(currenttimeparts_str())
These small helpers reduce repetition and make it harder to accidentally call datetime.now() multiple times.
H2: Comparing approaches with a decision table
When I’m writing a guide for teammates, I sometimes include a small decision table like this to avoid repeated questions.
Best tool
Caveat
—
—
datetime.now()
Local time only
datetime.now(timezone.utc)
Requires timezone
time.time()
Microseconds from fraction
time.perf_counter()
Not wall-clockThis table also makes it easier to justify the choice in code review.
H2: Edge cases that matter more than you think
Even in small scripts, the edge cases can surprise you. Here are the ones I watch for:
1) Second rollover between reads
If you read hour, minute, second, microsecond from separate datetime.now() calls, the second may change and your output becomes inconsistent. The fix is simple: capture once.
2) Daylight saving time transitions
Local time can jump forward or backward during DST transitions. If you run a script during the shift, you might see repeated hours or skipped minutes. For reproducibility, log in UTC and convert at the edges.
3) System clock adjustments
NTP corrections can shift your system clock slightly. That can lead to repeated or out-of-order times if you use wall-clock time for ordering. For measuring elapsed time, always use time.perf_counter().
4) Floating point precision in time.time()
The fractional part of time.time() is a float, which can introduce subtle precision issues when you convert to microseconds. In most scripts this is fine, but if you need deterministic microseconds, stick to datetime.
5) Output buffering in logs
Sometimes the “time mismatch” is not about the timestamp but about buffering delays. If you print a time stamp and the output is buffered, the log line may appear later than expected. Using a logger configured with flush or line buffering can help.
H2: A fuller example with logging and testing
Here’s a small, practical module that formats time parts and is easy to test. I use this pattern for small tools and CLIs.
from datetime import datetime, timezone
def nowpartsutc() -> tuple[int, int, int, int]:
now = datetime.now(timezone.utc)
return now.hour, now.minute, now.second, now.microsecond
def formattimeparts(hour: int, minute: int, second: int, microsecond: int) -> str:
return f"{hour:02d}:{minute:02d}:{second:02d}.{microsecond:06d}"
if name == "main":
h, m, s, us = nowpartsutc()
print(formattimeparts(h, m, s, us) + "Z")
Example tests (conceptual)
I rarely need heavy tests for time formatting, but a simple unit test is worth it:
from datetime import datetime
def formattimeparts(dt: datetime) -> str:
return f"{dt.hour:02d}:{dt.minute:02d}:{dt.second:02d}.{dt.microsecond:06d}"
fixed = datetime(2026, 1, 19, 9, 7, 5, 42)
assert formattimeparts(fixed) == "09:07:05.000042"
This keeps output stable and prevents future refactors from accidentally dropping zero padding.
H2: Variations you might need in real projects
Sometimes the “right” output format changes based on the consumer of your data. Here are three variations I use, each for a different audience.
1) Log-friendly
from datetime import datetime, timezone
now = datetime.now(timezone.utc)
print(f"{now:%Y-%m-%d %H:%M:%S}.{now.microsecond:06d}Z")
2) CSV-friendly
from datetime import datetime
now = datetime.now()
print(f"{now.hour:02d},{now.minute:02d},{now.second:02d},{now.microsecond:06d}")
3) Human-readable with labels
from datetime import datetime
now = datetime.now()
print(f"Hour={now.hour:02d} Minute={now.minute:02d} Second={now.second:02d} Microsecond={now.microsecond:06d}")
The logic is the same, but the formatting fits the context. I don’t force a single format across all tools; I choose based on where the data is going.
H2: Comparing datetime to third-party libraries
It’s tempting to reach for external libraries, especially when dealing with time. But for the specific task of printing hour, minute, second, and microsecond, the standard library is more than enough. I usually avoid additional dependencies unless I need more complex timezone logic or parsing.
The minimal takeaway: if all you need is the current time parts, datetime is small, fast, and clear. External libraries add power, but also add surface area that needs documentation, maintenance, and updates.
H2: A practical mini-project: a tiny time reporter
If you want a more complete example with a CLI interface, here’s a tiny script I use for demos. It prints the time parts and shows both local and UTC values for comparison. This makes it easy to debug time zone issues in a dev environment.
from datetime import datetime, timezone
local = datetime.now()
utc = datetime.now(timezone.utc)
print("Local time")
print(f" Hour: {local.hour:02d}")
print(f" Minute: {local.minute:02d}")
print(f" Second: {local.second:02d}")
print(f" Microsecond: {local.microsecond:06d}")
print("UTC time")
print(f" Hour: {utc.hour:02d}")
print(f" Minute: {utc.minute:02d}")
print(f" Second: {utc.second:02d}")
print(f" Microsecond: {utc.microsecond:06d}")
Even this simple script catches surprises, like when a server is configured with an unexpected timezone.
H2: Why microseconds still matter even with coarse clocks
Even if the system clock only updates every few milliseconds, microseconds are still useful because they add ordering information inside the same second. In other words, they create a stable format that sorts correctly even if many values repeat. I’ve seen teams drop microseconds because they looked “noisy.” That usually makes debugging harder when multiple events happen in the same second.
The compromise I like is this: keep microseconds in logs, but don’t rely on them for precise elapsed-time measurements. If you need precision, you should measure durations with a monotonic timer instead.
H2: A quick note on monotonic timers vs wall-clock time
While this guide is about printing the current time, it’s worth stating the difference between wall-clock and monotonic time clearly.
- Wall-clock time can move backward or forward if the system clock is adjusted.
- Monotonic time only moves forward and is ideal for measuring durations.
If you want to print “current hour, minute, second, microsecond,” you should use wall-clock time (datetime). If you want to measure how long something took, use time.perf_counter().
Here’s a minimal demonstration:
import time
from datetime import datetime
start = time.perf_counter()
Do work here
end = time.perf_counter()
print(f"Elapsed: {end - start:.6f} seconds")
now = datetime.now()
print(f"Current time: {now:%H:%M:%S}.{now.microsecond:06d}")
Keep those two concepts separate and you’ll avoid a huge category of subtle bugs.
H2: Output consistency across platforms
Different operating systems expose different clock resolutions. On one machine you might see microseconds change nearly every call, while on another they appear in steps. This is expected, not a bug. To keep your output consistent across platforms, focus on formatting and snapshot consistency, not on the numerical variability.
If you need deterministic testing across platforms, inject fixed datetime values into your formatting functions and avoid datetime.now() in tests.
H2: A quick refactor checklist for existing code
When I audit a codebase for time handling, I do a quick pass with this checklist:
- Replace repeated
datetime.now()calls with a single snapshot. - Ensure microseconds are padded to six digits.
- Confirm UTC usage (or documented local usage) in logs.
- Separate wall-clock timestamps from performance measurements.
- Add a simple formatter function and test it.
Even applying two or three items from this list can make log output cleaner and debugging faster.
H2: Small improvements that pay off in debugging
Sometimes the most valuable change is a tiny formatting tweak. Here are two I use a lot:
Always include microseconds in logs
Logs that only show seconds often leave you guessing about event order. I treat microseconds as a default, not an optional add-on.
Use a fixed-width, sortable format
HH:MM:SS.microseconds is both readable and sortable. If you include the date, YYYY-MM-DD HH:MM:SS.microseconds sorts lexically and chronologically, which is great for log analysis tools and manual inspection.
H2: Common pitfalls in quick scripts
Quick scripts are where time bugs often hide. Here are a few easy mistakes I’ve seen in real scripts:
- Creating time strings with
+concatenation and forgetting padding. - Mixing
datetime.now()andtime.time()within the same function. - Assuming the microsecond value is always unique in a loop.
- Printing times from multiple threads without consistent snapshots.
The fixes are all small, but they require intention. If you adopt a helper function early, you eliminate most of these pitfalls.
H2: Expanded examples for clarity
To make the concepts concrete, here are two more examples with slightly different styles.
Example 1: Explicit attribute capture
from datetime import datetime
now = datetime.now()
hour = now.hour
minute = now.minute
second = now.second
microsecond = now.microsecond
print(f"{hour:02d}:{minute:02d}:{second:02d}.{microsecond:06d}")
Example 2: Compact formatting helper
from datetime import datetime
def formatted_time() -> str:
now = datetime.now()
return f"{now:%H:%M:%S}.{now.microsecond:06d}"
print(formatted_time())
Both are valid. I lean toward the helper if the output is used in multiple places.
H2: When you should avoid printing microseconds
This might sound contradictory, but there are times when microseconds add more noise than value. If your logs are meant for high-level operations staff who only need minute-level visibility, the extra precision can obscure the signal. In those cases I omit microseconds and keep a separate structured log or trace for deeper analysis.
This is less about correctness and more about audience. The correct format is the one that helps the people reading it.
H2: Wrapping up the expanded view
Printing the current hour, minute, second, and microsecond is a small task with outsized impact. The moment you start debugging or logging real systems, the details matter: capture once, format consistently, and know whether you’re working in local time or UTC. That alone prevents most of the time-related confusion I see in scripts.
If you want a single takeaway, it’s this: use datetime.now() to capture a snapshot, and never slice time across multiple calls. Add padding to keep your output consistent, and treat microseconds as a precision label rather than a promise of exact timing. With those habits, your time prints become reliable building blocks instead of fragile helpers.
If you want, I can also help turn this into a short tutorial series with exercises, or convert the snippets into a small package with tests and a CLI. Just say the word.
