I1qs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a class for a bank and create methods to add clients and to perform transactions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use pandas to convert column of data frame to series\n",
    "Perform arithmetic operations on pandas series and check the elements of two series are same or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Series A:\n",
      " [1 2 3 4 5]\n",
      "Series B:\n",
      " [ 6  7  8  9 10]\n",
      "Sum of Series A and B:\n",
      " [ 7  9 11 13 15]\n",
      "Difference of Series A and B:\n",
      " [-5 -5 -5 -5 -5]\n",
      "Are all elements of Series A and B same? False\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Sample DataFrame\n",
    "data = {\n",
    "    'A': [1, 2, 3, 4, 5],\n",
    "    'B': [6, 7, 8, 9, 10]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Convert a column of the DataFrame to a Series\n",
    "series_A = df['A']\n",
    "series_B = df['B']\n",
    "\n",
    "# Perform arithmetic operations on pandas Series\n",
    "sum_series = series_A + series_B\n",
    "sub_series = series_A - series_B\n",
    "\n",
    "# Check if elements of two Series are the same or not\n",
    "elements_same = (series_A == series_B).all()\n",
    "\n",
    "print(\"Series A:\\n\", series_A.values)\n",
    "print(\"Series B:\\n\", series_B.values)\n",
    "print(\"Sum of Series A and B:\\n\", sum_series.values)\n",
    "print(\"Difference of Series A and B:\\n\", sub_series.values)\n",
    "print(\"Are all elements of Series A and B same?\", elements_same)  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "decorator to count execution time of function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Hi How are you\n",
      "Runtime of my_function: 4.38690185546875e-05 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def runtime_decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        start_time = time.time()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.time()\n",
    "        print(f\"Runtime of {func.__name__}: {end_time - start_time} seconds\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "# Example usage:\n",
    "@runtime_decorator\n",
    "def my_function():\n",
    "    print(\"Hello Hi How are you\")\n",
    "    pass\n",
    "\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decimal to binary using recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The binary representation of 12 is: 1100\n"
     ]
    }
   ],
   "source": [
    "def decimal_to_binary(decimal):\n",
    "    if decimal == 0:\n",
    "        return '0'  # Base case: Decimal 0 is binary 0\n",
    "    elif decimal == 1:\n",
    "        return '1'  # Base case: Decimal 1 is binary 1\n",
    "    else:\n",
    "        return decimal_to_binary(decimal // 2) + str(decimal % 2)\n",
    "\n",
    "# Test the function\n",
    "decimal_num = 12\n",
    "binary_num = decimal_to_binary(decimal_num)\n",
    "print(f\"The binary representation of {decimal_num} is: {binary_num}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "decorator to convert data type "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result of divide function (converted to float): 5.0\n",
      "Result of concatenate function (converted to int): 1020\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 29\u001b[0m\n\u001b[1;32m     26\u001b[0m result2 \u001b[38;5;241m=\u001b[39m concatenate(\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m20\u001b[39m)\n\u001b[1;32m     27\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResult of concatenate function (converted to int):\u001b[39m\u001b[38;5;124m\"\u001b[39m, result2)\n\u001b[0;32m---> 29\u001b[0m result3 \u001b[38;5;241m=\u001b[39m \u001b[43mdivide\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m2\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     30\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mResult of divide function (error handling):\u001b[39m\u001b[38;5;124m\"\u001b[39m, result3)\n",
      "Cell \u001b[0;32mIn[5], line 4\u001b[0m, in \u001b[0;36mconvert_data_type.<locals>.decorator.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m----> 4\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m      6\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m data_type(result)\n",
      "Cell \u001b[0;32mIn[5], line 16\u001b[0m, in \u001b[0;36mdivide\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;129m@convert_data_type\u001b[39m(\u001b[38;5;28mfloat\u001b[39m)\n\u001b[1;32m     15\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdivide\u001b[39m(a, b):\n\u001b[0;32m---> 16\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "def convert_data_type(data_type):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            result = func(*args, **kwargs)\n",
    "            try:\n",
    "                return data_type(result)\n",
    "            except (ValueError, TypeError):\n",
    "                print(f\"Error: Cannot convert {result} to {data_type.__name__}.\")\n",
    "                return None\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "# Example usage:\n",
    "@convert_data_type(float)\n",
    "def divide(a, b):\n",
    "    return a / b\n",
    "\n",
    "@convert_data_type(int)\n",
    "def concatenate(a, b):\n",
    "    return str(a) + str(b)\n",
    "\n",
    "# Test the decorated functions\n",
    "result1 = divide(10, 2)\n",
    "print(\"Result of divide function (converted to float):\", result1)\n",
    "\n",
    "result2 = concatenate(10, 20)\n",
    "print(\"Result of concatenate function (converted to int):\", result2)\n",
    "\n",
    "result3 = divide(10, '2')\n",
    "print(\"Result of divide function (error handling):\", result3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "reversed transpose of numpy 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "Reversed transpose of the array:\n",
      "[[3 6 9]\n",
      " [2 5 8]\n",
      " [1 4 7]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create a sample 2D NumPy array\n",
    "array_2d = np.array([[1, 2, 3],\n",
    "                      [4, 5, 6],\n",
    "                      [7, 8, 9]])\n",
    "\n",
    "# Transpose the array\n",
    "transposed_array = np.transpose(array_2d)\n",
    "\n",
    "# Reverse the order of rows in the transposed array\n",
    "reversed_transpose_array = np.flip(transposed_array, axis=0)\n",
    "\n",
    "print(\"Original array:\")\n",
    "print(array_2d)\n",
    "\n",
    "print(\"\\nReversed transpose of the array:\")\n",
    "print(reversed_transpose_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fn to convert string to Palindrome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Palindrome: abcbabdbabcba\n"
     ]
    }
   ],
   "source": [
    "def make_palindrome(s):\n",
    "    return s+s[::-1][1:]\n",
    "\n",
    "# Test the function\n",
    "string = input(\"Enter a string: \")\n",
    "palindrome = make_palindrome(string)\n",
    "print(\"Palindrome:\", palindrome)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "convert to decimal to bin, oct, hex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Binary: 0b101\n",
      "Octal: 0o5\n",
      "Hexadecimal: 0x5\n"
     ]
    }
   ],
   "source": [
    "decimal_number = int(input(\"Enter a decimal number: \"))\n",
    "\n",
    "binary_number = bin(decimal_number)\n",
    "octal_number = oct(decimal_number)\n",
    "hexadecimal_number = hex(decimal_number)\n",
    "\n",
    "print(\"Binary:\", binary_number)\n",
    "print(\"Octal:\", octal_number)\n",
    "print(\"Hexadecimal:\", hexadecimal_number)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use decorators to log arguments of a function and return a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arguments: (3, 5) {}\n",
      "Result: 8\n"
     ]
    }
   ],
   "source": [
    "def log_arguments(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(\"Arguments:\", args, kwargs)\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@log_arguments\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "result = add(3, 5)\n",
    "print(\"Result:\", result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorting a list of tuples where each tuple has 2 elements and sorting the tuples based on second element\n",
    "\n",
    "Ex. List1 = [('a', 2),('b',1)]\n",
    "Sorted list = [('b', 1),('a',2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('b', 1), ('a', 2)]\n"
     ]
    }
   ],
   "source": [
    "List1 = [('a', 2),('b',1)]\n",
    "sorted_list=sorted(List1,key=lambda x:x[1])\n",
    "print(sorted_list)"
   ]
  }
 ],
 "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}