29 \typ{while}

    29 \subsection{\typ{while}}

    32 In []: while b < 10:

    32 In []: while b < 10:  

    35 \end{lstlisting}

    35   ...:

    36 \end{lstlisting}

    37 Basic syntax of \typ{while} loop is:

    38 \begin{lstlisting}

    39 while condition:

    40     statement1

    41     statement2

    42 \end{lstlisting}

    43 All statements are executed, till the condition statement evaluates to True.

    44 \subsection{\typ{for} and \typ{range}}

    45 \typ{range(start, stop, step)}\\

    46 returns a list containing an arithmetic progression of integers.\\

    47 Of the arguments mentioned above, both start and step are optional.\\

    48 For example, if we skip third argument, i.e \typ{step}, default is taken as 1. So:

    49 \begin{lstlisting}

    50 In []: range(1,10)

    51 Out[]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

    52 \end{lstlisting}

    53 \textbf{Note:} stop value is not included in the list.\\

    54 Similarly if we don't pass \typ{first} argument (in this case \typ{start}), default is taken to be 0.

    55 \begin{lstlisting}

    56 In []: range(10)

    57 Out[]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    58 \end{lstlisting}

    59 In case third argument is mentioned(\typ{step}), the jump between consecutive members of the list would be equal to that.

    60 \begin{lstlisting}

    61 In []: range(1,10,2)

    62 Out[]: [1, 3, 5, 7, 9]

    63 \end{lstlisting}

    64 %Notice the jump between two consecutive elements is 2, i.e step.\\

    37 \typ{range([start,] stop[, step])}

    66 As mentioned previously \typ{for} in Python is used to iterate through the list members. So \typ{for} and \typ{range} can be used together to iterate through required series. For example to get square of all numbers less then 5 and greater then equal to 0, code can be written as:

    38 \begin{lstlisting}

    67 \begin{lstlisting}

    39 In []: for i in range(3, 10, 2):

    68 In []: for i in range(5):

    42 5 25

    76 4 16

    43 7 49

    77 \end{lstlisting}

    44 9 81

    78 

    45 \end{lstlisting}

    79 \section{list}

    46 List methods (Contd.)

    80 \begin{lstlisting}

    81 In []: num = [1, 2, 3, 4] # Initializing a list

    82 In []: num

    83 Out[]: [1, 2, 3, 4]

    84 \end{lstlisting}

    85 \subsection{Accessing individual elements}

    86 \begin{lstlisting}

    87 In []: num[1]

    88 Out[]: 2  

    89 \end{lstlisting}

    90 \textbf{Note:} Index of list starts from 0.

    91 \begin{lstlisting}

    92 In []: num[5]  # ERROR: throws a index error

    93 IndexError: list index out of range

    94 In []: num[-1]

    95 Out[]: 4

    96 \end{lstlisting}

    97 \textbf{Note: }\typ{-1} points to last element in a list. Similarly to access third last element of a list one can use: 

    98 \begin{lstlisting}

    99 In []: num[-3]

   100 Out[]: 2  

   101 \end{lstlisting}

   102 \subsection{\typ{list} operations}

   103 \begin{lstlisting}

   104 In []: num += [9, 10, 11] # Concatenating two lists

   105 In []: num

   106 Out[]: [1, 2, 3, 4, 9, 10, 11]

   107 \end{lstlisting}

   108 \typ{list} provides \typ{append} function to append objects at the end. 

   109 \begin{lstlisting}

   110 In []: num = [1, 2, 3, 4] 

   111 In []: num.append(-2) 

   112 In []: num

   113 Out[]: [1, 2, 3, 4, -2]

   114 \end{lstlisting}

   115 %% In []: num += [-5] 

   116 %% In []: num

   117 %% Out[]: [1, 2, 3, 4, -2, -5]

   118 Working of \typ{append} is different from \typ{+} operator on list. Till here both will behave as same. But in following case:

    49 In []: num.append([9, 10, 11])

   121 

    50 In []: num

   122 In []: num + [9, 10, 11]

    51 Out[]: [1, 2, 3, 4, [9, 10, 11]]

   123 Out[]: [1, 2, 3, 4, 9, 10, 11]

   124 

   125 In []: num.append([9, 10, 11]) # appending a list to a list

   126 

   127 In []: num

   128 Out[]: [1, 2, 3, 4, [9, 10, 11]] # last element is a list

   129 \end{lstlisting}

   130 when one attempts to append a list(in above case [9, 10, 11]) to a list(num) it adds list as a single element. So the resulting list will have a element which itself is a list. But \typ{+} operator would simply add the elements of second list.\\

   131 \subsection{Miscellaneous}

   132 \begin{lstlisting}

    53 In []: num.extend([5, 6, 7])

   134 In []: num.extend([5, 6, 7])  # extend list by adding elements

    56 In []: num.reverse()

   137 In []: num.reverse()  # reverse the current list

    59 In []: num.remove(6)

   140 In []: num.remove(6) # removing first occurrence of 6

    60 In []: num

   141 In []: num

    61 \end{lstlisting}

   142 Out[]: [7, 5, 4, 3, 2, 1]

    62 Slicing: \typ{list[initial:final:step]}

   143 In []: len(num) # returns the length of list

    63 \begin{lstlisting}

   144 Out[]: 6

    64 In []: a[1:-1:2]

   145 In []: a = [1, 5, 3, 7, -2, 4]

   146 In []: min(a) # returns smallest item in a list.

   147 Out[]: -2

   148 In []: max(a) # returns largest item in a list.

   149 Out[]: 7

   150 \end{lstlisting}

   151 

   152 \subsection{Slicing} 

   153 General syntax for getting slice out of a list is \\

   154 \typ{list[initial:final:step]}

   155 \begin{lstlisting}

   156 In []: a = [1, 2, 3, 4, 5]

   157 In []: a[1:-1:2] 

    71 Tuples(Immutable lists)

   177 Since \typ{final} is left blank, it will traverse through whole list in reverse manner.\\

    72 \begin{lstlisting}

   178 \textbf{Note:} While \typ{reverse} reverses the original list, slicing will just result in a instance list with reverse of original, which can be used and worked upon independently.

    73 In []: t = (1, 2, 3, 4, 5, 6, 7, 8)

   179 %%Should we include  list copy concept here?

    74 In []: t[0] + t[3] + t[-1]

   180 \subsection{Containership}

   181 \typ{in} keyword is used to check for containership of any element in a given list.

   182 \begin{lstlisting}

   183 In []: a = [2, 5, 4, 6, 9]

   184 In []: 4 in a

   185 Out[]: True

   186 

   187 In []: b = 15

   188 In []: b in a

   189 Out[]: False

   190 \end{lstlisting}

   191 \section{Tuples}

   192 Tuples are sequences just like Lists, but they are \textbf{immutable}, or items/elements cannot be changed in any way.

   193 \begin{lstlisting}

   194 In []: t = (1, 2, 3, 4, 5, 6, 7, 8) 

   195 \end{lstlisting}

   196 \textbf{Note:} For tuples we use parentheses in place of square brackets, rest is same as lists.

   197 \begin{lstlisting}

   198 In []: t[0] + t[3] + t[-1] # elements are accessed via indices

    78 Sets

   202 \textbf{Note:} elements cant be changed!

   203 \section{Dictionaries}

   204 Dictionaries are data structures that provide key-value mappings. They are similar to lists except that instead of the values having integer indexes, they have keys or strings as indexes.\\

   205 A simple dictionary can be created by:

   206 \begin{lstlisting}

   207 In []: player = {'Mat': 134,'Inn': 233,

   208           'Runs': 10823, 'Avg': 52.53}

   209 \end{lstlisting}

   210 For above case, value on left of ':' is key and value on right is corresponding value. To retrieve value related to key 'Avg'

   211 \begin{lstlisting}

   212 In []: player['Avg']

   213 Out[]: 52.530000000000001

   214 \end{lstlisting}

   215 \subsection{Element operations}

   216 \begin{lstlisting}

   217 In []: player['Name'] = 'Rahul Dravid' #Adds new key-value pair.

   218 In []: player

   219 Out[]: 

   220 {'Avg': 52.530000000000001,

   221  'Inn': 233,

   222  'Mat': 134,

   223  'Name': 'Rahul Dravid',

   224  'Runs': 10823}

   225 In []: player.pop('Mat') # removing particular key-value pair

   226 Out[]: 134

   227 In [21]: player

   228 Out[21]: {'Avg': 52.530000000000001, 'Inn': 233, 

   229           'Name': 'Rahul Dravid', 'Runs': 10823}

   230 \end{lstlisting}

   231 \begin{lstlisting}

   232 In []: player['Name'] = 'Dravid'

   233 In []: player

   234 Out[23]: {'Avg': 52.530000000000001, 'Inn': 233, 

   235           'Name': 'Dravid', 'Runs': 10823}

   236 \end{lstlisting}

   237 \textbf{Note:} Duplicate keys are overwritten!

   238 \subsection{containership}

   239 \begin{lstlisting}

   240 In []: 'Inn' in player

   241 Out[]: True

   242 In []: 'Econ' in player

   243 Out[]: False

   244 \end{lstlisting}

   245 \textbf{Note:} Containership is always checked on 'keys' of dictionary, never on 'values'.\\

   246 \subsection{Methods}

   247 \begin{lstlisting}

   248 In []: player.keys() # returns list of all keys

   249 Out[]: ['Runs', 'Inn', 'Avg', 'Mat']

   250 

   251 In []: player.values() # returns list of all values.

   252 Out[]: [10823, 233, 

   253         52.530000000000001, 134]  

   254 \end{lstlisting}

   255 \section{Sets}

   256 are an unordered collection of unique elements.\\

   257 Creation:

   258 \begin{lstlisting}

   259 In []: s = set([2,4,7,8,5]) # creating a basic set

   260 In []: s

   261 Out[]: set([2, 4, 5, 7, 8])

   262 In []: g = set([2, 4, 5, 7, 4, 0, 5])

   263 In []: g

   264 Out[]: set([0, 2, 4, 5, 7]) # No repetition allowed.

   265 \end{lstlisting}

   266 Some other operations which can be performed on sets are:

    84 In []: g = set([2, 4, 5, 7, 4, 0, 5])

   272 In []: f & p # Intersection of two sets

    85 In []: g

   273 Out[]: set([2, 3, 5])

    86 Out[]: set([2, 4, 5, 7, 0]) # No repetition allowed.

   274 In []: f - p # Elements in f not is p

   275 Out[]: set([1, 8])

   276 In []: f ^ p # (f - p) | (p - f)

   277 Out[]: set([1, 7, 8])) 

   278 In []: set([2,3]) < p # Test for subset

   279 Out[]: True