面向对象

目录

1. 什么是面向对象？

2. 封装，继承，多态？特性

3. 新式类&经典类

4. 静态方法，类方法，属性方法

5. 魔法方法

6. 反射

7. 单例模式

1. 什么是面向对象？

　　使用模板的思想，将世界完事万物使用对象来表示一个类型

2. 封装，继承，多态？特性

• 封装
  • 对类中属性和方法进行一种封装，隐藏了实现细节
• 继承
  • 子类继承父类后，就具有了父类的所有属性和方法，先继承，后重写
• 多态
  • 一种接口，多种表现形式
  • 中国人、和美国人都能讲话，调用中国人的类讲中文，调用美国人将英文

3. 新式类&经典类

• pythn3无论新式类还是经典类都是用 广度优先
• python2中，新式类：广度优先，经典类：深度优先

 　　

class D:
    def talk(self):
        print('D')

class B(D):
    pass
    # def talk(self):
    #     print('B')

class C(D):
    pass
    def talk(self):
        print('C')

class A(B,C):
    pass
    # def talk(self):
    #     print('A')

a = A()
a.talk()

4. 静态方法，类方法，属性方法

　　静态方法

　　　　特点：名义上归类管理，实际上不能访问类或者变量中的任意属性或者方法

　　　　作用：让我们代码清晰，更好管理

　　　　调用方式: 既可以被类直接调用，也可以通过实例调用

1. 作用：静态方法可以更好的组织代码，防止代码变大后变得比较混乱。  
2. 特性:  静态方法只是名义上归类管理，实际上在静态方法里访问不了类或则实例中的任何属性
3. 静态方法使用场景：
　　1）我们要写一个只在类中运行而不在实例中运行的方法.
　　2）经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法.
　　3）比如更改环境变量或者修改其他类的属性等能用到静态方法.
　　4）这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码，造成维护困难.
4. 调用方式:  既可以被类直接调用，也可以通过实例调用

class Dog(object):
    def __init__(self,name):
        self.name = name
    @staticmethod
    def eat():
        print("I am a static method")
d = Dog("ChenRonghua")
d.eat()                     #方法1：使用实例调用
Dog.eat()                   #方法2：使用类直接调用

　　类方法

　　　　作用：无需实例化直接被类调用

　　　　特性: 类方法只能访问类变量，不能访问实例变量

　　　　类方法使用场景：当我们还未创建实例，但是需要调用类中的方法

　　　　调用方式: 既可以被类直接调用，也可以通过实例调用

1. 作用：无需实例化直接被类调用  
2. 特性:  类方法只能访问类变量，不能访问实例变量
3. 类方法使用场景： 当我们还未创建实例，但是需要调用类中的方法
4. 调用方式:  既可以被类直接调用，也可以通过实例调用

class Dog(object):
    name = '类变量' #在这里如果不定义类变量仅定义实例变量依然报错
    def __init__(self,name):
        self.name = '实例变量'
        self.name = name
    @classmethod
    def eat(self,food):
        print("%s is eating %s"%(self.name,food))
Dog.eat('baozi')                   #方法1：使用类直接调用
d = Dog("ChenRonghua")          
d.eat("包子")                      #方法2：使用实例d调用

　　属性方法

　　　　属性方法把一个方法变成一个属性，隐藏了实现细节,调用时不必加括号直接d.eat即可调用self.eat()方法

作用：属性方法把一个方法变成一个属性，隐藏了实现细节,调用时不必加括号直接d.eat即可调用self.eat()方法

class Dog(object):
    def __init__(self, name):
        self.name = name

    @property
    def eat(self):
        print(" %s is eating" % self.name)
d = Dog("ChenRonghua")
d.eat()
# 调用会出以下错误， 说NoneType is not callable, 因为eat此时已经变成一个静态属性了， 
# 不是方法了， 想调用已经不需要加()号了，直接d.eat就可以了

 5. 魔法方法

# 1. type生成类调用顺序
 __new__  :  先于__init__方法，每生成一个实例执行一次，__new__ 类方法创建实例对象
 __init__   :  __init__方法每生成一个实例就会执行一次，初始化实例对象
__call__  :   后与__init__方法，C()() 使用类再加一个括号调用， C为类名称
__del__   :   析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

# 2. 类实例化时魔法方法调用顺序
class Student(object):
    def __new__(cls, *args, **kwargs):
        print('__new__')
        return object.__new__(cls)   # 必须返回父类的__new__方法，否则不不执行__init__方法，无法创建实例


 def __init__(self,name):
        print('__init__')
        self.name = name

    def __str__(self):                # 作用：打印实例时显示指定字符串，而不是内存地址
        print('__str__')
        return self.name

    def __call__(self, *args, **kwargs):        # 当执行C()(*args) 或者 s1(*args) 就会执行__call__
        print('__call__',*args)

    def __del__(self):                # 作用：清除无用的实例对内存的暂用
        print('__del__')

#1、实例化时机会执行__new__、__init__
s1 = Student('tom')

#2、执行 实例()  就会执行__call__ 方法，并将参数传递给__call__函数
s1('call01')

#3、当打印实例时就会执行 __str__ 方法下返回的字符串（默认返回的实例地址）
print(s1)

#4、析构方法：当删除实例时就会调用 __del__ 方法
del s1
# 析构方法作用：在程序结束后会自动执行析构方法删除所有实例
# 但是在程序运行时有很多实例是无用的，但是python内存回收机制却不会自动删除他们，这样就浪费内存
# 我们可以执行 del s1 ，那么在程序运行时，python内存回收机制会检测到这些实例时无用的，才会删除
# 其实我们执行del s1，并没有回收内存，只不过是摘除门牌号，python内存回收机制发现没有门牌号后会自动回收内存

 　　__new__

　　　　产生一个实例

　　__init__

　　　　产生一个对象

 　　__del__

 　　　　析构方法，删除无用的内存对象（当程序结束时会自动执行析构方法）

 　

6. 反射

　　hasattr: 判断当前类是否有这个方法

　　getattr: 通过字符串反射出这个方法的内存地址

# 2. getattr(obj,name_str) 根据字符串去获取obj对象里的对应的方法的内存地址

class Dog(object):
    def eat(self):
        print("eat method!!!")
d = Dog()

if hasattr(d,'eat'):          # hasattr判断实例是否有eat方法
    func = getattr(d, 'eat')  # getattr获取实例d的eat方法内存地址
    func()                    # 执行实例d的eat方法
#运行结果：  eat method!!!

　　setattr：将当前类添加一个方法

　　delatrr: 删除实例属性

7. 单例模式

　　单例模式：永远用一个对象得实例，避免新建太多实例浪费资源

　　实质：使用__new__方法新建类对象时先判断是否已经建立过，如果建过就使用已有的对象

　　使用场景：如果每个对象内部封装的值都相同就可以用单例模式

class Foo(object):
   instance = None
   def __init__(self):
      self.name = 'alex'

   def __new__(cls, *args, **kwargs):
      if Foo.instance:
         return Foo.instance
      else:
         Foo.instance = object.__new__(cls,*args,**kwargs)
         return Foo.instance

obj1 = Foo()       # obj1和obj2获取的就是__new__方法返回的内容
obj2 = Foo()
print(obj1,obj2)   # 运行结果： <__main__.Foo object at 0x00D3B450>    <__main__.Foo object at 0x00D3B450>

# 运行结果说明：
# 这可以看到我们新建的两个Foo()对象内存地址相同，说明使用的•同一个类，没有重复建立类