1) 封装
2) 继承
3) 多态
面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么。基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式。
优点：复杂的过程流程化。
缺点：扩展性差。
面向对象：核心是对象二字，对象指特征与技能的结合体。基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种“上帝式”的思维方式。
优点：可扩展性强。
缺点：变成复杂度高，极容易出现过度设计的问题。
对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体。
在现实生活中：一定是先有一个个具体的对象，后总结出类；
在程序中：一定是先定义类，后产生对象。
定义类用命令class，定义类名字最好用驼峰式命名法。
类的定义和类的实例化： #定义类 class StudentsInfo: #定义类 class_a = ‘1902‘ #类的属性 def __init__(self,name,age): #定义初始化函数，用以区分对象 #self：谁调用谁就是self self.name = name #对象属性 self.age = age #对象属性 def run(self): #用函数定义特征，self自加 print(‘%s is running‘ % self.name) #实例化，产生对象 stu1 = StudentsInfo(‘zxj‘,23) print(stu1.class_a) #调用属性 stu1.run() #1调用self为1 print(‘-------------华丽的分割线----------------‘) stu2 = StudentsInfo(‘wrl‘,24) print(stu2.class_a) #调用属性 stu2.run() #2调用self为2 result： 1902 zxj is running -------------华丽的分割线---------------- 1902 wrl is running
封装是面相对性一大特点，面向对象编程的第一步就是将属性和方法封装到一个抽象的类当中；外界使用类创建对象，然后让对象调用方法；对象方法的细节都被封装在类的内部。
封装案例1：
需求：
1> 小明体重75公斤；
2> 小明每次跑步都会减肥0.5公斤；
3> 小明每次吃东西体重会增加1公斤。
#定义类 class Person: def __init__(self,name,weight): self.name = name self.weight = weight def run(self): self.weight -= 0.5 def eat(self): self.weight += 1 def __str__(self): #定义str函数，打印return的返回值 return ‘%s的体重为%s‘ % (self.name,self.weight) #产生对象 zxj = Person(‘小周‘,75) print(zxj) result： 小周的体重为75 调用对象时自动执行str函数将其打印，这就是__str__函数的意义。 zxj = Person(‘小周‘,75) zxj.run() #调用技能 zxj.run() zxj.run() print(zxj) result： 小周的体重为73.5 zxj = Person(‘小周‘,75) zxj.run() zxj.run() zxj.run() zxj.eat() print(zxj) result： 小周的体重为74.5
封装案例2：
需求：
1> 房子有户型、总面积、家具名称列表；
房子没有任何家具；
2> 家具有名字和占地面积，其中；
席梦思(bed):4平米；
衣柜(chest): 2平米；
餐桌(table): 1.5平米；
3> 将以上3个家具添加到房子中；
4> 打印房子中，要求输出:户型、总面积、剩余面积、家具名称列表。
class Item: #定义家具 def __init__(self,name,area): self.name = name self.area =area class House: #定义房子 def __init__(self,name,total_area): self.name = name self.total_area = total_area self.free_area = total_area self.items = [] def add_item(self,item): self.free_area = self.total_area - item.area self.items.append(item.name) def __str__(self): return ‘户型：%s|总面积：%s|剩余面积“%s|家具列表：%s‘ % (self.name,self.total_area,self.free_area,self.items) house = House(‘别墅‘,200) print(house) result: 户型：别墅|总面积：200|剩余面积“200|家具列表：[] 添加家具： house = House(‘别墅‘, 200) bed = Item(‘席梦思‘, 4) chest = Item(‘衣柜‘, 2) table = Item(‘餐桌‘, 1.5) house.add_item(bed) house.add_item(chest) house.add_item(table) print(house) result： 户型：别墅|总面积：200|剩余面积“192.5|家具列表：[‘席梦思‘, ‘衣柜‘, ‘餐桌‘] 封装案例三： class Gun: #创建枪类 def __init__(self,gun_type): self.gun_type = gun_type #初始化枪的型号 self.bullet = 0 #初始化子弹的数量 def add_count(self, count): #添加子弹 self.bullet += count def shoot(self): #射击 if self.bullet > 0: #假如子弹数量大于0 self.bullet -= 1 # 那就射击，并且减少子弹数量 print(‘开火.......%s‘ % self.bullet) else: print(‘没有子弹啊，兄弟，别这么坑我啊？？？‘)#否则没有就显示没有子弹 class Soldier: #创建一个士兵的类 def __init__(self, name,gun=None): self.name = name #初始化士兵的姓名 self.gun = gun #初始化枪 def fire(self): #开火方法 if self.gun: #假如有枪 self.gun.shoot() #那就射击 else: #不然就显示没有枪 print(‘没有枪啊，兄弟，你让我去送死吗？？‘) ak47 = Gun(‘AK47‘) #创建一个枪的对象叫ak47 ak47.add_count(10) #添加10颗子弹 xsd = Soldier(‘许三多‘) #实例化一个许三多的士兵对象 xsd.gun = ak47 #把枪交到许三多手中 xsd.fire() #开火 result: 开火.......9
继承实现代码的重用，相同的代码不需要重复的编写，继承包括单继承和多继承。
不继承地定义类代码有很多重复，使用继承可以降低代码的重复，减少代码量，然后再加上自己的技能属性。
继承只需要在定义类的括号里写上父类的名字。继承的鼻祖为object（新式类），定义类括号不加object则为旧式类；一般的定义习惯是：如果没有父类则将object写上。
多继承即在定义类时的括号里写入多个父类，对于多个父类，谁写前面谁优先级大。
class Anamal(object): def eat(self): print(‘吃‘) def drink(self): print(‘喝‘) def run(self): print(‘跑‘) def sleep(self): print(‘睡‘) class Dog(Anamal): def bark(self): print(‘汪汪叫‘) class XiaoTianQuan(Dog): def fly(self): print(‘我会飞啦！！！！‘) dog = XiaoTianQuan() dog.eat() dog.run() dog.sleep() dog.drink() dog.bark() dog.fly() result： 吃 跑 睡 喝 汪汪叫 我会飞啦！！！！
方法的重写：
重新写一个方法覆盖掉原来的方法即可。
#重写哮天犬叫唤的方法 class Anamal(object): def eat(self): print(‘吃‘) def drink(self): print(‘喝‘) def run(self): print(‘跑‘) def sleep(self): print(‘睡‘) class Dog(Anamal): def bark(self): print(‘汪汪叫‘) class XiaoTianQuan(Dog): def fly(self): print(‘我会飞啦！！！！‘) def bark(self): print(‘牛逼的叫.......‘) dog = XiaoTianQuan() dog.eat() dog.run() dog.sleep() dog.drink() dog.bark() dog.fly()
对父类的方法进行扩展
1> 在子类中重写父类的方法
2> 在需要的位置使用super().父类方法来调用父类方法的执行
3> 代码其他的位置针对子类的需求，编写子类特有的代码实现
关于super
在python中super是一个特殊的类
super()就是使用super类创建出来的对象
最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现。
#用super继承父类的方法并扩展新内容 class Anamal(object): def eat(self): print(‘吃‘) def drink(self): print(‘喝‘) def run(self): print(‘跑‘) def sleep(self): print(‘睡‘) class Dog(Anamal): def bark(self): print(‘汪汪叫‘) class XiaoTianQuan(Dog): def fly(self): print(‘我会飞啦！！！！‘) def bark(self): print(‘牛逼的叫.......‘) super().bark() print(‘%*#*@^$*(@‘) dog = XiaoTianQuan() dog.eat() dog.run() dog.sleep() dog.drink() dog.bark() dog.fly() result： 吃 跑 睡 喝 牛逼的叫....... 汪汪叫 %*#*@^$*(@ 我会飞啦！！！！
面向对象的三大特性：
1> 封装根据职责将属性和方法封装到一个抽象的类中
定义类的准则
2> 继承实现代码的重用，相同的代码不需要重复的编写
设计类的技巧
子类针对自己特有的需求，编写特定的代码
3> 多态不同的子类对象调用相同的父类方法，产生不同的执行结果
多态可以增加代码的灵活度
以继承和重写父类方法为前提
是调用方法的技巧，不会影响到类的内部设计
#多态的特性：让不同的子类对象调用相同的代码产生不同的结果 class Dog(object): def __init__(self, name): self.name = name def game(self): print(‘%s 开开心心去玩耍.....‘ % self.name) class XiaoTianQuan(Dog): def game(self): print(‘%s 开开心心去玩耍.....‘ % self.name) class Person(object): def __init__(self, name): self.name = name def game_with_dog(self, dog): print(‘%s 和 %s 正在开开心心的玩耍......‘ % (self.name, dog.name)) dog.game() #创建人对象 xiaoming = Person(‘小明‘) #创建狗对象 dog = Dog(‘旺财‘) #让小明跟狗玩耍 xiaoming.game_with_dog(dog) resut: 小明 和 旺财 正在开开心心的玩耍...... 旺财 开开心心去玩耍.....
什么是异常？
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
异常处理：
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：
try: 正常的操作 ...................... except: 发生异常，执行这块代码 ...................... else: 如果没有异常执行这块代码
try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") except IOError: print("Error: 没有找到文件或读取文件失败") else: print("内容写入文件成功") fh.close() result: 内容写入文件成功
try-finally 语句：
try: <语句> finally: <语句> #退出try时总会执行 raise
try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") finally: print("Error: 没有找到文件或读取文件失败")
result: Error: 没有找到文件或读取文件失败
用户自定义异常：
通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。
在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。
class MyError(Exception): def __init__(self,age): self.age=age # def __str__(self): # return self.age def ag(): age=int(input(‘输入年龄：‘)) if age<=0 or age>100: raise MyError(‘年龄只能在0到100岁之间‘) try: ag() except MyError as e: print(e) result: 输入年龄：150 年龄只能在0到100岁之间 自定义异常
原文：https://www.cnblogs.com/ajunyu/p/11024071.html