Python-ifed-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python-ifed\n",
    "\n",
    "Welcome to the python-ifed notebook, This notebook is a walkthrough + task for you to get started with software development using python.\n",
    "\n",
    "After completing this notebook successfully you should be familiar with the following concepts:\n",
    "* Use version control\n",
    "* Writing clean and modular code\n",
    "* Improve code efficiency\n",
    "* Add effective documentation\n",
    "* Testing \n",
    "* Code reviews\n",
    "\n",
    "**This exercise depends on a lot of googling skills and is aimed at making you efficient in the same**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 1 : Tables and stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 0\n",
    "\n",
    "You might be already done with this step\n",
    "\n",
    "### Learn to version control using git\n",
    "\n",
    "1. Install git CLI tool\n",
    "1. Configure git CLI\n",
    "1. Create a GitHub account if you already have not \n",
    "1. Clone the repo that contains this repository\n",
    "1. Now you are in master branch\n",
    "1. Create a new branch with your name as the branch name and continue\n",
    "\n",
    "### Reference materials\n",
    "https://www.atlassian.com/git\n",
    "\n",
    "https://www.tutorialspoint.com/git/git_basic_concepts.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1\n",
    "\n",
    "## Clean and modular code\n",
    "\n",
    "Test out your googling skills and understand what writing clean and modular code means and answer the following questions by editing this cell in jupyter notebook.\n",
    "\n",
    "### Describe what each of the following means\n",
    "\n",
    "#### Production\n",
    "In order to understand what production essentially means, we need to define what an environment is. By definition, a software development environment is a collection of software and hardware tools required by a developer to make software. Simply put, an environment is rather useful to control what your user sees by deploying software components in stages or steps. The final environment in software development is production. It's where the project goes live and the final code is tested and reviewed before making it publicly available. This stage is crucial as any errors in the code will be visible to the users. Hence, continuously reviewing the code is important. Usually, before deploying a new release, it's given to few number of users to test it before distributing it to everyone.\n",
    "\n",
    "#### Clean \n",
    "Clean code refers to code that is efficient, readable and easy to understand. This means that everyone who has access to the code should be able to read it and not only the original author of the code. The execution flow of the program, the meanings of various variables and functions in your code and the role of each class should be easy to understand as well.\n",
    "\n",
    "#### Modular\n",
    "Modular code is code that is separated into independent modules. It helps manage aspects of the code more efficiently by segmenting it into sub-programs. These sub-programs hide the internal details of the code under a simple interface which avoids complications while trying to understand your code.\n",
    "\n",
    "#### Module\n",
    "A module is a software component that encapsulates code and data which provides a specific functionality to your program. It's packaged in a single unit which makes it easy to incorporate in your program. In Python, we can access modules using the import keyword which helps implements modularity.\n",
    "\n",
    "#### Refactoring code\n",
    "Refactoring code refers to restructuring and simplifying your code without actually changing the primary functionality associated with it. These changes are usually tiny so they don't radically change the behaviour of your code. Refactoring code is imperative as it is used to change 'dirty' code into clean code, i.e. making the code more efficient so that it is easier to update and maintain. This reason may seem trivial but it is infact, crucial in the future if the programs needs further improvements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have finished writing the answers you can now commit these new changes with git using the commit message __step 1 completed__ ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2\n",
    "\n",
    "## Refactor: Cricket Match Analysis\n",
    "\n",
    "Here I would be providing you with a sample code, don't worry about the working much try to get an abstract idea and complete the task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('matches.csv', sep=',')\n",
    "df.set_index('id',inplace=True)\n",
    "df.drop('umpire3',axis=1,inplace=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how our data looks like right now we need to write efficient code to replaces the spaces with an underscore, the janky way of doing this is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = df.rename(columns={'team 1': 'team_1',\n",
    "                             'team 2': 'team_2',\n",
    "                             'toss winner': 'toss_winner',\n",
    "                             'dl applied': 'dl_applied',\n",
    "                             'win by runs': 'win_by_runs',\n",
    "                             'win by wickets': 'win_by_wickets',\n",
    "                            'player of match': 'player_of_match',\n",
    "                            'umpire 1':'umpire_1',\n",
    "                            'umpire 2':'umpire_2'\n",
    "                            })\n",
    "new_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is like a hardcoded way of doing it slightly better way of doing this is "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = list(df.columns)\n",
    "labels[0] = labels[0].replace(' ', '_')\n",
    "labels[1] = labels[1].replace(' ', '_')\n",
    "labels[2] = labels[2].replace(' ', '_')\n",
    "labels[3] = labels[3].replace(' ', '_')\n",
    "labels[5] = labels[5].replace(' ', '_')\n",
    "labels[6] = labels[6].replace(' ', '_')\n",
    "labels[7] = labels[7].replace(' ', '_')\n",
    "labels[8] = labels[8].replace(' ', '_')\n",
    "labels[9] = labels[9].replace(' ', '_')\n",
    "labels[10] = labels[10].replace(' ', '_')\n",
    "df.columns = labels\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is also a very redundant way of doing this try writing a better code to do the same. Limit yourselves to one or two lines of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert your solution here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are done till here make a new commit with message __step 2 complete__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 3\n",
    "\n",
    "## Optimizing Code\n",
    "\n",
    "### Efficient Code\n",
    "\n",
    "Knowing how to write code that runs efficiently is another essential skill in software development. Optimizing code to be more efficient can mean making it:\n",
    "\n",
    "* Execute faster\n",
    "* Take up less space in memory/storage\n",
    "\n",
    "\n",
    "Resources:\n",
    "https://stackify.com/20-simple-python-performance-tuning-tips/\n",
    "\n",
    "https://pybit.es/faster-python.html\n",
    "\n",
    "https://towardsdatascience.com/one-simple-trick-for-speeding-up-your-python-code-with-numpy-1afc846db418\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('subset_elemets.txt') as f:\n",
    "    subset_elements = f.read().split('\\n')\n",
    "    \n",
    "with open('all_elements.txt') as f:\n",
    "    all_elements = f.read().split('\\n')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "verified_elements = []\n",
    "\n",
    "for element in subset_elements:\n",
    "    if element in all_elements:\n",
    "        verified_elements.append(element)\n",
    "\n",
    "print(len(verified_elements))\n",
    "print('Duration: {} seconds'.format(time.time() - start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use vector operations using NumPy to optimise the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert answer here\n",
    "\n",
    "print(len(verified_elements))\n",
    "print('Duration: {} seconds'.format(time.time() - start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use a python datastructure which has a method to peform this task faster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert answer here\n",
    "\n",
    "print(len(verified_elements))\n",
    "print('Duration: {} seconds'.format(time.time() - start))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 4\n",
    "# Documentation\n",
    "\n",
    "Documentation is one of the important part of software development. Teach yourself about documentation in python and convert code in step 3 to functions and add relevant documentation for the same.\n",
    "\n",
    "#### Resources\n",
    "https://www.python.org/dev/peps/pep-0257/\n",
    "\n",
    "https://numpydoc.readthedocs.io/en/latest/format.html\n",
    "\n",
    "https://www.datacamp.com/community/tutorials/documenting-python-code\n",
    "\n",
    "do not add this code to the notebook instead create a new python file called step_4.py and define the functions as well as a main to test the working of all the functions make sure to version this file as well on the commit message __step 4 completed__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 5\n",
    "\n",
    "# Testing\n",
    "\n",
    "Testing your code is essential before deployment. It helps you catch errors and faulty conclusions before they make any major impact. Today, employers are looking for data scientists with the skills to properly prepare their code for an industry setting, which includes testing their code.\n",
    "\n",
    "Learn about pytest and install it \n",
    "\n",
    "https://docs.pytest.org/en/stable/\n",
    "\n",
    "create a new file called nearest_square.py this function should return the nearest perfect square number which is less than or equal to the number.\n",
    "\n",
    "create another file called test_nearest_square.py to test the function with different test each for values 5,-12,9 and 23\n",
    "\n",
    "execute the line below to ensure it is working correctly\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pytest test_nearest_square.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are done with this step make a new commit __step5 completed__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 6 \n",
    "# Code review\n",
    "\n",
    "Understand how code review works\n",
    "\n",
    "https://github.com/lyst/MakingLyst/tree/master/code-reviews\n",
    "\n",
    "https://www.kevinlondon.com/2015/05/05/code-review-best-practices.html\n",
    "\n",
    "_Leave it to us_ if you are done with this step go ahead and push this notebook as well as all the files to your GitHub and make a pull request to the repository that you cloned this task from so that we can review your progress till now, Please continue with the challenge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge 2 : Pokemon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you are familiar with writing efficient code let's use that practice and do some API fetching to answer some questions, Below are some questions below and you should use the [pokeapi](https://pokeapi.co/) to do some API fetching with python and answer the questions.\n",
    "\n",
    "**NOTE**\n",
    "You should fill the cell with code that gives the answer and not write the answer directly, failing to do so will reduce your evaluation and proves that you did not bother reading this part."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember you were in a pokemon room (discord) what is the **type** of that pokemon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What **type** of pokemons does this **type** take damage from\n",
    "\n",
    "__hint__ the url field of previous response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each of the **double damage from** type list 5 pokemons in that type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a function ability() inside a new file ability.py to return a list of the abilities of any given pokemon by doing an API query the function should accept a string parameter which is the name of the pokemon\n",
    "\n",
    "execute the line below to ensure everything is working properly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.8.5, pytest-6.2.1, py-1.10.0, pluggy-0.13.1\n",
      "rootdir: /Users/abhijitramesh/development/Python-ifed\n",
      "collected 4 items                                                              \u001b[0m\n",
      "\n",
      "test_abilities.py \u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\u001b[32m                                                   [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m============================== \u001b[32m\u001b[1m4 passed\u001b[0m\u001b[32m in 2.75s\u001b[0m\u001b[32m ===============================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pytest test_abilities.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please version till this point saying with a message \"Completed challenge 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra Challenge for extra karma point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the above challenge was a cakewalk and you have a lot of time left to attempt this challenge to earn some karma points, this challenge is completely optional.\n",
    "Let's create a pokedex with the function we created earlier on that is\n",
    "\n",
    "* What is the type of pokemon\n",
    "* What type of pokemon gives double damages to the given pokemon\n",
    "* List 5 pokemons which gives the given pokemon double damage\n",
    "* Abilities of our pokemon\n",
    "\n",
    "Use [pysimplegui](https://pypi.org/project/PySimpleGUI) to create a simple pokedex which consumes these functions\n",
    "\n",
    "save the file as pokedex.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Version till this point with a message \"Completed Extra Challenge\"\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}