三大成员
在Python的面向对象中，主要包括三大成员：字段、方法、属性
字段
类成员的字段又可分为普通字段、静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，代码示例如下：
class Foo:
#字段：静态字段
CC = 123
def __init__(self, name):
# 字段：普通字段
self.name = name
访问普通字段：
obj = Foo('bob')
print(obj.name)
out: bob 访问静态字段：
print(Foo.CC)
out: 123
1.普通字段：self.xxx
从上边的例子可以看出，普通字段存储在对象中，需要通过对象去访问。
2.静态字段:
从上边的例子可以看出，静态字段写在方法外边，只属于类,保存在类里边，不需要实例化也能访问，可以直接通过类去访问。可以起到节省内存的作用，静态字段代码加载的时候已经在内存创建。当然了，也可以通过对象去访问，但是不推荐。
小结：
普通字段只能用对象访问。静态字段用类访问(不建议用对象访问).且静态字段未做修改之前，对象共享一块内存地址。当对静态字段进行修改后，对象拥有自己的静态字段，不再共享
方法
方法分为普通方法、静态方法和类方法。这三种方法在内存中都归属于类。代码如下：
class Foo:
# 字段：静态字段
CC = 123 def __init__(self, name):
# 字段：普通字段
self.name = name # 普通方法
def show(self):
print(self.name) # 静态方法
@staticmethod
def f1(arg):
print("静态方法" + arg) # 类方法
@classmethod
def f2(cls):
print("类方法")
print(cls)
# 调用普通方法：
obj = Foo('bob')
obj.show()
out: bob
# 调用静态方法;
Foo.f1('Bob')
out: 静态方法bob
# 调用类方法：
Foo.f2()
out: 类方法 <class '__main__.Foo'>
1. 普通方法：由对象调用
至少包含一个self参数，并且在执行普通方法时，自动将调用该方法的对象赋值给self
2. 静态方法：由类调用
由staticmethod装饰，且无默认参数self，可以根据对应方法，接收任意参数。当方法内部不需要对象中封装的值时，可以将方法写成静态方法。
3. 类方法：由类调用
类方法是静态方法的特殊形式，至少一个包含cls参数；该参数不需要传递，会自动进行传递，执行类方法时，自动将调用该方法的类名赋值给cls。
小结：
相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
不同点：方法调用者不同、调用方法时自动传入的参数不同。
属性
属性其实就是类中普通方法的变种。属性具有方法的写作形式，具有字段的访问方式，并且提供了一种关联方式。定义方法如下
定义方式1：对方法使用装饰器
class Pager:
CC = 123
def __init__(self, all_count):
self.all_count = all_count @property
def all_pager(self):
a1, a2 = divmod(self.all_count, 10)
if a2 == 0:
return a1
else:
return a1 + 1 @all_pager.setter
def all_pager(self, value):
self.all_count = value
print(self.all_count) @all_pager.deleter
def all_pager(self):
print('del ' , Pager.CC)
# 自动执行@property修饰的all_pager方法
obj = Pager(101)
print(obj.all_pager)
out: 11
# 自动执行@all_pager.setter修饰的all_pager方法
obj.all_pager = 99
out: 99 print(obj.all_pager)
out: 10
# 自动执行@all_pager.deleter修饰的all_pager方法
del obj.all_pager
out: del 123
定义方式2：创建property对象
class Pager:
def __init__(self, all_count):
self.all_count = all_count def f1(self):
return 123 def f2(self, value):
print('执行f2 ' + value) def f3(self):
print("执行f3") foo = property(fget=f1,fset=f2,fdel=f3) p = Pager(101) # 执行f1方法
result = p.foo
print(result) # out: 123 # 执行f2方法
p.foo = 'xxxxx' # out: 执行f2 xxxxx # 执行f3方法
del p.foo # out: 执行f3
类成员修饰符
类成员修饰符，顾名思义，就是用来修饰字段、方法和属性的。对于每一个类的成员，都有两种形式：共有成员和私有成员。
私有成员和公有成员的定义不同
私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
私有成员和公有成员的访问限制不同
静态字段
公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问；
class C:
name = "公有静态字段"
def func(self):
print(C.name) class D(C):
def show(self):
print(C.name) print(C.name) # 类访问
out： 公有静态字段
obj = C()
obj.func() # 类内部可以访问
out： 公有静态字段
obj_son = D()
obj_son.show() # 派生类中可以访问
out： 公有静态字段
公有静态字段
class C:
__name = "公有静态字段"
def func(self):
print(C.__name) class D(C):
def show(self):
print(C.__name) print(C.__name) # 类访问 ==> 错误
out: AttributeError: type object 'C' has no attribute '__name'
# obj = C()
obj.func() # 类内部可以访问 ==> 正确
# out: 公有静态字段
obj_son = D()
obj_son.show() # 派生类中可以访问 ==> 错误
# out： AttributeError: type object 'C' has no attribute '_D__name'
私有静态字段
普通字段
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
私有普通字段：仅类内部可以访问；代码同静态字段的测试方法是一样，这里不再距离。
ps：非要访问私有属性的话，可以通过 "对象._类名__属性名"的方式来访问。代码如下：
class C:
__name = "公有静态字段"
def func(self):
print(C.__name) class D(C):
def show(self):
print(C.__name) obj = D()
print(obj._C__name)
out: 公有静态字段
强制访问私有字段
类特殊成员
常用的类特殊成员如下
1. __init__ 构造方法，类在实例化的时候自动执行
2. __doc__ 表示类的描述信息
3. __module__ 表示当前操作的对象在哪个模块
4. __class__ 表示当前操作的对象的类是什么
5. __call__ 对象后面加括号，触发执行__call__方法。比如A=Foo()， A()会自动出发__call__方法。
6. __str__ 该方法return什么，print(obj)的时候自动调用该方法，否则返回对象地址。或者执行str() ，自动调用该方法
7. __del__ 析构方法，一般不需要自己实现。在类在被垃圾回收机制清理之前， 会自动执行该方法。
8. __add__ 一个对象加另外一个对象，就自动执行 ret = obj1 +obj2. 知道就行，很少用到
9. __dict__ 不用写，默认已经有一个dict。 obj.__dict__ . 获取对象中封装的数据
10. __setitem__, __getitem__, __delitem__
方式一：输入类型为str
class Foo(object):
def __init__(self,name,age):
self.name = name
self.age = age def __getitem__(self, key):
print('__getitem__',key) def __setitem__(self, key, value):
print('__setitem__',key,value)
# print(value[key]) def __delitem__(self, key):
print('__delitem__',key) obj = Foo('Boss', 18)
# 执行obj['...']的时候执行__getitem__
obj['Baby']
out: __getitem__ Baby # 执行obj['...'] = ...的时候执行__setitem__
obj['Baby'] = 1123
out: __setitem__ Baby 1123 # 执行del obj['...']的时候执行__delitem__
del obj['XXOO']
out: __delitem__ XXOO
str:__getitem__、__setitem__、__delitem__
方式二：输入类型为slice，此时key具有三个字段为[start:stop:step]，测试代码如下
class Foo(object):
def __init__(self,name,age):
self.name = name
self.age = age def __getitem__(self, key):
print(type(key)) # 类型有两种： str或者 slice
# 如果是输入类型是slice
# print(key.start)
# print(key.stop)
# print(key.step)
# key.step
print('__getitem__',key) def __setitem__(self, key, value):
print('__setitem__',key,value)
print(value[key]) def __delitem__(self, key):
print(type(key), key)
# print(key.start)
# print(key.stop)
# print(key.step)
print('__delitem__',key) # obj[key] 自动调用__getitem__
obj = Foo('alex', 18)
obj[1:4:2]
out:
<class 'slice'>
__getitem__ slice(1, 4, 2) # obj[key] = ... 自动调用__setitem__
obj[1:4] = [1,2,3,4,5,6,7]
out:
__setitem__ slice(1, 4, None) [1, 2, 3, 4, 5, 6, 7]
[2, 3, 4] # del obj[key] 自动调用__delitem__
del obj[1:4:2]
out:
<class 'slice'> slice(1, 4, 2)
__delitem__ slice(1, 4, 2)
slice:__getitem__、__setitem__、__delitem__
11.__iter__ 对象通常不能被迭代，因此此方法可以使对象可迭代，该方法返回可迭代对象
class Foo(object):
def __iter__(self):
# return iter([11,22,33,44,55])
yield 1
yield 2 obj = Foo()
for item in obj:
print(item) out:
1
2
__iter__
面向对象的其他知识点
1. isinstance(a, b) 查看a是不是b的实例，或者是b的父类的实例。
2. issubclass(a, b) 查看a是否b的子类
3. 应用：利用类的继承关系，实现有序字典的类
class MyDict(dict):
def __init__(self):
# 执行父类的init方法
super(MyDict, self).__init__()
self.li = []
def __setitem__(self, key, value):
self.li.append(key)
super(MyDict, self).__setitem__(key, value)
def __getitem__(self, item):
pass
def __str__(self):
temp_list = []
for key in self.li:
value = self.get(key)
temp_list.append("'%s':%s" % (key, value))
return '{' + ",".join(temp_list) + '}'
obj = MyDict()
obj['k1'] = 123
obj['k2'] = 456
print(obj)
out: {'k1':123,'k2':456}
自定义实现简单有序dict
4. 如何执行父类的方法
class C1:
def f1(self):
print('C1.f1') class C2(C1):
def f1(self):
# 主动去执行父类的F1方法
super(C2, self).f1()
print('C2.f1') obj = C2()
obj.f1()
out:
C1.f1
C2.f1
执行父类：super的用法
5. python2中的继承(待补)
其他
设计模式之单例模式
单例模式可以用类方法或者静态方法来实现
案例：假设有个连接池，用户如果首次去连接，则创建一个池对象，返回给用户或者线程。如果在用户或线程连接的时候，该池对象已经存在，那么则直接返回。当然，也可以定义一个计数器，计算当前已分配地址池和总地址池的关系。代码如下：
class Foo:
instance = None def __init__(self,name):
self.name = name @classmethod
def get_instance(cls, name):
if cls.instance:
return cls.instance
else:
obj = cls(name)
cls.instance = obj
return obj obj1 = Foo.get_instance('alex')
print(obj1)
obj2 = Foo.get_instance('bbb')
print(obj2)
out:
<__main__.Foo object at 0x0000000000B246A0>
<__main__.Foo object at 0x0000000000B246A0>
# 返回相同的地址，说明他们共用一个池对象
单例模式
异常处理
所以异常处理，就是在可预知或者不可预知的情况下，提前捕捉异常，甚至针对异常进行的一种或一类操作。这里就用到了try语句。try语句的完整语法如下：
try:
# 捕捉这段代码的异常情况
...
except:
# 检测到异常的处理手段
...
else:
# 如果未检测到异常的处理手段
...
finally:
# 无论是否检测到异常，都执行该代码块
...
案例就不作过多说明了，这里说另外一个东西，触发异常和自定义异常！
触发异常和自定义异常
python允许程序员自定义异常，用于描述python中没有涉及的异常情况，自定义异常必须继承Exception类，自定义异常按照命名规范以"Error"结尾，显式地告诉程序员这是异常。自定义异常使用raise语句引发，而且只能通过人工方式触发。当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。
# 触发自定义异常
class InputError(Exception):
def __init__(self):
print("输入类型错误") inp = input('请输入一个数字:').strip()
if inp.isdigit():
raise InputError
else:
print(123) 如果输入123
则会报错。
测试如下：
请输入一个数字:123
输入类型错误
Traceback (most recent call last):
File "E:/学习经历/python勃起/s2.py", line 90, in <module>
raise InputError
__main__.InputError
# 捕获自定义异常
class InputError(Exception):
断言 assert
assert语句用于检测某个条件表达式是否为真，如果检测到是假，则触发AssertionError。
ip = '127.0.1.1'
assert ip == '127.0.0.1' out:
Traceback (most recent call last):
File "E:/学习经历/s2.py", line 109, in <module>
assert ip == '127.0.0.1'
AssertionError
如果要为assert增加异常说明信息，语法：assert Expression [, message]
ip = '127.0.1.1'
assert ip == '127.0.0.1', 'No network connect, please the network connect again!'
out:
Traceback (most recent call last):
File "E:/学习经历/python勃起/s2.py", line 109, in <module>
assert ip == '127.0.0.1', 'No network connect, please the network connect again!'
AssertionError: No network connect, please the network connect again!