Please enable JavaScript.

Coggle requires JavaScript to display documents.

Python Zero to Mastery (Introduction (Basics 1 (Basics 2 (Object Oriented…

- - - - these changes were breaking changes meaning previously written python 2 syntax code would crash if ran on python 3
  - - - Terms
      - Data Types
      - Actions
      - Best Practices
    - - fundamental
        
        int
        
        float
        
        str
        
        bool
        
        list
        
        dict
        
        tuple
        
        set
      - custom (Classes)
      - modules
        
        extension of fundamental
      - None
        
        absence of value
    - - covers 2 types
        
        int
        
        float
      - when performing mathematical operations, the types above go hand to hand
    - - python has many, round and abs are two examples
    - - follows BEDMAS
    - - bin gives binary representation of number
      - complex is used for complex numbers
    - - conditions
        
        snake_case
        
        don't overwrite keywords
        
        case sensitive
        
        start with lowecase or _
        
        can include letters, numbers, _
      - use capital for constants
      - don't use __
    - - expression occurs at the RHS of =, statement is the entire line
    - - +=
      - -=
      - *=
    - - '...'
      - "..."
      - '''...'''
      - String Concatenation is the concept of adding strings together
    - - can be done very easily in python, ex: str(100)
    - - \
        
        ignore what comes after this
      - \n
        
        newline
      - \t
        
        tab
    - - use f string instead of .format
    - - [start, stop, stepover]
      - special cases
        
        word[-i]
        
        get from behind
        
        word[:i]
        
        end at i
        
        word[::-1]
        
        reverse
    - - string are immutable, they cannot be changed
        
        you must re-assign to update
    - - functions are available globally
      - methods are owned by certain types
    - - True
      - False
    - - are data structures
        
        container for grouping a lot of data
      - can include any type as it's elements
    - - same approach as strings
      - lists are pass by reference, just like JS
      - to duplicate a list:
        li2 = li1[:]
    - - multi-dimensional lists
      - easy access: [i][j]
    - - a lot work in-place
        
        some create a new copy
      - the "in" keyword is very useful
      - sorted(lst) vs lst.sort()
    - - list(range(100))
        
        note, range doesn't include 100
      - ' '.join[lst]
      - list unpacking
        
        a, b, *other, d = lst
        
        *other is a list
    - - unordered key-value pairs
      - keys must be unique and immutible
        
        95% of the time, strings are used as keys
      - if you try to access a key that doesn't exist you'll get an Error
        
        instead use d.get('key')
        
        this will return None if it doesn't exist
        
        you can pass in another parameter for default value in .get()
      - you can extract keys, values, entries, and use the in operator like lists
    - - immutable lists
      - have better performance
      - allow for unpacking just like lists
    - - all elements are unique
      - cannot access using [] like the other data structures
      - think of these like sets in statistics, syntax is the same and they have methods that are named appropriately
    - - Conditional Logic
        
        if, elif, else
        
        and, or keywords can be used in statement
        
        these 2 use short circuiting
      - Truthy vs Falsey
        
        used in conditional statements
        
        bool(var) is done under the hood
      - Ternary Operators
        
        ... if ... else ...
        
        returns the value
      - Logical Operators
        
        and, or, >, <, >=, <=, ==, !=, not
        
        these all short circuit too
        
        not is a function
      - is vs ==
        
        using == you are checking the values, type conversion will occur
        
        using "is", you check to see if the address matches
      - For Loops
        
        for ... in ...
        
        can use lists, tuples, sets, dictionary, strings
        
        iterables
        
        can be iterated through
      - range
        
        special object used in for loops
        
        range(start, end, stepover)
      - enumerate
        
        not as useful as range
        
        gives us access to index during iteration
      - while loops
        
        while ...:
        
        can use with else
        
        execution of else ensures that the loop didn't break
        
        useful for more complex problems, for example asking for input over and over
        
        continue, break, pass
      - Functions
        
        def func():
        
        arguments are values provided when invoking function
        
        positional (must be in the same order as function parameters), keyword(doesn't have to be in the same order)
        
        parameters are used when defining function
        
        default parameters are used when arguments aren't passed
        
        args, *kwargs
        
        useful when passing in many items
        
        allow doc strings
        
        can access using help() or .__doc__
      - Scope
        
        we create a new scope when we create a function
        
        start at local, then go to parent, ..., global, built-in python
      - global
        
        try to avoid using this keyword, instead use dependency injection
        
        nonlocal is used for accessing parent variables
      - Object Oriented Programming
        
        Creating our own objects
        
        __init__ method is the constructor, it executes when we instantiate
        
        "self" refers to what is at the left of the "."
        
        in python, objects have attributes and methods
        
        2 different object instances will have different location in memory
        
        Attributes and Methods
        
        class object attributes
        
        defined before __init__
        
        are static, cannot be changed
        
        can use class name in constructor to access them
        
        class attributes
        
        are dynamic
        
        must access using self
        
        classmethod and staticmethod
        
        these are 2 decorators
        
        they can be called without having to instantiate a class
        
        classmethod is dynamic (must pass in cls) and staticmethod is static
        
        abstraction
        
        hiding information and giving access to only what is necessary
        
        no such thing as private variable in python, instead use _ to indicate something that shouldn't be changed
        
        Inheritence
        
        having children classes that extend from parent class
        
        pass in the parent class as a parameter
        
        everything inherits from an object
        
        you can use isinstance function to check if an object is an instance of another object
        
        Polymorphism
        
        object classes can share the same method name that act differently
        
        What is OOP
        
        a way to structure and organize code
        
        everything in python is an object
        
        we can create our own objects using the class keyword
        
        we instantiate a class to create an object
        
        encapsulation
        
        the binding of data and functions that manipulate that data
        
        a class without methods is the same as a dictionary
        
        super
        
        calls the parent classes init method
        
        Object Introspection
        
        being able to see objects attributes and methods during runtime
        
        python allows for this
        
        Dunder Methods
        
        allow us to use methods like functions (no need to place to the right)
        
        in python, we can override a classes dunder method
        
        Multiple Inheritance
        
        hard to read code
        
        don't use super for this
        
        Method Resolution Order
        
        you can use python mro method to check inheritance order
        
        uses depth first search algorithm
        
        Functional Programming
        
        filter
        
        filters iterable based on boolean function returns
        
        zip
        
        takes 2 lists and zips them together, each element is a tuple
        
        map
        
        maps over each element and calls function that modifies it
        
        reduce
        
        use to accumulate a value as you go through the iterable
        
        Pure Functions
        
        no side effects
        
        function gives back the same output every time for unique input
        
        hard to use this approach everywhere bc side effects are important in programs
        
        lambda
        
        for anonymous functions
        
        use this for functions that are used only once
        
        What is it?
        
        we want to separate data and functions
        
        each function does 1 thing very well
        
        List Comprehensions
        
        used to quickly generate lists
        
        [item for ... in ... if ...]
        
        Set Comprehension
        
        same as list comprehensions, but use {}
        
        Dictionary Comprehension
        
        can be used to generate key, value pairs from any iterable
        
        Decorators
        
        Decorators
        
        are higher order functions that wrap functions to allow for additional features
        
        Higher Order Functions
        
        either accept a function as an argument or return a function
        
        What is it?
        
        are used to supercharge our functions
        
        place ... before function definition
        
        Error Handling
        
        Error Handling
        
        uses try-except-else-finally
        
        you can specify which errors to catch in except (unlike JS)
        
        you can get the err message using "except as err"
        
        throwing errors
        
        raise Exception()
        
        can specify the exception instead
        
        Erors
        
        python throws an exception when something goes wrong
        
        Generators
        
        What is it?
        
        4 more items...
        
        Modules
        
        8 more items...