类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。对象是由类创建出来的真实存在的事物。
#创建类 class 类名(): #类名要满足标识符命名规则，同时遵循大驼峰命名习惯 代码 ...... def 函数名(self): #self指调用该函数的对象 代码 #创建对象 对象名 = 类名()类外面添加对象属性：
对象名.属性名 = 值类外面获取对象属性：
对象名.属性名类里面获取对象属性：
self.属性名综合实例：
class Washer(): def wash(self): print('wash the clothes!') def get_size(self): print(f'此洗衣机的尺寸是{self.width} X {self.height}') haier1 = Washer() haier1.width = 500 haier1.height = 300 haier2 = Washer() haier2.width = 600 haier2.height = 400 print(haier1.width) haier1.get_size() haier2.get_size()魔法方法： __init__() 、 __str__()、__del__()。
#1. __init__() 初始化对象。 #创建对象时默认被调用；不需开发者传递self参数，python解释器会自动把当前对象引用传递过去。 class washer(): def __init__(self,width,height): self.width = width self.height = height def print_info(self): print(f'{self.width} X {self.height}') h = washer(500,800) h.print_info() #输出结果 500 X 800 #2. __str__() 使得用print输出对象时，输出该方法中return的数据,而不再输出对象的内存地址。 def __str__(self): return "这是洗衣机对象！" print(h) #输出结果 这是洗衣机对象！ #3. __del__() 当删除对象时，python解释器会默认调用__del__()方法 def __del__(self): print(f'{self}对象已经被删除！') del h #输出结果 <__main__.washer object at 0x000002531DF744F0>对象已经被删除！两个案例：
烤地瓜
#需求：1.被烤时间和地瓜状态相对应 2.用户可按意愿添加调料 class SweetPotato(): def __init__(self): self.cook_time=0 self.cook_state='生的' self.condiments=[] def cook(self, time): if time >=0: self.cook_time += time if 0<= self.cook_time < 3: self.cook_state = '生的' elif 3 <= self.cook_time < 5: self.cook_state = '半生不熟' elif 5 <= self.cook_time < 8: self.cook_state = '熟了' elif self.cook_time >= 8: self.cook_state = '糊了!' else: print('时间刺客？！') def add_condiment(self, con): self.condiments.append(con) def __str__(self): return f'这个地瓜烤了{self.cook_time}分钟，状态是{self.cook_state}，添加的调料有{self.condiments}' p = SweetPotato() p.add_condiment('番茄酱') print(p) p.cook(8) p.add_condiment('芥末') print(p) # 这个地瓜烤了0分钟，状态是生的，添加的调料有['番茄酱'] # 这个地瓜烤了8分钟，状态是糊了!，添加的调料有['番茄酱', '芥末']搬家具
#需求 将小于房子剩余面积的家具摆放到房子中 class Furniture(): def __init__(self,name,area): self.name = name self.area = area class House(): def __init__(self,adress,area): self.adress = adress self.area = area self.free_area = area self.furniture = [] def add_furniture(self,item): if self.free_area >= item.area: self.furniture.append(item.name) self.free_area -= item.area else: print('家具太大，剩余面积不足，无法容纳') def __str__(self): return f'这个房子的地址是{self.adress}，总面积是{self.area}，当前剩余面积是{self.free_area}，家具有{self.furniture}' bed = Furniture('双人床',6) sofa = Furniture('沙发',10) court = Furniture('高尔夫球场',1000) house = House('陆家嘴',200) print(house) house.add_furniture(bed) house.add_furniture(sofa) house.add_furniture(court) print(house) #这个房子的地址是陆家嘴，总面积是200，当前剩余面积是200，家具有[] #家具太大，剩余面积不足，无法容纳 #这个房子的地址是陆家嘴，总面积是200，当前剩余面积是184，家具有['双人床', '沙发']继承： Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下：
#定义父类A class A(object): def __init__(self): self.num = 1 def infor_print(self): print(self.num) #定义子类B，继承父类A class B(A): pass #创建对象，验证对象继承 result = B() result.info_print()在python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫派生类。
拓展：python2中的经典类 和 python3中的新式类
#经典类(不由任意内置类型派生出的类) class 类名: 代码 ...... #新式类 class 类名(object): 代码 ...... #在今后的学习和运用中，统一使用新式类单继承：一个子类继承一个父类，这种单一的继承关系称为单继承。
多继承：一个子类同时继承多个父类。
class 子类(父类A,父类B,父类C) #当两个父类中的属性和方法有同名时，优先继承第一个父类中的同名属性和方法，即继承A类。子类重写父类同名属性与方法：在子类中可以重写与父类中同名的属性和方法。子类创建的对象调用属性和方法时，会调用子类中重写的属性和方法。
拓展： **__mro__**顺序 方法查看类的继承层级顺序。
print(类名.__mro__)子类调用父类同名属性和方法：在子类中重写了父类中同名属性与方法的情况下，调用父类中的同名属性和方法。
class 子类B(父类A): def 同名方法(self): #如果之前调用了父类的属性和方法，则父类属性会覆盖子类属性，故在调用子类属性前，先调用子类自己的初始化 self.__init__(self) 代码 def 调用父类方法(self): #调用父类方法，为保证调用到的属性也是父类的属性，必须在调用方法前调用父类的初始化 父类A.__init__(self) 父类A.同名方法(self)多层继承：一般指大于两层的继承关系。
class A(object): ... class B(A): ... class C(B): #多层继承 ...super()调用父类方法：自动查找父类，直接调用父类的属性方法，调用顺序遵循__mro__类属性的顺序。
class A(object) class B(A) class C(B): #方法一：原始方法 def useAB(self): A.__init__(self) A.同名方法(self) B.__init__(self) b.同名方法(self) #方法二：super()方法 #方法2.1 super(当前类名,self).函数() def useAB(self): super(C,self).__init__() super(C,self).同名方法() #此时会调用父类B的方法;若想调用A类的方法，需要在B类的同名方法中添加同样的super方法代码来调用A类 #方法2.2 super().函数() def useAB(self): super().__init__(self) super().同名方法() #同样调用父类B的方法;无法直接调用父类的父类A的属性和方法私有权限
设置私有属性和方法：在属性名和方法名前面加上两个下划线。
私有属性和私有方法只能在类内访问和修改，即子类无法继承或直接访问父类的私有属性和方法。
class A(object): def __init__(self): self.name = 'A' self.__money = 99999 #私有属性 def __CostMoney(self,money): #私有方法 self.__money -= money获取和修改私有属性值：可在类内定义公有函数来获取和修改 私有属性值，在类外调用该函数来实现获取和修改私有属性功能。
#一般在类内用函数名get_xx来获取私有属性，用set_xx来修改私有属性 class A(object): def __init__(self): self.__money = 99999 def get_money(self): return self.__money def set_money(self,new_money): self.__money = new_money class B(A): pass b = B() b.get_money() #成功获取父类中的私有属性 b.set_money(0) #成功修改父类中的私有属性多态：一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。即传入不同的对象，产生不同的结果。
类属性和实例属性：类属性即类所拥有的属性，它为该类所有对象共有。类属性可以用 类对象 或 实例对象 访问。
类属性只能通过类对象修改。
#修改类属性 类名.属性 = 值类方法：需要用装饰器 @classmethod 来标识其为类方法，类方法第一个参数必须是类对象，一般以 cls 作为第一个参数。
class A(object): __num = 777 @classmethod def get_num(cls): return cls.__num obj = A() print(obj.get_num())静态方法：通过装饰器 @staticmethod 进行修饰，静态方法即不需要传递类和对象的方法，有利于减少不必要的内存占用和性能消耗。
class A(object): @staticmethod def info_print(): print('这是A类')异常的定义：解释器检测到错误时无法继续执行，并出现一些错误的提示，这就是所谓的异常。
异常的作用：使得解释器检测到错误时，转而执行另一句没错误的语句，使得程序不因一个错误而停止下来。
基本写法：
try: 可能发生错误的代码 except: 出现异常时执行的代码 else: 没有异常时执行的代码 finally: 无论是否异常都要执行的代码体验案例：
#需求：尝试以r模式打开文件，若文件不存在(发生错误)，则以w方式打开 try: f = open('test.txt','r') except: f = open('test.txt','w')捕获指定异常：
try: print(num) except (NameError, ZeroDivisionError) as result: print(result) #捕获的异常描述信息 num = 777 print(num) #若尝试执行代码的异常类型和要捕获的异常类型不一致，则无法捕获异常 #一般try下方只放一行尝试执行的代码捕获所有异常：利用 Exception 类
#Exception是所有程序异常类的父类 try: 可能错误的代码 except Exception as result: print(result)异常中的 else 和 finally:
try: f = open('test.txt','r') except Exception as result: f = open('test.txt','w') print(result) else: # try 下方的代码无异常时执行的代码 print('代码没有异常和错误') finally: #无论有无异常都要执行的代码，如关闭文件 f.close()异常的传递：
import time try: f = open('test.txt') #默认打开模式为只读 #尝试循环读取内容 try: while True: con = f.readline() #无内容时退出循环 if len(con) == 0: break time.sleep(2) print(con) except: #在命令提示符中按下 Ctrl+C 终止程序 print('程序被意外终止') except: print('文件不存在')自定义异常： 抛出自定义异常的语法为raise 异常类对象
#自定义异常类，继承Exception class ShortInputError(Exception): def __init__(self,length,min_length): self.length=length self.min_length=min_length #设置抛出异常的描述信息 def __str__(self): return f'输入长度为{self.length},不能少于{self.min_length}个字符' def main(): #封装代码 try: con = input('请输入密码: ') if len(con) < 6: raise ShortInputError(len(con),6) except Exception as result: print(result) else: print('密码输入完成') main()了解模块：Python模块(Module)，是一个Python文件，包含了Python对象定义和语句。
导入和调用模块：
#导入及调用模块 #写法一 import 模块名 #导入模块中的所有代码 模块名.功能名() #写法二 from 模块名 import 功能1,功能2... #单个调用某功能 功能名() #即不需要在功能前写 "模块名." #写法三 from 模块名 import * 功能名() #一般用第一种写法利用as定义别名：定义别名后，使用时要用定义的别名
#模块定义别名 import 模块名 as 别名 #功能定义别名 from 模块名 import 功能 as 别名制作模块：模块名字就是py文件的名字。自定义模块名必须要符合标识符命名规则。
#只会在当前文件中调用下列测试代码，其他导入的文件内不符合该条件，也就不会执行测试代码 # __name__ 是系统变量，是模块的标识符。如果在自身模块里，则其值为 '__main__';否则是所在模块的名字 if __name__ == '__main__': 测试模块功能代码模块定位顺序：当导入一个模块，Python解释器对模块位置的搜索顺序是：
当前目录 > 搜索在shell变量PYTHONPATH下的每个目录 > 操作系统的默认python路径
注意：
自己的文件名不要和已有模块名重复，否则模块功能无法使用。
使用from 模块名 import 功能时，若功能名字重复，则调用最后定义的或最后导入的功能。
当使用 import 模块名 的写法调用模块时，不需要担心功能名重复。
__all__列表：如果一个模块文件中有__all__ 变量列表，当使用from 模块名 import *导入该模块时，则只能导入__all__列表中的元素。
包：包将有联系的模块组织在一起，放到同一个文件夹下，并且在这个文件夹内自动生成一个名字为__init__.py的文件，这个文件控制着包的导入行为。
创建包：在Pycharm中 New -> Python Package -> 输入包名 - > [OK] 即可新建一个包。
导入包：
#方法一 import 包名.模块名 包名.模块名.功能 #方法二 #注意，必须在 __init__.py 文件中添加 __all__ = [] 来控制允许导入的模块列表 from 包名 import * 模块名.功能