python-基础-面象对象

1 类和对象

定义类

定义一个类，格式如下：



class 类名:

    方法列表

demo：定义一个Car类

# 定义类

class Car:

    # 方法

    def getCarInfo(self):

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

    def move(self):

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

说明：

定义类时有2种：新式类和经典类，上面的Car为经典类，如果是Car(object)则为新式类
类名的命名规则按照"大驼峰"

创建对象

通过上一节课程，定义了一个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)

总结：

BMW = Car()，这样就产生了一个Car的实例对象，此时也可以通过实例对象BMW来访问属性或者方法
第一次使用BMW.color = '黑色'表示给BMW这个对象添加属性，如果后面再次出现BMW.color = xxx表示对属性进行修改
BMW是一个对象，它拥有属性（数据）和方法（函数）
当创建一个对象时，就是用一个模子，来制造一个实物

2 init和del

__init__()方法

<1>使用方式

def 类名:

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

    def __init__():

        pass

<2>__init__()方法的调用



# 定义汽车类

class Car:

    def __init__(self):

        self.wheelNum = 4

        self.color = '蓝色'

    def move(self):

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

# 创建对象

BMW = Car()

print('车的颜色为:%s'%BMW.color)

print('车轮胎数量为:%d'%BMW.wheelNum)

总结1

当创建Car对象后，在没有调用__init__()方法的前提下，BMW就默认拥有了2个属性wheelNum和color，原因是__init__()方法是在创建对象后，就立刻被默认调用了



# 定义汽车类

class Car:

    def __init__(self, newWheelNum, newColor):

        self.wheelNum = newWheelNum

        self.color = newColor

    def move(self):

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

# 创建对象

BMW = Car(4, 'green')

print('车的颜色为:%s'%BMW.color)

print('车轮子数量为:%d'%BMW.wheelNum)

总结2

__init__()方法，在创建一个对象时默认被调用，不需要手动调用
__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去

3 魔法方法和self

1. 打印id()

如果把BMW使用print进行输出的话，会看到如下的信息

即看到的是创建出来的BMW对象在内存中的地址

2. 定义__str__()方法

class Car:

    def __init__(self, newWheelNum, newColor):

        self.wheelNum = newWheelNum

        self.color = newColor

    def __str__(self):

        msg = "嘿。。。我的颜色是" + self.color + "我有" + int(self.wheelNum) + "个轮胎..."

        return msg

    def move(self):

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

BMW = Car(4, "白色")

print(BMW)

总结

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

self

1. 理解self

看如下示例:

# 定义一个类

class Animal:

    # 方法

    def __init__(self, name):

        self.name = name

    def printName(self):

        print('名字为:%s'%self.name)

# 定义一个函数

def myPrint(animal):

    animal.printName()

dog1 = Animal('西西')

myPrint(dog1)

dog2 = Animal('北北')

myPrint(dog2)

运行结果:

总结

所谓的self，可以理解为自己
可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思
某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可

4 属性

保护对象的属性

如果有一个对象，当需要对其进行修改属性时，有2种方法

对象名.属性名 = 数据 ---->直接修改
对象名.方法名() ---->间接修改

为了更好的保存属性安全，即不能随意修改，一般的处理方式为

将属性定义为私有属性
添加一个可以调用的方法，供调用

class People(object):

    def __init__(self, name):

        self.__name = name

    def getName(self):

        return self.__name

    def setName(self, newName):

        if len(newName) >= 5:

            self.__name = newName

        else:

            print("error:名字长度需要大于或者等于5")

xiaoming = People("dongGe")

print(xiaoming.__name)

class People(object):

    def __init__(self, name):

        self.__name = name

    def getName(self):

        return self.__name

    def setName(self, newName):

        if len(newName) >= 5:

            self.__name = newName

        else:

            print("error:名字长度需要大于或者等于5")

xiaoming = People("dongGe")

xiaoming.setName("wanger")

print(xiaoming.getName())

xiaoming.setName("lisi")

print(xiaoming.getName())

总结

Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。

类属性、实例属性

在了解了类基本的东西之后，下面看一下python中这几个概念的区别

先来谈一下类属性和实例属性

在前面的例子中我们接触到的就是实例属性（对象属性），顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问

类属性

class People(object):

    name = 'Tom'  #公有的类属性

    __age = 12     #私有的类属性

p = People()

print(p.name)           #正确

print(People.name)      #正确

print(p.__age)            #错误，不能在类外通过实例对象访问私有的类属性

print(People.__age)        #错误，不能在类外通过类对象访问私有的类属性

实例属性(对象属性)

class People(object):

    address = '山东' #类属性

    def __init__(self):

        self.name = 'xiaowang' #实例属性

        self.age = 20 #实例属性

p = People()

p.age =12 #实例属性

print(p.address) #正确

print(p.name)    #正确

print(p.age)     #正确

print(People.address) #正确

print(People.name)    #错误

print(People.age)     #错误

通过实例(对象)去修改类属性

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)

总结

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

5 单继承和多继承

2. 继承示例

# 定义一个父类，如下:

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("印度猫")

print('bs的名字为:%s'%bs.name)

print('bs的颜色为:%s'%bs.color)

bs.eat()

bs.setNewName('波斯')

bs.run()

运行结果:

说明：

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

总结

子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类

3. 注意点

私有的属性，不能通过对象直接访问，但是可以通过方法访问
私有的方法，不能通过对象直接访问
私有的属性、方法，不会被子类继承，也不能被访问
一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

多继承

Python中多继承的格式如下:

# 定义一个父类

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

obj_C = C()

obj_C.printA()

obj_C.printB()

运行结果:

----A----

----B----

说明

python中是可以多继承的
父类中的方法、属性，子类会继承

注意点

想一想:

如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？

#coding=utf-8

class base(object):

    def test(self):

        print('----base test----')

class A(base):

    def test(self):

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

# 定义一个父类

class B(base):

    def test(self):

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

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

class C(A,B):

    pass

obj_C = C()

obj_C.test()

print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序

6 多态和重写

多态

多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

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

Python伪代码实现Java或C#的多态

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'

# 由于在Java或C#中定义函数参数时，必须指定参数的类型

# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类

# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):

    """Func函数需要接收一个F1类型或者F1子类的类型"""

    print obj.show()

s1_obj = S1()

Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()

Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

Python “鸭子类型”

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)

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

1. 重写父类方法

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

#coding=utf-8

class Cat(object):

    def sayHello(self):

        print("halou-----1")

class Bosi(Cat):

    def sayHello(self):

        print("halou-----2")

bosi = Bosi()

bosi.sayHello()

2. 调用父类的方法

#coding=utf-8

class Cat(object):

    def __init__(self,name):

        self.name = name

        self.color = 'yellow'

class Bosi(Cat):

    def __init__(self,name):

        # 调用父类的__init__方法1(python2)

        #Cat.__init__(self,name)

        # 调用父类的__init__方法2

        #super(Bosi,self).__init__(name)

        # 调用父类的__init__方法3

        super().__init__(name)

    def getName(self):

        return self.name

bosi = Bosi('xiaohua')

print(bosi.name)

print(bosi.color)

静态方法和类方法

1. 类方法

是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。

class People(object):

    country = 'china'

    #类方法，用classmethod来进行修饰

    @classmethod

    def getCountry(cls):

        return cls.country

p = People()

print p.getCountry()    #可以用过实例对象引用

print People.getCountry()    #可以通过类对象引用

类方法还有一个用途就是可以对类属性进行修改：

class People(object):

    country = 'china'

    #类方法，用classmethod来进行修饰

    @classmethod

    def getCountry(cls):

        return cls.country

    @classmethod

    def setCountry(cls,country):

        cls.country = country

p = People()

print p.getCountry()    #可以用过实例对象引用

print People.getCountry()    #可以通过类对象引用

p.setCountry('japan')   

print p.getCountry()

print People.getCountry()

结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变

2. 静态方法

需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数

class People(object):

    country = 'china'

    @staticmethod

    #静态方法

    def getCountry():

        return People.country

print People.getCountry()

总结

从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用

巴特西

python-基础-面象对象

1 类和对象

2 init和del

3 魔法方法和self

4 属性

5 单继承和多继承

6 多态和重写

静态方法和类方法

最新文章

热门文章

巴特西

python-基础-面象对象

1 类和对象

2 __init__和__del__

3 魔法方法和self

4 属性

5 单继承和多继承

6 多态和重写

静态方法和类方法

最新文章

热门文章

2 init和del