more excercise

Author: kkasra12

Session7/Q1.py

@@ -1,4 +1,4 @@
-# CLASS
+# Class (part1)
 
 
 Python is an object oriented programming language.
@@ -76,6 +76,7 @@ person0.sayHello()
 
 ## Magic Functions or Dunder Functions
 
+[docs for special functions](https://docs.python.org/3/reference/datamodel.html#special-method-names)
 
 - `__lt__(self, other)`
 
@@ -88,3 +89,76 @@ person0.sayHello()
 - `__gt__(self, other)`
 
 - `__ge__(self, other)`
+
+****
+
+
+- `__getitem__(self, key)`
+
+- `__setitem__(self, key, value)`
+
+- `__contains__(self, item)`
+
+****
+
+- `__add__(self, other)`  ==> `+`
+
+- `__sub__(self, other)` ==> `-`
+
+- `__mul__(self, other)` ==> `*`
+
+- `__matmul__(self, other)` ==> `@ `
+
+> [ptyhonDoc](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations) says `The @ (at) operator is intended to be used for matrix multiplication. No builtin Python types implement this operator.`
+
+- `__truediv__(self, other)` ==> `/`
+
+- `__floordiv__(self, other)` ==> `//`
+
+- `__mod__(self, other)` ==> `%`
+
+- `__pow__(self, other[, modulo])` ==> `**`
+
+- `__lshift__(self, other)` ==> `<<`
+
+- `__rshift__(self, other)` ==> `>>`
+
+- `__and__(self, other)` ==> `&`
+
+- `__xor__(self, other)¶` ==> `^`
+
+- `__or__(self, other)` ==> `|`
+
+- `__radd__(self, other)`
+- `__rsub__(self, other)`
+- `__rmul__(self, other)`
+- `__rmatmul__(self, other)`
+- `__rtruediv__(self, other)`
+- `__rfloordiv__(self, other)`
+- `__rmod__(self, other)`
+- `__rpow__(self, other)`
+- `__rlshift__(self, other)`
+- `__rrshift__(self, other)`
+- `__rand__(self, other)`
+- `__rxor__(self, other)`
+- `__ror__(self, other)¶`
+
+- `__iadd__(self, other)` ==> `+=`
+- `__isub__(self, other)` ==> `-=`
+- `__imul__(self, other)` ==> `*= `
+- `__imatmul__(self, other)` ==> `@=`
+- `__itruediv__(self, other)` ==> `/=`
+- `__ifloordiv__(self, other)` ==> `//=`
+- `__imod__(self, other)` ==> `%=`
+- `__ipow__(self, other[, modulo])` ==> `**=`
+- `__ilshift__(self, other)` ==> `<<=`
+- `__irshift__(self, other)` ==> `>>=`
+- `__iand__(self, other)` ==> `&=`
+- `__ixor__(self, other)` ==> `^=`
+- `__ior__(self, other)` ==> `|=`
+
+****
+
+- `__str__(self)`
+
+- `__len__(self)`

Session7/README.md

@@ -0,0 +1,34 @@
+> this is a answer to question which mentioned in lesson
+
+
+# Question
+ think a pile of numbers that we should check whether they are in the Fibonacci series or not.
+- **fisrt** most of numbers are duplicated
+- **second** make it *fast*
+
+> try to solve it by your own before looking at the answers
+
+## Files Description
+- `fastFib.py` is **the main answer**(your answers are welcomed if you can make it faster 😉)
+- also I solved this question using a *regular* method and not taking care of time which is in the `regularFib.py`.
+- `speedChecker.py` simply examines the other codes speed
+
+## Sample Output
+```
+generating numbers...
+numbers generated...
+	biggest number generated: 121918
+	smallest number generated:121053
+numbers counted...
+making the graph...
+qt5ct: using qt5ct plugin
+...
+time elapsed for fast fib is 2.676896810531616
+time elapsed for fast fib is 16.891290426254272
+	NOTE: all answers match
+number of matched items: 20818
+number of unmatched items: 9979182
+```
+
+![](./numbers_destribution.png)
+![](./answers_destribution.png)

Session7/fastFib/README.md

@@ -0,0 +1,27 @@
+class FibMaker:
+    def __init__(self):
+        self.series={1,1}
+        self.lastNum0=1
+        self.lastNum1=1
+
+    def isFib(self,num):
+        if num in self.series:
+            return True
+        if num<self.lastNum1:
+            return False
+        a,b=self.lastNum0,self.lastNum1
+        while b<num:
+            a,b=b,a+b
+            self.series.add(b)
+            if b==num:
+                self.lastNum0=a
+                self.lastNum1=b
+                return True
+        self.lastNum0=a
+        self.lastNum1=b
+        return False
+
+if __name__ == '__main__':
+    f=FibMaker()
+    for i in [3,5,11,8,20,50,100,90]:
+        print(f.isFib(i))

Session7/fastFib/__pycache__/fastFib.cpython-36.pyc

@@ -0,0 +1,11 @@
+def isFib(num):
+    a,b=1,1
+    while b<num:
+        a,b=b,a+b
+        if b==num:
+            return True
+    return False
+
+if __name__ == '__main__':
+    for i in [3,5,11,8,20,50,100,90]:
+        print(isFib(i))

Session7/fastFib/__pycache__/regularFib.cpython-36.pyc

@@ -0,0 +1,73 @@
+from time import time
+from random import randint,gauss
+from fastFib import FibMaker
+from regularFib import  isFib
+from collections import Counter
+try:
+    from matplotlib import pyplot as plt
+    drawGraph=True
+except:
+    print('''You dont have matplotlib!!So I cant show any graph...
+try installing it using:
+    $pip install matplotlib''')
+    drawGraph=False
+# This is a Fibonacci series chose your constant wiser...
+# 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393
+#
+TEST_SIZE=int(1e7)
+START_RANGE=int(1.21e5)
+END_RANGE=int(1.22e5)
+print('generating numbers...')
+# numbers=[randint(START_RANGE,END_RANGE) for _ in range(TEST_SIZE)]
+numbers=[int(gauss((START_RANGE+END_RANGE)/2,(END_RANGE-START_RANGE)/12)) for _ in range(TEST_SIZE)]
+print('numbers generated...')
+print(f'''\tbiggest number generated: {max(numbers)}
+\tsmallest number generated:{min(numbers)}''')
+if drawGraph:
+    numbersDest=Counter(numbers)
+    ############this is not good(why?):
+    #x=[i[0] for i in numbersDest.items()]
+    #y=[i[1] for i in numbersDest.items()]
+    ############this is much faster
+    x=[]
+    y=[]
+    for i in numbersDest:
+        x.append(i)
+        y.append(numbersDest[i])
+    print("numbers counted...\nmaking the graph...")
+    plt.bar(x,y)
+    plt.show()
+ansfastFib=[]
+ansreguFib=[]
+print('...')
+fastFib=FibMaker()
+now=time()
+for i in numbers:
+    ansfastFib.append(fastFib.isFib(i))
+fastFibTime=time()-now
+print(f"time elapsed for fast fib is {fastFibTime}")
+
+now=time()
+for i in numbers:
+    ansreguFib.append(isFib(i))
+reguFibTime=time()-now
+print(f"time elapsed for fast fib is {reguFibTime}")
+
+if all([i==j for i,j in zip(ansfastFib,ansreguFib)]):
+    print("\tNOTE: all answers match")
+else:
+    print("\tNOTE: all answers does NOT match")
+
+ansDest=Counter(ansfastFib)
+
+# plt.bar(['True','False'],[ansDest[True],ansDest[False]],yerr=["sallaaam","rrrr"])
+print(f"number of mathed items: {ansDest[True]}\nnumber of unmathed items: {ansDest[False]}")
+# plt.show()
+
+fig, ax = plt.subplots()
+y=[ansDest[True],ansDest[False]]
+ax.bar(['True','False'],y)
+for index,data in enumerate(y):
+    plt.text(index, 10, s=f"{data}")
+plt.tight_layout()
+plt.show()

Session7/fastFib/answers_destribution.png

@@ -0,0 +1,48 @@
+# Class(part2)
+
+lets make an stack...
+
+## a Simple Example
+**lets make a class**
+### what is stack ?
+
+![stack](./stack.jpg)
+
+> TIP: The initial step to make a class is defining its API *(what is API?)*
+
+### API
+
+| function/variable | arguments|returns| description |
+| :-------------: | :-------:| :---:|:--- |
+| push       |   value:[anytype] | `None` | pushes `value` into stack
+pop|-|last item in the stack, `None` if stack is empty | removes the last item in the stack and returns it|
+lastItem|-|last item in the stack|like pop but without removing
+isEmpty|-|`True` or `False`|returns `True` if stack is empty
+size|-| `int` |returns the number of items stored in the stack
+str|-|?|?
+eq|other stack|?|?
+
+
+**Question**
+
+1. Implement a stack class
+2. describe how to use it in other code
+
+**How to force user not to have access to main data in class?**
+
+### public, private and protected Access Modifiers
+
+**Question**\
+ define terms public, private and protected.
+
+```Python
+class test:
+  """docstring for test."""
+
+  def __init__(self):
+    self.public='public' # this is public
+    self._protected="protected" # this is protected
+    self.__private="private" # this is private
+```
+
+> NOTE: that was all joke!!! :)

Session7/fastFib/fastFib.py

@@ -0,0 +1,52 @@
+class stack:
+    def __init__(self):
+        self.values=[]
+    def push(self,value):
+        self.values.append(value)
+
+
+    def pop(self):
+        if len(self.values)==0:
+            return None
+        else:
+            return self.values.pop(-1)
+
+    def lastItem(self):
+        if len(self.values)==0:
+            return None
+        else:
+            return self.values[-1]
+    def isEmpty(self):
+        if len(self.values)==0:
+            return True
+        else:
+            return False
+    def __len__(self):
+        return len(self.values)
+    def __str__(self):
+        return f"[ {' '.join(self.values)} ]"
+    def __eq__(self,other):
+        if type(other)==type(self):
+            return self.values==other.values
+        raise Exception("other type is not stack")
+
+if __name__ == '__main__':
+    s=stack()
+    s.push(1)
+    s.push(4)
+    s.push(6)
+    s.push("kasra")
+    s.push("hellllo")
+    print(s.pop())
+    print(s.lastItem())
+    print(s.pop())
+    print(s.pop())
+    print(s.lastItem())
+    print(s.pop())
+    print(s.pop())
+    print(s.pop())
+    print(s.pop())
+    print(s.lastItem())
+    print(s.pop())
+    print(s.pop())
+