文章目录
- 面向对象编程概念(OOP)
- 抽象
- 类和实例
- 封装/接口
- 组合/包含
- 派生/继承
- 多态
- 自省/反射
- 属性和方法
- 创建类
- 创建对象
- 实例方法(非静态成员函数)
- 实例属性(非静态成员变量)
- 类属性(静态成员变量)
- 静态方法(静态成员函数)
- 类方法
- 属性的面向没访问权限
- 类之间的关系
- 组合
- 简单的通讯录
- 继承
- 理解Python的多态
- 类和实例的常用内建函数
- issubclass
- isinstance
- hasattr, getattr, setattr, delattr
- dir
- vars
- super
- 特殊方法的作用
- 特殊方法一览
重点内容:
理解面向对象编程OOP的概念和思想方法
掌握Python面向对象的语法规则
理解继承, 封装, 多态等面向对象特性, 在Python中的具体体现.
面向对象编程概念(OOP)
面向过程是编年史: 按照时间先后顺序, 一条一条的记录发生的事情.
面向对象是记传史: 按照每个王侯将相的维度, 记录这个人是谁, 有哪些特点, 做过哪些事情.
所以史记其实是中国古代的一个非常成功的应用了 OOP 思想的著作
OOP是一种编程思想. 所谓 “思想”, 指的是解决一类问题时, 使用的一系列的方法手段
两种角色:
- 1.类的实现
- 2.类的调用者(使用者)
抽象
抽象是指对现实世界问题和实体的本质表现, 行为, 特征进行建模;抽象的反义词是 “具体”
抽象的本质, 是抓住我们重点关注的主体, 而忽略一些我们不需要关注的细节;
写程序也是一样, 我们不可能把一个现实事物所有的信息都在程序中表示出来, 而是只表示我们需要用到
的.
类和实例
类是施工图纸, 里面有房子的重要信息(户型, 面积, 朝向, 层高等等).
实例是造好的房子, 房子造好了, 才能住进去, 才能娶到媳妇. 如果房子烂尾了, 美好生活就只是在YY~
通过同一张图纸可以建造出N个相同格局的房子, 那么这N个实例就都是属于同一个类(回忆下我们的type
函数).
总结:
对象就是类的实例,是一个客观事物的抽象.
把多个对象按一定的规则进行归类, 就成为了类.
Python中的对象包含三个部分: id, 类型, 值
封装/接口
封装描述了对数据/信息进行隐藏的观念, 对象的使用者只能通过接口来访问/修改对象的数据.
封装的好处是减轻调用者的使用负担, 调用者只需要知道接口如何使用, 而不需要知道对象的具体实现.
封装这个概念当然不是只存在于面向对象思想中. 回忆计算机网络协议栈的分层结构, 也是为了达到封装的效果.
组合/包含
多个小的类组合成一个大的类, 来解决一个相对复杂的问题.
组合表示 has-a语义
组合的目的是代码重用
派生/继承
基于一个现有的类, 通过继承这个类创建一个新的类.
如果基于类A用继承的方式创建了类B, 我们就将这个过程成为类A派生出了类B. 类A称为父类(或超类), 类B称为子类.子类对象包含了父类对象的所有属性和操作.
继承表示了 is-a这样的语义.
继承的目的还是代码重用
多态
本质上讲 多态是在运行时能够自动的识别出对象的类型, 并使用对应类型的方法来完成一定的动作.
多态也是一种 “信息隐藏”, 让调用者了解的信息越少, 那么使用起来负担就越低.
刚才我们说的封装, 只是让调用者不知道这个类里面的实现; 而我们的多态, 是让调用者连这个类究竟是哪
个类都不需要关心.
自省/反射
自省和反射是一个意思. 顾名思义, 就是认清自己是谁. 指对象在程序运行时能获取到一些自己的信息
dir/id/type/__name__ _doc_ 这些内置属性和方法就是自省的具体体现.
其实C++中也有typeid这样的方法来进行一部分的"自省"的功能. 只不过是和C++的设计理念背道而驰, 因
此不推荐使用.
属性和方法
创建类
使用class关键字创建一个类. 创建类的语法和创建函数很像.
#创建一个函数def func(): #文档字符串 #函数体 #创建一个类#默认继承object类class ClassName: #文档字符串 #类体
创建一个类, 实际上是创建了一个自定制的类型.其实Python中, 类和类型是统一的. 而不像很多其他编程
语言那样, 区分内置类型和"类类型"
类的定义语句一般出现在模块的顶级缩进; 但是Python并不强制要求. 类的定义也可以出现在类/函数, 或者其他语句块中. 当然作用域也就不一样了
创建对象
在C++或者Java中, 使用new这个关键字来创建一个对象. 在Python中把这个new直接就省略掉了
class A(): pass #空语句a = A()
创建空列表时:
#方法1:a = []#方法2:a = list() #工厂函数
实例方法(非静态成员函数)
在类中直接定义的函数就是类的成员函数.
成员函数必须先创建一个类的对象,然后通过对象的 .
操作来访问
例子
class C(): def Print(self): print('hello')c = C() #创建对象c.Print() #调用成员函数 hello#注意: c.Print() == C.Print(c)
注意看, 我们在类中定义的这个成员函数Print, 有一个参数self. 这个self参数指的是这个对象本身(注意是
对象, 不是类!).
self相当于C++中的this指针. 这个参数不一定非叫self, 也可以改成其他的名字(比如命名为this).
但是大家约定都写作self.
如果我们不创建对象, 直接通过类名来调用, 就会抛出异常.
class C(): def Print(self): print('hello')C.Print() #TypeError: Print() missing 1 required positional argument: 'self'
根据这个错误信息, 看起来貌似是缺少一个参数.我们尝试一下.
class C(): def Print(self): print('hello')c =C()C.Print(c) #hello
实际上, c.Print() 在Python解释器中会转换成 C.Print©. 但是为了方便, 我们平时都写作c.Print()
实例属性(非静态成员变量)
类的成员变量, 也称为实例属性, 和类的属性相对应.
Python可以在运行时给一个对象新增或删除实例属性.这一点是C++和Java等语言做不到的.
可以在任何一个类的方法中创建实例属性.
class C(): #Init需要手动调用 def Init(self): self.a = 100 def Print(self): print(self.a)c =C()#创建对象c.Init()#先初始化,相当于调用默认构造函数c.Print()#调用Print函数 100
如果不先调用Init函数就会出错
使用构造器 _init_ 来创建实例属性, _init_ 会在创建对象的时候自动被调用, 这样就不需要我们
手动去调一个Init这样的函数了
__init__相当于默认构造函数,通常把一个类的实例属性都写到__init__里面
class C(): def __init__(self): self.a = 100 #创建一个实例属性a的值为100 def Print(self): print(self.a)c =C()#创建对象c.Print()#调用Print函数 100
__init__ 构造器可以带一些参数, 这样的话就可以创建对象的时候直接赋值进去了. 记得第一个参数一定
是 self(表示示例自身).
class C(): def __init__(self,x): self.a = x #创建一个实例属性a的值为x def Print(self): print(self.a)c =C(200)#创建对象c.Print()#调用Print函数 200
如果构造器有多重不同形式的参数怎么办? 和C++, Java不同, Python不需要进行多个版本的构造器 “重载”,
因为Python中压根就不需要 “重载” 语法~
Python中还有一个解构器 __del__但是Python有内置的GC机制,一般不需要程序猿手动定义__del__
来回收对象.
类属性(静态成员变量)
在类创建过程中, 可以直接在类里定义一些属性
class A(): val = 100print(A.val) #100
这种方法在类创建好之后就可以直接使用, 而不需要先创建一个对象. 这就是我们C++或者Java中接触过的
静态成员变量
所谓静态成员, 其实指的是这是一个类的属性, 而不是一个对象的属性
静态方法(静态成员函数)
刚才我们提到的成员函数, 都是实例属性, 必须要创建实例才能调用. 我们能否创建一个类属性, 也就是 “静态成员函数”
方法1:手动将函数改为静态成员函数 用
staticmethod
修改
注意:对于静态方法, 就不需要 self 这样的参数了.,所以Print函数的参数不需要加self
class A(): def Print(): print('hello') Print = staticmethod(Print) #将Print变为静态成员函数A.Print() #hello
方法2:
使用 @staticmethod这种方式来修饰 Print 函数, 同样能达将一个方法定义成静态方法的效果. 这个语法
叫做函数修饰符, 也叫 装饰器.
class A(): @staticmethod def Print(): print('hello')A.Print() #hello
对于类的静态方法, 本质上是一个和类无关的函数, 只是这个函数的作用域是在类名之内.
注意:静态方法不能访问静态成员变量(类属性)
类方法
Python中的静态方法, 其实不能和C++的静态成员函数等价. 真正能作为等价的应该是 类方法
使用 classmethod进行修饰, 同时使用 cls 作为第一个参数, 这样就构成了类方法.
class A(): x = 100 #静态成员函数->类属性 @classmethod def Print(cls): print(cls.x)a = A()a.Print() #100
用cls这个参数, 来表示当前类(记得Python中类也是对象) 刚才的self表示当前对象. 然后就可以通过 cls 来访问到类属性了
self类似. cls 也只是一个约定俗称的名字. 也可以命名成其他的名字
属性的访问权限
学过C++/Java的同学们知道, 使用关键字public/private/protected等关键字, 可以对属性的访问权限进行控制. 这也是"封装" 思想的一种具体体现.
Python中使用双下划线前缀( __ )来表示私有成员
class A(): def __init__(self): self.__a = 100 #私有成员,在类外不能访问a = A()print(a.__a) #抛异常 AttributeError: 'A' object has no attribute '__a'
类之间的关系
在设计一个程序时, 需要设计多个有一定关系的类. 而这种类和类之间的关系, 最主要有两种. 组合和继承
组合
一个类中包含其他的类,形成这样的组合关系, 表示 has-a语义.
类之间显著不同, 并且较小的类是较大的类的组件的时候, 使用组合非常合适
简单的通讯录
例子:一个简单的通讯录,Book类包含一个标题title,和一个列表对象data(保存每一个人的信息person),同时person这个类中又包含了两个字符串,表示名字和电话
#成员class person(): #默认构造函数,self表示当前对象 def __init__(self,name,phone): #成员为: name phone self.name = name #姓名 self.phone = phone #电话#通讯录class Book(): def __init__(self,title): #成员为: data列表 self.data = [] #添加用户 #entry是一个person类的对象 def AddUser(self,entry): self.data.append(entry) #展示内容 def Show(self): #data是一个列表,entry是它的每一个成员 for entry in self.data: print(entry.name) print(entry.phone) book = Book('name Phone')book.AddUser(person("Mango",'1')) #添加的是一个person类对象book.AddUser(person("Lemon",'2'))book.Show()#执行结果:Mango1Lemon2
继承
类之间大体相似, 但是某些细节不同, 这时候适合使用继承的方式. 表示 is-a语义.
继承也可以理解成, 对一个已经定义好的类, 进行一定的扩展.
如果一个类没有从任何一个父类继承, 那么可以让这个类继承自object
class A(object): pass
另外, 也可以不写继承自object. 这种类称为经典类(也叫旧式类). 旧式类和新式类大部分特性都是一样的.
class A: #经典类 pass
子类能够继承父类的属性和方法.
class Parent: def ParentPrint(self): print('ParentPrint')class Child(Parent): #表示继承Parent这个类 def ChildPrint(self): print('ChildPrint')p = Parent() #创建父类对象p.ParentPrint() #父类对象调用父类的方法c = Child() #创建子类对象c.ParentPrint()#子类对象调用父类的方法c.ChildPrint()#子类对象调用子类的方法#执行结果:ParentPrintParentPrintChildPrint
如果子类中存在和父类中相同名字的方法, 子类方法会覆盖父类方法.*Python的覆盖和方法的参数没关系
class Parent: def func(self): print('ParentPrint')class Child(Parent): #表示继承Parent这个类 def func(self): print('ChildPrint')p = Parent() #创建父类对象p.func() #父类对象调用父类的方法c = Child() #创建子类对象c.func() #执行结果ParentPrintChildPrint
这一点在实现类的构造器要额外注意. 子类和父类都有同名的构造器. 子类的构造器中需要显式调用父类构
造器.
class Parent: def __init__(self): self.x = 10class Child(Parent): #表示继承Parent这个类 def __init__(self): self.y = 20p = Parent() #创建父类对象print(p.x)c = Child() #创建子类对象print(c.x) #抛异常AttributeError: Child' object has no attribute 'x'
没有显式调用父类构造器, 执行报错.
如何显示调用?在子类的__init__函数中,加上:
Parent.__init__(self)
#显示调用父类的方法
class Parent: def __init__(self): self.x = 10class Child(Parent): #表示继承Parent这个类 def __init__(self): Parent.__init__(self) #显示调用父类的方法 self.y = 20p = Parent() #创建父类对象print(p.x)c = Child() #创建子类对象print(c.x) #执行结果:1010
可以使用super方法来协助我们找到父类的方法, 而不需要显式的指定父类的类名.
在子类的__init__函数中,加上: super(子类的名称,self).__init__()
#显示调用父类的方法
class Parent: def __init__(self): self.x = 10class Child(Parent): #表示继承Parent这个类 def __init__(self): super(Child,self).__init__() #显示调用父类的方法 self.y = 20p = Parent() #创建父类对象print(p.x)c = Child() #创建子类对象print(c.x) #执行结果:1010
理解Python的多态
对于Python的多态, 其实和 “父类/子类” 并没有必然联系.
对于Python的这种多态方式, 也称为 鸭子类型(duck typing). 只要一个东西, 能像鸭子一样能叫, 能走路,
能游泳, 那么就可以认为这是一只鸭子~~而不考虑这个对象真实是什么类型.
例如
def Add(x,y): return x + yprint(Add(1,2))print(Add("hello","world"))print(Add([1,2],[3,4]))#执行结果3helloworld[1, 2, 3, 4]
好了, 其实鸭子类型, 并不是Python这样的动态类型语言的专属. 一些静态类型语言
类和实例的常用内建函数
issubclass
判定一个类是不是另外一个类的子类.
class Parent: passclass Child(Parent): #表示继承Parent这个类 passprint(issubclass(Child,Parent)) #True--------------------------------------------------class Parent: passclass Child(): passprint(issubclass(Child,Parent)) #False
isinstance
判定一个对象是不是一个类的实例.
class C: passc = C()print(isinstance(c,C)) #True
注意:isinstance还可以判断一个对象的类型
a = 10print(isinstance(a,int)) #True
hasattr, getattr, setattr, delattr
用来对一个类/对象的属性进行操作和判定
class C: x = 100print(hasattr(C,'x')) #Trueprint(hasattr(C,'y')) #False
class C: x = 100print(getattr(C,'x')) # 100print(getattr(C,'y')) #类C中没有y属性,抛异常:AttributeError: type object 'C' has no attribute 'y'
该函数没有返回值,所以如果打印返回值是None
class C: x = 100print(setattr(C,'x',200)) #Noneprint(C.x) #200setattr(C,'y',600)print(C.y) #600
class C: x = 100delattr(C,'x') #x这个属性被删除print(C.x) #AttributeError: type object 'C' has no attribute 'x'
dir
查看类/对象的所有属性和方法.
class C: passprint(dir(C))#执行结果['__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__']
vars
和dir类似. dir只是返回了有哪些属性, 但是没显示属性的值. vars将值也取了出来.
class C: passprint(vars(C))#执行结果: { '__module__': '__main__', '__dict__': , '__weakref__': , '__doc__': None}
super
获取到当前类/对象的父类
super本质也是一个工厂函数, 创建了一个父类的对象
特殊方法的作用
我们前面学的 init只是其中一个特殊方法. 其实类还有很多特殊方法, 通过这些特殊方法, 可以完成
_str_
class Time: def __init__(self,hour,min): self.hour = hour self.min = min def __str__(self): return f"{ self.min}"t = Time(21,11)print(t) #21:11
如果不实现_str_,那就是打印对象的id
<_main_.Time object at 0x0000027FAECC3400>
_len_
如:直接获取字符串的长度作为时间类的长度
class Time: def __init__(self,hour,min): self.hour = hour self.min = min def __str__(self): return f"{ self.min}" def __len__(self): return len(self.__str__())t = Time(21,11)print(t) #21:11print(len(t)) #5