Question: I am trying to build my first project using an existing sqlite database in Android Studio. All of the instructions I have referenced say to create an assets folder and copy the database into that folder. A call from the database helper will move the file for me for run time testing. The problem is that when the database is in the assets folder and I click on the plus sign next to the folder, Android studio immediately halts, closing all windows and displays no error. I am running studio 3.01 build #AI-171.4443003 dated 11/9/2017. I have applied all updates and the results are the same. I have tried using different extension for the DB with no luck.

Answer: 
```
spam = print('Hello!')

```

evaluates the expression on the right hand side and binds its value to `spam`. The return value of the (Python 3) `print()` function is `None`, so `spam` refers to `None`:

```
>>> spam = print('Hello!')
Hello!
>>> spam is None
True

```

One way to handle this is to create a partial function with `functools.partial()`:

```
>>> from functools import partial
>>> spam = partial(print, 'Hello!')
>>> spam
functools.partial(<built-in function print>, 'Hello!')
>>> spam()
Hello!

```

Or a `lambda` expression:

```
>>> spam = lambda : print('Hello!')
>>> spam
<function <lambda> at 0x7f619cabf9d8>
>>> spam()
Hello!

```

Essentially both of the above use a closure around a function like this:

```
def printer(s):
    def f():
        print(s)
    return f

>>> spam = printer('Hello!')
>>> spam
<function printer.<locals>.f at 0x7f619cabfb70>
>>> spam()
Hello!

```
A function, depending on how that function is written, may or may not have an explicit return value. It's up to the author of the function to decide how he wants to implement his function. A function with an explicit return value must have a `return` statement in it. The `return` statement causes the function to end and for the value following the `return` statement to be "returned" to the calling code. When a function reaches the end of its code without an actual `return` statement, it's like there's an implicit `return None` at the end. So...

```
def is_5(num):
    if num is 5:
        return True

```

What happens above? If num is 5, the function returns the boolean value of True. But if num is not 5, there is no final `return` statement, so the implicit `None` is returned. 

As to your question, there is also a difference between the "name" of a function and invoking the function. In our example above, the "name" of the function is `is_5`, and we invoke it by following the name of the function with parentheses. If there are no parentheses following the function name, then the function name is just like any other variable, only it happens to hold a reference to a function. When you follow it with parentheses, that causes the function to be invoked. This is why we can call

```
is_5(2+3)

```

but we can also say:

```
myfunc = is_5
myfunc(2+3)

```

and get the same exact result. As for `lambda` and `functools.partial`, both are used to create what are known as "nameless" functions -- they return a reference to a function, but that function has no name. You can capture the return from either of those and store it in a variable. Then, you can invoke the function by following the name of the variable with parentheses, just like above. Keep in mind that the function does not get run till it's invoked using parentheses. So, for example:

```
mylambda = lambda x: True if x is 5 else None
mylambda(1+4)

```

Having said all this, regarding your question, the variable `spam` gets whatever the return value, if any, of the `print()` function returns. `print()` has no return value, so `spam` gets assigned the value `None`. If you wanted to assign a reference to the print function to `spam`, you could say:

```
spam = print

```

And then later you could say

```
spam("Hello!")

```

and you would get your "Hello!" string printed to the screen at that time.

Also, having a return value and printing strings to the screen or terminal are two different things. A function could do both or neither of those things and still be a useful function. It all depends on what the coder was trying to accomplish.