面向对象进阶
1. 访问权限
1.1 @property
前面讲到方法里，python 可以通过下划线来标识方法和属性的权限，
name公共,__name私有,_name保护
那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。
class safe:
__test = 100
def __init__(self,test):
self.__test = test
@property
def test(self):
return self.__test
@test.getter
def test(self):
return self.__test
@test.setter
def test(self,test):
self.__test = test
def show(self):
print('self.__test:', self.__test)
a = safe(1000)
a.show()
print(a.test)
print(a.test)
a.test = 1111
a.show()
try:
print(a.__test)
except AttributeError as err1:
print(err1)
结果：
self.__test: 1000
1000
1000
self.__test: 1111
'safe' object has no attribute '__test'
1.2 __slots__
前面说到属性是可以动态删减的，如果想保护起来，就得用
__slots__保护起来
这个关键字声明了只有它限定得属性是可读可写的，不再元组里的只能读，不能写
看例子：
class test_private:
'nothong'
__slots__ = ('_name', '_age', '_high')
test = 111
def __init__(self,name,age,high):
self._name = name
self._age = age
self._high = high
@property
def name(self):
return self._name
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def play(self):
if self._age <= 16:
print('%s正在玩飞行棋.' % self._name)
else:
print('%s正在玩斗地主.' % self._name)
a = test_private('zhangsan', 18, 130)
a.play()
try:
print('a.name : ', a.name)
except AttributeError as err1:
print('err1: ',err1)
try:
a.ability = 'aaa'
except AttributeError as err2:
print('err2:',err2)
try:
a.test = 1000
print(a.test)
except AttributeError as err3:
print('err3', err3)
a.age = 15
a.play()
结果：
zhangsan正在玩斗地主.
a.name : zhangsan
err2: 'test_private' object has no attribute 'ability'
err3 'test_private' object attribute 'test' is read-only
zhangsan正在玩飞行棋.
2. 静态方法和类方法
之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。静态方法是可以发消息给类的，就是说，类和对象都可以执行，代码如下所示。
class test_static:
@staticmethod
def test_static(cls):
print('you can do')
@staticmethod
def test_no_param():
print('you cant')
cls = ''
test_static.test_static(cls=cls)
test_static.test_no_param()
a = test_static()
a.test_static(cls=cls)
a.test_no_param()
结果:
you can do
you cant
you can do
you cant
可以不用加cls
和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象，随便给自己初始化了，但是要通过静态方法，返回的也是个cls，就是自己，代码如下所示。
import os
from time import time, localtime, sleep
class Clock(object):
"""数字时钟"""
def __init__(self, hour=0, minute=0, second=0):
self._hour = hour
self._minute = minute
self._second = second
@classmethod
def now(cls):
ctime = localtime(time())
return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
def run(self):
"""走字"""
self._second += 1
if self._second == 60:
self._second = 0
self._minute += 1
if self._minute == 60:
self._minute = 0
self._hour += 1
if self._hour == 24:
self._hour = 0
def show(self):
"""显示时间"""
return '%02d:%02d:%02d' % \
(self._hour, self._minute, self._second)
结果：
18:56:04
就是个1s一次的时间
3. 类之间的关系
这个完全用作者的了，主要是要理解
简单的说，类和类之间的关系有三种：is-a、has-a和use-a关系。
- is-a关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系。
- has-a关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。
- use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。
uml-components.png
uml-example.png
直接上大神的图
利用类之间的这些关系，我们可以在已有类的基础上来完成某些操作，也可以在已有类的基础上创建新的类，这些都是实现代码复用的重要手段。复用现有的代码不仅可以减少开发的工作量，也有利于代码的管理和维护，这是我们在日常工作中都会使用到的技术手段。
方便开发，帮助你我他
4. 继承和多态
继承和多继承在上一个文章已经讲了
面向对象三大法宝，封装，继承，多态，
- 封装：就是类的作用
- 继承：就是通过继承基类已经实现的方法和属性，来减少开发量，方便你我他
- 多态 ：就是在继承的基础上可以对基类的方法的重写，让子类和父类的方法表现形式不一样
可能表述有些问题，但是基本方向没啥问题
文集传送门 学习python100天
整个学习python100天的目录传送门
无敌分割线
再最后面附上大神的链接 传送门
