面向对象编程【python笔记（六）】

对象=属性+方法

面向对象的特征：

封装、继承、多态

self：

python的self相当于C++的this指针

class Ball:
    def setName(self,name):
        self.name=name
    def kick(self):
        print("我叫%s,谁踢我" %self.name) 
    
a=Ball()
a.setName('球A')
a.kick()

init():相当于C++中的构造函数

class Ball:
    def __init__(self,name):
        self.name=name

如果在类定义时，函数没有传入self参数，可直接调用类的方法，但是不能直接调用类的对象的方法

class A:
    def get_a():
        print("a")

class B:
    def get_b(self):
        print("b")
A.get_a()
b=B()
b.get_b()
a.get_a()

运行结果 

 

私有或公有

类的属性和方法默认公有

class Ball:
    name="hahaha"

a=Ball()
print(a.name)

私有可用name mangling，在变量名前加两个下划线，该变量就成私有的了

class Ball:
    __name="hahaha"

a=Ball()
print(a.name)

class Ball:
    __name="hahaha"
    def getName(self):
        return self.__name

a=Ball()
print(a.getName())

解释：在变量名前加上两个下划线，其实python就自动把变量变成了“_类名__变量名”

class Ball:
    __name="hahaha"
    def getName(self):
        return self.__name

a=Ball()
print(a.getName())
print(a._Ball__name)

继承

class DerivedClassName(BaseClassName):

普通

子类会继承父类的属性和方法

class Parent():
    def hello(self):
        print("hello world+ 正在调用父类方法")

class Child(Parent):
    pass
p=Parent()
p.hello()
c=Child()
c.hello()

若子类的方法或属性与父类同名，则会覆盖父类，此时的解决办法有两个

1、调用未绑定的super方法

2、使用父类函数

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):
        #Fish.__init__(self)
        super().__init__() #与上一局意思相同
        self.hungry=True
    
    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有吃的")
            self.hungry=False
        else:
            print("太撑了，吃不下了")

shark=Shark()
shark.move()

多重继承

class Base1:
    def fool1(self):
        print("我是fool，我为Base1代言")
class Base2:
    def fool2(self):
        print("我是fool，我为Base2代言")

class C(Base1,Base2):
    pass

c=C()
c.fool1()
c.fool2()

组合

把几个有并列关系的类放在一起

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))

p=Pool(1,10)
p.print_num()

一些相关的BIF

issubclass（class，classinfo)

如果class是classinfo的子类，则返回True

1、一个类被认为是它自身的子类

2、classinfo可以是类对象组成的元组，只要class于是其中任何一个候选类的子类，则返回True（object是所有类的父类）

isinstance（object，classinfo）

检查一个实例对象是否属于类

1、如果第一个参数不是对象，则永远返回False

2、如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常

hasattr（object，name）

检查一个对象是否有属性name

1、name要用单引号括起来

getattr(object,name[,default])

返回对象指定的属性值，若属性不存在，返回default

setattr(object,name,value)

设置对象指定属性的值，如果指定属性不存在，新建属性并给它赋值

delattr(object,name)

删除对象的属性，如果属性不存在，抛出AttributeError异常

property（fget=None,fset=None,fdel=None,doc=None)

通过属性来设置属性，作用就是改起来方便，相当于一个中转站。

emmmm有点神奇，看下边的例子，

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)

c1=C()
#三种获取属性的方法
print(c1.getSize())
print(c1.x)
print(c1.size)

#给属性赋值
c1.x=20
print(c1.x)

#删除属性
del c1.x
print(c1.size)

__new__

__del__

 这块应该还有一个魔法方法，我给跳过了，因为感觉听的课程中讲的不适用于python3，以后如果有需要的话我再反过来学