1.屬性和方法的訪問權(quán)限

私有的：在類的外部不可以使用，也不可以繼承
保護的：在類的外部不可以使用，可以繼承
公開的：在類的外部可以使用，也可以被繼承

2.python的私有化

python中屬性和方法的訪問權(quán)限只有公開，但是提供了另一種私有化的方式

python中在屬性或者方法名前加，就可以將屬性或者方法變成私有的(注意：只能兩開頭，不能__結(jié)尾)
私有的屬性和方法只能在類的內(nèi)部使用，不能在類的外面使用

3.python私有化的原理

在名字前是_的屬性和方法前再加 '類名' 去保存屬性和方法

class Person:
    num = 61
    __num2 = 62

    def __init__(self, name='張三', age=0):
        self.name = name
        self.age = age
        self.__sex = '男'

    def eat(self, food):
        print(self.name, food, self.__sex)
        self.__run()

    def __run(self):
        print('在跑步')

    @classmethod
    def show_num(cls):
        print('人類的數(shù)量：%d, %d' % (cls.num, cls.__num2))

    @staticmethod
    def func1():
        print('人類要保護大自然！')


def main():
    p1 = Person()

    print(Person.num)
    # print(Person.__num2)
    print(Person._Person__num2)
    print(p1.name)
    # print(p1.__sex)
    print(p1._Person__sex)


    p1.eat('面條')
    Person.show_num()
    Person.func1()

    print(p1.__dict__)


if __name__ == '__main__':
    main()

1.應(yīng)用場景

getter:獲取對象屬性的值之前想要做點兒別的事情，就給這個屬性添加getter
setter:給對象屬性賦值之前想要做點兒別的事情，就給這個屬性添加setter

2.getter

第一步: 聲明屬性的時候在屬性名前加_
第二步：聲明函數(shù)(函數(shù)沒有除了self以外的參數(shù)，但是要有返回值，返回值就是獲取屬性拿到的值)
@property
def 去掉的屬性名(self):
做點別的事情
返回屬性的值
第三步：在類的外部通過 '對象.去掉的屬性' 去獲取相關(guān)的屬性

調(diào)用函數(shù)不加括號

3.setter - 想要添加setter必須要先有g(shù)etter

第一步: 聲明屬性的時候在屬性名前加_
第二步：聲明函數(shù)(函數(shù)除了self以外還需要一個參數(shù)，沒有返回值。這兒的參數(shù)代表給屬性賦的值)
@屬性名去掉.setter
def 去掉的屬性名(self, 參數(shù)):
做點別的事情
給屬性賦值
第三步：在類的外部通過 '對象.去掉_的屬性' 去給相關(guān)屬性賦值

直接使用'對象.去掉_的屬性名 = 值'來使用

class Person:
    def __init__(self, name=''):
        self.name = name
        self._age = 0
        self._week = 1    # 屬性名前有_，使用屬性的時候不要直接用

    # 給age添加getter
    @property
    def age(self):
        return self._age

    # 給age添加setter
    @age.setter
    def age(self, value):
        if not isinstance(value, int):
            raise ValueError
        if not (0 <= value <= 150):
            raise ValueError
        self._age = value

    # 給week添加getter
    @property
    def week(self):
        if self._week < 7:
            return '星期%d' % self._week
        else:
            return '星期天'


def main():
    p1 = Person()

    # 通過不帶_的屬性給屬性賦值實質(zhì)是在調(diào)用setter對應(yīng)的函數(shù)
    p1.age = 120

    print(p1.age)

    # 這個操作實質(zhì)是在調(diào)用week函數(shù)
    # 通過不帶_的屬性來獲取屬性的值實質(zhì)是在調(diào)用getter對應(yīng)的函數(shù)
    print(p1.week)


if __name__ == '__main__':
    main()

1.什么是繼承

一個類繼承另外一個類，其中會產(chǎn)生繼承者和被繼承者。這兒的繼承者叫子類，被繼承者叫父類/超類
繼承就是讓子類直接擁有父類的方法和屬性

2.怎么繼承

語法：
class 類名(父類列表):
類的內(nèi)容

說明：
a.python中所有的類都是直接或者間接繼承自基類object
class 類名： ===> class 類名(object):

b.python中的繼承支持多繼承，父類列表中可以有多個類，多個類之間用逗號隔開

3.能繼承哪些東西:所有的屬性和方法都能夠繼承

注意：a. slots的值繼承后沒有效果
b. 在類中給slots賦值后，當(dāng)前類的對象不能使用dict，但是這個類的子類對象可以使用dict，
只是dict中沒有從父類繼承下來的對象屬性，只有在子類中添加的對象屬性
c. 如果父類沒有給slots賦值，直接給子類的slots賦值，無效！

class Person(object):
    num = 61

    __slots__ = ('name', 'age', 'sex', '__face')

    def __init__(self, name='張三', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
        self.__face = 60

    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

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


class Student(Person):
    pass


def main():
    Student.num = 20
    print(Student.num)

    stu = Student()
    print(stu.name)

    stu.eat('香蕉')

    Student.show_num()


if __name__ == '__main__':
    main()

=========================添加方法=========================

1.添加方法

直接在子類中聲明新的方法

2.重寫方法

在子類中重新實現(xiàn)父類的方法 - 完全重寫
保留父類的功能，在子類中添加新的功能 - 部分重寫(在子類方法中通過'super().'的方式調(diào)用父類方法)

3.類中函數(shù)的調(diào)用過程：

回到函數(shù)聲明的位置：先看當(dāng)前類中是否有方法，如果有就直接調(diào)用當(dāng)前類中的方法，沒有就去看父類中有沒有這個方法，
如果父類中也沒有就看父類的父類中有沒有...直到找到object類，如果object中也沒有就報錯！

=========================添加屬性=========================

1.類的字段

直接在子類中聲明新的字段

class Person(object):
    num = 61

    __slots__ = ('name', 'age', 'sex', '__face')

    def __init__(self, name='張三', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
        self.__face = 60

    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

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


class Student(Person):
    num2 = 100

    # 添加方法
    def study(self):
        print('%s在寫代碼' % self.name)

    @classmethod
    def func1(cls):
        print('我是學(xué)生類的類方法')

    @staticmethod
    def func2():
        print('我是學(xué)生類的靜態(tài)方法')

    @classmethod
    def show_num(cls):
        print('學(xué)生數(shù)量：%d' % cls.num)

    def eat(self, food):
        super().eat(food)
        print('吃飽了')


def main():
    p1 = Person('張三')
    stu1 = Student('李四')
    stu1.study()

    # 子類可以使用父類的屬性和方法，但是父類不能使用子類中添加的屬性和方法
    Student.func1()

    Person.show_num()
    Student.show_num()

    stu1.eat('蘋果')


if __name__ == '__main__':
    main()

添加對象屬性：
對象屬性其實是通過繼承init方法繼承下來的

class Animal:

    def __init__(self, age):
        self.age = age
        self.color = '灰色'


class Dog(Animal):

    def __init__(self, name, age):
        # 調(diào)用父類的init方法來繼承父類的對象屬性
        super().__init__(age)
        self.name = name

練習(xí)：聲明人類，有屬性：名字、年齡、性別
聲明學(xué)生類，有屬性：名字、年齡、性別、學(xué)號、分數(shù)
要求：創(chuàng)建人的對象的時候名字必須賦值，性別可以賦值也可以不賦值，年齡不能賦值
創(chuàng)建學(xué)生對象的時候名字可以賦值可以不賦值，學(xué)號必須賦值，分數(shù)和性別、年齡不能賦值

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


class Student(Person):
    def __init__(self, id, name='張三'):
        super().__init__(name)
        self.id = id
        self.score = 60


def main():
    dog1 = Dog('默默', 3)
    print(dog1.name, dog1.age, dog1.color)


if __name__ == '__main__':
    main()

多繼承：
class 類名(父類1, 父類2, ...):
類的內(nèi)容

多繼承的時候，多個父類中的所有方法和字段都可以繼承，只是對象屬性只能繼承第一個父類的

class Animal:
    def __init__(self):
        self.name = '小白'
        self.age = 0
        self.color = '黑色'

    def func1(self):
        print('動物中的對象方法')


class Fly:
    def __init__(self):
        self.height = 1000

    def func2(self):
        print('飛行類的對象方法')


class Bird(Animal, Fly):
    pass


def main():
    b1 = Bird()
    b1.func1()


if __name__ == '__main__':
    main()

1.什么是運算符重載

通過實現(xiàn)類中相應(yīng)的魔法方法來讓當(dāng)前類的對象支持相應(yīng)的運算符

注意：python中所有的數(shù)據(jù)類型都是類，所有的數(shù)據(jù)都是對象

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

    # 實現(xiàn)'+'對應(yīng)的魔法方法，讓兩個學(xué)生對象能夠進行+操作
    # self和other的關(guān)系： self+other   ==>   self.__add__(other)
    # 返回值就是運算結(jié)果
    def __add__(self, other):
        # a.支持Student + Student
        return self.age + other.age
        # b.支持Student + 數(shù)字
        # return self.age + other

    # self * other
    # 將other當(dāng)成數(shù)字
    def __mul__(self, other):
        return self.name * other

    # self和other都是學(xué)生對象
    # 注意：大于和小于運算符只需要重載一個就行
    def __gt__(self, other):
        return self.score > other.score

    def __repr__(self):
        return '<' + str(self.__dict__)[1:-1] + '>'


def main():
    stu1 = Student('小花', 18, 90)
    stu2 = Student('夏明', 20, 78)
    stu3 = Student('小紅', 17, 99)

    # 所有類的對象都支持'=='和'!='
    print(stu1 == stu2)

    print(stu1 + stu2)

    print(stu1 * 2)

    print(stu1 > stu2)
    print(stu1 < stu2)

    students = [stu1, stu2, stu3]
    print(students)
    students.sort()
    print(students)


if __name__ == '__main__':
    main()

內(nèi)存管理

1.數(shù)據(jù)的存儲

內(nèi)存分為棧區(qū)間和堆區(qū)間；從底層來看棧區(qū)間的內(nèi)存的開辟和釋放是系統(tǒng)自動管理的，堆區(qū)間的內(nèi)存是由程序員通過代碼開辟(malloc)和釋放的
從python語言角度，棧區(qū)間的內(nèi)存的開辟和釋放是系統(tǒng)自動管理的，堆區(qū)間的內(nèi)存管理也已經(jīng)封裝好了
程序員也不需要寫代碼來開辟空間和釋放空間

a. python中變量本身是存在棧區(qū)間的，函數(shù)調(diào)用過程是在棧區(qū)間；對象都是存在堆區(qū)間(python所有數(shù)據(jù)都是對象)
b. 變量賦值過程：先在堆區(qū)間開辟空間將數(shù)據(jù)存起來，然后將數(shù)據(jù)對應(yīng)的地址存到棧區(qū)間的變量中數(shù)字和字符串比較特殊，賦值的時候不會直接開辟空間，而是先檢測之前有沒有存儲過這個數(shù)據(jù)，如果有就用之前的數(shù)據(jù)的地址

2.內(nèi)存釋放(垃圾回收機制)原理：

python中的每個對象都有一個屬性叫'引用計數(shù)'，表示當(dāng)前對象的引用的個數(shù)。判斷一個對象是否銷毀就看對象的引用計數(shù)是否為0，為0的就銷毀，不為0的就不銷毀。

from sys import getrefcount
getrefcount函數(shù)：
getrefcount(對象) -> 獲取對象的引用計數(shù)

使用不同的變量存對象地址會增加引用計數(shù)