3-1.5_Mod01_Practice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 1 Practice\n",
    "\n",
    "### Students will be able to:\n",
    "\n",
    "## 3-1.1 Using Python Modules\n",
    "* Import different Python modules\n",
    "* Compute mathematical expressions using functions from the math module\n",
    "* Recognize the effect of operator precedence\n",
    "* Round real numbers into the nearest integer\n",
    "* Generate (pseudo-)random integers\n",
    "* Select a random element from a list\n",
    "* Shuffle the elements of a list\n",
    "\n",
    "##  3-1.2 Working with Date and Time\n",
    "* Assign and modify a time object (variable)\n",
    "* Assign and modify a date object (variable)\n",
    "* Get the current local date\n",
    "* Assign and modify a datetime object (variable)\n",
    "* Split a datetime object into separate time and date objects\n",
    "* Combine time and date objects into datetime objects\n",
    "* Display a datetime object as a formatted string\n",
    "\n",
    "## 3-1.3 Date and Time Arithmetic\n",
    "\n",
    "* Create timedelta objects\n",
    "* Use timedelta objects to perform date arithmetic\n",
    "* Compare two datetime objects\n",
    "* Build a useful application using timedelta arithmetic\n",
    "\n",
    "## 3-1.4 File System\n",
    "\n",
    "* Identify the platform running a Python script ('Linux', 'win32', 'Darwin')\n",
    "* Get the current working directory\n",
    "* Change the current working directory\n",
    "* List the content of the current working directory\n",
    "* Create a new directory\n",
    "* Remove a directory\n",
    "* Rename files and/or directories\n",
    "* Recognize the difference between a relative path and an absolute path\n",
    "* Test if a path exists\n",
    "* Test if a specific file or directory exists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 1</B></font>\n",
    "\n",
    "## `math` module\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Use the math module to display an accurate value for pi\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to:\n",
    "# 1) find all the numbers in a list that are divisible by 3\n",
    "# 2) display the square root of these numbers\n",
    "# 3) use a rounding function to display the square roots while ignoring the decimal fraction\n",
    "\n",
    "lst = [23, 45, 65, 2345, 42, 76, 37, 87, 647, 35, 37 ,39, 898, 92, 18]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 2</B></font>\n",
    "\n",
    "## Mathematical operators\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coin calculators\n",
    "\n",
    "In the following exercises, you will develop functions to count the number of coins in a certain dollar amount. You will then use these functions to write a program that can calculate the change due to a customer in coins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quarters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `quarters_count` so it calculates and prints the number of quarters in `input_cents`\n",
    "# The function input `input_cents` should be in cents \n",
    "# The function should print the number of calculated quarters in `input_cents`\n",
    "# The function should return the number of remaining cents `remaining_cents` (which is less than 25, why?)\n",
    "# HINT: You might want to use % and // operators\n",
    "\n",
    "def quarters_count(input_cents):\n",
    "    #TODO\n",
    "\n",
    "# test with $2\n",
    "# Output should be: 8 quarter\\s\n",
    "dollars = 2\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = quarters_count(total_cents)\n",
    "\n",
    "# test with $5.30\n",
    "# Output should be: 21.0 quarter\\s\n",
    "dollars = 5.30\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = quarters_count(total_cents)\n",
    "\n",
    "# test with $9.49\n",
    "# Output should be: 37.0 quarter\\s\n",
    "dollars = 9.49\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = quarters_count(total_cents)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `dimes_count` so it calculates and prints the number of dimes in `input_cents`\n",
    "# The function input `input_cents` should be in cents \n",
    "# The function should print the number of calculated dimes in `input_cents`\n",
    "# The function should return the number of remaining cents `remaining_cents` (which is less than 10, why?)\n",
    "# HINT: You might want to use % and // operators\n",
    "\n",
    "def dimes_count(input_cents):\n",
    "    #TODO\n",
    "\n",
    "# test with $2\n",
    "# Output should be: 20 dime\\s\n",
    "dollars = 2\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = dimes_count(total_cents)\n",
    "\n",
    "# test with $5.30\n",
    "# Output should be: 53.0 dime\\s\n",
    "dollars = 5.30\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = dimes_count(total_cents)\n",
    "\n",
    "# test with $9.49\n",
    "# Output should be: 94.0 dime\\s\n",
    "dollars = 9.49\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = dimes_count(total_cents)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nickels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `nickels_count` so it calculates and prints the number of nickels in `input_cents`\n",
    "# The function input `input_cents` should be in cents \n",
    "# The function should print the number of calculated nickels in `input_cents`\n",
    "# The function should return the number of remaining cents `remaining_cents` (which is less than 5, why?)\n",
    "# HINT: You might want to use % and // operators\n",
    "\n",
    "def nickels_count(input_cents):\n",
    "    #TODO\n",
    "\n",
    "# test with $2\n",
    "# Output should be: 40 nickel\\s\n",
    "dollars = 2\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = nickels_count(total_cents)\n",
    "\n",
    "# test with $5.30\n",
    "# Output should be: 106.0 nickel\\s\n",
    "dollars = 5.30\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = nickels_count(total_cents)\n",
    "\n",
    "# test with $9.49\n",
    "# Output should be: 189.0 nickel\\s\n",
    "dollars = 9.49\n",
    "total_cents = dollars * 100\n",
    "remaining_cents = nickels_count(total_cents)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Change calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `coins_due` to calculate and print the change due to a customer in coins\n",
    "#\n",
    "# The function `coins_due` has 2 inputs:\n",
    "#      - `amount_paid`: Amount paid by a customer (in cents)\n",
    "#      - `item_price`: Purchase price of an item\n",
    "#\n",
    "# The function should print:\n",
    "#      - The number of quarters due\n",
    "#      - The number of dimes due\n",
    "#      - The number of nickels due\n",
    "#      - The number of cents due\n",
    "#      \n",
    "# The function does not need to return anything\n",
    "#\n",
    "# HINT: Use the functions you developed before `quarters_count`, `dimes_count`, `nickels_count`\n",
    "\n",
    "\n",
    "def quarters_count(input_cents):\n",
    "    #TODO\n",
    "\n",
    "def dimes_count(input_cents):\n",
    "    #TODO\n",
    "\n",
    "def nickels_count(input_cents):\n",
    "    #TODO\n",
    "\n",
    "def coins_due(amount_paid, item_price):\n",
    "    print(\"Change due:\")\n",
    "    #TODO\n",
    "\n",
    "# Test case:\n",
    "# amount paid = $10, item price = $5.37\n",
    "# Output should be: \n",
    "#    Change due:\n",
    "#    18.0 quarter\\s\n",
    "#    1.0 dime\\s\n",
    "#    0.0 nickel\\s\n",
    "#    3.0 cent\\s\n",
    "\n",
    "amount_paid = 10 * 100 # in cents\n",
    "item_price = 5.37 * 100 # in cents\n",
    "coins_due(amount_paid, item_price)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 3</B></font>\n",
    "\n",
    "## Random numbers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Probability of a die roll\n",
    "\n",
    "It is possible to mathematically predict the probability (or chance) of getting a certain die roll; however, in this exercise you will use Python to do it without math. The trick is to roll a die a large number of times and count how many times we get a certain roll. You can, then, divide the count by the large number to get the probability. For a fair 6-sided die, the chance of getting any of its faces is about 16.6%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the following program to display the probability of a certain die roll\n",
    "\n",
    "from random import randint\n",
    "\n",
    "def die_roller ():\n",
    "    return(randint(1, 6))\n",
    "\n",
    "#TODO\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Roll till you get 11\n",
    "\n",
    "In this exercise, you will count the number of times you need to roll a set of 2 dice till you get a roll sum of 11."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the following program so you can count the number of times needed to get a roll sum of 11\n",
    "\n",
    "from random import randint\n",
    "\n",
    "def die_roller():\n",
    "    return(randint(1, 6))\n",
    "\n",
    "def roll_sum():\n",
    "    return die_roller() + die_roller()\n",
    "\n",
    "#TODO\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pick a candy\n",
    "\n",
    "In this exercise, you will write a program to randomly select a candy from a box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `pick_candy` so it returns a candy from box at random\n",
    "\n",
    "def pick_candy():\n",
    "    box = [\"Taffy\", \"Brownie\", \"Cookie\", \"Candy bar\", \"Chocolate\", \"Lollipop\", \"Gingerbread\", \"Marshmallow\"]\n",
    "    #TODO\n",
    "\n",
    "print(pick_candy())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shuffle a sorted list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to shuffle the following sorted list\n",
    "\n",
    "lst = [3, 5, 9, 29, 35, 59, 62, 69, 102, 394, 594, 1993]\n",
    "\n",
    "#TODO\n",
    "\n",
    "print(lst)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 4</B></font>\n",
    "\n",
    "## Working with date and time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Current date and time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program that displays the current time as (HH:MM AM/PM) (example 02:28 PM)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program that displays the current time as (HH:MM:SS) (example 14:28:10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program that displays the current date as (Friday, December 15, 2017)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### American VS European date format\n",
    "\n",
    "In the United States, the date is formatted as Month/Day/Year; whereas, in Europe the date is formatted as Day/Month/Year. In this exercise, you will write two functions that will display a `datetime` object in the American or European format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the functions `american_format(d)` and `european_format(d)` to display the datetime object d in the proper format\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "def american_format(d):\n",
    "    #TODO\n",
    "    \n",
    "def european_format(d):\n",
    "    #TODO\n",
    "    \n",
    "# test\n",
    "d = datetime(month = 2, year = 2012, day = 13)\n",
    "\n",
    "print(\"American format:\", american_format(d))\n",
    "print(\"European format:\", european_format(d))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Birthday days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to display a list of all your birthdays from the day you were born till 2025.\n",
    "# You should also show the weekdays so you can see which of them was (or will be) on a weekend\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 5</B></font>\n",
    "\n",
    "## Date and Time Arithmetic\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `timedelta`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Write a program to find out how many minutes are in a 4-week period\n",
    "# Hint: Use a timedelta object and the total_seconds() method\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Date arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to compute the number of days remaining in the current year\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing `datetime` objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the program below to find out if July 4th is within 10 days of today's date,\n",
    "# if it is, find out if has passed or not\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "# get today's date\n",
    "todays_date = datetime.today()\n",
    "\n",
    "# 4th of July of current year\n",
    "july_4th = datetime(month = 7, day = 4, year = todays_date.year)\n",
    "\n",
    "days_difference = todays_date - july_4th\n",
    "\n",
    "#TODO\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 6</B></font>\n",
    "\n",
    "## File System\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Directory operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the following program to:\n",
    "# 1) navigate to `parent_dir` directory (if not already in it)\n",
    "# 2) create a new directory called `practice_1`\n",
    "# 3) change the working directory to `practice_1`\n",
    "# 4) display the current working directory to verify you are in the correct location\n",
    "# 5) create a new directory called `practice_2`\n",
    "# 6) verify that `practice_2` was created by listing the content of the current directory\n",
    "# 7) rename `practice_2` as `sub_practice_2`\n",
    "# 8) verify the name was successful changed by listing the content of the current directory\n",
    "# 9) remove `sub_practice_2`\n",
    "# 10) change working directory to the parent directory using `..`\n",
    "# 11) remove `practice_1`\n",
    "# 12) verify your current working directory and display its content\n",
    "\n",
    "import os, os.path\n",
    "\n",
    "# 1) navigate to `parent_dir` directory (if not already in it)\n",
    "if('parent_dir' not in os.getcwd()):\n",
    "    # Changing the current working directory to parent dir\n",
    "    print(\"Changing working dir to parent_dir\")\n",
    "    os.chdir('parent_dir')\n",
    "    print(\"Current working directory:\", os.getcwd())\n",
    "\n",
    "# 2) create a new directory called `practice_1`\n",
    "#TODO\n",
    "\n",
    "# 3) change the working directory to `practice_1`\n",
    "#TODO\n",
    "\n",
    "\n",
    "# 4) display the current working directory to verify you are in the correct location\n",
    "#TODO\n",
    "\n",
    "# 5) create a new directory called `practice_2`\n",
    "#TODO\n",
    "\n",
    "\n",
    "# 6) verify that `practice_2` was created by listing the content of the current directory\n",
    "#TODO\n",
    "\n",
    "# 7) rename `practice_2` as `sub_practice_2`\n",
    "#TODO\n",
    "\n",
    "\n",
    "# 8) verify the name was successful changed by listing the content of the current directory\n",
    "#TODO\n",
    "\n",
    "# 9) remove `sub_practice_2`\n",
    "#TODO\n",
    "\n",
    "\n",
    "# 10) change working directory to the parent directory using `..`\n",
    "#TODO\n",
    "\n",
    "\n",
    "# 11) remove `practice_1`\n",
    "#TODO\n",
    "\n",
    "\n",
    "# 12) verify your current working directory and display its content\n",
    "#TODO\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Path operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program that prompts the user for a file or directory name\n",
    "# if it exists in the current working directory, it prints whether it is a file or directory\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Module 1 Project</B></font>\n",
    "\n",
    "## Directory creator\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] The following program is designed to generate a number of directories.\n",
    "# The directory names follow the pattern (MM_DD_YY_randnum), where:\n",
    "#     - MM_DD_YY: is today's date as month/day/year\n",
    "#     - randnum: is a random integer between 10000 and 50000\n",
    "# For example, if today is May 12th, 2016, then the following would be valid names: 05_12_16_11050 or 05_12_16_15001\n",
    "#\n",
    "# For this task, you should complete the functions:\n",
    "# 1) `directory_count()`\n",
    "# 2) `name_generator()`\n",
    "# 3) `directory_creator(name)`\n",
    "# 4) `create()`\n",
    "#\n",
    "# HINT: You should import all necessary modules\n",
    "\n",
    "import os\n",
    "\n",
    "def directory_count():\n",
    "    \"\"\"\n",
    "    Calculate the number of directories to be generated.\n",
    "    \n",
    "    I) Get the current minute using appropriate functionality from `datetime`\n",
    "    II) Take the square root of ..the current minute + 15\n",
    "    III) Round the square root to an integer\n",
    "    VI) return the rounded number as the number of directories to be created\n",
    "    \n",
    "    args: \n",
    "          NONE\n",
    "    \n",
    "    returns: \n",
    "         `dir_count`: number of directories to be created \n",
    "    \"\"\"\n",
    "    #TODO\n",
    "\n",
    "def name_generator():\n",
    "    \"\"\"\n",
    "    Generate a single directory name using the pattern (MM_DD_YY_randnum).\n",
    "    \n",
    "    args:\n",
    "         NONE\n",
    "    \n",
    "    returns:\n",
    "         `dir_name`: string containing a valid directory name\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "\n",
    "def directory_creator(name):\n",
    "    \"\"\"\n",
    "    Create a single directory called `name` in the current working directory.\n",
    "    \n",
    "    args:\n",
    "         name: directory to be created\n",
    "    \n",
    "    returns:\n",
    "         NONE\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "\n",
    "def create():\n",
    "    \"\"\"\n",
    "    Generate the necessary directories.\n",
    "    \n",
    "    Use `directory_count` to calculate the number of directories, then use `directory_creator` and `name_generator`.\n",
    "\n",
    "    args:\n",
    "         NONE\n",
    "    \n",
    "    returns:\n",
    "         NONE\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "\n",
    "# Change working directory to `parent_dir` or `create`\n",
    "if(\"parent_dir\" not in os.getcwd()):\n",
    "    if os.path.exists(\"./parent_dir\"):\n",
    "        print(\"Changing working dir to parent_dir\")\n",
    "        os.chdir(\"parent_dir\")\n",
    "    else:\n",
    "        os.mkdir(os.getcwd() + \"./parent_dir\")\n",
    "        print(\"Changing working dir to parent_dir\")\n",
    "        os.chdir(\"parent_dir\")\n",
    "else:\n",
    "    # so the code can run multiple times \n",
    "    # while directory not ending with 'parent_dir' move up the path ..\\\n",
    "    while \"parent_dir\" not in os.getcwd()[-11:]:\n",
    "        # move up in dir to find 'parent_dir'\n",
    "        os.chdir(\"..\")\n",
    "        print(\"moved up\", os.getcwd())\n",
    "        \n",
    "# print the current working directory (should be \"parent_dir\")\n",
    "print(\"The current working directory is:\", os.getcwd())\n",
    "\n",
    "# check for randoms_directory if not present, create new\n",
    "if os.path.exists(os.getcwd() + \"/randoms_directory\") != True:\n",
    "    os.mkdir(\"randoms_directory\")\n",
    "\n",
    "# change the current working directory to randoms_directory\n",
    "print(\"Changing working dir to randoms_directory\")\n",
    "os.chdir(\"randoms_directory\")\n",
    "# print the current working directory (should be \"randoms_dir\")\n",
    "print(\"The current working directory is:\", os.getcwd())\n",
    "\n",
    "# create directories inside \"randoms_directory\"\n",
    "create()\n",
    "    \n",
    "# list the content of the current directory\n",
    "print(\"Current directory content:\", os.listdir())\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6",
   "language": "python",
   "name": "python36"
  },
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}