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

```{code-cell} python3

```{code-cell} python3

```{code-cell} python3

```{code-cell} python3

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

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

We can also find `f` our current namespace

```{code-cell} python3

Modules loaded into memory are also treated as objects

```{code-cell} python3

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

```{code-cell} python3

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

```{code-cell} python3

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

```{code-cell} python3

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.*