Python基础语法速记-2

面向对象编程，不按照步骤来实现业务，而是把一个系统拆解出若干事务，每个事务就是一个对象。区别于面向对象编程，自顶向下，逐步细化，把一个系统拆解为若干步骤，每一个步骤就是一个函数

1. 类与对象

获得具体对象，首先先要有类

"""
object为一切类的父类(此处为 继承特性的语法书写格式)
object类似Java中的java.lang.Object
"""


class ClassTest(object):
    # 占位符
    pass

对象具有成员(对象)属性 和 成员(对象)方法，成员属性 和 成员方法既可以在类内部定义，也可以在类外部定义

对象的成员属性外部定义

class ClassTest(object):
    # 占位符
    pass


# 对象的成员属性外部定义
classTest = ClassTest()
classTest.memPro1 = 10
classTest.memPro2 = '这是一个测试类'
classTest.memFun = lambda a, b: a + b

print(classTest.memPro1)
print(classTest.memPro2)
print(classTest.memFun(3, 4))

在类的内部，为所有对象添加成员属性，需要借助于魔术方法
类似于__int__(),__str__(),__del__()这样，用__开头，
以__结尾的方法称为魔术方法，同样，以__开头，以__结尾的属性称为魔术属性(魔术变量) if __name__ == '__main__':

class ClassTest(object):
    """
    self关键字指向实例化对象本身,类似于Java中的this关键字
    当类被具体实例化时，__init__()自动触发，用于对象的初始化操作
    """

    def __init__(self, memPro1, memPro2):
        self.memPro1 = memPro1
        self.memPro2 = memPro2

    def memFun(self, a, b):
        return a + b

    # 该方法不被重写时，默认返回实例化对象的内存地址
    # 该方法类似于Java中的toString()
    def __str__(self):
        return f'实例化了一个对象,成员属性为{self.memPro1}、{self.memPro2}'

    # 用于对象资源的释放，类似于C语言中的析构函数
    def __del__(self):
        pass

2. 面向对象三大特性之封装

Java语言中，可以使用private关键字实现成员属性和成员方法的封装，但Python中没有private关键字，属性和方法的封装通过__实现，以此达到保护对象内数据的目的

class ClassTest(object):
    def __init__(self, memPro1, memPro2):
        self.memPro1 = memPro1
        self.memPro2 = memPro2
        # 私有成员属性
        self.__memPro3 = self.memPro1 + self.memPro2

    # 公共方法
    def redirectURL(self, url):
        if self.__getMemPro3() == url:
            print(f'跳转到{url}')
        else:
            print('用户非法访问')

    # 私有成员方法
    def __getMemPro3(self):
        return self.__memPro3

    def superMethod(self):
        print('subClass may used or override')
# 对象实例化
classTest = ClassTest(10, '这是一个测试类')
classTest.redirectURL('https://www.csdn.net/')

3. 面向对象三大特性之继承

继承就是一个类直接使用另一个类定义的成员属性和成员方法(包括构造方法)，本类不再重复定义。区别于Java中的extends关键字，Python中的继承语法如下：

from object.ClassTest import ClassTest

# 类SubClassTest继承父类ClassTest
class SubClassTest(ClassTest):
    def __init__(self, mempro1, mempro2):
        self.mempro1 = mempro1
        self.mempro2 = mempro2

    def __init__(self):
        pass

subClassTest = SubClassTest()
# 子类直接使用父类中的superMethod()
subClassTest.superMethod()

区别于Java中的继承，Python中一个子类可以同时继承多个父类

class C(object):
    pass
class B(object):
    pass

class A(B, C):
    pass

如果多个父类具有相同的属性和方法，则子类中位于左边父类的属性和方法具有较高优先级

可以通过子类的方法moto() 或 魔术变量 __moto__ 查看子类的继承关系

print(HybridCar.mro())
print(HybridCar.__mro__)

子类可以重写父类中的方法，只需要方法签名和父类保持一致，在子类的重写方法中，也可以调用 super()方法，访问父类的成员属性和成员方法

4.面向对象三大特性之多态

多态可以理解为同一个事物的的多种形态，Python语言中体现为：同一个方法，随着传入参数的不同，返回不同的执行结果

多态依赖继承，需要重写父类中的公共方法

class Fruit(object):
    def makejuice(self):
        print('i can makejuice')

class Apple(Fruit):
    def makejuice(self):
        print('i can make apple juice')

class Banana(Fruit):
    def makejuice(self):
        print('i can make banana juice')

class Orange(Fruit):
    def makejuice(self):
        print('i can make orange juice')

# 定义一个公共接口
def service(obj):
    obj.makejuice()

# 统一方法，随着传入对象的不同，可以返回不同的执行结果
service(Apple())
service(Banana())
service(Orange())

5. 静态方法

类中的静态方法，需要在方法前添加装饰器 @staticmethod ，装饰器主要用于修饰方法，在不修改源代码的基础上，为其增加额外功能。
调用方式：类名.静态方法，对象实例.静态方法

class StudentManager(object):
    def __init__(self):
        self.students = []

    @staticmethod
    def menu():
        print('-' * 50)
        print('欢迎使用学生管理系统V1.0')
        print('-' * 50)

StudentManager.menu()
StudentManager().menu()