01-recode

1.類聲明
class 類名
——說明文檔
——類的內(nèi)容
2.怎么聲明對象
對象 = 類名
3._ init _函數(shù)
a.自動(dòng)調(diào)用（當(dāng)創(chuàng)建對象的時(shí)候）
b.通過構(gòu)造方法給init方法傳參
c.想要聲明對象的屬性，必須要有init方法
4.對象的屬性
a.不同的對象對應(yīng)的值可能不一樣
b.聲明在init方法中
c.self.屬性名 = 初值
d.通過對象使用
5.對象屬性的增刪改查（查，改）
6.對象方法
a.直接聲明在類中篡悟，并且?guī)б粋€(gè)默認(rèn)的參數(shù)self
b.調(diào)用對象方法不需要給self傳參，系統(tǒng)會(huì)自動(dòng)把當(dāng)前對象傳給它交煞，誰調(diào)用這個(gè)方法，self就指向誰
c.對象方法中的self可以當(dāng)成當(dāng)前類的對象使用
7.類的字段
a.聲明在類中的變量
b.通過類去使用：類.字段
8.類方法
a.@class method來說明可岂，自帶一個(gè)cls參數(shù)
b.cls參數(shù)調(diào)用的時(shí)候不需要傳參，誰調(diào)用這個(gè)方法就指向誰翰灾，永遠(yuǎn)指向當(dāng)前類
c.通過類調(diào)用
9.a.@statimethod來說明缕粹，沒有默認(rèn)參數(shù)
b.通過類調(diào)用

02-內(nèi)置類屬性

內(nèi)置類屬性就是魔法屬性
魔法屬性：屬性名的前面和后面都有兩個(gè)下劃線
魔法方法：方法的前后都有兩個(gè)下劃線

import datetime
class Person:
    '''人的類'''
    # 類的字段
    number = 61
    def __init__(self,name1,age1,height1):
        # 對象的屬性
        self.name = name1
        self.age = age1
        self.height =height1

    def run(self):
        print('%s在跑步'% (self.name))

    #類方法
    @classmethod
    def show_number(cls):
        print('人類的數(shù)量為：%d億'% (cls.number))

    # 靜態(tài)方法
    @staticmethod
    def destroy():
        print('人類在破壞環(huán)境!')

if __name__ == '__main__':
    p1 = Person('張三豐',20,173)

1.name屬性 --- 類的名字（是字符串）

    # 類的屬性
    name = Person.__name__
    print(name,type(name))

2.class屬性 --- 獲取對象對應(yīng)類（是一個(gè)類）

    # 對象的屬性
    # my_classs是一個(gè)類，之前類能做的事情他都能做
    my_class = p1.__class__
    p2 = my_class('小明',20,100)
    print(p2.name)

3.dict屬性 --- 將對象和類的屬性及其對應(yīng)的值轉(zhuǎn)換成鍵值對存到一個(gè)字典中

    # print(Person.__class__)
    print(p1.__dict__)     #  {'name': '張三豐', 'age': 20, 'height': 173}

4.doc屬性----獲取類的說明文檔

    # 類的屬性
    doc = Person.__doc__
    print(doc)

5.module屬性 ---- 獲取所有模塊對應(yīng)的名字

    print(Person.__module__)
    print(datetime.datetime.__module__)

6.bases屬性 ---獲取當(dāng)前類的父類

    # 類的屬性
    print(Person.__bases__)

03-slots魔法

class Person:
    '''人的類'''
    # 通過__slots__中存的元素的屬性的值來約束當(dāng)前這個(gè)類的對象的屬性纸淮，對象的屬性只能比元組中的少平斩，不能多
    __slots__ = ('name','age','face')
    def __init__(self):
        # 對象的屬性
        self.name = '張三豐'
        self.age = 20
        self.face = 80
        # self.sex = 'boy'     # __slots__中并沒有sex

if __name__ == '__main__':
    p1 = Person()
    # p1.sex = 'girl'
    # print(p1.sex)

    # p1.name = '小明'
    print(p1.name)

    # 注意：一旦在類中給__slots__屬性賦了值，那么這個(gè)類的對象的__dict__屬性就不能使用了
    # print(p1.__dict__)

04-私有化

python中并沒有真正的私有化
1.私有化的語法
a.類中的屬性和方法都可以通過在屬性名和方法名前加兩個(gè)下劃線咽块，來讓屬性和方法變成私有的
b.私有的屬性和方法只能在當(dāng)前的類中使用
2.私有化的原理
在前面有兩個(gè)下劃線的屬性名和方法名前添加了'_類名'來阻止外部直接訪問屬性名來使用屬性

class Dog:
    # 字段
    number = 100
    __count = 200

    def __init__(self):
        # 對象的屬性
        self.color = '黃色'
        self.age = 3
        self.name = '大黃'
        self.__sex = '公狗'

    # 對象方法
    def __eat(self):
        print('%s啃骨頭'% (self.name))

    def eat(self):
        # 在類中可以使用私有的屬性
        self.__eat()
        print('%s在吃屎·' % (self.name))

    # 類方法
    @classmethod
    def shout(cls):
        print('count',cls.__count)
        print('汪汪汪~~~')

    # 靜態(tài)方法
    @staticmethod
    def function():
        print('看家!!')

 # python的類中默認(rèn)的屬性和方法是公開的
dog1 = Dog()
print(Dog.number)
print(dog1.name,dog1.color,dog1.age)
dog1.eat()
Dog.shout()
Dog.function()

# 在類的外面不能使用私有屬性
# print(Dog.__count)                AttributeError: type object 'Dog' has no attribute '__count'
# print(dog1.__sex)               AttributeError: 'Dog' object has no attribute '__sex'
dog1.eat()
print(dog1.__dict__)

05-屬性的getter和setter

1.解釋
a.保護(hù)類型的屬性：就是在聲明對象屬性的時(shí)候在屬性名前加一個(gè)下劃線來代表這個(gè)屬性是受保護(hù)的屬性绘面，
那么以后訪問這個(gè)屬性的時(shí)候就不要直接訪問，要通過getter來獲取這個(gè)屬性的值侈沪，通過setter來給這個(gè)屬性賦值
b.如果一個(gè)屬性已經(jīng)聲明成保護(hù)類型的屬性揭璃，那么我們就要給這個(gè)屬性添加getter，也可以添加setter
2.添加getter
添加getter就是聲明一個(gè)沒有參數(shù)亭罪，有一個(gè)返回值的函數(shù)
a.格式：
@property
def 去掉下劃線的屬性名（self）：
——函數(shù)體
——將屬性相關(guān)的值返回
b.使用場景
場景一：如果想要獲取對象的某個(gè)屬性的值之前瘦馍，想要做其他處理，就可以給這個(gè)屬性添加getter
場景二：想要拿到某個(gè)屬性被使用的時(shí)刻
3.添加setter
添加setter就是聲明一個(gè)有一個(gè)參數(shù)应役，但是沒有返回值的參數(shù)情组，作用是給屬性賦值
a.格式
b.使用場景
在給屬性賦值前要進(jìn)行其他操作，就給屬性聲明一個(gè)setter函數(shù)

class Car:

    def __init__(self):
        self.color = '黃色'
        self.type = '自行車'
        # price是保護(hù)類型
        self._price = 2000

    # 給_price屬性添加getter
    @property
    def price(self):
        print('在使用_price屬性')
        return self._price/1000

    # 想要給一個(gè)屬性添加setter箩祥，就必須先給這個(gè)屬性添加getter
    @price.setter
    def price(self,price):
        if isinstance(price,int) or isinstance(price,float):
            self.price
        else:
            self._price = 0

練習(xí)：聲明一個(gè)員工類院崇，其中一個(gè)屬性是否已婚（bool），獲取值之前根據(jù)存的值返回"已婚"/"未婚"

class Staff:
    '''員工類'''
    def __init__(self,name,age):
        self.name =name
        self.age = age
        self._is_marry = False

    @property
    def is_marry(self):
        print('在使用_price屬性')
        if self._is_marry:
            return '已婚'
        return '未婚'

    @is_marry.setter
    def is_marry(self, marry):
        self._is_marry = marry

if __name__ == '__main__':

    car1 = Car()
    print(car1.color,car1._price)
    # 添加完getter后就通過getter去獲取屬性值袍祖，實(shí)質(zhì)就是調(diào)用getter對應(yīng)方法
    # price就是屬性_price的getter
    print(car1.price,'k')

    # 通過setter給屬性賦值,實(shí)質(zhì)是調(diào)用setter對應(yīng)的方法
    car1.price= 'abc'
    print(car1.price)

    s1 = Staff('張三', 20)
    print(s1.is_marry)

    s1.is_marry = True
    print(s1.is_marry)

06-繼承

python中類可以繼承底瓣，并且支持多繼承
程序中的繼承：就是讓子類字節(jié)擁有父類的屬性和方法（繼承父類中的內(nèi)容不會(huì)因?yàn)楸焕^承而減少）

1.繼承的語法
class 子類（父類）：
類的內(nèi)容
注意：如果聲明類的時(shí)候沒有寫繼承，那么這個(gè)類會(huì)自動(dòng)繼承python中的基類蕉陋，object;相當(dāng)于class 類名（object）：
python中所有的類都是直接和間接的繼承自object
2.能繼承那些東西
a.所有的屬性和方法都能繼承
b.slots的值不會(huì)繼承濒持，但是會(huì)影響子類對象的dict屬性键耕，不能獲取父類繼承下來的屬性

class Person:
    '''人類'''
    # 字段
    number = 61

    # __slots__ = ('name','age')
    # 對象屬性
    def __init__(self,name='張三',age=18):
        self.name = name
        self.age = age
        self._height = 173

    # 對象方法
    def show_message(self):
        print('姓名：%s 年齡：%d'% (self.name,self.age))

    @classmethod
    def show_number(cls):
        print('人類的數(shù)量：%d億'% cls.number)

    @staticmethod
    def show_message():
        print('人類毆打小動(dòng)物!')

class Student(Person):
    '''學(xué)生類'''
    pass

#創(chuàng)建Person類的對象
p = Person()

# 學(xué)生類
stu1 = Student()
print(Student.number)
print(stu1.name)
stu1.show_number()
stu1.show_message()
print(stu1.__dict__)

if __name__ == '__main__':
    pass

07-方法的重寫

子類繼承父類，擁有父類的屬性和方法以后柑营，還可以添加自己的屬性和方法
1.添加方法和類的字段
直接在子類中聲明相應(yīng)的字段和方法
2.添加對象屬性
對象的屬性是通過繼承父類的init方法而繼承下來
如果想要保留父類的對象的同時(shí)添加自己的對象屬性屈雄，需要在子類的init方法中通過super（）去調(diào)用父類的init方法
3.方法的重寫
在子類中重新實(shí)現(xiàn)父類的方法，就是重寫
方式一：直接覆蓋父類的實(shí)現(xiàn)
方式二：保留父類的功能再添加其他功能
4.類中方法的調(diào)用過程
先在當(dāng)前這個(gè)中的去找官套，沒有找到就去父類中找酒奶，還是沒找到就去，就去父類的父類中去找奶赔，以此類推惋嚎，如果在基類中也沒找到，才崩潰
在第一次找到的位置站刑，去調(diào)用
注意：使用super的時(shí)候必須通過super（）來代替父類或者是父類的對象

class Animal:
    '''動(dòng)物'''
    def __init__(self):
        self.age = 0
        self.sex = '雌'

    def shout(self):
        print('嗷嗷叫')

class Cat(Animal):
    '''貓'''
    def __init__(self):
        # 調(diào)用父類的init方法
        super().__init__()
        self.name = '小花'
    food = '魚'

    def shout(self):
        print('喵喵喵~~~')

class Dog(Animal):
    '''狗'''
    def shout(self):
        # 通過super（）調(diào)用父類的方法另伍，保留父類功能
        super().shout()
        print('汪汪汪~~~')

cat1 = Cat()
print(cat1.name,cat1.age,cat1.sex)
cat1.shout()
dog1 = Dog()
dog1.shout()

08-init方法的重寫

練習(xí)：寫一個(gè)人類，擁有屬性name,age,sex绞旅。要求創(chuàng)建Person對象的時(shí)候必須給name和age賦值摆尝，sex可賦可不賦，再寫一個(gè)Staff類繼承自Person類因悲，要求保留Person中所有的屬性堕汞，并且添加新的屬性salary，要求創(chuàng)建Staff類的對象的時(shí)候晃琳，只能給name賦值（必須賦）

class Person:
    '''人類'''
    def __init__(self,name,age,sex='boy'):
        self.name = name
        self.age =age
        self.sex = sex

class Staff(Person):
    def __init__(self,name):
        super().__init__(name,20)
        self.salary = '10000'

if __name__ == '__main__':
    p1 = Person('張三',20)
    s1 = Staff('李四')

09-運(yùn)算符的重載

如果希望類的對象支持相應(yīng)的運(yùn)算符（+讯检，-，*卫旱，/人灼，>,<ect），就必須實(shí)現(xiàn)相應(yīng)的魔法方法
繼承一樣有用

• : daa

:gt
一般情況需要對>或者<進(jìn)行重載顾翼，重載后可以通過sort方法直接對對象的列表進(jìn)行排序

class Student:
    def __init__(self,name='',age=0,score=0):
        self.name = name
        self.age = age
        self.score = score

    # self:+ 前面的對象
    # other:+ 后面的對象
    def __add__(self, other):
        return self.score + other.score

    # 重載 > 符號
    # 注意：重載>和<可以只重載一個(gè)挡毅，另一個(gè)對應(yīng)的功能自動(dòng)取反
    def __gt__(self, other):
        return self.age > other.age

    # 重寫魔法方法__str__，用來制定對象的打印樣式
    def __str__(self):
        return 'Student:%s %d %d'% (self.name,self.age,self.score)

if __name__ == '__main__':
    stu1 = Student('小明',18,90)
    stu2 = Student('老王',29,84)
    stu3 = Student('項(xiàng)羽',24,70)
print(stu1 + stu2)
print(stu1 > stu2)
print(stu1 < stu2)

all_student = [stu1,stu2,stu3]
all_student.sort()
for stu in all_student:
    print(stu.name,stu.age,stu.score)
print(stu1.__str__())