The approach will be:<\/p>\n
- \n
- Get a dataset<\/a> with daily sunrise and sunset information.<\/li>\n
- Calculate daylight and dark duration for each day.<\/li>\n
- Plot the result.<\/li>\n<\/ol>\n
Since exact times vary depending on latitude, I’ll pick a city near the center of the U.S.\u2014Lincoln, Nebraska.<\/p>\n
\n1. Get a dataset<\/h4>\n
The CSV dataset looks like this. Notice that date and time are stored in separate columns. We’ll have to address this when we convert timestamps into datetime types.<\/p>\n
date,sunrise,sunset\r\nJan-01-2021,07:51:37,17:09:58\r\nJan-02-2021,07:51:42,17:10:49\r\nJan-03-2021,07:51:46,17:11:42\r\n.\r\n.\r\n.<\/pre>\n
Begin by reading the CSV into a pandas<\/em> DataFrame. Let’s skip converting the date <\/em>column into a datetime format for now. It will be easier to manipulate it as a string.<\/p>\n
import pandas as pd\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib.dates import MonthLocator, DateFormatter\r\nfrom matplotlib.offsetbox import OffsetImage, AnnotationBbox\r\n\r\ndf = pd.read_csv(\"lincoln_sunrise_sunset_2021.csv\")<\/pre>\n
Create two new columns to hold sunrise and sunset datetimes. This is done by concatenating each day’s date and time strings together, then converting type to
datetime<\/code>.<\/p>\ndf.loc[:, \"sunrise_datetime\"] = pd.to_datetime((df[\"date\"] + \" at \" + df[\"sunrise\"]))\r\ndf.loc[:, \"sunset_datetime\"] = pd.to_datetime((df[\"date\"] + \" at \" + df[\"sunset\"]))<\/pre>\n
Now the DataFrame’s
head()<\/code> anddtype<\/code> look like this. The original columns are stillobject<\/code>, i.e. string, and the new columns aredatetime64<\/code>.<\/p>\ndate sunrise sunset sunrise_datetime sunset_datetime\r\n0 Jan-01-2021 07:51:37 17:09:58 2021-01-01 07:51:37 2021-01-01 17:09:58\r\n1 Jan-02-2021 07:51:42 17:10:49 2021-01-02 07:51:42 2021-01-02 17:10:49\r\n2 Jan-03-2021 07:51:46 17:11:42 2021-01-03 07:51:46 2021-01-03 17:11:42\r\n3 Jan-04-2021 07:51:47 17:12:36 2021-01-04 07:51:47 2021-01-04 17:12:36\r\n4 Jan-05-2021 07:51:46 17:13:32 2021-01-05 07:51:46 2021-01-05 17:13:32\r\n\r\ndate object\r\nsunrise object\r\nsunset object\r\nsunrise_datetime datetime64[ns]\r\nsunset_datetime datetime64[ns]<\/pre>\n
2. Calculate daylight and dark hours<\/h4>\n
Remember the goal is to plot duration<\/strong> of day and night, not sunrise and sunset times. To get this information we’ll need to subtract the new columns. Daylight hours can be calculated by subtracting sunrise from sunset. And since every day is 24 hours long, we can get dark hours by subtracting daylight hours from 24.<\/p>\n
df.loc[:, \"daylight_hours\"] = (df[\"sunset_datetime\"] - df[\"sunrise_datetime\"]).dt.total_seconds() \/ 3600\r\ndf.loc[:, \"dark_hours\"] = 24.0 - df[\"daylight_hours\"]<\/pre>\n
With our datetime parsing out of the way, we should convert the date<\/em> column to
datetime64<\/code>. It will serve as the x-axis variable on the plot. Normally you would do this conversion insideread_csv<\/code> by including aparse_dates<\/code> argument, but this method works as well.<\/p>\ndf[\"date\"] = pd.to_datetime(df[\"date\"])<\/pre>\n
\n3. Plot the result<\/h4>\n
Now we can plot the data like this:<\/p>\n
- \n
- x-axis\n
- \n
- date<\/li>\n<\/ul>\n<\/li>\n
- y-axis\n
- \n
- daylight_hours<\/li>\n
- dark_hours<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
I created a custom
mplstyle<\/code> for this plot based on Joey Politano’s work<\/a>. It will be linked at the bottom of this post.<\/p>\nThere are a few different approaches but
plt.subplots<\/code> is a good way to begin Matplotlib<\/em> code. It returns figure<\/em> and axes<\/em> objects, which is convenient because you’ll often need to reference them later. It also accepts parameters likefigsize<\/code>, although I set a default size withinmplstyle<\/code> so it won’t be necessary here.<\/p>\nPass the appropriate DataFrame columns to
ax.plot<\/code>. Include label arguments so a legend can find them later.<\/p>\nplt.style.use(\"wollen_dark-blue.mplstyle\")\r\nfig, ax = plt.subplots()\r\n\r\nax.plot(df[\"date\"], df[\"daylight_hours\"], label=\"Daylight Hours\")\r\nax.plot(df[\"date\"], df[\"dark_hours\"], label=\"Dark Hours\")<\/pre>\n
Matplotlib<\/em> has a few handy built-in tools for plotting dates.
MonthLocator<\/code> finds the first day of every month and places a tick there (or any other day-of-month you’d like). You have other options likeWeekdayLocator<\/code> andHourLocator<\/code> as well.<\/p>\nDateFormatter<\/code> accepts a datetime string format and applies it to every tick label.%b<\/code> represents an abbreviated form of month, e.g. “Jan” for January. I also include%y<\/code>, which is the shortened two-digit form of year. The rightmost x-tick will be January 2022\u2014the next year\u2014so it will be helpful to include year information.<\/p>\nax.xaxis.set_major_locator(MonthLocator())\r\nax.xaxis.set_major_formatter(DateFormatter(\"%b '%y\"))<\/pre>\n
In situations where you don’t want to customize font, size, and so on, you can pass several arguments to
ax.set<\/code>.<\/p>\nFor example, we could write
ax.set_xlim<\/code> and on the next lineax.set_ylim<\/code>, but it’s a bit cleaner to include both in a single method.<\/p>\nax.set(xlim=(pd.Timestamp(\"Dec 20 2020\"), pd.Timestamp(\"Jan 12 2022\")),\r\n yticks=range(8, 18),\r\n ylim=(7.8, 17.0),\r\n ylabel=\"Hours\",\r\n title=\"Lincoln, Nebraska | Daylight Hours | 2021\")<\/pre>\n
A legend will be helpful on this plot, even though we’ll identify the lines with images in a moment.<\/p>\n
The legend’s location is “upper center”. This could equivalently be written as
loc=9<\/code>.<\/p>\nYou can probably guess that
ncol<\/code> defines number of columns. With its default value of 1, the legend entries would be stacked vertically. I think a horizontal orientation looks nicer on this plot.<\/p>\nplt.legend(loc=\"upper center\", ncol=2)<\/pre>\n
Now I’d like to add a couple images to the plot. I created very simple sun and moon clipart to identify the two curves\u2014the same images featured at the top of this post.<\/p>\n
This can be accomplished by passing an
OffsetBox<\/code> into anAnnotationBbox<\/code>. I understand no one wants to hear me break this down more than necessary so I’ll link to an official Matplotlib demo<\/a> for anyone interested in learning more.<\/p>\nIt isn’t necessary to structure the code as a loop, especially if you plan to overlay only a single image. But I find it convenient to abstract images and their xy-coordinates away from the heavy lifting.<\/p>\n
image_list = [(pd.Timestamp(\"Jan 10 2021\"), 8.9, \"sun.png\"),\r\n (pd.Timestamp(\"Jan 10 2021\"), 15.0, \"moon.png\")]\r\n\r\nfor x_pos, y_pos, path in image_list:\r\n ab = AnnotationBbox(OffsetImage(plt.imread(path), zoom=0.07), (x_pos, y_pos), frameon=False)\r\n ax.add_artist(ab)<\/pre>\n
The
zoom<\/code> parameter above is important. The output will look much better if you use a normal resolution image, e.g. 500×500 pixels, along with a smallzoom<\/code> argument, rather than attempting to shrink the image before plotting.<\/p>\nSet
frameon=False<\/code> so Matplotlib<\/em> will respect transparency.<\/p>\nAs always I suggest saving in vectorized SVG format whenever possible. If you need a raster image, it will help to increase
dpi<\/code> from its default of 100. Doing so will provide an anti-aliasing effect, i.e. fewer jaggy stairstep edges, which is especially important when adding images to a plot.<\/p>\nplt.savefig(\"daylight_2021.png\", dpi=200)<\/pre>\n
The output:<\/p>\n
![\"\"](\"https:\/\/wollen.org\/blog\/wp-content\/uploads\/2021\/10\/daylight_2021-1.png\")
<\/a><\/p>\n