Python-面向对象之基本概念，封装

1、语言分类

　　三大范式：（即方法论）

　　　　面向机器：抽象成机器指令，机器容易理解，代表：汇编

　　　　面向过程：做一件事情，排出个步骤，第一步干什么，第二步干什么，如果出现A情况，做什么处理。

　　　　　　问题规模小，可以步骤化，按部就班处理

　　　　　　代表：c语言

　　　　面向对象：OOP，随着计算机需要解决的问题的规模扩大，情况月复杂，需要很多人，很多部门协作，面向过程编程不太社和了

　　　　　　代表：c++， java， Python

2、面向对象：

　　面向对象：一种认识世界，分析世界的方法论，将万事抽象为类Class

　　类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合

　　用计算机语言来描述类，就是属性和方法的集合

　　对象instance,object，对象是类的具体，是一个实体。

　　哲学思想：

　　　　　　一切皆对象，包括类也是对象

　　　　　　对象是数据和操作的封装

　　　　　　对象是独立的，但是对象之间可以互相作用

　　　　　　目前OOP 是最接近人类认知的编程范式

3、面向对象的3要素：

　　① 封装

　　　　- 组装：将数据和操作组装到一起

　　　　- 隐藏数据：对外只暴露一些借口，通过接口访问对象

　　② 继承

　　　　- 多复用，继承来的就不用自己写了

　　　　- 多继承，少修改，OCP（Open-closed Principle）开闭原则，使用继承来改变，来体现个性

　　　　- 可以多继承，Java不支持，C++ 支持

　　③ 多态

　　　　-面向对象编程最灵活的地方，动态绑定

4、Python的类

　　定义：　　　

class ClassName:
    pass

 　　必须使用class关键字
　　类名必须是用大驼峰命名
　　类定义完成后，就产生了一个类对象，绑定到了标识符ClassName上

class MyClass:
    ''' A example class'''
    x = 'abc'
    def foo(self):
        return 'My Class'
    
print(MyClass.x)

5、类对象及类属性

　　类对象：类的定义就会生成一个类对象，也就是说MyClass 就是一个对象

　　类的属性：类定义中的变量和类中的方法都是类的属性

　　类变量：举例中X 就是类MyClass的变量

　　　　　MyClass中x, foo 都是泪的属性，MyClass.__doc__，__doc__也是类的属性
　　　　　foo方法是类的属性，也叫方法，在类中 叫 method，普通函数 叫function，foo(self)中的self是一个惯用标识符，可以换别的，但是使用惯例，self指当前实例本身。
    
  实例化:
        1、a = MyClass() 每一次实例化，只能生产该类的一个对象
　　　　　2、使用上面的语法，在类对象名称后面加上一个括号，就调用类的实例化方法，完成实例化。
　　　　　3、实例化就真正创建一个该类的对象（实例）
         4、每次实例化，产生的都是不同的对象
            -----内存地址都不一样的对象

a = MyClass()
print(id(a)) # 43808192
a = MyClass()
print(id(a)) # 43808248

　　　　　5、Python类实例化后，会自动调用__init__ 方法，对实例初始化的方法：其他语言，也叫构造方法
                
                第一个参数，必须要留给self，是可以修改名字，但是习惯用self
                self：某个具体实例的本身，谁调用，就是谁！！！！！
                java中用的是this

           6、Python类实例化，一定调用__init__ 方法，可以定义，可以不定义，会隐式的调用父类的，自己定义，就是个性化
　　　　　　　　 作用：初始化
               先实例化，在初始化：
                    类 --》 对象
                        __new__  是实例化，现在不用管
                    对象 --》 给一个设定，比如颜色之类的，修饰
                        __init__
                    也就是说，实例化后，才能调用__init__ 方法

                    ClassName() ---- 认为实例化和初始化是接近着的，实例化，马上自动初始化！！！

            7、__init__不能返回任何值，默认返回None

6、实例对象instance

class Person:
    x = 13 # 类属性

    # 方法是属于类的
    def __init__(self, name, age):  # Python解释器送过来的，也可以手动
        print('init',hex(id(self)))
        self.name = name # 实例属性
        self.age = age

    # 方法是属于类的
    def showage(self):
        return self.age

print(Person)
print('+++++++++++++++++++++++++++++++++++++++++++++++++')
tom = Person('tom', 12)
print(tom, hex(id(tom)))
print(tom.name, '-------')
print(tom.age)
tom.age += 20
print(tom.age)
print(tom.showage(), '---------')
print('++++++++++++++++++++++++++++++++++++++++++++++++++')
jerry = Person('jerry', 16)
print(jerry, hex(id(jerry)))
print(jerry.name, '-----')
print(jerry.age)
jerry.age += 20
print(jerry.age)
print(jerry.showage(), '---------')


# print（tom.showage()）  == print(Person.showage(tom)) 等价

　　类实例化后 一定会获得一个对象，就是实例对象
　　类实例化后，得到一个实例对象，实例对象 会 绑定 方法，调用 方法时采用实例.方法名 的方式。
　　但是函数签名是showage(self)，这个self就是jerry，Python会吧方法的调用者作为第一参数seld的实参传入。
　　self.name就是jerry 对象的name，name是保存在了jerry对象上，而不是Person类上，所以，称为实例变量
　　

7、实例变量和类变量：
　　　　实例变量是每个实例自己的变量，是自己独有的：
　　　　类变量是类的变量，是类的所有实例共享的属性和方法

            特殊属性：
                    __name__:对象名
                        类名， Person.__name__
                        对象是没有的，但是 tom.__class__.__name__

                        type()  等价  __class__
                              ----所以  type('tom').__name__

　　　　　　　　　　　　__class__:对象的类型

                    ___dict__: 对象的属性的字典

                    __qualname__:类的限定名
　　　　　　注：
            对象可以调用类属性，类不能调用对象属性
　　　　　　　Python中每一种对象都拥有不同的属性，函数，类都是对象，类的实例也是对象。
　　__dict__举例：

class Person:
    age = 3
    def __init__(self, name):
        self.name = name


print('-----class----')
print(Person.__dict__)
# {'__module__': '__main__', 'age': 3, '__init__': <function Person.__init__ at 0x000000000299F268>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
print(sorted(Person.__dict__.items()))
# [('__dict__', <attribute '__dict__' of 'Person' objects>), ('__doc__', None), ('__init__', <function Person.__init__ at 0x000000000299F268>), ('__module__', '__main__'), ('__weakref__', <attribute '__weakref__' of 'Person' objects>), ('age', 3)]

tom = Person('tom')
print('------istance tom ------')
print(tom.__class__)
# <class '__main__.Person'>
print(sorted(tom.__dict__.items()))
[('name', 'tom')]

print('---tom class---')
print(tom.__class__.__name__)
# Person
print(sorted(tom.__class__.__dict__.items()))
# [('__dict__', <attribute '__dict__' of 'Person' objects>), ('__doc__', None), ('__init__', <function Person.__init__ at 0x000000000299F268>), ('__module__', '__main__'), ('__weakref__', <attribute '__weakref__' of 'Person' objects>), ('age', 3)]

　　注： 可以看到 类属性保存在类的__dict__ 中，实例属性保存在实例的__dict__ 中，如果从实例访问类的属性，就需要借助__class__找到所属的类
            
　　举例：

class Person:
    age = 3
    height = 170

    def __init__(self, name, age=1):
        self.name = name
        self.age = age

tom = Person('tom')
jerry = Person('jerry', 20)

Person.age = 30
print(Person.age, tom.age, jerry.age) # 30 1 20

print(Person.height, tom.height, jerry.height) # 170 170 170
jerry.height = 175
print(Person.height, tom.height, jerry.height) # 170 170 175

tom.height += 10
print(Person.height, tom.height, jerry.height) # 170 180 175

Person.height += 15
print(Person.height, tom.height, jerry.height) # 185 180 175

Person.weight = 70
print(Person.weight, tom.weight, jerry.weight) # 70 70 70

print(tom.__dict__['height'])
print(tom.__dict__['weight']) # 报错，实例字典中没有这个key

　　总结：

　　　　是类的，也是这个类所有实例的，其 实例 都是可以访问到

　　　　是实例的，就是这个实例自己的，通过类访问不到

　　　　类变量是属于类的变量，这个类的所有实例可以共享这个变量

　　　　对象（实例 或 类）可以动态的给自己增加一个属性，实例.__dict__[变量名] 和实例.变量名 都可以访问到

　　　　实例的同名变量会隐藏掉类变量，或者说覆盖了这个类变量

　实例属性的查找顺序：
　　　指的是实例 使用. 点号来访问属性，会先找自己的__dict__， 如果没有，然后通过属性__class__找到自己的类，在去类的__dict__中找
　　  注意：如果实例 使用 __dict__[变量名]访问变量，将不会按照上面的查找顺序找变量了，这是指明使用字典的key查找，不是属性查找
　　　　　　一般来说，类变量可使用全大写来命名



8、装饰一个类（区别类装饰器）

# no 1
def foo(cls, name='jerry'):
    cls.NAME=name
    return cls
@foo
class Person1:
    AGE = 20
print(Person1.__dict__['NAME'])

# no 2
def foo(name='jerry'):
    def wrapper(cls):
        cls.NAME=name
        return cls
    return wrapper

@foo(name='tom') # Person=foo(name='tom)(Person)=wrapper(Person)
class Person1:
    AGE = 20
print(Person1.__dict__['NAME'])

　　之所以能够装饰，本质上是为类对象动态的添加了一个属性，而Person这个标识符指向这个类对象。         

9、静态方法和类方法

　　　　总结：
　　　　　　类方法：
　　　　　　　　1、在类定义中，使用@classmethod 装饰器修饰的方法
　　　　　　　　2、必须至少有一个参数，且第一个参数留给了cls，cls指代调用者即类对象本身
　　　　　　　　3、cls这个标识符可以是任意合法名称，但是不要改
　　　　　　　　4、通过cls可以直接操作类的属性
　　　　　　　　　　注意：无法通过cls操作类的实例，有类不一定有实例
　　　　　　静态方法：
　　　　　　　　1、在类定义中，使用@staticmethod装饰器修饰的方法
　　　　　　　　2、调用时，不会隐式的传参
　　　　　　　　3、只是表明这个方法属于这个名词空间，函数跪在一起，方便组织管理


10、方法的调用
　　
　　
　　总结：
　　　　类几乎可以调用所有内部定义的方法，但是调用普通方法　时会报错，原因是第一参数必须是类的实例
　　　　实例也几乎可以调用所有的方法，普通函数的调用一般不可能出现，因为不允许这么定义
　　　　
　　　　类除了普通方法都可以调用，普通方法需要对象的实例作为第一参数
　　　　实例可以调用所有类中定义的放到（包括类方法，静态方法），普通方法传入实例自身，静态方法和类方法需要找到实例的类


11、访问控制：
　　1、私有属性（Private）

# no1 原本是想通过控制方法，控制age，
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def growup(self, i=1):
        if i>0 and i<100:
            self.age += 1

p1 = Person('tom',12)
p1.growup(20)
p1.age = 160 # 但是超界了，还是会修改
print(p1.age)

# no2  __age 作为私有，双下划线
class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def growup(self, i=1):
        if i>0 and i<100:
            self.__age += 1

p1 = Person('tom',12)
p1.growup(20)
# print(p1.__age) # 获取不到，根本没有这样的一个属性，报错



class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def growup(self, i=1):
        if i>0 and i<100:
            self.__age += 1

    def getage(self):
        return self.__age

p1 = Person('tom',12)
p1.__age = 1000 # 这个是自己另外给p1实例增加了一个__age 属性，并不是私有的属性
print(p1.__age) # 1000
print(p1.getage()) # 12


print(p1.__dict__)
# {'name': 'tom', '_Person__age': 12, '__age': 1000}
# 看字典就明白了
# 事实上，私有的是修改了名字， _Person__age
# 知道了这个名字 可以直接修改了
p1._Person__age = 10
print(p1.getage()) # 10

　　2、保护变量：

class Person:
    def __init__(self, name, age):
        self.name = name
        self._age = age

    def growup(self, i=1):
        if i>0 and i<100:
            self.age += 1

tom = Person('tom',12)
print(tom._age) # 12
print(tom.__dict__) # {'name': 'tom', '_age': 12}

　　　　　　可以看出，这个_age 属性根本就有没改变名称，和普通的属性一样，解释器不做任何特殊处理，这只是开发者共同的约定，不要直接使用

12、私有方法：类似私有属性

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def _getname(self):
        return self.name

    def __getage(self):
        return self.age


tom = Person('tom',12)
# print(tom.__getage()) #报错，没有
print(tom._getname())
print(tom.__dict__)
print(tom.__class__.__dict__)
print(tom._Person__getage())

# tom
# {'name': 'tom', 'age': 12}
# {'__module__': '__main__', '__init__': <function Person.__init__ at 0x000000000297C8C8>, '_getname': <function Person._getname at 0x00000000029402F0>, '_Person__getage': <function Person.__getage at 0x0000000002992840>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
# 12

13、补丁：

　　可以通过修改或者替换类的成员，使用者调用的方式没有改变，但是，类提供的功能可能已经改变了

　　猴子补丁(Monkey Patch）

　　在运行时，对属性，方法，函数等进行动态替换

　　其目的往往是为了通过替换，修改来增强，扩展原有代码的能力

　　慎用！！！！！！

　　　　之前：

　　　　之后：

14、属性装饰器：

　　一般好的设计是：把实例的属性保护起来，不让外部直接访问，外部使用getter读取属性和setter方法设置属性

# 普通方式
class Person:
    def __init__(self, name, age=18):
        self.name = name
        self.__age = age

    def age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age

tom = Person('tom')
print(tom.age()) # 18
tom.set_age(20)
print(tom.age()) # 20

# 装饰器方式
class Person:
    def __init__(self, name, age=18):
        self.name = name
        self.__age = age

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, age):
        self.__age = age

    @age.deleter
    def age(self):
        print('del')

tom = Person('tom')
print(tom.age) # 18
tom.age = 30
print(tom.age) # 30

　　特别注意：使用property装饰器的时候这三个方法同名

　　　　其他写法：

　　　　还可以如下：使用了匿名函数，但是set没办法，因为匿名函数条件不能出现等号

15、对象销毁

　　类中可以定义__del__ 方法，称为析构方法（函数）

　　作用：销毁类的实例的时候调用，以释放占用的资源，其中就放些清理资源的代码，比如释放链接，关闭文件句柄

　　注意这个方法不能疫情对象的真正的销毁，只是对象销毁的时候会自动调用它.

　　使用del 语句删除实例，引用计数减1， 当引用计数为0 时，会自动调用__del__方法。

　　由于Python实现了垃圾回收机制，不能确定对象何时执行垃圾回收

　　注：由于垃圾回收 对象销毁时，才会真正清理对象，还会在回收对象之前自动调用__del__ 方法，除非你明确自己的目的，建议不要手动嗲用这个方法

16、方法重载（overload）

　　在Java，等语言中，会有重载的概念

　　所谓重载 ，就是同一个方法名，但是参数数量，类型不一样，就是同一个方法的重载。

　　Python没有重载，也不需要重载，*args可以解决多参，且强类型，动态语言，不需要指定参数类型

17、封装

　　面向对象的三要素之一，封装Encapsulation

　　封装：

　　　　将数据和操作组织到类中，即属性和方法

　　　　将数据隐藏起来，给使用者提供操作（方法）， 使用者通过操作就可以获取或者修改数据，getter和setter。

　　　　通过访问控制，暴露适当的数据和操作给用户，该隐藏的隐藏起来。