一. 类的重写
只需要重新定义类的属性(变量),就是类的重写了
示例:重新定义类grandson的 name属性
#/usr/bin/python
#coding=utf-8
#@Time :2017/11/7 23:23
#@Auther :Daishijian
#@File :类的重写.py
classparent(object):
name ='parent'
sex ='F'
coller ='yellow'
language ='chinese'
def__init__(self):
print'my name is {0}'.format(self.name)
defget_sex(self):
returnself.name
a = parent()
a.get_sex()
print'#'*15
classchild(object):
name ='child'
coller ='yellow'
def__init__(self):
print'my name is {0}'.format(self.name)
defget_coller(self):
returnself.coller
b = child()
printb.get_coller()
print'#'*15
classgrandson(parent,child):
name ='grandson'
def__init__(self):
print'my name is {0}'.format(self.name)
defget_coller(self):
returnself.coller
defget_language(self):
returnself.language
#类的重写,只需要重新定义变量,直接打印
defget_name(self):
print'my name is xiaoming'
c = grandson()
printc.get_coller()
printc.get_language()
c.get_name()
二. __init__ 是每个类的默认方法,如果子类想继承父类的__init__ 方法,需要用supper(子类,self)。子类把父类方法重写的时候,会默认忽略父类中的 return
格式:子类想继承__init__
supper(子类名称,self).__init__(有参数就跟参数)
print '$$$$$$$ ' //使用supper函数,会忽略父类中的return,直接执行子类中
supper下的一些方法逻辑,所以直接用print 打出来
格式: 子类想继承父类中的其他方法
supper(子类名称,self).父类中的方法 //没参数就跟父类中的方法名
print '#######' // 使用supper函数,会忽略父类中的return
二 .类的私有变量
默认情况下,Python中的成员函数和成员变量都是公开的(public),在python中没有类似public,private等关键词来修饰成员函数和成员变量。
在python中定义私有变量只需要在变量名或函数名前加上 ”__“两个下划线,那么这个函数或变量就是私有的了。
在内部,python使用一种 name mangling 技术,将 __membername替换成 _classname__membername,也就是说,类的内部定义中,
所有以双下划线开始的名字都被"翻译"成前面加上单下划线和类名的形式。
例如:为了保证不能在class之外访问私有变量,Python会在类的内部自动的把我们定义的__spam私有变量的名字替换成为
_classname__spam(注意,classname前面是一个下划线,spam前是两个下划线),因此,用户在外部访问__spam的时候就会
提示找不到相应的变量。 python中的私有变量和私有方法仍然是可以访问的;访问方法如下:
私有变量:实例._类名__变量名
私有方法:实例._类名__方法名()
其实,Python并没有真正的私有化支持,但可用下划线得到伪私有。 尽量避免定义以下划线开头的变量!
(1)_xxx "单下划线 " 开始的成员变量叫做保护变量,意思是只有类实例和子类实例能访问到这些变量,
需通过类提供的接口进行访问;不能用'from module import *'导入
(2)__xxx 类中的私有变量/方法名 (Python的函数也是对象,所以成员方法称为成员变量也行得通。),
" 双下划线 " 开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。
(3)__xxx__ 系统定义名字,前后均有一个“双下划线” 代表python里特殊方法专用的标识,如 __init__()代表类的构造函数。
下面我们看几个例子:
【1】
- class A(object):
- def __init__(self):
- self.__data=[]
- def add(self,item):
- self.__data.append(item)
- def printData(self):
- print self.__data
-
- a=A()
- a.add('hello')
- a.add('python')
- a.printData()
-
- print a._A__data
运行结果是:
['hello', 'python']
['hello', 'python']
【2】
获取实例的所有属性 print a.__dict__
获取实例的所有属性和方法 print dir(a)
- class A():
- def __init__(self):
- self.__name='python'
- def __say(self):
- print self.__name
-
- a=A()
-
- print a.__dict__
- print a._A__name
-
- print dir(a)
- a._A__say()
运行结果:
{'_A__name': 'python'}
python
['_A__name', '_A__say', '__doc__', '__init__', '__module__']
python
从上面看来,python还是非常的灵活,它的oop没有做到真正的不能访问,只是一种约定让大家去遵守,
比如大家都用self来代表类里的当前对象,其实,我们也可以用其它的,只是大家习惯了用self 。
【3】小漏洞:派生类和基类取相同的名字就可以使用基类的私有变量
- class A():
- def __init__(self):
- self.__name='python'
-
- class B(A):
- def func(self):
- print self.__name
-
- instance=B()
-
- print instance.__dict__
- print instance._A__name
运行结果:
{'_A__name': 'python'}
python
- class A():
- def __init__(self):
- self.__name='python'
-
- class A(A):
- def func(self):
- print self.__name
-
- instance=A()
- instance.func()
运行结果:
python