面向對象--初級

時間  2019-12-11
標籤 面向對象 初級 欄目 軟件設計 简体版
原文   原文鏈接

1、反射

一、反射的小例子：

>>> import json 
>>> dir(json)             
['JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', '__version__', '_default_decoder', '_default_encoder', 'decoder', 'dump', 'dumps', 'encoder', 'load', 'loads', 'scanner']

 如上所示，dir 是一個內置的反射函數，能夠列出對象的屬性和方法java

二、　　

　　經過字符串的形式，導入模塊
　　經過字符串的形式，去模塊中尋找指定的函數，並執行python

反射：(在內存中操做，對原來的文件沒有影響)
		根據字符串的形式去某個模塊中尋找東西
		根據字符串的形式去某個模塊中判斷是否存在
		根據字符串的形式去某個模塊中設置東西
		根據字符串的形式去某個模塊中刪除東西
		
		根據字符串的形式去對象(某個模塊)中操做成員

三、模塊導入升級版

inp = input("請輸入模塊名:")
inp_func = input("請輸入要執行的函數名：")
dd = __import__(inp)# __import__ 用於以字符串的形式導入模塊

target_func = getattr(dd, inp_func)# getattr  用於以字符串的形式去某個模塊中尋找函數

ret = target_func()
print(ret)
經過字符串帶入模塊 
#應用根據用戶輸入導入模塊
inp = input("請輸入模塊：")
inp_func = input("請輸入執行的函數：")

# __import__以字符串的形式導入模塊
moudle = __import__(inp)
#getattr  用以去某個模塊中尋找某個函數
target_func = getattr(moudle,inp_func)

relust = target_func()
print(relust)
執行指定模塊中的指定函數

四、在反射中經常使用到的方法

  • getattr---以字符串的形式去某一個模塊中尋找，找不到返回None
import mosson

#去mosson模塊，尋找name變量，找不到返回none
target_func = getattr(commas ,"name",None)
print(target_func)
getattr
  • hasattr---經過字符串的形式去某一個模塊中判斷是否存在
import mosson

#去mosson模塊中尋找f1，有返回true，沒有返回none
target_func = hasattr(commas,"f1")
print(target_func)
hasattr
  • setattr---經過字符串的形式去模塊中設置東西
import mosson

#去mosson模塊中尋找name，有返回true，沒有返回none
target_func1 = hasattr(commas,"name")
print(target_func1)

#在內存裏往mosson模塊中添加name = "zhangyanlin"
setattr(mosson,"name","zhangyanlin")
#在內存裏往mosson模塊中建立函數
setattr(mosson,"f3",lambda x: "zhen" if x >10 else "jia")

#去mosson模塊中尋找name，有返回true，沒有返回none
target_func = hasattr(mosson,"name")
print(target_func)
setattr
  • delattr---以字符串的形式去模塊中刪除內容
import mosson

target_func = hasattr(mosson,"f1")
print(target_func)

del_func = delattr(mosson,"f1")

target_func = hasattr(mosson,"f1")
print(target_func
delattr

實例：程序員

'''
基於web框架實現路由功能
'''
url = str(input("請輸入URL："))  #輸入URL，先輸入模塊名，‘/’，後面加函數
 
target_moudle,target_func = url.split("/") # 用/把分割開，前面是模塊 後面是函數
 
moudle = __import__(target_moudle,fromlist=True)  #導入模塊
 
if hasattr(moudle,target_func):   #判斷模塊裏有這個函數
    target_func = getattr(moudle,target_func)   #找到那個函數
    ret = target_func()   #執行函數
    print(ret)
else:                 #不然報錯
    print("404")

2、面向對象

  • 面向過程編程：根據業務邏輯從上到下寫壘代碼
  • 函數式編程：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可
  • 面向對象編程：對函數進行分類和封裝，讓開發「更快更好更強...」

面向過程編程最易被初學者接受，其每每用一長段代碼來實現指定功能，開發過程當中最多見的操做就是粘貼複製，即：將以前實現的代碼塊複製到現需功能處。web

while True：
    if cpu利用率 > 90%:
        #發送郵件提醒
        鏈接郵箱服務器
        發送郵件
        關閉鏈接

    if 硬盤使用空間 > 90%:
        #發送郵件提醒
        鏈接郵箱服務器
        發送郵件
        關閉鏈接

    if 內存佔用 > 80%:
        #發送郵件提醒
        鏈接郵箱服務器
        發送郵件
        關閉鏈接
面向過程

隨着時間的推移，開始使用了函數式編程，加強代碼的重用性和可讀性，就變成了這樣：數據庫

def 發送郵件(內容)
    #發送郵件提醒
    鏈接郵箱服務器
    發送郵件
    關閉鏈接

while True：
    if cpu利用率 > 90%:
        發送郵件('CPU報警')

    if 硬盤使用空間 > 90%:
        發送郵件('硬盤報警')

    if 內存佔用 > 80%:
        發送郵件('內存報警')
函數式編程

2.一、建立類和對象

面向對象編程是一種編程方式，此編程方式的落地須要使用 「類」 和 「對象」 來實現，因此，面向對象編程其實就是對 「類」 和 「對象」 的使用。編程

　　類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能json

　　對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數c#

  • class是類的關鍵字，表示要建立一個類
  • 建立對象，類名稱後加括號

注： 類中的函數的第一個參數必須是self服務器

　　類中定義的函數叫作方法框架

# 建立類，類名爲Foo
class Foo:
    def Bar(self):#定義一個Bar方法
        print 'Bar'#若是Foo類執行Bar方法就會打印'Bar'
    def Hello(self, name):
        print 'i am %s' %name
# 根據類Foo建立對象obj
obj = Foo()
obj.Bar()            #執行Bar方法
obj.Hello('wupeiqi') #執行Hello方法　
  • 面向對象：【建立對象】【經過對象執行方法】
  • 函數編程：【執行函數】

2.二、面向對象的三大特徵：封裝、繼承、多態

2.2.一、封裝

封裝，顧名思義就是將內容封裝到某個地方，之後再去調用被封裝在某處的內容。

因此，在使用面向對象的封裝特性時，須要：

  • 將內容封裝到某處
  • 從某處調用被封裝的內容

self 是一個形式參數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等於 obj1

                              當執行 obj2 = Foo('alex', 78 ) 時，self 等於 obj2

因此，內容其實被封裝到了對象 obj1 和 obj2 中，每一個對象中都有 name 和 age 屬性，在內存裏相似於下圖來保存

2.2.二、從某處調用被封裝的內容

調用被封裝的內容時，有兩種狀況：

  • 經過對象直接調用
  • 經過self間接調用

實例一、經過對象直接調用被封裝的內容

上圖展現了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式能夠如此調用被封裝的內容：對象.屬性名

class Foo:
    def __init__(self, name, age):#構造方法
        self.name = name
        self.age = age

obj1 = Foo('wupeiqi', 18) 
print(obj1.name)    # 直接調用obj1對象的name屬性
print(obj1.age)    # 直接調用obj1對象的age屬性

obj2 = Foo('alex', 73)
print(obj2.name)    # 直接調用obj2對象的name屬性
print(obj2.age)     # 直接調用obj2對象的age屬性

實例2：經過self間接調用被封裝的內容

執行類中的方法時，須要經過self間接調用被封裝的內容

class Foo:
    def __init__(self, name, age):#構造方法
        self.name = name
        self.age = age

    def detail(self):
        print self.name
        print self.age 
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，因此，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Foo('alex', 73)
obj2.detail()  # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，因此，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
self間接調用

綜上所述，對於面向對象的封裝來講，其實就是使用構造方法將內容封裝到 對象 中，而後經過對象直接或者self間接獲取被封裝的內容

下面咱們經過實例來比較函數時編程和麪向對象編程：

練習一：在終端輸出以下信息

  • 小明，10歲，男，上山去砍柴
  • 小明，10歲，男，開車去東北
  • 小明，10歲，男，最愛大保健
  • 老李，90歲，男，上山去砍柴
  • 老李，90歲，男，開車去東北
  • 老李，90歲，男，最愛大保健

　　函數式編程要先定義函數，而後在對函數進行調

def kanchai(name, age, gender):
    print("%s,%s歲,%s,上山去砍柴" %(name, age, gender))

def qudongbei(name, age, gender):
    print("%s,%s歲,%s,開車去東北" %(name, age, gender))

def dabaojian(name, age, gender):
    print("%s,%s歲,%s,最愛大保健" %(name, age, gender))

kanchai('小明', 10, '男')
qudongbei('小明', 10, '男')
dabaojian('小明', 10, '男')

kanchai('老李', 90, '男')
qudongbei('老李', 90, '男')
dabaojian('老李', 90, '男')
函數式編程

　　面向對象編程

 

class Foo:
    def __init__(self, name, age ,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def kanchai(self):
        print("%s,%s歲,%s,上山去砍柴" %(self.name, self.age, self.gender))

    def qudongbei(self):
        print("%s,%s歲,%s,開車去東北" %(self.name, self.age, self.gender))

    def dabaojian(self):
        print("%s,%s歲,%s,最愛大保健" %(self.name, self.age, self.gender))

xiaoming = Foo('小明', 10, '男')
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()

laoli = Foo('老李', 90, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()
面向對象編程

 上述對比能夠看出，若是使用函數式編程，須要在每次執行函數時要傳入相同的參數，若是參數多的話，又須要粘貼複製...；而對於面向對象只須要在建立對象時，將全部須要的參數封裝到當前對象中，以後再次使用時，經過self間接去當前對象中取值便可。

練習二：遊戲人生程序

一、建立三個遊戲人物，分別是：

  • 蒼井井，女，18，初始戰鬥力1000
  • 東尼木木，男，20，初始戰鬥力1800
  • 波多多，女，19，初始戰鬥力2500

二、遊戲場景，分別：

  • 草叢戰鬥，消耗200戰鬥力
  • 自我修煉，增加100戰鬥力
  • 多人遊戲，消耗500戰鬥力
# #####################  定義實現功能的類  #####################
class Person:
    def __init__(self, na, gen, age, fig):
        self.name = na
        self.gender = gen
        self.age = age
        self.fight =fig

    def grassland(self):
        """註釋：草叢戰鬥，消耗200戰鬥力"""
        self.fight = self.fight - 200

    def practice(self):
        """註釋：自我修煉，增加100戰鬥力""" 
        self.fight = self.fight + 200

    def incest(self):
        """註釋：多人遊戲，消耗500戰鬥力"""
        self.fight = self.fight - 500

    def detail(self):
        """註釋：當前對象的詳細狀況"""
        temp = "姓名:%s ; 性別:%s ; 年齡:%s ; 戰鬥力:%s"  % (self.name, self.gender, self.age, self.fight)
        print(temp)

        
# #####################  開始遊戲  #####################

cang = Person('蒼井井', '女', 18, 1000)    # 建立蒼井井角色
dong = Person('東尼木木', '男', 20, 1800)  # 建立東尼木木角色
bo = Person('波多多', '女', 19, 2500)      # 建立波多多角色

cang.incest() #蒼井空參加一次多人遊戲
dong.practice()#東尼木木自我修煉了一次
bo.grassland() #波多多參加一次草叢戰鬥


#輸出當前全部人的詳細狀況
cang.detail()
dong.detail()
bo.detail()


cang.incest() #蒼井空又參加一次多人遊戲
dong.incest() #東尼木木也參加了一個多人遊戲
bo.practice() #波多多自我修煉了一次

#輸出當前全部人的詳細狀況
cang.detail()
dong.detail()
bo.detail()

遊戲人生
遊戲人生

3、繼承

3.一、單繼承

繼承，面向對象中的繼承和現實生活中的繼承相同，即：子能夠繼承父的內容。

例如：

　　貓能夠：喵喵叫、吃、喝、拉、撒

　　狗能夠：汪汪叫、吃、喝、拉、撒

若是咱們要分別爲貓和狗建立一個類，那麼就須要爲 貓 和 狗 實現他們全部的功能，以下所示：

class Animals:
    def chi(self):
        print(self.name +"吃啥")

    def he(self):
        print(self.name + "喝啥")

    def piao(self):
        print(self.name + "如花")

class Uncle:
    def du(self):
        print(self.name + "賭")

    def piao(self):
        print(self.name + "如小花")

class Dog(Animals, Uncle):

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

    def jiao(self):
        print(self.name + "旺")

    def piao(self):
        print(self.name + "妹子")

sb = Dog("理解")
sb.chi()
sb.he()
sb.jiao()
sb.piao()
sb.du()
小例子 
class Animal:

    def eat(self):
        print "%s 吃 " %self.name

    def drink(self):
        print "%s 喝 " %self.name

    def shit(self):
        print "%s 拉 " %self.name

    def pee(self):
        print "%s 撒 " %self.name


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '貓'

    def cry(self):
        print '喵喵叫'

class Dog(Animal):
    
    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'
        
    def cry(self):
        print '汪汪叫'
        

# ######### 執行 #########

c1 = Cat('小白家的小黑貓')
c1.eat()

c2 = Cat('小黑的小白貓')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()
貓狗例子

注：對於面向對象的繼承來講，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而沒必要一一實現每個方法。
　　子類(派生類)，父類(基類)

class Animal:

    def eat(self):
        print "%s 吃 " %self.name

    def drink(self):
        print "%s 喝 " %self.name

    def shit(self):
        print "%s 拉 " %self.name

    def pee(self):
        print "%s 撒 " %self.name


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '貓'

    def cry(self):
        print '喵喵叫'

class Dog(Animal):
    
    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'
        
    def cry(self):
        print '汪汪叫'
        

# ######### 執行 #########

c1 = Cat('小白家的小黑貓')
c1.eat()

c2 = Cat('小黑的小白貓')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()
貓狗的繼承

3.二、多繼承　

　　在python中子類能夠有多個父類，java和c#中國子類只能有一個父類

　　在python中，類若是繼承了多個類，那麼其尋找方法就有兩種方式：深度優先、廣度優先

  • 當類是經典類時，多繼承狀況下，會按照深度優先方式查找
  • 當類是新式類時，多繼承狀況下，會按照廣度優先方式查找

經典類和新式類，從字面上能夠看出一個老一個新，新的必然包含了跟多的功能，也是以後推薦的寫法，從寫法上區分的話，若是 當前類或者父類繼承了object類，那麼該類即是新式類，不然即是經典類

class D:
    def bar(self):
        print 'D.bar'

class C(D):
    def bar(self):
        print 'C.bar'

class B(D):

    def bar(self):
        print 'B.bar'

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

a = A()
# 執行bar方法時
# 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯
# 因此，查找順序：A --> B --> D --> C
# 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了
a.bar()
經典類多繼承 
class D(object):
    def bar(self):
        print 'D.bar'

class C(D):
    def bar(self):
        print 'C.bar'

class B(D):
    def bar(self):
        print 'B.bar'

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

a = A()
# 執行bar方法時
# 首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯
# 因此，查找順序：A --> B --> C --> D
# 在上述查找bar方法的過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了
a.bar()
新式類繼承

經典類：首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去D類中找，若是D類中麼有，則繼續去C類中找，若是仍是未找到，則報錯

新式類：首先去A類中查找，若是A類中沒有，則繼續去B類中找，若是B類中麼有，則繼續去C類中找，若是C類中麼有，則繼續去D類中找，若是仍是未找到，則報錯

注意：在上述查找過程當中，一旦找到，則尋找過程當即中斷，便不會再繼續找了

4、多態

Pyhon不支持多態而且也用不到多態，多態的概念是應用於Java和C#這一類強類型語言中，而Python崇尚「鴨子類型」。

class F1:
    pass

class S1(F1):
    def show(self):
        print 'S1.show'

class S2(F1):
    def show(self):
        print 'S2.show'

# 因爲在Java或C#中定義函數參數時，必須指定參數的類型
# 爲了讓Func函數既能夠執行S1對象的show方法，又能夠執行S2對象的show方法，因此，定義了一個S1和S2類的父類
# 而實際傳入的參數是：S1對象和S2對象

def Func(F1 obj):
    """Func函數須要接收一個F1類型或者F1子類的類型"""
    print obj.show()
    
s1_obj = S1()
Func(s1_obj) # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show
java、c#中的多態 
class F1:
    pass

class S1(F1):
    def show(self):
        print 'S1.show'

class S2(F1):
    def show(self):
        print 'S2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj)
python中的鴨子類型

5、總結

對於面向對象初級知識的介紹

  • 面向對象是一種編程方式，此編程方式的實現是基於對 類 和 對象 的使用
  • 類 是一個模板，模板中包裝了多個「函數」供使用
  • 對象，根據模板建立的實例（即：對象），實例用於調用被包裝在類中的函數
  • 面向對象三大特性：封裝、繼承和多態

武sir的經典總結：

問題一：什麼樣的代碼纔是面向對象？
答：從簡單來講，若是程序中的全部功能都是用 類 和 對象 來實現，那麼就是面向對象編程了。

問題二：函數式編程 和 面向對象 如何選擇？分別在什麼狀況下使用？
答：須知：對於 C# 和 Java 程序員來講不存在這個問題，由於該兩門語言只支持面向對象編程（不支持函數式編程）。
而對於 Python 和 PHP 等語言卻同時支持兩種編程方式，且函數式編程能完成的操做，面向對象均可以實現；
而面向對象的能完成的操做，函數式編程不行（函數式編程沒法實現面向對象的封裝功能）。

因此，通常在Python開發中，所有使用面向對象 或 面向對象和函數式混合使用

面向對象的應用場景：

　　一、多函數須要使用共同的值，如數據庫的增、刪、改、查操做都須要鏈接數據庫字符串、主機名、用戶名和密碼

class SqlHelper:

    def __init__(self, host, user, pwd):

        self.host = host
        self.user = user
        self.pwd = pwd

    def 增(self):
        # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
        # do something
        # 關閉數據庫鏈接

    def 刪(self):
        # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
        # do something
        # 關閉數據庫鏈接

    def 改(self):
        # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
        # do something
        # 關閉數據庫鏈接

    def 查(self):
    # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
        # do something
        # 關閉數據庫鏈接# do something
View Code

　　二、須要建立多個事物，每一個事物屬性個數相同，可是值的需求不一樣

　　如：張3、李4、王五；他們都有姓名、年齡、血型

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

    def detail(self):
        temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
        print temp

zhangsan = Person('張三', 18, 'A')
lisi = Person('李四', 73, 'AB')
yangwu = Person('楊五', 84, 'A')
View Code

　　三、類和對象在內存中保存的方式

類以及類中的方法在內存中只有一份，而根據類建立的每個對象都在內存中須要存一份

如上圖所示，根據類建立對象時，對象中除了封裝 name 和 age 的值以外，還會保存一個類對象指針，該值指向當前對象的類。

當經過 obj1 執行 【方法一】 時，過程以下：

  1. 根據當前對象中的 類對象指針 找到類中的方法
  2. 將對象 obj1 看成參數傳給 方法的第一個參數 self 
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程