面向對象

面向對象: class

函數編程

def email():
    print('發送郵件')

def msg():
    print('發送短信')


def weichat():
    print('發送微信')

if 1==1:
    email()
    msg()
    weichat()

　　面向對象編程

class Message:
    def email(self):
        print('發送郵件')

    def msg(self):
        print('發送短信')

    def weichat(self):
        print('發送微信')
if 1 == 1:
    obj = Message()
    obj.weichat()
    obj.msg()
    obj.email()

　　函數:定義簡單/調用簡單

       面向對象:缺點定義複雜/調用複雜   優勢 歸類  將某些相似的函數寫在一塊兒

總結:

函數的編程可能會比面向對象好

python中支持兩種編程方式

 

面向對象的三大特徵

封裝   繼承    多態

封裝:

數據封裝和方法封裝

相關功能封裝到一個類中

將數據封裝到一個對象

繼承

提升代碼的重用性

先在本身類(派生類)中，沒有時去父類(基類)中找

python支持多繼承

多繼承 先找左邊

self究竟是誰，self是哪一個類的對象，那麼就從該類開始找

super主動調用其餘類的成員

類名.方法名（本身穿self）   與繼承無關

super（）

多態

多種形態或多種狀態

鴨子模型，只要能夠嘎嘎叫的就是鴨子

因爲python原生態支持多態，因此沒有特殊性。可是在Java中必須爲要求的形態或形態子類

面向對象的成員

分三類  變量（字段）  方法    屬性

變量

實例變量 

靜態變量

class Province:

    # 靜態字段
    country ＝ '中國'

    def __init__(self, name):

        # 普通字段
        self.name = name


# 直接訪問普通字段
obj = Province('河北省')
print obj.name

# 直接訪問靜態字段
Province.country

字段的定義和使用

　　準則：

實例變量（字段）訪問時，使用對象訪問。即：obj.name

類變量（靜態字段）訪問時，使用方法訪問，即Foo.country（是在不方便時，才用對象）

 

方法：  實例方法    靜態方法   類方法

實例方法：  def  func（self）：

靜態方法：@staticmethod

若是方法無需使用對象中封裝的值，那麼就可使用靜態方法

類方法：@classmethod

若是會使用當前類那麼就使用類方法

class Foo:

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

    def ord_func(self):
        """ 定義普通方法，至少有一個self參數 """

        # print self.name
        print '普通方法'

    @classmethod
    def class_func(cls):
        """ 定義類方法，至少有一個cls參數 """

        print '類方法'

    @staticmethod
    def static_func():
        """ 定義靜態方法 ，無默認參數"""

        print '靜態方法'


# 調用普通方法
f = Foo()
f.ord_func()

# 調用類方法
Foo.class_func()

# 調用靜態方法
Foo.static_func()

方法的定義和使用

　

屬性：經過方法改造出來

編寫：方法上方寫@property    方法參數：只有一個self

調用：無需加括號   對象.方法

應用場景：對於簡單的方法，當無需傳參且有返回值時可使用@property

# ############### 定義 ###############
class Foo:

    def func(self):
        pass

    # 定義屬性
    @property
    def prop(self):
        pass
# ############### 調用 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #調用屬性

屬性的定義和使用

修飾符

私有

成員的修飾符爲兩個下劃線

繼承中   私有變量在父類(基類)中，子類沒法瞭解獲取

公有

默認公有

嵌套（組合）

數據的各類嵌套

 

 特殊方法

class Foo(object):

    def __init__(self,a1,a2):
        self.a1 = a1
        self.a2 = a2
    
    def __call__(self, *args, **kwargs):
        print(11111,args,kwargs)
        return 123

    def __getitem__(self, item):
        print(item)
        return 8

    def __setitem__(self, key, value):
        print(key,value,111111111)

    def __delitem__(self, key):
        print(key)

    def __add__(self, other):
        return self.a1 + other.a2

    def __enter__(self):
        print('1111')
        return 999

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('22222')

# 1. 類名() 自動執行 __init__
# obj = Foo(1,2)

# 2. 對象() 自動執行 __call__
# ret = obj(6,4,2,k1=456)

# 3. 對象['xx']  自動執行 __getitem__
# ret = obj['yu']
# print(ret)

# 4. 對象['xx'] = 11  自動執行 __setitem__
# obj['k1'] = 123

# 5. del 對象[xx]     自動執行 __delitem__
# del obj['uuu']

# 6. 對象+對象         自動執行 __add__
# obj1 = Foo(1,2)
# obj2 = Foo(88,99)
# ret = obj2 + obj1
# print(ret)

# 7. with 對象        自動執行 __enter__ / __exit__
# obj = Foo(1,2)
# with obj as f:
#     print(f)
#     print('內部代碼')

# 8. 真正的構造方法
# class Foo(object):
#     def __init__(self, a1, a2):     # 初始化方法
#         """
#         爲空對象進行數據初始化
#         :param a1:
#         :param a2:
#         """
#         self.a1 = a1
#         self.a2 = a2
#
#     def __new__(cls, *args, **kwargs): # 構造方法
#         """
#         建立一個空對象
#         :param args:
#         :param kwargs:
#         :return:
#         """
#         return object.__new__(cls) # Python內部建立一個當前類的對象(初創時內部是空的.).
#
# obj1 = Foo(1,2)
# print(obj1)
#
# obj2 = Foo(11,12)
# print(obj2)

內置函數

issubclass（）

檢查第一個參數是第二個參數的子類

class Base(object):
    pass

class Foo(Base):
    pass

class Bar(Foo):
    pass

print(issubclass(Bar,Base)) # 檢查第一個參數是不是第二個參數的 子子孫孫類

		

type

獲取當前對象是有哪一個類建立

獲取對象類

"""
 獲取當前對象是由那個類建立。

"""

"""
class Foo(object):
    pass

obj = Foo()

print(obj,type(obj)) # 獲取當前對象是由那個類建立。
if type(obj) == Foo:
    print('obj是Foo類型')
"""

# #### 練習題
"""
class Foo(object):
    pass

class Bar(object):
    pass

def func(*args):
    foo_counter =0
    bar_counter =0
    for item in args:
        if type(item) == Foo:
            foo_counter += 1
        elif type(item) == Bar:
            bar_counter += 1
    return foo_counter,bar_counter

# result = func(Foo(),Bar(),Foo())
# print(result)

v1,v2 = func(Foo(),Bar(),Foo())
print(v1,v2)
"""

isinstance

判斷第一個參數（實例）是不是第二個參數（類及父類）的實例

class Base(object):
    pass

class Foo(Base):
    pass

obj1 = Foo()
print(isinstance(obj1,Foo))  # 檢查第一個參數（對象）是不是第二個參數（類及父類）的實例。
print(isinstance(obj1,Base)) # 檢查第一個參數（對象）是不是第二個參數（類及父類）的實例。


obj2 = Base()
print(isinstance(obj2,Foo))  # 檢查第一個參數（對象）是不是第二個參數（類及父類）的實例。
print(isinstance(obj2,Base)) # 檢查第一個參數（對象）是不是第二個參數（類及父類）的實例。



# #################### 練習
"""
給你一個參數，判斷對象是否是由某一個指定類？ type                  --> type(obj) == Foo
給你一個參數，判斷對象是否是由某一個指定類或其父類？ isinstance    --> instance(obj,Foo)
"""