Assignment_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "49385136",
   "metadata": {},
   "source": [
    "## Assignment_4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "234c29c7",
   "metadata": {},
   "source": [
    "#### 1. What exactly is []?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ae95fa2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [] reperesents an empty list. \n",
    "# A list is a collection of elements encloused wih in square brackets '[]'.\n",
    "mylist=['shankar', 'ineuron']\n",
    "\n",
    "# A list can contains Heterogenious elements\n",
    "mylist=['shankar', 'ineuron',11,True]\n",
    "\n",
    "#A list elements are ordered, changable, allows duplicates\n",
    "mylist=['shankar', 'ineuron',11,True]\n",
    "mylist[1]=50\n",
    "print(mylist)#['shankar', 50, 11, True]\n",
    "mylist=['shankar', \"shankar\"'ineuron',11,True]\n",
    "print(mylist)#['shankar', 'shankarineuron', 11, True]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6080028",
   "metadata": {},
   "source": [
    "#### 2. In a list of values stored in a variable called spam, how would you assign the value \"hello\" as the\n",
    "<!-- third value? (Assume [2, 4, 6, 8, 10] are in spam.) -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef3506d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "spam=[2, 4, 6, 8, 10]\n",
    "spam[2]=\"hello\" \n",
    "print(spam)\n",
    "print(spam[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8889475",
   "metadata": {},
   "source": [
    "#### 3. What is the value of spam[int(int('3'* 2) / 11)]?\n",
    "<!--  Let's pretend the spam includes the list ['a','b,'c','d'] for the next three queries. -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11e0756d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spam=[2, 4, 6, 8, 10]\n",
    "spam[int(int('3'* 2) / 11)] \n",
    "#'3'*2 ='33'\n",
    "#int('33')=33/11=3\n",
    "# spam[3]=8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb43ff8",
   "metadata": {},
   "source": [
    "#### 4. What is the value of spam[-1]?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a65754",
   "metadata": {},
   "outputs": [],
   "source": [
    "spam=[2, 4, 6, 8, 10]\n",
    "spam[-1]#10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0e7e780",
   "metadata": {},
   "source": [
    "#### 5. What is the value of spam[:2]? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b0f65e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "spam=[2, 4, 6, 8, 10]\n",
    "spam[:2]#2, 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e66d60c",
   "metadata": {},
   "source": [
    "#### 6. What is the value of bacon.index( 'cat')?\n",
    "<!-- Let's pretend bacon has the list [3.14,  'cat','11','cat' True] for the next three questions. -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "744f6074",
   "metadata": {},
   "outputs": [],
   "source": [
    "bacon=[3.14,  'cat','11','cat', True]\n",
    "bacon.index('cat')#1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db01268c",
   "metadata": {},
   "source": [
    "#### 7. How does bacon.append(99) change the look of the list value in bacon?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9f1e25f",
   "metadata": {},
   "outputs": [],
   "source": [
    "bacon=[3.14,  'cat','11','cat', True]\n",
    "bacon.append(99)# it will append the 99 at last of the list\n",
    "bacon #[3.14, 'cat', '11', 'cat', True, 99]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b6ff1d6",
   "metadata": {},
   "source": [
    "#### 8. How does bacon.remove('cat') change the look of the list in bacon?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "222c33b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "bacon=[3.14,  'cat','11','cat', True]\n",
    "bacon.remove('cat')\n",
    "bacon #[3.14,'11', 'cat', True]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deb07de1",
   "metadata": {},
   "source": [
    "#### 9. What are the list concatenation and list replication operators?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cb8a0c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List concatenation\n",
    "my_list = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "result = list1 + list2\n",
    "print(result) #[1, 2, 3, 4, 4, 5, 6]\n",
    "\n",
    "# List replication\n",
    "my_list = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "result = list1 * 3\n",
    "print(result) #[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a594c080",
   "metadata": {},
   "source": [
    "#### 10. What is difference between the list methods append() and insert()?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1fa9c94",
   "metadata": {},
   "outputs": [],
   "source": [
    "# append : append the value at the end of the list\n",
    "bacon=[3.14,  'cat','11','cat', True]\n",
    "bacon.append(99) \n",
    "bacon #[3.14, 'cat', '11', 'cat', True, 99]\n",
    "\n",
    "# insert : insert the value at specified index of the list\n",
    "bacon_insert=[3.14,  'cat','11','cat', True]\n",
    "bacon_insert.insert(1,99) \n",
    "bacon_insert #[3.14, 99, 'cat', '11', 'cat', True]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9561a1c5",
   "metadata": {},
   "source": [
    "#### 11. What are the two methods for removing items from a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b909489",
   "metadata": {},
   "outputs": [],
   "source": [
    "list.remove()\n",
    "list.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ec3a5f3",
   "metadata": {},
   "source": [
    "#### 12. Describe how list values and string values are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b836280",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "List values and string values in Python share some similarities, \n",
    "but they are fundamentally different data types. \n",
    "\n",
    "Here are some ways in which list values and string values are similar:\n",
    "Sequential Data: Both lists and strings are sequential data types. They are ordered collections of elements.\n",
    "\n",
    "Indexing: Both lists and strings support indexing, allowing you to access individual elements by their position. \n",
    "The indexing starts from 0.\n",
    "\n",
    "Slicing: Lists and strings can be sliced to extract a portion or subsequence of elements. \n",
    "Slicing allows you to create new lists or strings based on a specified range of indices.\n",
    "\n",
    "Iteration: You can iterate over both lists and strings using loops or other iterable constructs in Python. \n",
    "This allows you to access each element in the sequence one by one.\n",
    "\n",
    "However, there are important differences between lists and strings:\n",
    "Mutability: Lists are mutable, which means you can modify their elements, add or remove elements, or change their length. In contrast, strings are immutable, meaning you cannot change individual characters of a string. Instead, you can create new strings by concatenating or manipulating existing strings.\n",
    "\n",
    "Type of Elements: Lists can contain elements of different data types, such as integers, strings, or even other lists. \n",
    "In contrast, strings are sequences of characters and contain only characters.\n",
    "\n",
    "Operations: Lists and strings support different operations and methods specific to their respective data types. \n",
    "For example, lists have methods like append(), insert(), and remove() for modifying the list, \n",
    "while strings have methods like split(), join(), and replace() for string manipulation.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33991284",
   "metadata": {},
   "source": [
    "#### 13. What's the difference between tuples and lists?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55038c69",
   "metadata": {},
   "outputs": [],
   "source": [
    "1.A list is a collection of elements encloused with in square brackets '[]'.\n",
    " where as Tuple is a collection of elements encloused with in parenthesis '()'.\n",
    "2. List and Tuple both are ordered and allow duplicates\n",
    "3. List elments changeble but Tuple elements unchangable\n",
    "4. Both List and Tule can store different data types i.e Heterogenious"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cac384fc",
   "metadata": {},
   "source": [
    "#### 14. How do you type a tuple value that only contains the integer 42?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8adb5b4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple=(42,)\n",
    "type(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12cbab3f",
   "metadata": {},
   "source": [
    "#### 15. How do you get a list value's tuple form? How do you get a tuple values list form?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9972149f",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list=[1,2,3,5]\n",
    "my_tuple=tuple(my_list)\n",
    "print(type(my_tuple))\n",
    "\n",
    "new_tuple=(1,2,3,5)\n",
    "list2=list(new_tuple)\n",
    "print(type(list2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "322a63f8",
   "metadata": {},
   "source": [
    "#### 16. Variables that \"contain\" list values are not necessarily lists themselves. Instead, what do they contain?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "05a08260",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Variables that \"contain\" list values in Python are actually references\n",
    "to the list objects rather than the lists themselves. \n",
    "In Python, variables are used to store references to objects in memory.\n",
    "When you assign a list to a variable, \n",
    "the variable holds a reference to the memory location where the list object is stored. \n",
    "It doesn't store the list directly. \n",
    "This means that the variable contains a reference to the list object rather than the list object itself.\"\"\"\n",
    "\n",
    "list1 = [1, 2, 3]\n",
    "list2 = list1  # Both variables reference the same list object\n",
    "\n",
    "list2.append(4)\n",
    "\n",
    "print(list1)  # [1, 2, 3, 4]\n",
    "print(list2)  # [1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e6c469c",
   "metadata": {},
   "source": [
    "#### 17. How do you distinguish between copy.copy() and copy.deepcopy()?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6186fb86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 2, 3, 5]\n",
      "[1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "# list.copy() \n",
    "# The list.copy() function creates a shallow copy of an object.\n",
    "my_list=[1,2,3,5]\n",
    "new_list=my_list.copy()\n",
    "\n",
    "my_list[0]=100\n",
    "\n",
    "print(my_list)\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8f96bf83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 2, 3, 5]\n",
      "[1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "# The copy.copy() function creates a shallow copy of an object.\n",
    "\n",
    "# copy.copy() \n",
    "_list=[1,2,3,5]\n",
    "new_list=copy.copy(_list)\n",
    "_list[0]=100\n",
    "\n",
    "print(_list)\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "1e10882d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 2, 3, 5]\n",
      "[1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "# Deep copy means that a completely independent copy of the object and its contents is created.\n",
    "\n",
    "# copy.deepcopy() \n",
    "_list=[1,2,3,5]\n",
    "new_list=copy.deepcopy(_list)\n",
    "_list[0]=100\n",
    "\n",
    "print(_list)#[100, 2, 3, 5]\n",
    "print(new_list)#1, 2, 3, 5]"
   ]
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}