{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Chapter 12: Importing external modules\n",
"*We use some materials from [this other Python course](https://github.com/kadarakos/python-course).*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Most of the functionality we have used thus far is built into the Python language itself. Now we have also learned how to write our own functions. Often, however, you need to use external modules in your code. A lot of external modules are already available in the Python Standard Library, for a wide variety of tasks. There are also countless third-party providers of Python modules.\n",
"\n",
"### At the end of this chapter, you will be able to:\n",
"* import an entire module\n",
"* import a specific function from a module\n",
"* use `dir` and `help` to get information about a module or function\n",
"* import a few commonly used modules: random, datetime, and requests\n",
"\n",
"**If you want to learn more about these topics, you might find the following links useful:**\n",
"* [Tutorial: The import statement](https://www.tutorialspoint.com/python/python_modules.htm)\n",
"* [Video: OS Module - Use Underlying Operating System Functionality](https://www.youtube.com/watch?v=tJxcKyFMTGo)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you have **questions** about this chapter, please contact us **(cltl.python.course@gmail.com)**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 1. Importing a module or a function"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Python modules**\n",
"\n",
"A Python module is a Python file (i.e., a file ending in .py) which contains function definitions and statements. You can already write one yourself! (More about this in the next chapter.)\n",
"\n",
"Some modules are part of the Python standard library and contain useful functions. You can import these modules and use the functions as explained below.\n",
"\n",
"More on modules can be found here: https://docs.python.org/3/tutorial/modules.html"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To use an external module in your code, you need to **import** it explicitely. Consider, for example, the module `random` from the standard library, which contains functions for generating random numbers:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import random\n",
"print(random.randint(0, 100))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note the syntax used:** using the dot, we indicate that our machine should look for the `randint()` method inside the `random` module we just imported. You can import an entire module or import only a specific function in the module. We could also have imported the (single) method we needed as follows:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from random import randint\n",
"print(randint(0, 100))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this case we wouldn't have to specify where our machine should find the `randint()` function: note that we don't need to use the module random in the function call in this case."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2. Getting help"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We might not understand how an external method works, or what input it needs, or what are the output values it returns. In that case, we can use `help()` (just as we did with functions and methods):"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"help(randint)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we like the `randint()` method, we might also be interested which other methods are offered in the `random` package. We can use `dir()` for this:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"dir(random)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" You can also (temporarily) change the names of the functions you import:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from random import randint as random_number\n",
"print(random_number(0, 100))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you want to import the entire module, it works the same way (using the syntax we have already seen above). Changing the name can be useful if we want to shorten it (as shown below)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import random as rn\n",
"print(rn.randint(0,4))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 3. Other useful modules"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There are plenty of very useful modules out there, so it is a good practice to check if someone has already created a module for a task that you are facing. Here, we'll show\n",
"\n",
"* datetime (module to manipulate dates)\n",
"* requests (module to download the content of a webpage)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.1 Datetime"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import datetime\n",
"print(datetime.datetime.now())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can decipher the output ourselves: the first value is the current year, the second the current month, then day, hour, minute, etc. We can also see what Python tells us about this result:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"help(datetime.datetime.now)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.2 Requests"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import requests\n",
"a=requests.get(\"https://piasommerauer.github.io\")\n",
"print(a.content)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Don't worry too much about the response: it is a format called HTML (which is basically behind all web pages) and one would need to write some more code to extract the useful information from it. But: it is really impressive that we can retrieve any webpage from the web with just three lines of code! If you want to have a quick look at how to extract content, feel free to check out the beautifulsoup module. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So, how does one **find** a useful module for a specific task? Answer: Google it ;-)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercises"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 1:** \n",
"\n",
"Check which arguments should be supplied to the `random.sample()` method and what is their intention. Then call this function with different arguments."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# your code here"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Exercise 2**\n",
"\n",
"Figure out what the os module does and think about tasks it could be used for. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# play around here"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.4"
}
},
"nbformat": 4,
"nbformat_minor": 4
}