python源码中的学习笔记_第9章_类与对象

编程的两大思想

#
# 主题：编程的两大思想
#

# 面向过程：事物比较简单，可以用线性的思维解决
# 面向对象：事物比较复杂，无法用线性的思维解决
# 共同点：都是解决实际问题的思维方式
# 解决复杂问题，通过面向对象方式便于从宏观上把握事物之间复杂的关系，方便我们分析整个系统
# 具体到微观操作，仍然使用面向过程的方式来处理

类与对象

#
# 主题：类与对象
#

if __name__ == '__main__':
    # 类：多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质
    # 对象：100,99,25 都是 int 类下面包含的相似的不同个例，这些个例专业术语成为实例或对象
    # python 中一切皆对象

    # 不同的数据类型属于不同的类
    # 使用内置函数 type 查看数据类型
    print(type(100))            # <class 'int'>

创建类

#
# 主题：创建类
#

class Student:          # Student 是类名，使用大驼峰法命名
    pass

print(id(Student))      # 地址 2162215694248
print(type(Student))    # 数据类型 <class 'type'>
print(Student)          # 值 <class '__main__.Student'>

# 类的组成：类属性，实例方法，静态方法，类方法

class MyStudent:
    '''
    功能：MyStudent 类
    '''

    # 类属性
    native_place = '吉林'     # native_place 是类属性，即直接写在类中的变量

    # 初始化方法
    def __init__(self, name, age):
        self.name = name    # self.name 和 self.age 是实例属性
        self.age = age

    # 实例方法：在类中定义的函数（在类外定义的函数叫函数）
    def eat(self):
        print('学生在吃饭')

    # 静态方法：
    @staticmethod            # 使用 staticmethod 修饰，则下面定义的方法是静态方法
    def method():
        print('我是静态方法')

    # 类方法
    @classmethod            # 使用 classmethod 修饰，则下面定义的方法是类方法
    def cm(cls):
        print('我是类方法')

创建对象

#
# 主题：创建对象
#

class MyStudent:
    '''
    功能：MyStudent 类
    '''

    # 类属性
    native_place = '吉林'     # native_place 是类属性，即直接写在类中的变量

    # 初始化方法
    def __init__(self, name, age):
        self.name = name    # self.name 和 self.age 是实例属性
        self.age = age

    # 实例方法：在类中定义的函数（在类外定义的函数叫函数）
    def eat(self):          # self 与 JavaScript 中的 this 关键字的功能类似
        print('学生 %s 在吃饭' % self.name)

    # 静态方法：
    @staticmethod            # 使用 staticmethod 修饰，则下面定义的方法是静态方法
    def method():
        print('我是静态方法')

    # 类方法
    @classmethod            # 使用 classmethod 修饰，则下面定义的方法是类方法
    def cm(cls):
        print('我是类方法')

# 创建 MyStudent 类的对象：类的实例化
stu1 = MyStudent('张三', 20) # stu1 是 MyStudent 类对象的一个实例对象
print(id(stu1))             # 1722168051696 十六进制为0x00000197880107F0
print(type(stu1))           # <class '__main__.MyStudent'>
print(stu1)                 # <__main__.MyStudent object at 0x00000197880107F0>

# MyStudent 是类对象
# stu1 是实例对象

# 调用类中的方法
print('---')
stu1.eat()                  # 学生 张三 在吃饭
                            # stu1 调用了 eat 方法，则 self 就是 stu1
print(stu1.age)             # 20
MyStudent.eat(stu1)         # 学生 张三 在吃饭
                            # 直接将 stu1 实例对象放在 self 参数的位置，从而代替了 self
                            # stu1.eat() 语句功能相同

类属性，类方法，静态方法

#
# 主题：类属性，类方法，静态方法
#

class MyStudent:
    '''
    功能：MyStudent 类
    '''

    # 类属性
    native_place = '吉林'     # native_place 是类属性，即直接写在类中的变量

    # 初始化方法
    def __init__(self, name, age):
        self.name = name    # self.name 和 self.age 是实例属性
        self.age = age

    # 实例方法：在类中定义的函数（在类外定义的函数叫函数）
    def eat(self):          # self 与 JavaScript 中的 this 关键字的功能类似
        print('学生 %s 在吃饭' % self.name)

    # 静态方法：
    @staticmethod            # 使用 staticmethod 修饰，则下面定义的方法是静态方法
    def method():
        print('我是静态方法')

    # 类方法
    @classmethod            # 使用 classmethod 修饰，则下面定义的方法是类方法
    def cm(cls):
        print('我是类方法')

# 类属性：处于类中、方法外的变量，他被该类的所有对象所共享
# 类方法：使用 @classmethod 修饰的方法，使用类名直接访问
# 静态方法：使用 @staticmethod 修饰的方法，使用类名直接访问
# 实例对象通过类指针访问类对象中的属性和方法

if __name__ == '__main__':
    print(MyStudent.native_place)       # 吉林
    stu1 = MyStudent('张三', 20)
    stu2 = MyStudent('李四', 35)
    print(stu1.native_place)            # 吉林
    print(stu2.native_place)            # 吉林
    MyStudent.native_place = '天津'
    print(stu1.native_place)            # 天津
    print(stu2.native_place)            # 天津

    # 类方法
    print('---')
    MyStudent.cm()                      # 我是类方法
    stu1.cm()                           # 我是类方法

    # 静态方法
    print('---')
    MyStudent.method()                  # 我是静态方法

动态绑定属性和方法

#
# 主题：动态绑定属性和方法
#

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

    def eat(self):
        print(self.name + '在吃饭')

if __name__ == '__main__':
    # 一个 Student 类可以有多个实例对象
    # 每个实例对象的属性值（如name）可以不同
    stu1 = Student('张三', 20)
    stu2 = Student('李四', 22)
    print(id(stu1))             # 2702256703472
    print(id(stu2))             # 2702256705376

    # 为 stu2 动态绑定属性
    print('---')
    stu2.gender = '女'    # 动态绑定属性
                          # gender 属性是在实例对象定义之后建立的，只适用于特定的实例对象，而不是用 Student 类的所有实例对象
                          # Student 类中的初始化方法中定义的属性是在实例对象定义之前建立的，适用于 Student 类的所有实例对象
    print(stu1.name, stu1.age)              # 张三 20
    print(stu2.name, stu2.age, stu2.gender) # 李四 22 女
    # print(stu1.gender)                    # stu1 没有 gender 属性，会报错

    # 动态绑定方法
    print('---')
    def show():             # 定义在类外的是函数
        print('我是函数')
    stu1.show = show        # 动态绑定方法
    stu1.show()             # 我是函数
    # stu2.show()           # stu2 没有 show 方法，会报错