python_functions_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LAB | Python Functions Exercises\n",
    "\n",
    "These exercises will help you practice defining functions in Python while empthising your understanding of various programming concepts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 1: Find Maximum of Three Numbers\n",
    "Create a function that takes three numbers as arguments and returns the maximum value among them.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here\n",
    "def maximum(a,b,c):\n",
    "    maxi = float(\"-inf\")\n",
    "    if a > maxi:\n",
    "        maxi = a\n",
    "    if b > maxi:\n",
    "        maxi = b\n",
    "    if c > maxi:\n",
    "        maxi = c\n",
    "    return maxi\n",
    "\n",
    "maximum(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 2: Sum of List Elements\n",
    "Write a function that calculates the total sum of all numbers in a given list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `[8, 2, 3, 0, 7]`\n",
    "\n",
    "*Expected Output*: `20`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here\n",
    "def sum(lst):\n",
    "    value = 0\n",
    "    for num in lst:\n",
    "        value += num\n",
    "    return value\n",
    "\n",
    "sum([8, 2, 3, 0, 7])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 3: Product of List Elements\n",
    "Define a function that multiplies all the integers in a list and returns the result.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `[8, 2, 3, -1, 7]`\n",
    "\n",
    "*Expected Output*: `-336`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-336"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here\n",
    "def product(lst):\n",
    "    value = 1\n",
    "    for num in lst:\n",
    "        value *= num\n",
    "    return value\n",
    "\n",
    "product([8, 2, 3, -1, 7])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 4: Reverse a Given String\n",
    "Write a function that takes a string as input and returns the string reversed.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `\"abcd1234\"`\n",
    "\n",
    "*Expected Output*: `\"4321dcba\"`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4321dcba'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here\n",
    "def reverse(string: str):\n",
    "    reversed_string = \"\"\n",
    "    length = len(string)\n",
    "    for i in range(length):\n",
    "        reversed_string += string[length - i - 1]\n",
    "    return reversed_string\n",
    "\n",
    "\n",
    "reverse(\"abcd1234\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 5: Calculate Factorial\n",
    "Implement a function that computes the factorial of a non-negative integer passed as an argument.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here\n",
    "def factorial(n):\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    return n * factorial(n - 1)\n",
    "\n",
    "factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 6: Check Number Range\n",
    "Create a function that checks if a given number is within a specified range (inclusive).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def range_check(num, lower, upper):\n",
    "    if lower <= num <= upper:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "print(range_check(5,3,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 7: Count Upper and Lower Case Letters\n",
    "Write a function that takes a string and counts the number of uppercase and lowercase letters.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `\"The Quick Brown Fox\"`\n",
    "\n",
    "\n",
    "*Expected Output*:\n",
    "\n",
    "Uppercase letters: 3\n",
    "\n",
    "Lowercase letters: 12\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uppercase: 12 || Lowercase: 4\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def letter_count(string):\n",
    "    upper = 0\n",
    "    lower = 0\n",
    "    for letter in string:\n",
    "        if 97 <= ord(letter) <= 122:\n",
    "            upper += 1\n",
    "        elif 65 <= ord(letter) <= 90:\n",
    "            lower += 1\n",
    "    print(f\"Uppercase: {upper} || Lowercase: {lower}\")\n",
    "\n",
    "letter_count(\"The Quick Brown Fox\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 8: Unique Elements from List\n",
    "Define a function that accepts a list and returns a new list containing only distinct elements.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `[1, 2, 3, 3, 4, 5]`\n",
    "\n",
    "*Expected Output*: `[1, 2, 3, 4, 5]`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def unique_list(lst):\n",
    "    new_list = []\n",
    "    for element in lst:\n",
    "        if element in new_list:\n",
    "            continue\n",
    "        else:\n",
    "            new_list.append(element)\n",
    "    return new_list\n",
    "\n",
    "print(unique_list([1, 2, 3, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 9: Prime Number Checker\n",
    "Create a function that checks if the given number is prime or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is a prime\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def prime_check(num):\n",
    "    for i in range(2, num):\n",
    "        if num % i == 0:\n",
    "            print(\"Not a prime\")\n",
    "            return\n",
    "    print(\"Is a prime\")\n",
    "\n",
    "prime_check(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 10: Extract Even Numbers from List\n",
    "Write a function that filters out even numbers from the provided list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `[1, 2, 3, 4, 5, 6]`\n",
    "\n",
    "*Expected Output*: `[2, 4, 6]`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def even_number(numbers):\n",
    "    evens = []\n",
    "    for num in numbers:\n",
    "        if num % 2 == 0:\n",
    "            evens.append(num)\n",
    "    return evens\n",
    "\n",
    "print(even_number([1, 2, 3, 4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 11: Perfect Number Checker\n",
    "Implement a function to determine if a number is \"Perfect\". A perfect number is equal to the sum of its proper divisors (excluding itself).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perfect number\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def perfect_num(num):\n",
    "    sum_divisors = 0\n",
    "    for i in range(1 , num):\n",
    "        if num % i == 0:\n",
    "            sum_divisors += i\n",
    "    if num == sum_divisors:\n",
    "        print(\"Perfect number\")\n",
    "    else:\n",
    "        print(\"Nice try\")\n",
    "\n",
    "perfect_num(8128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 12: Palindrome Checker\n",
    "Write a function to check if the input string is a palindrome (reads the same forwards and backwards).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not a palindrom\n"
     ]
    }
   ],
   "source": [
    "def palindrom(string):\n",
    "    if string.lower() == reverse(string.lower()): #using earlire defined function reverse\n",
    "        print(\"Is a palindrom\")\n",
    "    else:\n",
    "        print(\"not a palindrom\")\n",
    "\n",
    "palindrom(\"Anna\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 13: Generate Pascal's Triangle\n",
    "Create a function that prints the first `n` rows of Pascal's triangle.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "\n",
    "def pascal(n):\n",
    "    levels = []\n",
    "    for i in range(n):\n",
    "        level = []\n",
    "        for j in range(i+1):\n",
    "          if j == 0 or j == i:\n",
    "              level.append(1)\n",
    "          else:\n",
    "              level.append(levels[i-1][j-1] + levels[i-1][j])\n",
    "        levels.append(level)\n",
    "        \n",
    "    print(levels)\n",
    "\n",
    "pascal(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 14: Pangram Checker\n",
    "Define a function to check if the input string is a pangram (contains every letter of the alphabet at least once).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `\"The quick brown fox jumps over the lazy dog\"`\n",
    "\n",
    "*Expected Output*: `True`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is a pangram\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def pangram(string):\n",
    "    alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "    for letter in alphabet:\n",
    "        if letter in string.lower():\n",
    "            continue\n",
    "        else:\n",
    "            print(\"not a pangram\")\n",
    "            return\n",
    "    print(\"is a pangram\")\n",
    "    return\n",
    "        \n",
    "pangram(\"The quick brown fox jumps over the lazy dog\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 15: Sort Hyphen-Separated Words\n",
    "Write a program that takes hyphen-separated words as input and prints them in alphabetical order.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Input*: `\"green-red-yellow-black-white\"`\n",
    "\n",
    "*Expected Output*: `\"black-green-red-white-yellow\"`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "black-green-red-white-yellow-\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def sort_text(string):\n",
    "    words = []\n",
    "    word = \"\"\n",
    "    for character in string:\n",
    "        if character == \"-\":\n",
    "            words.append(word)\n",
    "            word = \"\"\n",
    "        else:\n",
    "            word += character \n",
    "    words.append(word) # for the last word\n",
    "\n",
    "    words.sort()\n",
    "\n",
    "    output = \"\"\n",
    "    for word in words:\n",
    "        output += word + \"-\"\n",
    "    \n",
    "    print(output)\n",
    "\n",
    "sort_text(\"green-red-yellow-black-white\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 16: Generate Squares of Numbers\n",
    "Create a function that generates and prints squares of numbers from `1` to `30`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "100\n",
      "121\n",
      "144\n",
      "169\n",
      "196\n",
      "225\n",
      "256\n",
      "289\n",
      "324\n",
      "361\n",
      "400\n",
      "441\n",
      "484\n",
      "529\n",
      "576\n",
      "625\n",
      "676\n",
      "729\n",
      "784\n",
      "841\n",
      "900\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def squares(n):\n",
    "    for i in range (1, n+1):\n",
    "        print(i**2)\n",
    "\n",
    "squares(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 17: Function Decorators\n",
    "Implement decorators to apply multiple formatting styles (bold, italic) to text output.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'**_Hello, World!_**'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Your code here\n",
    "def bold(func):\n",
    "    def wrapper():\n",
    "        result = func()\n",
    "        return f\"**{result}**\"\n",
    "    return wrapper\n",
    "\n",
    "def italic(func):\n",
    "    def wrapper():\n",
    "        result = func()\n",
    "        return f\"_{result}_\"\n",
    "    return wrapper\n",
    "\n",
    "@bold\n",
    "@italic\n",
    "def say_hello():\n",
    "    return \"Hello, World!\"\n",
    "\n",
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 18: Execute Python Code from String\n",
    "Write a program that executes Python code contained in a string variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "code = \"\"\"\n",
    "def greet():\n",
    "    print(\"Hello, World!\")\n",
    "\n",
    "greet()\n",
    "\"\"\"\n",
    "\n",
    "exec(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 19: Nested Function Access\n",
    "Define two functions where one function calls another inside it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, martijn\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "def enter_name():\n",
    "    name = input(\"enter your name\")\n",
    "    return name\n",
    "\n",
    "def greet():\n",
    "    name = enter_name()\n",
    "    print(f\"Hello, {name}\")\n",
    "\n",
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 20: Count Local Variables\n",
    "Create a function that counts how many local variables are declared within it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*Example Output*: `3`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def count_local_variables():\n",
    "    a = 1\n",
    "    b = 2\n",
    "    c = 3\n",
    "    local_vars = locals()\n",
    "    return len(local_vars)\n",
    "\n",
    "# Test the function\n",
    "print(count_local_variables())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Happy coding!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "datasci_env",
   "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.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}