面向對象編程

面向對象

''''
一、面向過程編程
核心是"過程"二字，過程指的是解決問題的步驟，即先幹什麼再幹什麼
基於該思想編寫程序就比如在編寫一條流水線，是一種機械式的思惟方式

優勢：複雜的問題流程化、進而簡單化
缺點：可擴展性差

二、面向對象
核心"對象"二字，對象指的是特徵與技能的結合體，
基於該思想編寫程序就比如在創造一個世界，你就是這個世界的上帝，是一種
上帝式的思惟方式

優勢：可擴展性強
缺點：編程的複雜度高於面向過程

重點：面向對象的核心體現是將數據和處理數據的程序封裝到對象中
'''

# 函數與方法：都是解決問題的功能
# 函數：經過函數名直接調用
# 方法：經過附屬者.語法來調用

# 變量：經過變量名訪問變量值
# 屬性：經過附屬者.語法來訪問變量值

名稱空間操做

# 全部能產生名稱空間對應的對象(存放地址的變量)有__dict__值

# __dict__指向的就是附屬對象的名稱空間
import re
print(re.__dict__)

re.__dict__['name'] = 're模塊'
print(re.__dict__['name'])

re.__dict__['action'] = lambda x: x
print(re.__dict__['action'](1000))


def fn():
pass
print(fn.__dict__)

fn.name = 'fn函數'
print(fn.name)

def test():
print("能夠成爲fn功能的函數")
fn.action = test
fn.action()

類與對象的概念

# 類：具備相同特徵與行爲個體集合的抽象
# 對象：有特徵、行爲的具體個體。就是類的具體體現

# 區別：兩我的同時思考一個名字，想到的必定是同一個物體，就必定是對象，反之必定是類

語法

# 類的聲明：
'''
class 類名:  # class定義類語法的關鍵字
pass
'''

# 對象的產生: 對象的實例化
'''
對象1 = 類名()
對象2 = 類名()
對象3 = 類名()
'''

# 類與對象都有本身獨立的名稱空間，每個被實例化出來的對象，名稱空間也是各自獨立
# 因此類與對象都能額外添加 屬性(變量) 和 方法(函數)

# 重點：類一旦被加載(隨着所屬文件的加載就加載)，就會進入類的內部執行類中的全部代碼

對象查找屬性的順序

class People:
# 類自帶(不一樣在外界額外添加)的屬性與方法
identify = '人類'
def sleep(self):
  print('睡覺')


p1 = People()
p2 = People()

p1.identify = '新人類'
print(p1.identify)  # 訪問本身的
p1.__dict__.clear()  # 刪除本身的後
print(p1.identify)  # 訪問類的

print(p2.identify)  # p2沒有本身的，訪問類的

# 重點：屬性的訪問順序：優先加載自身的名字，若是沒有再考慮類的

總結

'''
1.面向過程與面向對象
   過程：程序流程化，可拓展性差
   對象：程序流程多樣化，可拓展性強

   變量 | 函數 => 屬性 | 方法：前者直接使用，經過所屬者.語法調用

2.擁有名稱空間的對象：有__dict__屬性，該屬性就是指向對象的名稱空間
   -- 文件 | 包(__init__.py文件) | 函數 | 類
   -- 能夠爲__dict__屬性添加值，簡化爲.語法，也能夠對__dict__總體賦值一個字典

3.類與對象
   -- 類是抽象的，不是真實存在：具備相同特徵(屬性)和行爲(方法)個體的集合的抽象
   -- 對象具象的，是真實存在的：具備特徵與行爲的實際個體(類的實際體現：實例化)

4.類與對象的語法
class 類名:
   代碼塊(一堆屬性與方法)
對象名 = 類名()

類會隨所屬文件加載而加載(執行內部全部代碼)，造成類的名稱空間

1.每一個實例化出來的對象及類都有本身的名稱空間
2.類與對象均可以經過.語法來拓展新功能
3.提早在類中屬性的屬性與方法，在對象一產生就可使用這些屬性和方法
4.對象查找屬性的順序：先找自身的，若是沒有找類的(只有訪問權沒有修改權)
'''