60 shows up in lots
of places. It’s the smallest number divisible by 1 through 6, and perhaps
because of that, it’s the basis of our timekeeping and angular measurements.
Of course the angles in an equilateral triangle are 60 degrees. But
60 also appears in solid geometry. There are four Archimedean solids (regular
polyhedra made with any mixture of regular polygons) with 60 vertices. You can
use Nat Alison’s beautiful polyhedra
viewer to explore them:
Yesterday I did my 400th pandemic walk. These started as a way to get
exercise during lockdown with my son Nat, as I wrote about in
Pandemic walks (Feb 2021) and
300 walks (Sept 2021).
Now I’ve done 400 walks starting and ending at the same point, totaling 2318
miles:
The cadence of these walks has slowed quite a bit. Not the pace of the
walking itself, but the number of walks in a week. Nat is only with us one day
a week now, so I don’t have to be out for his sake. I have biking and swimming
as exercise options now, and my toes were getting a bit aggravated by
walking.
Quantifying the walks was a fun project, and motivated me to get out and go,
but it also pushed me to go farther and farther: in February, all the walks were
longer than 7 miles, which might not have been wise. The problem with a
statistic is the unreasonable expectation that it will constantly increase.
I’m not sure what will happen now. I’m going to continue walking as an at
least occasional exercise, but maybe with a different motivator? Or maybe not:
it’s hard to drop a project once you start it...
Now I’m going on a bike ride, and I’m not going to measure my speed.
We had a tricky debugging need at work: we wanted to track how an attribute
on an object was changing. Here’s the unusual solution we used.
The __setattr__ special method (dunder) is called when an attribute is
changed on an object. But like all special methods, it’s not found on the
object, only on the class. We didn’t want to track changes to all objects of
the class because it would produce too much noise in the logs.
So we wanted a per-object special method. The way we came up with was to
define a new class with the special method. The class is derived from the
object’s existing class, so that everything would work the way it should. Then
we changed the object’s class.
Changing an object’s class sounds kind of impossible, but since in Python
everything happens at run-time, you can just assign a new class to
obj.__class__, and now that is the object’s class.
Here’s the code, simplified:
>>> class SomeObject:
... ...
>>> class Nothing:
... """Just to get a nice repr for Nothing."""
... def __repr__(self):
... return "<Nothing>"
>>> obj = SomeObject()
>>> obj.attr = "first"
>>> obj.attr
'first'
>>> def spy_on_changes(obj):
... """Tweak an object to show attributes changing."""
... class Wrapper(obj.__class__):
... def __setattr__(self, name, value):
... old = getattr(self, name, Nothing())
... print(f"Spy: {name}: {old!r} -> {value!r}")
... return super().__setattr__(name, value)
... obj.__class__ = Wrapper
>>> spy_on_changes(obj)
>>> obj.attr = "second"
Spy: attr: 'first' -> 'second'
>>> obj.attr
'second'
>>> obj.another = 'foo'
Spy: another: <Nothing> -> 'foo'
One more detail: the Nothing class lets us use repr() to show an object but
also get a nice message if there wasn’t a value before.
The real code was more involved, and showed what code was changing the
attribute. This is extreme, but helped us debug a problem. As I said in
Machete-mode Debugging, Python’s dynamic nature can get us into trouble,
so we might as well use it to get us out of trouble.
You can define custom search keywords in your browser to make common searches
easier. How to do it isn’t well documented, so I’m showing you how here.
As an example, I have a custom keyword “pypi”, so I can search PyPI for a
package name by typing “pypi some name” in my browser’s address bar, and it
takes me directly to https://pypi.org/search/?q=some name.
You can create your own custom keywords to have shortcuts to all kinds of
searches. You provide a URL with a placeholder %s in it. When you type
the keyword in the address bar, the rest of the entry is plugged into the
placeholder, and you jump to the resulting URL.
Handy keywords
These are some of the custom search keywords I use. You can use them as-is,
adapt them as you need, or create your own. Instructions for creating keywords
are further down the page.
- py: Search Python docs
- https://www.google.com/search?q=site%3Adocs.python.org%20%s
- pep: Find a PEP by number
- https://peps.python.org/pep-0%s
- pypi: Find a PyPI package
- https://pypi.org/search/?q=%s
- gh: GitHub code search
- https://github.com/search?type=Code&q=%s
- gpy: Google search for Python things, but not Monty Python
- http://www.google.com/search?q=%s+python+-monty
- xlate: Translate text, auto-detecting the language
- https://translate.google.com/?sl=auto&tl=en&op=translate&q=%s
How to define a keyword in Firefox
Firefox defines custom keywords as bookmarks:
- Select Bookmarks - Manage Bookmarks from the menu to open the Library dialog.
- In the left-hand sidebar, select Quick Searches. You’ll see a handful of pre-defined searches.
- Using the gear drop-down at the top of the dialog, select Add Bookmark...
- Enter the URL of the search in the URL field. Use %s as the placeholder.
- Put the keyword you want to use in the Keyword field.
- You can give the bookmark a name to make it easier to find it later if you need to.
- Save the bookmark, and close the Library.
- Now you can use your keyword in the address bar.
How to define a keyword in Chrome
Chrome defines custom keywords as search engines in Settings:
- Select Preferences or type chrome://settings in the address bar.
- In the left-hand sidebar, select Search engine and then Manage search engines and site search.
- Scroll down to Site search.
- Click Add.
- Put a description in the Search engine field.
- Enter the URL in the URL field, with %s as a placeholder.
- Put the keyword in the Shortcut field.
- Click Add, then close the Settings tab.
- Now you can use your keyword in the address bar.
I finally came up with a way I like to create
PyCairo
drawings in a Jupyter notebook.
A few years ago I wrote here about
how to draw Cairo
SVG in a Jupyter notebook. That worked, but wasn’t as convenient as I
wanted. Now I have a module that manages the PyCairo contexts for me. It
automatically handles the displaying of SVG and PNG directly in the notebook, or
lets me write them to a file.
The module is
drawing.py.
The code looks like this (with a sample drawing copied from the PyCairo docs):
from drawing import cairo_context
def demo():
with cairo_context(200, 200, format="svg") as context:
x, y, x1, y1 = 0.1, 0.5, 0.4, 0.9
x2, y2, x3, y3 = 0.6, 0.1, 0.9, 0.5
context.scale(200, 200)
context.set_line_width(0.04)
context.move_to(x, y)
context.curve_to(x1, y1, x2, y2, x3, y3)
context.stroke()
context.set_source_rgba(1, 0.2, 0.2, 0.6)
context.set_line_width(0.02)
context.move_to(x, y)
context.line_to(x1, y1)
context.move_to(x2, y2)
context.line_to(x3, y3)
context.stroke()
return context
demo()
Using demo()
in a notebook cell will draw the SVG. Nice.
The key to making this work is Jupyter’s
special
methods _repr_svg_, _repr_png_, and a little _repr_html_ thrown in also.
The code is at drawing.py.
I created it so that I could play around with Truchet tiles:
Lately I’ve been posting Python tidbits on
Twitter. It’s been fun finding
things that people might not yet know, fitting them into a tweet, and giving
them some energy.
People ask how I make them. I tried a few “make a code screenshot” sites at
first, but wanted more control over how the images looked. Now I create the
code shots in vim with a tweaked color scheme
(shades-of-purple).
This lets me do things like highlight specific words I want to draw attention
to. Then I use the Mac screenshot tool to grab an image:
The font is Recursive Mono SemiCasual.
Recursive is a lovely and lively
variable font with a number of axes to play with, especially the Casual axis,
which I’ve set to halfway between Linear and Casual.
You can get it now on
Google Fonts. I’d
like to try using Semi-Mono, but vim only understands monospaced fonts.
Some people have asked about publishing these tidbits here on
nedbatchelder.com also, but I’m not sure it’s worth the effort. Would it be
helpful to have a page like this that
collected them per-month or something? Or one tweet per page? Or just let them
live on Twitter?
Older: