Question

Create a file called zoo.py. In it, define a function called hours () that prints the string 'Open 9-5 daily'. Then, use the interactive interpreter to import the zoo module and call its hours () function.

Short answer

Create `zoo.py`, define `hours()`, open the interpreter, import `zoo`, and call `hours()`. Output: 'Open 9-5 daily'.

Step-by-step solution

Create a File

Create a new Python file named `zoo.py`. You can do this by opening a text editor, writing the content, and saving it with the `.py` extension.

Define the Function

In the `zoo.py` file, define a function named `hours()` that prints the message 'Open 9-5 daily'. The code should look like this: ```python def hours(): print('Open 9-5 daily') ```

Open Interactive Interpreter

Start the Python interactive interpreter. This can be done by opening a terminal or command prompt and typing `python` or `python3` (depending on your system setup).

Import the Module

Once the Python interpreter is open, import your `zoo` module using the command: ```python import zoo ```

Call the Function

Call the `hours()` function from the `zoo` module by typing: ```python zoo.hours() ``` This should output the string 'Open 9-5 daily'.

Key concepts

Python Modules

In Python, modules are a way to organize your code for reuse and clarity. A module is essentially a file containing Python definitions and statements. By saving related functions and classes in a single file, you create a module, which can be imported into other programs. This modularity simplifies debug processes, promotes code reuse, and makes your program more maintainable.

• A module can define functions, classes, and variables.
• Modules can also include runnable code.
• The standard library in Python is a large collection of modules available for use.

The `zoo.py` file mentioned in the exercise is a classic example of a custom module. Once you've written the necessary functions within this file, you import it in your main script to use its features. This import process can be done using the `import` statement, which searches for your file, compiles it to bytecode as necessary, and makes its contents accessible to the script that imported it.

Function Definition

In Python, defining a function involves using the `def` keyword, followed by the function name and parentheses `()`. Functions encapsulate a block of code, allowing it to be executed repeatedly without rewriting the same code.

• Functions can take parameters, which allow them to be more dynamic.
• The code block within every function starts with a colon (:) and is indented.
• Functions can include a `return` statement to send a value back to the caller.

In the exercise, we defined a simple function called `hours()` inside our `zoo.py` module. This function, upon being called, executes a `print` statement to output the string 'Open 9-5 daily'. Even though it doesn't take parameters or return a value, it's a basic example of how functions are structured and utilized in Python.

Interactive Interpreter

The Python Interactive Interpreter is a tool that allows you to execute Python commands and scripts in real-time, providing immediate results. This is highly useful for testing snippets of code, debugging, and experimenting with new modules or functions.

To access the interactive interpreter, open your terminal or command prompt and type `python` or `python3`. Once inside, you can execute Python commands as you would in a script. This capability makes it a valuable tool for learning and exploration.

• It provides an easy way to test small chunks of code.
• Offers access to your custom and standard library Python modules immediately after import.
• Great for quick testing without creating a complete file.

In the context of our exercise, after you import the `zoo` module in the interpreter, you can instantly use `zoo.hours()` to call the function and verify it works as intended. This seamless interaction highlights the power and flexibility of the interactive interpreter.