tips.txt

Python tips from "Compiling to Python"

1. local names are faster for repeated use.
    variable names in Python can be:
      - local to a functionn
      - global to a module
      - builtin Python
    names that are 'local to a function' are faster
    to access than builtins.

Hence,

```python3

def func():
    print(str(3))

    to_str = str
    print(to_str(3)) # faster
```

2. one of the best way of creating strings is from a
  list of strings, and then joining them.

3. calling a method on an object is executed in two
  steps e.g

```python3
result = []
result.append("hello")
result.append("dude")
```
  i. **append** is fetched from the **result** object
  ii. the value fetched is invoked as a function by
      passing "hello" as its argument.

  An optimization principle to shave off the time required
  by the first step is:

```python3
result = []
result_append = result.append

result_append("hello")
result_append("dude")
```

4. **exec** is a Python builtin function. Here is how it
   works:

```python3

python_source = """\
SEVENTEEN = 17

def three():
    return 3

"""

global_namespace = {}
exec(python_source, global_namespace)

# global_namespace["SEVENTEEN"] return 17

```

5. Argument unpacking

   `*contexts` argument in the function below denotes that
   all postional arguments will be packed into a tuple and
   passed in as `contexts`.

```python3

def template(text, *contexts):
    context = {}
    for c in contexts:
        context.update(c)
    return context

t = template("dude")
t = template("dude", {"lower":str.lower})
t = template("dude", {"lower":str.lower}, {"upper":str.upper})

```

6. Closure

   These are functions that refer to variables outside of
   theirself. Consider:

```python3
class CodeBuilder:
    def __init__(self):
        self.code = []

    def add(self, line):
        self.code.append(line+'\n')


code = CodeBuilder()
buf = []
def flush_output():
    if len(buf) == 1:
        code.add("single(%s)" % buf[0])
    elif len(buf) > 1:
        code.add("multiple(%s)" % ",".join(buf))
    del buf[:]  # delete the contents of :buf:
```

:func flush_output: is a closure as it accesses :buf:
and :code: which are defined outside its body.

The similitude of the code above is a micro-optimization
logic used in the code generation phase of a template
engine design.

Strings are added to :buf: and the
:func flush_output: will make an appropriate decision
based on the length of :buf: when it is called.