01_120_Python_Basics_Interview_Questions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Data Science Interview Questions** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/DataScience_Interview_Questions)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics ➞ <span class='label label-default'>120 Questions</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. What is Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Python is a high-level, interpreted, interactive and object-oriented scripting language. Python is designed to be highly readable. It uses English keywords frequently where as other languages use punctuation, and it has fewer syntactical constructions than other languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Name some of the features of Python.\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "Following are some of the salient features of python −\n",
    "\n",
    "* It supports functional and structured programming methods as well as OOP.\n",
    "\n",
    "* It can be used as a scripting language or can be compiled to byte-code for building large applications.\n",
    "\n",
    "* It provides very high-level dynamic data types and supports dynamic type checking.\n",
    "\n",
    "* It supports automatic garbage collection.\n",
    "\n",
    "* It can be easily integrated with C, C++, COM, ActiveX, CORBA, and Java."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. What is the purpose of PYTHONPATH environment variable?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- PYTHONPATH - It has a role similar to PATH. This variable tells the Python interpreter where to locate the module files imported into a program. It should include the Python source library directory and the directories containing Python source code. PYTHONPATH is sometimes preset by the Python installer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. What is the purpose of PYTHONSTARTUP environment variable?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- PYTHONSTARTUP - It contains the path of an initialization file containing Python source code. It is executed every time you start the interpreter. It is named as .pythonrc.py in Unix and it contains commands that load utilities or modify PYTHONPATH."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. What is the purpose of PYTHONCASEOK environment variable?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- PYTHONCASEOK − It is used in Windows to instruct Python to find the first case-insensitive match in an import statement. Set this variable to any value to activate it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.  What is the purpose of PYTHONHOME environment variable?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- PYTHONHOME − It is an alternative module search path. It is usually embedded in the PYTHONSTARTUP or PYTHONPATH directories to make switching module libraries easy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Is python a case sensitive language?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Yes! Python is a case sensitive programming language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. What are the supported data types in Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Python has five standard data types:\n",
    "    1. Numbers\n",
    "    2. String\n",
    "    3. List\n",
    "    4. Tuple\n",
    "    5. Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. What is the output of print `str` if `str = 'Hello World!'`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print complete string. \n",
    "- Output would be `Hello World!`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. What is the output of print `str[0]` if `str = 'Hello World!'`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print first character of the string. Output would be H."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. What is the output of print `str[2:5]` if `str = 'Hello World!'`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print characters starting from 3rd to 5th. \n",
    "- Output would be `llo`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. What is the output of print `str[2:]` if `str = 'Hello World!'`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print characters starting from 3rd character. \n",
    "- Output would be `llo World!`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13. What is the output of print `str * 2` if `str = 'Hello World!'`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print string two times. \n",
    "- Output would be `Hello World!Hello World!`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 14. What is the output of print `str + \"TEST\"` if `str = 'Hello World!'`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print concatenated string. \n",
    "- Output would be `Hello World!TEST`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15. What is the output of print `list` if `list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print complete list. \n",
    "- Output would be `['abcd', 786, 2.23, 'john', 70.200000000000003]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 16. What is the output of print `list[0]` if `list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print first element of the list. \n",
    "- Output would be `abcd`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 17.  What is the output of print `list[1:3]` if `list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print elements starting from 2nd till 3rd. \n",
    "- Output would be `[786, 2.23]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18. What is the output of print `list[2:]` if `list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print elements starting from 3rd element. \n",
    "- Output would be `[2.23, 'john', 70.200000000000003]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 19. What is the output of print `tinylist * 2` if `tinylist = [123, 'john']`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print list two times. \n",
    "- Output would be `[123, 'john', 123, 'john']`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 20. What is the output of print `list1 + list2`, if `list1 = [ 'abcd', 786 , 2.23, 'john', 70.2 ] and ist2 = [123, 'john']`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print concatenated lists. \n",
    "- Output would be `['abcd', 786, 2.23, 'john', 70.2, 123, 'john']`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 21. What are tuples in Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- A tuple is another sequence data type that is similar to the list. \n",
    "- A tuple consists of a number of values separated by commas. \n",
    "- Unlike lists, however, tuples are enclosed within parentheses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 22. What is the difference between tuples and lists in Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- The main differences between lists and tuples are: \n",
    "    - Lists are enclosed in brackets `[ ]` and their elements and size can be changed, while tuples are enclosed in parentheses `( )` and cannot be updated. \n",
    "    - Tuples can be thought of as read-only lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 23. What is the output of print `tuple` if `tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print complete tuple. \n",
    "- Output would be `('abcd', 786, 2.23, 'john', 70.200000000000003)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 24. What is the output of print `tuple[0]` if `tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print first element of the tuple. \n",
    "- Output would be `abcd`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 25. What is the output of print `tuple[1:3]` if `tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print elements starting from 2nd till 3rd. \n",
    "- Output would be `(786, 2.23)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 26. What is the output of print `tuple[2:]` if `tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print elements starting from 3rd element. \n",
    "- Output would be `(2.23, 'john', 70.200000000000003)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 27. What is the output of print `tinytuple * 2` if `tinytuple = (123, 'john')`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print tuple two times. \n",
    "- Output would be `(123, 'john', 123, 'john')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 28. What is the output of print `tuple + tinytuple` if `tuple = ( 'abcd', 786, 2.23, 'john', 70.2 )` and `tinytuple = (123, 'john')`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- It will print concatenated tuples. \n",
    "- Output would be `('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 29. What are Python's dictionaries?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Python's dictionaries are kind of hash table type. \n",
    "- They work like associative arrays or hashes found in Perl and consist of key-value pairs. \n",
    "- A dictionary key can be almost any Python type, but are usually numbers or strings. \n",
    "- Values, on the other hand, can be any arbitrary Python object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 30. How will you create a dictionary in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Dictionaries are enclosed by curly braces `{ }` and values can be assigned and accessed using square braces `[]`.\n",
    "\n",
    "```python\n",
    "dict = {}\n",
    "dict['one'] = \"This is one\"\n",
    "dict[2]     = \"This is two\"\n",
    "tinydict = {'name': 'john','code':6734, 'dept': 'sales'}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 31. How will you get all the keys from the dictionary?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Using `dictionary.keys()` function, we can get all the keys from the dictionary object.\n",
    "\n",
    "```python\n",
    "print dict.keys()   # Prints all the keys\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 32. How will you get all the values from the dictionary?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Using `dictionary.values()` function, we can get all the values from the dictionary object.\n",
    "\n",
    "```python\n",
    "print dict.values()   # Prints all the values\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 33. How will you convert a string to an int in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `int(x [,base])` - Converts `x` to an integer. `base` specifies the base if `x` is a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 34. How will you convert a string to a long in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `long(x [,base] )` - Converts `x` to a long integer. `base` specifies the base if `x` is a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 35. How will you convert a string to a float in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `float(x)` − Converts `x` to a floating-point number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 36. How will you convert a object to a string in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `str(x)` − Converts object `x` to a string representation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 37. How will you convert a object to a regular expression in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `repr(x)` − Converts object `x` to an expression string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 38. How will you convert a String to an object in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `eval(str)` − Evaluates a string and returns an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 39. How will you convert a string to a tuple in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `tuple(s)` − Converts `s` to a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 40. How will you convert a string to a list in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `list(s)` − Converts `s` to a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 41. How will you convert a string to a set in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `set(s)` − Converts `s` to a set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 42. How will you create a dictionary using tuples in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `dict(d)` − Creates a dictionary. `d` must be a sequence of (key,value) tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 43. How will you convert a string to a frozen set in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `frozenset(s)` − Converts `s` to a frozen set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 44. How will you convert an integer to a character in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `chr(x)` − Converts an integer to a character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 45. How will you convert an integer to an unicode character in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `unichr(x)` − Converts an integer to a Unicode character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 46. How will you convert a single character to its integer value in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `ord(x)` − Converts a single character to its integer value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 47. How will you convert an integer to hexadecimal string in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `hex(x)` − Converts an integer to a hexadecimal string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 48. How will you convert an integer to octal string in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `oct(x)` − Converts an integer to an octal string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 49. What is the purpose of `**` operator?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `**` Exponent − Performs exponential (power) calculation on operators. \n",
    "- `a**b` = 10 to the power 20 if `a = 10` and `b = 20`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 50. What is the purpose of `//` operator?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `//` Floor Division − The division of operands where the result is the quotient in which the digits after the decimal point are removed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 51. What is the purpose of `is` operator?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `is` − Evaluates to `True` if the variables on either side of the operator point to the same object and false otherwise. `x` is `y`, here is results in 1 if `id(x)` equals `id(y)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 52. What is the purpose of `not in` operator?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `not in` − Evaluates to `True` if it does not finds a variable in the specified sequence and false otherwise. `x` not in `y`, here not in results in a 1 if `x` is not a member of sequence `y`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 53. What is the purpose `break` statement in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `break` statement − Terminates the loop statement and transfers execution to the statement immediately following the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 54. What is the purpose `continue` statement in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `continue` statement − Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 55. What is the purpose `pass` statement in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `pass` statement − The `pass` statement in Python is used when a statement is required syntactically but you do not want any command or code to execute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 56. How can you pick a random item from a list or tuple?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `choice(seq)` − Returns a random item from a list, tuple, or string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 57. How can you pick a random item from a range?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "-  `randrange ([start,] stop [,step])` − returns a randomly selected element from range(start, stop, step)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 58. How can you get a random number in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `random()` − returns a random float `r`, such that 0 is less than or equal to `r` and `r` is less than 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 59. How will you set the starting value in generating random numbers?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `seed([x])` − Sets the integer starting value used in generating random numbers. Call this function before calling any other random module function. Returns `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 60. How will you randomizes the items of a list in place?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `shuffle(lst)` − Randomizes the items of a list in place. Returns `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 61. How will you capitalizes first letter of string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `capitalize()` − Capitalizes first letter of string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 62. How will you check in a string that all characters are alphanumeric?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `isalnum()` − Returns `True` if string has at least 1 character and all characters are alphanumeric and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 63. How will you check in a string that all characters are digits?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `isdigit()` − Returns `True` if string contains only digits and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 64. How will you check in a string that all characters are in lowercase?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `islower()` − Returns `True` if string has at least 1 cased character and all cased characters are in lowercase and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 65. How will you check in a string that all characters are numerics?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `isnumeric()` − Returns `True` if a unicode string contains only numeric characters and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 66. How will you check in a string that all characters are whitespaces?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `isspace()` − Returns `True` if string contains only whitespace characters and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 67. How will you check in a string that it is properly titlecased?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `istitle()` − Returns `True` if string is properly \"titlecased\" and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 68. How will you check in a string that all characters are in uppercase?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `isupper()` − Returns `True` if string has at least one cased character and all cased characters are in uppercase and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 69. How will you merge elements in a sequence?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `join(seq)` − Merges (concatenates) the string representations of elements in sequence `seq` into a string, with separator string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 70. How will you get the length of the string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `len(string)` − Returns the length of the string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 71. How will you get a space-padded string with the original string left-justified to a total of width columns?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `ljust(width[, fillchar])` − Returns a space-padded string with the original string left-justified to a total of width columns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 72. How will you convert a string to all lowercase?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `lower()` − Converts all uppercase letters in string to lowercase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 73. How will you remove all leading whitespace in string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `lstrip()` − Removes all leading whitespace in string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 74. How will you get the max alphabetical character from the string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `max(str)` − Returns the `max` alphabetical character from the string `str`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 75. How will you get the min alphabetical character from the string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- ``min(str)` − Returns the `min` alphabetical character from the string `str`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 76. How will you replaces all occurrences of old substring in string with new string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `replace(old, new [, max])` − Replaces all occurrences of old in string with new or at most max occurrences if `max` given."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 77. How will you remove all leading and trailing whitespace in string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `strip([chars])` − Performs both `lstrip()` and `rstrip()` on string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 78. How will you change case for all letters in string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `swapcase()` − Inverts case for all letters in string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 79. How will you get titlecased version of string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `title()` − Returns \"titlecased\" version of string, that is, all words begin with uppercase and the rest are lowercase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 80. How will you convert a string to all uppercase?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `upper()` − Converts all lowercase letters in string to uppercase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 81. How will you check in a string that all characters are decimal?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `isdecimal()` − Returns `True` if a unicode string contains only decimal characters and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 82. What is the difference between `del()` and `remove()` methods of list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- To remove a list element, you can use either the `del` statement if you know exactly which element(s) you are deleting or the `remove()` method if you do not know."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 83. What is the output of `len([1, 2, 3])`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `3`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 84. What is the output of `[1, 2, 3] + [4, 5, 6]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `[1, 2, 3, 4, 5, 6]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 85. What is the output of `['Hi!'] * 4`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `['Hi!', 'Hi!', 'Hi!', 'Hi!']`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 86. What is the output of 3 in `[1, 2, 3]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `True`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 87. What is the output of for `x in [1, 2, 3]: print x`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "```python\n",
    "1\n",
    "2\n",
    "3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 88. What is the output of `L[2]` if `L = [1,2,3]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `3`, Offsets start at zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 89. What is the output of `L[-2]` if `L = [1,2,3]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `1`, Negative: count from the right."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 90. What is the output of `L[1:]` if `L = [1,2,3]`?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `2, 3`, Slicing fetches sections."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 91. How will you compare two lists?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `cmp(list1, list2)` − Compares elements of both lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 92. How will you get the length of a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `len(list)` − Gives the total length of the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 93. How will you get the max valued item of a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `max(list)` − Returns item from the list with max value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 94. How will you get the min valued item of a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `min(list)` − Returns item from the list with min value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 95. How will you get the index of an object in a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `list.index(obj)` − Returns the lowest index in list that `obj` appears."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 96. How will you insert an object at given index in a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `list.insert(index, obj)` − Inserts object `obj` into list at offset index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 97. How will you remove last object from a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "`list.pop(obj=list[-1])` − Removes and returns last object or obj from list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 98. How will you remove an object from a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `list.remove(obj)` − Removes object `obj` from list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 99. How will you reverse a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `list.reverse()` − Reverses objects of list in place."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 100. How will you sort a list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `list.sort([func])` − Sorts objects of list, use compare `func` if given."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 101. What is lambda function in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `‘lambda’` is a keyword in python which creates an anonymous function. Lambda does not contain block of statements. It does not contain return statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 102. What we call a function which is incomplete version of a function?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `Stub`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 103. When a function is defined then the system stores parameters and local variables in an area of memory. What this memory is known as?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `Stack`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 104. A canvas can have a foreground color? (Yes/No)\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `Yes`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 105. Is Python platform independent?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- No. There are some modules and functions in python that can only run on certain platforms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 106. Do you think Python has a complier?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Yes. Python complier which works automatically so we don’t notice the compiler of python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 107. What are the applications of Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "1. Django (Web framework of Python).\n",
    "\n",
    "2. Micro Frame work such as Flask and Bottle.\n",
    "\n",
    "3. Plone and Django CMS for advanced content Management."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 108. What is the basic difference between Python ver 2 and Python ver 3?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Table below explains the difference between Python version 2 and Python version 3.\n",
    "\n",
    "| S.No | Section | Python Version 2 | Python Version 3 | \n",
    "|:-------|:---------------| :------ |:--------|\n",
    "| 1. | Print Function | Print command can be used without parentheses. | Python 3 needs parentheses to print any string. It will raise error without parentheses. | \n",
    "| 2. | Unicode | ASCII str() types and separate Unicode() but there is no byte type code in Python 2. | Unicode (utf-8) and it has two byte classes − Byte, Bytearray S. |\n",
    "| 3. | Exceptions | Python 2 accepts both new and old notations of syntax. | Python 3 raises a SyntaxError in turn when we don’t enclose the exception argument in parentheses. |\n",
    "| 4. | Comparing Unorderable | It does not raise any error. | It raises ‘TypeError’ as warning if we try to compare unorderable types. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 109. Which programming Language is an implementation of Python programming language designed to run on Java Platform?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `Jython`. (Jython is successor of Jpython.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 110. Is there any double data type in Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `No`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 111. Is String in Python are immutable? (Yes/No)\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `Yes`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 112. Can `True = False` be possible in Python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `No`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 113. Which module of python is used to apply the methods related to OS.?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `OS`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 114. When does a new block begin in python?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- A block begins when the line is intended by 4 spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 115. Write a function in python which detects whether the given two strings are anagrams or not.\n",
    "\n",
    "<span class='label label-default'>Solution</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-22T07:53:06.172548Z",
     "start_time": "2021-09-22T07:53:06.155950Z"
    }
   },
   "outputs": [],
   "source": [
    "def check(a,b):\n",
    "    if(len(a)!=len(b)):\n",
    "        return False\n",
    "    else:\n",
    "        if(sorted(list(a)) == sorted(list(b))):\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 116. Name the python Library used for Machine learning.\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- Scikit-learn python Library used for Machine learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 117. What does `pass` operation do?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `pass` indicates that nothing is to be done i.e., it signifies a no operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 118. Name the tools which python uses to find bugs (if any).\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "- `Pylint` and `pychecker`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 119. Write a function to give the sum of all the numbers in list?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "Sample list − (100, 200, 300, 400, 0, 500)\n",
    "\n",
    "Expected output − 1500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-22T07:53:06.492373Z",
     "start_time": "2021-09-22T07:53:06.180366Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the numbers:  1500\n"
     ]
    }
   ],
   "source": [
    "# Program for sum of all the numbers in list is −\n",
    "\n",
    "def sum(numbers):\n",
    "    total = 0\n",
    "    for num in numbers:\n",
    "        total+=num\n",
    "    print(\"Sum of the numbers: \", total)\n",
    "sum((100, 200, 300, 400, 0, 500))\n",
    "\n",
    "# We define a function ‘sum’ with numbers as parameter. \n",
    "#The in for loop we store the sum of all the values of list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 120. Write a program in Python to reverse a string without using inbuilt function reverse string?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-22T07:53:06.631533Z",
     "start_time": "2021-09-22T07:53:06.498233Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of string is:  6\n",
      "point1\n"
     ]
    }
   ],
   "source": [
    "# Reverse a string without using reverse() function\n",
    "\n",
    "def string_reverse(string):\n",
    "    i = len(string) - 1\n",
    "    print (\"The length of string is: \", len(string))\n",
    "    sNew = ''\n",
    "    while  i >= 0:\n",
    "        sNew = sNew + str(string[i])\n",
    "        i = i -1\n",
    "    return sNew\n",
    "print(string_reverse(\"1tniop\"))\n",
    "\n",
    "# First we declare a variable to store the reverse string. \n",
    "# Then using while loop and indexing of string (index is calculated by string length) \n",
    "# we reverse the string. While loop starts when index is greater than zero. \n",
    "# Index is reduced to value 1 each time. When index reaches zero we obtain the reverse of string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 121. Write a program to test whether the number is in the defined range or not?\n",
    "\n",
    "<span class='label label-default'>Solution</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-22T07:53:06.735537Z",
     "start_time": "2021-09-22T07:53:06.643256Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99 is in range\n"
     ]
    }
   ],
   "source": [
    "# Program is −\n",
    "\n",
    "def test_range(num):\n",
    "    if num in range(0, 101):\n",
    "        print(\"%s is in range\"%str(num))\n",
    "    else:\n",
    "        print(\"%s is not in range\"%str(num))\n",
    "#        print(\"The number is outside the given range.\")\n",
    "        \n",
    "test_range(99)\n",
    "\n",
    "# To test any number in a particular range we make use of the method ‘if..in’ and else condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 122. Write a program to calculate number of upper case letters and number of lower case letters?\n",
    "\n",
    "<span class='label label-default'>Solution</span>\n",
    "\n",
    "Test on String: 'The quick Brown Fox'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-22T07:53:06.848818Z",
     "start_time": "2021-09-22T07:53:06.745304Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String in testing is:  The quick Brown Fox\n",
      "Number of Lower Case characters in String:  3\n",
      "Number of Upper Case characters in String:  13\n"
     ]
    }
   ],
   "source": [
    "# Program is −\n",
    "\n",
    "def string_test(s):\n",
    "    d={\"UPPER_CASE\":0, \"LOWER_CASE\":0}\n",
    "    for c in s:\n",
    "        if c.isupper():\n",
    "            d[\"UPPER_CASE\"]+=1\n",
    "        elif c.islower():\n",
    "            d[\"LOWER_CASE\"]+=1\n",
    "        else:\n",
    "            pass\n",
    "    print (\"String in testing is: \", s)\n",
    "    print (\"Number of Lower Case characters in String: \", d[\"UPPER_CASE\"])\n",
    "    print (\"Number of Upper Case characters in String: \", d[\"LOWER_CASE\"])\n",
    "\n",
    "string_test('The quick Brown Fox')\n",
    "\n",
    "# We make use of the methods .isupper() and .islower(). We initialise the count for lower and upper. \n",
    "# Using if and else condition we calculate total number of lower and upper case characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}