Python高级（二）_面向对象进阶

Python高级-面向对象进阶

第二章 面向对象进阶

数据封装、继承和多态只是面向对象程序设计中最基础的3个概念。

在Python中，面向对象还有很多高级特性，允许我们写出非常强大的功能。

python是动态语⾔，动态编程语⾔ 是 ⾼级程序设计语⾔ 的⼀个类别，在计算机科学领域已被⼴泛应⽤。它是⼀类在 运⾏时可以改变其结构 的语⾔ ：例如新的函数、对象、甚⾄代码可以被引进，已有的函数可以被删除或是其他结构上的变化。动态语⾔⽬前⾮常具有活⼒

例如，我们现在创建一个人的类，在这个类里面，定义了两个初始属性name和age

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

现在我们实例化一个人，P1对象对应的就是诸葛亮这个人，我们传入p1对象的两个属性，姓名和年龄，这个p1对象就好像是自己，我们把自己的姓名和年龄的属性，挂在自己身上，但可见可不见 p1 = Person(‘诸葛亮’, ‘21’)

接着，此时出现问题，若我不知道不认识这个人，例如我在人这个一个系统里面，茫茫人海无意间看到了有这个p1对象，有点好奇，或者需要查到他一些资料，给到他，但我不熟悉有这个人，我想看看这个人是男是女

>>> p1.name
诸葛亮
>>> # 如果我这里写上p1.sex就会存在问题吧，因为没有这个人的性别信息，那我查找到，该填进来吧
>>> p1.sex = '男'
>>> p1.sex
男

这时候就发现问题了，我们定义的类⾥⾯没有sex这个属性啊！怎么回事呢？这就是动态语⾔的魅⼒和坑！ 这⾥实际上就是 动态给实例绑定属性！

在运行的过程中给类绑定属性,看下面的例子

>>> P2 = Person("⼩丽", "25")
>>> P2.sex
Traceback (most recent call last):4
.......
AttributeError: Person instance has no attribute 'sex'
>>>

我们尝试打印P2.sex，发现报错，P2没有sex这个属性！---- 给P1这个实例绑定属性对P2这个实例不起作⽤！ 那我们要给所有的Person的实例加上 sex属性怎么办呢？ 答案就是直接给Person绑定属性！

>>>> Person.sex = None #给类Person添加⼀个属性
>>> P2 = Person("⼩丽", "25")
>>> print(P1.sex) #如果P1这个实例对象中没有sex属性的话，那么就会访问它的类属性
None #可以看到没有出现异常
>>>

我们直接给Person绑定sex这个属性，重新实例化P2后，P2就有sex这个属性了！ 那么function呢？怎么绑定？

class Person(object):
    def __init__(self, name = None, age = None):
        self.name = name
        self.age = age
    def eat(self):
        print("eat food")
    # 单独定义一个run方法
    def run(self, speed):
        print("%s在移动, 速度是 %d km/h"%(self.name, speed))

p = Person("曹操", 24)
print(p.eat()) #eat food
print(p.run()) 
Traceback (most recent call last):
......
AttributeError: Person instance has no attribute 'run'

import types

p.run = types.MethodType(run, P)#给对象p添加一个实例（成员）函数
print(P.run(180)) #曹操在移动,速度是 180 km/h

既然给类添加⽅法，是使⽤ 类名.⽅法名 = xxxx ，

那么给对象添加⼀个⽅法也是类似的 对象.⽅法名 = xxxx

看完整代码，对类方法，方法，增加绑定

import types

class Person:    
    num = 0
    def __init__(self, name=None, age=None):
        self.name = name
        self.age = age
    def eat(self):
        print("eat food")
    # 单独定义的一个run方法
    def run(self, v):
        print(f"{
     
     self.name}在移动, 速度是 {
     
     v} km/h")
    # 定义一个类方法
    @classmethod
    def classClass(cls):
        cls.num = 100
    # 定义一个静态方法
    @staticmethod
    def staticClass():
        print("-------static method-------")

# 创建实例对象
p1 = Person('刘备', 21)
# 调用class中的方法，类中eat的方法
p1.eat()
# 给这个对象添加实例方法,types.MethodType函数将run方法绑定到p1这个对象上
p1.run = types.MethodType(run, p1)
# 调用对象的方法
p1.run(120)
# 给Person类绑定类方法,这里的是方法名
Person.classClass = classClass
# 调用类方法
print(Person.num)
Person.classClass()
print(Person.num)
# 给Person绑定静态方法
Person.staticClass = staticClass
# 调用静态方法
p1.staticClass() 
Person.staticClass()

那既然有增加，就有删除

删除对象与属性的方法

1. del 对象.属性名2. delattr(对象, “属性名”)

我们知道，正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和

方法，这就是动态语言的灵活性。先定义class：然后尝试给实例绑定一个属性，还可以绑定一个方法，但是一个实

例方法对另一个实例不起作用，那就得给类整个类绑定一个方法或属性，这样所有的实例都可以调用

需要注意的是我们的动态语言在运行后还能修改的，但是静态语言是不可以的，这就会造成不严谨

1、__slots__

正常情况下，当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。

动态语⾔：可以在运⾏的过程中，修改代码
静态语⾔：编译时已经确定好代码，运⾏过程中不能修改

但是，如果我们想要限制class的属性怎么办？比如，上例只允许对人类的实例添加 name 和 age 属性。
为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的 __slots__ 变量，来限制该class能添加的属性：
先定义一个学生的类：

#限制类动态添加属性
class Student(object):
    # 用__slots__定义允许绑定的属性名称，只允许定义name和age属性
    __slots__ = ('name', 'age')


s1 = Student()
s1.name = "刘备"
s1.age = 20
s1.score = 100
Traceback (most recent call last):
......
AttributeError: Person instance has no attribute 'score'

首先，我们创建了一个学生对象s1，给s1一个name和age属性，给定成功，但是，当我们给实例s1一个score的属性时，提示"Person instance has no attribute ‘score’"报错

由此可以看出来， slots 限制了对象的属性随意添加。

需要注意一点的是：使⽤ slots 要注意， slots 定义的属性仅对当前类实例起作⽤，对继承的⼦类是不起作⽤的

class subStudent(Student):
    pass

sub1 = subStudent()
sub1.score = 100