Assignment 14.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ed68e0ba",
   "metadata": {},
   "source": [
    "# Q1. Is an assignment operator like += only for show? Is it possible that it would lead to faster results at the runtime ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b94ee06",
   "metadata": {},
   "source": [
    "A=A+1 evaluates to finding A, adding 1 to it. Then storing the value again in variable A. This expression makes Python to look for memory holder of 'a' twice. But A+=1 simply means value of A is to incremented by 1. As memory address has to be identified once, += leads to faster operation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d660dc03",
   "metadata": {},
   "source": [
    "# Q2. What is the smallest no of statements you'd have to write in most programming languages to replace the Python expr a, b = a + b, a ?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f2c60c3",
   "metadata": {},
   "source": [
    "Minimum number of lines required to write above code in languages other Python will be 4, two for assigning initial values for variables a and b, and two for reassignment i.e. a=a+b and b=a."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b8a9b09",
   "metadata": {},
   "source": [
    "# Q3. In Python, what is the most effective way to set a list of 100 integers to 0?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "312de1cb",
   "metadata": {},
   "source": [
    "The Most effective way to set a list of 100 integers to 0 in python is by using repition operator(*) or by using list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3b99004d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "# Method 1\n",
    "list_zero=[0]*100\n",
    "print(list_zero)\n",
    "# Method 2\n",
    "zero_list = [0 for x in range(100)]\n",
    "print(zero_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00d46cd6",
   "metadata": {},
   "source": [
    "# Q4. What is the most effective way to initialise a list of 99 integers that repeats the sequence 1, 2, 3? S If necessary, show step-by-step instructions on how to accomplish this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "601908cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]*33\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c049521f",
   "metadata": {},
   "source": [
    "# Q5. If you're using IDLE to run a Python application, explain how to print a multidimensional list as efficiently?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e0b5326e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 2 3 3 4 4 5 5 "
     ]
    }
   ],
   "source": [
    "my_list = [[1,1],[2,2],[3,3],[4,4],[5,5]] # 2 dimensional List\n",
    "for x in range(len(my_list)):\n",
    "    for y in range(len(my_list[x])):\n",
    "        print(my_list[x][y],end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e7749ea",
   "metadata": {},
   "source": [
    "# Q6. Is it possible to use list comprehension with a string? If so, how can you go about doing it?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c47413",
   "metadata": {},
   "source": [
    "List comprehension with string is possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0f36fb4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i', 'N', 'e', 'u', 'r', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "my_list = [ele for ele in 'iNeuron']\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d784b41",
   "metadata": {},
   "source": [
    "# Q7. From the command line, how do you get support with a user-written Python programme? Is this possible from inside IDLE?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33791587",
   "metadata": {},
   "source": [
    "Get support with a user-written Python Programme: Start a command prompt (Windows) or terminal window (Linux/Mac). If the current working directory is the same as the location in which you saved the file, you can simply specify the filename as a command-line argument to the Python interpreter.\n",
    "\n",
    "Get support with a User-written Python Program from IDLE: You can also create script files and run them in IDLE. From the Shell window menu, select File → New File. That should open an additional editing window. Type in the code to be executed. From the menu in that window, select File → Save or File → Save As… and save the file to disk. Then select Run → Run Module. The output should appear back in the interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a29c09",
   "metadata": {},
   "source": [
    "# Q8. Functions are said to be “first-class objects” in Python but not in most other languages, such as C++ or Java. What can you do in Python with a function (callable object) that you can't do in C or C++?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b258b4fe",
   "metadata": {},
   "source": [
    "The tasks which can be performed with the functions in python are:\n",
    "\n",
    "1.A function is an instance of the Object type.\n",
    "\n",
    "2.You can store the function in a variable.\n",
    "\n",
    "3.You can pass the function as a parameter to another function.\n",
    "\n",
    "4.You can return the function from a function.\n",
    "\n",
    "5.You can store them in data structures such as hash tables, lists,"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76a86107",
   "metadata": {},
   "source": [
    "# Q9. How do you distinguish between a wrapper, a wrapped feature, and a decorator?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b40d2ff5",
   "metadata": {},
   "source": [
    "Wrappers Around the functions are known as Decrators."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fadc75ea",
   "metadata": {},
   "source": [
    "# Q10. If a function is a generator function, what does it return?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff30e958",
   "metadata": {},
   "source": [
    "Generator functions are a special kind of function that return a lazy iterator. These are objects that you can loop over like a list. However, unlike lists, lazy iterators do not store their contents in memory."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d45563",
   "metadata": {},
   "source": [
    "# Q11. What is the one improvement that must be made to a function in order for it to become a generator function in the Python language?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "299792ba",
   "metadata": {},
   "source": [
    "Generator is a written as normal function but uses yield keyword to return values instead of return keyword."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cbd6e7",
   "metadata": {},
   "source": [
    "# Q12. Identify at least one benefit of generators."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39a6c5ce",
   "metadata": {},
   "source": [
    "return statement sends a specified value back to its caller whereas yield statment can produce a sequence of values. We should use generator when we want to iterate over a sequence, but don’t want to store the entire sequence in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90aabf5c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}