python學習之面向對象編程---類

面向過程編程:

特性:
模塊化 流程化
優點:
性能比面向對象高, 因為類調用時需要實例化,開銷比較大,比較消耗資源;
單片機、嵌入式開發、Linux/Unix等一般采用面向過程開發,性能是最重要的因素。
缺點:
沒有面向對象易維護、易復用、易擴展

函數式編程:

函數式編程是種編程方式,它將電腦運算視為函數的計算。函數編程語言最重要的基礎是λ
演算(lambda calculus),而且λ演算的函數可以接受函數當作輸入(參數)和輸出(返回值)。
主要思想: 把運算過程盡量寫成一系列嵌套的函數調用。
面向對象編程
面向對象是按人們認識客觀世界的系統思維方式,把構成問題事務分解成各個對象,建立對
象的目的不是為了完成一個步驟,而是為了描敘某個事物在整個解決問題的步驟中的行為

面向對象編程

特性: 抽象 封裝 繼承 多態
優點: 易維護、易復用、易擴展,由于面向對象有封裝、繼承、多態性的特性,
可以設計出低耦合 的系統,使系統更加靈活、更加易于維護
缺點:
性能比面向過程低

01_面向對象理解.py

class Student(object):
    """封裝學生類"""
    def __init__(self, sid, name, score1, score2):
        """封裝了學生屬性信息"""
        self.sid = sid
        self.name = name
        self.score1 = score1
        self.score2 = score2

    def show(self):
        pass

    def compute_sum_score(self):
        return self.score1 + self.score2

    def compute_avg_score(self):
        return  (self.score1 + self.score2)/2

stu1 = Student(sid='001', name='張三', score1=100, score2=90)
print(stu1.compute_sum_score())
stu2 = Student(sid='002', name='張三', score1=100, score2=100)
print(stu2.compute_avg_score())"""

類(Class) 是現實或思維世界中的實體在計算機中的反映,它將數據以及這些數
據上的操作封裝在一起。
對象(Object) 是具有類類型的變量。類和對象是面向對象編程技術中的最基本的概
念。
對象和類

1. 如何定義類?
   class 類(): pass
2. 如何將類轉換成對象?
   實例化 是指在面向對象的編程中,把用類創建對象的過程稱為實例化。是將一個抽象的概
   念類,具體到該類實物的過程。實例化過程中一般由類名 對象名 = 類名(參數1,參數2...參數n)
   構成。
   對象和類
   類(Class) 是是創建實例的模板
   對象(Object) 是一個一個具體的實例

   02_類的定義.py

#class 類名稱:    定義類的方式
class Person:
    #占位關鍵字， 什么也不做
    pass
print(Person)       # <class '__main__.Person'> 存儲于當前腳本的Person類

#對象：將類實例化/具體化產生的值
personObj = Person()
#<__main__.Person object at 0x7f28164b04d0>
#當前腳本的Person類實例化出來的對象存儲的內存地址是0x7f28164b04d0
print(personObj)

#Python自帶的類
from datetime import  datetime
from datetime import date
from collections import  defaultdict

03_構造方法的理解.py

#構造方法__init__與其他普通方法不同的地方在于,當一個對象被創建后(實例化),會立即調
#用構造方法。自動執行構造方法里面的內容。
class Student:
    # 實例化對象的過程中自動執行的函數
    def __init__(self):         # self是形參還是實參? - 形參
        # self是什么? self實質上實例化出來的對象。系統自動將實例化的對象傳遞給構造方法。
        print("self: ", self)
        print("正在運行構造方法........")

print(Student)      # <class '__main__.Student'>
#實例化產生對象的過程
stu1 = Student()
print("stu1: ", stu1)

封裝特性
面向對象的三大特性是指:封裝、繼承和多態
封裝,顧名思義就是將內容封裝到某個地方,以后再去調用被封裝在某處的內容。
所以,在使用面向對象的封裝特性時,需要:
1). 將內容封裝到某處
2). 從某處調用被封裝的內容
1). 通過對象直接調用被封裝的內容: 對象.屬性名
2). 通過self間接調用被封裝的內容: self.屬性名
3). 通過self間接調用被封裝的內容:
self.方法名()
構造方法init與其他普通方法不同的地方在于,當一個對象被創建后,會立即調
用構造方法。自動執行構造方法里面的內容。
對于面向對象的封裝來說,其實就是使用構造方法將內容封裝到 對象 中,然后通過
對象直接或者self間接獲取被封裝的內容

04_如何實現數據的封裝.py

class Student:
    def __init__(self, name, score1, score2):
        # 將對象和屬性封裝在一起
        self.name = name
        self.score1 = score1
        self.score2 = score2
        #print("self.name: ", self.name)

    def compute_sum_score(self):
        #獲取封裝的屬性信息方法一: ， 通過對象名.屬性名的方式獲取。
        return  self.score1 + self.score2

stu1 = Student(name="張三", score1=100, score2=100)

#獲取封裝的屬性信息方法二: ， 通過對象名.屬性名的方式獲取。
print("學生姓名: ",  stu1.name)
sum_scores = stu1.compute_sum_score()
print("總分數: ", sum_scores)

創建一個類People,擁有的屬性為姓名, 性別和年齡, 擁有的方法為購物,玩游戲,學習;實例化
對象,執行相應的方法。 顯示如下:
小明,18歲,男,去西安賽格購物廣場購物
小王,22歲,男,去西安賽格購物廣場購物
小紅,10歲,女,在西部開源學習

05_封裝練習題目.py

class People:
    print("正在創建類對象..........")
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def shopping(self):
        print("%s,%d歲,%s,去西安賽格購物廣場購物" %(self.name, self.age, self.gender))
    def playGame(self):
        pass
    def learning(self):
        pass

#當定義類的時候， 類內容是否會執行?  會執行
#stu1 = People('xx', 10, 'xxx')"""

繼承特性
面向對象的三大特性是指:封裝、繼承和多態

1. 繼承
2. 多繼承
3. 私有屬性與私有方法
   繼承描述的是事物之間的所屬關系,當我們定義一個class的時候,可以從某個現有的class
   繼承,新的class稱為子類、擴展類(Subclass),而被繼承的class稱為基類、父類或超類(Baseclass、
   Superclass)
   重寫父類方法: 就是子類中,有一個和父類相同名字的方法,在子類中的方法
   會覆蓋掉父類中同名的方法。

   06_單繼承特性.py

問題一: 如何讓實現繼承?
        子類在繼承的時候,在定義類時,小括號()中為父類的名字

問題二: 繼承的工作機制是什么?
    父類的屬性、方法,會被繼承給子類。
    舉例如下:
        如果子類沒有定義__init__方法,父類有,那么在子類繼承父類的時候這個方法就被繼承了,
        所以只要創建對象,就默認執行了那個繼承過來的__init__方法
#在Python代碼中，沒有指定父類， 默認繼承object類。
#父類: object   子類: Student
class Student(object):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    def learn(self):
        print("%s正在學習編程......." %(self.name))

#父類: Student   子類: MathStudent
class MathStudent(Student):
    # 重寫父類的learn方法
    #重寫父類方法: 就是子類中,有一個和父類相同名字的方法,在子類中的方法會覆蓋掉父類中同名的方法。
    def learn(self):
        # 方法一: 調用父類的方法
        #Student.learn(self)
        #方法二: 調用父類的方法, 自動幫當前類尋找父類的名稱
        super(MathStudent, self).learn()
        print("%s正在學習英語四級....." %(self.name))

#父類: Student   子類: EnglishStudent
class EnglishStudent(Student):
    pass

s1 = Student("粉條", 10, 'male')
print(s1.name)
#當實例化對象， 子類沒有構造方法， 自動調用并執行父類的構造方法。
s2 = MathStudent("拉格朗日", 100, 'male')
#當子類調用的方法沒有的時候， 自動去父類里面尋找并執行。
s2.learn()

07_單繼承特性.py

問題一: 如何讓實現繼承?
        子類在繼承的時候,在定義類時,小括號()中為父類的名字

問題二: 繼承的工作機制是什么?
    父類的屬性、方法,會被繼承給子類。
    舉例如下:
        如果子類沒有定義__init__方法,父類有,那么在子類繼承父類的時候這個方法就被繼承了,
        所以只要創建對象,就默認執行了那個繼承過來的__init__方法。

#在Python代碼中，沒有指定父類， 默認繼承object類。
#父類: object   子類: Student
class Student(object):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    def learn(self):
        print("%s正在學習編程......." %(self.name))

#父類: Student   子類: MathStudent
class MathStudent(Student):
    pass

#父類: Student   子類: EnglishStudent
class EnglishStudent(Student):
    pass

s1 = Student("粉條", 10, 'male')
print(s1.name)
#當實例化對象， 子類沒有構造方法， 自動調用并執行父類的構造方法。
s2 = MathStudent("拉格朗日", 100, 'male')
#當子類調用的方法沒有的時候， 自動去父類里面尋找并執行。
s2.learn()

默認情況下,屬性在 Python 中都是“public”, 大多數 OO 語言提供“訪問控
制符”來限定成員函數的訪問。
在 Python 中,實例的變量名如果以 開頭,就變成了一個私有變量/屬性
(private),實例的函數名如果以 開頭,就變成了一個私有函數/方法(private)只
有內部可以訪問,外部不能訪問。

08_私有屬性和私有方法.py

#私有屬性和私有方法：

class Student(object):

    需求： 學生成績保密， 外部不可以訪問分數， 只可以訪問分數的等級

    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        #self.__score是私有屬性， 只能在類的內部訪問， 類的外部不可以訪問。
        self.__score = score

    #__get_level是私有方法，只能在類的內部訪問， 類的外部不可以訪問。
    def __get_level(self):
        if 90 <= self.__score <= 100:
            return "優秀"
        elif 80 <= self.__score < 90:
            return "良好"
        elif 60 <= self.__score < 80:
            return "及格"
        else:
            return "不及格"

stu1 = Student("粉條", 10, 59)
#print(stu1.__score)                               # 調用私有屬性失敗
#print("學生分數的等級: ", stu1.__get_level())        # 調用私有方法失敗

#Python解釋器自動將私有屬性和私有方法重命名了， 命名方式一般是_類名__屬性名、_類名__方法名
print(stu1._Student__score)
print(stu1._Student__get_level())

在Python 2及以前的版本中,由任意內置類型派生出的類,都屬于“新式
類”,都會獲得所有“新式類”的特性;反之,即不由任意內置類型派生出的類,
則稱之為“經典類
“新式類”和“經典類”的區分在Python 3之后就已經不存在,在Python 3.x
之后的版本,因為所有的類都派生自內置類型object(即使沒有顯示的繼承
object類型),即所有的類都是“新式類”。
最明顯的區別在于繼承搜索的順序不同,即:
經典類多繼承搜索順序(深度優先算法):先深入繼承樹左側查找,然后再返回,開始查找右側。
新式類多繼承搜索順序(廣度優先算法):先在水平方向查找,然后再向上查找,

09_多繼承.py

class TeacherMajor(object):
    def __init__(self, students_count):
        self.student_count = students_count

class DoctorMajor(object):
    def __init__(self, patients_count):
        self.patients_count = patients_count

#子類Student擁有2個父類TeacherMajor和DoctorMajor
class Student(TeacherMajor, DoctorMajor):
    def __init__(self, name, students_count, patients_count):
        self.name = name
        TeacherMajor.__init__(self, students_count)
        DoctorMajor.__init__(self, patients_count)

##繼承的順序如何查看?
#print(Student.__mro__)
stu1 = Student("粉條", 0, 0)
print(stu1.patients_count)
print(stu1.student_count)

#coding:utf-8
#注意： Python2環境中做實驗
#類D新式類.
class D(object):
    def hello(self):
        print("D...... hello")
class C(D):
    def hello(self):
        print("C...... hello")
class B(D):
    pass
class A(B, C):
    pass

#新式類多繼承搜索順序(廣度優先算法):先在水平方向查找,然后再向上查找,
a = A()
a.hello()
#C...... hello

#coding:utf-8
#注意： Python2環境中做實驗
#類D經典類.
class D:
    def hello(self):
        print("D...... hello")
class C(D):
    def hello(self):
        print("C...... hello")
class B(D):
    pass
class A(B, C):
    pass
#經典類多繼承搜索順序(深度優先算法):先深入繼承樹左側查找,然后再返回,開始查找右側。
a = A()
a.hello()
#D...... hello

多態特性
多態的好處就是,當我們需要傳入更多的子類,只需要繼承父類就可以了,而方法既可以直接
不重寫(即使用父類的),也可以重寫一個特有的。這就是多態的意思。調用方只管調用,不管
細節,而當我們新增一種的子類時,只要確保新方法編寫正確,而不用管原來的代碼。這就是著
名的“開閉”原則:
對擴展開放(Open for extension):允許子類重寫方法函數
對修改封閉(Closed for modification):不重寫,直接繼承父類方法函數
棧的封裝
棧是限制在一端進行插入操作和刪除操作的線性表(俗稱堆棧),允許進行操作的一端稱為“棧頂”,
另一固定端稱為“棧底”,當棧中沒有元素時稱為“空棧”。向一個棧內插入元素稱為是進棧,push;
從一個棧刪除元素稱為是出棧,pop。特點 :后進先出(LIFO)。

隊列的封裝
隊列是限制在一端進行插入操作和另一端刪除操作的線性表,允許進行插入操作的一端稱為“隊尾”,
允許進行刪除操作的一端稱為“隊頭”,,當隊列中沒有元素時稱為“空隊”。特點 :先進先出(FIFO)

12_stack.py

class Stack(object):
    """
    根據列表的數據結構封裝棧的數據結構
    屬性: 棧元素stack
    方法:
        get_top()
        get_bootom()
        push()
        pop()
    """
    def __init__(self):
        self.stack = [] # [1, 2, 3]

    def top(self):
        return self.stack[-1]

    def bootom(self):
        return self.stack[0]

    def push(self, item):
        """
        :param item: 入棧元素
        :return:
        """
        self.stack.append(item)
        return True

    def pop(self):
        item = self.stack.pop()
        return item

    def show(self):
        return self.stack

    #魔術方法, 使得代碼運行更加簡潔
    def __len__(self):
        return len(self.stack)

if __name__ == '__main__':
    stack = Stack()
    print(stack.show())
    #print(stack.top())
    #stack.push(1)
    #stack.push(2)
    #stack.push(3)
    #print("入棧后: ", stack.show())
    #item = stack.pop()
    #print("出棧元素為: ", item)
    #print("出棧后: ", stack.show())
    #print('棧元素個數: ', stack.__len__())
    print('棧元素個數: ', len(stack))

13_二叉樹節點的封裝.py

class Node(object):
    def __init__(self, data, lchild=None, rchild=None):
        self.data = data
        self.lchild = lchild
        self.rchild = rchild

    #魔術方法: len(), __len__. str(), __str__
    def __str__(self):  # 友好的字符串顯示信息
        return 'Node<%s>' % (self.data)

def pre_view( root):
    """
    先序遍歷: 根節點-左子樹節點-右子樹節點
    傳遞根節點
    :param root:
    :return:
    """
    if root == None:
        return
    print(root.data)
    pre_view(root.lchild)
    pre_view(root.rchild)
def last_view(root):
    """
    后序遍歷: -左子樹節點-右子樹節點-根節點
    傳遞根節點
    :param root:
    :return:
    """
    if root == None:
        return
    last_view(root.lchild)
    last_view(root.rchild)
    print(root.data)

def mid_view(root):
    """
    中序遍歷: -左子樹節點--根節點-右子樹節點
    傳遞根節點
    :param root:
    :return:
    """
    if root == None:
        return
    mid_view(root.lchild)
    print(root.data)
    mid_view(root.rchild)

if __name__ == '__main__':
    D = Node('D')
    B = Node('B', D)
    C = Node('C')
    A = Node('A', B, C)
    #print("A-left: ", str(A.lchild))
    #print("A-right: ", str(A.rchild))

    #先序遍歷(根左右)、中序遍歷(左根右)、后序遍歷(左右根)
    print("先序遍歷:")
    pre_view(A)
    print("后序遍歷:")
    last_view(A)
    print("中序遍歷:")
    mid_view(A)