01 面向對象之：初識。

一. 面向對象初識

1.1 回顧面向過程編程vs函數式編程

# 面向過程編程 測量對象的元素個個數。
s1 = 'fjdsklafsjda'
count = 0
for i in s1:
    count += 1


l1 = [1,2,3,4]
count = 0
for i in l1:
    count += 1

def func(s):
    count = 0
    for i in s:
        count += 1
    return count
func('fdsafdsa')
func([1,2,3,4])

通過對比可知：函數編程較之面向過程編程最明顯的兩個特點：

1，減少代碼的重用性。

2，增強代碼的可讀性。

1.2 函數式編程vs面向對象編程

# 函數式編程

# auth 認證相關
def login():
    pass

def regisgter():
    pass

# account 賬戶相關
def func1():
    pass

def func2():
    pass


# 購物車相關
def shopping(username,money):
    pass
def check_paidgoods(username,money):
    pass
def check_unpaidgoods(username,money):
    pass
def save(username,money):
    pass

class LoginHandler:
    def login(self):
        pass

    def regisgter(self):
        pass

class Account:
    def func1(self):
        pass

    def func2(self):
        pass

class ShoppingCar:
    def shopping(username,money):
        pass
    def check_paidgoods(username,money):
        pass
    def check_unpaidgoods(username,money):
        pass
    def save(username,money):
        pass

# 通過對比可以看出面向對象第一個優點：

面向對象編程：是一類相似功能函數的集合,使你的代碼更清晰化，更合理化。

說第二個優點之前，先看看什么是面向對象。

面向對象的程序設計的核心是對象（上帝式思維），要理解對象為何物，必須把自己當成上帝，上帝眼里世間存在的萬物皆為對象，不存在的也可以創造出來。

那什么是類？什么是對象？

類：就是具有相同屬性和功能的一類事物。

對象：就是類的具體表現。

具體一些：先解釋解釋什么是⻋? 有軲轆, 有⽅向盤, 有發動機, 會跑的是⻋. 好. 在解釋⼀個. 什么是⼈. 有名字, 年齡, 愛好, 會唱歌跳舞思考的是⼈.那么廣義上 車，人就是類：但是具體的我的車，你這個人這是一個對象。

貓，是一類，你們家養的 大橘。

狗，是一類，隔壁家養的那只二哈就是對象。

⾯向對象思維, 要⾃⼰建立對象. ⾃⼰建立場景. 你是就是⾯向對象世界中的上帝. 你想讓⻋⼲嘛就⼲嘛. 你想讓⼈⼲嘛⼈就能⼲嘛。

再說第二個優點：面向對象，要擁有上帝的視角看問題，類其實就是一個公共模板（廠房），對象就從具體的模板實例化出來（慢慢體會）。

1.3類的結構

class Human:
    """
    此類主要是構建人類
    """
    mind = '有思想'  # 第一部分：靜態屬性 屬性 靜態變量 靜態字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函數 動態屬性
        print('人類會工作')
class 是關鍵字與def用法相同，定義一個類。
Human是此類的類名，類名使用駝峰(CamelCase)命名風格，首字母大寫，私有類可用一個下划線開頭。
類的結構從大方向來說就分為兩部分：
靜態變量。
動態方法。

二. 從類名的角度研究類

2.1 類名操作靜態屬性

 　　2.11 第一種，查看類中的所有內容：類名.__dict__方式。

class Human:
    """
    此類主要是構建人類
    """
    mind = '有思想'  # 第一部分：靜態屬性 屬性 靜態變量 靜態字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函數 動態屬性
        # print(self)
        print('人類會工作')

print(Human.__dict__)
print(Human.__dict__['mind'])
Human.__dict__['mind'] = '無腦'
print(Human.__dict__)  # 錯誤
#通過這種方式只能查詢，不能增刪改.

# 第一種方式只用戶查詢全部內容（一般不用單獨屬性查詢）.

　　2.12 第二種：萬能的點.  

class Human:
    """
    此類主要是構建人類
    """
    mind = '有思想'  # 第一部分：靜態屬性 屬性 靜態變量 靜態字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函數 動態屬性
        # print(self)
        print('人類會工作')
print(Human.mind)  # 查
Human.mind = '無腦'  # 改
print(Human.mind)
del Human.mind  # 刪
Human.walk = '直立行走'
print(Human.walk)
# 通過萬能的點 可以增刪改查類中的單個屬性

　　對以上兩種做一個總結：如果想查詢類中的所有內容，通過 第一種__dict__方法，如果只是操作單個屬性則用萬能的點的方式。

2.2 類名操作動態方法

　　前提：除了兩個特殊方法：靜態方法，類方法之外，一般不會通過類名操作一個類中的方法。

class Human:
    """
    此類主要是構建人類
    """
    mind = '有思想'  # 第一部分：靜態屬性 屬性 靜態變量 靜態字段
    dic = {}
    l1 = []
    def work(self): # 第二部分：方法 函數 動態屬性
        # print(self)
        print('人類會工作')
    def tools(self):
        print('人類會使用工具')

Human.work(111)
Human.tools(111)
下面可以做，但不用。
Human.__dict__['work'](111)

三. 從對象的角度研究類

3.1 什么是對象

對象是從類中出來的，只要是類名加上（），這就是一個實例化過程，這個就會實例化一個對象。

執行下列代碼會發生什么事情？

class Human:
    mind = '有思想'
    def __init__(self):
        print(666)
        print(self)  # <__main__.Human object at 0x00000191508AA828>

    def work(self): 
        print('人類會工作')

    def tools(self):
        print('人類會使用工具')
obj = Human() # 只要實例化對象，它會自動執行__init__方法
print(obj)  # <__main__.Human object at 0x00000191508AA828>
# 並且obj的地址與self的地址相同

其實實例化一個對象總共發生了三件事：

　　1，在內存中開辟了一個對象空間。

　　2，自動執行類中的__init__方法，並將這個對象空間（內存地址）傳給了__init__方法的第一個位置參數self。

　　3，在__init__ 方法中通過self給對象空間添加屬性。

示例：

class Human:
    mind = '有思想'
    language = '使用語言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一個內存地址同一個空間，下面就是通過self給這個對象空間封裝四個屬性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'運動')

3.2 對象操作對象空間屬性

　　3.21 對象查詢對象中所有屬性。 對象.__dict__

class Human:

    mind = '有思想'
    language = '實用語言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一個內存地址同一個空間，下面就是通過self給這個對象空間封裝四個屬性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'運動')
print(obj.__dict__)  # {'n': 'barry', 'h': '運動', 's': '男', 'a': 18}

　　3.22 對象操作對象中的單個屬性。 萬能的點 .

class Human:

    mind = '有思想'
    language = '實用語言'
    def __init__(self,name,sex,age,hobby):
        # self 和 obj 指向的是同一個內存地址同一個空間，下面就是通過self給這個對象空間封裝四個屬性。
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'運動')
obj.job = 'IT'  # 增
del obj.n  # 刪
obj.s = '女' # 改
print(obj.s)  # 查
print(obj.__dict__)

3.3 對象查看類中的屬性

class Human:

    mind = '有思想'
    language = '實用語言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

obj = Human('barry','男',18,'運動')
print(obj.mind)
print(obj.language)
obj.a = 666
print(obj.a)

3.4 對象操作類中的方法

class Human:

    mind = '有思想'
    language = '實用語言'
    def __init__(self,name,sex,age,hobby):
        self.n = name
        self.s = sex
        self.a = age
        self.h = hobby

    def work(self):
        print(self)
        print('人類會工作')

    def tools(self):
        print('人類會使用工具')

obj = Human('barry','男',18,'運動')
obj.work()
obj.tools()

　　類中的方法一般都是通過對象執行的（出去類方法，靜態方法外），並且對象執行這些方法都會自動將對象空間傳給方法中的第一個參數self.

self 是什么？

self其實就是類中方法（函數）的第一個位置參數，只不過解釋器會自動將調用這個函數的對象傳給self。所以咱們把類中的方法的第一個參數約定俗成設置成self, 代表這個就是對象。

一個類可以實例化多個對象

obj1= Human('小胖','男',20,'美女')
obj2= Human('相爺','男',18,'肥女')
print(obj1,obj2)
print(obj1.__dict__)
print(obj2.__dict__)