We will leave this for you to explore.

## Summary

Messages in this lecture are clear:

* In Python, *everything in memory is treated as an object*.

* Zero, one or many names can be bound to a given object.

* Every name resides within a scope defined by its namespace.

This includes not just lists, strings, etc., but also less obvious things, such as

* functions (once they have been read into memory)

* modules (ditto)

* files opened for reading or writing

* integers, etc.

Consider, for example, functions.

When Python reads a function definition, it creates a **function object** and stores it in memory.

The following code illustrates further this idea

```{code-cell} python3

#reset the current namespace

%reset

```

```{code-cell} python3

def f(x): return x**2

f

```

```{code-cell} python3

type(f)

```

```{code-cell} python3

id(f)

```

```{code-cell} python3

f.__name__

```

We can see that `f` has type, identity, attributes and so on---just like any other object.

It also has methods.

One example is the `__call__` method, which just evaluates the function

```{code-cell} python3

f.__call__(3)

```

Another is the `__dir__` method, which returns a list of attributes.

We can also find `f` our current namespace

```{code-cell} python3

'f' in dir()

```

Modules loaded into memory are also treated as objects

```{code-cell} python3

import math

id(math)

```

We can find `math` in our global namespace after the import

```{code-cell} python3

print(dir()[-1::-1])

```

We can also find all objects associated with the `math` module in the private namespace of `math`

```{code-cell} python3

print(dir(math))

```

We can also directly import objects to our current namespace using `from ... import ...`

```{code-cell} python3

from math import log, pi, sqrt

print(dir()[-1::-1])

```

We can find these names appear in the current namespace now.

*This uniform treatment of data in Python (everything is an object) helps keep the language simple and consistent.*