python面向对象 (八)

语言的分类

• 面向机器
  抽象成机器指令，机器容易理解
  代表：汇编语言
• 面向过程
  问题规模小，可以步骤化，按部就班处理
  代表：C语言
• 面向对象OOP
  随着计算机需要解决的问题的规模扩大，情况越来越复杂。需要很多人、很多部门协作，面向过程编程不太合适了
  代表：C++、Java、Python等

面向对象

面向对象是一种认识世界、分析世界的方法论。将万事万物抽象为各种对象

类class

• 类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合
• 用计算机语言来描述类，是属性和方法的集合

对象instance、object

• 对象是类的具象，是一个实体
• 对于我们每个人这个个体，都是抽象概念人类的不同的实体

类是抽象的，对象是具体化的

• 属性：它是对象状态的抽象，用数据结构来描述
• 操作：它是对象行为的抽象，用操作名和实现该操作的方法来描述

哲学

• 一切皆对象
• 对象是数据和操作的封装
• 对象是独立的，但是对象之间可以相互作用
• 目前OOP是最接近人类认知的编程范式

面向对象3要素

1. 封装

• 组装：将数据和操作组装到一起
• 隐藏数据：对外只暴露一些接口，通过接口访问对象。比如驾驶员使用汽车，不需要了解汽车的机动原理，会用就行

2. 继承

• 多复用，继承来的就不用自己写了
• 多继承少修改，OCP（Open-closed Principle），使用继承来改变，来体现个性

3. 多态

• 面向对象编程最灵活的地方，动态绑定

Python的类

定义

class ClassName:
	语句块
12

1. 必须使用class关键字
2. 类名必须是用大驼峰命名
3. 类定义完成后，就产生了一个类对象，绑定到了标识符ClassName上

举例

class MyClass:
    """A exapmle class"""
    x = 'abc' # 类属性

    def foo(self): # 类属性foo,也是方法
        return 'My Class'

print(MyClass.x)
print(MyClass.foo)
print(MyClass.__doc__)

# 打印结果
abc
<function MyClass.foo at 0x00000000021F3C80>
A exapmle class
123456789101112131415

类对象及类属性

• 类对象，类的定义执行后会生成一个类对象
• 类的属性，类定义中的变量和类中定义的方法都是类的属性
• 类变量，上例中x是类MyClass的变量

MyClass中，x、foo都是类的属性， __doc__ 也是类的特殊属性
foo方法是类的属性，如同吃是人类的方法，但是每一个具体的人才能吃东西，也就是说吃是人的实例能调用的方法
foo是方法method，本质上就是普通的函数对象function，它一般要求至少有一个参数。第一个形式参数可以是
self（self只是个惯用标识符，不推荐修改），这个参数位置就留给了self。
self 指代当前实例本身

实例化

a = MyClass() # 实例化
1

使用上面的语法，在类对象名称后面加上一个括号，就调用类的实例化方法，完成实例化。
实例化就真正创建一个该类的对象（实例）。例如

tom = Person()
jack = Person()
12

上面的tom、jack 都是Person类的实例，通过实例化生成了2个实例。
每次实例化后获得不同的实例，即使是使用同样的参数实例化，也得到不一样的对象。
Python类实例化后，会自动调用__init__方法。这个方法第一个形式参数必须留给self，其它参数随意。

__init__方法

• MyClass()实际上调用的是__init__(self) 方法，可以不定义，如果没有定义会在实例化后隐式调用。
• 作用：对实例进行初始化

class MyClass:
    def __init__(self):
        print('init')

print(MyClass) # 不会调用
print(1, '-' * 50)
print(MyClass()) # 调用__init__
print(2, '-' * 50)
a = MyClass() # 调用__init__

# 打印结果
<class '__main__.MyClass'>
1 --------------------------------------------------
init
<__main__.MyClass object at 0x0000000001E90860>
2 --------------------------------------------------
init
init
123456789101112131415161718

• 初始化函数可以多个参数，请注意第一个位置必须是self，例如__init__(self, name, age)

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

    def showage(self):
        print('{} is {}'.format(self.name,self.age))

tom = Person('Tom', 20) # 实例化, 会调用__init__方法并为实例进行属性的初始化
jack = Person('Jack', 25)
print(tom.name, jack.age) # Tom 25
jack.age += 1
print(jack.age) # 26
jack.showage()  # Jack is 26
1234567891011121314

• 注意： __init__() 方法不能有返回值，也就是只能是return None

实例对象instance

• 类实例化后一定会获得一个类的实例，就是实例对象
• 上例中的tom、jack就是Person类的实例
• __init__方法的第一参数 self 就是指代某一个实例自身
• 类实例化后，得到一个实例对象，调用方法时采用jack.showage()的方式，实例对象会绑定到方法上。
• 但是该函数签名是showage(self)，少传一个实际参数self吗？
• 这个self就是jack，jack.showage()调用时，会把方法的调用者jack实例作为第一参数self的实参传入。
• self.name就是jack对象的name，name是保存在了jack对象上，而不是Person类上。所以，称为实例变量

self

class MyClass:
    def __index__(self):
        print(1,'self in init = {}'.format(id(self)))

    def showself(self):
        print(2, 'self in showself() = {}'.format(id(self)))

c = MyClass() # 会调用__init__
print(3, 'c = {}'.format(id(c)))
print('-' * 30)
c.showself()

# 打印结果
3 c = 35653784
------------------------------
2 self in showself() = 35653784
12345678910111213141516

上例说明，self就是调用者，就是c对应的实例对象。
self这个名字只是一个惯例，它可以修改，但是请不要修改，否则影响代码的可读性

实例变量和类变量

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

tom = Person('Tom') # 实例化、初始化
jack = Person('Jack')

print(tom.name, tom.age)
print(jack.name, jack.age)
print(Person.age)
# print(Person.name)
Person.age = 30
print(Person.age, tom.age, jack.age)

# 运行结果
Tom 3
Jack 3
3
30 30 30
1234567891011121314151617181920

• 实例变量是每一个实例自己的变量，是自己独有的
• 类变量是类的变量，是类的所有实例共享的属性和方法
  
• 注意：
  Python中每一种对象都拥有不同的属性。函数、类都是对象，类的实例也是对象。
• 举例

class Person:
    age = 3

    def __init__(self, name):
        self.name = name
print('----class----')
print(Person.__class__, type(Person))
print(sorted(Person.__dict__.items()), end='\n\n') # 属性字典

tom = Person('Tom')
print('----instance tom----')
print(tom.__class__, type(tom))
print(sorted(tom.__dict__.items()), end='\n\n')

print("----tom's class----")
print(tom.__class__.__name__)
print(sorted(tom.__class__.__dict__.items()), end='\n\n') # type(tom).__dict__

# 打印结果
----class----
<class 'type'> <class 'type'>
[('__dict__', <attribute '__dict__' of 'Person' objects>), ('__doc__', None), ('__init__', <function Person.__init__ at 0x00000000021E3C80>), ('__module__', '__main__'), ('__weakref__', <attribute '__weakref__' of 'Person' objects>), ('age', 3</