Type checking functions

• type(object) – returns class type of the argument passed as parameter.
• isinstance(object, class) – returns a Boolean value indicating if the object belongs to or inherits from the class.
• issubclass(classA, classB) returns a Boolean value indicating if 2 classA is a subclass of classB. Notice that a class is a subclass of itself. This concept is from set theory – any set is its own subset.

print(type("goodbye")) #<class 'str'>
print(type("goodbye") == type("hello"))  #True
print(type("goodbye") == type(3))  #False

class C:
  pass
class B(C):
  pass
class A(B):
  pass

a = A()
b = B()
c = C()

print(isinstance(a, A))  #True
print(isinstance(a, B))  #True
print(isinstance(a, C))  #True
print(isinstance(c, A))  #False

print(issubclass(A, A))  #True
print(issubclass(A, B))  #True
print(issubclass(A, C))  #True
print(issubclass(C, A))  #False

Duck Typing

If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

• we don’t necessarily need to know the data type of an object, as long as the object has the functionality we need.
• 程式設計中動態型別的一種風格。在這種風格中，一個物件有效的語意，不是由繼承自特定的類或實現特定的介面，而是由「當前方法和屬性的集合決定。
• 在鴨子型別中，關注點在於物件的行為，能做什麼；而不是關注物件所屬的類型。
• 鴨子型別優點為「不」測試方法和函式中參數的類型，而是依賴文件、清晰的代碼和測試來確保正確使用。

# The sorted function is using the principle of duck typing
# This is a Duck Typing style design

print(sorted(['foo','bar','fox']))  #['bar', 'foo', 'fox']
print(sorted({'foo','bar','fox'}))  #['bar', 'foo', 'fox']
print(sorted({'key1':'foo', 'key2':'bar', 'key3':'fox'}))  #['key1', 'key2', 'key3']
print(sorted('foobarfox'))  #['a', 'b', 'f', 'f', 'o', 'o', 'o', 'r', 'x']

print(sorted(99644))  #TypeError: 'int' object is not iterable

try:
  print(sorted(99644))
except:
  print("Error happened while sorted")

def calculate(x, y,z):
  return (x + y) * z

print(calculate(3, 2, 2))  #10
print(calculate('foo', 'bar', 2))  #foobarfoobar
print(calculate([1, 3], [4, 2], 3))  #[1, 3, 4, 2, 1, 3, 4, 2, 1, 3, 4, 2]

try:
  print(calculate([1, 3], 3, 5))
except:
  print('we got error')

TypedList

The advantage of a one-type list includes tracking errors and making the list stable. If we add something that shouldn’t be in the list, we can quickly figure it out at the beginning of our development.

class TypedList:
    def __init__(self, example_element, initial_list):
        self.type = type(example_element)
        if not isinstance(initial_list, list):
            raise TypeError("Second argument of TypedLisst must be a list.")
        for element in initial_list:
            self.__check(element)
        self.elements = initial_list[:] #copy be value

    def __check(self, element):
        if type(element) != self.type:
            raise TypeError(
                "Attempted to add an element of incorrect type to a TypedList.")
    
    def __setitem__(self, i, element):
        self.__check(element)
        self.elements[i] = element
    
    def __getitem__(self, i):
        return self.elements[i]
    
    def __str__(self):
        return str(self.elements)
    
    def __add__(self, anotherList):
      return len(self.elements) + len (anotherList.elements)

x = TypedList('Hello', ['some', 'original', 'stuff'])
print(x)  #['some', 'original', 'stuff']
y = TypedList('', [''] * 5)
print(y)  #['', '', '', '', '']
print(x + y)  #8

class TypedList(list):
    def __init__(self, example_element, initial_list):
        self.type = type(example_element)
        if not isinstance(initial_list, list):
            raise TypeError("Second argument of TypedLisst must be a list.")
        for element in initial_list:
            self.__check(element)
        super().__init__(initial_list)

    def __check(self, element):
        if type(element) != self.type:
            raise TypeError(
                "Attempted to add an element of incorrect type to a TypedList.")

    def __setitem__(self, i, element):
        self.__check(element)
        super().__setitem__(i, element)

    def __getitem__(self, i):
        return super().__getitem__(i)

x = TypedList('Hello', ['Some', 'original', 'stuff'])
print(x)  #['Some', 'original', 'stuff']
y = TypedList('', [''] * 5)
print(y)  #['', '', '', '', '']
print(x + y)  #['Some', 'original', 'stuff', '', '', '', '', '']

Decimal, Binary, and Hexadecimal