What's in a Software Dev degree anyway? Course 1 - Information Structures

• primitives vs collections
• primitives: int bool float complex char
• collections: list tuple set dictionary string

• statement returns nothing
• expression returns something, also called a side effect

• complex numbers
  • totally new to me. Guess they’re used in things like electromagnetics, chemistry, and economics.

• shallow copy makes copy but points to other object
• deepcopy() makes new object

• == checks values
• is checks id to see if same exact object

• chr() and ord()

• immutable, but there are work arounds
  • range(start, stop, step)
  • half-open range: does not include stop number
  • slicing [start:stop:jump]
  • string reversal string[-1]
  • out of bound slicing will not error, but give you whatever is in bounds
  • string formatting {:[alignment][width][decimal precision][type descriptor]}

• if-elif-else
• try - except

• while and for

• open,read, readlines, write, writelines
• importance of close

• list comprehensions
  • can have multiple conditions
  • works for mutable objects (lists & sets, not tuples & strings)

• returns a list with an index number

• sort() changes things in place
• sorted() orders things and creates a new list

• See above, went over some list stuff in week 3
• indexing a nested list list[1][2] would give index 1 of main list then index 2 of the nested list
• sorting list of list sorts on the index [0] of nested lists
• some methods that modify a list: append() pop() extend() insert() remove() sort() reverse()
• reversing a list list[::-1] (gives no start or stop and a -1 step)
• Exercise: check if words are anagrams
• create a copy slice using [:] (shallow copy?)
• when list appends itself as an element, infinite regress occurs

• single element tuple tuple = ("cat",) note the trailing comma, otherwise this would not be a tuple
• can use the same set up for a list comprehension
• immutable but can contain mutable objects
• tuples use most of the same methods as lists, except the ones that would change a list (eg append())

• can use a similar set up for a list comprehension
• keys are not arranged in a specific order, they are in an order to efficiently search
• Exercise: count words or letters in a string
• namespaces are implemented with dictionaries
• items() all key-value pairs as a list of tuples
• keys() all keys as a list of list
• values() all values as a list of list
• zip() 2 or more lists together. Tuples by default
• can merge dicts with update() (note: for keys that already exist, values will be replaced)

• mutable, not ordered, only unique values
• subset small_set <= big_set vs superset big_set >= small_set
• frozen sets are possible to make sets immutable
• Methods
  • & or intersection() creates new set of all elements that are the same
  • | or union() creates new set of all elements of both lists
  • - or difference() creates new set of all elements in 1st set but not 2nd set
  • ^ or symmetric_difference() creates new set of all elements that are different
  • Link to Python Tutor with examples (with animals) of these set methods
• split() returns a list
• data type is the actual use of data structures, where data structures are more the theory or idea of
• efficiency refers to time, space, and algorithm
• Implementing other data structures with the types we have
• stacks can be made with lists
• Ternary if basically an if-else but jammed onto one line

• interupts vs Exceptions
• Allows us to watch code for errors
  • useful for things like user inputs ("All user input is evil")
• Try - Except
  • can handle multiple exceptions
• can do except IndexError as e to later use e (the error)
• If you use finally it runs every time, not required though

• functions are objects and have their own namespace (reminder: everything is an object)
• function docstring can include inputs, outputs, what the function does
• Parameters != arguments
  • parameters are in the function definition def feed_dog(dog_weight):
  • arguments are in the function call/invocation feed_dog(25.5)
• functions return None if there is no return statement
• can pass functions as arguments
• possible to have different function "signatures". same name === same function
• default parameters def pet_cat(time="now"): if you don't give a different time, cat will be pet now
• variable positional args def func(*args): this requires a tuple as input
• Mutable parameters as args/params, avoid if possible. Can cause issues
• parameter names as keywords feed_dog(dog_age=5, dog_weight = 25.5)
• annotation of params to document/suggest what type the param should be def feed_dog(dog_weight: float, dog_age: int):

• use yield instead of return
• allows you to start where you pick up as opposed to the beginning like a return
• yield give results and wait until next time function is called
• __iter__() __next__()

Lambda Function

• lambda args: expression

map() filter() reduce()

Recursion

• must have a base case and the base case must be first in the function
• can be slower than a non-recursive function
• Advantage: less code, may be easier for some problems
• Disadvantage: inefficient on memory and processing time, harder to read and follow
  • Calls by...
  • if you pass a mutable param -> call by reference
  • create a new object -> call by values
  • if you pass a immutable param -> call by value ### Week 6

Classes

• can be used to make new data structures. (Classes were used to build dict(), set(), list() etc)
• defining a class:
• self allows an object to keep it's own data (like this in js/c++/java)

• better to have static variables vs instance variables
• better to have 1 copy of a variable as opposed to 1 copy per instance
• static vars are before the methods defined in a class
• instance var or non-static would have the var in a method and each instance would have it's own copy of the var making it not so efficient
• __repr__() "official" object description (example: <__main__.Dog object at 0x7f545b6db8d0>)

• no private like java
• all methods and variables are public
• name mangling provides minimum protection
  • give __ before name like __stomach to prevent accidental changing.
  • Though you could still change Dog._Dog__stomach = 4 it would just be less of a chance to do it by accident

• Could write a method to use +,-,<,>,==,!=,&,! in a way they weren't already built to do by using "magic methods"
• magic methods are just overwritten methods that overload operators?

• can derive classes from new classes.
• In real life, mammals could be a parent class and cats could be a child class. Cat has some similarities, but some stuff is different
• if child class doesn't have a str() defined, python will look in the parent class
• functions like print() and len() can be used across different classes and functions
• if inheriting a parent class, include in the constructor/__init__

• python allows classes to have multiple parent classes. not all languages allow this (like Java and C)
• one problem

Abstract Classes

• Link to Python Tutor with examples (with animals) of abstract classes

Unit Tests

• run your function and use assert statements to test the expected output