DEV Community: rkucsora

Timezones in Python datetime objects

rkucsora — Wed, 26 Jul 2023 19:51:04 +0000

I've learned something useful about Python timezone handling in datetime objects.

Let's suppose I got a timestamp from an external source. It's in a string variable now.

>>> timestamp_str = "2023-07-19T18:15:10-07:00"

Cool, it's in ISO format, let's parse it!

>>> from datetime import datetime
>>> timestamp = datetime.fromisoformat(timestamp_str)

Is it in the past?

>>> timestamp < datetime.now()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't compare offset-naive and offset-aware datetimes

What? One of these datetime objects contain timezone information, the other one doesn't. They don't play with each other nicely.

>>> timestamp.isoformat()
'2023-07-19T18:15:10-07:00'
>>> datetime.now().isoformat()
'2023-07-19T18:24:10.978546'

OK, how can I add timezone to now? I'm in Central European Summer Time (CEST) at the moment. But as I learned, it's a bit complicated. I will get back to this later, let's work with UTC, it's easier. datetime.now accepts a timezone parameter.

>>> from datetime import timezone
>>> datetime.now(timezone.utc).isoformat()
'2023-07-19T18:25:38.4567+00:00'
>>> timestamp < datetime.now(timezone.utc)
False

That's better. But can I use my own timezone here? I can, if I know what my timezone is. CEST is UTC +2. The timezone class is here to help.

>>> from datetime import timedelta
>>> timezone(timedelta(hours=2))
datetime.timezone(datetime.timedelta(seconds=7200))
>>> datetime.now(timezone(timedelta(hours=2))).isoformat()
'2023-07-19T18:31:355.529775+02:00'
>>> timestamp < datetime.now(timezone(timedelta(hours=2)))
False

But what if I don't know my timezone? How can I get the local timezone? If it's a remote host, it can be anywhere. What I found is that the datetime.astimezone() method can help here. If it gets a target timezone parameter, it converts the datetime to that timezone. If it gets nothing (or None) it uses the system local timezone.

>>> datetime.now().isoformat()
'2023-07-19T18:37:47.447466'
>>> datetime.now(timezone.utc).isoformat()
'2023-07-19T16:37:55.417677+00:00'
>>> datetime.now(timezone.utc).astimezone(timezone(timedelta(hours=2))).isoformat()
'2023-07-19T18:38:32.881836+02:00'
>>> datetime.now(timezone.utc).astimezone().isoformat()
'2023-07-19T18:39:25.116842+02:00'

Yep, I'm really in CEST. I can get that info in the tzinfo attribute.

>>> datetime.now(timezone.utc).astimezone().tzinfo
datetime.timezone(datetime.timedelta(seconds=7200), 'CEST')
>>> local_timezone = datetime.now(timezone.utc).astimezone().tzinfo
>>> datetime.now().isoformat()
'2023-07-19T18:40:56.4701'
>>> datetime.now(local_timezone).isoformat()
'2023-07-19T18:41:02.30460+02:00'

So astimezone works fine with no parameters, but I find it hard to read. I'm still looking for the really readable solution.

But here comes the next challenge, if you are still not dizzy. You read the following timestamp from a textfile.

>>> timestamp_str = "2023-07-19T18:39:25"

It doesn't contain timezone information, but you know that it's in Pacific Daylight Time. How can you add that timezone information to the datetime object?

Can datetime.astimezone help here? It not just simply adds the timezone information to the datetime, it adjusts date and time accordingly.

>>> datetime.fromisoformat(timestamp_str)
datetime.datetime(2023, 7, 19, 18, 39, 25)
>>> pdt_timezone = timezone(timedelta(hours=-7))
>>> datetime.fromisoformat(timestamp_str).astimezone(pdt_timezone)
datetime.datetime(2023, 7, 19, 9, 39, 25, tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=61200)))

This is not exactly what I wanted. It turned out that the solution is simply replacing tzinfo in the datetime object.

>>> datetime.fromisoformat(timestamp_str).replace(tzinfo=pdt_timezone)
datetime.datetime(2023, 7, 19, 18, 39, 25, tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=61200)))

Much better. Happy? Kind of. Can we just store every timestamp with timezone info added? Or everything it UTC? Thanks.

What I've learned about Python from Advent of Code day 13

rkucsora — Sat, 18 Dec 2021 19:59:27 +0000

Advent of Code puzzles are fun. I use them for learning new python features that I rarely or never use at work. Day 13 was particularly interesting.

WARNING! This article contains spoilers! If you want to solve this puzzle, stop reading, go to the advent of code page and have fun. You can back later :)

The puzzle

You can read the details on the above link, but here is a short summary:

We have a list of dots on a transparent paper (a foil).
There is a list of folding instructions: fold the paper in half along the given row or column. One half will cover the other one, and as the paper is transparent, this is some kind of a union of the two halves.

The task is to apply these folding instructions (or just one in the first part).

The learnings

Split string into variables

I learned it long ago and I use it from time to time, but it was a big wow-moment for me coming with a java background, so I think it's worth mentioning here.

You can split a string into a list with the str.split method:

coordinates = line.split(',')

It returns a list, but you can unpack it directly into variables:

x, y = line.split(',')

I used it a lot when parsing puzzle input. Of course you have to be sure about how many parts the original string has, or you risk a ValueError at runtime. The split method also has a maxsplit argument that can prevent such an error, but in my opinion input validation is a better idea in a real world scenario.

Partially applied functions

I wanted to try this for so long, I even changed my solution a bit to be able to use it.

I created two functions for the folding operations.

def fold_horizontally(fold_row: int, dots: set[tuple[int, int]]) -> set[tuple[int, int]]:
  ...

def fold_vertically(fold_col: int, dots: set[tuple[int, int]]) -> set[tuple[int, int]]:
  ...

And I parsed the fold instruction strings to a list of partially applied functions.

from functools import partial

instructions = []
while line := f.readline():
  instruction, coord = line.split('=')
  fold_func = fold_horizontally if instruction.endswith('y') else fold_vertically
  instructions.append(partial(fold_func, int(coord)))

What does it do? The partial function returns a callable object for a function and a list of arguments. The remaining arguments will be the arguments of this callable object. In my case the base function is either fold_horizontally or fold_vertically. Those functions have 2 arguments: the row or column to fold along and the list of dots. I fixed the first argument, the fold coordinate to create a partially applied function, and I put it to the instructions list. These functions have one argument (the set of dots) and they can be called like this:

  dots = instructions[i](dots)

I think this can be a quite powerful tool, I should use it more frequently.

Unicode character name

The puzzle description uses # characters for the dots which is a good ASCII character for this purpose, but unicode has better options. What about a full block █ character? Or a black large circle ⬤ ? Or a hexagon ⬢ ?

You can copy-paste it into your python code, but there is an escape sequence that I like much better. This is how I used it to print a dot in the grid:

  print('\N{FULL BLOCK}' if (col, row) in dots else ' ', end='')

The result looks like this:

 ██       █     ██  █ █   ██    ██  █  
             █         █         █     
   █       ███      ██   ███     █ █   
 ██     █ █     █   █  █ █       █     
█         █  █ █       █ █    █  █ █   
█       █      ████ █ █         █    █ 

█     ███ █  █   █   █   █     ██   █  
█    █  █ █         █            █    █
█    █ ██    █      █  █         █ █   
█    █    █  █   █    █                
█  █ █  █ █       █ █  █ █       █ █  █
██    ██  █  █ ████  █   ██ █       ██

It's cool, isn't it? :)

I really enjoyed this puzzle, I'm looking forward to my next python discoveries with Advent of Code.