python面向对象编程——面向对象编程概述、实例对象属性、类对象属性、实例方法

1. 面向对象编程概述

面向对象编程是一种编程方式，这种编程方式需要使用对象来实现

1.1 对象的特征

• 世间万物皆是对象
• 每个对象都是唯一的
• 对象具有属性和行为
  对象的行为包括具有的功能及具体的实现
• 对象具有状态
• 对象分为类对象和实例对象两大类：
  1. 类对象是具有相同属性和行为的实例对象的抽象
  2. 类对象就是实例对象的模板，实例对象是由类对象创建出来的
  3. 同一个类对象的所有实例对象具有相同的属性，表明它们的属性含义是相同的，但是它们的状态不一定相同，也就是户型不一定相同

1.2 面向对象编程的大体步骤

1. 抽象出类对象
2. 抽象出类对象的属性
3. 抽象出类对象的行为（方法）
4. 根据类对象创建实例对象
5. 通过实例对象访问属性和方法

1.3定义类对象的语法格式

class 类名(object):
    #属性与方法

eg:

>>> class Cat(object): #Cat是类对象
>>>     pass

注：object表示该类对象继承自python内置的类对象object，python中所有的类对象都继承自一个统一的基类：object

1.4 初识属性

构造方法：用两个双下划线表示的函数

 >>> class Cat(object):
 >>>     # 构造属性
 >>>     def __init__(self, breed, name, sge, health): #第一个self必须写
 >>>         self.breed = breed #品种
 >>>         self.name = name
 >>>         self.sge = sge
 >>>         self.health = health

1.5 初识类的方法

行为（方法）是类中特殊的函数

• 类的方法与函数的区别
  方法就是定义在类对象中的函数
  1. 定义方法时，方法的第一个形参表示调用该方法的实例对象，第一个形参的名称通常是self，也可以是其它名称
  2. 调用方法时，系统自动将调用该方法的实例对象作为实参传递给第一个形参。第一个实参会传递给第二个形参，第二个实参会传递给第三个形参，以此类推

>>>     def run(self):
>>>         print("Cat is running")
>>>     def miao(self):
>>>         print("Cat is maioing")
>>>     def eat(self):
>>>         print("Cat id eating")

注：def与1.4中的def对齐

1.6 根据类对象创建实例对象语法格式：

类名（[实参]）
eg:

 >>> #cat是实例对象  Cat是类对象
 >>> cat = Cat("波斯猫","喵咪", 1, "健康")
 >>> print(cat.breed)
 >>> cat.run()

2. 实例对象属性

2.1 实例属性

• 实例对象所绑定的属性

• 绑定实例属性的方法：

  1. 在类对象的内部（方法中）：
     语法格式：
     self.属性名 = 属性值
     （推荐在__init__中进行绑定，这样在创建实例对象后会自动调用特殊方法__init__对实例对象进行初始化，从而绑定实例属性。如果在其他方法中进行绑定，可能需要手动调用方法后才会绑定）
  2. 在类对象外部：
     python是动态语言，所以在类对象创建之后可以对其动态地进行绑定
     语法格式：
     实例对象.属性名 = 属性值
     如果指定名称的实例属性已经存在，则是对类属性进行修改

• 访问实例属性的方式：

  1. 在类对象的内部（方法中）
     语法格式：
     self.属性名
  2. 在类对象外部
     语法格式：
     实例对象.属性名
     添加前缀“self”或“实例对象”是为了表明实例属性被哪个实例对象所绑定

>>> class MyClass(object):
>>>     def __init__(self):
>>>         # 在类对象内部绑定实例属性
>>>         self.ia1 = 18
>>>     def do_sth1(self):
>>>         # 在类对象内部访问实例属性
>>>         print(self.ia1)
>>>     def do_sth2(self):
>>>         print(self.ia2)
>>>     def do_another(self):
>>>         self.ia2 = 56
>>>     def do_sth3(self):
>>>         print(self.ia3)
>>> #绑定（创建）实例对象
>>> mc = MyClass()

>>> # 在类对象外部绑定实例属性
>>> mc.ia3 = 66
>>> # 在类对象外部访问实例属性
>>> mc.do_sth3()

>>> #同一个类对象所绑定的另一个实例对象
>>> mc2 = MyClass()

2.2 实例对象. __ dict __

可获得该实例对象所绑定的所有属性及其值的字典
具体见博客 python面向对象编程——new()、getitem()、call()与callable()、doc__与__dict：https://blog.csdn.net/weixin_43799652/article/details/92589216

>>> mc.__dict__
{'ia1': 18, 'ia3': 66, 'ia2': 56}

3. 类对象属性

3.1 类属性

类属性指的是类对象所绑定的属性

• 绑定类属性的方法：
  1. 在类对象的内部（方法外）:
     语法格式：
     属性名 = 属性值
  2. 在类对象外部：
     python是动态语言，所以在类对象创建之后可以对其动态地进行绑定
     语法格式：
     类对象.属性名 = 属性值
     如果指定名称的雷属性已经存在，则是对类属性进行修改
• 访问类属性的方法：
  1. 在类对象的内部（方法中）
     语法格式：
     类对象.属性名
  2. 在类对象外部
     语法格式：
     实例对象.属性名或类对象.属性名

注：类对象的所有实例中都有一个指向类对象的指针，所以类对象的所有实例对象都可以访问类属性。添加前缀“类对象”是为了表明类属性被哪个类对象所绑定。

>>> class MyClass(object):
>>>     #在类对象内部（方法外）绑定类属性
>>>     ca1 = 66
>>>     def do_sth(self):
>>>         #在类对象内部（方法中）访问类属性
>>>         print(MyClass.ca1)
>>>     def do_another(self):
>>>         #在类对象内部（方法中）访问类属性
>>>         print(MyClass.ca2)
>>> mc = MyClass()
>>> #在类对象的外部绑定类属性
>>> MyClass.ca2 = 88
>>> print(MyClass.ca2)
>>> print(mc.ca2)
>>> #在类对象的外部修改类属性
>>> MyClass.ca2 = 99
>>> print(MyClass.ca2)
>>> print(mc.ca2)
>>> #在类对象外部调用类方法，使得在类对象内部访问类属性
>>> mc.do_another()

4. 实例方法

实例方法：指只有实例对象才能调用的方法

• 实例对象调用实例方法的两种调用方式：
  • 1.在类对象内部
    语法格式：self.方法名([实参])
  • 2.在类对象的外部
    语法格式：实例对象.方法名([实参])

class MyClass(object):
    #在类对象中定义实例方法
    def im1(self, p1, p2):
        print(p1,p2)
    def im2(self):
        #在类对象内部调用实例方法
        self.im1(1,2)
mc = MyClass()
#在类对象外部调用实例方法
mc.im1(1,2)

注：

1. 类对象不能直接调用实例对象
2. 实例方法可以在实例对象或类对象创建以后绑定
3. 同一个类对象的不同实例对象之间绑定的实例方法不会相互影响，也就是说在一个实例对象绑定的实例方法不会在另一个实例对象里起作用
4. 想要让同一类对象中的实例对象都能够调用某一实例方法，可以给类对象绑定该实例方法

>>> # 注 2

>>> #定义一个实例方法
>>> def do_sth(self, a, b):
>>>     print(a,b)
    
>>> #导入标准库types中的类MethodType
>>> from types import MethodType
>>> #给实例对象mc动态地绑定实例方法
>>> mc.do_sth = MethodType(do_sth, mc)
>>> #调用绑定的实例方法
>>> mc.do_sth(1, 2) #do_sth()被调用了
1 2

>>> #注 3

>>> #创建另一个实例对象
>>> mc2 = MyClass()

>>> def im3(self):
>>>     print("im3()被调用了")

>>> #给类对象动态地绑定实例方法
>>> MyClass.im3 = im3

>>> #一个实例对象可以调用
>>> mc.im3()
>>> #另一个实例对象可以调用
>>> mc2.im3()
im3()被调用了
im3()被调用了