Python 面向对象

什么是类，什么是对象

类是具有相同属性和行为的事物统称，是个抽象的概念，不是真是存在的事物。
对象是实际存在的具体个体，日常能看到的东西都是对象

面向对象三大特性

• 封装
• 多态
• 继承

属性

实例属性

类外面定义实例属性： 对象名.属性名 = 值
类外面获取对象属性： 对象名.属性名
类里面获取对象属性： self.属性名
类里面定义对象属性：
使用魔法方法__init__在Python中， _ xx _()的方法叫做魔法方法，具有特殊的功能， 在特定场景中系统会自动调用，而不需手动调用。

# 定义初始化功能的函数
def __init__(self):
    # 添加实例属性
    self.width = 500
    self.height = 800

类属性

• 不需要实例化方法就能获取
• 类属性 就是给 类对象 中定义的 属性
• 通常用来记录 与这个类相关 的特征
• 类属性 不会用于记录 具体对象的特征
• 对象获取属性顺序，先获取对象内部属性，如果内部没有再获取类属性

实例私有属性&类私有属性

只有类内部才能调用，如果外部想获取私有属性值，需要通过中间值获取。
实例私有属性定义： 在实例属性前加__,如： self.__height=170
定义了私有权限的属性和方法只能在当前的类的内部使用，不能在类的外部使用，也不能继承给子类
设置私有权限的目的： 更好保护数据

方法

实例方法

def method(self,...):
　　pass

类方法&静态方法

类方法：类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。可以通过对象和类来访问。
静态方法：需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数，可以通过对象和类来访问。

• 从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；

• 实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。

• 静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类实例对象来引用

私有方法

方法名 前面 加上两个下划线 __，只能在内部调用

魔法方法

• __ new __: 在创建时自动调用，返回一个对象值
• __ init __: 初始化对象
• __ del :当删除对象时，python解释器也会默认调用__del()方法
• __ str __:当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__方法，那么就会打印从在这个方法中 return 的数据。
• __ repr __:结果和str方法类似
• 关于调用 __ str 和 repr :两种方法的时机
  使用print()时
  使用%s和f’{}'拼接对象时
  使用str(x)转换对象x时
  在上述三种场景中，会优先调用对象的__str()方法；若没有，就调用__repr__()方法；若再没有，则显示其内存地址。
  特别地，对于下面两种场景：
  用%r进行字符串拼接时
  用repr(x)转换对象x时
  则会调用这个对象的__repr__()方法；若没有，则不再看其是否有__str__()方法，而是显示其内存地址。
  Django中打印queryset时,会调用__repr__方法

self 和 cls 参数的含义

self 是对象，cls 是类

多层继承和多继承

多继承是一个类继承多个父类，多层继承是一个继承他的父类，它的父类又继承另一个类

什么是重写

子类会继承父类的方法和属性，当某些方法和属性不适用时进行重新赋值或者改写

如何调用父类被重写的方法

直接调用子类的重名方法。子类和父类具有同名属性和方法，默认使用子类的同名属性和方法。

类的mro继承顺序关系

mro顺序 ：方法解析(查找)顺序(Method Resolution Order)，通过 对象名.__mro__调用

property 属性

property属性;
a.一种用起来像实例属性一样的特殊属性，可以对应于某些方法，property的本质还是方法
1.property属性的定义和调用要注意几点：
1.定义时，在实例方法的基础上添加@property装饰器，
2.并且方法只有一个self参数
3.调用时无需括号

2.property的好处：
将一个属性的操作通过property封装起来，区别于实例方法，但其本质也是方法，
调用者用起来就跟操作普通属性一样，十分简洁

3.property有两种方式来定义property属性：
1.使用装饰器的方式定义property属性：
-@property:取得属性值，修饰的方法有且只有一个self参数；
-@方法名.setter:设置属性值，修饰的方法，只能传一个参数
-@方法名.deleter:删除属性的方法有且只有一个self参数
注意：
这种方式用起来很简洁，但要注意其中的调用原理，他是通过类对象调用
来取得属性值，然后传递给setter设置属性值，在这部分你还可以做一些身份验证
确保数据安全，删除很少使用这种方法
2.通过类属性方式定义property属性
property()这个方法里有四个参数：def init(self, fget=None, fset=None, fdel=None, doc=None)
第一个参数是方法名：获取属性值
第二个参数是方法名;设置属性值
第三个参数是方法名;删除属性值
第四个参数是字符串;描述该属性的信息，通过类名.属性名.__doc__调用

   参考代码：
    class foo():

        def __init__(self):
            self.name = "男男女女"
            self.__price = 2000
        def get_price(self):
            print("私有财产为：%d"%self.__price)

        @property
        def prop(self):
            print("私有财产为：%d" % self.__price)

    f = foo()
    #1.使用实例属性访问私有属性
    # print(f.__price)#无法访问

    #2.通过实例方法来访问私有属性,这是传统的方式
    f.get_price()

    #3.使用property访问私有属性

    f.prop

    """1.使用装饰器的方式定义property属性："""
    class foo():
        def __init__(self):
            self.__price = 2000
        """-@property:取得属性值，修饰的方法有且只有一个self参数；
            -@方法名.setter:设置属性值，修饰的方法，只能传一个参数
            -@方法名.deleter:删除属性的方法有且只有一个self参数"""

        @property#取到属性值
        def price(self):
            print("@property：取到属性值")
            return self.__price
        @price.setter#修改或者设置属性值
        def price(self,value):
            print("@price.setter:设置属性值")

            try:
                self.__price=int(value)
            except:
                print("修改不成功")

        @price.deleter#删除属性值
        def price(self):

            print("@price.deleter； 删除属性值")
            # del self.__price

        def get_price(self):
            print(self.__price)

    f = foo()

    print(f.price)
    f.price="5555"
    print(f.price)
    del f.price
    print(f.price)


    """2.通过类属性方式定义property属性"""

    class foo():

        def __init__(self):
            self.__price = 5000
        def get_price(self):
            print("取到属性值")
            return self.__price
        def set_price(self,value):
            print("修改属性名")
            try:
                self.__price=int(value)
            except:
                print("修改错误")
        def del_price(self):
            print("删除属性值")

        price = property(get_price,set_price,del_price,'使用类属性定义property')


    f = foo()
    print(f.price)
    f.price=2550
    print(f.price)
    print(foo.price.__doc__)

转载链接：https://blog.csdn.net/sinat_31907813/article/details/82729393

如何理解python一切皆对象

对象是编程语言中相对独立的实体，它可以被调用、赋值或者作为参数供函数使用。python里所有的参数都具体有这些特征

type和object区别和联系

object(常规意义上的类) 是一切类的基类,列表、字符串包括最基本的type都继承自object
列表、字符串包括最基本的type等都是type的实例

对元类的理解

type类就是一个元类，即第一列。

当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。

但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。

连接起来就是：先定义metaclass，就可以创建类，最后创建实例。

所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。

实现单例

单例模式就是确保某一个类只有一个实例存在。__new__函数在创建类时已经默认调用，在 new 函数中判断 Singleton类 是否已经实例化过，如果不是，调用父类的 new 函数创建实例；否则返回之前创建的实例
方法：

• 使用模块
• 使用装饰器
• 使用类