01-重寫

"""
繼承后，子類可以擁有除父類繼承的內容以外的其他的內容

1.關于方法
1）.在子類中可以直接添加其他的方法
2）.重寫：
a.完全重寫
重新實現從父類繼承下來的方法，重寫后，子類再調用這個方法的時候，就調用子類的
b.保留父類實現的功能，再添加新的功能

對象和類調用方法的過程：先看當前類是否存在這個方法，沒有才看父類有沒有這個方法；
如果父類沒有就看父類的父類有沒有，直到找到基類(object)為止

"""

class Animal(object):
    """動物類"""
    def __init__(self):
        self.age = 0
        self.color = ''

    def eat(self):
        print('吃東西')

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

    @classmethod
    def get_number(cls):
        return 100


class Dog(Animal):
    """狗類"""
    def look_after(self):
        print('看家')

    #  重寫父類的shout
    def shout(self):
        print('汪汪汪~')

    # 重寫父類eat方法
    def eat(self):
        # 保留父類eat的功能
        super().eat()
        print('吃骨頭')

    @classmethod
    def get_number(cls):
        # 保留父類的類方法的功能的時候，還是super().類方法
        print(super().get_number())


if __name__ == '__main__':
    dog = Dog()
    dog.age = 3
    print(dog.color)
    dog.shout()
    dog.look_after()
    dog.eat()

    an = Animal()
    # 繼承后，父類不能使用在子類中添加的屬性和方法
    # an.look_after()
    an.eat()

    Dog.get_number()

02-添加屬性

"""
對象屬性的繼承：是通過繼承init方法來繼承的對象屬性

給當前類添加對象屬性: 重寫init方法。
注意：如果要保留父類的對象屬性，需要使用super()去調用父類的init方法

多態(tài)：同一個事物有多種形態(tài)。
方法的多態(tài)：子類繼承父類的方法，可以對方法進行重寫，一個方法就有多種形態(tài)（多態(tài)的表現）
類的多態(tài)：繼承產生多態(tài)
"""

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

    def eat(self):
        print('人在吃飯')


class Staff(Person):
    # init方法的參數：保證在創(chuàng)建對象的時候就可以給某些屬性賦值
    def __init__(self, name='', age=0, salary=0):
        super().__init__(name, age)
        self.salary = salary

    def eat(self):
        print('員工在吃飯')

class Scientist(Person):
    def eat(self):
        print('科學家在吃飯')


if __name__ == '__main__':
    p1 = Person('李四',sex='女')
    p1.eat()

    s1 = Staff(age=18)
    s1.sex = '男'
    print(s1.name)
    s1.salary = 10000
    print(s1.salary)
    s1.eat()

練習：

"""
聲明人類，有屬性，名字、年齡、性別、身高
要求創(chuàng)建人的對象的時候可以給名字、性別、年齡賦初值

再創(chuàng)建學生類繼承自人類，擁有人類的所有的屬性，再添加學號、成績、電話屬性
要求創(chuàng)建學生對象的時候可以給名字、年齡和電話賦初值
"""

class Person2:
    """人類"""
    a = 10

    def __init__(self, name, sex, age):
        self.name = name
        self.age = age
        self.sex = sex
        self.height = 0


class Student(Person2):
    """學生類"""
    b = 100

    def __init__(self, name='', age=0, tel='00'):
        super().__init__(name, age=age, sex='女')
        self.study_id = '00'
        self.score = 0
        self.tel = tel


stu = Student('李四')
stu.sex = '男'
print(stu.age)

p1 = Person2('張三', '男', 18)

03-運算符的重載

"""
1.重載：一個類中可以有多個名字相同的方法，但是參數不一樣，就叫重載。python中不支持
"""

class Student:

    # python不支持方法的重載
    # def run(self):
    #     print('人在跑')
    def run(self, name):
        print('%s在跑' % name)

"""
2.運算符重載（重新定義運算符運算的過程）

、<
大于和小于符號只需要重載其中的一個，另外一個的結果，直接是重的結果取反

+、-
"""

class Student2:
    def __init__(self, name='', age=0, height=0):
        self.name = name
        self.age = age
        self.height = height

    #   重載: >
    """
    self > other
    """
    def __gt__(self, other):
        # 比較對象1>對象2的時候是比較的他們的height屬性
        return self.height > other.height
        # return self.age > other.age
        # return id(self) > id(other)

    # 重載：<
    def __lt__(self, other):
        return self.age < other.age

    # 重載: +
    def __add__(self, other):
        return self.age + other.age

    # 重載: -
    def __sub__(self, other):
        return self.height - other.height


if __name__ == '__main__':
    stu = Student()
    stu.run('余婷')

    stu1 = Student2('aa', 18, height=170)
    stu2 = Student2('bb', 20, height=140)

    if stu1 > stu2:
        print('學生1大于學生2啊啊')

    if stu1 < stu2:
        print('學生1大于學生2')
    else:
        print('學生2小于學生1')

    print(stu1 + stu2)
    print(stu1-stu2)

    print(100+200)
    print('abc'+'abc')

04-python中的內存管理

"""
python內存管理原理

內存中有兩個特殊的區(qū)域：棧、堆
棧：棧中的內存是系統自動管理（內存的開辟和內存的釋放） --- 作用域結束，內存就釋放
堆：堆中的內存都需要寫程序去開辟和釋放的（python中這個過程也已經自動化）

原理？：堆中的數據到底是什么時候釋放的？
看一個對象有幾個引用，當一個對象沒有引用的時候，對象對應的內存空間就會被釋放
(引用計數機制)

引用：存儲對象地址的變量

"""

class Person:
    def __init__(self, name):
        self.name = name
    def run(self):
        print(self.name,'人在跑')


if __name__ == '__main__':
    # 聲明了一個Person對象，存到p中的
    p = Person('p')
    p.run()
    # 刪除對象的唯一的引用，對象就會被銷毀
    del p
    # p.run()

    # Person對象(0)，name='p1'  0+1+1-1-1
    p1 = Person('p1')
    p2 = p1
    del p2
    p1.run()
    p1 = 'a'

    # 注意：將對象添加到容器中，對象的引用會加1
    p3 = Person('p3')
    lists = [p3, 100]
    del p3

    lists[0].run()

    # del lists[0]
    # del lists
    lists[0] = None

05-包的使用

"""
封裝：
對一個功能的封裝 --> 用函數
對多個功能的封裝 --> 模塊和類
對多個數據進行封裝 --> 類、字典
對多個類進行封裝 ---> 模塊
對多個模塊進行封裝 ---> 包(文件夾)

"""

# 導入某個包中的某個模塊
from package1 import my_math
# 導入某個包的某個模塊中的某個函數和類
from package1.my_math import sum,Math

if __name__ == '__main__':
    # sum()
    # Math.sum()
    #
    # my_math.sum()
    # print(my_math.Math.pi)
    pass