id(<variable name>)

    x = 5
    y = 5
    ml1 = id(x)
    ml2 = id(y)

in essence a memory location contains an immutable value
a variable points to a shared memory location based on the value
when the variable's value changes the memory location it points to changes

• None (null)
• Numeric
  • Int
  • Float
  • Complex
  • Bool - internally True is 1, False is 0
• Sequences
• Sets
• Mapping

    x = 50 + 5j
    type(x)
    <class 'complex'>

• String - collection of characters
• List - group of elements, dynamic growth

      # note square brackets
      my_list = ["flip", 23, 6.3]
      # zero indexed
      print(my_list[0])
      'flip'
  

• Tuple - immutable sequence

      # note parentheses
      my_tuple = ("flip", 23, 6.3)
      # zero indexed
      print(my_tuple[0])
      'flip'
  

• Range - to create range(start,stop,step)
  stop value is not inclusive
  1 is default value of step

      r = range(1, 10, 2)
      q = list(r)
      print(q)
      [1,3,5,7,9]

    # note curly brackets
    s = {10,5,7}
    # create set from list
    my_list = ["flip", 23, 6.3]
    s = set(my_list)
    print(s)
    {'flip', 6.3, 23}
    

    # note curly brackets
    d = {1:"wn1vkn",2:"wa1vkn",3:"n4jvp"}
    # to print use a key
    print(d[1])

    # a (variable name) is the identifier
    # 15 (value) is the literal
    a = 15

• Numeric
• Boolean
• String

• Arithmetic
• Assignment
• Unary Minus
• Relational
• Logical
• Boolean

    n = 10
    print(-n)
    -10

    x = False
    y = not x
    print(y)
    True

    a = True
    b = False
    a and b
    False
    a or b 
    True
    not a
    False

    # format method
    x = 5
    y = 50
    print("Multiplication of {0} and {1} is {2}.".format(x, y, x*y)
    Multiplication of 5 and 50 is 250.

    # string format
    my_name = "Flip"
    print("Hello %s" % my_name)
    Hello Flip

    # format float
    num = 123.444666
    print("The value is %f" % num")
    The value is 123.444666

    # format 2 decimal places
    num = 123.444666
    print("The value is %.2f" % num")
    The value is 123.44

    # format using a tuple
    int-num = 150
    print("The values are %.2f and %d" % (num, int_num)
    The values are 123.44 and 150

    my_name = input()
    # result from input
    Flip
    print(my_name)
    Flip

    # input with a prompt
    my_name = input("Please enter your name : ")
    Please enter your name : Flip
    print(my_name)
    Flip

    age = input("Enter your age :")
    Enter your age : 68
    type(age)
    <class 'str'>
    # use int method
    int_age = int(age)
    type(int_age)
    <class 'int'>

    if age >= 18:
    # this will not work
    if age >= 18 :
        ...

    if i >= 0 and i <= 100:
        ...
    elif i <= 0:
        ...
    else:
        ...

    sum = 0
    num = 1
    while num != 0:
        num = int(input("Enter a number : "))
        sum += num
        print("Sum :", sum)
    else:
        print("The final total is", sum)

    a = [0,1,2,3,4,5]
    print(2 in a)

    b = ["A","B","C","D"]
    print(C in b)

    a = [0,1,2,3,4,5]
    for i in a:
        print(i)

    a = {
            "name":"Flip", 
            "age":68
        }
    for i in a:
        print(i)

    a = {
            "name":"Flip",
            "age":68
        }
    for x, y in a.items():
        print(x + " ", y)

    range(<start inclusive>, <end exclusive>, <step>)

    a = [0,1,2,3,4,5]
    for i in a:
        if i = 2:
            break;
        print(i)

    a = [0,1,2,3,4,5]
    for i in a:
        if i = 2:
            continue;
        print(i)

    # this is a comment

    """
    x += 1
    y += 1
    """

    # x += 1
    # y += 1
    

    x = "hello world"
    y = x.capitalize()
    print(y)

    print(y[0])
    # H

    <string variable>[<start index>:<length>]        
    print(y[0:5])
    # Hello

    x = "          Hello world               "
    # strip methods
    print(x.strip())
    print(x.rstrip())
    print(x.lstrip())

• isupper
• islower
• replace
• split

    x = ["Flip", 23, "C#", "Python", 68]
    y = x[2]
    print(y)
    # C#

    list_length = len(x)
    # 5

• append
• clear
• insert
• pop
• remove
• reverse
• sort

    del x

    a = (10,20)
    b = (5,15)
    c = a + b
    print(c)
    # result is (10, 20, 5, 15)

    x = ("hello", )
    y = x * 5
    print(y)
    # ('Hello','Hello','Hello','Hello','Hello') 

• all
• any
• enumerate
• len
• max
• min
• sorted
• sum
• tuple

    emp = {"name":"flip", "age":68, ("h","w"):(67,200)}

    x = emp["name"]
    print(x)
    # flip

    emp["sal"] = 1000000

• clear
• get
• items
• keys
• pop
• popitem
• update
• values

    x = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109]
    y = (00, 10, 20, 30, 40, 50, 60, 70, 80, 90)
    z = "Flip"

    a = x[-2]
    print(a)
    # 108

    <sequence variable>[<start index>:<count>:<step>]

    b = x[0:3:1]
    # [100, 101, 102]

    x[4:]
    # [104, 105, 106, 107, 108, 109]

    c = x[:4]
    # [100, 101, 102, 103]

    print(x[::2])
    # [100, 102, 104, 106, 108]

    print(x[::-1])
    # [109, 108, 107, 106, 105, 104, 103, 102, 101, 100]

    def sumf(arg1, arg2):
        print(arg1 + arg2)
    
    sumf(23,22)

    x = 23
    y = 22

    def sumf(arg1, arg2):
        z = arg1 + arg2
        print(z)
    
    sumf(x,y)

    def sumf(arg1, arg2):
        global total
        total = arg1 + arg2
        print(total)

     def sumf(arg1, arg2):
        total = arg1 +arg2
        return total
    
    result = sumf(x,y)
    print(result)

• positional arguments
• keyword arguments
• default arguments
• variable length arguments

    def shop(item, price):
        print("Item : ", item)
        print("Price : ", price

    # positional args
    shop("sugar", 50)
    # keyword args
    shop(price=50, item="sugar")

    # default arg
    def shopx(item, price = 50):
        print("Item : ", item)
        print("Price : ", price

    # variable length - note asterisk
    def student(name, course, *grades):
        print("Name : ", name)
        print("Course : ", course)
        # print("Grades : ", grades)
        for x in grades:
            print("Grade : ", x)

    student("Flip", 12, 95, 96, 99)

    # multiple keywords - note asterisks
    def student(name, course, **grades):
        print("Name : ", name)
        print("Course : ", course)
        print("Grades : ", grades)

    student(name = "Flip", course = 12, math = 95, english = 96, science = 99)

    # dictionary displays multiples
    # Grades: {'math': 90, 'english': 96, 'science': 99}
    

• no reusability
• difficult to debug
• difficult to update

• encapsulation
• abstraction
• polymorphism
• inheritance
• class

    class Student:
        def __init__(self):
            # attributes
            self.name = "Flip"
            self.age = 68
            self.marks = 100
        
        #action    
        def talk(self):
            print("Name - ", self.name)               
            print("Age - ", self.age)               
            print("Marks - ", self.marks)    
            
    # c'tor        
    s1 = Student()      
    s1.talk()  

    class Student:
        def __init__(self):
            # attributes
            self.name = "Flip"
            self.age = 68
            self.marks = 100

    class Student:
    def __init__(self, name, age, marks):
        self.name = name
        self.age = age
        self.marks = marks
        
    def display(self):
        print(self.name)
        print(self.age)
        print(self.marks)

    class Speed:
        def __init__(self):
            self.__speed = 60
       
        def get_speed(self):
            return self.__speed
    
        def set_speed(self, new_speed):
            self.__speed = new_speed
           
    s =  Speed()  

    print("changing speed by assignment")
    s.__speed = 100
    print(s.__speed)
    # prints 100
    print(s.get_speed())
    # prints 60

    print("changing speed by setter")
    s.set_speed(100)
    print(s.__speed)
    # prints 100
    print(s.get_speed())
    # prints 100

   class Example:
        def __init__(self):
            # public
            self.x = 10
            # _single weak 'internal use' indicator
            self._y = 50
            # private
            self.__z = 100
        
        def public_method(self):
            print(self.x)
            print(self._y)
            print(self.__z)
        
        # private
        def __private_method(self):
            print("private_method")
        
    s = Example()
    s.public_method()
    # error - cannot access private method
    # s.__private_method()

    class Polygon:
        # None is null
        __width = None
        __height= None
    
        def set_value(self, width, height):
            self.__width = width
            self.__height = height
    
        def get_width(self):
            return self.__width
        def get_height(self):
            return self.__height
    
    class Square(Polygon):
        def area(self):
            return self.get_height() * self.get_width() 
    
    class Triangle(Polygon):
        def area(self):
            return self.get_height() * self.get_width() * 1/2 
    
    s = Square();
    # calling area() before set_value() will cause error : null * null
    # print(s.area())    
    s.set_value(22,23)
    print(s.area())

    t =Triangle()
    t.set_value(22,23)
    print(t.area())

• math
• sys
• os
• statistics
• collections
• random

   # filename is mymath.py
    def add(x, y):
        return x + y

    def multiply(x, y):
        return x * y

    # filename is main.py
    import mymath

    result = mymath.add(22, 23)
    print(result)

   from foo import mymath

    import foo.mymath

    result = foo.mymath.add(22, 23)
    print(result)

    import foo.mymath as bar

    result = bar.mymath.add(22, 23)
    print(result)

   from foo import mymath as bar

• Polygon
• Square
• Triangle

    import polygon

    class Square(polygon.Polygon):
        def area(self):
            return self.get_height() * self.get_width() 

    from square import Square
    import triangle

    s = Square()
    s.set_value(10, 10)
    a = s.area()
    print(a)

    t = triangle.Triangle()
    t.set_value(10, 10)
    b = t.area()
    print(b)

    class Shape:
        __color = None
    
        def set_color(self, color):
            self.__color = color
        
        def get_color(self):
            return self.__color

    import polygon
    import shape

    class Square(polygon.Polygon, shape.Shape):

        def area(self):
            return self.get_height() * self.get_width() 

    from square import Square
    import triangle

    s = Square()
    s.set_value(10, 10)
    s.set_color("Blue")
    a = s.area()
    c = s.get_color()
    print(a, c)

    t = triangle.Triangle()
    t.set_value(10, 10)
    t.set_color("Red")
    b = t.area()
    d = t.get_color()
    print(b, d)

    class Parent:
        def __init__(self, name):
            print("Parent init - ", name)
        
    class Child(Parent):
        def __init__(self):
            print("Child init")
            Parent.__init__(self, "Flip")
        
    chld = Child()  

    class Child(Parent):
        def __init__(self):
            print("Child init")
            super().__init__("Flip")

• names should be all lower case
• when multiple words are needed, an underscore should separate them
• preferable to use 1 word names

• names should should follow UpperCaseCamelCase convention
• Python's 'built-in classes are typically lower case
• exception classes should end in Error

• names should be all lowercase
• when multiple words are needed, an underscore should separate them

• names should be all lowercase
• an underscore should separate words
• non-public instance variables should start with single underscore
• private variable names start with two underscores

• names should be all lowercase
• an underscore should separate words

• instance methods' first arg should be self
• lowercase for arg names

• name should be fully capitalized
• an underscore should separate words

    class Salary:
        def __init__(self, pay, reward):
            self.pay = pay
            self.reward = reward
    
        def annual_salary(self):
            return (self.pay * 12) + self.reward

    class Employee:
        def __init__(self, name, position, pay, reward):
            self.name = name
            self.position = position
            self.salary = Salary(pay, reward)
        
    emp = Employee("Flip", "CSO", 10000, 10000)     
    print(emp.salary.annual_salary())

    class Salary:
        def __init__(self, pay, reward):
            self.pay = pay
            self.reward = reward
    
        def annual_salary(self):
            return (self.pay * 12) + self.reward

    class Employee:
        def __init__(self, name, position, salary):
            self.name = name
            self.position = position
            self.salary = salary
        
    sal = Salary(10000, 10000)        
    emp = Employee("Flip", "CSO", sal)     
    print(emp.salary.annual_salary())

    from abc import ABC, abstractmethod
    # shape class is abstract
    class Shape(ABC):
        @abstractmethod
        def area(self):
            pass
        @abstractmethod
        def perimeter(self):
            pass
    
    class Square(Shape):
        def __init__(self, side):
            self.__side = side
        def area(self):
            return self.__side * self.__side
        def perimeter(self):
            return self.__side * 4  
   
    sq = Square(10)     
    print(sq.area())   
    print(sq.perimeter())

    class Books:
        def __init__(self, pages):
            self.pages = pages

    b1 = Books(100)
    b2 = Books(150)
    # '+' is the unsupported operand
    print(b1+b2)   

    class Books:
        def __init__(self, pages):
            self.pages = pages

        # override the add method
        def __add__(self, book):
            return self.pages + book.pages

    b1 = Books(100)
    b2 = Books(150)
    # b1.__add__(b2)
    print(b1+b2)   

• Compile-time - bad syntax and semantics of the language
• Run-time - error generated when program is running
• Logical - poor understanding of the problem

• ArithmeticError
• AssertionError
• SyntaxError
• TypeError
• EOFError
• RuntimeError
• ImportError
• NameError

• DeprecationWarning
• RuntimeWarning
• ImportWarning

    result = None
    x = int(input("numerator : "))
    y = int(input("denominator : "))

    try:    
        result = x/y
    except Exception as e:
        print("An error has occured : ", e)
        print(type(e))
    
    print(result)

    result = None
    x = int(input("numerator : "))
    y = int(input("denominator : "))

    try:    
        result = x/y
    except Exception as e:
        print("An error has occured : ", e)
        print(type(e))
    else:
        print("inside the else block")
    finally:
        print("inside the finally block")   
    print(result)

    class Tea: 
        def __init__(self, temperature):
            self.__temperature = temperature
        
        def drink_tea(self):
            if self.__temperature > 85:
                # print("too hot")
                raise Exception("too hot")
            elif self.__temperature < 65:
                print("too cold")
            else:
                print("just right")
            
    t = Tea(100)     
    t.drink_tea()

    class TeaException(Exception):
        def __init__(self, msg):
            self.msg = msg

    class Tea: 
        def __init__(self, temperature):
            self.__temperature = temperature
        
        def drink_tea(self):
            if self.__temperature > 85:
                raise TeaException("too hot")
            elif self.__temperature < 65:
                 raise TeaException("too cold")
            else:
                print("just right")
            
    t = Tea(100)     
    t.drink_tea()

    def add(x, y):
        return x + y

    def multiply(x, y):
        return x * y

    print(add(10,20))

    import mymath

    print(mymath.add(50,50))

    30
    100

    def add(x, y):
    return x + y

    def multiply(x, y):
        return x * y

    # if mymath.py is running as the main module 
    if __name__ == "__main__":
        print(add(10,20))

• binary
• text

    open(<filename>,<access mode>)

    fh = open("example.txt", "w")
    fh.write("Hello file system!")
    fh.close()

    fh = open("example.txt", "w")
    try:
        for i in range(1, 11):
            fh.write("%d \n" %i)
    finally:
        fh.close()

    fh = open("example.txt", "a")
    try:
        for i in range(1, 11):
            fh.write("%d \n" %i)
    finally:
        fh.close()

    with open("example.txt", "a") as fh:
        for i in range(1, 11):
            fh.write("%d \n" %i)

    with open("demo.txt", "r") as fh:
        print(fh.read())

    with open("demo.txt", "r") as fh:
        # read first two characters of file
        print(fh.read(2))   
        # pointer is now at 3
        # reads characters 3 through 12
        print(fh.read(10))

    print(fh.readline())

    print(fh.readlines())

    for line in fh:
        print(line)

• add packages to customise according to Python
• add in-built terminal prompt
• file management system
• integrate with version control system (Git-Github)
• highlight syntax, functions, classes with different colors

• Atom - Atom is getting sunsetted in December 2022 in favor of VS Code
• VS Code - after installing click on the extensions icon (bottom icon in left pane). Install the Python Extension Pack.
• Running .py Through Terminal - in File Explorer select the desired folder. Then click the address bar and enter cmd. This will open up a DOS box aka terminal in the folder

    pip --version

    pip --help

    pip <command> [<options>]