python面向对象

类和对象

类（Class）：描述具有相同的属性和方法的对象的集合。

对象(Object)：通过类进行实例化，分配内存空间，能被用户实际调用。

封装

对象的生命周期以及函数执行顺序

class Apple:
    def __init__(self):            # 初始化函数，实例化时被自动调用
        print("初始化函数__init__")
    def __del__(self):            # 析构函数，释放对象时被自动调用
        print("析构函数__del__")
a = Apple()

运行结果：
初始化函数__init__
析构函数__del__
class Apple:
    def __new__(cls):            #构造函数，返回的对象传递给__init__
        print("构造函数__new__")
        return super().__new__(cls)
    def __init__(self):
        print("初始化函数__init__")
    def __del__(self):
        print("析构函数__del__")

a = Apple()
运行结果：
构造函数__new__
初始化函数__init__
析构函数__del__

self

self代表当前对象，可以在类的内部直接访问任何类的变量和方法，所有函数都以self为第一个参数。

class Apple:
    name = "apple"
    def get_name(self):
        print(self.name)
    def display(self):
        self.get_name()
        
Apple().display()        # 运行结果：apple

类属性（可变与不可变）

类属性变化，对象属性跟着变化

不可变：对象属性变化，类属性不变化

class Apple:
    name = "Tom"
    l = [1, 2, 3]

a = Apple()
print(id(Apple.name) == id(a.name))        # True
print(id(Apple.l) == id(a.l))                # True
a.name = "Jack"
a.l += [4, 5, 6]
print(id(Apple.name) == id(a.name))        # False
print(id(Apple.l) == id(a.l))                # True

对象属性

class A:
    def __init__(self,name,age):
        # 声明属性
        self.name = name
        self.age = age
a = A("Tom", 18)
print(a.name)
print(a.age)

运行结果：
Tom
18

公有与私有

class Apple:
    i = 100                        # 公有变量
    __j = 1000                    # 私有成员变量，外部不能访问
    def test1(self):                
        print(self.i)
        print(self.__j)
        self.__test1()
        print("Apple.test1()")
    def __test2(self):                # 私有函数，外部不能访问
        print("Apple.__test1()")
a = Apple()
print(a.i)
a.test1()

可以通过实例名._类名__[变量、属性、方法]来对私有的属性或方法来逆行访问，但是及其不推荐这样做。

类方法，静态方法，魔术方法

class Apple:
    # 类方法（属于类，不属于对象）
    @classmethod
    def test(cls):
        print("ClassMethod")

# 类.方法名（）   对象.方法名（）都可以访问类方法
Apple.test()
a = Apple()
a.test()

class Apple:
    # 静态方法：寄居在类中，独立存在，不能调用对象方法和类方法（类名.方法名()除外）
    @staticmethod
    def test():
        print("ClassMethod")
# 类.方法名（）   可以访问静态方法
Apple.test()

class A:
    def __init__(self, name="Tom", age=18):
        self.name = name
        self.age = age
    def __str__(self):
        return "我叫%s，我今年%d岁。" % (self.name, self.age)
a = A()
print(a)

运行结果：
我叫Tom，我今年18岁。

class Apple:
    name = "Apple"
    def __len__(self):      # 被内置函数len()调用时返回
        return len(Apple.name)

a = Apple()
print(len(a))

运行结果：
5

继承：子类访问父类私有的类属性、对象属性、方法

子类（派生类）通过继承父类（基类），拥有了父类的属性和方法（不包括私有的）。

class A:
    def __init__(self, name="Rose", age=28):
        self.name = name
        self.age = age
    def a_test(self):
        print("a_test()")

class B(A):
    def b_test(self):
        print("b_test()")

b = B("Tom",18)
b.a_test()
b.b_test()

属性和方法的覆盖

B类继承A类的属性和方法，但是在B类中覆盖了A类中的属性和方法

class A:
    def __init__(self):
        self.name = "Tom"
    def display(self):
        print("我是A，我叫%s。" % self.name)
class B(A):
    def __init__(self):
        self.name = "Jerry"
    def display(self, name = "Jame"):
        print("我是B，我叫%s。" % self.name)
b = B()
print(b.name)            # Jerry
b.display()                # 我是B，我叫Jerry。

super（）

class A:
    def __init__(self, name="Tom"):
        self.name = name
    def display(self):
        print("A.display()")
class B(A):
    def __init__(self):
        super().display()        # 调用父类的方法
        super().__init__("Jerry") # 调用之后，继承父类生成的name属性
b = B()
print(b.name)

方法的重写

class A:
    def test(self):
        print("A.test()")
class B(A):
    def test(self):        # 重写父类的test()方法
        print("B.test()")
b = B()
b.test()
super(B, b).test()        # 调用B类的父类A的test()方法
运行结果：
B.test()
A.test()

多继承

class A:
    def test1(self):
        print("A.Test()")
class B:
    def test2(self):
        print("B.Test()")
class C(A, B):
    def test3(self):
        print("C.Test()")
c = C()
c.test1()
c.test2()
c.test3()

多态：子类重写父类的方法

class A:
    def test(self):
        print("A.Test()")
class B(A):
    def test(self):
        print("B.Test()")
b = B()
b.test()

运行结果：
B.Test()

编写一个水果类，实现属性color、weight、place。 2、编写子类Apple、Banana，继承水果类，实现属性price、实现方法buy()、eat()。

class Fruit:
    def __init__(self,color,weight,place):
        self.color = color
        self.weight = weight
        self.place = place

class Apple(Fruit):
    def __init__(self,color,weight,place,price):
        super(Apple, self).__init__(color,weight,place)
        self.price = price
    def info(self):
        print(self.color,self.weight,self.place,self.price)
    def eat(self):
        print("eat apple")
    def buy(self):
        print("buy apple")

class Banana(Fruit):
    def __init__(self,color,weight,place,price):
        super(Banana, self).__init__(color,weight,place)
        self.price = price
    def info(self):
        print(self.color,self.weight,self.place,self.price)
    def eat(self):
        print("eat banana")
    def buy(self):
        print("buy banana")

apple = Apple("red",1.5,"武侯区",8)
# banana = Banana("yellow",2,"温江区",4)
apple.info()
apple.eat()
apple.buy()
# banana.info()
# banana.eat()
# banana.buy()

面向对象综合练习：猜数字游戏

from random import randint
# 猜数字游戏类
class GuessNumber:
    def __init__(self):
        self.answer = randint(1, 100)            # 定义属性：谜底
        self.message = None                         # 定义属性：打印信息

    # 定义猜数字方法
    def guess(self, user_answer):
        if user_answer > self.answer:
            self.message = "猜小一点"
        elif user_answer < self.answer:
            self.message = "猜大一点"
        else:
            self.message = '恭喜你，猜对了！'
            return True
        return False
# 实例化
gn = GuessNumber()
while True:
    user_answer = int(input('请输入1到100之间的一个数: '))
    # 调用类的guess方法
    if gn.guess(user_answer):
        print(gn.message)
        break;
    print(gn.message)