类和对象
1. 一个例子
# 对象 = 属性 + 方法
# Python 中的类名称约定首字母大写,而 Python 函数名首字母小写
class Turtle:
#属性
color = 'green'
weight = 10
legs = 4
shell = True
mouth = '大嘴'
# 方法
# 这里的 self 表示 this 指针
def climb(self):
print("我正在很努力地向前爬")
def run(self):
print("我正在飞快地向前跑")
def bite(self):
print("我咬死你咬死你")
def eat(self):
print("有得吃,真满足!")
def sleep(self):
print("困了,睡觉,晚安")
tt = Turtle()
tt.climb()
tt.bite()
tt.sleep()
我正在很努力地向前爬
我咬死你咬死你
困了,睡觉,晚安
2. 面向对象的特征
① 封装
# 我们只知道这些方法如何调用,并不知道方法内部怎么实现的
list1 = [2,1,7,5,3]
list1.sort()
list1.append(9)
print(list1)
[1, 2, 3, 5, 7, 9]
② 继承
class MyList(list): # 这里表示 Mylist 类继承于 list 类
# pass 为占位符,表明不做任何操作
pass
list2 = MyList()
# list 类中的方法都被继承了
list2.append(1)
list2.append(7)
list2.append(5)
list2.append(4)
list2.append(9)
list2.sort()
print(list2)
[1, 4, 5, 7, 9]
③ 多态
# 不同对象对同一方法响应不同的行动
class A:
def fun(self):
print("我是小A")
class B:
def fun(self):
print("我是小B")
a = A()
b = B()
a.fun()
b.fun()
我是小A
我是小B
3. self
# 当一个对象的方法被调用时,会将自身作为参数传入
# 类的方法定义时,必须把 self 写入第一个参数
class Ball:
def setName(self,name):
self.name = name
def kick(self):
print("我叫%s,该死的,谁踢我。。。" % self.name)
a = Ball()
a.setName('球A')
b = Ball()
b.setName('球B')
c = Ball()
c.setName('球C')
a.kick()
b.kick()
c.kick()
我叫球A,该死的,谁踢我。。。
我叫球B,该死的,谁踢我。。。
我叫球C,该死的,谁踢我。。。
4. _ _ init _ _ (self)(这里是两个双下划线)
class Ball:
# 这个即为构造函数
def __init__(self,name):
self.name = name
def kick(self):
print("我叫%s,该死的,谁踢我。。。" % self.name)
b = Ball('土豆')
b.kick()
我叫土豆,该死的,谁踢我。。。
5. 公有和私有
class Person:
name = '小甲鱼'
p = Person()
print(p.name)
小甲鱼
class Person:
# 变量前加上双下划线就会变成私有变量,无法直接调用
__name = '小甲鱼'
# 可以通过方法来调用
def getName(self):
return self.__name
p = Person()
print(p.name)
-------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in ()
5 return self.__name
6 p = Person()
----> 7 print(p.name)
AttributeError: 'Person' object has no attribute 'name'
print(p.getName())
小甲鱼
# 其实 Python 的私有为伪私有,只是将变量的名字改了(名字改编)
# 可以通过 对象名._类名__变量名 来调用
print(p._Person__name)
小甲鱼
6. 继承
class Parent:
def hello(self):
print("正在调用父类的方法。。。")
class Child(Parent):
pass
p = Parent()
p.hello()
c = Child()
c.hello()
正在调用父类的方法。。。
正在调用父类的方法。。。
class Child1(Parent):
# 如果在子类中定义与父类同名的方法或属性,则会覆盖父类相应的方法或属性
def hello(self):
print("正在调用子类的方法。。。")
d = Child1()
d.hello()
p.hello()
正在调用子类的方法。。。
正在调用父类的方法。。。
7. 继承例子
import random as r
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
def move(self):
self.x -= 1
print("我现在的位置是:", self.x, self.y)
class Goldfish(Fish):
pass
class Carp(Fish):
pass
class Salmon(Fish):
pass
class Shark(Fish):
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print("吃货的梦想就是天天有得吃")
self.hungry = False
else:
print("太撑了,吃不下了!")
fish = Fish()
fish.move()
我现在的位置是: 3 6
fish.move()
我现在的位置是: 2 6
goldfish = Goldfish()
fish.move()
我现在的位置是: 1 6
shark = Shark()
shark.eat()
吃货的梦想就是天天有得吃
# 由于 Shark 子类重写了 __init__ 方法,属性 x 和 y,都不存在了,所以会报错
shark.move()
-------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in ()
----> 1 shark.move()
in move(self)
5 self.y = r.randint(0,10)
6 def move(self):
----> 7 self.x -= 1
8 print("我现在的位置是:", self.x, self.y)
9
AttributeError: 'Shark' object has no attribute 'x'
class Shark1(Fish):
def __init__(self):
# 这里调用未绑定的父类方法
# 这里的 self 是子类的对象,即将子类对象作为参数传入父类的构造方法
# 从而定义了属性 x 和 y
Fish.__init__(self)
self.hungry = True
def eat(self):
if self.hungry:
print("吃货的梦想就是天天有得吃")
self.hungry = False
else:
print("太撑了,吃不下了!")
shark1 = Shark1()
shark1.eat()
shark1.move()
吃货的梦想就是天天有得吃
我现在的位置是: 8 9
class Shark2(Fish):
def __init__(self):
# 也可以使用super
super().__init__()
self.hungry = True
def eat(self):
if self.hungry:
print("吃货的梦想就是天天有得吃")
self.hungry = False
else:
print("太撑了,吃不下了!")
shark2 = Shark2()
shark2.eat()
shark2.move()
吃货的梦想就是天天有得吃
我现在的位置是: 5 9
8. 多重继承
# 尽量避免使用多重继承
class Base1:
def foo1(self):
print("我是foo1,我为Base1代言。。。")
class Base2:
def foo2(self):
print("我是foo2,我为Base2代言。。。")
class C(Base1, Base2):
pass
c = C()
c.foo1()
c.foo2()
我是foo1,我为Base1代言。。。
我是foo2,我为Base2代言。。。
9. 组合
class Turtles:
def __init__(self, x):
self.num = x
class Fishs:
def __init__(self, x):
self.num = x
class Pool:
def __init__(self, x, y):
# 把类的实例化放到一个新类中,这样就可以避免使用多重继承
self.turtles = Turtles(x)
self.fishs = Fishs(y)
def print_num(self):
print("水池里总共有乌龟 %d 只,小鱼 %d 条!" % (self.turtles.num, self.fishs.num))
pool = Pool(1,10)
pool.print_num()
水池里总共有乌龟 1 只,小鱼 10 条!
10. Mix-in 编程机制
11. 类、类对象和实例对象
# 在定义的时候他是一个类,等他定义完就是一个类对象
class C:
count = 0
a = C()
b = C()
c = C()
print(a.count)
print(b.count)
print(c.count)
0
0
0
# 这里相当于生成了一个对象来覆盖了原来的count
# 类中定义的属性都是静态属性
# 类属性和类对象是相互绑定的,并不依赖于实例对象
# 当执行 c.count += 10 的时候,c实例对象里面多出了一个count属性
# 这个实例属性将类属性给覆盖了
c.count += 10
print(c.count)
print(a.count)
print(b.count)
10
0
0
C.count += 100
print(a.count)
print(b.count)
print(c.count)
100
100
10
12. 属性和方法同名
class D:
def x(self):
print("X-man!")
d = D()
d.x()
X-man!
# 这里是在实例对象里创建一个新的变量x,与方法同名,会覆盖方法
d.x = 1
print(d.x)
1
d.x()
-------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
----> 1 d.x()
TypeError: 'int' object is not callable
不要试图在一个类里边定义出所有能想到的特性和方法,应该利用继承和组合机制来进行扩展。
用不同的词性命名,如属性名用名词,方法名用动词。
13. 绑定
Python要求方法需要有实例才能被调用,即为绑定
class BB:
# 这里没写参数 self
def printBB():
print("no zuo no die")
# 直接用类名可以调用
BB.printBB()
no zuo no die
# 由于没有 self 参数,所以实例化对象没办法调用该方法
bb = BB()
bb.printBB()
-------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
1 bb = BB()
----> 2 bb.printBB()
TypeError: printBB() takes 0 positional arguments but 1 was given
class CC:
# 方法是静态的,绑定在类对象中
def setXY(self, x, y):
self.x = x
self.y = y
def printXY(self):
print(self.x, self.y)
dd = CC()
# 以字典方式输出 dd 对象所有的属性
print(dd.__dict__)
# 只有实例对象的属性,不显示类属性和特殊属性(魔法方法)
# 键用引号引起来,表示属性名
# 值表明属性对应的值
print(CC.__dict__)
{}
{'__module__': '__main__', 'setXY': , 'printXY': , '__dict__': , '__weakref__': , '__doc__': None}
# 这里调用实际上调用的是dd.setXY(dd,4,5)
# x,y 变量储存在 dd 实例对象的空间中
dd.setXY(4,5)
# 这里的 x, y 仅属于dd
print(dd.__dict__)
print(CC.__dict__)
{'x': 4, 'y': 5}
{'__module__': '__main__', 'setXY': , 'printXY': , '__dict__': , '__weakref__': , '__doc__': None}
del CC
ee = CC()
-------------------------------------------------------------------------
NameError Traceback (most recent call last)
in ()
1 del CC
----> 2 ee = CC()
NameError: name 'CC' is not defined
# 虽然类对象已经被删除,但是实例对象已经储存在内存中,仍然可以使用
# 只有在程序退出时才会被释放
# 所以大多数情况下应该使用实例属性,而不要去使用类属性
dd.printXY()
4 5
14.一些BIF
① issubclass(class,classinfo)
如果 clss 是 classinfo 的子类,就会返回TRUE
一个类会被认为是其自身的子类
classinfo可以是类对象组成的元组,只要class是其中任何一个候选类的子类,则会返回True
class A:
pass
class B(A):
pass
class C:
pass
print(issubclass(B,A))
print(issubclass(B,B))
# 所有类都是object类的子类
print(issubclass(B,object))
print(issubclass(B,C))
True
True
True
False
② isinstance(object,classinfo)
如果 object 是 classinfo 的实例对象,就会返回TRUE
如果第一个参数不是对象,则永远返回False
classinfo可以是类对象组成的元组,只要object是其中任何一个候选类的实例对象,则会返回True
如果第二个参数不是类或者由类对象组成的元组,会抛出一个TypeError
b1 = B()
print(isinstance(b1,B))
# B类继承于A类
print(isinstance(b1,A))
print(isinstance(b1,C))
print(isinstance(b1,(A,B,C)))
True
True
False
True
③ hasattr(object,name)
测试object对象里面是否有属性name
class D:
def __init__(self,x=0):
self.x = x
d1 = D()
# 这里的属性名参数,必须加上引号,否则会报错
print(hasattr(d1,'x'))
True
④ getattr(object,name[,default])
返回对象指定的属性值,如果属性不存在,如果你还设置了default,则会打印出default;如果没设置,则会抛出AttributeError的异常
print(getattr(d1,'x'))
0
print(getattr(d1,'y'))
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in ()
----> 1 print(getattr(d1,'y'))
AttributeError: 'D' object has no attribute 'y'
print(getattr(d1,'y','您所访问的属性不存在'))
您所访问的属性不存在
⑤ setattr(object,name,value)
设置对象中指定属性的值,如果没有,则会新建并赋值
setattr(d1,'y','Nigream')
print(getattr(d1,'y'))
Nigream
⑥ delattr(object,name)
删除对象中指定的属性,如果不存在则抛出AttributeError的异常
delattr(d1,'y')
delattr(d1,'y')
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in ()
----> 1 delattr(d1,'y')
AttributeError: y
⑦ property(fget=None, fset=None, fdel=None, doc=None)
通过属性来设置属性
fget为获取属性的方法,当执行e1.x语句时调用
fset为设置属性的方法,当执行e1.x=18语句时调用
doc为删除属性的方法,当执行del e1.x语句时调用
class E:
def __init__(self,size=10):
self.size = size
def getSize(self):
return self.size
def setSize(self,value):
self.size = value
def delSize(self):
del self.size
x = property(getSize,setSize,delSize)
e1 = E()
print(e1.getSize())
10
print(e1.x)
10
e1.x = 18
print(e1.x)
18
print(e1.getSize())
18
del e1.x
e1.size
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in ()
----> 1 e1.size
AttributeError: 'E' object has no attribute 'size'