"人生苦短，我用Python"--面向对象

Python语言之面向对象

前言

面向对象 -- Object Oriented 简写：OO
面向对象设计 -- Object Oriented Design 简写：OOD
面向对象编程 -- Object Oriented Programming 简写：OOP
面向对象分析方法 -- Object Oriented Analysis 简写：OOA

一、面向过程与面向对象

1.面向过程--怎么做？

1. 把完成某一个需求的所有步骤，从头到尾逐步实现
2. 根据开发需求，将功能独立的代码封装成一个又一个函数
3. 最后完成的代码，就是顺序地调用不同的函数

特点

• 注重步骤与过程，不注重职责分工。
• 如果需求复杂，代码会变得很复杂。
• 开发复杂项目，没有固定的套路，开发难度很大。

2.面向对象--谁来做？

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法。

1. 在完成某一个需求前，首先确定职责——要做的事情（方法）
2. 根据职责确定不同的对象，在对象内部封装不同的方法（多个）
3. 最后完成的代码，就是顺序地让不同的对象调用不同的方法

特点

• 注重对象和职责，不同的对象承担起不同的职责。
• 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路。
• 需要在面向过程的基础上，再学习一些面向对象的语法。

二、类和对象

1.类和对象的概念

面向对象编程的两个核心概念：类和对象。

1. 类

• 类是一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用。

• 特征被称为属性，行为被称为方法

• 例：类就相当于制造玩具时的图纸，是一个模板，是负责创建对象的。

2. 对象

• 对象由类创建出来的一个具体存在，可以直接使用。

• 由哪一个类创建出来的对象，就拥有在哪一个类中定义的属性和方法

• 例：对象就相当于用图纸制造的玩具。

在程序开发中，应该先有类，再有对象。

2.类和对象的关系

• 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象

• 类只有一个，而对象可以有很多个 (不同的对象之间属性可能会各不相同)

• 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

3.类的设计

在使用面向对象开发前，应该首先分析需求，确定一下程序中需要包含哪些类。

在程序开发中，要设计一个类，通常需要满足以下三个要素类：

• 类的名称：这类事物的名称，满足大驼峰命名法(每个单词的首字母大写，单词与单词之间没有下划线)，比如Person。

• 类的属性：这类事物具有什么样的特征，比如性别。

• 类的方法：这类事物具有什么样的行为，比如说话。

补充

类名的确定：

名词提炼法，分析整个业务流程，出现的名词，通常就是找到的类。

属性和方法的确定：

对对象的特征描述，通常可以定义为属性。

对象具有的行为(动词)，通常可以定义成方法。

需求中没有涉及的属性或者方法在设计类时，不需要考虑。

三、面向对象基础语法

1.dir内置函数

在python中对象几乎是无所不在的，变量、数据、函数都是对象。

在python中可以使用以下两个方法验证：

• 在标识符/数据后输入一个.，然后按下TAB键，ipython会提示该对象能够调用的方法列表

• 使用内置函数dir()传入标识符/数据，可以查看对象内的所有属性及方法

注：__方法名__格式的方法是python提供的内置方法/属性。

2.定义简单的类

定义只包含方法的类

使用class关键字来声明一个类，语法格式如下：

class 类名: # 类名首字母大写

    def 方法1(self,参数列表);
        pass

    def 方法2(self,参数列表);
        pass

方法的格式与函数几乎一样，区别在于第一个参数必须是self。

根据类创建对象

根据类创建对象的语法格式如下：

对象变量 = 类名()

要想给对象添加属性，可以通过如下方式：

对象变量.新的属性名 = 值（不推荐使用）

面向对象程序举例

class Car:
    price = 0
    def drive(self):
        print("速度七十迈")

c = Car() # 实例化
c.drive() # 调用函数
print(f'c.price:{c.price}')  #输出价格
c.price = 10  #修改价格
print(f'c.price:{c.price}')
c.color = 'red'  #修改颜色
print(f'c.color:{c.color}')
Car.price = 100  #不实例化情况下修改价格
print(f'Car.price:{Car.price}')

引用概念

在面向对象开发中，引用的概念是同样适用的。

• 在python中使用类创建对象之后，c中仍然记录的是对象在内存中的地址，也就是c变量引用了新建的车对象

• 使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址(十六进制表示)

3.类、对象的属性和方法

• 类属性：定义在所有函数外边，不需要实例化直接进行使用，使用方法是：类名.属性。

• 对象属性：定义在构造函数__init__中，只有实例化后才可使用，使用方法是：对象.属性。

• 私有属性和私有方法：在属性名或者函数名前加入2个下划线__。

• 定义成员方法（成员函数）：在类内定义时必须有参数self，否则会报错。

4.方法中的self参数

• 在方法的列表中，第1个参数永远都是self。

• self的字面意思是自己，我们可以把它当做C++里面的this指针理解，表示的是对象自身。

• 当某个对象调用方法的时候，Python解释器会把这个对象作为第1个参数传给self，开发者只需要传递后面的参数就可以了。

使用self参数

由哪一个对象调用的方法，方法内的self就是哪一个对象的引用

• 在类封装的方法内部，self就表示当前调用方法的对象自己
• 调用方法时，程序员不需要传递self参数
• 在方法内部：可以通过self.访问对象的属性；也可以通过self.访问其他的对象方法

例：

class Dog:
    def __init__(self, color):
        self.color = color
    def printColor(self):
         print("小狗邦德的颜色为：%s" % self.color)
# 哪一个对象调用的方法，self就是哪一个对象的引用
dog1 =  Dog("白色") # 创建对象
dog1.printColor()

5.初始化方法

初始化方法

• 当使用类名()创建对象时，会自动执行以下操作：

1. 为对象在内存中分配空间--创建对象
2. 为对象的属性设置初始值--初始化方法(init)

• 这个初始化方法就是__init__方法，__init__是对象的内置方法

__init__方法是专门用来定义一个类具有哪些属性的方法

在初始化方法内部定义属性

• 在__init__方法内部使用self.属性名 = 属性的初始值就可以定义属性

• 定义属性之后，再使用类创建的对象，都会拥有该属性

初始化同时设置初始值

在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造：

1. 把希望设置的属性值，定义成__init__方法的参数
2. 在方法内部使用self.属性名 = 形参接收外部传递的参数
3. 在创建对象时，使用类名(属性1,属性2...)调用

6.内置方法和属性

序号	方法名	类型	作用
01	__del__	方法	对象被从内存中销毁前，会被自动调用
02	__str__	方法	返回对象的描述信息，print函数输出使用

__del__方法

• 在python中

1. 当使用类名()创建对象时，为对象分配完空间后，自动调用__init__方法
2. 当一个对象从内存中销毁前，会自动调用__del__方法

• 应用场景

1. __init__改造初始化方法，可以让创建对象更加灵活
2. __del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

• 生命周期

1. 一个对象从调用类名()创建，生命周期开始
2. 一个对象的__del__方法一旦被调用，生命周期结束
3. 在对象的生命周期内，可以访问对象属性，或者让对象调用方法

例：

class Car:
    def __init__(self,name):
        self.name = name
        print("%s 出场" % self.name)
    def __del__(self):
        print("%s 离场" % self.name)

car = Car("Lykan")
print(car.name)
# while True:
#     pass

__str__方法

• 在python中，使用print输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址(十六进制表示)

• 如果在开发中，希望print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了

注意：__str__方法必须返回一个字符串

例：

class Car:
    def __init__(self,name):
        self.name = name
        print("这是一辆 %s " % self.name)
    def __str__(self):
        # 必须返回一个字符串
        return "自定义内容[%s]" % self.name
car = Car("超级跑车")
print(car)

四、运算符重载

运算符重载

运算符重载是通过实现特定的方法使类的实例对象支持Python的各种内置操作 。例如：+运算符是类里提供的__add__这个函数，当调用+实现加法运算的时候，实际上是调用了__add__方法。

 方法                 说明                何时调用方法
__add__             加法运算           对象加法：x+y，x+=y
__sub__             减法运算           对象减法：x-y，x-=y
__mul__             乘法运算           对象乘法：x*y，x*=y
__diy__             除法运算           对象除法：x/y，x/=y
__getitem__         索引，分片         x[i]、x[i:j]、没有__iter__的for循环等
__setitem__         索引赋值           x[i]=值、x[i:j]=序列对象
__delitem__         索引和分片删除      del x[i]、del x[i:j]

加法运算符重载

加法运算是通过调用__add__方法完成重载的，当两个实例对象执行加法运算时，自动调用__add__方法。

z = x+y，执行加法运算，实质是调用__add__方法

例：

class Cat:
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        print('运算符被重载 ')
        print(f'{self.name} and {other.name}')
cat1 = Cat('白仔')
cat2 = Cat('黑仔')
print(cat1 + cat2)

索引和分片重载

跟索引相关的重载方法包括如下3个：

• __getitem__：索引、分片

• __setitem__：索引赋值

• __delitem__：索引和分片删除

1. __getitem__方法

在对实例对象执行索引、分片或者for迭代操作时，会自动调用__getitem__方法。

# 定义索引、分片运算符重载方法
def __getitem__(self, index):
    return self.data[index]

2. __setitem__方法

通过赋值语句给索引或者分片赋值时，调用__ setitem __方法实现对序列对象的修改。

def __setitem__(self, index, value):
    self.data[index] = value

3. __delitem__方法

当调用del方法时，实质上会调用__delitem__方法实现删除操作。

def __delitem__(self, index):
    del self.data[index]

*面向对象三大特征：封装、继承、多态

五、封装

1.封装

• 封装是面向对象编程的一大特点
• 面向对象编程的第一步：将属性和方法封装到一个抽象的类中
• 外界使用类创建对象，然后让对象调用方法
• 对象方法的细节都被封装在类的内部

例：

class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight
    def run(self):
        print("我正在体能锻炼")
        self.weight -= 1

    def eat(self):
        print("我正在补充营养")
        self.weight += 1

violet = Person('薇尔莉特', 41)
print("我的名字叫 %s , 体重是 %.2f 公斤" % (violet.name,violet.weight))
violet.run()
print("现在我的体重是 %.2f 公斤" % violet.weight)
violet.eat()
print("现在我的体重是 %.2f 公斤" % violet.weight)
print('-'*30)
darling = Person('02', 42)
print("我的名字叫 %s , 体重是 %.2f 公斤" % (darling.name,darling.weight))
darling.eat()
print("现在我的体重是 %.2f 公斤" % darling.weight)
darling.run()
print("现在我的体重是 %.2f 公斤" % darling.weight)

• 在对象的方法内部，是可以直接访问对象的属性的
• 同一个类创建的多个对象之间，属性互不干扰

封装的优点：

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

2.封装案例(士兵突击)

需求：

1. 士兵小七有一把98K
2. 士兵可以开火
3. 枪能够发射子弹
4. 枪可以装填子弹：增加子弹数量

class Gun:
    def __init__(self,model):
        self.model = model # 枪的型号
        self.bullet_count = 0 # 子弹的数量
    def add_bullet(self,count):
        self.bullet_count += count
    def shoot(self):
        if self.bullet_count <= 0: # 判断子弹数量
            print("[%s]没有子弹了" % self.model)
            return
        else:
            self.bullet_count -= 1
            print("[%s] BANG! [%d]" % (self.model,self.bullet_count))

class Soldier:
    def __init__(self,name):
        self.name = name
        self.gun = None # 定义枪
    # None关键字表示一个空对象,没有方法和属性,是一个特殊的常量
    def fire(self):
        if self.gun == None:
            print("未配置枪")
            return
        else:
            print("献出心脏 [%s]" % self.name)
            self.gun.add_bullet(5)
            self.gun.shoot()

g = Gun("98K")
s = Soldier("小七")
s.gun = g
s.fire()

3.身份运算符

身份运算符用于比较两个对象的内存地址是否一致--是否是对一个对象的引用

• 在python中针对None比较时，建议使用is判断

运算符	描述	实例
is	is是判断两个标识符是不是引用同一个对象	x is y 类似于 id(x) == id(y)
is not	is not是判断两个标识符是不是引用不同的对象	x is not y 类似于 id(x) !=id (y)

is与==的区别：

• is用于判断两个变量引用对象是否为同一个
• ==用于判断引用对象的值是否相等

4.私有属性和私有方法

应用场景

• 在实际开发中，对象的某些属性和方法，可能只希望在对象的内部被使用，而不希望在外部被访问到
• 私有属性就是对象不希望公开的属性
• 私有方法就是对象不希望公开的方法

定义方式

• 在定义属性或方法时，在属性名或方法名前增加两个下划线，定义的就是私有属性或方法

例：

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def secret(self):
        print("%s的年龄是%s岁" % (self.__name,self.__age))
        # 在对象的内部，是可以访问对象的私有属性的
    def __secret(self):
        print("%s的年龄是%s岁" % (self.__name,self.__age))

ming = Person('明明', 19)
ming.secret()
# print("%s的年龄是%s岁" % (ming.__name,ming.__age))
# 私有属性，在外界不能够被直接访问
# ming.__secret()
# 私有方法，同样不允许在外界直接访问

伪私有属性和方法(科普)

注：在日常开发中，不要使用这种方式来访问对象的私有属性或私有方法

在python中，并没有真正意义上的私有：

• 在给属性、方法命名时，实际上是对名称做了一些特殊处理，使得外界无法访问到
• 处理方式：在名称前面加上_类名->_类名__名称

六、继承

在程序中，继承描述的是事物之间的所属关系。

1.单继承

类的继承：是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，子类拥有父类的所有方法和属性。

单继承的语法格式：

class 子类名(父类名):
    pass

• 子类继承自父类，可以直接享用父类中已经封装好的方法，不需要再次开发
• 子类中应该根据职责，封装子类特有的属性和方法

例：

class Animal:
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s 会吃 " % self.name)
    def sleep(self):
        print("%s 会睡 " % self.name)

class Dog(Animal):
    def run(self):
        print("%s 会跑 " % self.name)

class Xiaotian(Dog):
    def fly(self):
        print("%s 会飞 " % self.name)

king = Xiaotian('哮天')
king.eat()
king.sleep()
king.run()
king.fly()

注意：子类不重写__init__，实例化子类时，会自动调用父类定义的__init__，但重写了__init__时，实例化子类，就不会调用父类已经定义的__init__。

专业术语：

• Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承
• Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生

继承的传递性：

• C类从B类继承，B类又从A类继承
• 那么C类就具有B类和A类的所有属性和方法

子类拥有父类以及父类的父类中封装的所有属性和方法。

2.方法的重写

• 子类拥有父类的所有属性和方法
• 子类继承自父类，可以直接享用父类中已经封装好的方法，不需要再次开发

应用场景：

• 在继承关系中，子类会自动拥有父类定义的方法，但是有时子类想要按照自己的方式实现方法，那么此时可以对父类中继承来的方法进行重写

重写父类有两种情况：

• 覆盖父类方法
• 对父类方法进行扩展

覆盖父类方法

• 如果在开发中，父类的方法实现和子类的方法实现完全不同
• 就可以使用覆盖的方法，在子类中重新编写父类的方法实现

具体的实现方法，就相当于在子类中定义了一个和父类同名的方法并且实现

重写之后，再运行时，只会调用子类中重写的方法，而不会调用父类封装的方法

例：

class Animal:
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s 会吃 " % self.name)
    def sleep(self):
        print("%s 会睡 " % self.name)

class Dog(Animal):
    def run(self):
        print("%s 会跑 " % self.name)

class Xiaotian(Dog):
    def fly(self):
        print("%s 会飞 " % self.name)
    def run(self):
        print("%s 迅雷不及掩耳之势 " % self.name)
# 如果子类中重写了父类的方法，在使用子类对象调用方法时，会调用子类中重写的方法
king = Xiaotian('哮天')
king.run()
king.eat()
king.sleep()
king.fly()

对父类方法进行扩展

• 如果在开发中，子类的方法实现中包含父类的方法实现(父类原本封装的方法实现是子类方法的一部分)
• 就可以使用扩展的方法：

1. 在子类中重写父类的方法
2. 在需要的位置使用super().父类方法来调用父类方法的执行
3. 代码其他位置针对子类的需求，编写子类特有的代码实现

关于super

• 在python中super是一个特殊的类
• super()就是使用super类创建出来的对象
• 最常使用的场景就是重写父类方法时，调用在父类中封装的方法实现

例：

class Animal:
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s 会吃 " % self.name)
    def sleep(self):
        print("%s 会睡 " % self.name)

class Dog(Animal):
    def run(self):
        print("%s 会跑 " % self.name)

class Xiaotian(Dog):
    def fly(self):
        print("%s 会飞 " % self.name)
    def run(self):
        # 针对子类特有的需求编写代码
        print("%s 迅雷不及掩耳之势 " % self.name)
        # 使用super()调用原本在父类中封装的方法
        super().run()
        # 增加其他子类代码
        print("金色闪光")
king = Xiaotian('哮天')
king.run()
king.eat()
king.sleep()
king.fly()

3.父类的私有属性和私有方法

1. 子类对象不能在自己的方法内部，直接访问父类的私有属性或私有方法
2. 子类对象可以通过父类的公有方法间接访问到私有属性或私有方法

• 私有属性、方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
• 私有属性、方法通常用于做一些内部的事情

例：

class A:
    def __init__(self):
        self.num1 = 1
        self.__num2 = 2
    def __test(self):
        print("父类的私有方法 %d %d" % (self.num1,self.__num2))
    def test(self):
        print("父类的公有方法 %d %d" % (self.num1,self.__num2))
        self.__test()

class B(A):
    def demo(self):
        # # 在子类的对象方法中，不能访问父类的私有属性
        # print("访问父类的私有属性 %d" % self.__num2)
        # # 不能调用父类的私有方法
        # self.__test()
        # 访问父类的公有属性
        print("公有属性 %d" % (self.num1))
        # 调用父类的公有方法
        self.test()

b = B()
print(b)
b.demo()

4.多继承

概念：多继承就是子类拥有多个父类，并且具有它们共同的特征，即子类继承了父类的方法和属性。

多继承的语法格式：

class 子类名(父类名1，父类名2...):
    pass

例：

class A:

    def test(self):
        print("test方法")

class B:
    def demo(self):
        print("demo方法")

class C(A,B):
    pass

c = C()
c.test()
c.demo()

注意事项：

问题：如果不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪一个父类中的方法呢？

提示：开发时应尽量避免这种容易产生混淆的情况，如果父类之间存在同名的属性或者方法，应该尽量避免使用多继承

class A:
    def test(self):
        print("A--test方法")
    def demo(self):
        print("A--demo方法")

class B:
    def test(self):
        print("B--test方法")
    def demo(self):
        print("B--demo方法")

class C(A,B):
    pass

c = C()
# 如果子类继承的多个父类间是平行的关系，子类先继承的哪个类就会调用哪个类的方法
c.test()
c.demo()

MRO--方法搜索顺序

• python中针对类提供了一个内置属性__mro__，可以查看方法搜索顺序
• MRO主要用于在多继承时判断方法、属性的调用途径

print(C.__mro__)

• 在搜索方法时，是按照__mro__的输出结果从左至右的顺序查找的
• 如果在当前类中找到方法，就直接执行，不再搜索
• 如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索
• 如果找到最后一个类，还没有找到方法，程序报错

新式类与旧式(经典)类

object是python为所有对象提供的基类，提供一些内置的属性和方法，可以使用dir函数查看

• 新式类：以object为基类的类，推荐使用

• 旧式(经典)类：不以object为基类的类，不推荐使用

• 在python 3.x中定义类时，如果没有指定父类，会默认使用object作为该类基类

• 在python 2.x中定义类时，如果没有指定父类，则不会以object作为基类

新式类和旧式类在多继承时--会影响到方法的搜索顺序

注：如果没有父类，建议统一继承自object。

七、多态

概念：不同的子类对象调用相同的父类方法，产生不同的执行结果

• 多态可以增加代码的灵活度
• 以继承和重写父类方法为前提
• 是调用方法的技巧，不会影响到类的内部设计

多态案例

需求：

1. 在Dog类中封装方法game(普通狗：普通的玩耍)

2. 定义XiaoTian继承自Dog，并且重写game方法(哮天犬：腾云驾雾的玩耍)

3. 定义Person类，并且封装一个人和狗一起玩耍的方法(在方法内部，直接让狗对象调用game方法)

class Dog(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print("%s 普通的玩耍" % self.name)

class XiaoTian(Dog):
    def game(self):
        print("%s 腾云驾雾的玩耍" % self.name)

class Person(object):
    def __init__(self,name):
        self.name = name
    def game_with(self,dog):
        print("%s和%s 一起玩耍" % (self.name,dog.name))
        dog.game()

b = Person('阿妮亚')
a = Dog('邦德')
b.game_with(a)
a = XiaoTian('哮天')
b.game_with(a)

小结：

• Person类中只需要让狗对象调用game方法，而不关系具体是什么狗(game方法是在Dog父类中定义的)
• 在程序执行时，传入不同的狗对象实参，就会产生不同的执行效果

八、类的属性和方法

1.类的结构

实例

1. 使用面向对象开发，第一步是设计类
2. 使用类名()创建对象，创建对象的动作有两步：

• 1)在内存中为对象分配空间
• 2)调用初始化方法__init__为对象初始化

3. 对象创建后，内存中就有了一个对象的实实在在的存在--实例

类名()     ----->     __init__定义
                        实例属性
--------------------------------------------------
对象名.方法名()     ----->     实例方法(self)
                            对象1  对象2  对象3
                            属性1  属性1  属性1
                            属性2  属性2  属性2

因此，通常也会把：

• 创建出来的对象叫做类的实例
• 创建对象的动作叫做实例化
• 对象的属性叫做实例属性

在程序执行时：

1. 对象各自拥有自己的实例属性
2. 调用对象方法，可以通过self.

• 访问自己的属性
• 调用自己的方法

结论：

• 每一个对象都有自己独立的内存空间，保存各自不同的属性
• 多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用传递到方法内部

类是一个特殊的对象

python中一切皆对象：

• class AAA(): 定义的类属于类对象
• obj1 = AAA() 属于实例对象

• 在程序运行时，类同样会被加载到内存
• 在python中，类是一个特殊的对象(类对象)
• 在程序运行时，类对象在内存中只有一份，使用一个类可以创建出很多个对象实例
• 除了封装实例的属性和方法外，类对象还可以拥有自己的属性和方法(类属性；类方法)
• 通过类名.的方式可以访问类的属性或者调用的方法

类名.属性     ----->     类属性
类名.方法名()     ----->     类方法(cls)
# 该类的所有对象共享通过类名直接访问
类名()     ----->     __init__定义
                        实例属性
对象名.方法名()     ----->     实例方法(self)

2.类属性和实例属性

概念和使用

• 类属性就是给类对象中定义的属性
• 通常用来记录与这个类相关的特征
• 类属性不会用于记录具体对象的特征

例：

class Tool(object):
    count = 0
    # 使用赋值语句定义类属性，记录下所有工具对象的数量
    def __init__(self,name):
        self.name = name
        # 让类属性值+1
        Tool.count += 1

tool1 = Tool('斧头')
print("工具总数：%d" % Tool.count)
tool2 = Tool('锤子')
print("工具总数：%d" % Tool.count)
tool3 = Tool('镰刀')
print("工具总数：%d" % Tool.count)

属性获取机制

在python中属性的获取存在一个向上查找机制

想要获取count属性：tool1.count
1.首先在对象内部查找是否有对象属性
    tool1
name = Tool('斧头')
2.没有找到就会向上寻找类中是否存在类属性
    Tool
Tool count
name

因此，要访问类属性有两种方式：

• 类名.类属性
• 对象.类属性(不推荐)

注意：如果使用对象.类属性 = 值的赋值语句，只会给对象添加一个属性，而不会影响到类属性的值

例：

class AAA():
    aaa = 10

# 情形1
obj1 = AAA()
obj2 = AAA()
print(obj1.aaa, obj2.aaa, AAA.aaa)

# 情形2
obj1.aaa += 2
print(obj1.aaa, obj2.aaa, AAA.aaa)

# 情形3
AAA.aaa += 3
print(obj1.aaa, obj2.aaa, AAA.aaa)

3.类方法和静态方法

类方法

1. 类属性就是针对类对象定义的属性

• 使用赋值语句在class关键字下方可以定义类属性
• 类属性用于记录与这个类相关的特征

2. 类方法就是针对类对象定义的方法

• 在类方法中内部可以直接访问类属性或者调用其他的类方法

语法格式：

class 类名:
    @classmethod
    def 类方法名(cls):
        pass

3. 类方法需要用修饰器@classmethod来标识，告诉解释器这是一个类方法

4. 类方法的第一个参数应该是cls

• 由哪一个类调用的方法，方法内的cls就是哪一个类的引用
• 这个参数和实例方法的第一个参数self类似
• 提示：使用其他名称也可以，不过习惯使用cls

5. 通过类名调用类方法，调用方法时，不需要传递cls参数

6. 在方法内部：

• 可以通过cls.访问类的属性
• 也可以通过cls.调用其他的类的方法

例：

class Tool(object):
    count = 0
    @classmethod
    def show(cls):
        print("工具对象的数量 %d" % cls.count)
    def __init__(self,name):
        self.name = name
        Tool.count += 1

tool1 = Tool('斧头')
tool1.show()
tool1 = Tool('榔头')
tool1.show()

注意：类方法只能使用类变量，因为不用实例化就可以使用，所以调用对象变量会报错。

静态方法

1. 在开发时，如果需要在类中封装一个方法，这个方法：

• 既不需要访问实例属性，或者调用实例方法
• 也不需要访问类属性或者调用类方法

2. 这个时候，可以把这个方法封装成一个静态方法

语法格式：

class 类名:
    @staticmethod
    def 静态方法名():
        pass

3. 静态方法需要用修饰器@staticmethod来标识，告诉解释器这是一个静态方法

4. 通过类名.调用静态方法

例：

class Cat(object):

    @staticmethod
    def run():
    # 不访问实例属性/类属性
        print("跑...")

# 通过类名.调用静态方法，不需要创建对象
Cat.run()

补充：

• 静态方法是没有self参数，在静态方法中无法访问实例变量。

• 静态方法中不可以直接访问类属性，但是可以通过类名引用类属性。

• 静态方法跟定义它的类没有直接关系，只是起到了类似函数的作用。

结尾

不要让追求之舟停泊在幻想的港湾，而应扬起奋斗的风帆，驶向现实生活的大海。