Python面向对象基础

一、概念

1.1面向对象的设计思想

面向对象是基于万物皆对象这个哲学观点。在Python中，一切皆对象

举例说明：

案例一：我要吃大盘鸡

面向过程                            面向对象

1.自己去买菜                         1.委托一个会砍价的人帮忙去买菜

2.自己择菜                           2.委托一个临时工帮忙择菜

3.自己做菜                           3.委托一个厨师帮忙做菜

4.自己开始吃                         4.自己开始吃

案例二：小明是一个电脑小白，想要配一台电脑，买完零件后需要运到家里，组装完成后打开电脑玩游戏

面向过程                            面向对象

1.小明补充电脑知识                    1.委托一个懂电脑的朋友(老王)去帮忙买零件

2.小明去买零件                        2.委托一个能跑腿的人将零件运送到家里

3.小明把零件带回家里                   3.委托一个会组装电脑的人帮小明组装电脑

4.小明组装电脑                        4.小明自己打开电脑，开始玩游戏

5.小明开机玩电脑   

1.2 面向过程和面向对象

1.2.1 面向过程

• 在生活案例中：
  • 一种看待问题的思维方式，在思考问题的时候，着眼于问题是怎样一步一步解决的，然后亲力亲为的去解决问题
• 在程序中：
  • 代码从上而下顺序执行
  • 每一模块内部均是由顺序、选择和循环三种基本结构组成
  • 程序流程在写程序时就已决定

1.2.2 面向对象

• 在生活案例中：

  • 也是一种看待问题的思维方式，着眼于找到一个具有特殊功能的具体个体，然后委托这个个体去做某件事情，我们把这个个体就叫做对象，一切皆对象
  • 是一种更符合人类思考习惯的思想（懒人思想），可以将复杂的事情简单化，将程序员从执行者角度转换成了指挥者角度

• 在程序中：
  把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象

  • 对同类对象抽象出其共性，形成类
  • 类中的大多数数据，只能用本类的方法进行处理
  • 程序流程由用户在使用中决定
  • 使用面向对象进行开发，先要去找具有所需功能的对象，如果该对象不存在，那么创建一个具有该功能的对象

注：面向对象只是一种思想，并不是一门编程语言,也不会绑定编程语言

1.2.3 面向过程和面向对象的优缺点

• 面向过程：
  • 优点：性能比面向对象高，比如单片机、嵌入式开发等一般采用面向过程开发，因为性能是最重要的因素
  • 缺点：没有面向对象易维护，易复用，易扩展，开销比较大，比较消耗资源
• 面向对象：
  • 优点：易维护，易复用，易扩展，由于面向对象有封装，继承，多态的特性，可以设计出低耦合的系统，使得系统更加灵活，更加易于维护
  • 缺点：性能比面向过程低

注：使用面向对象的思维解决问题，核心：类和对象

二、类和对象

2.1 概念

• 类：一个具有特殊功能的实体的集合，是抽象的概念

• 对象：在一个类中，一个具有特殊功能的实体，能够帮忙解决特定的问题（对象也被称为实例），是具体的存在

• 两者之间的关系：类用于描述某一类对象的共同特征，而对象则是类的具体存在

• 先有对象还是先有类？

  • 先有对象，再有类：将多个具有共同特征的对象，提取出来一个类
  • 先有类，再有对象：定义类，通过类创建对象，在代码中常用

• 举例：

类                               对象

人                              张三、李四、王麻子、杨阳。。。

SuperHero                       蝙蝠侠、蜘蛛侠、美国队长。。。

快递                             顺丰、圆通、申通、韵达。。。

帮助理解：类也是一种数据类型，只不过是自定义的，跟所学过int、str、bool等类似。用类实例化对象相当于定义一个类的变量

num = 10
print(type(num))  # 

e = ValueError()   # 类实例化对象 /  定义一个类的变量
print(type(e))   # 

2.2 类的定义

• 语法

class  类名()：

    类体

• 说明

  • Python中使用class关键字定义类

  # 1.定义一个空类
  class MyClass1():
  pass
  class MyClass2():
  pass

  • 类名只要是一个合法的标识符即可，但是要求：遵循大驼峰命名法 ，如：KeyError，ValueError，NameError，IndexError…….
  • 尽量使用单个或多个有意义的单词连接而成
  • 通过缩进来体现类体的存在
  • 类体一般包含两部分内容：对类的特征描述（变量）和行为描述（函数）

  # 2.定义非空类
  class MyClass3():
    # 类体
    # a.对类的特征描述：变量
    num = 10
    name = 'zhangsan'
  
    # b.对类的行为描述：函数
    def show(self):
        print("showing")
  
    def func1(self):
        print("11111")

• 总结

  • 类的定义和函数的定义类似，但是，一个函数定义完毕之后，只有调用才会执行其中的代码；类定义完毕之后，其中的代码立马会被加载
  • 同一个py文件中可以定义多个类，但是在实际项目开发中，由于每个类实现的代码可能较为复杂，类的定义建议一个py文件一个类（创建一个包，一个模块中定义一个类）
  • 当一个类定义完成，类中的内容被称为类体，又被称为类的成员，当类被加载的时候，类中的成员也会被加载
  • 和函数相同，类也会引入新的作用域，所以在类中定义的变量或函数，在类的外面无法直接访问

  # 定义函数
  def check():
    print("函数————开始")
    print("函数————结束")
  
  # 定义类
  class MyClass3():
    print("类————开始")
    # 类体
    # a.对类的特征描述：变量
    num = 10
    name = 'zhangsan'
    # b.对类的行为描述：函数
    def show(self):
        print("showing")
    print("类————开始")
  
  print(num) # NameError: name 'num' is not defined.

  结果：类中的内容被打印出来，而函数没有；并且类中定义的变量在外面无法访问

  

2.3 对象的创建

对象又叫实例，所以对象的创建又可以叫：创建对象/实例化对象/类的实例化

2.3.1 类中未定义构造函数

构造函数之一：__init__

语法：变量 = 类名()

# 1.未定义构造函数：__init__
# 定义类
class Person():
    pass

# 语法：变量 = 类名()
# 创建对象
p1 = Person()
print(p1)  # <__main__.Person object at 0x000001D2AD83FC50>
p2 = Person()
print(p2)  # <__main__.Person object at 0x000001D2B0D78350>

解释：打印一个自定义类创建的对象，默认情况下，打印的是该对象在内存空间的地址<main.Person object at 0x10ec17400>

总结：

a.创建对象的过程，本质上就是定义变量的过程，该变量中存储的是创建出来的对象
b.打印一个自定义类创建的对象，默认情况下，打印的是该对象在内存空间的地址<__main__.Person object at 0x10ec17400>
c.一个普通类，可以创建无数个对象，每个对象在内存空间中拥有独立的地址
d.类名() 表示创建对象，但是该代码每执行一次，则表示创建一个新的对象

2.3.2 类中定义构造函数

语法：变量 = 类名(xxx,xxx...)，说明：xxx,xxx...类似于函数中的传参（实参）

class Animal():
    def __init__(self):
        print("init-----", id(self))  # init----- 2197353966096

a1 = Animal()
print("a1:", id(a1))  # a1: 2197353966096

根据打印结果可知，在init函数中的self为初始化的参数

• 构造函数__init__
  • 构造函数之一：__init__，表示初始化，给对象初始化
  • 形如__xxx__命名的函数，在Python中，成为魔术函数（魔术方法），此类函数无序手动调用，都会在特定的场景下自动调用
  • __init__：当我们创建对象的时候，会自动调用__init__函数
  • self：当前对象。无需传参，当创建对象的时候，会将当前创建的对象，自动传参给self。

类中定义构造函数，一般用于给当前对象进行特征的描述

语法：对象.变量 = 值

创建对象的时候，需不需要传参，传几个参数，一定要和__init__函数匹配

class Animal():
    def __init__(self, name, age, kind):
        print("init-----", id(self), name, age, kind)
        # 语法：对象.变量 = 值，表示给当前对象进行特征的描述
        self.name = name
        self.age = age
        self.kind = kind

# 注意：创建对象的时候，需不需要传参，传几个参数，一定要和__init__函数匹配
a1 = Animal("小白", 3, "猫")
print("a1:", id(a1))
print(a1.name, a1.age, a1.kind)

a2 = Animal('旺财',5,'田园犬')
# print('a2:',id(a2))
print(a2.name,a2.age,a2.kind)

使用__init__函数的好处就是提高代码的复用性，如果不使用__init__，创建多个对象时

class Animal():
 pass
a1 = Animal()
a1.name = '小白'
a1.age = 3
a1.kind = '猫'
print(a1.name,a1.age,a1.kind)

a2 = Animal()
a2.name = '旺财'
a2.age = 5   
a2.kind = '田园犬'
print(a2.name,a2.age,a2.kind)

代码需要重复的编写

2.4 类的设计

只需要关心3个要素

• 事物名称（类名）
  • 例：人类（Person）
• 特征（变量）
  • 例：身高（height）、年龄（age）————> 名词 ————>变量
• 行为（函数）
  • 例：跑（run）、打架（fight）—————> 动词 ————> 函数

注：初期学习，通过提炼动名词进行类的提取

三、类中的成员

3.1 变量/属性

类中的变量也可以叫属性，分为类属性（类的字段）和实例属性（对象属性，对象的字段）

3.1.1 总结

类属性【类的字段】和实例属性【对象属性，对象的字段】的区别

• 定义位置不同
  • 类属性直接定义在类中，只要是动态绑定的属性都是实例属性【在__init__中或在类的外面直接动态绑定定义】
• 访问方式不同
  • 类属性可以通过类名或对象访问，而实例属性只能通过对象访问
• 访问优先级不同
  • 当类属性和实例属性重名时，通过对象访问，优先访问的是实例属性
• 在内存中出现的时机不同
  • 类属性优先于实例属性出现在内存中，类属性随着类的加载而出现，实例属性是对象创建完毕之后才会出现
• 使用场景不同
  • 类属性用于表示多个对象共享的数据，实例属性表示每个对象特有的数据

3.1.2 代码解析

3.1.2.1 定义位置

class Person():
    # 1.定义的位置不同
    # 类属性：直接定义在类中
    place = "地球"

    # 实例属性体现形式一：只要是通过语法：对象.属性 = 值 定义的属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("小明", 10)
# 实例属性体现形式二
p1.hobby = "跳舞"

3.1.2.2 访问方式

基于上诉的类，进行对象访问

# 类属性可以通过类名或者对象访问

# 通过类名访问
print(Person.place)
# 通过对象访问
print(p1.place)

# 实例属性只能通过对象访问

# 通过对象访问
print(p1.name, p1.hobby)
# 通过类名访问,报错
# print(Person.name)  # AttributeError: type object 'Person' has no attribute 'name'

3.1.2.3 访问优先级

最后的结果为 11，为实例属性

# 3.访问优先级不同：当类属性和实例属性重名时，通过对象访问，优先访问的是实例属性
class Person():
    place = "地球"
    num = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("小明", 10)

p1.hobby = "跳舞"
p1.num = 11
print(p1.num)  # 11

3.1.2.4 在内存中出现的时机

在写代码时，一般都是先定义类，然后在编写对象；

所以当程序运行时，先加载类，即类属性随着类的加载而出现；后加载对象，即实例属性是对象创建完毕之后才会出现

3.1.2.5 使用场景不同

不同对象打印类属性，为同一个值

不同对象打印实例属性，为不同的值

修改其中的一个对象的实例属性，其他对象的实例属性不受印象，即分别表示不同的内存地址，相互之间不影响

修改类属性，所以所有对象的类属性都发生更改，即示同一个地址，如果类属性的值发生修改，则都会更改

class Person():
    place = "地球"

    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("小明", 10)
p2 = Person('小花', 12)
p3 = Person('张三', 11)
# 打印类属性，为同一个值
print(p1.place, p2.place, p3.place)
# 打印实例属性，为不同的值
print(p1.name, p2.name, p3.name)

# 修改其中的一个对象的实例属性，其他对象的实例属性不受印象，即分别表示不同的内存地址，相互之间不影响
p1.name = 'Jack'
print(p1.name, p2.name, p3.name)  # 分别表示不同的内存地址，相互之间不影响

# 修改类属性，所以所有对象的类属性都发生更改，即示同一个地址，如果类属性的值发生修改，则都会更改
Person.place = '火星'
print(p1.place, p2.place, p3.place)  # 表示同一个地址，如果类属性的值发生修改，则都会更改

3.2 动态绑定属性

3.2.1 动态绑定属性

给对象动态绑定属性，语法：对象.属性 = 值

默认情况下，可以给一个对象绑定任意名称、任意数量的属性，即没有限制

如：下面的代码中给对象p1，绑定了5个属性：name、age、hobby、score、zyx

class Person:

    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("小明", 10)
p1.hobby = "跳舞"
p1.score = 100
print(p1.name, p1.age, p1.hobby, p1.score)
p1.zyx = 33

3.2.2 限制对象属性的动态绑定

在实际应用中，在一些场景里面，需要对对象属性的动态绑定进行限制。

语法：在类中定义__slots__ = ('属性名1','属性名2'...)，等号右边为元组，即创建的对象属性只能为元组中的元素

注意事项：注意元组的写法，当元组中的元素只有一个的时候，不能忘记,

如：下面的代码中给对象p1，进行了限制对象属性的动态绑定，属性只能为：name、age、hobby、score。此时在定义对象属性zyx时，报错

# b.限制对象属性的动态绑定
class Person:
    # 限制对象属性的动态绑定
    __slots__ = ("name", "age", "hobby", "score")

    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("小明", 10)
p1.hobby = "跳舞"
p1.score = 100
print(p1.name, p1.age, p1.hobby, p1.score)
# p1.zyx = 33  # AttributeError: 'Person' object has no attribute 'zyx'

3.3 类中的函数/方法

类中的函数也可以成为方法，并且有三种类型：实例方法，类方法和静态方法

3.3.1 总结

实例方法，类方法和静态方法的区别和联系

不同点：

• 是否有装饰器装饰
  • 实例方法无需装饰器装饰，类方法需要使用@classmethod装饰，静态方法需要使用@staticmethod装饰
• 形参不同
  • 实例方法第一个参数必须是self，类方法的第一个参数是cls，静态方法的参数没有要求
• 调用方式不同
  • 实例方法只能通过对象调用，类方法和静态方法可以通过类名或者对象调用
• 使用场景不同
  • 如果要封装一个工具类，可以使用静态方法或类方法
  • 在实际项目开发中，使用实例方法较多

相同点：

• 可以使用默认参数，关键字参数，不定长参数
• 可以使用返回值

3.3.2 代码解析

3.3.2.1 装饰器、形参角度

类方法需要使用@classmethod装饰，第一个参数是cls，cls：表示当前类，如果需要自定义参数，添加到cls后面即可

实例方法无需装饰器装饰，第一个参数必须是self，self：表示当前对象，如果需要自定义参数，添加到self后面即可

静态方法需要使用@staticmethod装饰，只需要定义自定义的参数即可

class Person():
    # 1.特征：变量/属性
    # 类属性
    place = "地球"

    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 2.行为：函数/方法
    # 类函数：需要用@classmethod装饰器
    @classmethod
    def check(cls):  # cls：表示当前类，如果需要自定义参数，添加到cls后面即可
        pass

    # 实例函数，不需要装饰器
    def show(self):  # self：表示当前对象，如果需要自定义参数，添加到self后面即可
        pass

    # 静态函数，需要用@staticmethod装饰器
    @staticmethod
    def func():     # 只需要定义自定义的参数即可
        pass

3.3.2.2 调用方式不同

实例方法只能通过对象调用，类方法和静态方法可以通过类名或者对象调用

若通过类名调用实例方法，报错

注意事项：

1. 类函数中的变量cls和实例函数中的变量self，都是系统自动完成传参的，无需手动传参
   • 如下面代码，在类函数中打印cls的值，与在类外面直接打印类Person的值是一样的
2. 类中的函数相互调用，都必须遵循通过类名（即cls或对象（即cls创建对象或self）调用

class Person():
    place = "地球"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 类函数：需要用@classmethod装饰器
    @classmethod
    def check(cls):
        print('类函数~~~~~check')

    # 静态函数，需要用@staticmethod装饰器
    @staticmethod
    def func():
        print('静态函数~~~~~func')

    # 实例函数，不需要装饰器
    def show(self):
        print('实例函数~~~~~show')

# 创建一个对象
per = Person("小明", 20)

# 通过 类名 或者 对象 ，调用类函数
Person.check()
per.check()

# 通过 类名 或者 对象 ，调用静态函数
Person.func()
per.func()

# 只能通过 对象 调用实例函数
per.show()
# Person.show() # TypeError: Person.show() missing 1 required positional argument: 'self'

3.3.2.3 类中函数的相互调用

类中函数的相互调用，也需要遵守规则：实例方法只能通过对象调用，类方法和静态方法可以通过类名或者对象调用

类中的函数相互调用，都必须遵循通过类名（即cls)或对象（即通过cls创建对象或self）调用

• 在类函数中调用实例函数和静态函数

同样，在类中可以调用类属性

class Person():
    place = "地球"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 类函数：需要用@classmethod装饰器
    @classmethod
    def check(cls):
        print('类函数~~~~~check')

        # 创建对象
        obj = cls("张三", 11)

        # a1.在类函数中调用 实例函数 和 静态函数
        obj.show()

        # a2.在类函数中调用 静态函数
        cls.func()
        obj.show()

        # 在类函数中访问类属性
        print(obj.place)  # 通过对象访问类属性
        print(cls.place)  # 通过类访问类属性

    # 静态函数，需要用@staticmethod装饰器
    @staticmethod
    def func():
        print('静态函数~~~~~func')

    # 实例函数，不需要装饰器
    def show(self):
        print('实例函数~~~~~show')

# 调用类函数
Person.check()

输出结果

类函数~~~~~check
实例函数~~~~~show
静态函数~~~~~func
实例函数~~~~~show
地球
地球

• 在实例函数中调用类函数和静态函数

class Person():
    place = "地球"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 类函数：需要用@classmethod装饰器
    @classmethod
    def check(cls):
        print('类函数~~~~~check')

    # 静态函数，需要用@staticmethod装饰器
    @staticmethod
    def func():
        print('静态函数~~~~~func')

    # 实例函数，不需要装饰器
    def show(self):
        print('实例函数~~~~~show')
        # 在实例对象中调用 类函数 和 静态函数
        # 通过类名调用
        Person.check()
        Person.func()

        # 通过对象调用
        self.check()
        self.func()

# 创建一个对象
per = Person("小明", 20)

# 只能通过 对象 调用实例函数
per.show()

运行结果

实例函数~~~~~show
类函数~~~~~check
静态函数~~~~~func
类函数~~~~~check
静态函数~~~~~func

• 在静态函数中不调用类方法和实例方法，无法获取准确的变量

3.3.2.4 使用场景

应用：定义工具类

工具类：目的是为了使用起来更加方便，所以在工具类中定义的函数一般是类函数或静态函数

因为调用的时候，无需创建对象就可以通过类名直接调用

# 定义一个加减乘除的类
class Number():
    @staticmethod
    def add(num1, num2):
        return num1 + num2

    @staticmethod
    def sub(num1, num2):
        return num1 - num2

    @staticmethod
    def mul(num1, num2):
        return num1 * num2

    @staticmethod
    def div(num1, num2):
        return num1 / num2

print(Number.add(10, 20))
print(Number.sub(10, 20))
print(Number.mul(10, 20))
print(Number.div(10, 20))