Python面向对象基础

NOTE：
重要强调：
    Python的作用域和命名空间
（1）命名空间 是从命名到对象的映射
    ①内置命名空间
    ②全局命名空间：模块
    ③本地命名空间：模块中的函数和类
（2）作用域   是一个 Python 程序可以直接访问命名空间的正文区域
    
一：简介
            类：用来描述具有相同的属性和方法的对象的集合
        方法：类中定义的函数
      类变量：类变量在整个实例化的对象中是公用的。
                    类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
    实例变量：定义在方法中的变量，只作用于当前实例的类。（注意区分实例变量和类变量）

    实例变量用于对每一个实例都是唯一的数据，类变量用于类的所有实例共享的属性和方法
    用构造方法初始化的属性叫做实例变量，直接在类中定义的属性叫做类变量。

   方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override）
       实例化：创建一个类的实例，类的具体对象
           对象：通过类定义的数据结构实例    

二：语法格式
    
    class ClassName:
            <statement-1>
            <statement-N>

三：类对象

    类对象支持两种操作：属性引用和实例化。
    （1）类对象创建后，类命名空间中所有的命名都是有效属性名MyClass.f
    （2）实例化：将类对象看作是一个返回新的类实例的无参数函数x = MyClass()
    
四：类属性

    公有属性：在类中定义，可以在类间调用，可以通过析构函数进行初始化
    私有属性：在类中定义，以双下划线开始，在类外不能被直接调用，只能被类内部方法使用！
    调用方法：用公有方法返回！

五：类方法

    （1）类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,
    按照惯例它的名称是 self
    （2）在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，
    类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例
    （3）两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用
    （4）类的专有方法

六：构造函数

    类有一个名为 __init__() 的特殊方法（构造方法），
    该方法在类实例化时会自动调用类有一个名为 __init__() 的特殊方法（构造方法），
    该方法在类实例化时会自动调用
    可以声明带默认参数的实例变量！

七：析构函数

    实例化的对象调用结束时候调用！

八：类的继承

        (1)语法结构

        class DerivedClassName(BaseClassName1):
                    <statement-1>
                    .
                    <statement-N>

        (2)多类继承的时候，新式类（python3）按照广度优先的原则，
        (找一个爸爸，再找下一个爸爸。。。。）
    
        class DerivedClassName(Base1, Base2, Base3):
                <statement-1>
                .
                    <statement-N>

    (3)基类名与派生类定义在同一个作用域中，除了类，还可以用表达式，
    基类定义在另一个模块中时这一点非常有用:
        class DerivedClassName(modname.BaseClassName):
    这种写法在模块化程序中很重要！

    (4)方法重写

    ①父类方法的功能不能满足你的需求，可以在子类重写你父类的方法    
    super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
          子类,对象， 方法
    ②派生类对基类的方法重写，重写后的基类方法叫做费捆绑方法，
    不能直接调用，需要使用super函数。

    注意：

    ①子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__。
    ②重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__
    ③如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字
        super(子类，self).__init__(参数1，参数2，....)
        父类名称.__init__(self,参数1，参数2，...)
    
八：多态和封装

    “当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
    在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。
    例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，
    并调用它的走和叫方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，
    并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。
    任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，
    这种决定类型的方式因此得名。

    http://www.php.cn/python-tutorials-366356.html

    （关于多态不是太懂！）

# -------------------------------------------------------------------------------------------------------------#
# 创建类
# -------------------------------------------------------------------------------------------------------------#


class MyClass:                      # 类的命名为大驼峰原则
    """一个简单的类实例"""
    i = 12345                       # 类的公有属性

    def __init__(self, real):       # 带参数的构造函数(方法)
        self.r = real
        # self.i = imag

    def func(self):                     # 类的方法和普通函数的区别
        m = self.i + self.r
        return m
# -------------------------------------------------------------------------------------------------------------#
# 类的实例化
# -------------------------------------------------------------------------------------------------------------#


print("------------------------类的实例化-----------------------------------")
x = MyClass(2)
y = MyClass(3)
# print(x.__doc__)
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的属性 i 为：", y.i)

# 对于可变对象如列表、字典、集合,应该声明为实例变量，因为实例化后的对象会改变原来的值！
x.i = 23
print("实例化X后 i 为：", x.i)
print("实例化Y后 i 为：", y.i)
print("MyClass 类的方法 f 输出为：", x.func())

# -------------------------------------------------------------------------------------------------------------#
# 类的继承
# -------------------------------------------------------------------------------------------------------------#
print("------------------------类的继承-------------------------------------")


# 定义基类
class People:
    # 定义类变量
    # name = ''
    # age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    # __weight = 0
    # 定义构造方法，初始化类变量的值

    def __init__(self, n, a, w):    # 构造函数
        # print('调用了构造函数')     # 测试构造函数的调用
        self.name = n
        self.age = a
        self.__weight = w
        # 上面的变量可以全部定义为私有变量！因为在外部没有必要使用！

    def speak(self):
        print("%s 说: ’我 %d 岁 %dkg’" % (self.name, self.age, self.__weight))

    def my_print(self, name):
        print(self.name)    # self的作用是类级别上的变量
        print(name)         # 不带self可能是变量的值

    def get_name(self):     # OPP家族传统理念：Getter + Setter
        return self.name    # 为了得到类中的数据并且抱枕数据的安全（无受保护的数据类型）

    def get_age(self):      # 通过self实现内容的间接调用
        return self.age

    # @property   #
    def get_weight(self):  # 通过self实现内容的间接调用
        return self.__weight

    def __del__(self):      # 注意学习python的垃圾回收机制
        print('调用了父析构函数')
# 总结：对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，
# 通过对象或者self间接的调用内容

# 继承：子可以继承父亲的所有内容
# 定义派生类


class Student(People):

    def __init__(self, n, a, w, g):
        self.__grade = g
        People.__init__(self, n, a, w)          # 调用父类的构造函数

    # 保变量的值不被改变 ，又要得到值
    def lo_ol(self):
        print('I am not a good student!')
        print('My grade is %d' % self.__grade)

    def __del__(self):          # 注意学习python的垃圾回收机制
        print('调用了子析构函数')


myInfo = People('faith', 24, 60)
myInfo.speak()
myInfo.age = 10
myInfo.speak()
print(myInfo.age)               # 类外直接使用


print("------------------------测试派生类-------------------------------------")
# 通过上面的代码可以得到下面的结论：
# 析构函数在对象释放的时候调用
# 可以直接在类外访问类的基本属性
# 不能在类外直接访问类的私有属性

stud = Student('faith', 2, 2, 2)
stud.lo_ol()
stud.speak()
print("体重", stud.get_weight())
# 方法重写


class Parent:   # 定义父类
    def mymethod(self):
        print('调用父类方法')


class Child(Parent):  # 定义子类
    def mymethod(self):
        print('调用子类方法')


print("------------------------测试方法重写-------------------------------------")
c = Child()          # 子类实例
c.mymethod()         # 子类调用重写方法
super(Child, c).mymethod()  # 用子类对象调用父类已被覆盖的方法

# 静态方法和类方法
print("------------------------测试静态方法和类方法-------------------------------------")


class Apple:
    def fun1(self):
        return 'normal'

    @staticmethod       # 静态方法
    def fun2():
        return 'staticmethod'

    @classmethod
    def fun3(cls):      # 类方法（能够访问类属性）
        return 'classmethod'


print(Apple.fun1)   # 非捆绑调用
print(Apple.fun2)
print(Apple.fun3)
print("-"*80)


apple = Apple()     # 捆绑调用
print(apple.fun1)
print(apple.fun2)
print(apple.fun3)

print("-"*80)

apple1 = Apple()    # 捆绑调用
print(apple1.fun1)
print(apple1.fun2)
print(apple1.fun3)