面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。
而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
面向对象的编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
·class 是关键字
·创建对象后面要加括号
面向对象举例
class add: def foo(self, a, b):
print("%s" % (a + b))
return 222222 obj = add()
c = obj.foo(1, 2)
print(c) class Bar: def foo(self, arg):
print(self, self.name, self.age, self.gender, arg) z = Bar()
z.name = "alex"
z.age = 84
z.gender = "zhong"
z.foo(666) z1 = Bar()
z1.name = "eric"
z1.age = 73
z1.gender = "nv"
z1.foo(699999)
面向对象三大特性
1.封装
封装就是把内容封到某个地方，供调用时使用
如例子
class Person:
def __init__(self, name, age):
self.n = name
self.a = age def show(self):
print("%s -%s" % (self.n, self.a))hu = Person("huxianglin", 25) # 创建对象
hu.show()liu = Person("dadd", 55) # 创建对象
liu.show()
self 是一个形式参数，当执行 hu = Person(“huxianglin”, 25)时，self 相当于 hu
self.name 这种形式叫做实例属性
当对象被创建时，先去寻找class中的__init__中的内容，存在则执行其中的内容，不存在则不执行。
继承
子类可以继承父类里面的各个方法，可以在子类中添加新的方法，或者用相同的函数名重写父类中用不到的方法。
class 子类(父类)：
class F:
def f1(self, b):
print("F.f1", b) def f2(self):
print("F.f2") class S(F): def s1(self):
print("S.s1") def f2(self):
super(S, self).f2()
print("S.f2")
F.f2(self) obj = S() obj.s1()
obj.f1(2)
obj.f2()
python可以继承多个父类，当调用一个方法时，先在子类中寻找，找不到则按顺序从左到右在父类中寻找。__init__也是如此。
继承的顺序：python3里面都是新式类，采用了C3算法。
先采用深度优先，当出现了一个交叉点时，则不在此点中寻找，而是重走交叉的另一条路，走到此点。
如图，E继承D,C
找寻顺序为D→B1→B2→B→C→A
若在运行时，父类中出现了新的方法，则从方法定义的类里重找，无论是多少级的父类。
class BaseRequest:
pass class RequestHandler(BaseRequest): def sever_forever(self): print("RequestHandler.sever_forever")
self.process_request() # 重新回到Son里寻找，最后运行Minx里的procexx_request() def process_request(self):
print("RequestHandler.process_request") class Minx: def process_request(self):
print("minx.process_request") class Son(Minx, RequestHandler):
pass obj = Son()
obj.sever_forever()
多态
自带多态
进阶
类的成员
类的成员分为三大类：字段、方法和属性。
其中静态字段叫做类属性。
字段包括：普通字段和静态字段。他们在定义和使用中有所区别，其最本质的区别是内存中保存的位置不同。
·普通字段属于对象
·静态字段属于类
class Province: # 静态字段,保存在类中
country ＝ '中国' def __init__(self, name): # 普通字段，保存在对象中
self.name = name # 直接访问普通字段 ， 通过对象访问
obj = Province('河北省')
print(obj.name) # 直接访问静态字段 ，通过类访问， 也可通过对象访问
Province.country 字段的定义和使用
普通字段在__init__下，静态字段不属于方法。
·静态字段在内存中值保存一份
·普通字段在每个对象中都要保存一份
应用场景：通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段。
方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都属于类，区别在于调用方式不同。
·普通方法：由对象调用，至少一个self参数，执行普通方法时，自动将调用该方法的对象赋值给self;
·类方法：由类调用，至少一个cls参数，执行类方法时，自动将调用该方法的类复制给cls；
·静态方法：由类调用，无默认参数
class Foo: def __init__(self, name):
self.name = name def ord_func(self):
""" 定义普通方法，至少有一个self参数 """ # print self.name
print('普通方法') @classmethod
def class_func(cls):
""" 定义类方法，至少有一个cls参数
cls是类名，保存在类中
""" print('类方法') @staticmethod
def static_func():
""" 定义静态方法 ，无默认参数""" print('静态方法') # 调用普通方法
f = Foo()
f.ord_func() # 调用类方法
Foo.class_func() # 调用静态方法
Foo.static_func() 方法的定义和使用
对于所有的方法而言，均属于类中，在内存中也只保存一份。
属性
属性是普通方法的变种。
1.属性的基本使用
# ############### 定义 ###############
class Foo: def func(self):
pass # 定义属性
@property
def prop(self):
pass
# ############### 调用 ###############
foo_obj = Foo() foo_obj.func()
foo_obj.prop #调用属性 属性的定义和使用
定义时，在普通方法上添加@property装饰器
定义时，属性仅有一个self参数
调用时，无需括号
方法： foo_obj.fun()
属性： foo_obj.prop
class Pergination:
def __init__(self, current_page):
try:
p1 = int(current_page)
except Exception as e:
p1 = 1 self.page = p1 @property
def start(self):
val = (self.page - 1) * 10
return val @property
def end(self):
val2 = self.page * 10
return val2 li = []
for i in range(1000):
li.append(i) while True:
p = input("请输入要查看的页码:")
obj = Pergination(p)
print(li[obj.start: obj.end])
2.属性的两种定义方式
装饰器：在方法上应用装饰器
静态字段 ： 在类定义值为property对象的静态字段
装饰器方式：在类的普通方法上应用@property装饰器
class Goods(object): def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8 @property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price @price.setter
def price(self, value):
self.original_price = value @price.deltter
def price(self, value):
del self.original_price obj = Goods()
obj.price # 获取商品价格
obj.price = 200 # 修改商品原价
del obj.price # 删除商品原价 # 与删除操作无关，只对应@price.deltter
静态字段方式，创建值为property的对象的静态字段
class Foo: def get_bar(self):
return 'wupeiqi' BAR = property(get_bar) obj = Foo()
reuslt = obj.BAR # 自动调用get_bar方法，并获取方法的返回值
print(reuslt)
property的构造方法中有个四个参数
- 第一个参数是方法名，调用
对象.属性时自动触发执行方法 - 第二个参数是方法名，调用
对象.属性 ＝ XXX时自动触发执行方法 - 第三个参数是方法名，调用
del 对象.属性时自动触发执行方法 - 第四个参数是字符串，调用
对象.属性.__doc__，此参数是该属性的描述信息
class Foo： def get_bar(self):
return 'wupeiqi' # *必须两个参数
def set_bar(self, value):
return return 'set value' + value def del_bar(self):
return 'wupeiqi' BAR ＝ property(get_bar, set_bar, del_bar, 'description...') obj = Foo() obj.BAR # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
del Foo.BAR # 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__ # 自动获取第四个参数中设置的值：description...
成员修饰符
前面带两个_的为私有成员，外部无法直接访问
class Foo: def __init__(self, name, age):
self.name = name
# self.age = age
self.__age = age # 私有，外部无法直接访问 def show(self):
return self.__age obj = Foo('alex', 19)
print(obj.name)
# obj.age
# print(obj.__age)
ret = obj.show()
print(ret)
class Foo:
__v = '' def __init__(self):
pass
def show(self):
return Foo.__v
@staticmethod
def stat():
return Foo.__v
# print(Foo.__v)
# ret = Foo().show()
# print(ret) ret = Foo.stat()
print(ret)
2
class Foo:
def __f1(self):
return 123 def f2(self):
r = self.__f1()
return r obj = Foo()
ret = obj.f2()
print(ret)
3
类的特殊成员
1.__init__
构造方法，创建对象时自动执行
2.__del__
析构方法，当对象在内存中被释放时自动执行
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo: def __del__(self):
pass
__del__
3.__call__
对象后面加括号触发执行
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo: def __init__(self):
pass def __call__(self, *args, **kwargs): print '__call__' obj = Foo() # 执行 __init__
obj() # 执行 __call__
__call__
class Entity: def __init__(self, size, x, y):
self.size = size
self.x = x
self.y = y
print(self.x, self.y) def __call__(self, x, y):
self.x, self.y = x, y
obj = Entity(6, 8, 9) obj(10, 19)
print(obj.x, obj.y)
# 10 19
# x和y的值改变了
应用
4.__int__、__str__
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class Foo: def __init__(self,n,a):
self.name =n
self.age =a def __str__(self):
return '%s-%s' %(self.name,self.age,) obj = Foo('alex', 18)
print(obj) #print(str(obj)) str(obj) obj中__str__，并获取其返回值
__str__
int,对象，自动执行对象的 __int__方法，并将返回值赋值给int对象
class Foo: def __init__(self):
pass def __int__(self):
return 1111 def __str__(self):
return 'alex' obj = Foo()
print(obj, type(obj)) # int,对象，自动执行对象的 __int__方法，并将返回值赋值给int对象
r = int(obj)
print(r)
i = str(obj)
print(i)
"""
输出为
alex <class '__main__.Foo'>
1111
alex
"""
__int__
5.__add__
两个对象相加时，自动执行第一个对象的的 __add__方法，并且将第二个对象当作参数传递进入
class Foo: def __init__(self, name, age):
self.name = name
self.age = age def __add__(self, other):
# self = obj1 (alex,19)
# other = obj2(eric,66)
# return self.age + other.age
#return Foo('tt',99)
return Foo(self.name, other.age) # def __del__(self):
# print('析构方法') # 对象被销毁（）时，自动执行 obj1 = Foo('alex', 19)
obj2 = Foo('eirc', 66) r = obj1 + obj2
# 两个对象相加时，自动执行第一个对象的的 __add__方法，并且将第二个对象当作参数传递进入
print(r, type(r))
print(r.name, r.age)
'''
输出为
<__main__.Foo object at 0x000001F81BD29390> <class '__main__.Foo'>
alex 66
'''
__add__
6.__dict__
类的普通字段属于对象；类中的静态字段和方法等属于类
将对象中所封装的元素通过字典的形式返回
class Province: country = 'China' def __init__(self, name, count):
self.name = name
self.count = count def func(self, *args, **kwargs):
print('func') # 获取类的成员，即：静态字段、方法、
print(Province.__dict__)
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None} obj1 = Province('HeBei',10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'} obj2 = Province('HeNan', 3888)
print(obj2.__dict__)
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}
__dict__
7.__getitem__、__setitem__、__delitem__
用于索引操作，如字典、列表
class Foo(object):
def __getitem__(self, key):
print('__getitem__', key) def __setitem__(self, key, value):
print('__setitem__', key, value) def __delitem__(self, key):
print('__delitem__', key) obj = Foo() result = obj[0] # 自动触发执行 __getitem__
obj[1] = 'wupeiqi' # 自动触发执行 __setitem__
del obj[2] # 自动触发执行 __delitem__
class Foo: def __init__(self, name,age):
self.name = name
self.age = age def __getitem__(self, item):
# return item+10
# 如果item是基本类型：int，str，索引获取
# slice对象的话，切片
if type(item) == slice:
print('调用这希望内部做切片处理')
else:
print(item.start)
print(item.stop)
print(item.step)
print('调用这希望内部做索引处理') def __setitem__(self, key, value):
print(key, value) def __delitem__(self, key):
print(key) li = Foo('alex', 18)
# li[123]
li[1:4:2] li[1:3] = [11, 22] del li[1: 3]
'''
输出为
调用这希望内部做切片处理
slice(1, 3, None) [11, 22]
slice(1, 3, None)
'''
2
8.__iter__
如果类中有 __iter__ 方法，对象=》可迭代对象
对象.__iter__() 的返回值： 迭代器
for 循环，迭代器，next
for 循环，可迭代对象，对象.__iter__()，迭代器，next
1、执行li对象的类F类中的 __iter__方法，并获取其返回值
2、循环上一步中返回的对象
元类
a. Python中一切事物都是对象
b.
class Foo:
pass
obj = Foo()
# obj是对象，Foo类
# Foo类也是一个对象，type的对象
c.
类都是type类的对象 type(..)
“对象”都是以类的对象 类()
创建类的另一种方法：通过type的构造函数
def func(self):
print('hello wupeiqi') Foo = type('Foo', (object,), {'func': func})
# type第一个参数：类名
# type第二个参数：当前类的基类
# type第三个参数：类的成员
a = Foo()
a.func()
类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。
class MyType(type): def __init__(self, what, bases=None, dict=None):
super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs):
obj = self.__new__(self, *args, **kwargs) self.__init__(obj)class Foo: __metaclass__ = MyType def __init__(self, name):
self.name = name def __new__(cls, *args, **kwargs):
return "对象"# 第一阶段：解释器从上到下执行代码创建Foo类
# 第二阶段：通过Foo类创建obj对象
obj = Foo("xiaoming") # Foo由MyType创建，所以，Foo()先执行MyType()中的__call__
通过字符串操作对象中的成员getattr(),hasattr(),setattr(),delattr()
hasattr(object, name)
判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
name要加引号
>>> class test():
... name="xiaohua"
... def run(self):
... return "HelloWord"
...
>>> t=test()
>>> hasattr(t, "name") #判断对象有name属性
True
>>> hasattr(t, "run") #判断对象有run方法
True
>>>
getattr(object, name[, default])
获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。
需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，
可以在后面添加一对括号。
>>> class test():
... name="xiaohua"
... def run(self):
... return "HelloWord"
...
>>> t=test()
>>> getattr(t, "name") #获取name属性，存在就打印出来。
'xiaohua'
>>> getattr(t, "run") #获取run方法，存在就打印出方法的内存地址。
<bound method test.run of <__main__.test instance at 0x0269C878>>
>>> getattr(t, "run")() #获取run方法，后面加括号可以将这个方法运行。
'HelloWord'
>>> getattr(t, "age") #获取一个不存在的属性。
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: test instance has no attribute 'age'
>>> getattr(t, "age","") #若属性不存在，返回一个默认值。
''
>>>
setattr(object, name, values)
给对象的属性赋值，若属性不存在，先创建再赋值。
>>> class test():
... name="xiaohua"
... def run(self):
... return "HelloWord"
...
>>> t=test()
>>> hasattr(t, "age") #判断属性是否存在
False
>>> setattr(t, "age", "") #为属相赋值，并没有返回值
>>> hasattr(t, "age") #属性存在了
True
>>>
delattr(object, name)
删除对象的属性
综合应用
>>> class test():
... name="xiaohua"
... def run(self):
... return "HelloWord"
...
>>> t=test()
>>> getattr(t, "age") #age属性不存在
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: test instance has no attribute 'age'
>>> getattr(t, "age", setattr(t, "age", "")) #age属性不存在时，设置该属性
''
>>> getattr(t, "age") #可检测设置成功
''
>>>
