python面向对象

一.面向对象三大特性

1.封装

使用构造方法将内容封装到内容中,然后通过对象直接或通过self间接获取被封装的内容

2.继承

将多个类共有的方法提取到父类(基类)中,子类(派生类)仅需继承而不需要一一实现.

支持多继承.python3中定义的都是新式类,python2中是经典类

python继承顺序遵循3c算法

class D(object):
    def bar(self):
        print 'D.bar'

class C(D):
    def bar(self):
        print 'C.bar'

class B(D):
    def bar(self):
        print 'B.bar'

class A(B, C):
    def bar(self):
        print 'A.bar'
a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

新式类多继承

3.多态

多种状态,多种形态.

二.方法

方法包括:普通方法,静态方法和类方法.三种方法在内存中都归属于类,区别在于调用方式的不同.

普通方法:由对象调用;至少一个self参数,执行普通方法时,自动将调用方法的对象赋值给self.

类方法:由类调用,至少一个cls参数,执行方法时,自动将调用该方法的类赋值给cls.

静态方法:由类调用.无默认参数.

相同点:对于所有的方法而言,均属于类(非对象)中,所以,在内存中也只保存一份.

不同点:方法调用者不同,调用方法时自动传入的参数不同.

三.属性

在定义时候,在普通方法的基础上添加@property;属性仅有一个self参数

class Foo:
    def func(self):
        print(123)
    @property              
    def prop(self):       #定义属性
        print(666)
obj = Foo()
obj.func()
obj.prop

.

在调用时,无需括号 .方法:Foo_obj.func()

　　　　　　　　　　属性:Foo_obj.prop

属性存在的意义是:访问属性时可以制造和访问字段完全相同的假象.,属性由方法变种而来,如果python中没有属性,方法完全可以代替其功能.

四.类成员的修饰符

公有成员:在任何地方都可以访问

私有成员:只能在类的内部才可以访问

五.主动调用其他类的成员

方式一:

class Base(object):
     def f1(self):
            print('酸甜')
class Foo(object):
     def f1(self):
            print('麻辣')
            Base.f1(self)
obj = Foo()
obj.f1()  #打印 麻辣,酸甜

方式二:

class Foo(object):
    def f1(self):
         super().f1()
         print('suantian')
class Bar(object):
     def f1(self):
            print('mala')
class Info(Foo,Bar):
      pass
obj = Info()
obj.f1()           #打印  mala ,suantian

六.特殊成员

1.类名() 自动执行  __init__

2.对象() 自动执行 __call__

3.对象['xx']      自动执行__getitem__

4.对象['xx'] = 11 自动执行__setitem__

5.del 对象[xx]  自动执行__delitem__

6.对象+对象 自动执行 __add__

7.with 对象  自动执行__enter__ (开始) /     __exit__(结束)

8.真正 的构造方法

class Foo(object):
    def __init__(self, a1, a2):     # 初始化方法
        """
        为空对象进行数据初始化
        :param a1:
        :param a2:
        """
        self.a1 = a1
        self.a2 = a2

    def __new__(cls, *args, **kwargs): # 构造方法
        """
        创建一个空对象
        :param args:
        :param kwargs:
        :return:
        """
        return object.__new__(cls) # Python内部创建一个当前类的对象(初创时内部是空的.).

obj1 = Foo(1,2)
print(obj1)

obj2 = Foo(11,12)
print(obj2)

 9.__dict__

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        pass
obj1 = Foo('liu','18')
obj2 = Foo('wu','17')        #打印{'name': 'liu', 'age': '18'}                                            
                                      #打印{'name': 'wu', 'age': '17'}
print(obj1.__dict__)          
print(obj2.__dict__)                                                                                              

10.__iter__

如果想要把不可迭代对象转化为可迭代对象:1,在类中定义__iter__方法,2.iter内部返回一个迭代器

11.issubclass()

class Foo:
    pass
class Base(Foo):
    pass
class Bar(Base):
    pass
print(issubclass(Bar,Foo))  #打印True  判断第一个元素是否是第二个元素的子子孙孙类

12.type()   获取当前元素由哪个类创建

class Foo:
    pass
obj = Foo()
print(type(obj))    #打印<class '__main__.Foo'>

13.isinstance()   检查第一个参数(对象)是否是第二个参数(类及父类)的实例

class Base():
   pass
class Foo(Base):
  pass
obj1 = Foo()
print(isinstance(obj1,Foo))  #打印True
print(isinstance(obj1,Base))  #打印True
obj2 = Base():
print(isinstance(obj2,Foo))   #打印False
print(isinstance(obj1,Base))   #打印True

*区分:给一个参数,判断对象是不是由某一个指定类? type   --->type(obj) == Foo

          给一个参数,判断对象是不是由某一个指定类或其父类?isinstanace---->isinstance(obj,Foo)

判断一个元素是函数还是方法:

from types import MethodType,FunctionType
def check(arg):
   if isinstance(arg,MethodType):
        print('方法')
   if isinstance(arg,FunctionType)
        print('函数')

七.反射

python面向对象中的反射,通过字符串的形式操作对象相关的属性.python中的一切事物皆是对象(都可以使用反射)

四个可以实现自省的函数

hasattr     

getattr

setattr

delattr