一個小小工程師的心情抒發天地

剛剛看了紀錄，很可怕的是我七月份都沒有任何一次更新，

其實我在寫這篇的時候，一直在想要把這個放在哪一類，

from tkinter import *


def main():
    window = Tk()
    window.title("My window")
    window.geometry("300x300")

    label_1=Label(window,text = "Hello world",
                bg="lightyellow", width=15,
                font="Helvetica 16 bold italic").pack()

    label_2=Label(window,text = "Hello=",
                bg="lightyellow", width=15,
                font="Helvetica 16 bold italic").pack(side=BOTTOM)

    label_3=Label(window,text = "=World",
                bg="lightyellow", width=15,
                font="Helvetica 16 bold italic").pack(side=BOTTOM)





    window.mainloop()


if (__name__ == '__main__'):
    main()

其實這個library還蠻多東西可以玩的，
比如說圖像文字的辨識( 這個可能就需要training )

看完了上一篇，其實大家應該比較有感覺了，沒錯，這跟我們停車場的車牌辨識，是不是很像? 所以，我們就來進階一點，將這玩意寫出來吧，其實也沒幾行code :)

from PIL import ImageColor
from PIL import Image

def main():

    rushMore= Image.open("abc.jpg")
    print(type(rushMore)) #<class 'PIL.JpegImagePlugin.JpegImageFile'>

    width, height = rushMore.size
    print(width, height) # 1920 1080
    #rushMore.show() #show image
    #rushMore.save("AAAAAA.jpg") #Storage


    '''
        建立新的影像物件 
        可以使用new()的方法來建立新的影像物件
         new(mode,size,color=0)
    '''
    obj = Image.new("RGBA",(300,180),"Yellow") #create aqua color image
    print(obj.getpixel((150,50))) #列印中心點的色彩
    obj.save("newImg.png")



if (__name__ == '__main__'):
    main()

import shutil
import glob,os
import zipfile

import pyperclip

import traceback

import logging


'''
    程式日誌模組 logging
    
    python裡面有提供logging模組，其實
    這也是我覺得不錯的玩意，這東西可以讓
    我們使用程式日誌logging的功能，而在
    使用前，我們必須將這玩意導入 :
        import logging
    
    -logging的等級 ( 分五等級 ) 
    - 從最低到最高
    
    ※Debug leavel 
     使用logging.debug() 是顯示日誌的
     內容，所顯示的內容是程式的小細節，比
     如說參數的變化。
     
    ※INFO leavel 
     這是紀錄程式一般發生的事情.
    
    ※Warning leavel 
     warning就是她目前不會影響，但是未來
     有可能有影響的東西.
    
    ※Error leavel 
     這是程式在某些狀態引發的錯誤.
     
    ※Critical leavel 
     這是最嚴重的等級，通常就是顯示讓整個系統
     葛屁，或中斷的錯誤.
    
    
    程式設計時，可以使用下列函數設定顯示資訊的等級 : 
        
        logging.basicConfig(level=logging.DEBUG) 
        #假設是設定DEBUG等級
    
    當設定logging為某一個等級的時候，未來只有比
    這個等級高的logging才會被顯示。
    
'''




def main():

    logging.basicConfig(level=logging.DEBUG)
    logging.debug('logging message, DEBUG')
    logging.debug('logging message, INFO')
    logging.debug('logging message, WARNING')
    logging.debug('logging message, ERROR')
    logging.debug('logging message, CRITICAL')

if (__name__ == '__main__'):
    main()

突然發現好像少講兩樣很重要的東西 self ，這兩個東西其實我應該放在類的最開始說的，但我好像直接跳過去了，真是抱歉:(

import os
import sys
import copy
from functools import reduce

'''
    淺談 Python - super() 
        
        super() 其實是用來調用父類的一個方法，
        也是用來解決多重繼承問題的方式，直接用類的名稱調用父類方法，在使用單繼承的時候沒有問題，
        但是如果用再多繼承，則會涉及到查找順序( MRO )，重複之類的問題。
        
        ※ 所謂的 MRO 就是 類的方法解析的順序表，其實就是既成父類方法時的順序表
        
        而以下是super()方法 : 
            super(type,[,object-or-type])
            
'''
class FooParent(object):
    def __init__(self):
        self.parent='I\'m the parent.'
        print('Parent')
    def bar(self,message):
        print("%s from parent "% message)

class FooChild(FooParent):
    def __init__(self):
        # #super (FooChild,self) 首先! 會先找到 FooChild的 parent ( 就是 FooParent )，
        #然後再把FooChild的object轉換為 FooParent 的object
        super(FooChild,self).__init__()
        print('Child')
    def bar(self,message):
        super(FooChild, self).bar(message)
        print('Child bar function')
        print(self.parent)




def main():
    fooChild = FooChild()
    fooChild.bar('Hello')   ## Hello from Parent

    '''
    Parent
    Child
    Hello from Parent
    Child bar fuction
    I'm the parent.
    '''


if (__name__=='__main__'):
    main()

import os
import sys
import copy
from functools import reduce


'''
    類別 - 繼承 
    
        終於講解到這一章節了，在OOP的世界裡面，我認為很重要的知識其中之一，就是繼承。
        
        在類別裡面，被繼承的類別我們稱為 父類(paareent class)，繼承的類別稱為子類(child class)，
        當然還有許多叫法，比如說 基底類別、超類別之類的別名。
        
        而類別繼承最大的優點，就是父類別有許多 "公有" 的方法或屬性，在子類別中你不用再重新設計，
        直接拿來用就好。
        
        比如你爸有一間房子，房子裡面有個銀子，你是他兒子，所以你可以使用他的房子、銀子，這兩個是他開放給你用的，
        但是 ! 總有一些是不能共用的，而不能共用的，你爸就會設為private，例如.... 呵呵，不好說。
        
        反正，他給你用的你就能用，他不給你用的你就不能用，大概這樣想，會比較有感覺。
'''
class Father():
    def __init__(self ):
        self.__monry = 999

    def home(self):
        print("Taipei")

    def getMoney(self):
        return self.__monry


class Son(Father):
    pass


def main():
    Item = Father()
    Eric = Son()

    Item.home() #Taipei
    Eric.home() #Taipei

    print(Eric.getMoney())

if (__name__=='__main__'):
    main()

import os
import sys
import copy
from functools import reduce


'''
    #淺談方法與屬性的類型 
    
        簡單來說，在設計python物件導向程式的時候，可以把類別分為兩個種類
            1. 實例方法 (屬性)
            2. 類別方法 (屬性)
        
        1.  實例的方法與屬性的特色，就是有self，屬性開頭是self，同時所有方法的第一個參數
            是self，這些是建立class object的時候，屬於屬性的一部分。
        2.  類別的方法前面則是@classmethod，不一樣的是，她第一個參數習慣是用cls，而類別
            方法與屬性不需要實例化，並且，類別的屬性會隨時被更新。
        
'''
class ABCD():
    counter = 0
    def __init__(self):         #類別屬性，可由類別本身調用
        ABCD.counter +=1        #更新
    @classmethod                #類別方法，可由類別本身調用
    def class_show_counter(cls):
        print("class method : counter = %d , counter =%d "% (cls.counter,ABCD.counter))

    '''
        補充: staticmethod和classmethod都可以直接用 類.方法名() 來直接使用，兩個的區別是 :

        @staticmethod : 不需要表示自身對象的self和自身類的cls參數，就跟使用函數一樣 
        @classmethod  : 也不需要self參數，但第一個參數需要是表示自身類的cls參數
    '''
    @staticmethod
    def static_show_counter():
        print("static method invoke!")
        #print(counter) #Unresolved reference 'counter'
        print(ABCD.counter) #success : print :3



def main():
    item = ABCD()
    item.class_show_counter() # class method : counter = 1 , counter =1

    item2 = ABCD()
    item2.class_show_counter()  # class method : counter = 2 , counter =2

    item3 = ABCD()
    item3.class_show_counter()  # class method : counter = 3 , counter =3

    ABCD.static_show_counter()
    ABCD.class_show_counter()

if (__name__=='__main__'):
    main()

import os
import sys
import copy
from functools import reduce

class Score():
    def __init__(self, score):
        self.__score = score

    def getscore(self):
        print("inside the getscore")
        return self.__score

    def setscore(self,score):
        print("inside the setscore")
        self.__score = score

def main():
    stu = Score(0)
    print(stu.getscore())
    stu.setscore(80)
    print(stu.getscore())

if (__name__=='__main__'):
    main()

Private & Public   

import os
import sys
import copy
from functools import reduce


#物件導向的程式設計 !
'''
    Python 是一種物件導向(OOP,object oriented programming)語言，在
    python裡面，所有的資料類型都是' 物件 '，然而，python也允許工程師自己
    創類型，而自創的類型，我們稱為 ( 類別[Class] )
'''
class ClassName(): #Class name 第一個字建議大寫
    '''
    Statement
    '''
    car = 100              #定義屬性
    carName = "Toyota"
    def PrintCarInfo(self):#定義方法
        print(self.car, self.carName)


def main():
    item = ClassName() #使用這個class 的方法
    item.PrintCarInfo() #使用這個class裡面的method的方法




if (__name__=='__main__'):
    main()

#最大公約數 ( Greatest Common Divisor[GCD] )
def GCD(n1,n2):
    gcd = 1
    n = 2
    while n<=n1 and n<= n2:
        if n1% n == 0 and n2 %n ==0:
            gcd = n
        n+=1
    return gcd



def main():
    n1,n2 = eval(input("Please enter two value: "))
    print("GCD: " , GCD(n1,n2))


    '''
    Python :eval()
    Des : eval() 是用來執行一個字符串的表達式，並返回表達式的值
    以下是eval()的使用方法:
    
        eval(expression[, globals[, locals]])
    
    '''
    #舉例來說:
    x = 7
    res = eval ('3*x')
    print(res) # 21

    res = eval('pow(2,2)')
    print(res) #4

    res = eval("n+4")
    print(res) #Error: name'n' is not defined


if (__name__=='__main__'):
    main()

song="""
Whether you're new to programming or an experienced developer, it's easy to learn and use Python.

自從換來新公司之後，就一陣忙碌，似乎好像也沒啥蜜月期，第一天大概了解一下環境和系統，第二天就開始寫code，然後，就一路搞到現在，邊寫邊申請一些權限，直到上禮拜release後，才有點時間來記錄一下這幾星期的心得。