diff --git a/.gitignore b/.gitignore index f87cec7..8265764 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,127 @@ -cw/* -*.zip \ No newline at end of file +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints +*/.ipynb_checkpoints/* + +# IPython +profile_default/ +ipython_config.py + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ diff --git a/week4/.ipynb_checkpoints/w4-checkpoint.ipynb b/week4/.ipynb_checkpoints/w4-checkpoint.ipynb deleted file mode 100644 index 6e51677..0000000 --- a/week4/.ipynb_checkpoints/w4-checkpoint.ipynb +++ /dev/null @@ -1,816 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "ef584785", - "metadata": {}, - "source": [ - "# **xSoc Python Course** - Week 4\n", - "\n", - "### *File Handling & The Command Line*\n", - "\n", - "🖋️ *Written by Alistair & Tomas from [Warwick AI]()*" - ] - }, - { - "cell_type": "markdown", - "id": "606d5adb", - "metadata": {}, - "source": [ - "This week we will look at various methods of taking input into our python applications and the challenges that come with that.\n", - "\n", - "In this lecture, we will aim to cover:\n", - "* File reading\n", - "* File writing\n", - "* User input\n", - "* Command line arguments\n", - "* Libraries" - ] - }, - { - "cell_type": "markdown", - "id": "ad926535", - "metadata": {}, - "source": [ - "## File Reading" - ] - }, - { - "cell_type": "markdown", - "id": "6f35b417", - "metadata": {}, - "source": [ - "To read from a file, we need a file to read from.\n", - "**Create a file in the same folder as the notebook called \"test.txt\" and add some text to it.**" - ] - }, - { - "cell_type": "markdown", - "id": "d980531a", - "metadata": {}, - "source": [ - "Now we will read the file into Python. To do this, we use the ```open()``` function.\n", - "\n", - "The ```open()``` function primarily takes two arguments: **file path** and **mode**\n", - "\n", - "The file path argument is either the relative or absolute path to the file, we will cover the different modes later, but inorder to read text, we use the mode \"r\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "58f4d19f", - "metadata": {}, - "outputs": [], - "source": [ - "test_file = open(\"Data/test.txt\",\"r\")" - ] - }, - { - "cell_type": "markdown", - "id": "5b6c3749", - "metadata": {}, - "source": [ - "To read the file, we call ```read()``` on the result of the ```open()``` method. Let's put this in a variable called data for now." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "84cba540", - "metadata": {}, - "outputs": [], - "source": [ - "data = test_file.read()" - ] - }, - { - "cell_type": "markdown", - "id": "cf0dbc64", - "metadata": {}, - "source": [ - "Now we can print the contents of the file using ```print(data)```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b6d6971", - "metadata": {}, - "outputs": [], - "source": [ - "print(data)" - ] - }, - { - "cell_type": "markdown", - "id": "56465cdd", - "metadata": {}, - "source": [ - "Hooray, we have read from a file!\n", - "\n", - "However let's see what happens if we try to read from the file again." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2a2020c6", - "metadata": {}, - "outputs": [], - "source": [ - "data = test_file.read()\n", - "print(data)" - ] - }, - { - "cell_type": "markdown", - "id": "2c51b14d", - "metadata": {}, - "source": [ - "Notice we don't get anything this time. This is because Python remebers what postion you are at in a file. When we used ```read()``` the first time, we read all the way up to the end of the file so when we call ```read()``` again, we are already at the end so we get nothing!\n", - "\n", - "Think of it like a bookmark. When we read the book, the bookmark is at the end, so when we go to read it again, we find there is nothing left to read." - ] - }, - { - "cell_type": "markdown", - "id": "a8d0cd9d", - "metadata": {}, - "source": [ - "### Seeking\n", - "However, Python allows us to change where the bookmark is using the ```seek()``` method.\n", - "\n", - "The ```seek()``` method takes two arguments: **offset** and **whence**\n", - "\n", - "Offset determines how far forwards or backwards we want to move the bookmark.\n", - "\n", - "Whence determines from where we move the bookmark, the options are:\n", - "* 0 Move from the start of the file\n", - "* 1 Move from the position of the bookmark\n", - "* 2 Move from the end of the file\n", - "\n", - "*Note: for text files, only option 0 is supported. We will come onto the other options later.*\n", - "\n", - "Therefore using ```seek(0,0)``` should bring us back to the start of the file as we're telling Python to put the bookmark 0 places from the start of the file." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8da47dff", - "metadata": {}, - "outputs": [], - "source": [ - "test_file.seek(0,0)" - ] - }, - { - "cell_type": "markdown", - "id": "90f48224", - "metadata": {}, - "source": [ - "Now let's read in the data and print the results again" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "52b28b4e", - "metadata": {}, - "outputs": [], - "source": [ - "data = test_file.read()\n", - "print(data)" - ] - }, - { - "cell_type": "markdown", - "id": "ae77a1f4", - "metadata": {}, - "source": [ - "We can also try seeking to the middle of the file as so" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d268e056", - "metadata": {}, - "outputs": [], - "source": [ - "test_file.seek(8,0)\n", - "data = test_file.read()\n", - "print(data)" - ] - }, - { - "cell_type": "markdown", - "id": "fde0869c", - "metadata": {}, - "source": [ - "Lastly, we need to make sure we close the file once we're done with it. This is done using ```close()```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "80df39a5", - "metadata": {}, - "outputs": [], - "source": [ - "test_file.close()" - ] - }, - { - "cell_type": "markdown", - "id": "f320d8aa", - "metadata": {}, - "source": [ - "Now if we try to read from the file, we will get an error so we can tell that the file is closed." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "37617978", - "metadata": {}, - "outputs": [], - "source": [ - "test_file.read()" - ] - }, - { - "cell_type": "markdown", - "id": "0a7888f0", - "metadata": {}, - "source": [ - "### With ... As\n", - "Instead of using file.close() we can also use Python's ```with ... as``` operator.\n", - "After using ```with ... as```, we indent our code and once we return from the indent, the file will be closed automatically." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "46a75371", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"Data/test.txt\",\"r\") as test_file:\n", - " print(test_file.read())" - ] - }, - { - "cell_type": "markdown", - "id": "9ee6730f", - "metadata": {}, - "source": [ - "### Binary Files\n", - "Python also allows us to read in files as binary. This is done by appending a '**b**' to the mode parameter of the ```open()``` method." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5d29fb04", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"Data/test.txt\",\"rb\") as test_file:\n", - " data = test_file.read()\n", - "print(data)\n", - "print(data[0])\n", - "type(data)" - ] - }, - { - "cell_type": "markdown", - "id": "5ce67b10", - "metadata": {}, - "source": [ - "We can see that data is now a **bytes** object. This is useful for processing any filetype that isn't primarily text based, such as images or audio." - ] - }, - { - "cell_type": "markdown", - "id": "8cb118df", - "metadata": {}, - "source": [ - "Binary files also allow us to seek from the current cursor position or from the end of the file. The offset is the number of bytes to move forwards or backwards in the file." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a7edc375", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"Data/test.txt\",\"rb\") as test_file:\n", - " test_file.seek(-5,2)\n", - " print(test_file.read())" - ] - }, - { - "cell_type": "markdown", - "id": "bc8caf8c", - "metadata": {}, - "source": [ - "## File Writing\n", - "Now that we have covered reading from files, we now need to try to write to files.\n", - "\n", - "This is done using a different **mode** with the ```open()``` function. The possible modes are as follows:\n", - "|Mode|Function|\n", - "|---|---|\n", - "|'r'|Read from file, error if file doesn't exist|\n", - "|'w'|Write to file, will create/overwrite file|\n", - "|'x'|Write to file, will error if file exists|\n", - "|'a'|Appending to file, will create/overwrite file|\n", - "|'b'|Binary mode|\n", - "|'t'|Text mode (default)|\n", - "|'+'|Allows either writing if used as 'r+' or reading if used as 'w+'|\n", - "\n", - "In this lecture, we will only cover 'w' and 'a', but feel free to explore in your own time!" - ] - }, - { - "cell_type": "markdown", - "id": "4f6517a7", - "metadata": {}, - "source": [ - "To begin with, lets open a file called '**test2.txt**' and write some text to it.\n", - "\n", - "*Note we don't need to create the file as Python will do that for us!*" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "50ba509c", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"Data/test2.txt\",\"w\") as test_file_2:\n", - " test_file_2.write(\"Warwick AI is still the best!\")" - ] - }, - { - "cell_type": "markdown", - "id": "36bd8a72", - "metadata": {}, - "source": [ - "Now go to your file explorer and open the file, you should see that the text has been written to it!\n", - "\n", - "Now let's try that again, but this time use different text." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "65bc4124", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"Data/test2.txt\",\"w\") as test_file_2:\n", - " test_file_2.write(\"I love reading\")" - ] - }, - { - "cell_type": "markdown", - "id": "fdeef264", - "metadata": {}, - "source": [ - "We should see that the file has been overwritten with the new text. In some cases, this is useful, however sometimes we will want to append to the file without overwriting the previous content, for example when writing to an application log.\n", - "\n", - "We can do this using the '**a**' mode. Try appending some text to 'test2.txt'." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4fb5af0e", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"Data/test2.txt\",\"a\") as test_file_2:\n", - " test_file_2.write(\" and writing files.\")" - ] - }, - { - "cell_type": "markdown", - "id": "43b70430", - "metadata": {}, - "source": [ - "Opening the file in notepad, we see that we have appended text to the original file." - ] - }, - { - "cell_type": "markdown", - "id": "04445981", - "metadata": {}, - "source": [ - "### One Line at a Time\n", - "There are many instances where we will want to read a file in parts and process each part separately. For example, if we want to read Comma Separated Values (.csv) files into our program, we will want to read the header line first, then each line individually as each line will contain a new row of data." - ] - }, - { - "cell_type": "markdown", - "id": "a8cdc298", - "metadata": {}, - "source": [ - "#### Example CSV\n", - "Name, StudentNumber, Course \n", - "John, 2201234, Biology \n", - "Emma, 2109876, Maths \n", - "Sophie, 2001234, CompSci \n", - "James, 2101234, English \n", - "\n", - "*Note to make this more readable, I've added in spaces, however usually this would not be the case as they would require removal in the program.*" - ] - }, - { - "cell_type": "markdown", - "id": "86c42157", - "metadata": {}, - "source": [ - "Fortunately, we can use the ```readline()``` method to do exactly this. First lets open the **test_data.csv** file in **r+** mode so we can read and write to it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "00a422f6", - "metadata": {}, - "outputs": [], - "source": [ - "csv_file = open(\"Data/test_data.csv\",\"r+\")" - ] - }, - { - "cell_type": "markdown", - "id": "739eeebb", - "metadata": {}, - "source": [ - "Let's store the headers of the file in a list called ```headers```. This is done by reading the firstline of the file using the ```readine()```, then split the string by '**,**' since this is a csv file.\n", - "\n", - "Note you may want to use ```.strip('\\n')``` to remove the trailing newline from the line." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7262280", - "metadata": {}, - "outputs": [], - "source": [ - "headers = csv_file.readline().strip('\\n').split(',')\n", - "print(headers)" - ] - }, - { - "cell_type": "markdown", - "id": "7761671b", - "metadata": {}, - "source": [ - "Now lets put the data into a dictionary so that given a name, we can get the society they are in. In order to read all the lines of the file, we can use a ```while``` loop.\n", - "\n", - "Note since once we reach the end of the file, ```readline()``` will return an empty string, we can create a stop condition for the loop." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dd147e6c", - "metadata": {}, - "outputs": [], - "source": [ - "data_dict = {}\n", - "\n", - "line = csv_file.readline().strip('\\n').split(',')\n", - "while not line == ['']:\n", - " data_dict[line[0]] = line[1]\n", - " line = csv_file.readline().strip('\\n').split(',')\n", - "print(data_dict)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b429114c", - "metadata": {}, - "outputs": [], - "source": [ - "print(data_dict['Alistair'])" - ] - }, - { - "cell_type": "markdown", - "id": "b5a3515d", - "metadata": {}, - "source": [ - "Hopefully you should see that you can now access the data that was in the csv file using the dictionary. This is just a simple example of how we can use Python to parse CSV files into data structures that are more useful for us as programmers." - ] - }, - { - "cell_type": "markdown", - "id": "7985d883", - "metadata": {}, - "source": [ - "Let's also try writing a new line to the file. Unfortunately, Python doesn't have a ```writeline()``` method. However we can use the ```write()``` method to write a new line by prepending a '**\\n**' to our string. \n", - "\n", - "Write your name and society into the file, note you will need to use the csv format." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "54ecadd7", - "metadata": {}, - "outputs": [], - "source": [ - "csv_file.write(\"\\nAlistair,WAI\")" - ] - }, - { - "cell_type": "markdown", - "id": "7ff9ac11", - "metadata": {}, - "source": [ - "Now close the file and open it in the editor to see if it has changed." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3316fba7", - "metadata": {}, - "outputs": [], - "source": [ - "csv_file.close()" - ] - }, - { - "cell_type": "markdown", - "id": "4f186189", - "metadata": {}, - "source": [ - "## Command Line Arguments\n", - "Now we will cover one final useful way of getting input into our program, specifically programs run from the command line.\n", - "\n", - "Command line arguments are passed into a program when you run it from the command line and can pass using data into the program or affect the behaviour by specifing certain conditions.\n", - "\n", - "For example, running the command **python -c \"\"** will run the python code using python, but running **python -V** will print the current version of python." - ] - }, - { - "attachments": { - "Cmd_line_args_example.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "af436cd3", - "metadata": {}, - "source": [ - "![Cmd_line_args_example.png](attachment:Cmd_line_args_example.png)" - ] - }, - { - "cell_type": "markdown", - "id": "7d31027e", - "metadata": {}, - "source": [ - "Using command line arguments to take input can allow us to create powerful scripts that are suited to a particular task. If you have any experience with Linux or any other command line, you will know how useful command line programs can be, and Python provides the ability to create such programs.\n", - "\n", - "Due to the way Notebooks are run, we will have to create a new Python script in order to demonstrate how command line arguments work, however all the syntax will still be explained here." - ] - }, - { - "cell_type": "markdown", - "id": "982d3674", - "metadata": {}, - "source": [ - "First, you will need to import the **system** library using ```import sys```. This will allow us to access the command line arguments passed to the script." - ] - }, - { - "cell_type": "markdown", - "id": "f5e534c6", - "metadata": {}, - "source": [ - "Using ```sys.argv```, we can access the command line arguments. Note that ```sys.argv``` is actually a list, so we can access indiviual arguments using ```sys.argv[0]```, ```sys.argv[1]```, etc.\n", - "\n", - "Access and print out the first command line argument." - ] - }, - { - "attachments": { - "Cmd_line_args_example2.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "2cabb8ef", - "metadata": {}, - "source": [ - "![Cmd_line_args_example2.png](attachment:Cmd_line_args_example2.png)" - ] - }, - { - "cell_type": "markdown", - "id": "ede5540c", - "metadata": {}, - "source": [ - "You should notice that the path of the script you are running is printed. The first command line argument is always the path to the script, so there is always one command line argument. Any additional arguments will be in the 2nd index and above." - ] - }, - { - "cell_type": "markdown", - "id": "04edfee4", - "metadata": {}, - "source": [ - "Let's take in a username as our first additional argument. Set a ```username``` variable to ```sys.argv[1]``` and print out a greeting to the user. Remember when you run the script, you will need to run it as ```python ```." - ] - }, - { - "attachments": { - "Cmd_line_args_example3.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "aea1b87b", - "metadata": {}, - "source": [ - "![Cmd_line_args_example3.png](attachment:Cmd_line_args_example3.png)" - ] - }, - { - "cell_type": "markdown", - "id": "09c9c5ee", - "metadata": {}, - "source": [ - "Now let's add two optional arguments, **-u** which makes the name uppercase and **-r** which reverses the name. Create two variables to store the potential options. Note that since they are optional, we need to check the length of ```sys.argv``` to see how many arguments have been passed." - ] - }, - { - "cell_type": "markdown", - "id": "a9f493c2", - "metadata": {}, - "source": [ - "Use an ```if``` statement to check the length of ```sys.argv``` and set the option variables to the optional arguments if they exist." - ] - }, - { - "cell_type": "markdown", - "id": "9a224e04", - "metadata": {}, - "source": [ - "Lastly, we don't want order to matter with the optional arguments, so use another ```if``` statement with the ```or``` operator to check both optional variables for **-u** or **-r**.\n", - "\n", - "To set the username to uppercase, use ```user_name.upper()```\n", - "\n", - "To reverse the username, you can use techniques from week 3." - ] - }, - { - "cell_type": "markdown", - "id": "1cd1f700", - "metadata": {}, - "source": [ - "Finally, print out the greeting with the modified username. Test out the script with a different arguments and see if it works.\n", - "\n", - "For example, ```python