面向对象编程概念（Python版）

面向对象编程

什么是面向对象?

1. 面向对象（Object oriented Programming， OOP）编程的思想主要是针对大型软件设计而来的。面向对象编程使程序的扩展性更强，可读性更好，使得编程可以像搭积木一样简单。
2. 面向对象编程将从数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加贴近人的思维，从而大大提高了编程的效率。
3. Python完全采用了面向对象的思想，是真正面向对象的编程语言，完全直齿面向对象的基本功能，例如：继承，多态，封装等。
4. Python中，一切皆对象。之前学习的数据类型，函数等，都是对象。
5. Python支持面向过程，面向对象，函数式编程等多种编程范式。

面向对象和面向过程区别

6. 面向过程（Procedure Oriented）思维
   面向过程编程更加关注的是“程序的逻辑流程”，是一种“执行者”思维，适合编写小规模的程序。
   面向过程思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，最终完成。这个适合简单任务，不需要过多协作的情况下。例如，如何开车？
   1，发动汽车；2，挂挡；3，踩油门；4，启动
   面向过程适合简单，不需要协作的食物。但是思考比较复杂的问题，比如“如何造车？”时，就会发现，无法简单的罗列出所有步骤，因为这些步骤之间涉及很密集的协作过程。因此，面向对象思想应运而生。
7. 面向对象（Object Oriented）思维
   面向对象更加关注的是“软件中对象之间的关系”，是一种“设计者”思维，适合编写大规模的程序。
   面向对象思想更加契合人的思维模式。我们首先思考的是“怎么设计这个事物”，比如思考造车，我们就会首先思考“车怎么设计？”，而不是“怎么按步骤造车？”的问题。这就是思维方式的转变。
8. 面向对象方式思考造车，发现车由以下对象组成：
   1，轮胎
   2，发动机
   3，车壳
   4，座椅
   5，挡风玻璃
   为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤；这样，大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是有步骤的，还是离不开面向过程思想。
   因此，面向对象可以帮助我们从宏观上把握，从整体上分析整个系统。但是具体到实现部分的微观操作（一个个方法），仍然需要面向过程的思路去处理。
   千万不要把面向过程和面向对象对立起来，它们是相辅相成的！
9. 面向对象思考方式
   遇到复杂问题，先从问题中寻找名词（面向过程更多的是找动词），然后确立这些名词哪些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。

对象的进化

随着编程面临的问题越来越复杂，编程语言本身也在进化，从主要处理简单数据开始，随着数据变多，进化出了“数组”；数据结构变复杂，进化出了“结构体”；处理数据的方式和逻辑变复杂，进化出了“对象”。
1，简单数据
像1，2，50这些数字，可以看作是简单数据。最初的计算机编程，都是像这样的数字。
2，数组
将同类型的数据放到一起，比如，整数类型数据[1,2,3,50],浮点类型数据[10,2, 32,5]，字符串型数组[“a”, “cc”]
3，结构体
将不同类型的数据放到一起，为C语言中的数据结构。比如：

struct resume{
	int age;
	char name[10];
	double salary;
};

4，对象
将不同类型的数据、方法（也叫函数）放到一起，就是对象。比如：

class Student:
	company = "SXT" #类的属性
	count = 0 #类的属性
	
	def __init__(self, name, score): #类的方法，包含方法的具体动作
		self.name = name
		self.socre = score
		Student.count = Student.count + 1

	def say_score(self):
		print("我的公司是："Student.company)
		print(self.name,"的分数是：",self.socre)

面向对象三大特征介绍

Python是面向对象的语言，也支持面向对象编程的三大特性：继承，封装（隐藏），多态。

• 封装（隐藏）
  隐藏对象的属性和实现细节（方法），之对外提供必要的方法。相当于将“细节包装起来”，之对外暴露“相关调用方法”。
  通过前面学习到的“私有属性、私有方法”的方式，实现“封装”。Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是一块程序员自觉实现。
  比如，我们创建一个“手机”类，作为消费者，我们不需要掌握所有手机的原理，因为设计者隐藏了不必要的细节，我们只需要了解怎么使用手机。
• 继承
  继承可以让子类具有父类的特征，提高了代码的重用性
  从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法
• 多态
  多态是指同一个方法调用由于对象不同会产生不同的行为，生活中这样的例子比比皆是：同样是休息方法，人不用休息方式不用。甲休息是睡觉，乙休息是玩游戏。

类的定义

如何理解类和对象的关系？
以造房子为例，造房子需要以图纸为准，这个“图纸”就是类；而根据图纸造出来的实体房子，就是对象。
通过类定义数据类型的属性（数据）和方法（行为），也就是说，“类将行为和状态打包在一起”

对象是类的具体实体，一般称为“类的实例”。类看做“图纸”，对象就是根据这个“图纸”建造出的“实体房子”。
从一个类创建对象时，每个对象回共享这个类的行为（类中定义的方法），但会有自己的属性值（不共享状态）。更具体一点，”方法代码共享，属性数据不共享“。

Python中，一切皆对象。类也称为“类对象”，类的实例也称为“实例对象”。
定义类的语法格式如下：
class 类名:
类体
要点：
1.类名必须符合“标识符“原则；一般规定，首字母大写，多个单词使用”驼峰原则“。
2.类体中可以定义属性和方法。
3.属性用来描述数据，方法（函数）用来描述数据的相关操作。
示例：

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

	def  say_score(self):
		print(self.name, ‘的分数是：’, self.score)

s1 = Student('张三'，80) #实例对象名为s1，

s1 = Student(“张三”，80)，这句的意思，为调用构造方法，即对应类中的__init__，括号中为参数。注意，self为创建的实例对象的地址，调用构造方法后自动将参数传给self。self.name为Student的属性之一（自己定义），用于储存传入的参数name，score同理。

构造函数__init__()

类是抽象的，也称为”对象的模板“。通过这个模板，创建类的实例对象，才能使用类定义的功能。

Python的对象包括三个部分：id（identity，识别码）、type（对象类型）、value（对象的值）。
进一步的认识，一个Python对象包含以下部分：
1.id（identity，识别码）
2.type（对象类型）
3.value（对象的值）
（1）属性（attribute）
（2）方法（method）
创建对象，需要定义构造函数__init__方法。构造方法用于执行”实例对象的初始化工作“，即对象创建后，初始化当前对象的相关属性，无返回值。

init__的要点如下：
1.名称固定，必须为__init。
2.第一个参数固定，必须为self。self指的就是创建好的实例对象。
3.构造函数通常用来初始化实例对象的实例属性，以下代码就是初始化实例属性：name和score。

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

4.通过”类名（参数列表）“来调用构造函数。调用后，将创建好的对象返回给相应的变量。例如：
s1 = Student(“张三”, 80)。s1就是实体化的对象，根据参数顺序传入了name 和score的值，并储存于s1的内存中。
5.__init__方法：初始化创建好的对象，初始化指的是”给实例属性赋值“
6.__new__方法：用于创建对象，但我们一般无需重定义该方法。注：这一方法默认调用，无需再写一次。

实例属性、方法

实例属性

实例属性即所创建的实例对象的属性，也称为”实例变量“。它的使用有如下几个要点：
1.实例属性一般在__init__()方法中通过如下代码定义：
self.实例属性名 = 初始值
2.在本类的其他实例方法中，也是通过self进行访问。：
self.实例属性名
3.创建实例对象后，通过实例对象进行访问：
obj = 类名（）#创建对象，调用__init__初始化属性
obj.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性。（新加的属性为子类独有，创建新的子类时不继承）

实例方法

实例方法是从术语实例对象的方法。实例方法的定义格式如下：
def 方法名（self,[形参列表]）:
函数体
方法的调用格式如下：
实例对象.方法名（[实参列表]）
注意：
1.定义实例方法时，第一个参数必须为self。和前面一样，self指当前的实例对象。
2.调用实例方法时，不需要也不能给self传参，self由解释器自动传参。

• 函数和方法的区别：
  1.都是用来完成一个功能的语句块，本质一样。
  2.方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点。
  3.直观上看，方法定义时需要传递self，函数不需要。

类对象

在类定义格式中，”class 类名:“。实际上，当解释器执行class语句时，就会创建一个类对象。

class Student
	pass #空语句
	
print(type(Student))
print(id(Student))

Stu2 = Student
s2 = Stu2('Tom', 80)

以上过程中，Stu2 = Student这句代码，意为以Student类为模板，创建一个名为Stu2的类，其属性和方法与引用的类一致。

类属性和类方法

类属性

类属性是从属于”类对象“的属性，也称为”类变量“。由于类属性从属于类对象，可以被所有实例对象共享。
类属性的定义方法：
class 类名：
类变量名 = 初始值

在类中或者类的外面，我们可以通过：”类名.类变量名“来读写
示例：类属性的使用测试

class Student:
	company = "SXT" #类属性
	count = 0 #类属性

	def __init__(self,name, score):
		self.name = name #实例属性
		self.score = score #实例属性
		Student.count = Student.count + 1 #创建实例对象次数计数，每创建一次+1
		
	def say_score(self):
		print('我的公司是：', Student.company)
		print(self.name, '的分数是', self.score)

s1 = Student('张三', 80)
s1.say_score()
print('一共创建{0}个对象'.format{Student.count})

类方法

类方法是从属于”类对象“的方法。类方法通过装饰器@classmethod来定义，格式如下：
@classmethod
def 类方法名(cls, [形参列表]):
函数体

要点如下：
1.@classmethod必须位于方法上面一行
2.第一个cls必须有；cls值的就是”类对象“本身
3.调用类方法格式：”类名.类方法名(参数列表)“。参数列表中，不需要也不能给cls传参。
4.类方法中访问实例属性和实例方法会导致错误。
5.子类继承父类方法时，传入cls是子类对象，而非父类对象
示例：类方法使用测试

class Student:
	company = "SXT"
	
	@classmethod
	def PrintCompany(cls):
		print(cls.company)

Student.PrintCompany()

静态方法

Python中允许定义与”类对象“无关的方法，称为”静态方法“
”静态方法“和在模块中定义普通函数没有区别，只不过”静态方法“放到了”类的名字空间里面“，需要通过”类调用“。
静态方法通过修饰器@staticmethod定义，格式如下：
@staticmethod
def 静态方法名（[形参列表]）
函数体

要点如下：
1.@staticmethod必须位于方法上面一栏。
2.调用静态方法格式：”类名.静态方法名（参数列表）“
3.静态方法中访问实例属性和实例方法会导致错误
示例：静态方法使用测试

class Student:
	company = "SXT" #类属性
	
	@staticmethod
	#此方法没有调用到类属性
	#可以调用类属性，不可以调用实例属性
	def add(a, b):
		print('{0} + {1} = {2}'.format(a, b, (a + b)))
		return a + b

Student.add(20, 30)

__call__方法和可调用对象

定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。
举个例子：

a = 30
b = 50
c = a + b
上式中的“+”号，也可以表示为：
d = a.__add__(b)

在实质上，我们使用“+”号，就是调用了__call__这个方法。
在类中，如果我们想像使用函数一样使用对象，我们可以定义属于对象的__call__方法。

class SalaryCount:
	def __call__(self, salary):
		YearSalary = salary * 12
		DaySalary = salary//22.5  #国家规定的每个月的平均工作时间
		HourSalary = DaySalary//8

方法没有重载，方法的动态性

• Python中，方法的参数没有生命类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python中是没有方法的重载的。定义一个方法即可有多种调用方式，相当于实现了其他语言中的方法的重载。
• 如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。

class Person:
    def say_hi(self):
        print('hello')
        
    def say_hi(self, name):
        print({'{0}, hello'.format(name)})
        
        
p1 = Person()
p1.say_hi('Tom')

返回结果为：
{'Tom, hello'}
证明两个方法重名时，只有最后一个方法有效

Python是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有方法

class Person:
    def work(self):
        print('努力上班')
        
def play_game(s):
    print('{0}在玩游戏'.format(s))
    
可以看到，类中只定义了一个方法，我们如果想添加新的方法，需要这么做：    
Person.play = play_game

我们也可以编写一个与原方法重名的方法，来覆盖原本的方法
def work2(s):
	print('好好工作')
	
p = Person()
p.work()
p.play()

私有属性和私有方法（实现封装）

Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：

1，通常约定，两构下划线（__）开头的属性是私有的（private），其他的为公共的（public）。
2，类内部可以访问私有属性（方法）
3，类外部不能直接访问私有属性（方法）
4，类外部可以通过“_类名__私有属性（方法）名”访问私有属性（方法）

【注】：方法本质上也是属性，只不过是可以通过（）执行而已。所以，此处讲的私有属性和公有属性，也同时讲解了私有方法和公有方法的用法。如下测试中，同时也包含了私有方法和公有方法的例子。

class Employee:
    def __init__(self, name, age):
        self.name = name
        #私有属性定义：
        self.__age = age

	def __work(self):
		print('{0}的年龄是：'.format(self.__age)) #类内部可以直接调用
        
e = Employee('Tom', 18)
print(e.name)
#print(e.age) #无法从外部直接访问，报错
print(e._Employee__age)

继承

概念

继承是面向对象程序设计的重要特征，也是实现“代码复现”的重要手段。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类”或者“基类”，新的类，我们称为“子类”或者“派生类”
举个例子，“猫”和“狗”，都属于”哺乳动物“，也都属于“动物”。那么猫狗就属于子类，继承了其父类“哺乳动物”的部分特性，而“哺乳动物“类也会继承一些其父类”动物“的特性

语法

Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：

class 子类类名(父类1[, 父类2, ...]):
	类体

如果在类定义中没有指定父类，则默认父类是object类。也就是说，object是所有类的父类，里面定义了一些所有类公有的默认实现，比如：__new__方法。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：

父类名.__init__(self, 参数列表)

示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def say_age(self):
        print(self.name, '的年龄是：', self.age)
        
        
class Student(Person):
    def __init__(self, name, age, score):
        self.score = score
        
        Person.__init__(self, name, age)
        #构造函数中包含调用父类构造函数。根据需要，不是必须。
        #子类并不会自动调用父类的__init__()，我们必须显式的调用它

s1 = Student('张三', 15, 85)
s1.say_age()

类成员的继承和重写

1，成员继承：子类继承了父类出构造方法之外的所有成员
2，方法重写：子类可以重新定义父类中的方法，这样会覆盖父类的方法，也称为”重写“。
示例：继承和重写的案例

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def say_age(self):
        print(self.name, '的年龄是：', self.age)
        
    def say_introduce(self):
        print('我的名字是：{0}', format(self.name))
        

class Student(Person):
    def __init__(self, name, age, score):
        Person.__init__(self, name, age)
        self.score = score
 
    #将继承的父类方法重写，覆盖父类的方法
    def say_introduce(self):
        print('报告，我的名字是', self.name)
        
s = Student('Tom', 18, 80)
s.say_introduce()

查看类的继承层次结构

通过类的方法mro()或者类的属性__mor__可以输出这个类的继承层次结构。
操作：查看类的继承层次结构

class A:
	pass

class B(A):
	pass

class C(B):
	pass

print(C.mro())

输出结果为：
[<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class ‘object’>]

• 注意：Python支持多重继承，一个子类可以有多个”直接父类“。这样，就具备了”多个父类“的特点。但是，由于这样会被”类的整体层次“搞的异常复杂，应尽量避免使用。
• 当一个子类继承的多个父类中，存在相同名字的方法，在子类没有指定父名的时候，解释器将”从左往右“按顺序搜索。（MRO（Method Resolution Order）：方法解析顺序。我们可以通过mro()方法获得”类的层次结构“，方法解析顺序也是按照这个”类的层次结构寻找的“）

object根类

object类是所有类的父类。因此所有的类都有object类的属性和方法。

air()查看对象属性

为了深入学习对象，我们先学习内置函数dir()，它可以让我们方便的看到指定对于所有的属性。
【测试】查看对象所有属性以及和object进行对比

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def say_age(self):
        print(self.name, '的年龄是：', self.age)
        
    def say_introduce(self):
        print('我的名字是：{0}', format(self.name))
        
obj = object()
print(dir(obj))

s2 = Person('Tom', 18)
print(dir(s2))

输出结果：
[‘class’, ‘delattr’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’]
[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘age’, ‘name’, ‘say_age’, ‘say_introduce’]
对比上面结果，发现：
1，Person对象增加了6个属性：
dict，module，weakref， age， name， say_age
2.object的所有属性，Person类作为object的子类，显然包含了所有的属性。
3.我们打印age、name、say_age，发现say_age虽然是方法，实际上也是属性。只不过，这个属性的类型是”method“而已。
age <class’int’>
name <class’str’>
say_age <class ‘method’>

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过super()来做。
super()代表父类的定义，不是父类对象。

class A:
    def say(self):
        print('A:', self)
        

class B(A):
    def say(self):
    	#方法1
    	#A.say(self)
    	#方法2
        super().say()
        print('B:', self)
        
B().say()