面向对象（Object oriented Programming，OOP）编程的思想主要是针对大型软件设计而来的。面向对象编程使程序的扩展性更强、可读性更好，使的编程可以像搭积木一样简单。

面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维，从而大大提高了编程的效率。

Python 完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承、多态、封装等。

Python 中，一切皆对象。我们在前面学习的数据类型、函数等，都是对象。

面向对象和面向过程区别

面向过程(Procedure Oriented)思维

面向过程编程更加关注的是“程序的逻辑流程”，是一种“执行者”思维，适合编写小规模的程序。
面向过程思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终完成。 这个适合简单任务，不需要过多协作的情况下。比如，如何开车？
我们很容易就列出实现步骤：

1. 发动车
2. 挂挡
3. 踩油门
4. 走你

面向过程适合简单、不需要协作的事务。 但是当我们思考比较复杂的问题，比如“如何造车？”，就会发现列出 1234 这样的步骤，是不可能的。那是因为，造车太复杂，需要很多协作才能完成。此时面向对象思想就应运而生了。

面向对象(Object Oriented)思维

面向对象更加关注的是“软件中对象之间的关系”，是一种“设计者”思维，适合编写大规模的程序。
面向对象(Object)思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物？”比如思考造车，我们就会先思考“车怎么设计？”，而不是“怎么按步骤造车的问题”。这就是思维方式的转变。面向对象方式思考造车，发现车由如下对象组成：

1. 轮胎
2. 发动机
3. 车壳
4. 座椅
5. 挡风玻璃

为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤；这样，发现大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是有步骤的，还是离不开面向过程思想！
因此，面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。 但是，具体到实现部分的微观操作（就是一个个方法），仍然需要面向过程的思路去处理。我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面向过程！

面向对象思考方式

遇到复杂问题，先从问题中找名词（面向过程更多的是找动词），然后确立这些名词哪些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。

面向对象和面向过程的总结

1. 都是解决问题的思维方式，都是代码组织的方式。
2. 解决简单问题可以使用面向过程
3. 解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

对象的进化

随着编程面临的问题越来越复杂，编程语言本身也在进化，从主要处理简单数据开始，随着数据变多进化“数组”； 数据类型变复杂，进化出了“结构体”； 处理数据的方式和逻辑变复杂，进化出了“对象”。

1. 简单数据
   像 30,40，50.4 等这些数字，可以看做是简单数据。最初的计算机编程，都是像这样的数字。
2. 数组
   将同类型的数据放到一起。比如：整数数组[20,30,40]，浮点数数组[10.2, 11.3, 12.4]，字符串数组：[“aa”,”bb”,”cc”]
3. 结构体
   将不同类型的数据放到一起，是 C 语言中的数据结构。比如：
4. 对象
   将不同类型的数据、方法（即函数）放到一起，就是对象。比如：

class Student:company = "SXT" #类属性count = 0 #类属性def __init__(self,name,score):self.name = name #实例属性self.score = scoreStudent.count = Student.count+1def say_score(self): #实例方法print("我的公司是：",Student.company)print(self.name,'的分数是：',self.score)

我们前面提到的数字也是对象。比如：整数 9，就是一个包含了加法、乘法等方法的对象。

类的定义

我们把对象比作一个“饼干”，类就是制造这个饼干的“模具”。

我们通过类定义数据类型的属性（数据）和方法（行为）,也就是说，“类将行为和状态打包在一起”。

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

Python 中，“一切皆对象”。类也称为“类对象”，类的实例也称为“实例对象”。定义类的语法格式如下：

class 类名：类体

要点如下：

1. 类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
2. 类体中我们可以定义属性和方法。
3. 属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。

【操作】一个典型的类的定义

class Student:def __init__(self,name,score): #构造方法第一个参数必须为 selfself.name = name #实例属性self.score = scoredef say_score(self): #实例方法print(self.name,'的分数是：',self.score)s1 = Student('张三',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()

__init__构造方法和__new__方法

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

我们前面说过一个 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

1. 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。
   比如：s1 = Student(‘张三’, 80)
2. init()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
3. new()方法: 用于创建对象，但我们一般无需重定义该方法。
4. 如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参
   的__init__方法，系统不创建默认的__init__方法。

注：
Python 中的 self 相当于 C++中的 self 指针，JAVA 和 C#中的 this 关键字。Python 中，
self 必须为构造函数的第一个参数，名字可以任意修改。但一般遵守惯例，都叫做 self。

实例属性和实例方法

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：

1. 实例属性一般在__init__()方法中通过如下代码定义：
   self.实例属性名 = 初始值
2. 在本类的其他实例方法中，也是通过 self 进行访问：
   self.实例属性名
3. 创建实例对象后，通过实例对象访问：
   obj01 = 类名() #创建对象，调用__init__()初始化属性
   obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def 方法名(self [, 形参列表])：函数体方法的调用格式如下：对象.方法名([实参列表])

要点：

1. 定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。
2. 调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。

函数和方法的区别

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

实例对象的方法调用本质：

其他操作：

1. dir(obj)可以获得对象的所有属性、方法
2. obj.dict 对象的属性字典
3. pass 空语句
4. isinstance（对象,类型） 判断“对象”是不是“指定类型”

类对象、类属性、类方法、静态方法

类对象

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

【操作】测试类对象的生成

class Student:pass #空语句print(type(Student))
print(id(Student))
a = Student()
a.say_score() Student.say_score(a)Stu2 = Student
s1 = Stu2()
print(s1)

执行结果如下：
<class ‘type’>
51686328
<main.Student object at 0x0000000002B5FDD8>

我们可以看到实际上生成了一个变量名就是类名“Student”的对象。我们通过赋值给新变量 Stu2，也能实现相关的调用。说明，确实创建了“类对象”。

【注】pass 为空语句。就是表示什么都不做，只是作为一个占位符存在。当你写代码时，遇到暂时不知道往方法或者类中加入什么时，可以先用 pass 占位，后期再补上。

类属性

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

class 类名：类变量名= 初始值

在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。

【操作】 类属性的使用测试

class Student:company = "SXT" #类属性count = 0 #类属性def __init__(self,name,score):self.name = name #实例属性self.score = scoreStudent.count = Student.count+1def say_score(self): #实例方法print("我的公司是：",Student.company)print(self.name,'的分数是：',self.score)s1 = Student('张三',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()
print('一共创建{0}个 Student 对象'.format(Student.count))

执行结果：
我的公司是： SXT
张三 的分数是： 80 一共创建 1 个 Student 对象

类方法

类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod
def 类方法名(cls [，形参列表]) ：函数体

要点如下：

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

【操作】类方法使用测试

class Student:company = "SXT" #类属性@classmethoddef printCompany(cls):print(cls.company)Student.printCompany()

静态方法

Python 中允许定义与“类对象”无关的方法，称为“静态方法”。

“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。

静态方法通过装饰器@staticmethod 来定义，格式如下：

@staticmethod
def 静态方法名([形参列表]) ：函数体

要点如下：

1. @staticmethod 必须位于方法上面一行
2. 调用静态方法格式：“类名.静态方法名(参数列表)”。
3. 静态方法中访问实例属性和实例方法会导致错误

【操作】静态方法使用测试

class Student:company = "SXT" # 类属性@staticmethoddef add(a, b): # 静态方法print("{0}+{1}={2}".format(a,b,(a+b)))return a+bStudent.add(20,30)

内存分析实例对象和类对象创建过程

我们以下面代码为例，分析整个创建过程，让大家对面向对象概念掌握更加深刻：

class Student:company = "尚学堂" #类属性count = 0 #类属性def __init__(self,name,score):self.name = name #实例属性self.score = scoreStudent.count = Student.count+1def say_score(self): #实例方法print("我的公司是：",Student.company)print(self.name,'的分数是：',self.score)s1 = Student('高淇',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()
print('一共创建{0}个 Student 对象'.format(Student.count))

__del__方法(析构函数)和垃圾回收机制

__del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源，例如：打开的文件资源、网络连接等。

Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用__del__方法。

我们也可以通过 del 语句删除对象，从而保证调用__del__方法。
系统会自动提供__del__方法，一般不需要自定义析构方法。

#析构函数
class Person:def __del__(self):print("销毁对象：{0}".format(self))p1 = Person()
p2 = Person()
del p2
print("程序结束")

运算结果：

销毁对象：<main.Person object at 0x02175610>
程序结束
销毁对象：<main.Person object at 0x021755D0>

__call__方法和可调用对象

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

#测试__call__，可调用对象class SalaryAccount: '''工资计算类''' def __call__(self, salary):yearSalary = salary*12daySalary = salary//30hourSalary = daySalary//8return dict(monthSalary=salary,yearSalary=yearSalary,daySalary=daySalary,hourSalary=hourSalary)s = SalaryAccount()
print(s(5000)) #可以像调用函数一样调用对象的__call__方法

运行结果：
{‘monthSalary’: 5000, ‘yearSalary’: 60000, ‘daySalary’: 166, ‘hourSalary’: 20}

方法没有重载

在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含 3个部分：方法名、参数数量、参数类型。

Python 中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python 中是没有方法的重载的。定义一个方法即可有多种调用方式，相当于实现了其他语言中的方法的重载。

如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。

建议：不要使用重名的方法！Python 中方法没有重载。

方法的动态性

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

#测试方法的动态性
class Person:def work(self):print("努力上班！")def play_game(self):print("{0}玩游戏".format(self))def work2(s):print("好好工作，努力上班！")Person.play = play_game
Person.work = work2
p = Person()
p.play()
p.work()

我们可以看到，Person 动态的新增了 play_game 方法，以及用 work2 替换了 work 方法。

私有属性和私有方法(实现封装)

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

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

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

【测试】私有属性和公有属性使用测试

#测试私有属性、私有方法
class Employee: __company = "百战程序员" #私有类属性. 通过 dir 可以查到_Employee__companydef __init__(self,name,age):self.name = nameself.__age = age #私有实例属性def say_company(self):print("我的公司是：",Employee.__company) #类内部可以直接访问私有属性print(self.name,"的年龄是：",self.__age)self.__work()def __work(self): #私有实例方法 通过 dir 可以查到_Employee__workprint("工作！好好工作，好好赚钱，娶个媳妇！")p1 = Employee("高淇",32)
print(p1.name)
print(dir(p1)) #
p1.say_company()
print(p1._Employee__age)
#通过这种方式可以直接访问到私有属性 。通过 dir 可以查到属性：_Employee__age
#print(p1.__age) #直接访问私有属性，报错
#p1.__sleep() #直接访问私有方法，报错

执行结果：
高淇
[’_Person__age’, ‘_Person__leg_num’, ‘_Person__sleep’, ‘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’, ‘name’, ‘say_age’]
腿的数目： 2
高淇 的年龄是： 18
睡觉
18

从打印的 Person 对象所有属性我们可以看出。私有属性“__age”在实际存储时是按照“_Person__age”这个属性来存储的。这也就是为什么我们不能直接使用“__age”而可以使用“_Person__age”的根本原因。

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。下面是一个简单的示例，让大家体会一下这种转变：

#简单测试@property
class Employee:@propertydef salary(self):return 30000;emp1 = Employee()
print(emp1.salary) #打印 30000
print(type(emp1.salary)) #打印<class 'int'>
#emp1.salary() #报错：TypeError: 'int' object is notcallable
#emp1.salary =1000 #@property 修饰的属性，如果没有加 setter 方法，则为只读属性。此处修改报错：AttributeError: can't setattribute

@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个属性，我们可以直接通过：
emp1.salary = 30000 如上的操作读操作、写操作。但是，这种做法不安全。比如，我需要限制薪水必须为 1-10000的数字。这时候，我们就需要通过 getter、setter 方法来处理。

#测试@property
class Employee:def __init__(self,name,salary):self.name = nameself.__salary = salary@property #相当于 salary 属性的 getter 方法def salary(self):print("月薪为{0},年薪为{1}".format(self.__salary,(12*self.__salary)))return self.__salary;@salary.setterdef salary(self,salary): #相当于 salary 属性的 setter 方法if(0<salary<1000000):self.__salary = salaryelse:print("薪水录入错误！只能在 0-1000000 之间")emp1 = Employee("高淇",100)
print(emp1.salary)
emp1.salary = -200

运行结果：
月薪为 100,年薪为 1200
100
月薪为 100,年薪为 1200
100
薪水录入错误！只能在 0-1000000 之间

属性和方法命名总结

1. _xxx：保护成员，不能用“from module import * ”导入，只有类对象和子类对象能访问这些成员。
2. xxx：系统定义的特殊成员
3. __xxx： 类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通过“对象名. _类名__xxx”这种特殊方式访问。Python 不存在严格意义的私有成员）

注：再次强调，方法和属性都遵循上面的规则。

类编码风格

1. 类名首字母大写，多个单词之间采用驼峰原则。
2. 实例名、模块名采用小写，多个单词之间采用下划线隔开。
3. 每个类，应紧跟“文档字符串”，说明这个类的作用。
4. 可以用空行组织代码，但不能滥用。在类中，使用一个空行隔开方法；模块中，使用两个空行隔开多个类。

---

面向对象三大特征介绍

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

封装（隐藏）

隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。通过前面学习的“私有属性、私有方法”的方式，实现“封装”。

Python 追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。

继承

继承可以让子类具有父类的特性，提高了代码的重用性。

从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。

如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。

语法格式

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

class 子类类名(父类 1[，父类 2，...])：类体

如果在类定义中没有指定父类，则默认父类是 object 类。也就是说，object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如：new()。

定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：

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

【操作】实现Python类继承

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

运行结果：
张三 的年龄是： 15
[’_Person__age’, ‘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’, ‘name’, ‘say_age’, ‘score’]

类成员的继承和重写

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

【操作】继承和重写的案例

class Person:def __init__(self,name,age):self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是：",self.age)def say_name(self):print("我是",self.name)class Student(Person):def __init__(self,name,age,score):self.score = scorePerson.__init__(self,name,age) #构造函数中包含调用父类构造函数def say_score(self):print(self.name,"的分数是：",self.score)def say_name(self): #重写父类的方法print("报告老师，我是",self.name)s1 = Student("张三",15,85)
s1.say_score()
s1.say_name()
s1.say_age()

执行结果：
张三 的分数是： 85
报告老师，我是 张三
张三 的年龄是： 15

查看类的继承层次结构

通过类的方法 mro()或者类的属性__mro__可以输出这个类的继承层次结构。

【操作】 查看类的继承层次结构

class A:passclass B(A):passclass C(B):passprint(C.mro())

执行结果：
[<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class ‘object’>]

object 根类

object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。我们显然有必要深入研究一下 object 类的结构。对于我们继续深入学习 Python 很有好处。

dir()查看对象属性

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

class Person:def __init__(self,name,age):self.name = nameself.age = agedef say_age(self):print(self.name,"的年龄是：",self.age)obj = object()
print(dir(obj))
s2 = Person("高淇",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’]

从上面我们可以发现这样几个要点：

1. Person 对象增加了六个属性：
   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’>

【注】关于 object 这些属性的详细学习，会在后面学习中逐个涉及。在此，无法一一展开。

重写__str__()方法

object 有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数 str() 经常用于 print()方法，帮助我们查看对象的信息。

str()可以重写。

class Person:def __init__(self,name,age):self.name = nameself.__age = agedef __str__(self): '''将对象转化成一个字符串，一般用于 print 方法''' return "名字是：{0},年龄是{1}".format(self.name,self.__age)p = Person("高淇",18)
print(p)

运行结果：
名字是：高淇,年龄是 18

多重继承

Python 支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。

#多重继承
class A:def aa(self):print("aa")class B:def bb(self):print("bb")class C(B,A):def cc(self):print("cc")c = C()
c.cc()
c.bb()
c.aa()

运算结果：
cc
bb
aa

继承结构：

MRO()

Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。 MRO（Method Resolution Order）：方法解析顺序。 我们可以通过 mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

#多重继承
class A:def aa(self):print("aa")def say(self):print("say AAA!")class B:def bb(self):print("bb")def say(self):print("say BBB!")class C(B,A):def cc(self):print("cc")c = C()
print(C.mro()) #打印类的层次结构
c.say() #解释器寻找方法是“从左到右”的方式寻找，此时会执行 B类中的 say()

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过 super()来做。

super()代表父类的定义，不是父类对象。

#super()
class A:def say(self):print("A: ",self)print("say AAA")class B(A):def say(self):#A.say(self) 调用父类的 say 方法super().say() #通过 super()调用父类的方法print("say BBB")
b = B()
b.say()

运行结果：
A: <main.B object at 0x007A5690>
say AAA
say BBB

多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。同样是吃饭的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

关于多态要注意以下 2 点：

1. 多态是方法的多态，属性没有多态。
2. 多态的存在有 2 个必要条件：继承、方法重写

class Animal:def shout(self):print("动物叫了一声")class Dog(Animal):def shout(self):print("小狗，汪汪汪")class Cat(Animal):def shout(self):print("小猫，喵喵喵")def animalShout(a):if isinstance(a,Animal):a.shout() #传入的对象不同，shout 方法对应的实际行为也不同。animalShout(Dog())
animalShout(Cat())

运行结果：
小狗，汪汪汪
小猫，喵喵喵

特殊方法和运算符重载

Python 的运算符实际上是通过调用对象的特殊方法实现的。比如：

a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)

运算结果：
c= 50
d= 50

常见的特殊方法统计如下：

每个运算符实际上都对应了相应的方法，统计如下：
我们可以重写上面的特殊方法，即实现了“运算符的重载”。

#测试运算符的重载
class Person:def __init__(self,name):self.name = namedef __add__(self, other):if isinstance(other,Person):return "{0}--{1}".format(self.name,other.name)else:return "不是同类对象，不能相加"def __mul__(self, other):if isinstance(other,int):return self.name*otherelse:return "不是同类对象，不能相乘"p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)

运算结果：
高淇–高希希
高淇高淇高淇

特殊属性

Python 对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这里我们列出常见的特殊属性：

#测试特殊属性
class A:passclass B:passclass C(B,A):def __init__(self,nn):self.nn = nndef cc(self):print("cc")c = C(3)
print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())`

运行结果：
[‘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’, ‘cc’, ‘nn’]
{‘nn’: 3}
<class ‘main.C’>
(<class ‘main.B’>, <class ‘main.A’>)
[<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class ‘object’>]
[<class ‘main.C’>]

对象的浅拷贝和深拷贝

1. 变量的赋值操作
   只是形成两个变量，实际还是指向同一个对象。
2. 浅拷贝
   Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
3. 深拷贝
   使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。

#测试对象的引用赋值、浅拷贝、深拷贝
import copyclass MobilePhone:def __init__(self,cpu,screen):self.cpu = cpuself.screen = screenclass CPU:def calculate(self):print("计算，算个 12345")print("CPU 对象:",self)class Screen:def show(self):print("显示一个好看的画面，亮瞎你的钛合金大眼")print("屏幕对象：",self)c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()
n = m #两个变量，但是指向了同一个对象
print(m,n)
m2 = copy.copy(m) #m2 是新拷贝的另一个手机对象
print(m,m2)
m.cpu.calculate()
m2.cpu.calculate() #m2 和 m 拥有了一样的 cpu 对象和 screen 对象
m3 = copy.deepcopy(m)
m3.cpu.calculate() #m3 和 m 拥有不一样的 cpu 对象和 screen对象

运算结果：
计算，算个 12345
CPU 对象: <main.CPU object at 0x00685690>
<main.MobilePhone object at 0x00685B50> <main.MobilePhone object at 0x00685B50>
<main.MobilePhone object at 0x00685B50> <main.MobilePhone object at 0x0069B490>
计算，算个 12345
CPU 对象: <main.CPU object at 0x00685690>
计算，算个 12345
CPU 对象: <main.CPU object at 0x00685690>
计算，算个 12345
CPU 对象: <main.CPU object at 0x006A5DB0>

组合

“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。

“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

#组合测试
class MobilePhone:def __init__(self,cpu,screen):self.cpu = cpuself.screen = screenclass CPU:def calculate(self):print("计算，算个 12345")class Screen:def show(self):print("显示一个好看的画面，亮瞎你的钛合金大眼")c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate() #通过组合，我们也能调用 cpu 对象的方法。相当于手机对象间接拥有了“cpu 的方法”
m.screen.show()

运算结果：
计算，算个 12345
显示一个好看的画面，亮瞎你的钛合金大眼

设计模式_工厂模式实现

设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。当然，我们没有必要全部学习，学习几个常用的即可。

对于初学者，我们学习两个最常用的模式：工厂模式和单例模式。

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

#工厂模式
class CarFactory:def createCar(self,brand):if brand == "奔驰":return Benz()elif brand == "宝马":return BMW()elif brand == '比亚迪':return BYD()else:return "未知品牌，无法创建"class Benz:passclass BMW:passclass BYD:passfactory = CarFactory()
c1 = factory.createCar("奔驰")
c2 = factory.createCar("宝马")
print(c1)
print(c2)

运行结果：
<main.Benz object at 0x021C5770>
<main.BMW object at 0x021C5790>

设计模式_单例模式实现

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。

单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。

单例模式有多种实现的方式，我们这里推荐重写__new__()的方法。

#单例模式
class MySingleton:__obj = None__init_flag = Truedef __new__(cls, *args, **kwargs):if cls.__obj == None:cls.__obj = object.__new__(cls)return cls.__objdef __init__(self,name):if MySingleton.__init_flag:print("init....")self.name = nameMySingleton.__init_flag = Falsea = MySingleton("aa")
print(a)
b = MySingleton("bb")
print(b)

运算结果：
init…
<main.MySingleton object at 0x01E15610>
<main.MySingleton object at 0x01E15610>

设计模式称之为“模式”，就是一些固定的套路。我们很容易用到其他场景上，比如前面讲的工厂模式，我们需要将工厂类定义成“单例”，只需要简单的套用即可实现：

#测试工厂模式和单例模式的整合使用
class CarFactory: __obj = None #类属性__init_flag = Truedef create_car(self,brand):if brand =="奔驰":return Benz()elif brand =="宝马":return BMW()elif brand == "比亚迪":return BYD()else:return "未知品牌，无法创建" def __new__(cls, *args, **kwargs):def __new__(cls, *args, **kwargs):if cls.__obj ==None:cls.__obj = object.__new__(cls)return cls.__objdef __init__(self):if CarFactory.__init_flag:print("init CarFactory....")CarFactory.__init_flag = Falseclass Benz:passclass BMW:passclass BYD:passfactory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)
factory2 = CarFactory()
print(factory)
print(factory2)

运算结果：
init CarFactory…
<main.Benz object at 0x01E36E90>
<main.BYD object at 0x01E36C30>
<main.CarFactory object at 0x01E36730>
<main.CarFactory object at 0x01E36730>

如何深度解析Python面向对象相关推荐

1. 部分仍在编辑文章 - Python基础专题 - 深度解析python中的赋值与拷贝

   深度解析python中的赋值与拷贝 jcLee95 的 CSDN 博客:https://blog.csdn.net/qq_28550263?spm=1011.2124.3001.5343 邮箱 :29 ...

2. 深度解析Python的内存管理机制：垃圾回收机制

   Python程序在运行时,需要在内存中开辟出一块空间,用于存放运行时产生的临时变量,计算完成后,再将结果输出到永久性存储器中.但是当数据量过大,或者内存空间管理不善,就很容易出现内存溢出的情况,程序可 ...

3. python是不是特别垃圾-深度解析Python垃圾回收机制（超级详细）

   我们知道,目前的计算机都采用的是图灵机架构,其本质就是用一条无限长的纸带,对应今天的存储器.随后在工程学的推演中,逐渐出现了寄存器.易失性存储器(内存)以及永久性存储器(硬盘)等产品.由于不同的存储器 ...

4. python垃圾回收价格表_深度解析Python垃圾回收机制（超级详细）

   我们知道,目前的计算机都采用的是图灵机架构,其本质就是用一条无限长的纸带,对应今天的存储器.随后在工程学的推演中,逐渐出现了寄存器.易失性存储器(内存)以及永久性存储器(硬盘)等产品.由于不同的存储器 ...

5. 万字长文深度解析python 单元测试

   文章目录 unittest 基本概念 基本用法 命令行操作 组织测试用例 跳过测试&预期错误 subTest unittest小结 doctest 先谈pydoc doctest与unitte ...

6. python切片原理_深度解析Python切片

   详解Python 切片语法 Python的切片是特别常用的功能,主要用于对列表的元素取值.使用切片也会让你的代码显得特别Pythonic. 切片的主要声明如下,假设现在有一个list,命名为alist ...

7. Python源码深度解析—Python提供的C API

   今天比较忙,所以更新的较少,不过满满的都是干货啊! 建议将思维导图保存下来观看,或点击这里在线观看.

8. python编程基础是什么-Python面向对象编程基础解析（一）

   1.什么是面向对象 面向对象(oop)是一种抽象的方法来理解这个世界,世间万物都可以抽象成一个对象,一切事物都是由对象构成的.应用在编程中,是一种开发程序的方法,它将对象作为程序的基本单元. 2.面向 ...

9. python描述器深度解析

   写在篇前   在之前的博客Python面向对象.魔法方法中曾简单提到魔法方法__get__.__set__.__delete__,但只给出一个例子,这篇文章将对它做一个更详细的总结,因为这三个魔法函数 ...

最新文章

1. JavaScript规范
2. pyspark dataframe数据连接（join）、转化为pandas dataframe、基于多个字段删除冗余数据
3. Google Brain大牛Jeff dean视频
4. java.lang.VerifyError
5. python中list是什么类型_Python 入门系列 —— 13. List 类型简介
6. java操作当前日期的年月日
7. 如何使用Python操作MySQL数据库
8. 关于Unity中关节的使用(一)
9. Vue：结合ElementUI元素超过一定高度加滚动框,高度由浏览器高度决定并随浏览器变化而变化
10. 续【将数据从MongoDB迁移到mysql】
11. [963]Android app代理软件
12. python小课风变编程_风变编程Python小课最近很火，大家学完感受如何？
13. 全程不用usb数据线，adb通过网络连接Android设备
14. c语言实例--打渔晒网问题
15. syslinux 启动后显示SYSLINUX 5.01H. Peter Anvin et al
16. 回味陈年老酒----DOS
17. HTML+css+js实现网页时钟、全网做得最好的时钟！
18. 使用python生成信息学奥赛题目测试数据
19. ClickHouse 在爱奇艺实时数仓的应用
20. 《Web安全之机器学习入门》笔记第一章

热门文章

1. 计算机禁止用户登录,win7系统禁止显示用户登录信息的设置方法
2. 支持向量机（一）——深入理解函数间隔与几何间隔
3. python关系图谱_python 绘制三国人物关系图
4. QMS-云质-质量管理-质量控制中的常见误区(1): Cr=0
5. 淘宝买家谈阿里质量意识
6. docker-compose、kubernetes安装部署fastdfs文件集群系统
7. 微信小程序properties属性有observe。依赖它的数据可以考虑在这里处理，不用单独写在observe里面
8. 山东大学计算机博士申请,山东大学博士研究生招生“申请
9. 生产者与消费者问题C语言实现
10. 7-1 求斐波那契数的尾数