标签：
前面一系列博文讲解的都是面向过程的编程，如今是时候来一波面向对象的讲解了
面向对象编程是一种编程方式，使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。类就是一个模板，模板里可以包含多个方法（函数），方法里实现各种各样的功能，，对象则是根据模板创建的实例，通过实例，对象可以执行类中的方法，每个对象都拥有相同的方法，但各自的数据可能不同。
在Python中，定义类是通过class关键字，class后面紧接着是类名，类名通常是大写开头的单词，紧接着是(‘要继承的类名‘)，表示该类是从哪个类继承下来的，通常如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类，也可以不写。
class MyClass(): # 创建类
def func(self): # 定义方法
pass
obj1=MyClass() # 根据MyClass创建对象
类中定义方法的时候，和以前定义函数一样，都是用来实现某种功能的，不过定义方法的时候必须传至少一个参数（self），代表创建的对象，而函数则不需要，下面来看一下self具体指的什么。
class MyClass():
def func(self,str):
print(self,str)
def func1(self,str):
pass
obj1=MyClass() # self 哪个对象调用的，self就是那个对象 obi <====> self
print(obj1) # <__main__.MyClass object at 0x000002C2119AD4A8>
obj1.func(‘jason‘) # <__main__.MyClass object at 0x000002C2119AD4A8>
从上面打印出的数据可以看出，创建出来的obj1对象的地址值和func方法里面self的地址值一样，两者一致，说明self就是指代创建的对象，这里读者一定需要理解self指的是什么。
面向对象有3大特性，首先我们来说第一个特性，封装，封装一般是通过在类中封装数据，而通过对象或者self获取。和其他面向对象的语言类似，也是通过构造函数来进行数据封装。下面来看一下代码。
class A:
def __init__(self,name): # 构造函数，初始化数据，
self.name=name # 封装数据
def f1(self):
print(self.name) # 通过self获取封装的数据
a=A(‘jason‘)
a.f1() #通过对象获取封装数据
还有一种封装的方式，使用私用的属性来封装数据，看一下具体的用法，
class A:
name=‘Jason‘
__age=18 # 私有静态字段，
def __init__(self):
self.__like=‘soccer‘ # 私有普通字段
self.hobby=‘kkkk‘
def f1(self):
print(self.__age) # 私有静态字段,私有普通字段只能被类中的方法调用
print(self.__like)
# A.__age # 外部获取不到私有静态字段,数据被封装起来
a=A() # soccer
a.f1() # 18
print(a.hobby)
Python里面的继承可以多继承，通过继承，可以获得父类的功能，继承的时候，如果父类中有重复的方法，优先找自己，如果有下面关系，D继承B，E继承C，F继承D，E，则查找顺序，D->B->E->C，如果有下面关系，B继承A，C继承A，D继承B，E继承C，F继承D，E，则查找顺序，D->B->E->C-A，下面来看一下用法
class A:
def f(self):
print(‘a‘)
class B:
def f(self):
print(‘b‘)
def f1(self):
print(‘bbbb‘)
class C(A,B):
def f1(self):
print(‘c‘)
cc=C()
cc.f() # a
cc.f1() # c
#下面的是难点重点
class A:
def bar(self):
print(‘bar‘)
self.f1()
class B(A):
def f1(self):
print(‘b‘)
class C():
def f1(self):
print(‘c‘)
class D(B):
def f1(self):
print(‘d‘)
class E(C,D):
pass
d=D()
d.bar() # d.bar().f1() 去哪里找f1？
除了继承方法，还可以继承父类的构造函数
# 继承构造方法
class A:
def __init__(self):
self.name=‘jason‘
class B(A):
def __init__(self):
self.age=‘16‘
super(B,self).__init__()
# A.__init__(self) #另一种继承构造函数的方法
d=B()
python本身就是支持多态的，所以在Python面向对象里面讨论多态并没有什么意义，这里也就不多讲了
类的成员可以分为三大类：字段、方法和属性，下面从代码来看一下用法
class A:
country = ‘China‘ # 静态字段，保存在类中 节省内存
def __init__(self, name):
self.name = name # 普通字段，保存在对象中
def show(self): # 普通方法，保存在类中，对象通过类对象指针使用
print(‘普通方法‘)
return self.name
@staticmethod # 静态方法，保存在类中
def f1(): # 没有 self 参数
print(‘静态方法‘)
@classmethod # 类方法 相当于静态方法加了一个类名参数
def f2(cls): # 将当前类名当作参数传进去
print(‘类方法‘)
@property # 属性或者叫特性，将普通方法伪装成字段，但是不能传入第二个参数
def f3(self):
print(‘属性‘)
return self.name
@f3.setter # 设置属性
def f3(self,value):
print(value)
self.name= value
a = A(‘jason‘)
print(hasattr(A, ‘name‘)) # False
print(hasattr(a, ‘name‘)) # True
print(hasattr(a, ‘show‘)) # True
print(hasattr(A, ‘country‘)) # True
print(hasattr(a, ‘country‘)) # True
# 优先，自己先去访问自己的成员除了类中的方法
# 用下面的方式去操作
# 通过类去访问的有：静态字段，静态方法，类方法(静态方法加一个类名参数)
# 通过对象访问的有：普通字段，普通方法
# 有 self，对象调用
# 无 self，类调用
A.f1() # 静态方法
a.show() # 普通方法
A.f2() # 类方法
a.f3 # 属性，获取属性值 执行的时候不用加括号，和对象调用普通字段类似
a.f3=‘kobe‘ # 设置属性值，
print(A.country)
print(a.name)
# 私有的只能在类中调用，不能再外部调用
class A:
name=‘Jason‘
__age=18 # 私有静态字段
def __init__(self):
self.__like=‘soccer‘ # 私有普通字段
self.hobby=‘kkkk‘
def f1(self):
print(self.__age) # 私有静态字段,私有普通字段只能被类中的方法调用
print(self.__like)
# A.__age # 外部获取不到私有静态字段
a=A() # soccer
a.f1()
特殊成员，也不多说了，直接上代码了
class A:
def __init__(self):
print(‘init‘)
self.name=‘jason‘
def __str__(self):
return ‘........‘
def __call__(self, *args, **kwargs):
print(‘call‘)
return 1
def __getitem__(self, item):
print(item,type(item))
def __setitem__(self, key, value):
print(key,value)
def __delitem__(self, key):
print(key)
def __iter__(self):
yield 1
yield 2
a=A() # init 类后面加个括号执行 __init__
a() # call 对象后面加个括号执行 __call__
print(a) # 执行 __str__方法
k=A()() # init call k=1
a[‘dddd‘] # 执行 __getitem__ <class ‘str‘>
a[‘name‘]=‘jason‘ # 执行 __setitem__
del a[‘name‘] # 执行 __delitem__
a[1:3] # py2__getslice__,py3执行 __getitem__ <class ‘slice‘>
a[1:3]=[1,2] # py2__setslice__,py3执行 __setitem__
del a[1:3] # py2__detslice__,py3执行 __delitem__
print(a.__dict__) # {‘name‘: ‘jason‘} 对象里面的字段
print(A.__dict__) # 类里面的字段
for i in a: # 执行__iter__
print(i)
在Python中一切事物都是对象，类也是对象，那么问题来了，类是如何创建的了，类的定义是运行时动态创建的，而创建class的方法就是使用type()函数，通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。type可以接受一个类的描述作为参数，然后返回一个类可以像这样使用：type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值））
# 通过type自定义类
def f1(self):
print(self.name)
MyClass=type(‘MyClass‘,(),{‘name‘:‘jason‘,‘f1‘:f1})
print(MyClass,type(MyClass)) # <class ‘__main__.MyClass‘> ,<class ‘type‘>
print(MyClass.name) # jason
my=MyClass()
print(my.__class__) # <class ‘__main__.MyClass‘>
print(my) # <__main__.MyClass object at 0x000001F3013751D0>
my.f1() # jason
说完了type，那么type和元类到底是什么关系了，type实际上是一个元类。type就是Python在背后用来创建所有类的元类，除了使用type()动态创建类以外，要控制类的创建行为就要用到metaclass（元类），我们想创建出类，那就根据metaclass创建出类，所以：先定义metaclass，然后创建类。连接起来就是：先定义metaclass，就可以创建类，最后创建实例。元类的一般作用是拦截类的创建，修改类， 返回修改之后的类。下面看一下代码的使用
# 用函数实现
# def upper_attr(future_class_name, future_class_parents, future_class_attrs):
# attrs=((name, value) for name,value in future_class_attrs.items() if not name.startswith(‘__‘))
# uppercase_attr=dict((name.upper(), value) for name,value in attrs)
# return type(future_class_name,future_class_parents,uppercase_attr())
#
# class A():
# # __metaclass__ = upper_attr
# country="China"
# def __init__(self):
# self.name=‘jason‘
#
# print(hasattr(A,‘country‘))
# print(hasattr(A,‘COUNTRY‘))
‘‘‘
__new__()方法接收到的参数依次是：
当前准备创建的类的对象；
类的名字；
类继承的父类集合；
类的方法集合。
__new__ 是在__init__之前被调用的特殊方法
__new__是用来创建对象并返回之的方法
而__init__只是用来将传入的参数初始化给对象
你很少用到__new__，除非你希望能够控制对象的创建
这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__
如果你希望的话，你也可以在__init__中做些事情
还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用
‘‘‘
class UppMetaclass(type):
def __new__(cls, name,base,attrs):
uppattrs = dict((k.upper(),v)for k,v in attrs.items() if not k.startswith(‘__‘))
# return type.__new__(cls, name, base, uppattrs)
return super(UppMetaclass, cls).__new__(cls, name, base, uppattrs)
class A(metaclass=UppMetaclass):
# __metaclass__ = UppMetaclass
country="China"
def __init__(self):
self.name=‘jason‘
print(hasattr(A,‘country‘))
print(hasattr(A,‘COUNTRY‘))
print(A.COUNTRY)
单例，顾名思义单个实例，单利模式存在的目的是保证当前内存中仅存在单个实例，避免内存浪费，下面直接看一下怎么实现单例
class Instance: # 方法一
__instance=None # 私有静态字段
def __init__(self):
self.name=‘jason‘
self.passwd=‘kkkkk‘
@staticmethod
def get_instance():
if not Instance.__instance: # 如果私有静态字段为空的话，创建一个实例
Instance.__instance = Instance()
return Instance.__instance # 不为空的话，直接返回一个实例
obj1=Instance.get_instance() # 执行静态方法，创建一个实例赋值给obj1
obj2=Instance.get_instance() # 执行静态方法，将私有静态字段保存的对象赋值给obj2
print(obj1) # <__main__.Instance object at 0x0000021AEDF56048>
print(obj2) # <__main__.Instance object at 0x0000021AEDF56048>
class Singleton(): # 方法二
def __new__(cls, *args, **kwargs):
if not hasattr(cls,‘_instance‘):
cls._instance=super(Singleton,cls).__new__(cls,*args, **kwargs)
return cls._instance
class A(Singleton):
pass
a=A()
b=A()
print(a is b)
class Singleton(type): # 方法三
def __call__(cls, *args, **kwargs):
if not hasattr(cls, ‘_instance‘):
cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instance
class A(metaclass=Singleton):
# __metaclass__ = Singleton
pass
a = A()
b = A()
print(a is b)
属性的另一种表达方式：
class A:
def __init__(self):
self.mylist = [1, 2, 3, 4]
def getmylist(self):
print(self.mylist)
def setmylist(self, value):
self.mylist.append(value)
print(self.mylist)
def delmylist(self):
if len(self.mylist) > 0:
self.mylist.pop()
print(self.mylist)
my_pro_list = property(getmylist, setmylist, delmylist, ‘Property‘)
a = A()
a.my_pro_list
a.my_pro_list = 7
del a.my_pro_list
‘‘‘
[1, 2, 3, 4]
[1, 2, 3, 4, 7]
[1, 2, 3, 4]
‘‘‘
单利补充：
class SingMetaclass(type):
def __call__(self, *args, **kwargs):
if not hasattr(self, ‘instance‘):
# self.instance = super(SingMetaclass, cls).__new__(cls, name, base, attrs)
# self.instance = self.__new__(self, *args, **kwargs) # 下面这种方式也行，但是没有注释掉的好理解
self.instance = super().__call__(*args, **kwargs)
return self.instance
class A(metaclass=SingMetaclass):
pass
py27继承顺序，有一种情况和py3不一样，如下图，其中bar没有继承object（经典类）、深度优先，其他情况一样，都是广度优先
# py27
class bar():
def f1(self):
print(‘bar‘)
class A(bar):
def f(self):
print(‘a‘)
class C(A):
def f(self):
print(‘c‘)
class B(bar):
def f1(self):
print(‘b‘)
class D(B):
def f1(self):
print(‘d‘)
class E(C,D):
def f(self):
print(‘e‘)
e = E()
e.f1()
抽象类和抽象方法：
from abc import ABCMeta
from abc import abstractclassmethod
class Absclass(metaclass=ABCMeta): # 抽象类+抽象方法，类似接口，约束类
@abstractclassmethod
def f1(self): pass
@abstractclassmethod
def f2(self): pass
class B(Absclass): # B 需要完全实现抽象类中的抽象方法
def f1(self): pass
def f2(self): pass # 如果 B 类中没有完全实现 Absclass 类中的方法话，可以编译过，但是执行的话会报错
def f3(self): pass
c = B()
标签：
原文地址：http://www.cnblogs.com/Wxtrkbc/p/5550673.html
