Python面向对象编程-优快云博客

类和对象

定义类

定义一个类，格式如下：

class 类名:

方法列表

example：定义一个Car类

# 定义类

class Car:

# 方法

    def getCarInfo(self):

        print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color))

    def move(self):

        print("车正在移动...")

创建对象

定义了一个Car类；就好比有车一个张图纸，那么接下来就应该把图纸交给生成工人们去生成了

python中，可以根据已经定义的类去创建出一个个对象

创建对象的格式为:

对象名 = 类名()

创建对象demo:

# 定义类

class Car:

# 移动

    def move(self):

        print('车在奔跑...')

# 鸣笛

    def toot(self):

        print("车在鸣笛...嘟嘟..")

# 创建一个对象，并用变量BMW来保存它的引用

BMW = Car()

BMW.color = '黑色' #在类外可以给对象加数据成员

BMW.wheelNum = 4 #轮子数量 #在类外可以给对象加数据成员

BMW.move()

BMW.toot()

print(BMW.color)

print(BMW.wheelNum)

类中变量的属性

__ 变量私有变量，只能在类中访问

_变量私有化属性或方法，from somemodule import *禁止导入,类对象和子类可以访问

__变量__ 系统的具有特殊的功能函数

变量共有变量

为什么在类外不能用私有变量，__变量 python 会改成： _类名__变量名（名字重整）写出重整后就可以用，但是最好不要用

__init__()方法（类似C++中的构造函数）

def 类名:

#初始化函数，用来完成一些默认的设定

    def __init__():

        pass

在创建对象的时候自动调用执行该函数对类中的数据成员进行初始化

有形参的构造函数用法

# 定义汽车类

class Car:

    def __init__(self, newWheelNum, newColor):

        self.wheelNum = newWheelNum

        self.color = newColor

    def move(self):

        print('车在跑，目标:夏威夷')

# 创建对象

BMW = Car(4, 'green')

__new__和__init__的区别

__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值。

__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例，是个静态方法。

也就是，__new__在__init__之前被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数。

定义__str__()方法

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法（系统函数）

当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

self理解

self跟C++中的*this差不多，是指的自己本身

定义__slots__方法

作用是在类中限制类中是属性，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的（不会被子类继承）

用法：

__slots__=("属性名")

保护对象的属性（类似C++中的protecte和private）

Python中没有像C++中public和private这些关键字来区别公有属性和私有属性

它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法（函数）也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。

__del__()方法（C++中的析构函数）

创建对象后，python解释器默认调用__init__()方法； del 对象（删除对象）

当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

当有1个变量保存了对象的引用时，此对象的引用计数就会加1

当使用del删除变量指向的对象时，如果对象的引用计数不会1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除

类的继承

单继承

# 定义一个父类，如下:

class Cat(object):

    def __init__(self, name, color="白色"):

        self.name = name

        self.color = color

    def run(self):

        print("%s--在跑"%self.name)

# 定义一个子类，继承Cat类如下:

class Bosi(Cat):

    def setNewName(self, newName):

        self.name = newName

    def eat(self):

        print("%s--在吃"%self.name)

bs = Bosi("印度猫")

说明：

虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法

总结

子类在继承的时候，在定义类时，小括号()中为父类的名字

父类的属性、方法，会被继承给子类

私有的属性，不能通过对象直接访问，但是可以通过方法访问

私有的方法，不能通过对象直接访问

私有的属性、方法，不会被子类继承，也不能被访问

一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

多继承

# 定义一个父类

class A:

    def printA(self):

        print('----A----')

# 定义一个父类

class B:

    def printB(self):

        print('----B----')

# 定义一个子类，继承自A、B

class C(A,B):

    def printC(self):

        print('----C----')

重写

重写父类方法与调用父类方法

1. 重写父类方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

多态

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态

class F1(object):

    def show(self):

        print 'F1.show'

class S1(F1):

    def show(self):

        print 'S1.show'

class S2(F1):

    def show(self):

        print 'S2.show'

def Func(obj):

    print obj.show()

s1_obj = S1()

Func(s1_obj)

s2_obj = S2()

Func(s2_obj)

类属性和实例属性

如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。

class People(object):

    country = 'china' #类属性

print(People.country)

p = People()

print(p.country)

p.country = 'japan'

print(p.country) #实例属性会屏蔽掉同名的类属性

print(People.country)

del p.country #删除实例属性

print(p.country)

类的静态方法和类方法

实例方法

定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；

调用：只能由实例对象调用。

类方法

定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；

原则上，类方法是将类本身作为对象进行操作的方法。假设有个方法，且这个方法在逻辑上采用类本身作为对象来调用更合理，那么这个方法就可以定义为类方法。另外，如果需要继承，也可以定义为类方法。example：学生类的总人数

调用：实例对象和类对象都可以调用。

静态方法

定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

调用：实例对象和类对象都可以调用。

可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。