python筆記 - day7-1 之面向對象編程

什么時候用面向對象：

　　多個函數的參數相同；
　　當某一些函數具有相同參數時，可以使用面向對象的方式，將參數值一次性的封裝到對象，以后去對象中取值即可；

self是什么？　　　　

　　self是一個python自動會給傳值得參數；　　 　　哪個對象執行方法，self就是哪個對象； 　　

例：
class SQLHelper:
    def __init__(self,a1,a2,a3):
        print("自動執行")
        self.hhost = a1
        self.uusername = a2
        self.pwd = a3

    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

    def create(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

obj1 = SQLHelper('C1.SALT.COM','alex',123)
obj1.fetch("select * from A")
#如果SQLHelper后面加括號，表示執行SQLHelper的__init__方法；
#obj1如果執行了__init__方法，self就等于obj1
#如：
    def __init__(self,a1,a2,a3):
        print("自動執行")
        obj1.hhost = a1
        obj1.uusername = a2
        obj1.pwd = a3


obj2 = SQLHelper('www.baidu.com','freddy',123)
obj2.create("create ........")
#obj2如果執行了__init__方法，self就等于obj2
#如：
    def __init__(self,a1,a2,a3):
        print("自動執行")
        obj2.hhost = a1
        obj2.uusername = a2
        obj2.pwd = a3

構造方法：　　

　　類中有一個特殊的方法，__init__，類()自動執行； 　　創建對象，后面加括號，表示遇到__init__方法，就執行__init__方法；

面向對象，三大特性：　　

　　封裝，繼承，多態；

“函數式編程”，與“面向對象編程”比較：

函數式編程：使用函數式編程，如果執行每個函數，都要重新傳入參數，比較麻煩：

def fetch(host,username,password,sql):
    pass
def create(host,username,password,sql):
    pass
def remove(host,username,pasword,uid):
    pass
def modify(host,username,password,name):
    pass

面向對象編程：可以創建一個對象，到時候想要執行哪個方法，調用自己創建的對象即可；

class SQLHelper:

    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

    def create(self,sql):
        pass


    def remove(self,uid):
        pass


    def modify(self,name):
        pass

#類里面的方法只能通過對象來調用
obj = SQLHelper()

obj.hhost = "www.mysql.com"
obj.uusername = "freddy"
obj.pwd = '123'

obj.fetch("select * from A")

標準面向對象寫法：

class SQLHelper:
    def __init__(self,a1,a2,a3):
        print("自動執行")
        self.hhost = a1
        self.uusername = a2
        self.pwd = a3

    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

    def create(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

#這里會把自定義的三個參數，分別傳給fetch，create；
obj1 = SQLHelper('c1.salt.com','alex',123)

#調用上面創建的對象，并執行額外的命令
obj1.fetch("select * from A")

#調用這個對象，執行額外的命令
obj1.create("create database aaa")

取其它對象下面的值：

class c1:
    def __init__(self,name,obj):
        self.name = name
        self.obj = obj

class c2:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def show(self):
        print(self.name)
        
c2_obj = c2('aa',11)
c1_obj = c1("alex",c2_obj)

# - 取出來c2_obj下的age是多少？
# - c2_obj賦值給c1_obj了，先打印c1_obj，
# - c2_obj賦值給c1_obj下的obj了，再打印c1_obj.obj，相當于打印的c2_obj
# - 最后再c2_obj里面取出age的值即可

print(c1_obj.obj.age)

類之前的方法調用，三個類：

class c1:
    def __init__(self,name,obj):
        self.name = name
        self.obj = obj

class c2:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def show(self):
        print(self.name)
        # return 123

class c3:
    def __init__(self,a1):
        self.money = 123
        self.aaa = a1

#如何使用C3類，調用c2類下的show方法？
c2_obj = c2('freddy',11)
#c2_obj是c2類型
# - name = 'aa'
# - age = 11

c1_obj = c1("alex",c2_obj)
#c1_obj是c1類型
# - name = "alex"
# - obj = c2_obj
c3_obj = c3(c1_obj)
#使用c3_obj找到c2下的name
print(c3_obj.aaa.obj.age)

#使用c3_obj執行show方法
ret = c3_obj.aaa.obj.show()
print(ret)

繼承：

class F1:
    def show(self):
        print('show')

    def foo(self):
        print(self.name)

class F2(F1):
    def __init__(self,name):
        self.name = name

    def bar(self):
        print('bar')
    def show(self):
        print('F2.show')

#F2類下找不到foo方法，就繼續去F1下找foo方法，因為F2類繼承了F1類；
#繼承就相當于把父類的內容，在子類中創建了一份；
#子類可以繼承父類，父類不能繼承子類；
obj = F2('alex')
obj.foo()

#F1和F2類里面都有show方法，這里創建對象是F2的類，優先調用F2類下的show方法
obj = F2('alex')
obj.show()

面向對象之單繼承：

class S1:
    def F1(self):
        self.F2()
    def F2(self):
        pass

class S2(S1):
    def F3(self):
        self.F1()
    def F2(self):
        pass


obj = S2()
obj.F3()
#這里執行的是S2下的F2

obj = S1()
obj.F1()
#這里執行的是S1下的F2

面向對象之多繼承，繼承都是從底層開始找：

方法一：最簡單的多繼承，通過C3繼承了C2，C1，通過C3類，可以執行C2，C1里面的方法

class C1:
    def f1(self):
        print("f1")

class C2:
    def f2(self):
        print("f2")

class C3(C2,C1):
    def f3(self):
        print("f3")

obj = C3()
obj.f1()
obj.f2()
obj.f3()

方法二：一條道，走到黑，如果父類只有一個子類，就是先去子類找，找不到再往右找；

　　　　查找順序：C3.f2(沒有) → C1.f2(沒有) → C0.f2(有，執行)，沒有就執行C2.f2

class C0:
    def f2(self):
        print("C0.F2")

class C1(C0):
    def f3(self):
        print("C1.F3")

class C2:
    def f2(self):
        print("C2.f2")

class C3(C1,C2):
    def f3(self):
        print("f3")
obj = C3()
obj.f2()

結果：C0.F2

方法三：如果一個父類，有兩個子類，執行順序：

　　　　C3.f2(沒有) → C1.f2(沒有) → C0.f2(沒有，就不往上找了) → C3.f2(回到原點，沒有) → C2.f2(有，執行)

class C_2:
    def f2(self):
        print("C-2,F2")

class C_1(C_2):
    def f2(self):
        print("C_1.F2")
class C0(C_2):
    def f3(self):
        print("C0.F2")

class C1(C0):
    def f3(self):
        print("C1.F3")
class C2(C_1):
    def f2(self):
        print("C2.f2")

class C3(C1,C2):
    def f3(self):
        print("f3")

obj = C3()
obj.f2()

看源碼必須要懂這個原理：

執行：obj = A()

　　　obj.forever()

A → process() → __init__ 【找到init了，obj = A()執行完了，回到原點，開始執行obj.forever() 】

A → process() → __init__ → __init__ , run(),process() → forever()【找到了，執行這個方法】

執行：self.run()

　　A → process() → __init__ → __init__ , run()【找到了，執行這個方法】

執行：self.process()

　　A → process(),【找到了，執行這個方法】

這個模塊源碼，就是引用了上面的方法：

import socketserver

#加括號，是個函數執行這個函數，
# 是個類，執行init方法
obj = socketserver.ThreadingTCPServer()

obj.serve_forever()

總結

以上是生活随笔為你收集整理的python笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。