零基础学Python 基础班 第十二章 面向对象

zzzzzzzzzzzzzzzzzzzzzzzzzzzz@[TOC](零基础学Python 基础班 第十二章 面向对象)

第十二章 面向对象

面向对象三大特性
• 封装 确保对象中数据的安全
• 基础 保证了对象的扩展性
• 多态 保证了程序的灵活性

1 面向对象简介

Python是一⻔面向对象的编程语言
所谓面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的。面向过程指将我们的程序分解为一个一个步骤，通过对每个步骤的抽象来完成程序这种编写方式往往只适用于一个功能，如果要实现别的功能，往往复用性比较低这种编程方式符号人类的思维，编写起来比较容易
1.妈妈穿衣服穿鞋出⻔
2.妈妈骑上电动车
3.妈妈到超市口放好电动
4.妈妈买瓜
5.妈妈结账
6.妈妈骑电动⻋回家
7.到家孩子吃瓜
面向对象的编程语言，关注的是对象，而不注重过程，对于面向对象一切皆对象以上方式可以用孩子妈妈给孩子买瓜来解决面向对象的编程思想，将所有功能统一保存到对应的对象中，要使用某个功能，直接找到对应的对象即可这种编码方式比较容易阅读，并且易于维护，容易复用。但是编写的过程中不太符合常规的思维，编写相对麻烦

2 类(class)

2.1 类的简介

。我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以我们在开发中经常要自定义一些对象类，简单理解它就是相当于一个图纸，在程序汇总我们需要根据类来创建对象。类就是对象的图纸
。我们也称**对象是类的实例(instance)**如果多个对象是通过一个类创建的，我们称这些对象是一类对象
语法：class 类名([父类]):（自定义类一般要求大写字母开头，大驼峰命名法）
。类也是一个对象，类就是用来创建对象的.
。对象可以向对象中添加变量，对象中的变量称之为属性
。语法：对象.属性名 = 属性值

class My_class():
	pass
#mc,mc1,mc2,mc3都是My_class()的实例，他们都是一类对象
mc = My_class()
mc1 = My_class()
mc2 = My_class()
mc3 = My_class()
# isinstance用来检查某个对象是否是某个类的实例,语法instancemc(实例对象，类名)
print(isinstance(mc,My_class))
print(isinstance(mc1,My_class))
print(isinstance(mc2,My_class))
print(isinstance(mc3,My_class))
mc1.name = '钢铁侠'
print(mc1.name)

执行结果为

E:\python练习\venv\Scripts\python.exe E:/python练习/class.py
True
True
True
True
钢铁侠
Process finished with exit code 0

2.2 类的定义

类和对象都是对现实生活中事物的抽象事物,包含两部分
1. 数据(属性)
2. 行为(方法)
调用方法对象.方法名()方便调用和函数调用的区别：如果是函数调用，调用时有几个形参，就会传递几个实参。如果是方法调用，默认传递一个参数，所以方法中至少得有一个形参在类代码块中，
我们可以定义变量和函数.
类中定义的变量会成为该类实例的公共属性，所有的该实例都可以通过对象.属性名的形式访问函数会成为该类实例的公共方法，所有该类实例都可以通过对象.方法名的形式访问。

class person():
    gender = 'male'
    country = 'china'
    def speak(self):
        print('hello')
p1 = person()
p2 = person()
print(p1.gender,p2.country)
p2.speak()

执行结果

E:\python练习\venv\Scripts\python.exe E:/python练习/class.py
male china
hello

Process finished with exit code 0

3 self 参数

3.1 属性和方法

。当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错类
。对象和实例对象中都可以保存属性(方法)。如果这个属性(方法)是所以的实例共享的，则应该将其保存到类对象中。如果这个属性(方法)是摸个实例独有的。则应该保存到实例对象中。一般情况下，属性保存到实例对象中而方法需要保存到类对象中

class person():
    gender = 'male'
    country = 'china'
p1 = person()
p2 = person()
p1.gender = 'female'
print(p1.gender)
print(p2.age)

执行结果

E:\python练习\venv\Scripts\python.exe E:/python练习/self.py
Traceback (most recent call last):
  File "E:/python练习/self.py", line 8, in <module>
    print(p2.age)
AttributeError: 'person' object has no attribute 'age'
female

Process finished with exit code 1

3.2 self

self 在定义时需要定义，但是在调用时会自动传入。
self的名字并不是规定死的，但是最好还是按照约定是用self。
self总是指调用时的类的实例

class person():
    gender = 'male'
    country = 'china'
    name = '美猴王'
    def speak(self):
        print('你好,我是%s'%self.name)
p1 = person()
p2 = person()
p1.name = '猪八戒'
p2.name = '唐僧'
p1.speak()
p2.speak()

执行结果如下：

E:\python练习\venv\Scripts\python.exe E:/python练习/self.py
你好,我是猪八戒
你好,我是唐僧

Process finished with exit code 0

4 特殊方法

class Person:
    name = '葫芦娃'
    def speak(self):
        print('我是%s'%self.name)
p1 = Person()
p2 = Person()
p3 = Person()
p1.speak()

而在实际中，实例的属性是各不相同的，那么属性就不适合写在类中，所以我们这么写

class Person:
    # name = '葫芦娃'
    def speak(self):
        print('我是%s'%self.name)
p1 = Person()
p1.name = '钢铁侠'
p2 = Person()
p2.name = '緑巨人'
p3 = Person()
p3.name = '黑寡妇'
p1.speak()
p2.speak()
p3.speak()

对于Person类来说，name属性是必须的，而且又是不同的，那么我们希望在创建对象时，必须设置name属性，如果不设置，则对象无法创建，避免手动创建和报错。
在类中可以定义一些特殊方法也称为魔术方法
特殊方法都是形如 xxx()这种形式
特殊方法不需要我们调用，特殊方法会在特定时候自动调用
类中的代码块优先于方法中的代码块，且只执行一次
特上述方法在实例对象创建后立即执行
那么，综合以上问题和需求，可以这么写

class Person:
    def __init__(self,name):
            self.name = name
    def speak(self):
        print('我是%s'%self.name)
p1 = Person('钢铁侠')
p2 = Person('蜘绿巨人')
p3 = Person('黑寡妇')
p1.speak()
p2.speak()
p3.speak()

通过以上，我们可以看出类的基本结构如下：

class 类名（[父类]）：
	#公共属性...
	#对象的初始化方法
	def __init__(self,...):
		代码块
	#其他方法
	def m1(self,...):
		代码块
	def m2(self,...):
		代码块
	......
	```
**特殊方法的学习**
。什么时候调用
。什么作用
## 5 封装
### 5.1 封装的引入
我们来做一个小的练习
```python
class Car:
    def __init__(self,name,color):
        self.name = name
        self.color = color
    def run(self):
        print('汽车开始跑了')
    def laba(self):
        print('%s滴滴滴滴滴'%self.name)
c1 = Car('大奔','白色')
print(c1.name,c1.color)
c1.laba()
c1.name = '法拉利'
c1.laba()

由上可以看出，我们可以通过对象.属性来修改属性，这样就导致了属性的修改具有随意性，那么我们需要一种方式来增强数据的安全性：
• 1. 属性不能随意修改
• 2. 属性不能改为任意的值

5.2 封装的特性

• 封装是面向对象的三大特性之一
• 封装是指隐藏对象中一些不希望被外部所访问到的属性或方法

class Dog:
    def __init__(self,name):
          self.hidden_name = name
    def speak(self):
        print('大家好,我是%s'%self.hidden_name)
d = Dog('德牧')
d.name = '二哈'
d.speak()

上述代码中可以看出，我们可以将对象的属性名称修改成一个外部不知道的名字来防止被修改
那么，问题来了，我们如何获取（修改）对象的属性呢？
我们也可以提供给一个**getter()和setter()**方法使外部可以访问到属性
• getter() 获取对象中指定的属性
• setter() 用来设置对象指定的属性
如下：

class Dog:
    def __init__(self,name):
        self.hidden_name = name
    def speak(self):
        print('大家好,我是%s'%self.hidden_name)
    def get_name(self):
        # get_name()用来获取对象的name属性
        return self.hidden_name
    def set_name(self,name):
        # gset_name()用来修改对象的name属性
        self.hidden_name = name
d = Dog('德牧')
d.speak()
print(d.get_name())
d.set_name('二哈')
d.speak()

使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
• 1. 隐藏属性名，使调用者无法随意的修改对象中的属性
• 2. 增加了getter()和setter()方法，很好控制属性是否是只读的
• 3. 使用setter()设置属性，可以增加数据的验证

class Dog:
    def __init__(self,name,age):
        self.hidden_name = name
        self.hidden_age = age
    def speak(self):
        print('大家好,我%s岁'%self.hidden_age)
    def get_age(self):
        return self.hidden_age
    def set_age(self,age):
        if age > 0:
            self.hidden_age = age
d = Dog('德牧',5)
d.speak()
d.set_age(-8)
d.speak()

上面代码中狗的年龄明显不可能是负数，通过set方法对数据进行验证
• 4. 使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理

class Dog:
    def __init__(self,name,age):
        self.hidden_name = name
        self.hidden_age = age
    def speak(self):
        print('大家好,我%s岁'%self.hidden_age)
    def get_age(self):
        print('用户获取了属性')
        return self.hidden_age
    def set_age(self,age):
        print('用户修改了属性')
        if age > 0:
            self.hidden_age = age
d = Dog('德牧',5)
d.set_age(8)
print(d.get_age())

上面的代码可以看出，可以通过用户获取和修改属性来记录用户行为，从而做出有效判断
但是，上面的隐藏方法依然是可以修改的，那么有没有一种方法是外部无法修改的呢？
• 可以为对象的属性使用双下划线开头 __xxx。双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问

class Person():
    def __init__(self,name):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self,name):
        self.__name = name
p = Person('葫芦娃')
p.__name = '钢铁侠'
print(p.get_name())

执行的效果如下：

E:\python练习\venv\Scripts\python.exe E:/python练习/封装.py
葫芦娃

Process finished with exit code 0

我们从执行的效果来看，__xxx的方法无法从外部进行修改
但是事实上，这种隐藏属性只不过是Python自动为属性改了一个名字 --> _类名__属性名 例如 __name -> _Person__name

class Person():
    def __init__(self,name):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self,name):
        self.__name = name
p = Person('葫芦娃')
# p.__name = '钢铁侠'
p._Person__name = '钢铁侠'
print(p.get_name())

• 这种方式实际上依然可以在外部访问，所以这种方式我们一般不用。一般我们会将一些私有属性以_开头
如下：

class Person():
    def __init__(self,name):
        self._name = name
    def get_name(self):
        return self._name
    def set_name(self,name):
        self._name = name
p = Person('葫芦娃')
print(p._name)

• 一般情况下,使用_开头的属性都是私有属性，没有特殊情况下不要修改私有属性

5.3 property装饰器

我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改

class Person():
    def __init__(self,name):
        self._name = name
    def name(self):
        return self._name
    def set_name(self,name):
        self._name = name
p = Person('葫芦娃')
print(p.name())

如果，我们想打印‘print(p.name)’正常就会报错‘<bound method Person.name of <main.Person object at 0x0000000001EB1828>>’，那么怎么做呢

class Person():
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        return self._name
    def set_name(self,name):
        self._name = name
p = Person('葫芦娃')
#print(p.name())会报错TypeError: 'str' object is not callable
print(p.name)

getter方法的装饰器是@property，如上代码
setter方法的装饰器是@属性名.setter，如下代码

class Person:
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        print('getter方法执行了')
        return self._name
    @name.setter
    def name(self,name):
        self._name = name
p = Person('葫芦娃')
print(p.name)
p.name = ('钢铁侠')
print(p.name)

6 继承

6.1. 继承简介

#我们先定义一个简单的动物类
class Animal:
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
a = Animal()
a.run()

.我们想写狗，狗有特殊功能可以汪汪叫，还可以看家护院

class Animal:
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
    def speak(self):
        print('汪汪')
a = Animal()
a.run()

。上面这么写明显是不合适的，违反了ocp原则，于是我们重新新建一个狗类

class Animal:
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
class Dog():
    def run(self):
        print('狗跑')
    def sleep(self):
        print('狗睡觉')
    def speak(self):
        print('狗汪汪')
a = Animal()
a.run()

。以上的代码中，我们解决了之前的问题，但是创建新类也带来了新的问题，代码粘贴复制麻烦，代码重复性高
这就用到了对象的三大特性之一 - 继承

class Animal():
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
class Dog(Animal):
    def speak(self):
        print('汪汪')
d = Dog()
d.run()
d.speak()
#我们也可以检查一下d是否是以上两个类的实例
r = isinstance(d,Dog)
s = isinstance(d,Animal)
print(r)
print(s)
#在创建类时，如果没有指定父类，那么默认父类是object，object是所有类的父类。那么怎么检查一个类是否是另一个类的自雷呢？--> issubclass
print(issubclass(Dog,Animal))# True
class Person():
	pass
print(issubclass(Person,object))# True	

• 通过继承我们可以使一个类获取到其他类中的属性和方法
• 在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
• 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性

6.2 方法重写

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)

class Animal():
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
class Dog(Animal):
    def run(self):
        print('狗跑')
    def speak(self):
        print('狗汪汪')
d = Dog()
d.run()

执行结果为

E:\python练习\venv\Scripts\python.exe E:/python练习/继承和多态.py
狗跑

Process finished with exit code 0

• 当我们调用一个对象的方法时：
• 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
• 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
• 如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了

6.3 super()

class Animal():
    def __init__(self,name):
        self._name = name
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def __init__(self,name,age):
        self._name = name
        self._age = age
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,age):
        self._age = age
    def run(self):
        print('狗跑')
    def speak(self):
        print('汪汪')
d = Dog('二哈',8)
d.name = '德牧'
print(d.name)
print(d.age)

上面的代码中可以看出，父类的属性越多，我们在书写以及修改时，需要些的就更多，但是并不是所有的属性都是我们需要的，那么我们需要一种方法来初始化父类属性，这个方法就是父类.__init__方法，同时需要一种方法动态获取父类****，这个方法就是super()**
• super()可以获取当前类的父类
• 并且通过super()返回对象调用父类方法时，不需要传递self
那么，修改后的代码如下：

class Animal():
    def __init__(self,name):
        self._name = name
    def run(self):
        print('动物跑')
    def sleep(self):
        print('动物睡觉')
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def __init__(self,name,age):
        super().__init__(name)
        self._age = age
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,age):
        self._age = age
    def run(self):
        print('狗跑')
    def speak(self):
        print('汪汪')
d = Dog('二哈',8)
d.name = '德牧'
print(d.name)
print(d.age)

6.4 多重继承

bases 用来获取当前类的所有父类，
用法是类名.bases
在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
可以在类名的()后边添加多个类，来实现多重继承
多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

class A(object):
    def text(self):
        print('A..')
class B(object):
    def text2(self):
        print('B..')
class C(A,B):
    def text3(self):
        print('C..')
print(C.__bases__)
c = C()
c.text()
c.text3()

执行的结果如下：

E:\python练习\venv\Scripts\python.exe E:/python练习/继承和多态.py
(<class '__main__.A'>, <class '__main__.B'>)
A..
C..

Process finished with exit code 0

7 多态

• 多态是面向对象的三大特性之一。从字面理解就是多种形态
• 一个对象可以以不同形态去呈现

class A():
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name
class B():
    def __init__(self,name):
        self._name = name
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name = name
class C():
    pass
a = A('葫芦娃')
b = B('钢铁侠')
c = C()
def speak(obj):
    print('你好我是%s'%obj.name)

# speak(a) # 你好我是葫芦娃
# speak(b) # 你好我是钢铁侠
# speak(c) # AttributeError: 'C' object has no attribute 'name'

# 对于speak()这个函数来说，只要对象中含有name属性，他就可以作为参数传递
# 这个函数不考虑对象的类型，只要有name属性即可
def speak2(obj):
    if isinstance(obj,A):
        print('你好，我是%s'%obj.name)
speak2(a)# 你好，我是葫芦娃
speak2(b)#
# 在speak2()中我们做了一个类型检查，也就是只有满足obj是类型A的对象时，才可以使用该函数
# 其他类型的对象无法使用该函数，这个函数就违反了多态

其实，在我们日常的学习中见到了很多这样的例子：

lst = [1,2,3]
s = 'python'
print(len(lst)) #3
print(len(s)) # 6
# len()函数之所以能够获取长度，是因为这个对象中有一个特殊函数__len__
# 只要对象汇中函数__len__函数，就可以用通过len()函数来获取长度

8 属性和方法深入

8.1 属性深入

属性分为类属性和实例属性
话不多说，先上代码

class A(object):
    # 创建类属性
    count = 0
a = A()
print('A',A.count)
print('a',a.count)

大家猜测，结果是什么?

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
A 0
a 0

Process finished with exit code 0

以上说明了类属性可以通过类和实例访问到
代码继续

class A(object):
    # 创建类属性
    count = 0
    def __init__(self):
        self.name = '葫芦娃'
a = A()
a.count = 10
A.count = 100
print('A',A.count)
print('a',a.count)

结果又会是什么呢？

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
A 100
a 10
Process finished with exit code 0

以上说明，类属性只能通过类对象来修改，无法通过实例对象来修改
代码继续

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
a = A()
print('a',a.name)
print('A',A.name)

结果会是什么呢？

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
a 葫芦娃
Traceback (most recent call last):
  File "E:/python练习/基础班/属性和方法深入.py", line 13, in <module>
    print('A',A.name)
AttributeError: type object 'A' has no attribute 'name'

Process finished with exit code 1

以上说明了，实例属性只能通过实例对象访问和修改，类对象无法访问和修改。

8.2 方法深入

方法分为类方法、实例方法和静态方法
话不多说，上代码

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
    #创建类方法
    def test(self):
        print('这是test方法....',self)
a = A()
a.test()

结果是什么呢？

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
这是test方法.... <__main__.A object at 0x0000000002801710>
Process finished with exit code 0

那么，能否通过类访问到呢？

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
    #创建类方法
    def test(self):
        print('这是test方法....',self)
a = A()
A.test()

结果是什么呢？

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
Traceback (most recent call last):
  File "E:/python练习/基础班/属性和方法深入.py", line 18, in <module>
    A.test()
TypeError: test() missing 1 required positional argument: 'self'
Process finished with exit code 1

通过报错，我们知道这是类型错误，参数缺失，怎么做呢？

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
    #创建类方法
    def test(self):
        print('这是test方法....',self)
a = A()
A.test(a)

结果如何呢？

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
这是test方法.... <__main__.A object at 0x00000000027C1710>
Process finished with exit code 0

我们发现，和之前通过实例化对象访问的结果一致，总结如下：

• 在类定义中，以self作为第一个参数传入的都是实例化方法；
• 实例化方法在调用的时候，Python会自动将调用对象以self传入
• 当通过类取调用方法时，不会自动传入self，此时需要手动传入self。
• 怎么创建类方法呢，需要用到装饰器@classmethod，而且传入的参数默认不是self，而是cls，即那个类引用就是哪个类为参数
  代码如下：

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
    #创建类方法
    def test(self):
        print('这是test方法....',self)
    #创建实例化方法
    @classmethod
    def test2(cls):
        print('这是test2方法，他是一个类方法,....', cls)

a = A()
A.test2()

执行结果如下：

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
这是test2方法，他是一个类方法,.... <class '__main__.A'>
Process finished with exit code 0

那么类方法的调用机制是怎样的呢？

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
    #创建类方法
    def test(self):
        print('这是test方法....',self)
    @classmethod
    def test2(cls):
        print('这是test2方法，他是一个类方法,....', cls)
        print(cls.count)
a = A()
A.test2()
a.test2()

执行结果如下：

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
这是test2方法，他是一个类方法,.... <class '__main__.A'>
0
这是test2方法，他是一个类方法,.... <class '__main__.A'>
0

Process finished with exit code 0

以上总结如下：

• 实例方法和类方法主要看装饰器和参数
• A.test2（）等价于a.test2（）
• 静态方法的装饰器标志是@staticmethod
• 静态方法self为灰色，也就是说不需要指定任何参数，可以通过类和对象来访问静态方法
• 静态方法基本是一个和当前类无关的方法，只是保存到当前类的函数
• 静态方法一般是一些工具方法，和当前类无关
• 静态方法和函数的区别在于：静态方法必须通过类或者实例来调用，而函数可以直接调用

class A(object):
    # 创建类属性
    count = 0
    # 创建实例属性，指通过实例添加的属性
    def __init__(self):
        self.name = '葫芦娃'
    #创建类方法
    def test(self):
        print('这是test方法....',self)
    @classmethod
    def test2(cls):
        print('这是test2方法，他是一个类方法,....', cls)
        print(cls.count)
    @staticmethod
    def test3():
        print('这是一个静态方法')
a = A()
A.test3()
a.test3()

执行结果如下：

E:\python练习\venv\Scripts\python.exe E:/python练习/基础班/属性和方法深入.py
这是一个静态方法
这是一个静态方法

Process finished with exit code 0