Lists and Tuples.ipynb

{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Lists"},{"metadata":{},"cell_type":"markdown","source":"**Lists** are one of the basic data structures in Python. Python does not have an \"Array\" type as other languages, so **lists** are usually used for this purpose. **Lists** are considered a Sequence Type and support sequence related functions such as *len()*, indexing and slicing, and support iteration. A **list** object can either be created using the *list()* constructor or using square brackets enclosing the list content: **[element1, element2, ..., elementn]**. **Lists** are ordered collections and are mutable, meaning their content can be modified."},{"metadata":{"trusted":true},"cell_type":"code","source":"l1 = list()\nl2 = []\nl3 = [1,2,3]\nprint(\"l1:\", l1)\nprint(\"l2:\", l2)\nprint(\"l3:\", l3)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Lists can be nested, meaning can contain lists. There can be any number of nesting levels, and the lists can be of any size.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"nestedList = [l1,l2,l3]\nprint(nestedList)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"nestedNestedList = [nestedList, l1, [l2,l3]]\nprint(nestedNestedList)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Elements of a list do not need to be of the same type.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"mixedList = [\"John\", \"Doe\", \"m\", 34, 1.82, [\"Alice\", \"Bob\"]]\nprint(mixedList)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Indexing and slicing are performed in the same manner as previously shown for strings. Accessing an element by index returns a single element, slicing returns a list.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"print(mixedList[0])\nprint(mixedList[3:5])\nprint(mixedList[3:4])\nprint(mixedList[3])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(mixedList[-2:-1])\nprint(mixedList[3:])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(mixedList[-1][0])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(mixedList[-1:])\nprint(mixedList[-1:][0])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**As opposed to strings, lists are mutable and therefore an element at a given index can be changed**"},{"metadata":{"trusted":true},"cell_type":"code","source":"mutable = [\"one\", 2, 3.0]\nprint(mutable)\nmutable[0] = \"ONE\"\nprint(mutable)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"mutable2 = mutable\nprint(\"mutable2:\",mutable2)\nmutable2[1] = \"two\"\nprint(\"mutable:\",mutable)\nprint(\"mutable2:\",mutable2)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*Note: lists are created once and then passed by reference. Modifying a list does not create a new instance in memory, and changes it for all references."},{"metadata":{},"cell_type":"markdown","source":"**Other sequence type functionalities**"},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"mixedList length:\",len(mixedList))\nprint(\"34 in mixedList:\", 34 in mixedList)\nprint(\"'m' not in mixedList:\", \"m\" not in mixedList)\nprint(\"index of 'Doe' in mixedList:\", mixedList.index(\"Doe\"))\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('\"Alice\" in mixedList:', 'Alice' in mixedList)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('[\"Alice\",\"Bob\"] in mixedList:', [\"Alice\",\"Bob\"] in mixedList)\nprint('[\"Bob\",\"Alice\"] in mixedList:', [\"Bob\",\"Alice\"] in mixedList) ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**The list constructor can take other Sequence types as input and convert them element by element into a list**"},{"metadata":{"trusted":true},"cell_type":"code","source":"stringList = list(\"Python\")\nprint(stringList)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Lists can also be created from strings using the *split(sep)* function of a string object. The *sep* parmater is an optional separator string around which the string will be split into elements.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"ipList = \"192.168.1.1\".split(\".\")\nprint(ipList)\nsplit = \"192.168.1.1\".split(\".1\")\nprint(split)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data=\"Scientific Programming with Python!\"\ndataSplit = data.split()\nprint(dataSplit)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"\\n\".join(dataSplit)) #join list elements into a string using a connector string","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## List manipulation"},{"metadata":{},"cell_type":"markdown","source":"Once a list is created, its elements can be modified. <br>\n**Adding Elements**\n\n* `append(x)` - adds the element `x` at the end of the list\n* `insert(i, x)` insert the element `x` at the i-th place\n* `extend(iter)` - concatenate the elements of `iter` to the list\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"list1 = [\"Alice\", \"Bob\"]\nprint(list1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"list1.append(\"Dave\")\nprint(list1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"list1.insert(2,\"Charlie\")\nprint(list1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"list1.extend([\"Eve\",\"Faith\"])\nprint(list1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"list1.append([\"Grace\",\"Heidi\"])\nprint(list1)","execution_count":null,"outputs":[]},{"metadata":{"scrolled":true,"trusted":true},"cell_type":"code","source":"list1.extend(\"Ivan\")\nprint(list1)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"judy = [\"Judy\"]\nconcat = list1 + judy\nprint(\"concat:\",concat)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"list1:\",list1)\n##print(\"list1 + judy[0]:\",list1 + judy[0]) #error - cannot implicitly concatenate string to list","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"\n**Removing Elements**\n* `pop(i)` - Remove the item at index `i` (and return it). If `i`is not defined, pops last element.\n* `remove(x)` - Remove item `x` (first instance found)\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"list2 = [1,3,5,7,9]\nprint(list2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"list2 = list2 * 4\nprint(list2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"elem = list2.pop()\nelem3 = list2.pop(3)\nprint(\"Element at end of list:\", elem)\nprint(\"Element at index 3:\",elem3)\nprint(\"New element at index 3:\", list2[3])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(list2)\nlist2.remove(7)\nprint(list2)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Another useful function for lists is the *count()* function which returns the number of appearances of an element in the list**"},{"metadata":{"trusted":true},"cell_type":"code","source":"list2.count(9)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**The *count()* function can be used on strings as well**"},{"metadata":{"trusted":true},"cell_type":"code","source":"\"The quick brown fox jumped over the lazy gray dog\".count(\" \")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Sorting"},{"metadata":{},"cell_type":"markdown","source":"**List**s can be sorted using the built-in *sort()* function. By default, sorting is done in ascending order. Only **list**s containing comparable elements can be sorted. Sorting is done in place - altering the existing list."},{"metadata":{"trusted":true},"cell_type":"code","source":"numericalList = [1,65,12.44,78,123.09,2.2,7.11,234,534,3.2,9,12]\nnumericalList.sort()\nprint(numericalList)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"charList = list(\"asdkfjeisdklfjdkshfjksdhfeuvzpxcvjeiouczpoifj\")\nprint(\"unsorted:\",charList)\ncharList.sort()\nprint(\"sorted:\",charList)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"mixList = [17,\"5\"]\n##mixList.sort() #error - cannot compare string and int","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**The sort function has optional parameters - *sort(reverse,key)*. Reverse is False by default, and setting it to True will cause the sorting to be in descending order. The *key* parameter accepts a function to be called on the elements by which the comparison will be made, instead of the default comparator function for each type**"},{"metadata":{"trusted":true},"cell_type":"code","source":"codes = [\"delta\", \"alpha\", \"foxtrot\",\"beta\",\"charlie\"]\ncodes.sort(reverse=True)\nprint(codes)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"codes.sort(key=len)\nprint(codes)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"*Note: this is a special case where the parameters sent to the function are **named**, and not just sent in order of the function signature. In fact, we cannot send parameters to the sort() function without naming them. We will learn more about this in the future."},{"metadata":{"trusted":true},"cell_type":"code","source":"##codes.sort(True,len) #error - cannot send parameters to sort function without keywords","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Tuples"},{"metadata":{},"cell_type":"markdown","source":"**Tuples** are an immutable version of **lists**. **Tuples** are considered a Sequence Type and support sequence related functions such as *len()*, indexing and slicing, and support iteration. A **tuple** object can either be created using the *tuple()* constructor or using round brackets enclosing the list content: **(element1, element2, ..., elementn)**. **Tuples** are ordered collections and are immutable, meaning their content <font color=red>*cannot*</font> be modified."},{"metadata":{"trusted":true},"cell_type":"code","source":"t1 = tuple()\nt2 = ()\nt3 = (1,2,3)\nprint(\"l1:\", t1)\nprint(\"l2:\", t2)\nprint(\"l3:\", t3)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"mixedTuple = (17, 13.37, 'tuple', 543265e-3,\n          True, ('\\n',0,False), [t1,t2,t3], None)\nprint(mixedTuple)\nprint(\"mixedTuple length:\",len(mixedTuple))\nprint(\"True in mixedTuple :\",True in mixedTuple)\nprint(\"False not in mixedTuple:\",False not in mixedTuple)\nprint(\"Index of 'tuple' in mixedTuple:\",mixedTuple.index('tuple'))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(mixedTuple[0])\n##mixedTuple[0] = 18 #error - cannot modify element of tuple","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"stringTuple = tuple(\"This also works\")\nprint(stringTuple)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tupleList = list(stringTuple)\nprint(type(tupleList),tupleList)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"listTuple = tuple(listTuple)\nprint(type(listTuple),listTuple)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"\".join(listTuple))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Tuples can be implicitly created and unpacked.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"courseDetails = 'Scientific Programming in Python', 3, 3, [\"3502826\",\"3502811\"]\nprint(courseDetails)\nprint(type(courseDetails))","execution_count":null,"outputs":[]},{"metadata":{"scrolled":true,"trusted":true},"cell_type":"code","source":"name, credits, hours, prerequisites = courseDetails\nprint(\"name:\",name)\nprint(\"credits:\",credits)\nprint(\"hours:\",hours)\nprint(\"prerequisites:\",prerequisites)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"##name, credits = courseDetails #error - cannot implicitly unpack partial tuple","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**This can also be done for other sequences.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"a,b,c = [1,2,3]\nd,e,f = \"def\"\nprint(a,b,c,d,e,f)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Sequence Iteration"},{"metadata":{},"cell_type":"markdown","source":"We can iterate over a sequence type object, such as a **list**, **string** or **tuple** using the <font color=\"blue\">**for**</font> statement. Python treats <font color=\"blue\">**for**</font> loops differently than most languages you are probably familiar with, as it does not conform to the (initialize; condition; increment) format. In Python, the <font color=\"blue\">**for**</font> statement is declared as follows:<br>\nfor \\< iterator \\> in \\< iterable \\>:<br>\n&emsp;\\< perform_action \\><br>\nelse:<br>\n&emsp;\\< perform_end_iteration_action \\><br>\n<br>\n*Note: the else clause is optional. It is called when the iteration is complete, and won't be performed if the loop ended due to a **break** call.*\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"fruits = [\"apples\", \"oranges\", \"bananas\", \"lemons\"]\nfor fruit in fruits:\n    print(fruit)\nelse:\n    print(\"No more fruits.\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"num = 0\nfor char in \"171337984230423\":\n    num += int(char)\nprint(num)    ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**Sometimes we wish to know the index of elements while we iterate. For this we use the *enumerate()* function**"},{"metadata":{"trusted":true},"cell_type":"code","source":"num = 0\nfor i,char in enumerate(\"171337984230423\"):\n    print(i,char)\n    num += int(char) if i%3 == 0 else 0\nprint(\"sum of i mod 3 == 0:\",num)    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"mix = []\nfor fruit in fruits:\n    for char in fruit:\n        mix.append(char if fruit.index(char)%2 == 0 else char.upper())\nmix = \"\".join(mix)\nprint(mix)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"**What if we still wish to loop through a set of code a specified number of times, and not just loop through a sequence? We can use the *range()* function.**"},{"metadata":{"trusted":true},"cell_type":"code","source":"for i in range(5): #loops through values 0 to 4\n    print(i)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for i in range(2,5): #start at i=2\n    print(i)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for i in range(0,10,2): #start at i=0, increment by 2, stop at step before 10\n    print(i)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"veggies = [\"cucumber\",\"lettuce\",\"celery\",\"eggplant\",\"pepper\",\"squash\"]\nfor i in range(len(veggies)):\n    if i > 4:\n        break\n    print(veggies[i])\nelse:\n    print(\"No more veggies.\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for i in range(len(veggies)):\n    veggies[i] = veggies[i].upper()\n    print(veggies[i])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## List Comprehension"},{"metadata":{},"cell_type":"markdown","source":"The Python <font color=\"blue\">for</font> statement has a secondary syntax used for **list** comprehension - creating lists from sequences and other iterables. Following are a few examples."},{"metadata":{"trusted":true},"cell_type":"code","source":"numbers = [12,14,99,100,32,6,11,5,16,89]\nsquares = []\nfor num in numbers:\n    squares.append(num**2)\nprint(squares)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"squaresComp = [num**2 for num in numbers]\nprint(squaresComp)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"evenSquares = []\nfor num in numbers:\n    if num % 2 == 0:\n        evenSquares.append(num**2)\n    else:\n        evenSquares.append(num)\nprint(evenSquares)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"evenSquaresComp = [(num**2 if num % 2 == 0 else num) for num in numbers]\nprint(evenSquaresComp)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"string1 = \"aAbReSDGTesrfewWEf34sd fsdf wefSDFGr w234rWE SWDFw234 fasdf F\"\ncaps = [s for s in string1 if s.isupper()]\nprint(caps)","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.8","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":4}