python中的类
__metaclass__ = type
class Person:
def __init__(self, name):
self.name = name
def getName(self):
return self.name
def color(self, color):
print('%s is %s' % (self.name, color))
(1)新式类
__metaclass__ = type
,意味着下面的类是新式类(在python3以前的称之为旧式类,这里不讨论什么新式旧式)
(2)定义类
创建了一个叫"Persion“的类,这里就不废话了。。。
(3)初始化
def __init__()
这个函数比较特殊,叫做初始化函数(有的书上也会称之为构造函数,但 __new__()
才是真的构造)
通过 Person 创建一个实例对象:girl = Person('xuyuling')
传递一个参数xuyuling
girl 是Person类的一个实例对象,它Person类有属性和方法。。。。
使用对象的属性:girl.name
调用对象的方法:girl.getName()
def __init__(self, *args):
pass
不一定每次都要从外部传入参数,可以在函数参数中设置默认值
class Person:
def __init__(self, name, lang='python', website='youif.cn'):
self.name = name
self.lang = lang
self.website = website
p1 = Person('张三')
p2 = Person('李四', lang='java', website='www.baidu.com')
print('p1name=', p1.name)
print('p2name=', p2.name)
print('p2lang=', p2.lang)
print('p1Web=', p1.website)
print('p2Web=', p2.website)
输出:
---------------- p1name= 张三 p2name= 李四 p2lang= java p1Web= youif.cn p2Web= www.baidu.com ----------------------
self 的作用
类的函数里面,第一个参数是 self ,而且不能省略。但在实例化的时候,这个参数不需要写,也不需要为这个参数传值。
以前面的”Person“类为例,在 Person 实例化的过程总 girl = Person('xuyuling'),字符串’xuyuling'通过初始化函数(init)的参数已经存入到内存中,并且是以 Person 类型,组成了一个对象,这个对象和变量 girl 建立引用关系。
self 其实也是一个实例,这个实例与上面的 girl 一样,也有属性。
上述代码中:self.name = name, 就是规定了 self 实例的一个属性,这个是属性的名字也叫 name,且属性的值等于初始化函数的参数 name 所导入的数据。
注意,self.name 中的 name 和初始化函数的参数 name 没有任何关系,它们两个一样。当然,如果写出 self.xyz = name,也是可以的。
当然,self 的属性数据,也不一定非得由参数传入,可以在构造函数中设定。例如:
__metaclass__ = type
class Person:
def __init__(self, name):
self.name = name
self.email = "xxx@qq.com" #这个属性不是通过参数传递的
info = Person('zhong')
print('inofName=', info.name)
print('ifoEmail=', info.email)
输出结果:
---------------- inofName= zhong ifoEmail= xxx@qq.com ----------------------
继承
__metaclass__ = type
class Person:
def speak(self ):
print('hello world!')
def setHeight(self):
print('一米八')
def setWeight(self, n):
print('My weight is :', n)
class Girl(Person):
def setHeight(self):
print('一米六')
if __name__ == '__main__':
xu = Girl()
xu.setHeight()
xu.speak()
xu.setWeight(90)
输出结果:
---------------- 一米六 hello world! My weight is : 90 --------------------
首先,定义了一个 Person 类,在这个类里面定义了三个方法。注意,没有定义初始化函数,初始化函数在类中不是必须的。
然后有自定义了一个 Girl 类,这个类后面的括号里面是一个类的名字,这句以为着 Girl 类继承了 Person 类。因此 Girl 类就有了 Person 中的全部方法和属性。
如果子类中有父类中相同的方法名,那么,执行的执行的是子类的方法,这样叫做重写。
多重继承
__metaclass__ = type
class Person:
def eye(self):
print('two eyes')
def height(self, n):
print("一米八")
class Girl:
age = 20
def color(self):
print('The girl is white')
class HotGirl(Person, Girl):
pass
if __name__ == '__main__':
kong = HotGirl()
kong.eye()
kong.height(90)
kong.color()
print(kong.age)
输出:
-------------------- two eyes 一米八 The girl is white 20 -------------------------
多重继承的顺序
class A1(object):
def foo(self):
print("A1-foo")
class A2(object):
def foo(self):
print('A2-foo')
def color(self):
print('A2-color')
class B1(A1, A2):
pass
class B2(A1, A2):
def color(self):
print('M2-color')
class H(B1, B2):
pass
if __name__ == '__main__':
print(H.__mro__)
s = H()
s.foo()
s.color()
输出:
(<class '__main__.H'>, <class '__main__.B1'>, <class '__main__.B2'>, <class '__main__.A1'>, <class '__main__.A2'>, <class 'object'>)
A1-foo
M2-color
代码总的print(G.__mro__)
是要打印出类的继承顺序。
即 H --> B1 --> B2 --> A1 --> A2
对继承属性和方法搜索的顺序称之为“广度优先”。