python面向對象-1

行者花雕 2020-06-23

展開全文

1.面向對象的思想優(yōu)點

　　優(yōu)點: 簡化代碼 ,構建公共模板 ,擴展性強

　　思想: 類作為模板 ,對象通過模板實例化對象 ,對象去做事 ,抽象將顯示存在的事物使用代碼體現(xiàn)

2.三大特性

　　封裝(狹義) : 對屬性的封裝 ,對方法的封裝

　　繼承

　　　　1.子類擁有父類除私有內容外所有

　　　　2.對象通過子類-父類-...找到自己所需要的屬性方法

　　　　3.py3默認繼承object是新式類 , 使用c3算法 ,print(類型.mro()) 判斷類名,查看多繼承的繼承順序

　　　　4.super().方法 ,可以調用父類的同名方法

class Base:
    def __init__(self):
        print('BASE')


class A(Base):
    def __init__(self):
        super().__init__()
        print('A')


class B(Base):
    def __init__(self):
        super().__init__()
        print('B')


class C(A, B):
    def __init__(self):
        super().__init__()
        print('C')


C()

print(C.mro())  # 按照這個算法順序,確定某個類的繼承順序

　　多態(tài)

3.成員

　　屬性 (__dict__查看)

　　　　對象的屬性

　　　　類的屬性

　　方法 (dir()查看)

　　　　普通方法

　　　　類方法 :@classmethod

　　　　靜態(tài)方法 :@staticmethod 放在類中的普通函數(shù)

　　屬性 (方法偽裝屬性)

　　　　很多方法執(zhí)行后獲得的是一個結果 ,不像一個動作

　　　　@property　　　　　　#偽裝屬性

　　　　@方法名.setter　　　　#根據(jù)傳入的values ,來改變屬性的返回值

　　私有成員

　　　　僅內部可以調用的變量或方法 ,私有屬性,私有類方法,私有對象屬性

　　self與cls

　　　　self形參是對象本身 ,當對象實例化之后 ,調用時將對象的內存地址給self

　　　　cls形參是類本身

class Person:
    local = '地球'
    # 私有類屬性
    __character__ = '積極向上'

    def __init__(self, name, ad, hp, character):
        self.name = name
        self.ad = ad
        self.hp = hp
        # 私有對象屬性
        self.__character__ = character

    # 私有類方法
    def __local__(cls):
        print(cls.__character__)

    # 類方法
    @classmethod
    def Dict(cls):
        return cls.__dict__

    # 靜態(tài)方法
    @staticmethod
    def Sum(n):
        return n + 2

    # 屬性Info
    @property
    def Info(self):
        return '{}-{}-{}'.format(self.name, self.ad, self.hp)

    # 修改屬性Info
    @Info.setter
    def Info(self, values):
        if values < 100:
            self.ad = values


print(Person.__character__)
print(Person.Dict())
print(Person.Sum(2))

obj1 = Person('lucy', 10, 50, '積極向左')
print(obj1.Info)
obj1.Info = 99
print(obj1.Info)

4.對象的行為

　　實例化對象

　　　　1.__new__方法在內存開辟空間創(chuàng)建對象

　　　　2.執(zhí)行__init__方法初始化對象

　　對象調用屬性與方法的順序

　　　　優(yōu)先在內存中尋找-->對象內部封裝-->類-->父類

5.類與類之間的關系

　　依賴關系 : 相互依存性較低 ,就是一個類中需要執(zhí)行動作時 ,需要其他類中的方法屬性去幫助完成 ,一般通過參數(shù)將對象進行調用

class Eat:
    def handler(self, *args):
        for i in args:
            i.eat()


class Apple:
    def eat(self):
        print('吃蘋果')


class Pear:
    def eat(self):
        print('吃梨')


obj = Eat()
obj1 = Apple()
obj2 = Pear()
obj.handler(obj1, obj2)

　　關聯(lián)關系 : 兩種事物必須是互相關聯(lián)的. 但是在某些特殊情況下是可以更改和更換的.

class Country:
    def __init__(self, name):
        self.name = name
        self.pro_list = []

    def add_pro(self, pro):
        self.pro_list.append(pro)

    def show_pro(self):
        for i in self.pro_list:
            print(i.name, i.cou)


class province:
    def __init__(self, name, country):
        self.name = name
        self.cou = country


C1 = Country('火星國')

p1 = province('省1', C1.name)
p2 = province('省2', C1.name)

C1.add_pro(p1)
C1.add_pro(p2)

C1.show_pro()

　　繼承關系 :就是繼承父類非私有屬性方法 ,self會先從對象中尋找方法屬性 ,當沒有的時候會去父類中尋找

6.接口類(約束抽象)

　　接口類是繼承的一個用法 ,繼承可以讓子類擁有父類的代碼 ,防止代碼重復 ,還可以定義一個接口類 ,僅定義接口名(函數(shù)名) ,由子類繼承去寫接口中的功能

　　接口類抽象規(guī)定了兼容接口 ,是的外部調用者不需要關心細節(jié)

# 接口類 ,約束子類必須擁有的方法,及參數(shù)
class Pay_Base:
    def pay(self, money):
        raise NotImplementedError('pay must be Implemented')


class ALpay(Pay_Base):
    def pay2(self, money):
        print('支付寶支付')


class WXpay(Pay_Base):
    def pay(self, money):
        print('微信支付')


class APpay(Pay_Base):
    def pay(self, money):
        print('蘋果支付')

# 支付函數(shù)，執(zhí)行對象的接口類約束函數(shù)
def pay(payobj, money):
    payobj.pay(money)


p1 = ALpay()

pay(p1, 100)

7.反射

　　反射是通過字符串去操作對象或者類或者是模塊 ,第一參數(shù)是(對象或者類或者是模塊)

　　常用:

　　　　getter()　　　　 getattr(參數(shù)1 ,'字符串')　　　　　　　　#獲取內存地址

　　　　hasattr()　　　　hasattr(參數(shù)1 ,'字符串')　　　　　　　　#判斷變量是否存在

import m1
class A:
    local = 'Beijing'

    def __init__(self):
        pass

    def datetime1(self):
        print('time')

a1 = A()

# 通過反射從對象獲取屬性
b = getattr(a1, 'local')

# 通過反射從類中拿屬性
c = getattr(A, 'local')

# 通過反射從對象中拿方法
d = getattr(a1, 'datetime1')

# 通過反射從模塊中拿到類B
B = getattr(m1,'B')

print(hasattr(m1,'B'))

e = B()

8.特殊雙下方法

　　__str__與__repr__ ,不太理解,但是都可以把對象的內存地址轉為可讀字符串

　　__call__方法 ,當對象 + () 的情況就會執(zhí)行 __call__方法

class A:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def __call__(self, *args, **kwargs):
        print(args, kwargs)
        return args, kwargs

    def __repr__(self):
        return '有str就不會執(zhí)行repr'

a1 = A('lucy')

# 執(zhí)行對象的__str__方法
print(a1)

# 執(zhí)行__call__方法
a1(1, 2, 3, n=1, m=2)

# 直接執(zhí)行對象的__repr__方法
print(repr(a1)) 

# 查看對象有多少個方法
print(dir(a1))

　　__new__方法 ,new方法是object基類中的方法 ,是構造方法 ,開辟內存 ,創(chuàng)建對象

class A:
    def __new__(cls, *args, **kwargs):
        print('1')
        cls.name = 'LOP'
        return object.__new__(cls)  # 引用obeject的c語言創(chuàng)建對象功能

    def __init__(self):
        print('2')


# 第一步執(zhí)行__new__方法中的內容,將返回值給對象名a1
# 第二步執(zhí)行__init__初始化對象
a1 = A()
print(a1.name)
a2 = A()
print(a1 is a2)　　　　# False 兩個對象各用內存

##單例模式##

class A:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
        
        # __instance從此記錄單例對象的內存
        return cls.__instance

a1 = A()
a2 = A()
print(a1 is a2)