intro_function.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# why do we need function at all?   \n",
    "    # 1: dont repeat yourself  \n",
    "    # 2: thinking reason: allow us to think at the high level of abstraction  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCD'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# functions are objects, can be also think as a noun \n",
    "# function is verb. can be evoked and called \n",
    "\n",
    "s = 'abcd'\n",
    "s.upper()\n",
    "# .upper => evoke a method that return a new string with the same elements/letteres in 's'  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "x = s.upper() \n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCD'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = s.upper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "builtin_function_or_method"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# why does type(x) in line 12 is str, yet the output in line 5 is 'builtin_function_or_method'\n",
    "the reason is because line 12 has parentheses '()'  after method (upper), while line 24 does no have '()' after the method.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    " # () parentacy in python mean => I want you to execute the thing that is to my left  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "builtin_function_or_method"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s.upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in method upper of str object at 0x000001A8D9234530>\n"
     ]
    }
   ],
   "source": [
    "print (s.upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCD\n"
     ]
    }
   ],
   "source": [
    "print (s.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = s.upper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function str.upper()>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "builtin_function_or_method"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in method upper of str object at 0x000001A8D9234530>\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a = s.upper without () is a way to create a allias of the function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCD'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1\n",
      "b: 2\n",
      "c: 3\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b':2, 'c':3} \n",
    "for key, values in d.items():\n",
    "    print (f'{key}: {values}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'builtin_function_or_method' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[9], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m d \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m2\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m3\u001b[39m} \n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m:\u001b[49m\n\u001b[0;32m      3\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mkey\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m: \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mvalues\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'builtin_function_or_method' object is not iterable"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b':2, 'c':3} \n",
    "for key, values in d.items:\n",
    "    print (f'{key}: {values}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "upper(self, /) unbound builtins.str method\n",
      "    Return a copy of the string converted to uppercase.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unbound method str.upper() needs an argument",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[11], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m help(\u001b[38;5;28;43mstr\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupper\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: unbound method str.upper() needs an argument"
     ]
    }
   ],
   "source": [
    "help(str.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = 'abcd'\n",
    "a = h.upper() \n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# to remember: \n",
    "1) functions are objects \n",
    "2) if I dont use parenthesis, Im gonna get a allis (or a reference) to the object => similar to create a new name for the same elements. *NOT* a result of evolking a function  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(): \n",
    "    print(\"hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this function is named 'hello' \n",
    "this function does not take any argument \n",
    "when I call this functio (print())\n",
    "the output returned is 'hello!'   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "hello() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[56], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mhello\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: hello() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "hello(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print (hello())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello!\n"
     ]
    }
   ],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "hello() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[52], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mhello\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43masdf\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: hello() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "hello('asdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'helll' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[53], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mhelll\u001b[49m()\n",
      "\u001b[1;31mNameError\u001b[0m: name 'helll' is not defined"
     ]
    }
   ],
   "source": [
    "helll()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello!\n"
     ]
    }
   ],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello():\n",
    "    return \"hello!!! 1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello!!! 1'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello2():\n",
    "    print('hello!!! 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello!!! 2\n"
     ]
    }
   ],
   "source": [
    "hello2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "what is the difference between print and return function? \n",
    "- return does not need parenthesis \n",
    "- return give the output in string ''\n",
    "\n",
    "Return main role is to return value(s) for a function  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(): \n",
    "    name = input(\"enter your name: \")\n",
    "    \n",
    "    return f'hello, {name}! Nice to see you!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello, thinh! Nice to see you!'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, asdf! Nice to see you!\n"
     ]
    }
   ],
   "source": [
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    return 100, 'abcd', [10,20,30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 'abcd', [10, 20, 30])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 'abcd', [10, 20, 30])\n"
     ]
    }
   ],
   "source": [
    "print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = foo() # unpacking the value of function 'foo'. a function is able to return multiple values and then can grab multiple values to do something      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function len in module builtins:\n",
      "\n",
      "len(obj, /)\n",
      "    Return the number of items in a container.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello1():\n",
    "    return \"hello !!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hello in module __main__:\n",
      "\n",
      "hello()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# docstring can be as long as short as I want  \n",
    "# what it receive = what the input are? \n",
    "# what is the expect that is? \n",
    "# what is the return? \n",
    "# mofify "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello, asdf! Nice to see you!'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello() # what is the shortcut to read docstring in VSC "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('abcd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    return f'hello, {name}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello, world'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello ('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello, be'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello ('be')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write a function ('mysum') that takes a list or tuple of numbers, and return the sum of those numbers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def mysum (numbers):\n",
    "    total = 0\n",
    "    for item in numbers:\n",
    "        total += item\n",
    "    print (total)\n",
    "\n",
    "mysum ((1,2,3))\n",
    "mysum ([4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write a function (\"minmax\") that takes a list or tuple of numbers, and returns a 2-elemnt tuple containing the minimum and maximum numbers found amount those inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 9)\n",
      "(10, 50)\n"
     ]
    }
   ],
   "source": [
    "def minmax (numbers):\n",
    "    sorted_numbers = sorted(numbers)  \n",
    "    return sorted_numbers[0], sorted_numbers[-1] \n",
    "\n",
    "print (minmax([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]))\n",
    "print (minmax((10, 20, 30, 40, 50))) \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write a function (\"calc\") that takes three arguments: \n",
    "# two numbers, and then a string that'll contain \"+\". \"-\", \"*\", \"/\"\n",
    "# the third argument will default to \"+\" if  nothing is passed   \n",
    "# return the result of involking the approprirate operation on the two numbers  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "-2\n",
      "15\n",
      "0.6\n"
     ]
    }
   ],
   "source": [
    "def calc (first, second, op = '+'):\n",
    "    if op == '+':\n",
    "        return first + second \n",
    "    if op == '-':\n",
    "        return first - second\n",
    "    if op == '*':\n",
    "        return first * second\n",
    "    if op == '/':\n",
    "        return first / second\n",
    "    else:\n",
    "        print (f\"there is no operation '{op}'\")\n",
    "        return None\n",
    "\n",
    "\n",
    "print (calc (3,3))\n",
    "print (calc (3, 5, \"-\"))\n",
    "print (calc (3, 5, \"*\"))\n",
    "print (calc (3, 5, \"/\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "import operator\n",
    "\n",
    "def apply_operation(a, b, operation = '+'):\n",
    "    operations = {\n",
    "        '+': operator.add,\n",
    "        '-': operator.sub,\n",
    "        '*': operator.mul,\n",
    "        '/': operator.truediv,\n",
    "    }\n",
    "    \n",
    "    if operation in operations:\n",
    "        return operations[operation](a, b)\n",
    "    else:\n",
    "        raise ValueError(f\"Unsupported operation: {operation}\")\n",
    "\n",
    "print(apply_operation (10,5))\n",
    "print(apply_operation(10,5, '-'))\n",
    "print(apply_operation(10,5, '*'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  write a function ('fliestats') that takes a filename, and returns a dictionary with four key:\n",
    "# \"vowels\" \"consonants\" \"digits\" \"other\" \n",
    "# the function will open the named file and then return (in the dict) the number of vowels, consonants, figits, and other characters it found in the file \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'vowels': 4, 'consonants': 6, 'digits': 15, 'other': 3}\n",
      "{'vowels': 5, 'consonants': 22, 'digits': 6, 'other': 12}\n",
      "{'vowels': 11, 'consonants': 20, 'digits': 8, 'other': 11}\n"
     ]
    }
   ],
   "source": [
    "def filestats(file_name):\n",
    "    result = {'vowels': 0 ,\n",
    "              'consonants': 0,\n",
    "              'digits' : 0 ,\n",
    "              'other': 0,\n",
    "              }\n",
    "\n",
    "    vowels = \"aeiouAEIOU\"\n",
    "    consonants = \"bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ\"\n",
    "    digits = \"0123456789\"\n",
    " \n",
    "    for character in file_name:\n",
    "        if character in vowels:\n",
    "            result['vowels'] += 1  \n",
    "        elif character in consonants:\n",
    "            result['consonants'] += 1\n",
    "        elif character in digits:\n",
    "            result['digits'] += 1\n",
    "        else:\n",
    "            result['other'] += 1        \n",
    "    \n",
    "    return result \n",
    "\n",
    "print (filestats('asdfasrea42345546  1234213 l'))\n",
    "print (filestats('asdfmkn asdf asdf lkw oi  -0 234 rjq34jt qj  '))\n",
    "print (filestats(' malfkgn i50t u0395t uy98y ah eiufh woh akdnf ka  '))        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo(x):\n",
    "    x = 200\n",
    "\n",
    "y = 100 \n",
    "foo(y)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 1]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_one (x):\n",
    "    x.append(1)\n",
    "    return x \n",
    "y = [10, 20, 30]\n",
    "add_one(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# rewatch the video about #  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mysum (numbers):\n",
    "    total = 0 \n",
    "    for one_number in numbers:\n",
    "        total += one_number\n",
    "    return total\n",
    "\n",
    "mysum ([10,20,30,40,50])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "mysum() takes 1 positional argument but 5 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[18], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mmysum\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m40\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: mysum() takes 1 positional argument but 5 were given"
     ]
    }
   ],
   "source": [
    "mysum(10,20,30,40,50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "215410"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def mysum(*numbers): # splat-args \n",
    "    total = 0 \n",
    "    for one_number in numbers:\n",
    "        total += one_number\n",
    "    return total\n",
    "\n",
    "mysum (120,115,2021,213154)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +=: 'int' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[20], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mmysum\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m123\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1234\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[19], line 4\u001b[0m, in \u001b[0;36mmysum\u001b[1;34m(*numbers)\u001b[0m\n\u001b[0;32m      2\u001b[0m total \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m \n\u001b[0;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m one_number \u001b[38;5;129;01min\u001b[39;00m numbers:\n\u001b[1;32m----> 4\u001b[0m     \u001b[43mtotal\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mone_number\u001b[49m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m total\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +=: 'int' and 'list'"
     ]
    }
   ],
   "source": [
    "mysum([123,1234])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum(*[10,20,30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boonggggggggggggggg\n"
     ]
    }
   ],
   "source": [
    "print('Boonggggggggggggggg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise 1:\n",
    "(1) define a 'calcmany' function that takes a string (one of +, -, *, and /) and any number of numbers. The string will indicate what mathematical operation we'll invoke one eacj of the numbers, starting with the first pair of numbers, and going through the rest.  \n",
    "=> calcmany (\"+\", 100, 10, 2) will return 112, while calcmany (\"/\", 100, 10, 2, 5) will return 1 -- because 100/10 is 10, 10/2 is 5, and 5/1 is 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "-50\n",
      "0\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "def calcmany (operation, *numbers):\n",
    "    result = 0\n",
    "    for number in numbers:\n",
    "        if operation == \"+\":\n",
    "            result += number\n",
    "        if operation == \"-\": \n",
    "            result -= number\n",
    "        if operation == \"*\":\n",
    "            result *= number\n",
    "        if operation == \"/\": \n",
    "            result /= number\n",
    "    print (result) \n",
    "\n",
    "calcmany (\"+\", 5, 10, 15,20)\n",
    "calcmany (\"-\", 5, 10, 15,20)\n",
    "calcmany (\"*\", 1, 2, 3,20)\n",
    "calcmany (\"/\", 5, 10, 15,20)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "inital solution does not work because they return wrong answers for '-', '*', and '/' operation: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "-40\n",
      "120\n",
      "0.0003333333333333334\n"
     ]
    }
   ],
   "source": [
    "def calcmany (operation, *numbers):\n",
    "    if operation == \"+\":\n",
    "        result = sum(numbers)\n",
    "    if operation == \"-\":\n",
    "        result = (numbers[0]*2) - sum(numbers)\n",
    "    if operation == \"*\":\n",
    "        result = 1 \n",
    "        for number in numbers:\n",
    "            result  *= number\n",
    "    if operation == \"/\":\n",
    "        result = numbers[0]  \n",
    "        if numbers[1:] == 0:\n",
    "            print ('Cannt devided by 0')\n",
    "        else: \n",
    "            for number in numbers:\n",
    "                result /= number\n",
    "    print (result)\n",
    "    \n",
    "calcmany (\"+\", 5, 10, 15,20)\n",
    "calcmany (\"-\", 5, 10, 15,20)\n",
    "calcmany (\"*\", 1, 2, 3,20)\n",
    "calcmany (\"/\", 5, 10, 15,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise 2: \n",
    "Define a function that takes one mandatory argument (the name of an output file), any number of additional arguments (names of input files), and an optional argument ('separator') that defaults to an empty string. This function, when called, should read through each of the lines in the input files and write them in the named output file. Between the contents of each file, the separaor should be written"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function, 'each_len' that takes any number of arguments, runs 'len' on each of them, and return the result. For example, each_len ('abcd', 'efg', 'hijkl) will return 12. \n",
    "Now ask the user to enter a sentence. Turn that sentence into a list of strings, and use 'each_len' to calculate the total length of the words in that sentence.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "user_input = input('enter your sentence: ') \n",
    "\n",
    "def each_len (*words):\n",
    "    words_len = 0\n",
    "    for word in words:\n",
    "        print (len(word))\n",
    "        words_len += len(word)\n",
    "\n",
    "\n",
    "each_len (user_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) Write a function, transform_files, that takes any number\n",
    "    of filenames as arguments, and two optional keyword-only\n",
    "    arguments:\n",
    "\n",
    "    - suffix, which defaults to the string \"new\"\n",
    "    - function, which defaults to len\n",
    "\n",
    "    The function will iterate over the filenames it receives, applying\n",
    "    the function to each filename.  The output from the function will\n",
    "    be stored in a new file of the same name as the original filename,\n",
    "    but with the suffix appended.\n",
    "\n",
    "    So if we call\n",
    "\n",
    "        transform_files('a.txt', 'b.txt', 'c.txt')\n",
    "\n",
    "    The files a.txt.new and b.txt.new and c.txt.new will all\n",
    "    have the content \"5\", because the filename is 5 characters\n",
    "    long.  You can pass whatever function you want instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform_file(*args, suffix='new', function=len):\n",
    "    for one_filename in args: \n",
    "        with open(f'{one_filename}.{suffix}', 'w') as outfile: \n",
    "            outfile.write(str(function(one_filename)))\n",
    "\n",
    "transform_file('a.txt', 'b.txt', 'c.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "UsageError: Line magic function `%cat` not found.\n"
     ]
    }
   ],
   "source": [
    "%cat a.txt.new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function, combine_dicts, that takes any number of dicts as\n",
    "    arguments.  The output from the function is a new dict that merges\n",
    "    all of the keys and values together.  The values will always be in\n",
    "    a list, even if there is only one value.\n",
    "\n",
    "    The function takes a single keyword argument, maxvalues, an\n",
    "    integer indicating the maximum number of values that should be\n",
    "    associated with a key.  (Just take the first maxvalues\n",
    "    elements in a list.)\n",
    "\n",
    "    So if we call\n",
    "\n",
    "    d1 = {'a':1, 'b':2, 'c':3, 'd':4}\n",
    "    d2 = {'c':10, 'd':20, 'e':30}\n",
    "    d3 = {'d':200, 'e':300, 'f':400}\n",
    "\n",
    "    combine_dicts(d1, d2, d3)\n",
    "\n",
    "    the result will be\n",
    "\n",
    "    {'a':[1], 'b':[2] 'c':[3,10],\n",
    "     'd':[4, 20, 200], 'e':[30, 300],\n",
    "     'f':[400]}\n",
    "\n",
    "    But if we call\n",
    "\n",
    "    combine_dicts(d1, d2, d3, maxvalues=2)\n",
    "\n",
    "    the result will be\n",
    "\n",
    "    {'a':[1], 'b':[2], 'c':[3,10], 'd':[4, 20],\n",
    "     'e':[30, 300], 'f':[400]}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def combine_dicts (*dict, maxvalues = 2):\n",
    "    dict_combine = [*dict]\n",
    "    # merge all key and value together  \n",
    "    # test with two seperate dictionary first "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 10, 'd': 20, 'e': 30, 'f': 400}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'a':1, 'b':2, 'c':3, 'd':4}\n",
    "d2 = {'c':10, 'd':20, 'e':30}\n",
    "d3 = {'d':200, 'e':300, 'f':400}\n",
    "\n",
    "dc = {}\n",
    "dc |= d1\n",
    "dc |= d3\n",
    "dc |= d2 \n",
    "print (dc)\n",
    "# this method only copy the latest value of the key "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 10, 'd': 20, 'e': 30}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'a':1, 'b':2, 'c':3, 'd':4}\n",
    "d2 = {'c':10, 'd':20, 'e':30}\n",
    "d3 = {'d':200, 'e':300, 'f':400}\n",
    "\n",
    "d1.update(d2)\n",
    "print (d1)\n",
    "# this method also does not work: => because it update value of the same key to the latest value "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('a', 1), ('b', 2), ('c', 10), ('d', 20), ('e', 30)])\n",
      "dict_items([('c', 10), ('d', 20), ('e', 30)])\n"
     ]
    }
   ],
   "source": [
    "dic = (**d1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': [1], 'b': [2], 'c': [3, 10], 'd': [4, 20], 'e': [30, 300], 'f': [400]}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def combine_dicts(*args, maxvalues= None):\n",
    "    output = {}\n",
    "    for one_dict in args:   \n",
    "        for key, value in one_dict.items():\n",
    "            if key in output:  \n",
    "                if maxvalues is None or maxvalues > len(output[key]):\n",
    "                    output[key].append(value)\n",
    "            else: \n",
    "                output[key] = [value]\n",
    "                \n",
    "    return output\n",
    "\n",
    "d1 = {'a':1, 'b':2, 'c':3, 'd':4}\n",
    "d2 = {'c':10, 'd':20, 'e':30}\n",
    "d3 = {'d':200, 'e':300, 'f':400}\n",
    "\n",
    "combine_dicts (d1, d2, d3, maxvalues=2)                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc (a, **kwargs):\n",
    "    print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) Write a function (\"report_card\") that produces a generic report\n",
    "    card for a student. (The return value will be a string that can be\n",
    "    printed for all to see.)  The function will take one mandatory\n",
    "    positional argument, the name of the student.\n",
    "\n",
    "    The keyword arguments will represent the names of the different\n",
    "    courses that the student has taken.  Each course will have a\n",
    "    different name, and the value associated with each keyword\n",
    "    argument will be the student's grade.\n",
    "\n",
    "    The returned string should print the name of the student, as well\n",
    "    as courses they took, individual grades in those courses, and then\n",
    "    their average grade.\n",
    "\n",
    "    For example, invoking:\n",
    "\n",
    "    report_card('Eve', English=95, Math=90, History=75, Science=86)\n",
    "\n",
    "    will return a string like the following:\n",
    "\n",
    "    Eve:\n",
    "        English 95\n",
    "        Math    90\n",
    "        History 75\n",
    "        Science 86\n",
    "        Average 86.5\n",
    "\n",
    "    Note that you don't need the formatting to look just like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def report_card (student_name, **grades):\n",
    "    grade = 0\n",
    "    grade_count = 0 \n",
    "    \n",
    "    print(f'{student_name}:')\n",
    "    for value in grades.values():       # calculate the average by extracting the value in each key  \n",
    "            grade += value\n",
    "            grade_count += 1 \n",
    "            average = float(grade / grade_count)  \n",
    "    for key, value in grades.items():   # unwrap the key and value paired in the dictionary \n",
    "        print(f'    {key} {value}')\n",
    "    print(f'    Average: {average:.1f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eve:\n",
      "    English 95\n",
      "    Math 90\n",
      "    History 75\n",
      "    Science 86\n",
      "    Average: 86.5\n"
     ]
    }
   ],
   "source": [
    "report_card('Eve', English=95, Math=90, History=75, Science=86)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eve:\\n\\tEnglish...95\\n\\tMath......90\\n\\tHistory...75\\n\\tScience...86\\n\\tAverage...86.5'"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def report_card (name,**kwargs):\n",
    "    output = f'{name}:\\n'\n",
    "    total = 0\n",
    "    for key, value in kwargs.items():\n",
    "        output += f'\\t{key:.<10}{value}\\n'\n",
    "        total += value\n",
    "    output += f'\\tAverage...{total/len(kwargs)}'\n",
    "    return output\n",
    "\n",
    "report_card('Eve', English=95, Math=90, History=75, Science=86)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eve:\n",
      "\tEnglish...95\n",
      "\tMath......90\n",
      "\tHistory...75\n",
      "\tScience...86\n",
      "\tAverage...86.5\n"
     ]
    }
   ],
   "source": [
    "print (report_card('Eve', English=95, Math=90, History=75, Science=86))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the difference between the two codes are understanding of dictionary.  \n",
    "- didnt think that len of kwargs can be use as len of value => this will avoid making new variable to store value of values \n",
    "- didnt know how to use output properly. the second approach store all the values into output, then just return outout. the first approach does not have a standardize (combine) output into a variable, rather return each of required variable as the result  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x={x}, y ={y}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'x=100, y =[10, 20, 30]'"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 100 \n",
    "y = [10, 20, 30]\n",
    "s = 'x={x}, y ={y}'\n",
    "print (s)\n",
    "s.format(x=x, y=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x=100, y =[10, 20, 30]'"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.format(**globals())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function format:\n",
      "\n",
      "format(...) method of builtins.str instance\n",
      "    S.format(*args, **kwargs) -> str\n",
      "    \n",
      "    Return a formatted version of S, using substitutions from args and kwargs.\n",
      "    The substitutions are identified by braces ('{' and '}').\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(s.format)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "wonder how s.format be able to locate x and y as variables stored in global. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“All vanity plates must start with at least two letters.”\n",
    "“… vanity plates may contain a maximum of 6 characters (letters or numbers) and a minimum of 2 characters.”\n",
    "“Numbers cannot be used in the middle of a plate; they must come at the end. For example, AAA222 would be an acceptable … vanity plate; AAA22A would not be acceptable. The first number used cannot be a ‘0’.”\n",
    "“No periods, spaces, or punctuation marks are allowed.”\n",
    "In plates.py, implement a program that prompts the user for a vanity plate and then output Valid if meets all of the requirements or Invalid if it does not. Assume that any letters in the user’s input will be uppercase. Structure your program per the below, wherein is_valid returns True if s meets all requirements and False if it does not. Assume that s will be a str. You’re welcome to implement additional functions for is_valid to call (e.g., one function per requirement)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    plate = input(\"Plate: \")\n",
    "    if is_valid(plate):\n",
    "        print(\"Valid\")\n",
    "    else:\n",
    "        print(\"Invalid\")\n",
    "\n",
    "\n",
    "def is_valid(s):\n",
    "    if len(s) >= 2 and len(s) <= 6:\n",
    "        if s[0] != '0':\n",
    "            if s != ',./ !@#$%^&*()_+':\n",
    "                for i, char in enumerate(s):\n",
    "                    if char.isdigit():\n",
    "                        if all(c.isdigit() for c in s[i:]):\n",
    "                            return True\n",
    "                \n",
    "            \n",
    "main ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_valid(s):\n",
    "    if len(s) < 2 or len(s) > 6:\n",
    "        return False\n",
    "\n",
    "    if s[0] == '0':\n",
    "        return False\n",
    "\n",
    "    if not s.isalnum():\n",
    "        return False\n",
    "\n",
    "    for i, char in enumerate(s):\n",
    "        if char.isdigit():\n",
    "            if all(c.isdigit() for c in s[i:]):\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) Write a function (\"category_sum\") that takes any keyword arguments\n",
    "    with integer values. The output should be a dictionary with two\n",
    "    keys (\"vowels\" and \"consonants\") whose values will be the total of\n",
    "    the values passed to **kwargs.  Thus, if you call\n",
    "\n",
    "        category_sum(a=1, b=2, c=3, d=4, e=5)\n",
    "\n",
    "    then the output will be\n",
    "\n",
    "        {'vowels':6, 'consonants':9}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'vowels': 2, 'consonants': 10}\n"
     ]
    }
   ],
   "source": [
    "def category_sum(**kwargs):\n",
    "    output = {}\n",
    "    vowels_value = 0 \n",
    "    consonants_value = 0 \n",
    "    for key, value in kwargs.items():\n",
    "        if key in 'aeiou': \n",
    "            vowels_value += kwargs[key]            \n",
    "        else: \n",
    "            consonants_value += kwargs[key]\n",
    "    output['vowels'] = vowels_value\n",
    "    output['consonants'] = consonants_value\n",
    "    print (output)\n",
    "    \n",
    "# search for value of key, then add the value, then add back to vowels  \n",
    " \n",
    "category_sum(w=1, b =2, c=3, d=4, a = 2)           \n",
    "\n",
    "\n",
    "    \n",
    "#string = \"lorem ipsum\"\n",
    "#vowels = len([char for char in string if char.lower() in {'a', 'e', 'i', 'o', 'u'}])\n",
    "#consonants = len([char for char in string if char.isalpha() and char.lower() not in {'a', 'e', 'i', 'o', 'u'}])\n",
    "#print(\"Number of vowels:\", vowels)\n",
    "#print(\"Number of consonants:\", consonants)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main ():\n",
    "    user_input = input('What time is it? ')\n",
    "    convert_hour = convert(user_input)\n",
    "    if 7 <= convert_hour <= 8:\n",
    "        print ('breakfast time')\n",
    "    elif 12 <= convert_hour <= 13:\n",
    "        print ('lunch time')\n",
    "    elif 18 <= convert_hour <= 19:\n",
    "        print ('dinner time')\n",
    "    else:\n",
    "        return\n",
    "\n",
    "def convert(user_input):\n",
    "    hours, minutes = user_input.split(':')\n",
    "    minute_to_hour = round((int(minutes) / 60),2)\n",
    "    convert_hour = int(hours) + minute_to_hour\n",
    "    return convert_hour # initially didnt have this line then python report error TypeError: '<=' not supported between instances of 'int' and 'NoneType'\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n",
    "\n",
    "# not sure how the line if __name__  work  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2) Write a function (\"xml\") that returns a string containing a single\n",
    "    XML tag with optional content and optional attributes.  The content\n",
    "    might already contain XML.  Thus, calling\n",
    "\n",
    "        xml('foo')\n",
    "\n",
    "    will return the string\n",
    "\n",
    "        <foo></foo>\n",
    "\n",
    "    with the opening and closing tags.  And calling\n",
    "\n",
    "        xml('foo', 'bar')\n",
    "\n",
    "    will return the string\n",
    "\n",
    "        <foo>bar</foo>\n",
    "\n",
    "    with the content \"bar\" between the opening and closing tags.  And if we call\n",
    "\n",
    "        xml('foo', 'bar', a=1, b=2, c=3)\n",
    "\n",
    "    then we'll get the string\n",
    "\n",
    "        <foo a=\"1\" b=\"2\" c=\"3\">bar</foo>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function argument: \n",
    "# 1) mandatory, optional, *args, ** kwarge, \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 [10, 20, 30] {'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "x =10 \n",
    "y = [10, 20, 30]\n",
    "z = {'a':1, 'b':2, 'c':3} \n",
    "\n",
    "print (x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using ** when invojing functions\n",
    "def div (a, b): \n",
    "    return a/b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "div (100, 10) # work perfectly fine  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "div() missing 1 required positional argument: 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[4], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m d \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m100\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m10\u001b[39m}\n\u001b[1;32m----> 2\u001b[0m \u001b[43mdiv\u001b[49m\u001b[43m(\u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: div() missing 1 required positional argument: 'b'"
     ]
    }
   ],
   "source": [
    "d = {'a':100, 'b':10}\n",
    "div(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# does not work as function d is expecting 2 positional arguments, python understand that variable d is one positional argument, not the dictionary inside d. to solve this using ** to invoke the content of d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'a':100, 'b':10}\n",
    "div(**d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}