The Python zip function is a clever analogy of a real zipper: It allows you to iterate over multiple arrays element-wise without having to worry about indices. It is quite handy when you have to manually pair elements coming from two (or more) data sources:

>>> scoreList = [5, 3, 6, 8]
>>> playerList = [‘Mary’, ‘John’, ‘Emma’, ‘Gavin’]
>>> list(zip(scoreList, playerList))
# [(5, ‘Mary’), (3, ‘John’), (6, ‘Emma’), (8, ‘Gavin’)]

Please note the list() call is needed to convert the result to a list, otherwise it returns something like

>>> zip(scoreList, playerList)
# <zip object at 0x109b19d00>

which is an object implementing the iterator interface. Why the hassle with this object? Why is it not just a list? The iterator interface allows lazy-evaluation, meaning it won’t create a list, only if it’s asked. This object instead allows generating elements on-demand, which can be more efficient. Let’s say I want to find the first player with score 6:

for score, player in zip(scoreList, playerList):
 if score == 6:
 print(f’player {player} has score 6')
 break

In this case, the iteration stops with ((6, ‘Emma’)) and the last pair ((8, ‘Gavin’)) would never be constructed.

The implementation is quite interesting, because zip not only works with two lists, it can more than two arrays as input parameters. This can be particularly useful when trying to transpose a list of lists (a matrix). If you’re not familiar with the term transpose, it simply means a list of list is simply flipped by its diagonal. The transposition of

[
 [1, 2, 3],
 [4, 5, 6],
 [7, 8, 9]
]

is

>>> list(zip(*[
… [1, 2, 3],
… [4, 5, 6],
… [7, 8, 9]
… ]))
[
 [1, 4, 7],
 [2, 5, 8],
 [3, 6, 9]
]

What happens if the input arrays do not have the same length? According to the Python docs, it stops when the shortest input iterable is exhausted, meaning it will return as many elements as long the shortest array is:

>>> list(zip([1, 2, 3], [4, 5]))
[(1, 4), (2, 5)]

If all elements need to be returned, itertools.zip_longest should be used.

And just to spice things up the little, let me mention that as the zip function expects iterables as input, not specifically arrays. Iterables are more generic than arrays, without going too much into the details, they are objects that can be iterated over one element at the time, and they can signal if they are exhausted (iteration finished). In practice, it means that any object that can be iterated over can be used as inputs of zip: tuples, sets, dictionaries, range, or even results of other zips. Mind-blowing, right? 🤯 It is also possible to create an infinite zip. Let me use itertools.count to demonstrate it. It is very similar to range() except it has no stopping criteria, so if it is used in a for loop it keeps yielding values unless it is stopped.

>>> for a, b in zip(itertools.count(start=0, step=2), itertools.count(start=1, step=2)):
… print(a, b)
1 2
3 4
5 6
…

I really hope I could convince you by now, how cool and versatile this Python standard library function is. Why can’t we have nice things in JavaScript? Well we can, you just probably end up hunting for third-parties on npm or ready-made solutions on Stack Overflow. But is there anything more satisfying than using your home-grown utilities? You can find it out on my website.

Recently I came across several sites that showed a warning or paywall because I was using incognito mode. I think it is unfair. I should be allowed to use whatever browser and mode I want. This is a way to enforce their tracking tools. I know that incognito is not safe but it’s the bare minimum you can do to avoid ads to track you.

The whole thing took me about two hours and I learned a lot about browser extensions and hacking client-side code as an end user. I thought this might be worth sharing.

First, I had to look up how to detect private mode. As per my best knowledge, there’s no browser API to detect private mode directly, so I was pretty sure it is a sneaky little script. This StackOverflow answer gave me a hint, so I knew I’d have to look for webkitRequestFileSystem. I found this bit in one of those private loathing sites’ minified JavaScript code. Here’s the exciting part:

I could test the module by pasting it in incognito and public browser window dev console and run:

var module = {};
incognito(null, module);
module.exports.detectIncognito().then(console.log)

Bingo! This is it, I just have to find a way not to call the error callback in window.webkitRequestFileSystem(..). The easiest way is to monkey patch the function:

(function(webkitRequestFileSystem) {
  window.webkitRequestFileSystem = function(t, s, success, error) {
    webkitRequestFileSystem(t, s, success, success);
  }
})(window.webkitRequestFileSystem);

If you’re not familiar with the technique, monkey patching is a way to add, modify, or suppress the default behavior of a piece of code at runtime without changing its original source code.

Detour 1: First I started writing my own chrome extension using Extensionizr. It’s a great tool generating Chrome extension boilerplate code. But in the end, I found an easier solution.

Whenever it comes to customizing websites I use Tampermonkey (for example hiding job ads on Stack Overflow when I really shouldn’t spend time on looking for new positions). You don’t have to install a n+1th extension, and it provides a nice interface to manage your scripts. Ok, nice is probably an exaggeration, it’s ugly but handy.

So I added the monkey patch script I referenced above, already giggling how easy it was, but bummer, it didn’t work. I tried a few other things for example:

window.foobar = 'baz';

But in the dev console, this property was absent from the window variable. It turned out content scripts are running in an isolated environment, they only share the DOM with the webpage’s scripts. I started to work with the referenced solution from SO. There was one very important thing though, I had to execute this code before the current page’s code. Here’s what I came up with:

function injectScript(file_path, node) {
        var element = document.createElement('script');
        element.setAttribute('type', 'text/javascript');
        element.setAttribute('src', file_path);
        element.setAttribute('async', false);
        node.appendChild(element);
}
injectScript(url, document.documentElement);

Detour 2: As I started with an extension, loading another JavaScript file was trivial. However it’s not the case with Tampermonkey scripts (at least I don’t know about it). So I decided to put my code in a GitHub gist, and tried to load the raw file. But then the browser was complaining about its MIME type. Finally I ended up using https://rawgit.com/, which was exactly the right tool for this.

I realized that I should add those few lines of monkey patch code as a string, and fill in the script element’s text with that. Here’s my final solution:

An important thing to know if you work with Tampermonkey in incognito mode: your changes made in incognito mode won’t appear in normal mode, and vice versa: you have to close all your private windows if you want to try your latest changes made in public mode.

Be careful! If you decide to use my script, you have to know that this might (although not very likely) break some web pages. You can always turn these off in Tampermonkey. Use it at your own risk.

How to outsmart incognito block was originally published in We’ve moved to freeCodeCamp.org/news on Medium, where people are continuing the conversation by highlighting and responding to this story.

I faced an interesting challenge at work the other day. I felt like sharing because it might save a few hours for others, or reveal some insights about the Python internals.

There was a function which takes an object (let’s call it Foo) as an argument. I knew how the serialized object looks like, I had it in JSON format. Setting up the whole Python environment and provisioning the database looked like too much trouble, so I decided to restore the original object based on the JSON response. There must be a way, right?

It was pretty straightforward to parse the JSON as an object (of objects). What the following piece of code does it basically recursively turns each dict of the JSON into an object where the properties serve as the keys of the original dict. (Credits to this SO answer)

So far so good, but there was a surprise in the function I wanted to run:

Wait a minute. So this code expects a dictionary in some cases.. What to do now? I was sure about one thing: I don’t want to implement my own JSON parser. Of course I could write a more elaborate object_hook callback function instead of that lambda, but it felt like I’d micromanage things that way. Why not parse it as it is, then align it for the requested format? It’s easy to convert a named tuple to a dict with the ._asdict() call. So I tried

foo.bar.bazs = foo.bar.bazs._asdict()

But of course it raised an AttributeError, since namedtuples are immutable.

Ok, so I googled “mutable namedtuple” and this SO answer suggested me to use recordclass. How cool is this? It overcomes the standard library’s limitation. The only downside is that it’ll be another dependency. Well not quite the only one, as we’ll see. I tried to run the original function:

And it turns out the keys are meant to be objects, not just the ids of those objects. Luckily my JSON response also contains a list of baz objects. So I could just create a dict from them:

This raises an error saying that type: ‘X’ is unhashable. What is hashability? From the Python Glossary:

hashable

An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__() method), and can be compared to other objects (it needs an __eq__() or __cmp__() method). Hashable objects which compare equal must have the same hash value.

Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.

All of Python’s immutable built-in objects are hashable, while no mutable containers (such as lists or dictionaries) are. Objects which are instances of user-defined classes are hashable by default; they all compare unequal (except with themselves), and their hash value is derived from their id().

So this is not an Excalibur. Namedtuples are immutable for a reason. their hash value is based on their property value’s hash value, and it never changes. Note: Namedtuples are only hashable if their property values are hashable. See:

(The dict object is mutable, therefore it’s not hashable => the namedtuple is not hashable).

It is possible to compare recordclass objects, and it works nicely, however the hash value is for the object’s entire lifetime. For instance you expect

to work, but that’s granted by the namedtuple’s immutable nature. The two separate instances point to the same value.

I could have somehow automagically combine these mutable and immutable data structures together, in the json.loads’s object_hook, but again, it seemed like too much work.

I recently finished a book called Fluent Python and I remembered there was a code recipe for a nametuple like object:

fluentpython/example-code

so this returns an object, which is hashable by default (according the glossary), and mutable.

I tried to run the code, no luck as it lacks of the method _asdict(). I could quickly fix this by adding the following method:

This is all good, made my code run. Of course, the hash function is not working as expected. But that’s not too hard to fix. Since most of my objects had an id property, we can say that two objects are equal if their id’s are the same. If there’s no id, we can still rely on the Python object id:

Of course this implementation won’t account for property changes, but we can make this assumption that two instances are equal if they have the same id (or object id).

I hope you enjoyed this reading. If something’s unclear or I missed something, feel free to reach out to me.