一、面向物件的精髓

　　精髓就是將資料和處理資料的程式碼繫結成了一個物件,只要獲取到物件,相應的資料和方法都有了。

 1 #1、在沒有學習類這個概念時，資料與功能是分離的
 2 def exc1(host,port,db,charset,sql):
 3     conn=connect(host,port,db,charset)
 4     conn.execute(sql)
 5     return 123
 6 
 7 
 8 def exc2(host,port,db,charset,proc_name):
 9     conn=connect(host,port,db,charset)
 
10     conn.call_proc(proc_name)
11     return 123
12 
13 
14 def exc2(host,port,db,charset,proc_name):
15     conn=connect(host,port,db,charset)
16     conn.call_proc(proc_name)
17     return 123
18 #每次呼叫都需要重複傳入一堆引數
19 exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
20 
21 exc2('127.0.0.1',3306,'db1
 
','utf8','儲存過程的名字')
22 
23 #2、使用面向物件 
24 class Mysql: 25 26 def __init__(self,host,port,db,charset): 27 self.host = host 28 self.port = port 29 self.db = db 30 self.charset = charset 31 32 def exc2(self,proc_name): 33 conn=connect(self.host,self.port,self.db,self.charset) 34  conn.call_proc(proc_name) 
 
35 return 123 36 37 def exc1(self,sql): 38 conn=connect(self.host,self.port,self.db,self.charset) 39  conn.execute(sql) 40 return 123 41 42 43 my1 = Mysql("127.0.0.1",3306,"mydb","utf-8") 44 45 my1.exc1("select *from table1") 46 my1.exc2("名字")

二、組合

　　1.什麼是組合？

　　　　組合指的是某一個物件擁有一個屬性，該屬性的值是另外一個類的物件。

　　2.為何要用組合？

　　　　通過為某一個物件新增屬性，屬性的值是另外一個類的物件的方式，可以間接地將兩個類關聯/整合/組合到一起，從而減少類與類之間的程式碼冗餘。

　　3.如何用組合？

#學生老師系統中新增一個課程，學生可以檢視他選修的課程，老師也可以檢視他任課的課程
class OldboyPeople(object):
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex




class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,score=0):
        super().__init__(name,age,sex)
        self.score=score
        self.courses=[]

    def chose_courses(self):
        print("%s chose courses"%self.name)

    def show_courses(self):
        print("%s學生選修的課程:"%self.name)
        for i in self.courses:
            i.tell_info()



class OldschoolTeacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        super(OldschoolTeacher, self).__init__(name,age,sex)
        self.level=level
        self.courses=[]

    def score(self):
        pass

    def show_courses(self):
        print("%s老師開課的課程:"%self.name)
        for i in self.courses:
            i.tell_info()

class Course(object):
    def __init__(self,c_name,c_price,c_period):
        self.c_name=c_name
        self.c_price=c_price
        self.c_period=c_period
    def tell_info(self):
        print("<課程:%s 價格:%s 週期:%s>"%(self.c_name,self.c_price,self.c_period))


python=Course("python全棧開發",17800,"6個月")
linux=Course("linux",16800,"5個月")

stu1=OldboyStudent("周冬",18,"男")
stu2=OldboyStudent("賴正榮",28,"男")
tea1=OldschoolTeacher("林海峰",18,"男",10)
stu1.courses.append(python)
stu1.courses.append(linux)
tea1.courses.append(linux)
stu1.show_courses()
tea1.show_courses()

三、封裝

　　1.什麼是封裝？

　　　　封：將存放於名稱空間中的名字給藏起來，這種隱藏對外不對內。

　　　　裝：往容器/名稱空間中存名字

　　　　在程式中封裝指的是對外隱藏內部的實現細節，並對外部提供使用介面，從而嚴格控制對類中的屬性的操作。

　　2.為何要用封裝？

　　　　2.1可以提高安全性，不對外開放類內部的實現細節，同時也可以在封裝時，在外部提供的介面中增加額外的邏輯判斷，依次來提高安全性。

　　　　2.2封裝同時也是為了明確區分類的內部和外部。

　　　　2.3封裝函式的屬性可以隔離複雜度。

　　3.如何使用封裝？

　　　　在屬性或者方法名稱前，加上兩個下劃線，就可以將其設定為私有的。

class Student:
    def __init__(self,name,age,sex,id_card):
        self.name=name
        self.age=age
        self.sex=sex
        self.__id_card=id_card

    def show_id_card(self):
        print(self.__id_card)

stu1=Student("鍾大俊",20,"男","330133013302")
#print(stu1.id_card)  是訪問不到的，因為已經進行了封裝
#print(__stu1.id_card) 為什麼用__開頭也找不到呢？接下去看
#此時我們檢視stu1中的所有屬性，利用__dict__檢視
print(stu1.__dict__)
#>>>:{'name': '鍾大俊', 'age': 20, 'sex': '男', '_Student__id_card': '330133013302'}
#發現__stu1.id_card變成了_Student__id_card，原來封裝的時候原來的屬性名稱發生了變形，且這個變形只在類的定義階段才會發生。
#也就是說：
stu1.__score=90
print(stu1.__score)  #此時能訪問到的，屬性名不在定義階段加上__時不會發生變形。
#>>>:90

　　總結：

　　　　1. __開頭的屬性實現的隱藏僅僅只是一種語法意義上的變形,並不會真的限制類外部的訪問

　　　　2. 該變形操作只在類定義階段檢測語法時發生一次,類定義階段之後新增的__開頭的屬性並不會變形。

　　　　3. 如果父類不想讓子類覆蓋自己的屬性,可以在屬性前加__開頭