OO=Object Oriented面向对象
特征:封装+继承+多态
OOP=Object Oriented programming面向对象编程
OOD=面向对象设计
OOA=面向对象分析
对象=属性+方法
类名以大写字母开头
方法def 。。。(self)
属性
由于Python是动态语言,根据类创建的实例可以任意绑定属性。
给实例绑定属性的方法是通过实例变量,或者通过self变量。
类本身需要绑定一个属性,可以直接在class中定义属性,这种属性是类属性,归Student类所有。当我们定义了一个类属性后,这个属性虽然归类所有,但类的所有实例都可以访问到。
在编写程序的时候,千万不要对实例属性和类属性使用相同的名字,因为相同名称的实例属性将屏蔽掉类属性,但是当你删除实例属性后,再使用相同的名称,访问到的将是类属性。
魔法函数(下一篇文章):
_init_(self)构造方法(两个下划线):只要实例化一个类时,此方法就会被自动调用。实现对象的初始化工作。不可以返回除了None以外的任何对象。
>>> class Ball:
def setName(self,name):
self.name=name
def kick(self):
print('我叫%s,该死的,谁踢我'%self.name)
>>> a=Ball()
>>> a.setname('球A')
>>> a.kick()
我叫球A,该死的,谁踢我
>>> class Ball:
def __init__(self,name):
self.name=name
def kick(self):
print('我叫%s,该死的,谁替我'%self.name)
>>> b=Ball('土豆')
>>> b=Ball()
Traceback (most recent call last):
File "<pyshell#76>", line 1, in <module>
b=Ball()
TypeError: __init__() missing 1 required positional argument: 'name'
公有和私有
外部代码还是可以自由地修改一个实例的name属性,如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__
,在Python中,实例的变量名如果以__
开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,但是如果外部代码要获取name和score怎么办?可以给Student类增加get_name这样的方法。
需要注意的是,在Python中,变量名类似__xxx__
的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name__
、__score__
这样的变量名。
有些时候,你会看到以一个下划线开头的实例变量名,比如_name
,这样的实例变量外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问”。
>>> class Person:
name='bb'#公有
>>> p=Person()
>>> p.name
'bb'
>>> class Person:
__name='bb'#属性或方法前加两个下划线表示私有,不能被外部直接访问
>>> p=Person()
>>> p.__name #私有属性不能从外部直接访问
Traceback (most recent call last):
File "<pyshell#86>", line 1, in <module>
p.__name
AttributeError: 'person' object has no attribute '__name'
>>> class Person:
__name='bb'
def getName(self):#称为访问器
return self.__name
>>> p=Person()
>>> p.getName()
'bb'
>>> p._Person__name #伪私有,通过_类名__变量名访问,不提倡
'bb'
>>>
继承与组合
继承如果子类定义与父类同名的方法,会覆盖父类方法
1.调用未绑定的父类中的方法;
2.使用super方法:自动寻找所有基类以及方法
import random
class Fish:
def __init__(self):
self.x=random.randint(0,10)
self.y=random.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 Shake(Fish):#子类
def __init__(self):#重新定义了__init__
Fish.__init__(self)#调用未绑定了父类中的方法;
#super().__init__()#使用super方法,若父类的__init__除了self还有其他参数,一并写入
self.hungry=True
def eat(self):
if self.hungry:
print('吃货的梦想就是吃')
self.hungry=False
else:
print('太撑了,吃不下了')
多重继承,应该尽量避免使用
class DerivedClassName(Base1,Base2,…)
组合:将实例用作属性
class Turtle:
def __init__(self,x):
self.num=x
class Fish:
def __init__(self,x):
self.num=x
class Pool:
def __init__(self,x,y):
self.turtle=Turtle(x)
self.fish=Fish(y)
def print_num(self):
print('水池里拥有乌龟%d只,小鱼%d只'%(self.turtle.num,self.fish.num))
什么时候用组合,什么时候用继承
组合用于‘有一个’场景,继承用于‘是一个’场景
注意
对象的属性和方法名字相同时,属性会覆盖方法;
区别类属性和实例属性;类属性是静态变量;
区别类对象和实例对象;
掌握python的绑定概念
与类相关的BIF
issubclass(class,classinfo)
classinfo可以是类对象组成的元祖,只要class是其中任何一个候选类的子类,则返回True
>>> class A:
pass
>>> class B(A):
pass
>>> issubclass(B,A)
True
>>> issubclass(B,B)#一个类被认为使其自身的子类
True
>>> issubclass(B,object)
True
>>> class C:
pass
>>> issubclass(B,C)
False
>>> class D(A):
pass
>>> issubclass(D,(A,C))
True
isinstance(object,classinfo)
object是一个实例化对象
>>> class A:
pass
>>> class B(A):
pass
>>> a=B()
>>> isinstance(a,B)
True
>>> isinstance(a,A)
True
>>>
hasattr(object,name)
name是否是object的属性
>>> class C:
def __init__(self,x=0):
self.x=x
>>> c=C()
>>> hasattr(c,'x')#注意是字符串
True
>>> hasattr(c,x)
Traceback (most recent call last):
File "<pyshell#30>", line 1, in <module>
hasattr(c,x)
NameError: name 'x' is not defined
>>>
getattr(object,name[,default])
返回指定的属性值,如果指定的属性不存在,会返回default或抛出异常
>>> getattr(c,'x')
0
>>> getattr(c,'y')
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
getattr(c,'y')
AttributeError: 'C' object has no attribute 'y'
>>> getattr(c,'y','你所访问的属性不存在')
'你所访问的属性不存在
setattr(object,name,value)
给属性赋值,如果属性不存在,就会新建一个属性,并赋值。
>>> setattr(c,'y','fishc')#name带‘’
>>> getattr(c,'y')
'fishc'
>>>
delattr(object,name)
删除属性,若不存在则抛出异常
property(fget=None,fset=None,fdel=None,doc=None)通过属性设置属性
>>> class C:
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)
>>> c=C()
>>> c.getsize()
10
>>> c.x#调用getsize
10
>>> c.x=18#调用setsize
>>> c.x
18
>>> c.size
18
>>> del c.x#调用delsize
>>> c.size
Traceback (most recent call last):
File "<pyshell#58>", line 1, in <module>
c.size
AttributeError: 'C' object has no attribute 'size'
>>>
使用dir()
如果要获得一个对象的所有属性和方法,可以使用dir()函数,它返回一个包含字符串的list,比如,获得一个str对象的所有属性和方法:
>>> dir('ABC')
['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill'
动态绑定属性和方法&__slots__
>>> class Student:
pass
>>> s=Student()
>>> s.name='xinyue'#给实例动态绑定属性
>>> s.name
'xinyue'
>>> def set_age(self,age):
self.age=age
>>> from types import MethodType
>>> s.set_age=MethodType(set_age,s)#给实例动态绑定方法
>>> s.set_age(23)
>>> s.age
23
>>> def set_score(self,score):
self.score=score
>>> Student.set_score=set_score#给类动态绑定方法
>>> s.set_score(100)
>>> s.score
100
但是,如果我们想要限制实例的属性怎么办?比如,只允许对Student实例添加name和age属性。
为了达到限制的目的,Python允许在定义class的时候,定义一个特殊的slots变量,来限制该class实例能添加的属性。
使用slots要注意,slots定义的属性仅对当前类实例起作用,对继承的子类是不起作用的。
>>> class Student:
__slots__=('name','age')#只允许对Student实例添加name和age属性
>>> s=Student()
>>> s.name='xinyue'
>>> s.age=23
>>> s.score=100#不允许添加
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
s.score=100
AttributeError: 'Student' object has no attribute 'score'
>>> class GraduateStudent(Student):#子类
pass
>>> g=GraduateStudent()
>>> g.score=100#不影响子类添加属性
>>>