Python on XGUGENG

Connection Pool in redis-py

Fri, 18 Jan 2019 10:52:17 -0800

A typical example of using Collection Pools in redis-py is:

pool = redis.ConnectionPool(host='localhost', port=6379, db=0)
r = redis.Redis(connection_pool=pool)

Weak References

Mon, 05 Nov 2018 20:46:15 +0800

In Python, objects are never explicitly destroyed. However, they may be garbage-collected when they become unreachable.

The del statement deletes names, not objects. An object may be garbage collected as result of a del command, but only if the variable deleted holds the last reference to the object, or if the object becomes unreachable.

In CPython, the primary algorithm for garbage collection is reference counting. Essentially each object keeps count fo how many references point to it. As soon as that refcount reaches 0, the object is immediately destroyed: CPython calls the __del__ method on the object (if defined) and the frees the memory.

But sometimes, it is useful to have a reference to an object that does not keep it around longer than necessary. Week references to an object do not increase its reference count. A weak reference does not prevent the referent from being garbage collected.

Variables Are Labels, Not Boxes

Thu, 01 Nov 2018 14:51:40 +0800

Variables are labels, not boxes. Take the following code for example:

a = [1, 2, 3]
b = a
a.append(4)
print(b)

If you imagine that variables are like boxes, you cannot make sense of assignment in Python. For an assignment, you must always read the right-hand side first: that’s where the object is created or retrieved. After that, the variable on the left is bound to the object, like a label stuck to it. Just forget about the boxes.

When Python Executes Decorators

Mon, 29 Oct 2018 14:55:25 +0800

A key feature of decorators is that they run right after the decorated function is defined. This is usually at import time.

Design Patterns with First-class Functions

Sat, 27 Oct 2018 16:16:13 +0800

Design patterns are language-independent, but in the context of languages with first-class functions, it’s beneficial to rethink some patterns. The general idea is: you can replace instances of some participant class with simple functions, reducing a lot of boilerplate code.

In this post, I will refactor Strategy using functions objects.

A List Comprehension Puzzler

Wed, 24 Oct 2018 11:19:09 +0800

Sometimes, we need to initialize a list with a certain number of nested lists, for example, a list with 3 lists of length 3 that can represent a Tic-tac-toe board.

>>> board = [[''] * 3] * 3
>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>> board[1][2] = 'X'
>> board
[['', '', 'X'], ['', '', 'X'], ['', '', 'X']]

The output is not expected, why?

Using Mixins with Python

Thu, 18 Oct 2018 08:15:29 +0800

Python supports multiple inheritance, while it doesn’t provide the syntax for interface. See PEP-0245. Of course, you can use the abc module for abstract base classes, which seems tricky.

Python introduces a concept called mixin that encapsulates behavior that can be reused in other classes. It’s supported via multiple inheritance, the difference of inheritance and mixin is, inheritance means “is-a” and mixin means “has-a”.

This post will illustrate how mixin works with a simple example.

Special Methods in Python Data Model

Tue, 16 Oct 2018 15:19:05 +0800

You can think of the Data Model as a description of Python as a framework. It formalizes the interfaces of the building blocks of the languages itself, such as sequences, iterators, functions, classes, context managers and so on.

Python allows operator overloading, which let us to define the custom behavior for a class. For instance, if a class defines a __str__(), then it can return a readable string representation of an object.

In this post, I will enumerate some special methods that can change the behavior of an object and may putted into practice in daily work.

Managing Ordered Sequences With bisect

Mon, 24 Sep 2018 14:16:14 +0800

The bisect module offers two main functions - bisect and insort - that use the binary search algorithm to quickly find an d insert items in any sorted sequence.

Python Closure

Wed, 19 Sep 2018 18:38:29 +0800

A closure is a function with an extended scope that encompasses non-global variables but not defined there. It does not matter whether the function is anonymous of not, what matters is that it can access non-global variables that are defined outside of its body.

Handling Missing Keys in Python

Mon, 27 Aug 2018 14:50:08 +0800

In line with fail-fast philosophy, dict access with d[k] raises an error if k is not an existing key. A common solution is d.get(k, default) which return a default rather handling KeyError if k is not present.

This post introduces three alternatives - setdefault, defaultdict and __mising for this situation.

Unpacking in Python

Tue, 14 Aug 2018 20:02:15 +0800

Python provides many friendly advanced API for programmer, one of which is unpacking. By unpacking, it means getting all the elements from a container. A simplest case in the below demonstrates assigns the two items in tuple to variables.

>>> a, b = (1,2)
>>> a
1
>>> b
2

Besides tuple, every iterative object can support unpacking, such as list, dictionary, set, string, generator etc. Let’s traverse them one by one.

Variable Scope Rules in Python

Sun, 29 Oct 2017 15:44:51 +0800

What’s the output of the following code:

ans = []
def bt():
    for i in range(3):
        ans += [i]

bt()
print(ans)

Understanding Python Decorator

Wed, 20 Sep 2017 19:36:07 +0800

A Python decorator, similar with Decorator Pattern, is a specific change to the Python syntax that allows us to more conveniently alter functions and methods. In this post, I will try my best to deep into this advanced feature in Python.

*args and **kwargs Usage in Python

Fri, 08 Sep 2017 16:46:50 +0800

The *args and **kwargs is a common idiom to allow arbitrary number of arguments to functions as described in the section more on defining functions in the Python documentation.

When finally Really Executes

Mon, 04 Sep 2017 16:22:03 +0800

Epitome:

return doesn’t really return, it pushes value to stack, then jumps to finally, which was set up by SETUP_FINALLY before.
after executing finally, END_FINALLY returns.

Exit Options in Python

Fri, 01 Sep 2017 16:47:37 +0800

First candidate is os._exit, which exits without calling cleanup handlers, flushing stdio buffers, etc. (and which should normally only be used in the child process after a fork()).

Second, sys.exit is intended for use in programs. According to official document:

This is implemented by raising the SystemExit exception, so cleanup actions specified by finally clauses of try statements are honored, and it is possible to intercept the exit attempt at an outer level. Since exit() ultimately “only” raises an exception, it will only exit the process when called from the main thread, and the exception is not intercepted.

The Difference between range and xrange

Fri, 01 Sep 2017 16:22:27 +0800

Short answer:

range creates a list, so if you do range(1, 10000000) it creates a list in memory with 9999999 elements. This will become an expensive operation on very large ranges.
xrange is a sequence object that evaluates lazily(it will only compute the next value when needed).

A Dive into slots

Thu, 31 Aug 2017 14:25:37 +0800

__slots__ tells the interpreter not to use a dict, and only allocate space for a fixed set of attributes.

Pip Install ipython Exception on EI Capitan

Thu, 03 Aug 2017 15:23:36 +0800

For those impatient: OS X EI Capitan shipped a security feature named System Integrity Protection, which would be a hinder for pip. Try to install IPython in user mode: pip install ipython --user.