類與對象,類的繼承,類的派生,類的組合,多態

6.18-6.19自我總結

面向對象編程

1.類與對象

在python中先有類再有對象,類和對象,你能夠當作,類是把對象的相同特徵和相同方法彙總再一塊兒,再根據類來生成對象,這個對象具備類的特徵與方法

1.類的命名

class 類名:#這裏類名必須用駝峯體進行命名有些特殊狀況除外
    name = a #特徵
    def __init__(self): self #對於生成的對象來講是生成的對象,對於類來講是個要傳的形參,且__init__在運行類的時候他會調用函數
        pass
    def func():#func爲方法.其在命名對象時候不會進行調用
        pass
類的調用
對象 = 類名()

2.對象的查找順序

#先查找對象他自己,若是沒有,再去類裏面找,若是尚未就報錯
#一.自身有類也有
class a:
    name = 'sb'
    def __init__(self,name):
        self.name = name
        
b = a('2b')
print(b.name)
#結果是2b
#本身沒有類有
class a:
    name = 'sb'
    def __init__(self,name):
        self.xx = name
b = a('2b')
print(b.name)
#結果是sb

3.生成好後的對象進行值修改

用.把對於的值取出來再進行賦值修改,或者直接生成一個同名的對象把原來的覆蓋掉

2.類的繼承

1.父類,子類

繼承是一種新建類的方式，新建的類稱爲子類，被繼承的類稱爲父類

2.繼承寫法

class fu:
    print('from fu')
class son(fu): #命名中()內的內容則是這個類的其相對的父類,不進行處理默認傳無參的父類
    pass
a = son()
print(a)
#from fu

3.查找順序

#先查找對象他自己,若是沒有,再去類裏面找,若是還沒就去父類的自己找,在去父類的類中找,以此類推.直到沒有會報錯
#菱形繼承除外

3.類的派生

在父類和子類的基礎上,子類再父類的基礎上須要有更多的特徵的時候這時候咱們引入的派生

1.只有一個父類的時候

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

#在他子類咱們要加個車選項
#第一種寫法
class son(fu):
    def __init__(self,name,age,money,car):
        super().__init__(name,age,money)
        self.car = car
son_1 =son(1,2,3,4)
print(son_1.car)
#第二種寫法
'''
嚴格以來繼承屬性查找關係
super()會獲得一個特殊的對象，該對象就是專門用來訪問父類中的屬性的（按照繼承的關係）
super().__init__(不用爲self傳值)
super的完整用法是super(本身的類名,self),在python2中須要寫完整，而python3中能夠簡寫爲super()
'''
class son(fu):
    def __init__(self,name,age,money,car):
        super(son,self).__init__(name,age,money)
        self.car = car
son_1 =son(1,2,3,4)
print(son_1.car)

2.有多個父類的時候

class FuOne:
    def __init__(self,name,age):
        self.name = name
        self.age = age
class FuTwo:
    def __init__(self,money):
        self.money = money

class Son(FuOne,FuTwo): #不進行處理默認傳無參的父類
    def __init__(self,name,age,money):
    # super(Son, self).__init__(naem,age)等效與FuOne.__init__(FuOne,name,age)讓父類不爲無參
    #super我能力有限,只能作到他取第一個父類,無法作到他取第二個父類,可能他只能取第一個父類
        FuOne.__init__(FuOne,name,age)
        FuTwo.__init__(FuTwo,money)
son = Son(1,2,3)
print(son.money)

#不作處理
class FuOne:
    print('123')
    def __init__(self,name,age):
        self.name = name
        self.age = age
class FuTwo:
    print('123')
    def __init__(self,money):
        self.money = money

class Son(FuOne,FuTwo): #不進行處理默認傳無參的父類,且自動導入了第一個,須要傳和第一個同樣的參數個數
    pass
'''
123
123
'''

4.類的組合

主要就是經過類的方法進行組合,並且方法內傳的是類名

# 組合：組合在一塊兒
# 簡單的選課系統
class People:
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def eat(self):
        print(f'{self.name}開始吃了')


class Student(People):
    def __init__(self, student_id, name, gender):
        self.student_id = student_id
        super(Student, self).__init__(name, gender)

    def choose_course(self, course):  # python對象
        self.course = course  # 組合  # 把對象看成變量值來用，看成形參/實參/返回值。
        print(f'{self.name}選課{course.name}成功')


class Teacher(People):
    def __init__(self, level, name, gender):
        self.level = level
        super(Teacher, self).__init__(name, gender)

    def scored(self, student, course, score):
        print(f'老師{self.name}給{student.name}課程{course.name}打分{score}')


class Course:
    def __init__(self, name, price):
        self.name = name
        self.price = price


class Admin(People):
    def create_course(self, name, price):
        course = Course(name, price)
        print(f'管理員{self.name}建立了課程{name}')
        return course


# 課程
# python = Course('Python', '8888')
# linux = Course('Linux', '6666')

# 學生
zhubajie = Student('01', 'zhubajie', 'male')
sunwukong = Student('02', 'sunwukong', 'male')

# 老師
nick = Teacher('1', 'nick', 'male')
tank = Teacher('2', 'tank', 'female')

# 管理員
egon = Admin('egon', 'male')

# 業務邏輯

# 1. 建立課程
python = egon.create_course('python', '8888')
print(python.__dict__)
linux = egon.create_course('linux', '6666')
print(linux.__dict__)

# 2. 學生選擇課程
zhubajie.choose_course(python)


# 3. 老師給學生打分
nick.scored(zhubajie,python,'0')

5.多態

1.定義

多態指的是一類事物有多種形態，（一個抽象類有多個子類，於是多態的概念依賴於繼承）

1. 序列數據類型有多種形態：字符串，列表，元組
2. 動物有多種形態：人，狗，豬

2.使用示範

import abc


class Animal(metaclass=abc.ABCMeta):  # 同一類事物:動物
    @abc.abstractmethod  # 上述代碼子類是約定俗稱的實現這個方法，加上@abc.abstractmethod裝飾器後嚴格控制子類必須實現這個方法
    def talk(self):
        raise AttributeError('子類必須實現這個方法')


class People(Animal):  # 動物的形態之一:人
    def talk(self):
        print('say hello')


class Dog(Animal):  # 動物的形態之二:狗
    def talk(self):
        print('say wangwang')


class Pig(Animal):  # 動物的形態之三:豬
    def talk(self):
        print('say aoao')


peo2 = People()
pig2 = Pig()
d2 = Dog()

peo2.talk()
pig2.talk()
d2.talk()

3.注意事項

注意：多態與多態性是兩種概念

多態性是指具備不一樣功能的函數可使用相同的函數名，這樣就能夠用一個函數名調用不一樣內容的函數。在面向對象方法中通常是這樣表述多態性：向不一樣的對象發送同一條消息，不一樣的對象在接收時會產生不一樣的行爲（即方法）。也就是說，每一個對象能夠用本身的方式去響應共同的消息。所謂消息，就是調用函數，不一樣的行爲就是指不一樣的實現，即執行不一樣的函數。