基本概念

POP vs OOP

面向过程程序设计（Procedure Oriented Programming）POP： 把计算机程序视为一系列命令集合。一组函数按照事先设定的顺序依次执行。函数是程序的基本单元。 C、python等

面向对象程序设计（Object Oriented Programming）OOP： 新的程序设计思想和方法 把计算机程序视为一组对象（Object）的集合，每个对象可以接受其他对象发送的消息，并处理这些消息。 对象是程序的基本单元，一个对象包含数据和操作数据的方法。 C++、C#、Java、Python等 更加灵活，支持代码和设计复用，更好的可读性和扩展性，主流

procedure：过程 oriented：以···为方向 programming：编程

OOP

OOP基本思想：将数据以及对数据的操作封装在一起，组成一个相互依存、不可分割的整体，即对象。 对想同类型的对象进行分类、抽象后，得出共同特征而形成类。 OOP关键：如何合理地定义和组织这些类及类之间的关系 OOP基本概念：对象、类、消息、封装、继承、多态等 封装、继承、多态是OOP的最重要的三个特征

（1）对象（Object），要研究的任何事物 事：无形、抽象（规划、计划、事件） 物：沙、叶、书、屋 对象由数据（描述事物的特征）和数据操作（体现事物的行为）构成一个独立整体

（2）类（Class） 对一组具有相同特征和想通操作对象的定义 一个类所包含的数据和方法描述一组对象的共同特征和行为 不同类之间可以有继承、关联、依赖等关系，构成类的组织和层次结构 类A，内容包括a,b,c，抽取a,c组成类B，B继承自A，B叫A的派生类或子类 类是对象之上的抽象，是对象的模版；对象则是类的具体化，是类的实例 类A：学生，对象a：学生a

（3）消息（Message） 消息是一个对象要求另一个对象实施某项操作的请求 一个系统由若干个对象组成，各个对象之间通过消息相互联系、相互作用

（4）封装（Encapsulation） 封装把对象的数据和加工该数据的方法封装为一个整体，以实现独立性很强的模块 封装的目的在于把对象的设计者和使用者分开 使用者不能知晓对象实现的细节，只能使用设计者提供的外部接口来访问该对象，保证了程序中数据的合法性和安全性

（5）继承（Inheritance） 派生类或子类即可以继承父类的特征和行为，又可以增加派生类独有的特征和行为，还可以对父类的特征和行为进行改造，使之具有自己的特点

（6）多态（Polymorphism） 多态指同名的操作作用于多种类型的对象上并获得不同的结果 叫：猫：“喵”；狗：“汪”；鼠：“吱” 多态允许每个对象以适合自身的方式去响应共同的消息，增强了软件的灵活性和重要性

综上，OOP是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界，设计、构建相应软件系统的过程

Python中的OOP

与其他编程语言相比，Python不仅支持POP,更是一种面向对象、高级的动态编程语言，完全支持OOP的各项功能，如封装、继承、多态及对类方法的覆盖或重写等。

Python中对象的概念很广泛，一切内容都可以看成对象，如数字、字符串、列表、元组、字典、集合等都是对象，函数、类也是对象

类与对象

类的定义

类是一种类型，对象是该类型的一个变量。 类是抽象的，一般不占用内存空间 对象是具体的，创建一个对象时要为其特征分配相应的内存空间

在Python中，使用class关键字定义一个新类。定义类的一般格式为：

class 类名: """类说明""" 类体

（1）组成：类的定义主要由类头和类体两部分组成 （2）类头：由关键字class开头，后面是类的名称，冒号。（书中建议以首字母大写的符合标示符规则的命名） （3）类体：类体重包含类的实现细节 ①数据成员：用来存储特征的值，简称成员 ②成员方法：用来对成员进行操作，简称方法 （4）类说明：可以选择性添加文档字符串，对类的功能等进行说明

#定义类 class Student: name="Tim" #定义一个成员 def getName(self): #定义一个方法 return self.name

当定义一个类后，可以使用如下两种方式访问类中的成员和方法 （1）引用：通过类对象调用类中的成员和方法，格式为“类名.成员”,“类名.方法()” （2）实例化：先创建一个类的实例，即对象；再通过对象调用其中的成员和方法

对象创建和使用

要使用类中定义的成员和方法，必须对类实例化，即创建类的对象。 在Python中，使用赋值的方式创建类的对象： 对象名=类名([参数列表]) 对象创建后，可以使用“对象.成员”,“对象.方法()”调用该类的成员和方法

#定义类 class Car: #定义构造方法 def __init__(self,name): self.name=name #定义方法 def getName(self): return self.name #创建对象 c1=Car("马自达") print("这辆汽车的品牌：",c1.getName()) ### 这辆汽车的品牌：马自达

话说我很懵，我不知道__init__、self都是什么意思！ Python类中的__init__() 和 self 的解析 看完这篇文章后，我总结下：

def __init__(self,name,gender,age): self.name=name self.gender=gender self.gender=age

_init_ 在很多地方看到过，这里是第一次必须用到 init：初始化（initialization） 这里算是调用该类生成对象时，是依据这个方法给对象赋值的 self也是值赋值在该类中，总之这两个东西都是约定俗成的东西，然后写几遍变成一种习惯就是了

def __init__(self,brand) self.brand=brand

之后的就好解释了，然后利用文档告诉使用者该怎么做！ 但是我使用help的话，他出现了过多的信息，并非那么隐秘

Help on class Car in module __main__: class Car(builtins.object) | Car(name, gender=None, age=None) | | 这是文档 | | Methods defined here: | | __init__(self, name, gender=None, age=None) | Initialize self. See help(type(self)) for accurate signature. | | getName(self) | #定义方法 | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) #定义类 class Car: def __init__(self,name,gender=None,age=None): import datetime self.name=name self.gender=gender self.age=datetime.datetime.now().year-int(age) def getName(self): return self.name def getF(self): return self.gender def getA(self): return self.age #创建对象 c1=Car("奔驰","Karl Friedrich Benz","1926") print("这辆汽车的品牌：%s\n品牌创始人：%s\n品牌时长：%s"%(c1.getName(),c1.getF(),c1.getA()))

这里，self代表类的对象，而并非本身

类的成员

成员类型

按照能否在类的外面直接访问，类的成员可分为如下两种 （1）公有成员：公有成员不以下划线开头，在类的内部可以访问，在类的外面也可以访问 （2）私有成员：以单下划线或双下划线开头，在类的外面不能直接访问，只能在类的内部访问或在类的外面通过对象的公有方法访问

在形式上，以单下划线或双下划线开头的是私有成员 （1）_xxx：一个以下划线开头的成员。类和派生类可以访问这些成员，在类的外面一般不建议直接访问 （2）__xxx：以两个或更多下划线开头但不能以两个或更多下划线结束的成员。对该成员，只有类自己可以访问，派生类也不能访问

class 类: def __init__(self,a,b,c): self.公有成员=a self._派生类可以访问=b self.__只能类自己访问=c lei=类(1,2,3) print(lei.公有成员) print(lei._派生类可以访问) print(lei.__只能类自己访问) ### 1 2 AttributeError: '类' object has no attribute '__只能类自己访问'

按照归属于类还是对象，类的成员可分为如下两类 （1）类成员：定义在类体中且在所有方法外的成员为类成员。类成员属于类本身，一般通过类名调用，不建议使用对象名调用 （2）实例成员：在类的方法中定义的成员为实例成员。实例成员只能被对象调用。实例成员一般在构造方法__init__()中创建，也可以在其他方法中创建

class TestClass(object): val1 = 100 def __init__(self): self.val2 = 200 def fcn(self,val = 400): val3 = 300 self.val4 = val self.val5 = 500 if __name__ == '__main__': inst = TestClass() print(TestClass.val1) print(inst.val1) print(inst.val2) print(inst.val3) print(inst.val4)

书中最后一句话，我无法验证，尝试去写无法写出，无法被调用！ 自己写的有点乱，就用网上现有的一段 Python中的类变量和成员变量 于是书中的最后一句我们仍无法验证！

对类的成员访问可以总结如下 （1）公有的类成员：在类的方法中通过“类名.类成员”或“self.类成员”访问，在类的外面通过“类名.类成员”或“对象名.类成员”访问 （2）公有的实例成员：在类的方法中通过“self.实例成员”访问，在类的外面通过“对象名.实例成员”访问 （3）私有的类成员：在类的方法中通过“类名.类成员”或“self.类成员”访问，在类的外面不能直接访问 （4）私有的实力成员：在类的方法中通过“self.实例成员”访问，在类的外面不能直接访问

class 类: 公有的类成员="公有的类成员" _私有的类成员="_私有的类成员" __私有的类成员="__私有的类成员" def __init__(self): self.公有的实例成员="self.公有的实例成员" self._私有的实例成员="self._私有的实例成员" self.__私有的实例成员="self.__私有的实例成员" def 私有(self): print(类.__私有的类成员) print(self.__私有的类成员) print(self.__私有的实例成员) lei=类() print(类.公有的类成员) print(lei.公有的类成员) print(类._私有的类成员) print(lei._私有的类成员) # print(类.__私有的类成员) # print(lei.__私有的类成员) print(lei.公有的实例成员) print(lei._私有的实例成员) # print(lei.__私有的实例成员) lei.私有()

一个下划线的到底意味着什么，书中只写了一般不建议，并不是指的不能用，那到底是？ 站里其他的文章，私有只提到两个下划线的，并没有提及一个下划线的

在使用类名或对象名调用类的成员时，还需要注意以下几点 （1）当用对象名调用类成员时，“对象.类成员”只是“类.类成员”的一份拷贝。当修改“对象.类成员”时，“类.类成员”的值不变 （2）当类成员和实例成员同名时，在类的方法中和外面，“类名.类成员”调用的是同名的类成员，“slef.实例成员”（在类的方法中）或“对象名.实例成员”（在类的外面）调用的是同名的实例成员 （3）定义在类的方法中且不以self为前缀的变量时该方法的局部变量，不能在方法外使用，也不能在类的外面调用

class 类: 类成员="类成员" lei=类() print(lei.类成员) lei.类成员="被修改的类成员?" print(lei.类成员) print(类.类成员) class 类: 成员="类成员" def __init__(self): self.成员="实例成员" def p(self): self.成员a="方法内定义的成员a" print("类.成员：",类.成员) print("self.成员：",self.成员) print(成员) lei=类() print(类.成员) print(lei.成员) lei.p() print(lei.成员a)

还记得上面的疑惑吗？其他方法定义的变量，在这里出现了，在p中定义了一个变量，在p被执行后，这个变量是可以被读取的

动态添加和删除类成员

class 类: a="a" def __init__(self): self.b="b" lei=类() print(lei.a) print(lei.b) del lei.b print(lei.b) lei.c="c" # a.b="a.b" print(lei.a) print(lei.c) # print(a.b) lei.a="aa" print(lei.a) del lei.a print(lei.a) del lei.c print(lei.c)

上面可以直接被del就是完全的对象的实例成员，删除后啥都没有。当类成员被覆盖时，才能删除，删除后又变成了类成员，所以若是想真的删除，只能用None等特殊值代替，调用时判断。点前后确实是独立的，我尝试用a.b，他会对a单独考证

内置成员

所有的类（无论是系统内置的类还是自定义类）都有一组特殊的成员，其前后各有两个下划线，，是类的内置成员。 （1）__name__：类的名字，用字符串表示 （2）__doc__：类的文档字符串 （3）__bases__：由所有父类组成的元组 （4）__dict__：由类的成员组成的字典 （5）__module__：类所属模块

class 类: 成员="类成员" def __init__(self): self.成员="实例成员" def p(self): self.成员a="方法内定义的成员a" print("类.成员：",类.成员) print("self.成员：",self.成员) print(成员) print(类.__name__) print(类.__doc__) print(类.__bases__) print(类.__dict__) print(类.__module__) print(Exception.__name__) print(Exception.__doc__) print(Exception.__bases__) print(Exception.__dict__) print(Exception.__module__) # 类成员 类 None (<class 'object'>,) {'__module__': '__main__', '成员': '类成员', '__init__': <function 类.__init__ at 0x0000019F0DD331F0>, 'p': <function 类.p at 0x0000019F0DD33EE0>, '__dict__': <attribute '__dict__' of '类' objects>, '__weakref__': <attribute '__weakref__' of '类' objects>, '__doc__': None} __main__ Exception Common base class for all non-exit exceptions. (<class 'BaseException'>,) {'__init__': <slot wrapper '__init__' of 'Exception' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF995E44C10>, '__doc__': 'Common base class for all non-exit exceptions.'} builtins

类的方法

（1）公有方法，公有方法的名字不以下划线开头，可以再类的外面通过类名或对象名调用 （2）私有方法，私有方法以两个或更多下划线开头，可以在类的方法中通过self调用，不能在类的外面调用 （3）静态方法和类方法，静态方法和类方法成员可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员，不属于任何对象。相比类方法，静态方法的开销更小，类方法一般以cls作为第一个参数表示类自身，在调用类方法时不需要为该参数传递值，静态方法使用装饰器@staticmethod声明，类方法使用装饰起@classmethod声明 （4）抽象方法，抽象方法一般定义在抽象类中并要求派生类对抽象方法进行实现（之后章节）

#定义类 class A(object): def function_p(self): print("在公有方法中调用：",self.__function()) return "公有方法 'function_p'" def __function(self): return "私有方法 '__function'" @classmethod def function_c(cls): return "类方法 'function_c'" @staticmethod def function_s(): return "静态方法 'function_s'" #创建对象 a1=A() print(a1.function_p()) print(a1.function_c()) print(a1.function_s()) print(A.function_p(a1)) print(A.function_c()) print(A.function_s()) # 在公有方法中调用： 私有方法 '__function' 公有方法 'function_p' 类方法 'function_c' 静态方法 'function_s' 在公有方法中调用： 私有方法 '__function' 公有方法 'function_p' 类方法 'function_c' 静态方法 'function_s'

属性

类的公有成员可以在类的外面进行访问和修改，很难保证用户为公有成员提供数据的合法性，也不符合类的封装性要求。解决这一问题的常用方法是定义类的私有成员，然后设计类的公有方法对私有成员进行访问。 属性是一种特殊形式的方法，结合了成员和方法的各自优点，既可以通过属性访问类中的成员，也可以在访问前对用户为成员提供数据的合法性进行检测，还可以设置成员的访问机制。 属性通常包括get()方法和set()方法，前者用户获取成员的值，后者用于设置成员的值。此外，属性也可以包含其他方法，例如删除方法del()等

class 面积: def 圆的面积(self,直径): self.直径=直径 if self.直径>0: return 3.14*直径**2 else:return "输入数值不符合要求" def 获取直径(self): return self.直径 def 删除信息(self): del self.直径 c=面积() print(c.圆的面积(2)) print(c.圆的面积(-2)) # c.删除信息() print(c.获取直径())

虽然里面的赋值什么的是多此一举，但是为了演示属性，但是这个属性貌似就是一个概念，并没有实际得定义

Python内置的装饰器@property既可以对类的私有成员进行检查，又方便调用

使用@property设置类的属性访问方式

#定义类 class Woman(): def __init__(self,birth): self.__birth=birth @property #设置属性为可读 def salary(self): return self.__salary @salary.setter #设置属性为可写 def salary(self,salary): self.__salary=salary @property #设置属性为只读 def birth(self): return self.__birth def p(self): print(self.birth) #创建对象 w1=Woman("1992.06.06") w1.salary=10800.00 print("您的出生日期：%s ，薪水：%.2f 元"%(w1.birth,w1.salary)) w1.p() w2=Woman("1962.09.09") w2.__birth="1999.09.09" # w2.salary(1000) # print(w2.birth,w2.salary)

这里比较微妙但也好理解，但是需要转个弯！

def __init__(self,birth): self.__birth=birth w1=Woman("1992.06.06")

这个不用多解释，将字符串赋值给self.__birth 但是这是个私有对象，外界无法访问的

@property #设置属性为只读 def birth(self): return self.__birth

其实这里设置，应该说是可读，如果只设置@property，自然就是只读了 有了这个设置后，self.birth的结果就是self.__birth，外界感觉操作是一样的，对象内部也可以将self.birth当做参数调用

@salary.setter #设置属性为可写 def salary(self,salary): self.__salary=salary

这里我在外面尝试w1.salary(1000)是无效的，不等同于w1.salary=1000，虽然我并不知道这个装饰器的原理，但是效果已经是完全把self.salary和self.__salary等同一个变量了

另外没这个设置的话，

w2.__birth=“1999.09.09” 这个是无效的，其实__本已经隔绝了外部和内部之间的访问，虽然这个写法没有报错，但是却是无效果的 w2.birth=“1999.09.09” 这个是语法错误的，没有@birth.setter，这种写法就不合法

@birth.setter def birth(self,birth): self.__birth=birth

Python中的内置函数property()可以将类中的成员转为属性，并对属性进行更多的设置

#定义类 class Test(): def __get(self): #读成员方法 return self.__value def __set(self,value): #写成员方法 self.__value=value def __del(self): #删除成员方法 del self.__value value=property(__get,__set,__del) #设置属性为可读、可写、可删除 #创建类Test的对象 t=Test() t.value=100 #写成员 print(t.value) #读成员 del t.value #删除成员 Help on class property in module builtins: class property(object) | property(fget=None, fset=None, fdel=None, doc=None) | | Property attribute. | | fget | function to be used for getting an attribute value | fset | function to be used for setting an attribute value | fdel | function to be used for del'ing an attribute | doc | docstring | | Typical use is to define a managed attribute x: | | class C(object): | def getx(self): return self._x | def setx(self, value): self._x = value | def delx(self): del self._x | x = property(getx, setx, delx, "I'm the 'x' property.") | | Decorators make defining new properties or modifying existing ones easy: | | class C(object): | @property | def x(self): | "I am the 'x' property." | return self._x | @x.setter | def x(self, value): | self._x = value | @x.deleter | def x(self): | del self._x | | Methods defined here: | | __delete__(self, instance, /) | Delete an attribute of instance. | | __get__(self, instance, owner, /) | Return an attribute of instance, which is of type owner. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __set__(self, instance, value, /) | Set an attribute of instance to value. | | deleter(...) | Descriptor to change the deleter on a property. | | getter(...) | Descriptor to change the getter on a property. | | setter(...) | Descriptor to change the setter on a property. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __isabstractmethod__ | | fdel | | fget | | fset

特殊方法，析构

在Python中，类有大量的特殊方法，其中比较常见的是构造方法__init__()和析构方法__del__()。

关于析构，在别的语言中有更形象的词语：deinit，de-：意思是撤销、清除的意思，例如debug 但关于中文中： 析的意思：分崩离析：分离 𣂔： 片：被劈开的木头、木头片 斤：武器，斧之用为直劈，斤之用则为横断也。兵即斤一人，扛着兵器的人就是兵 我印象中，析一直是分析这个动词，但其本意是砍木头，进而有劈开（分离）、砍开木头看里面（分析）的意思 所以析构就是拆散构造而非分析构造，deinit则更直接表明清除初始，或是清空，在有道中，直接解释为清理函数

构造方法__init__()用来为类中的成员设置初始值或进行必要的初始化工作，在类实例化是自动调用和执行 如果没有显示地定义构造方法__init__()，Python会提供一个默认的构造方法 析构方法__del__()一般用来释放对象占用的资源，在删除对象和回收对象空间时被自动掉用和执行 如果用户没有编写析构方法__del__()，Python会提供一个默认的析构方法进行必要的清理工作

#定义类 class 矩形(): #定义构造方法 def __init__(self,长,宽): self.长=长 self.宽=宽 print("已执行构造方法") def 面积(self): return self.长*self.宽 #定义析构方法 def __del__(self): print("执行析构方法？") j=矩形(3,4) print("面积为：",j.面积()) del j # print("面积为：",j.面积())

更多特殊方法：官方文档：3.3. 特殊方法名称

类的继承与多态

类的继承，super

继承类称为派生类或子类，被继承类称为父类或基类 在Python中，派生类可以继承一个父类（单继承）或多个父类（多继承） 当派生类继承多个父类时，多个父类之间用逗号隔开

创建派生类的一般格式为： class 派生类(父类1,父类2,…): 类体 派生类可以继承父类的成员和方法，也可以定义自己的成员和方法 如果父类方法不能满足要求，派生类也可以重写父类的方法

#定义People类 class People: #定义构造方法 def __init__(self,n,a): self.name=n self.age=a #定义公有方法 def speak(self): print("我是%s，今年%d岁"%(self.name,self.age)) #定义Student类，继承类People class Student(People): def __init__(self,n,a,g): People.__init__(self,n,a) #调用父类的构造方法 self.grade=g #重写父类的方法 def speak(self): print("我是%s，今年%d岁，读%d年级。"%(self.name,self.age,self.grade)) if __name__=='__main__': #创建Student类的对象 s=Student('孔融',10,4) s.speak() #调用Student类中的speak()方法 super(Student,s).speak() #调用父类People的speak()方法 IS=Student('艾斯',23,1) super(Student,IS).speak()

这里突然冒出个super，用法 super(类,对象) == 对象(父类)

当派生类继承多个父类时，若父类中有相同的方法名，而在派生类使用时未指定，则按继承顺序从左到右查找父类中是否包含该方法，调用最先找到的父类方法

类的多继承

#定义People类 class People: #定义构造方法 def __init__(self,n,a,z): self.name=n self.age=a #定义公有方法 def speak(self): print("%s说：我今年%d岁。"%(self.name,self.age)) #定义Speaker类 class Speaker(): #定义构造方法 def __init__(self,n,t): self.name=n self.topic=t #定义公有方法 def speak(self): print("我叫%s，是一名科学家，今天演讲的主题是%s。"%(self.name,self.topic)) #定义Scientist类，同时继承People类和Speaker类 class Scientist(People,Speaker): #class Scientist(Speaker,People): #定义构造方法 def __init__(self,n,a,t,z): #调用两个父类的构造方法 People.__init__(self,n,a,z) Speaker.__init__(self,n,t) if __name__=="__main__": #创建Scientist类的对象，传入参数 Hawkin=Scientist("霍金",50,"《时间简史》","z") Hawkin.speak()

里面有我故意写的一个奇怪的地方，因为书里写漏一段，而我这里故意增加一段，看看到底有何不同

类的多态

多态（Polymorphism）一般是指父类的一个方法在不同派生类对象中具有不同表现和行为 派生类在继承父类的行为和属性之后，还可能增加某些特定的行为和属性，也可能会对继承父类的行为进行一定的改变，这些都是多态的表现形式

类的多态实现

#定义类Animal class Animal(): #定义方法 def getInfo(self): return "I am an animal" #定义类Lion，继承类Animal class Lion(Animal): #重写父类Animal的方法getInfo() def getInfo(self): return "I am a lion" #定义类Tiger，继承类Animal class Tiger(Animal): #重写父类Animal的方法getInfo() def getInfo(self): return "I am a tiger" #定义类Leopard，继承类Animal class Leopard(Animal): #重写父类Animal的方法getInfo() def getInfo(self): return "I am a leopard" if __name__=='__main__': #创建各类的对象列表objectList objectList=[item() for item in (Animal,Lion,Tiger,Leopard)] #不同对象调用同一方法getInfo() for object in objectList: print(object.getInfo()) print(type(object)) print(Animal().getInfo())

额，这又是一个概念性的东西，那么item是啥？把item换成a也照样能运行 看最后两句，是我加上的，所以item()就是item+()，他就是一个类的名称/调用，所以objectList他的元素不是字符串而是类名

抽象类和抽象方法

抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同但本质上相同的概念抽象。 抽象类与普通类的不同之处是：抽象类中通常包含抽象方法（没有实现功能） 该类不能被实例化，只能被继承，且派生类必须实现抽象类中的抽象方法 Python中一般使用抽象基类（Abstract Base Class，ABC）来实现抽象类。ABC主要定义了基本类和最基本的抽象方法，可以为派生类定义公有的API，不需要具体实现，想到与Java中的接口或抽象类，使用抽象基类需要先导入abc模块 天书？

抽象类和抽象方法的使用

import abc #定义抽象类 class People(metaclass=abc.ABCMeta): #定义抽象方法 @abc.abstractmethod def working(self): pass #定义抽象类People的派生类 class Chinese(People): #实现抽象类的抽象方法working() def working(self): print("中国人都在勤奋地工作····") #创建Chinese类的对象 c1=Chinese() c1.working()

恶趣味的例题 意思就是说，人必须工作 中国人的工作都很勤奋

定义一个类，他有一个抽象方法，他的子类必须有这个方法，如是

借书管理系统（伪）

#定义类，书的状态 class Book: def __init__(self,t,p,s): self.title=t self.price=p self.state=s #1为在库，0为借出 def __str__(self): state="已借出" if self.state==0 else "未借出" return "书名：《%s》，单价：%.2f元，状态：%s"%(self.title,self.price,state) # a1=Book("阿甘正传",99,1) # print(a1) class BookManager: books=[] def init(self): self.books.append(Book('茶花女',32,0)) self.books.append(Book('傲慢与偏见',41,1)) self.books.append(Book('罗密欧与朱丽叶',29,1)) def Menu(self): self.init() print('"书籍出租管理系统"\n菜单：') print('1、显示书籍') print('2、增加书籍') print('3、借出书籍') print('4、归还书籍') print('5、统计书籍') print('-1、退出系统') while 1: menu_item=int(input('请输入菜单编号：')) if menu_item==1:self.show_all_books() elif menu_item==2:self.add_books() elif menu_item==3:self.lend_books() elif menu_item==4:self.return_books() elif menu_item==5:self.count_books() elif menu_item==-1: print('谢谢使用！') break def show_all_books(self): for book in self.books: print(str(book)) def add_books(self): title=input("请输入要添加的书的书名：") if self.check_books(title): print("该书已存在") return price=float(input("请输入价格：")) self.books.append(Book(title,price,1)) print("书籍添加成功") #上面的功能费了一番周折，书上是吧检查书是否存在单独写了一个方法，有多处地方会用到这个功能，所以把他单独写出来，但又在self这里卡了好一会，最后是调用外部的Book，都是self def lend_books(self): title=input('请输入要借的书的书名：') book=self.check_books(title) if not book: print("要借的书不存在") return if book.state==0: print("要借的书已被借") return book.state=0 print("请拿好您借的书") def return_books(self): title=input('请输入您要归还的书的书名：') book=self.check_books(title) if not book: print('您要归还的书不存在，请检查输入是否错误') return if book.state==1: print('您要归还的书未出借') return day=int(input('请输入您借书的天数：')) print('您需要支付%.2f元'%(day*0.5)) def count_books(self): lend=[] nolend=[] for book in self.books: if book.state==0: lend.append(book.title) else:nolend.append(book.title) print('出借书籍%d册：%s，在库书籍%d册：%s'%(len(lend),str(lend)[1:-1],len(nolend),str(nolend)[1:-1])) def check_books(self,title): for book in self.books: if book.title==title: return book m=BookManager() m.Menu()

以上的核心就是books，这个列表存放的不是之前接触到的直接的元素信息，而是按类的规则打包的对象的信息。真要比喻的话，就是一定规则的列表，而类就赋予了列表内容的意义，甚至于定义合法性等。 难点，就是各种该不该添加self，方法内的成员不需要添加self，类内的、本方法外的成员，需要添加self

至于代码结构为何不符合现实逻辑，我现在淡定了，等过完这本书再那样写，目前就参照书中代码就是了！

本章完