python面向对象—-类的定义与实例化

python是一种面向对象编程语言，自然也有类的概念。python中的类通过class 关键字定义，提供了面向对象的所有标准特性，例如允许一个类继承多个基类， 子类可以覆盖父类的方法，封装，继承，多态 面向对象的三大特性python一样不少。

1.类的定义

定义一个类使用class关键字

class Stu:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def run(self):
        print("{name} is running".format(name=self.name))

关于这段代码有很多新的概念需要你了解

1.1 类的名字

上面所定义的类的名字叫Stu，你可以使用Stu的name属性来访问它

print(Stu.__name__)

1.2 实例方法

在函数一章，你已经学习使用def来定义函数，在类里面，同样用def关键字来定义函数，但是我们管类里的函数叫方法，在这个示例中所有的方法都是实例方法，如不特殊说明，本教程中所说的方法均指实例方法。

1.3 初始化函数与实例属性

注意看这个方法

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

单词init是初始化的意思，init是初始化函数，当实例被构造出来以后，使用init方法来初始化实例属性。
name 和 age都是实例的属性，属性就是数据。说了半天实例，到底谁是实例，在类的方法里，self就是实例，如果你有其他编程语言的经验，python中的self等同于其他编程语言里的this。

2. 实例化

类是一种封装技术，我们把数据和方法都封装到了类里，如果你想使用数据和方法，那么你需要用类创建出一个实例来，这个过程就叫做实例化

class Stu:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def run(self):
        print("{name} is running".format(name=self.name))
s = Stu('小明', 18)
s.run()

代码执行结果

<class '__main__.Stu'>
小明 is running

s 就是创建出来的实例，s是类Stu的一个实例。在定义Stu的时候，要求实例必须有name和age属性，因此，在创建示例时，我们必须提供这些属性，按照init函数的参数列表传入’小明’ 和 18。
s.run() 这行代码是在调用实例的run方法，不同于之前所学习的函数，类里的方法只能通过实例或者类来调用，调用的方式就如代码里演示的那样。

3. self是什么？

你或许已经注意到，类里定义的每个方法都有一个self参数，它并不是默认参数，但这个参数在方法被调用时是不需要传参的，这与之前所学过函数内容相违背。
self是方法的一个参数，在方法调用时，这个参数是默认传参的。

class Stu:
    def __init__(self, name, age):
        print("在__init__方法中", id(self))
        self.name = name
        self.age = age
    def run(self):
        print("在run方法中", id(self))
        print("{name} is running".format(name=self.name))
s = Stu('小明', 18)
print("s的内存地址", id(s))
s.run()

程序执行结果

在__init__方法中 4336221600
s的内存地址 4336221600
在run方法中 4336221600
小明 is running

self的内存地址，和s的内存地址是一致的，这可以证明，self就是s。函数被定义以后，在任何地方都可以调用，没有调用的主体，而类的方法，则需要一个调用主体，哪个实例调用了类的方法，self就会绑定为哪个实例，self这个参数就是哪个实例。
分析上面的输出结果，在init方法被调用时，s这个对象就已经被创建好了，这可以证明它不是构造方法，真正的构造方法是new，在没有调用构造方法前，对象是不存在的。

4.对象属性的访问

对象属性的访问与修改，只能通过对象来进行

class Stu:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def info(self):
        print("{name}今年{age}岁".format(name=self.name, age=self.age))
    def run(self):
        print("{name} is running".format(name=self.name))
    def print(self):
        print("ok")
s = Stu("小刚", 18)
s.info()
print(s.name)
s.age = 20
s.info()

代码输出结果

小刚今年18岁
小刚
小刚今年20岁

5. 使用类组合数据和方法

一个名为 成绩单 的文件中保存了学生的考试成绩，内容如下

姓名  语文  数学  英语
小红  90   95    90
小刚  91   94    93

请编写程序读取该文件，使用合适的数据类型保存这些数据，输出每一个人的各个科目和分数，并计算每个学生的总的分数。

5.1 面向过程

stus = []
with open('成绩单', 'r', encoding='utf-8') as file:
    lines = file.readlines()
    for i in range(1, len(lines)):
        line = lines[i]
        arrs = line.split()
        stus.append(arrs)
# 记住,每个列表里,第一个元素是姓名,第二个元素语文分数,后面的是数学分数,英语分数
for stu in stus:
    msg = "{name}的各科成绩如下: 语文:{yw_score}, " \
          "数学:{sx_score}, 英语:{en_score}".format(name=stu[0],
                                                yw_score=stu[1],
                                                sx_score=stu[2],
                                                en_score = stu[3]
                                                )
    print(msg)
    msg = "{name}的总成绩是{socre}".format(name=stu[0],
                                      socre=int(stu[1])+int(stu[2])+int(stu[3]))
    print(msg)

5.2 面向对象

class Stu:
    def __init__(self, name, yw, sx, en):
        self.name = name
        self.yw = yw
        self.sx = sx
        self.en = en
    def score_sum(self):
        return self.yw + self.sx + self.en
    def print_score(self):
        msg = "{name}的各科成绩如下: 语文:{yw_score}, " \
          "数学:{sx_score}, 英语:{en_score}".format(name=self.name,
                                                yw_score = self.yw,
                                                sx_score = self.sx,
                                                en_score = self.en
                                                )
        print(msg)
        msg = "{name}的总成绩是{score}".format(name=self.name, score=self.score_sum())
        print(msg)
stus = []
with open('成绩单', 'r', encoding='utf-8') as file:
    lines = file.readlines()
    for i in range(1, len(lines)):
        line = lines[i]
        arrs = line.split()
        s = Stu(arrs[0], int(arrs[1]), int(arrs[2]), int(arrs[3]))
        stus.append(s)
for stu in stus:
    stu.print_score()

如果仅仅从代码量上来看，使用类并没有减少代码，但是从代码的可阅读性上看，使用类组织数据和方法显然更具有优势，而且，类这种概念，更加符合我们人类的思维。
我们人喜欢把各种东西归类，爬行动物，恒温动物，冷血动物，猫科动物，犬科动物，这些都是类。
狮子也是一个类，是猫科动物的子类，具体到一个真实存在的狮子，我们可以认为这个真实存在的狮子是狮子这个类的一个实例，或者说狮子这个类的一个对象。
使用类组织数据和方法，扩展性更好，可以随时添加新的属性和方法，比如，我想输出学生最高的科目分数,那么，我只需要修改类就可以了

class Stu:
    def __init__(self, name, yw, sx, en):
        self.name = name
        self.yw = yw
        self.sx = sx
        self.en = en
    def score_sum(self):
        return self.yw + self.sx + self.en
    def get_max_score(self):
        if self.yw > self.sx:
            if self.yw > self.en:
                return self.yw
            else:
                return self.en
        else:
            if self.sx > self.en:
                return self.sx
            else:
                return self.en
    def print_score(self):
        msg = "{name}的各科成绩如下: 语文:{yw_score}, " \
          "数学:{sx_score}, 英语:{en_score}".format(name=self.name,
                                                yw_score = self.yw,
                                                sx_score = self.sx,
                                                en_score = self.en
                                                )
        print(msg)
        msg = "{name}的总成绩是{score}".format(name=self.name, score=self.score_sum())
        print(msg)
        msg = "最高分数是{max_score}".format(max_score = self.get_max_score())
        print(msg)

在程序里，调用对象print_score方法的地方不用做任何的修改。反观5.1 的写法，你不得不在for循环里做大量的修改，这样的代码可维护性是很差的。

6. 实例方法，类方法，静态方法， 类属性

类里的方法有3种，在第一小节中所定义的类中，方法都是实例方法。这3种方法有各自的定义方式和权限

下面修改类Stu的定义来向你展示这3种方法的区别

class Stu:
    school = '湘北高中'   # 类属性
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def play_basketball(self):
        print("{name} 正在打篮球".format(name=self.name))
    @classmethod
    def sport(cls):
        print("{school}的同学都喜欢篮球".format(school=cls.school))
    @staticmethod
    def clean():
        print("打扫教室卫生")
stu = Stu("樱木花道", 17)
stu.play_basketball()       # 通过实例调用实例方法
Stu.play_basketball(stu)    # 通过类调用实例方法
Stu.sport()     # 通过类调用类方法
stu.sport()     # 通过示例调用类方法
Stu.clean()     # 通过类调用静态方法
stu.clean()     # 通过实例调用静态方法
print(stu.school)       # 通过实例访问类属性
stu.school = '山王工业'     # 只是增加了一个实例属性,类属性不会被修改
print(Stu.school)       # 通过类访问类属性

代码执行结果

樱木花道 正在打篮球
樱木花道 正在打篮球
湘北高中的同学都喜欢篮球
湘北高中的同学都喜欢篮球
打扫教室卫生
打扫教室卫生
湘北高中
湘北高中

理解这3种方法的核心在于理解他们的权限。
在面向对象的设计理念中，方法必定属于某个类，如果这个方法不属于某个类，那么它就是函数了，就回归到了面向过程编程。方法属于某个类，但这个方法可能不会访问实例和类的任何属性或其他方法，对于这种方法，我们就应该把它设计成静态方法。
还有一种可能，一个方法会访问到类的属性，就像本示例中的sport方法，整个湘北高中的学生都喜欢篮球，这个方法就不是某个学生所特有的，而是整个类所拥有的一个方法，那么就需要把它设计成类方法。school是类属性，既然类拥有这个属性，那么类实例化出来的对象也自然拥有这个属性，通过类和示例都可以访问到这个属性，但是要注意，这个属性是类的，因此不能通过实例对它进行修改。

python面向对象—-类的封装

python的面向对象, 并没有严格意义上的私有属性和方法, 私有只是一种约定, 隐藏实现的细节，只对外公开我们想让他们使用的属性和方法，这就叫做封装，封装的目的在于保护类内部数据结构的完整性， 因为使用类的用户无法直接看到类中的数据结构，只能使用类允许公开的数据，很好地避免了外部对内部数据的影响，提高了程序的可维护性。用户只能通过暴露出来的方法访问数据时，你可以在这些方法中加入一些控制逻辑，以实现一些特殊的控制

1 私有属性和方法

面向对象的内容，在学习时要侧重其理念，但理念这东西需要实践加持，否则，很难理解。
假设，你和你的同事一起做项目，现在，需要你写一个类让同事使用，这个类，你定义了5个属性，10个方法，但是呢，你的同事其实只会用到其中一个方法，剩下那9个，都是用到的那个方法在执行过程中调用的方法。
那么问题来了，你明确告诉他，你就调用那个A方法就好了，其他方法，你不要使用，不然，可能会影响结果。如果你的同事是个很安分守己的人，他听从了你的建议，老老实实的调用A方法，其他方法，他一概不动，这样就是安全的。
可是过了几天，来了新同事，他偏偏不听话，非得调用剩余的9个方法，它觉得，自己调用那9个方法，可以更好的实现功能，结果呢，出了大问题了，那9个方法，他用的不好，导致程序出错了。
我们写了一个类，有些属性，有些方法，我们不希望被其他人使用，因为那样很容易就产生错误，那么这时，我们就需隐藏实现的细节，只对外公开我们想让他们使用的属性和方法，这就叫做封装。就好比把一些东西用一个盒子封装起来，只留一个口，内部让你看不见。
如何才能做到这一点呢，在python里，如果属性和方法前面是双下划线，那么这个属性和方法就变成了私有的属性。

class Animal:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def __run(self):
        print("run")
a = Animal('猫', 2)
a.__run()
print(a.__name, a.__age)

__run()方法是以双下划线开头的，这样的方法，类的对象无法使用，双下划线开头的属性也同样无法访问，通过这种方法，就可以将不希望外部访问的属性和方法隐藏起来。
属性隐藏起来，并非不让外部使用，而是在使用时收到控制，比如年龄，如果年龄属性定义成age，那么就会出现这样的情况

a.age = 10000

你见过哪个动物的年龄有10000岁呢，这显然是有问题的，但age属性暴露出来了，别人在使用时就可能会犯这样的错误，所以，为了防止这样的错误发生，就可以将age属性设置成私有的，然后提供一个set_age方法

class Animal:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def set_age(self, age):
        if age > 100 or age < 1:
            raise Exception("年龄范围错误")
        self.__age = age
    def get_age(self):
        return self.__age
    def __run(self):
        print("run")
a = Animal('猫', 2)
a.set_age(3)
print(a.get_age())
a.set_age(101)

2. 类属性

类可以有自己属性，这个属性不同于实例的属性，类属性属于类，但是可以被实例访问

class People(object):
    country = '中国'
print(id(People.country), People.country)       # 通过类去访问
p = People()
# 实例对象p并没有country属性,但会从类属性里找到同名的属性
print(id(p.country), p.country)
p.country = "美国"    # 创建了country实例属性, 而不是修改了类的country属性
print(id(p.country), p.country)
print(id(People.country), People.country)

3. classmethod

在这之前，所有的示例代码中，类中的方法都是普通方法，第一个参数是self，这种方法只能被实例调用，如果被classmethod装饰，这个方法就是类方法，可以被类和实例调用

class People(object):
    country = '中国'
    @classmethod
    def sing_the_national_anthem(cls):
        print('唱{country}国歌'.format(country=cls.country))
People.sing_the_national_anthem()
p = People()
p.sing_the_national_anthem()

如果一个方法不访问示例的属性，但会访问类的属性和方法时，就可以设置成类方法。

4. staticmethod

如果一个方法，既不会访问示例属性或方法，也不会访问类的属性或方法，方法里的都是有关逻辑性的代码，那么这种代码就可以设置成静态方法，你可能会好奇，既然这个方法跟类和实例都没啥交互，那要这个方法做什么呢？
回到我们最初描述类的定义上，类提供了一种组合数据和功能的方法，我们定义一个类，是希望这个类能够完成特定的功能，但这里的功能不一定非得访问什么属性啊，它只需要完成我们期望的事情就好了，将这个方法定义在这个类里，是因为它的逻辑和这个类在逻辑功能上有关系，所以，放在一起，便于管理

class People(object):
    country = '中国'
    @staticmethod
    def sing_the_national_anthem():
        print('唱国歌')
People.sing_the_national_anthem()
p = People()
p.sing_the_national_anthem()

5. 三种类方法对比

python面向对象—-类的继承

继承是python面向对象的三大特性之一，是一种创建新类的方式，python中的继承，可以继承一个或者继承多个父类，新建的类被称之为派生类或者子类，被继承的类是父类，可以称之为基类，超类，继承是实现代码重用的重要方式。

1. 单继承

先看单继承的例子

class Car(object):
    def __init__(self, speed, brand):
        self.speed = speed
        self.brand = brand
    def run(self):
        print("{brand}在行驶".format(brand=self.brand))
# 燃油车
class Gasolinecar(Car):
    def __init__(self, speed, brand, price):
        super().__init__(speed, brand)
        self.price = price
class Audi(Gasolinecar):
    pass
honda = Gasolinecar(130, '本田', 13000)
honda.run()
audi_car = Audi(100, '奥迪', 10000)
audi_car.run()
print(issubclass(Audi, Gasolinecar))        # 判断Audi是Gasolinecar的子类
print(issubclass(Gasolinecar, Car))

代码执行结果

本田在行驶
奥迪在行驶
True
True

2. 继承发生了什么

继承，意味着子类将“拥有”父类的方法和属性，同时可以新增子类的属性和方法。在Gasolinecar类里，我没有写run方法，但是Gasolinecar的父类定义了run方法，因此，Gasolinecar也有这个方法，因此这个类的对象honda可以使用run方法。
Audi类没有定义任何方法，但是它继承了Gasolinecar，因此，Gasolinecar有的属性和方法，它都拥有，这里就包括了init方法。
super()可以用来调用父类的方法，Gasolinecar多传了一个price属性，其父类的init方法里有两个参数，因此，可以先调用父类的init方法初始化speed, brand，然后在初始化price。

3. 多继承

class Person():
    def person_walk(self):
        print("走路")
class Wolf():
    def wolf_run(self):
        print("奔跑")
class WolfMan(Person, Wolf):
    def __init__(self, state):
        # 1表示狼形态,2表示人形态
        self.state = state
    def change(self):
        if self.state == 1:
            self.state = 2
        else:
            self.state = 1
    def run(self):
        if self.state == 1:
            self.wolf_run()
        else:
            self.person_walk()
wolf_man = WolfMan(1)
wolf_man.run()
wolf_man.change()
wolf_man.run()

4. 继承的优势

有了继承，创建一个新的类就非常的方便，因为只需要继承以前的父类就可以了，继承之后，子类拥有了父类的属性和方法，这样不仅仅是节省了代码，更重要的是，配合多态，让类的行为更加丰富

python面向对象—-类的多态

python面向对象的多态依赖于继承, 因为继承，使得子类拥有了父类的方法, 子类的方法与父类方法重名时是重写, 同一类事物，有多重形态, 这就是面向对象概念里的多态，多态使得不同的子类对象调用相同的 类方法，产生不同的执行结果，可以增加代码的外部调用灵活度。

1. 多态

1.1 重写

多态这个概念依赖于继承，因为继承，使得子类拥有了父类的方法，这里就产生了一个问题，如果子类有一个方法和父类的方法同名，那么子类在调用这个方法时，究竟是调用子类自己的方法，还是父类的方法？

class Base():
    def print(self):
        print("base")
class A(Base):
    def print(self):
        print("A")
a = A()
a.print()

父类和子类都有print方法，那么子类A的对象a调用print方法时，调用的是谁的print方法呢？
答案是子类的print方法，如果A类没有定义print方法，那么a.print()调用的是父类的print方法，但是A类定义了print方法，这种情况称之为重写，A类重写了父类的print方法。

1.2 继承的搜索

强调继承时，子类“拥有”父类的方法和属性，特意加了双引号，因为，这种拥有不是真实意义上的拥有。

class Base():
    def print(self):
        print("base")
class A(Base):
    pass
print(id(Base.print))
print(id(A.print))

Base.print 和 A.print 的内存地址是相同的，这说明他们是同一个方法。执行A.print时，python会寻找print方法，它会先从A类的定义中寻找，没有找到，然后去A的父类里寻找print方法，如果还是找不到，就继续向上寻找。
这便是子类拥有父类属性和方法的真相

1.3 多态的表现形式

同一类事物，有多重形态

class Animal:
    def run(self):
        raise NotImplementedError
class People(Animal):
    def run(self):
        print("人在行走")
class Pig(Animal):
    def run(self):
        print("猪在跑")
p1 = People()
p1.run()
p2 = Pig()
p2.run()

People和 Pig 都继承了Animal，都是动物，是同一类事物，他们都有run方法，但是最终的运行结果却不一样，这就是多态，同一类事物有多种形态。