This blog has a really interesting assortment of articles on mathematics and programming. You can use the tags to your right to find topics that interest you, or you may want to have a look at

- the problems I wrote to get your brain working;
- some twitter proofs of mathematical facts.

You can also subscribe to the blog newsletter.

A short article with all you need to know about sequence indexing in Python – and a bit more.

Two doors, one gives you eternal happiness and the other eternal sadness. How can you pick the correct one?

If you need to access the items of an iterable but also keep
track of their indices, have you considered using `enumerate`

?
Let's talk about another of Python's amazing tools to work
with `for`

loops.

Syncro is a beautiful game where you have to unite all the petals in a single flower. In how many moves can you do it?

In part 4 of this series we add some unit testing,
improve our tokenizer and implement the primitives `⍴`

and `⍤`

.

10500

`for`

loops are the bread and butter of imperative programming
and Python has some really nice tools to work with them.
If you want to traverse several structures in parallel,
have you considered using `zip`

?

A waiter at a restaurant gets a group's order completely wrong. Can you turn the table to get two or more orders right?

Structural pattern matching is coming in Python 3.10 and
the previous Pydon't explored some interesting use cases
for the new `match`

statement.
This article explores situations for which `match`

isn't the answer.

In the fourth article of this short series we will apply our neural network framework to recognise handwritten digits.

Structural pattern matching is coming in Python 3.10 and this article
explores how to use it to write Pythonic code,
showing the best use cases for the `match`

statement.

A bunch of ants are left inside a very, very, tight tube, and they keep colliding with each other and turning around. How long will it take them to escape?

The third article of this short series concerns itself with the implementation of the backpropagation algorithm, the usual choice of algorithm used to enable a neural network to learn.

In the second article of this short series we will create a class for a generic neural network and we will also see how to assess the quality of the output of a network, essentially preparing ourselves to implement the backpropagation algorithm.

This is the first article in a series to implement a neural network from *scratch*.
We will set things up in terms of software to install, knowledge we need,
and some code to serve as backbone for the remainder of the series.

Python's comparisons operators can be chained to shorten
common comparison expressions.
Learn the ins and outs of comparison operator chaining
and especially the cases you should *avoid*,
namely those where you chain comparison operators that aren't aligned.

Deep unpacking (or nested unpacking) provides a more powerful way for you to write assignments in your code. Deep unpacking can be used to improve the readability of your code and help protect you against unexpected bugs. Learning about deep unpacking will also be very important in order to make the most out of the structural matching feature that is to be introduced in Python 3.10.

You are sunbathing when you decide to go and talk to some friends under a nearby sun umbrella, but first you want to get your feet wet in the water. What is the most efficient way to do this?

Recursion is a technique that you should have in your programming arsenal, but that doesn't mean you should always use recursion when writing Python code. Sometimes you should convert the recursion to another programming style or come up with a different algorithm altogether.

All Python objects can be used in expressions that should
return a boolean value, like in an `if`

or `while`

statement.
Python's built-in objects are usually Falsy (interpreted as `False`

)
when they are “empty” or have “no value” and otherwise they
are Truthy (interpreted as `True`

).
You can define this behaviour explicitly for your own
objects if you define the `__bool__`

dunder method.

This problem is a step up from Problem #028 - hidden key. Can you tackle this one?