python之面向對象3

 面向對象介紹

1、面向對象和麪向過程
    面向過程：核心過程二字，過程即解決問題的步驟，就是先幹什麼後幹什麼
    基於該思想寫程序就比如在這是一條流水線，是一種機械式的思惟方式
    優勢：複雜的過程流程化
    缺點：擴展性差

    面向對象：核心是對象二字，對象指特徵與技能的結合體
    基於該思想編寫程序就比如在創造一個世界，世界是由一個個對象組成，是一種‘上帝式’的思惟方式
    優勢：可擴展性強
    缺點：變成複雜度高，極容易出現過分設計的問題


二、類
    對象是特徵與技能的結合體，類就是一系列對象類似的特徵與技能的結合體
    在現實生活中：必定是先有一個個具體的對象，後總結出類
    在程序中：必定是先定義類，後產生對象

#類體代碼在類的定義階段就會馬上執行
class Students:
    school = '宏福教育'
    def run(self):
        # return 'running......'
        print('running....')
stu1 = Students()

stu2 = Students()

stu3 = Students()

print(Students.school)#數據屬性 
print(Students.run)#函數屬性 


print(stu1.school)#查詢屬性 
stu1.contry = '中國'#添加屬性 
del stu1.contry#刪除類屬性 
stu1.school = '宏福'#修改屬性

#實例化出不一樣屬性的對象
class Students:
    school = '宏福教育'
    def __init__(self,name, age, job):
        self.name = name
        self.age = age
        self.job = job
    def run(self):
        # return 'running......'
        print('running....')
stu1 = Students('張三', 18, 'IT')
stu2 = Students('王二', 16, 'student')
stu3 = Students('趙五', 19, 'teacher')

 封裝

封裝案例1.

　　0一、封裝

　　　　1.封裝是面相對性一大特色

　　　　2.面向對象編程的第一步--將屬性和方法封裝到一個抽象的類當中

　　　　3.外界使用類建立對象，而後讓對象調用方法

　　　　4.對象方法的細節都被封裝在類的內部

　　0二、小明愛跑步

　　　　需求

　　　　1.小明體重75公斤

　　　　2.小明每次跑步都會減肥0.5公斤

　　　　3.小明每次吃東西體重會增長1公斤

　　　　

　　　　

class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def run(self):
        self.weight -= 0.5

    def eat(self):
        self.weight += 1

    def __str__(self):
        return '名字:%s\n體重:%s\n' % (self.name, self.weight)

xm = Person('小明', 75)
xm.eat()
xm.run()
print(xm)

#當使用print輸出對象的時候，只要本身定義了__str__(self)方法，那麼就會打印從在這個方法中return的數據

封裝案例2

　　需求：

　　　　一、房子有戶型、總面積、傢俱名稱列表

　　　　　　房子沒有任何傢俱

　　　　二、傢俱備名字和佔地面積，其中

　　　　　　席夢思(bed):4平米

　　　　　　衣櫃(chest): 2平米

　　　　　　餐桌(table): 1.5平米

　　　　三、將以上3個傢俱添加到房子中

　　　　四、打印房子中，要求輸出:戶型、總面積、剩餘面積、傢俱名稱列表

class Items(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return '傢俱名稱:%s\n佔地面積:%s\n' % (self.name, self.area)

class House(object):
    def __init__(self, house_type, total_area):
        self.house_type = house_type
        self.total_area = total_area
        self.free_area = total_area
        self.items = []

    def add_item(self, item):
        self.free_area = self.free_area - item.area
        self.items.append(item.name)

    def __str__(self):
        return '房子類型:%s\n房子總大小:%s\n房間剩餘面積:%s\n傢俱列表:%s\n' % (self.house_type, self.total_area, self.free_area, self.items)


bed = Items('席夢思', 10)
chest = Items('餐桌', 5)
house = House('兩室一廳', 100)
house.add_item(bed)
house.add_item(chest)
print(house)

View Code

 

 

 封裝案例3：

　　　　屬性能夠是另一個類建立的對象：

　　　　

 

class Gun:#建立槍類
    def __init__(self,gun_type):
        self.gun_type = gun_type#初始化槍的型號
        self.bullet = 0#初始化子彈的數量

    def add_count(self, count):#添加子彈
        self.bullet += count

    def shoot(self):#射擊
        if self.bullet > 0:#假如子彈數量大於0
            self.bullet -= 1# 那就射擊，而且減小子彈數量
            print('開火.......%s' % self.bullet)
        else:
            print('沒有子彈啊，兄弟，別這麼坑我啊？？？')#不然沒有就顯示沒有子彈


class Soldier:#建立一個士兵的類
    def __init__(self, name,gun=None):
        self.name = name#初始化士兵的姓名
        self.gun = gun#初始化槍

    def fire(self):#開火方法
        if self.gun:#假若有槍
            self.gun.shoot()#那就射擊
        else:#否則就顯示沒有槍
            print('沒有槍啊，兄弟，你讓我去送死嗎？？')

ak47 = Gun('AK47')#建立一個槍的對象叫ak47
ak47.add_count(10)#添加10顆子彈
xsd = Soldier('許三多')#實例化一個許三多的士兵對象
xsd.gun = ak47#把槍交到許三多手中
xsd.fire()#開火

View Code

 

 繼承

　　目標：

　　　　單繼承

　　　　多繼承

　　　　繼承：

　　　　　　繼承實現代碼的重用，相同的代碼不須要重複的編寫

 

 

 

class Anamal:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我會飛啦！！！！')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

　　方法的重寫

 

#重寫哮天犬叫喚的方法
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我會飛啦！！！！')

    def bark(self):
        print('牛逼的叫.......')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

　　對父類的方法進行擴展

　　　　1.在子類中重寫父類的方法

　　　　2.在須要的位置使用super().父類方法來調用父類方法的執行

　　　　3.代碼其餘的位置針對子類的需求，編寫子類特有的代碼實現

　　關於super

　　　　在python中super是一個特殊的類

　　　　super()就是使用super類建立出來的對象

　　　　最常使用的場景就是在重寫父類方法時，調用在父類中封裝的方法實現

#用super繼承父類的方法並擴展新內容
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我會飛啦！！！！')

    def bark(self):
        print('牛逼的叫.......')
        super().bark()
        print('%*#*@^$*(@') 
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

 

 多態

　　面向對象的三大特性：

　　1.封裝根據職責將屬性和方法封裝到一個抽象的類中

• • 定義類的準則

　　2.繼承實現代碼的重用，相同的代碼不須要重複的編寫

• • 設計類的技巧
  • 子類針對本身特有的需求，編寫特定的代碼

　　3.多態不一樣的子類對象調用相同的父類方法，產生不一樣的執行結果

　　　　1.多態能夠增長代碼的靈活度

　　　　2.以繼承和重寫父類方法爲前提

　　　　3.是調用方法的技巧，不會影響到類的內部設計

 

#多態的特性：讓不一樣的子類對象調用相同的代碼產生不一樣的結果
class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s 開開心心去玩耍.....' % self.name)

class XiaoTianQuan(Dog):
    def game(self):
        print('%s 開開心心去玩耍.....' % self.name)

class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print('%s 和 %s 正在開開心心的玩耍......' % (self.name, dog.name))
        dog.game()
#建立人對象
xiaoming = Person('小明')
#建立狗對象
dog = Dog('旺財')
#讓小明跟狗玩耍
xiaoming.game_with_dog(dog)

 

異常處理

什麼是異常？

異常便是一個事件，該事件會在程序執行過程當中發生，影響了程序的正常執行。

通常狀況下，在Python沒法正常處理程序時就會發生一個異常。

異常是Python對象，表示一個錯誤。

當Python腳本發生異常時咱們須要捕獲處理它，不然程序會終止執行。

 

異常處理：

捕捉異常可使用try/except語句。

try/except語句用來檢測try語句塊中的錯誤，從而讓except語句捕獲異常信息並處理。

若是你不想在異常發生時結束你的程序，只需在try裏捕獲它。

語法：

如下爲簡單的try....except...else的語法：

try:
    正常的操做
   ......................
except:
    發生異常，執行這塊代碼
   ......................
else:
    若是沒有異常執行這塊代碼

例子：

try:
    fh = open("testfile", "w")
    fh.write("這是一個測試文件，用於測試異常!!")
except IOError:
    print("Error: 沒有找到文件或讀取文件失敗")
else:
    print("內容寫入文件成功")
    fh.close()

try-finally 語句：

try:
<語句>
finally:
<語句>    #退出try時總會執行
raise

try:
    fh = open("testfile", "w")
    fh.write("這是一個測試文件，用於測試異常!!")
finally:
    print("Error: 沒有找到文件或讀取文件失敗")

用戶自定義異常：

經過建立一個新的異常類，程序能夠命名它們本身的異常。異常應該是典型的繼承自Exception類，經過直接或間接的方式。

如下爲與RuntimeError相關的實例,實例中建立了一個類，基類爲RuntimeError，用於在異常觸發時輸出更多的信息。

在try語句塊中，用戶自定義的異常後執行except塊語句，變量 e 是用於建立Networkerror類的實例。

 

class MyError(Exception):
    def __init__(self,age):
        self.age=age
    # def __str__(self):
    #     return self.age

def ag():
    age=int(input('輸入年齡：'))
    if age<=0 or age>100:
        raise MyError('年齡只能在0到100歲之間')
try:
     ag()
except MyError as e:
    print(e)

自定義異常