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))
Trueisinstance(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#不影响子类添加属性
>>> 
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
