Day15

一、 編程思想

1、 面向過程編程

遇到問題直接將邏輯轉(zhuǎn)換成代碼；邏輯思維，算法

2、 函數(shù)式編程

遇到問題就想找一個或?qū)懸粋€擁有相應(yīng)功能的函數(shù)；以函數(shù)作用工具

3、 面向?qū)ο缶幊?/h4>

遇到問題就考慮可以不可以有一個類來給我提供相應(yīng)的功能和數(shù)據(jù)；以類和對象為工具

python既支持函數(shù)式編程也支持面向?qū)ο缶幊?/p>

二、認識類和對象

1、 什么是類，什么是對象

類就是擁有相同功能和相同屬性的對象的集合；類是抽象的
對象就是類的實例；對象是具體的

2、 類的聲明

類中的內(nèi)容包含功能（函數(shù)）和屬性（變量/屬性）

a. 語法

class 類名（父類）:
類的內(nèi)容

b. 說明

class - python聲明類的關(guān)鍵字
類名 - 要求：標識符，不能是關(guān)鍵字
規(guī)范：駝峰式命名（通過首字母大寫來區(qū)分不同的單詞）
: - 固定寫法
類的內(nèi)容 - 包含類的方法、屬性和說明文檔
方法就是聲明在類中的函數(shù)
屬性就是聲明在類中的變量

3、 對象的聲明

語法：
類名() - 創(chuàng)建指定的類的對象并且返回

class Person:
    """類的說明文檔：人類"""
    num = 61 # 類中的屬性

    # 類中的方法
    def eat(self):
        print('吃飯')

def main():
    # 創(chuàng)建Person類的對象；p1就是對象
    p1 = Person()
    print(p1)
    p2 =Person()
    print(p2)
    p3 = p2
    print(p3)

if __name__ == '__main__':
    main()

三、 對象方法

class 類名:
類中的屬性
類中的方法

1、 類中的方法

聲明在類中的函數(shù)就是方法
類中的方法包括：對象方法（實例方法），類方法，靜態(tài)方法

a. 對象方法

直接聲明在類中的方法就是對象方法
有默認參數(shù)self
通過 ‘對象.’的方式來調(diào)用（對象方法要通過對象來調(diào)用）
當我們通過對象調(diào)用對象方法的時候，self不需要傳參；因為系統(tǒng)會自動將當前對象傳遞給self
當前對象：調(diào)用當前方法的對象（誰調(diào)用對象方法self就是誰）
注意：當前類的對象能做的事情，self都可以做

class Person:
    def run(self):
        print('人在跑步')
    def eat(self,food):
        print(food)
p1 = Person()
print(p1.run())
p1.eat('包子')

2、 init方法：init

init方法是類中的一個特殊對象方法，專門用來對象創(chuàng)建的對象進行初始化。
當通過類創(chuàng)建對象的時候，系統(tǒng)就會自動調(diào)用init方法

3、 構(gòu)造方法

函數(shù)名和類名一樣的函數(shù)就是構(gòu)造方法，專門用來創(chuàng)建對象
python中聲明類的時候系統(tǒng)會自動創(chuàng)建這個類對應(yīng)的構(gòu)造方法
當我們構(gòu)造方法的時候，內(nèi)部現(xiàn)在內(nèi)存中開辟空間保存對象，然后用創(chuàng)建的這個對象去調(diào)用init方法，用來對對象初始化
init方法調(diào)用結(jié)束，返回對象。
def Person():
對象 = 創(chuàng)建對象
對象.init():
return 對象

class Person:
    # 類中以“__”開頭結(jié)尾的方法叫魔法方法。不需要主動調(diào)用，系統(tǒng)會自動調(diào)用
    def __init__(self):
        print('init被調(diào)用了')

p1 = Person()

四、對象屬性

1、 什么是對象屬性

類中的屬性分為累的字段和對象屬性

a. 對象屬性

屬性的值會因為對象不同而不一樣，這種屬性就應(yīng)該聲明為對象屬性
聲明在init方法中 - 位置
以'self.屬性 = 值'的方式來聲明（這兒的屬性就是對象屬性） - 方式
通過'對象.屬性'的方式來使用 - 使用
b. 類的字段 - 屬性的值不會因為對象不同而不同，這種屬性就聲明成類的字段
直接聲明在類的里面，函數(shù)外面的變量就是類的字段
以'字段名=值'
通過'類.字段'的方式來使用

class Person():
    def __init__(self, name='年齡', age=0):
        self.name = name
        self.age = age


p1 = Person('張三', 18)
# 獲取對象屬性的值
print(p1.name, p1.age)

 練習：創(chuàng)建Dog類，有屬性名字、類型、年齡
要求創(chuàng)建Dog的對象的時候不能給年齡賦值，可以給類型賦值也可以不用給類型賦值，必須給名字賦值
# 對象方法eat：打印xxx在吃什么
class Dog():
    def __init__(self, name, type1='金毛'):
        self.name = name
        self.type = type1
        self.age = 10

    def eat(self):
        print(self.name + '吃')


print(Dog('wg').eat())

練習：聲明矩形類，擁有屬性長和款，擁有方法求面積和求周長
class retangle:
    def __init__(self, chang=0, kuan=0):
        self.chang = chang
        self.kuan = kuan

    def s(self):
        s = self.chang * self.kuan
        return '長%.3f，寬%.3f的面積是%.3f' % (self.chang, self.kuan, s)

    def c(self):
        c = (self.chang + self.kuan) * 2
        return '長%.3f，寬%.3f的周長是%.3f' % (self.chang, self.kuan, c)


r = retangle(10,20)
print(r.s()+'\n'+r.c())
# 使用類的字段
r.kuan = 100
r.chang = 200

五、 對象屬性的增刪查改

python中對象的屬性支持增刪改查

1、 查（獲取對象屬性）

class Person:
    def __init__(self, name='', age=0, sex=''):
        self.name = name
        self.age = age
        self.sex = sex

class Dog:
    # 約束當前類的對象最多能擁有的哪些屬性
    #__slots__ = ('name', 'color')
    def __init__(self,name='',color='黑色'):
        self.name = name
        self.color = color

def main():
    dog1 = Dog('WG', '黃色‘')

    p1 = Person('小花')
    p2 = Person('wg')

查（獲取對象屬性）

對象.屬性 - 獲取指定對象指定屬性值
getattr(對象,屬性名:str,默認值) - 獲取對象指定屬性值
                                  當默認值賦了值且屬性不存在的時候，程序不會報錯，并且將默認值作為結(jié)果 

    print(p1.name)
    print(getattr(p1,'name'))
    print(getattr(p1,'name1',None))

增/改
對象.屬性 = 值 - 當屬性存在的時候是修改屬性的值，不存在就增加屬性和值

    # 修改屬性
    p1.name ='xoiaohua'
    print(p1.name)
    # 添加屬性
    p1.height = 180
    print(p1.height)
    setattr(p1,'age',19)
    print(p1.age)
    setattr(p1,'weight',200)
    print(p1.weight)

刪

    del 對象.屬性
    delattr(對象,屬性名)
    """
    print('=================')
    del p1.sex
    delattr(p1,'age')

    # 注意：對象屬性的操作，只針對操作的那一個對象
    print(p1.height)




if __name__ == '__main__':
    main()

五、 內(nèi)置方法

內(nèi)置屬性指的是我們創(chuàng)建類的時候，系統(tǒng)自動給我們添加的屬性（其實是通過繼承獲取到的）

class Person:
    # 類的字段
    num = 61
   # __slots__ = ('name', 'age', 'sex')

    # 對象屬性
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self, food):
        print('')

定制對象的打印格式（當我們通過打印print打印一個對象的時候，實質(zhì)就是打印對象調(diào)用一個reor函數(shù)的返回值）
這個函數(shù)的返回值必須是字符串

    def __repr__(self):
        #return '<%s.%s object at %s>' % (self.__class__.__module__, self.__class__.__name__, hex((id(self))))
        return '<' + str(self.__dict__)[1:-1] + 'at' + hex(id(self)) + '>'

def main():
    # 1. __name__
    """
    獲取類名:
    """
    p1 = Person()
    persons = []
    print(Person.__name__)
    # 2 類.__class__ - 獲取對象對應(yīng)的類（結(jié)果是類）
    print(Person.__class__)
    # 3.類.__doc__ - 獲取說明文檔
    print(Person.__doc__)
    # 4. 對象.__dict__  -  將對象轉(zhuǎn)換成字典，將屬性和值作為字典的鍵值對
    print(p1.__dict__)
    # 5. 類.__module__             -      獲取當前類所在的模塊的模塊名
    print(Person.__module__)
    # 6. 類.__bases__              -      獲取當前類的父類（元組）
    print(Person.__bases__)
    print(p1)


if __name__ == '__main__':
    main()

六、 類方法和內(nèi)置方法

1、對象方法：

a. 聲明：直接聲明在類里

b. 特點：自帶self參數(shù)，調(diào)用的時候不用傳參，誰調(diào)用指向誰

c. 調(diào)用：對象.方法（）

2、類方法：

a. 聲明：聲明函數(shù)前加@classmethod

b. 特點：自帶默認參數(shù)cls；調(diào)用的而不用傳參，系統(tǒng)自動調(diào)用當前函數(shù)的類傳給它

     （cls是誰調(diào)用就指向誰）

c. 調(diào)用： 通過類來調(diào)用，類.方法()

3、 靜態(tài)方法

a. 聲明：聲明函數(shù)前加@staticmethod

b. 特點：沒有默認參數(shù)

c. 調(diào)用：通過類來調(diào)用，類.方法()

4、 在類中怎么選擇的使用哪種方法

如果實現(xiàn)類中的函數(shù)的功能需要使用對象的屬性，那么這個函數(shù)就要聲明對象方法。
實現(xiàn)函數(shù)的功能不需要對象屬性的前提下，如果需要類的字段，就聲明成類方法。
實現(xiàn)函數(shù)的功能既不需要對象屬性也不需要類的字段就聲明成靜態(tài)方法。

class Person:
    num = 60

    @classmethod
    def func1(cls):
        # 類能做的，cls都能做
        p1 = cls()  # 用cls來創(chuàng)建對象
        print(p1)
        print('這是一個類方法')
        cls.num = 100  # 用cls來使用類的字段
        cls.func2()  # 用cls來調(diào)用方法
        print(cls.num)

    @staticmethod
    def func2():
        print('我是靜態(tài)方法')


def main():
    Person.func1()


if __name__ == '__main__':
    main()