Try my app Expense Manager @ google play and amazon store.

Saturday, March 25, 2017

Python Part3: Bytes, Lists, Shallow copies and Dictionaries

Bytes

  • Immutable sequence of bytes.

Lists

  • Mutable sequences of objects.
    • e.g a = [1, 2, 3 ,4]
  • Get or set value using index
    • e.g a[1] = 20 and print(a[1])
  • Negative integers index from the end.
  • The last element is at index -1
  • Slicing extracts part of a list.
    • Slice = seq[start:stop]
  • Slice range is half open-stop not included.
    • >>> s = [1, 2, 3, 4, 5, 6]
    • >>> s[1:4]
    • 2, 3, 4
  • Slicing works with negative indexes. 
    • >>> s[1:-1] 
    • 2, 3, 4, 5 
  • Omitting the stop index slices to the end. 
    • Slice_to_end = seq[start:] 
  • Omitting the start index slices from the beginning. 
    • Slice_from_beginning = seq[:stop] 
  • Half open ranges give complementary.
    • slices S[:x] + s[x:] == s 
  • Omitting the start and stop indexes slices from beginning to the end – a full slice. 
    • Full_slice = seq[:]
  • Important idiom for copying lists: 
  • Copy list using 
    • Copy() method 
      •  U = seq.copy() 
    • List() constructor 
      •  V = list(seq) 
  • All of these techniques create shallow copies, mean create new list containing same object reference to source list.

Shallow copies: Examples

  • >>> A = [[1, 2], [3, 4]] 
  • >>> B = A[:]      (copy using full slice) 
  • >>> A is B      (both objects have different identities.) 
    • False 
  • >>> A == B 
    •  True 
  • >>> A[0] 
    • [1, 2] 
  • >>> B[0] 
    • [1, 2] 
  • A[0] is B[0]      (both objects have same identities.) 
    • True
  • >>> A[0] = [8, 9]      (This create a new list and set reference of A[0] to this.) 
  • >>> A[0] 
    • [8, 9] 
  • >>> B[0]      (B[0] is unchanged because it has reference to old list.) 
    • [1, 2] 
  • >>> A[1].append(5)      (A[1] and B[1] still have reference to same list. So changes reflects in both places.) 
  • >>> A[1] 
    • [3, 4, 5] 
  • >>> B[1] 
    • [3, 4, 5] 
  • >>> A      (Now both lists look like this) 
    • [[8, 9], [3, 4, 5]] 
  • >>> B 
    • [[1, 2], [3, 4, 5]]
  • Repeat lists using the * operator. 
  • Most often used for initializing a list of known size with a constant. 
    • S = [constant] * size 
  • Multiple references to one instance of the constant in the produced list. 
  • Repetition is shallow. 
    • >>> S = [[1, 2]] * 5 
      • [[1, 2], [1, 2], [1, 2], [1, 2], [1, 2]] 
    • >>> S[3].append(7) 
    • >>> S 
      • [[1, 2, 7], [1, 2, 7], [1, 2, 7], [1, 2, 7], [1, 2, 7]] 
  • Index(item) returns the integer index of the first equivalent element raises value error if not found. 
    • I = w.index(‘the’)
  • Count(item) returns the number of matching elements. 
    • W.count(‘the’) 
  • The in and not in operators test for membership. 
    • 5 in [1, 2, 3] 
    • 5 not in [1, 2, 3] 
  • Del seq[index] to remove by index. 
  • Seq.remove(item) to remove by value. Raises value error if not found. 
  • Insert items with seq.insert(index, item) 
  • Concatenate lists with + operator 
    • >>> M = [1, 2] 
    • >>> N = [3, 4] 
    • >>> K = m + n 
    • >>> k 
      • [1, 2, 3, 4]
  • In-place extension with += operator or extend method. 
    •  >>> K += [6, 7] 
    •  >>> K 
      •  [1, 2, 3, 4, 6, 7] 
    •  >>> K.entend([11, 12]) 
    •  >>> K 
      •  [1, 2, 3, 4, 6, 7, 11, 12] 
  • K.reverse() reverses in place. 
  • K.sort() sorts in place. 
  • K.sort(reverse=true) gives descending sort.

Dictionaries

  • Unordered mapping from unique, immutable keys to mutable values. 
  • Recap literals: 
    • Delimited by { and } 
    • Key-value pairs comma separated 
    • Corresponding keys and values joined by colon. 
    • Keys must be unique 
    • Urls = {'google':'http://google.com', 'microsoft':'http://Microsoft.com' } 
    • >>> url['google'] 
      • http://google.com
  • Dict() constructor accepts: 
    • Iterable series of key-value 2-tuples. 
      • >>> Names_and_ages = [('Alice', 32), ('Bob', 48)] 
      • >>> d = dict(Names_and_ages) 
      • >>> d 
        • {'Alice':32, 'Bob':48} 
  • Keyword arguments-requires keys are valid python identifiers. 
  • A mapping, such as another dict. 
    • >>> Phonetic = dict(a='alfa', b='bravo') 
    • >>> phonetic 
      • {'a':'alfa', 'b':'bravo'}
  • d.copy() for copying dictionaries. 
    • >>> e = d.copy() 
    • >>> e 
      • {'Alice':32, 'Bob':48} 
  • Or simply dict(d) constructor 
    • >>> f = dict(e) 
    • >>> f 
      • {'Alice':32, 'Bob':48}
  • Extend a dictionary with update() 
    • >>> g = dict('c':'charle', 'f':'fort') 
    • >>> f.update(g) 
    • >>> f 
      • {'a':'alfa', 'b':'bravo', 'c':'charle', 'f':'fort'} 
  • Update replaces values corresponding to duplicate keys. 
  • Iteration is over keys. 
  • Get corresponding value with d[key] lookup. 
    • >>> for key in f: 
    •  print("{key} => {value}".format(key= key, value=f[key])) 
  • Use values() for an iterable view onto the series of values 
  • No efficient way to get the key corresponding to a value. 
    •  >>> for value in f.values(): 
    •  print(value)
  • Keys() method gives iterable view onto keys – not often needed. 
    • >>> for key in f.keys(): 
    •  print(key) 
  • Use items for an iterable view onto the series of key-value tuples. 
  • Use with tuple unpacking. 
    • >>> for key, value in f.items(): 
    •  print("{key} => {value}".format(key=key, value=value)) 
  • The in and not in operators work on the keys. 
    • >>> 'a' in f 
    • >>> 'h' in f
  • Use del keyword to remove by key. del d[key] 
    • >>> del f['a'] 
  • Keys must be immutable. 
  • Values may be mutable. 
  • The dictionary itself is mutable.

No comments:

Post a Comment

Follow by Email

Google+ Badge