本文深入介绍了Python面向对象编程的概念，包括类、对象、属性、方法、类变量、实例变量、类方法、私有属性和方法、@property装饰器以及继承。通过实例展示了如何创建类、实例化对象、访问和修改属性，以及如何利用继承提高代码复用。同时，讲解了如何使用super()关键字调用父类方法，以及如何定义私有属性和方法，确保代码的封装性。
python作为一种解释性语言，其主要的编程方式就是面向对象，而且python的框架django也是主要面向对象的编程。
类(class)和对象(object)
类(class)是用来描述具有相同属性(attribute)和方法(method)对象的集合。对象(object)是类(class)的实例。比如学生都有名字和分数，他们有着共同的属性。这时我们就可以设计一个学生类，用来记录学生的名字和分数，并自定义打印出来。
属性(attribute)：类里面用于描述所有对象共同特征的变量或数据。比如此例的学生的名字和分数。
方法(method)：类里面的函数，用来区别类外面的函数，用来实现某些功能。比如打印出学生的名字和分数。
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 #创建一个类
7 classStudent:8
9 #定义学生属性
10 def __init__(self, name, score):11 self.name =name12 self.score =score13
14 #定义打印学生信息的方法
15 defshow(self):16 print("Name: {}. Score: {}".format(self.name, self.score))
这个案例我们只是定义了一个抽象的类，并没有实例化(Instance)。只有实例化时，才会创建一个对象(object)，并为之分配一个存储空间。所以说对象(object)是类(class)的一个实例。
要创建一个具体的学生对象，我么还需：
1 student1 = Student(‘Jimmy’, 100)2 student1 = Student(‘Tom’, 90)
在这个案例中，Student是类，student1和student2是我们创建的具体的学生对象。当我们输入上述代码时，Python会自动调用默认的__init__初始构造函数来生成具体的对象。关键字self是个非常重要的参数，代表创建的对象本身。
当你创建具体的对象后，你可以直接通过student1.name和student1.score来分别获取学生的名字和分数，也可以通过student1.show()来直接打印学生的名字和分数。
类变量(class variables)与实例变量(instance variables)
假设我们需要在Student类里增加一个计数器number，每当一个新的学生对象(Object)被创建时，这个计数器就自动加1。由于这个计数器不属于某个具体学生，而属于Student类的，所以被称为类变量(class variables)。而姓名和分数属于每个学生对象的，所以属于实例变量(instance variables)，也被称为对象变量(object variables)。
这个新student类是这样的：
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 #创建一个类
7 classStudent:8
9 #number属于类变量,不属于具体实例,定义在方法外
10 number =011
12 #定义学生属性,初始化方法
13 def __init__(self, name, score):14 self.name =name15 self.score =score16
17 #此处演示为错误写法,请忽略
18 number = number + 1
19
20 #定义打印学生信息的方法
21 defshow(self):22 print("Name: {}. Score: {}".format(self.name, self.score))
类变量和实例变量的区别很大，访问方式也不一样。
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中，但在函数体之外。访问或调用类变量的方法正确做法是类名.变量名或者self.__class__.变量名。self.__class__自动返回每个对象的类名。
实例变量：定义在方法中的变量。，属于某个具体的对象。访问这个变量的正确方式是self.变量名或者对象名.变量名。
纠正后的正确写法为Student.number或者self.__class__.number：
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 #创建一个类
7 classStudent:8
9 #number属于类变量,不属于具体实例,定义在方法外
10 number =011
12 #定义学生属性,初始化方法
13 def __init__(self, name, score):14 self.name =name15 self.score =score16
17 Student.number = Student.number + 1 #或者self.__class__.number = self.__class__.number + 1
18
19 #定义打印学生信息的方法
20 defshow(self):21 print("Name: {}. Score: {}".format(self.name, self.score))22
23
24 """
25 实例化：26 创建对象27 """
28 student1 = Student('Jimmy', 100)29 student2 = Student('Tom', 90)30
31 print(Student.number) #打印结果：2
32 print(student1.__class__.number) #打印结果：2
类方法(classmethod)
正如同有些变量只属于类，有些方法也只属于类，不属于具体的对象。你有没有注意到属于对象的方法里面都有一个self参数, 比如__init__(self), show(self)?self是指对象本身。属于类的方法不使用self参数， 而使用参数cls，代表类本身。另外习惯上对类方法我们会加上@classmethod的修饰符做说明。
下面仍旧以Student为例，不过这次不用print来打印学生数量，而定义一个类方法来打印，看是不是简洁很多。
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 #创建一个类
7 classStudent:8
9 #number属于类变量,不属于具体实例,定义在方法外
10 number =011
12 #定义学生属性,初始化方法
13 def __init__(self, name, score):14 self.name =name15 self.score =score16
17 Student.number = Student.number + 1 #或者self.__class__.number = self.__class__.number + 1
18
19 #定义打印学生信息的方法
20 defshow(self):21 print("Name: {}. Score: {}".format(self.name, self.score))22
23 #定义类方法，打印学生的数量
24 @classmethod25 deftotal(cls):26 print("Total: {0}".format(cls.number))27
28
29 """
30 实例化：31 创建对象32 """
33 student1 = Student('Jimmy', 100)34 student2 = Student('Tom', 90)35
36 #打印学生数量，Total：2
37 Student.total()
类的私有属性(private attribute)和私有方法(private method)
类里面的私有属性和私有方法以双下划线__开头。私有属性或方法不能在类的外部被使用或直接访问。我们同样看看学生类这个例子，把分数score变为私有属性，看看会发生什么。
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 #创建一个类
7 classStudent:8
9 #定义学生属性,初始化方法
10 def __init__(self, name, score):11 self.name =name12 self.__score =score13
14 #定义打印学生信息的方法
15 defshow(self):16 print("Name: {}. Score: {}".format(self.name, self.__score))17
18
19
20 """
21 实例化：22 创建对象23 """
24 student1 = Student('Jimmy', 100)25 student2 = Student('Tom', 90)26
27 student1.show()28 student1.__score #打印出错，该属性不能从外部访问
如果你将score变成__score, 你将不能直接通过student1.__score获取该学生的分数。show()可以正常显示分数，是因为它是类里面的函数，可以访问私有变量。
私有方法是同样的道理。当我们把show()变成，__show()你将不能再通过student1.__show()打印出学生的名字和分数。值得注意的是私有方法必需含有self这个参数，且把它作为第一个参数。
在面向对象的编程中,通常情况下很少让外部类直接访问类内部的属性和方法，而是向外部类提供一些按钮,对其内部的成员进行访问,以保证程序的安全性，这就是封装。
@property的用法与神奇之处
在上述案例中用户不能用student1.__score方式访问学生分数，然而用户也就知道了__score是个私有变量。我们有没有一种方法让用户通过student1.score来访问学生分数而继续保持__score私有变量的属性呢？这时我们就可以借助python的@property装饰器了。我们可以先定义一个方法score(), 然后利用@property把这个函数伪装成属性。见下面例子:
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 #创建一个类
7 classStudent:8
9 #定义学生属性,初始化方法
10 def __init__(self, name, score):11 self.name =name12 self.__score =score13
14 #定义打印学生信息的方法
15 @property16 defscore(self):17 print("Name: {}. Score: {}".format(self.name, self.__score))18
19
20
21 """
22 实例化：23 创建对象24 """
25 student1 = Student('Jimmy', 100)26 student2 = Student('Tom', 90)27
28 student1.score #Name: Jimmy. Score: 100
注意：一旦给函数加上一个装饰器@property,调用函数的时候不用加括号就可以直接调用函数了
类的继承(Inheritance)
面向对象的编程带来的最大好处之一就是代码的重用，实现这种重用的方法之一是通过继承(Inheritance)。你可以先定义一个基类(Base class)或父类(Parent class)，再按通过class 子类名(父类名)来创建子类(Child class)。这样子类就可以从父类那里获得其已有的属性与方法，这种现象叫做类的继承。
我们再看另一个例子，老师和学生同属学校成员，都有姓名和年龄的属性，然而老师有工资这个专有属性，学生有分数这个专有属性。这时我们就可以定义1一个学校成员父类，2个子类。
1 #-*- coding:utf-8 -*-
2 __author__ = 'dapeng'
3 __date__ = '18-10-26 上午12:08'
4
5
6 classSchoolMember:7
8 def __init__(self, name, age):9 self.name =name10 self.age =age11
12 deftell(self):13 #打印个人信息
14 print('Name: "{}" Age: "{}"'.format(self.name, self.age), end="")15
16
17 classTeacher(SchoolMember):18
19 def __init__(self, name, age, salary):20 SchoolMember.__init__(self, name, age) #利用父类进行初始化
21 self.salary =salary22
23 #方法重写
24 deftell(self):25 SchoolMember.tell(self)26 print('Salary: {}'.format(self.salary))27
28
29 #创建子类Student
30 classStudent(SchoolMember):31
32 def __init__(self, name, age, score):33 SchoolMember.__init__(self, name, age)34 self.score =score35
36 deftell(self):37 SchoolMember.tell(self)38 print('score: {}'.format(self.score))39
40
41 teacher1 = Teacher("Jimmy", 40, "$60000")42 student1 = Student("Tom", 18, 90)43
44 teacher1.tell() #打印 Name: "Jimmy" Age: "40"Salary: $60000
45 student1.tell() #打印 Name: "Tom" Age: "18"score: 90
上述代码中:
在创建子类的过程中，你需要手动调用父类的构造函数__init__来完成子类的构造。
在子类中调用父类的方法时，需要加上父类的类名前缀，且需要带上self参数变量。比如SchoolMember.tell(self), 这个可以通过使用super关键词简化代码。
如果子类调用了某个方法(如tell())或属性，Python会先在子类中找，如果找到了会直接调用。如果找不到才会去父类找。这为方法重写带来了便利。
实际Python编程过程中，一个子类可以继承多个父类，原理是一样的。第一步总是要手动调用__init__构造函数。
super()关键字调用父类方法
在子类当中可以通过使用super关键字来直接调用父类的中相应的方法，简化代码。在下面例子中，学生子类调用了父类的tell()方法。super().tell()等同于SchoolMember.tell(self)。当你使用Python super()关键字调用父类方法时时，注意去掉括号里self这个参数。
1 #创建子类学生Student
2 classStudent(SchoolMember):3
4 def __init__(self, name, age, score):5 SchoolMember.__init__(self, name, age)6 self.score =score7
8 deftell(self):9 super().tell() #等同于 SchoolMember.tell(self)
10 print('score: {}'.format(self.score))
扫一扫
925
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
