python面向对象基础知识笔记

面向对象与面向过程

面向过程：根据业务逻辑从上到下写代码。

面向对象：将变量与函数绑定到一起，分类进行封装，每个程

序只要负责分配给自己的分类，这样能够更快速的开发程序，减少

了重复代码。

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定

功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织在

一起，数据与函数分开考虑，面向过程基本是由函数组成的。

01.面向过程编程

面向过程编程的关注点在于怎么做

把完成某一个需求的所有步骤从头到尾逐步实现

根据开发需求，将某些功能独立的代码封装成一个又一

个函数

最后完成的代码，就是顺序地调用不同的函数

特点:

注重步骤与过程，不注重职责分工

如果需求复杂，代码会变得很复杂

开发复杂项目，没有固定的套路，开发难度很大!

02.面向对象基本概念

面向对象编程（ObjectOrientedProgramming,OOP,面向对

象程序设计）和面相过程编程，是两种不同的编程方式。

面向对象编程的关注点在于谁来做

相比较函数，面向对象是更大的封装，根据职责在一

个对象中封装多个方法

在完成某一个需求前，首先确定职责一一要做的事情（方

法）

根据职责确定不同的对象，在对象内部封装不同的方法

（多个）

最后完成的代码，就是顺序地调用不同对象的相应方法。

特点:

注重对象和职责，不同的对象承担不同的职责。

更加适合应对复杂的需求变化，是专门应对复杂项目开发，提

供的固定套路。

需要在面向过程基础上，再学习一些面向对象的语法。

类和对象

类和对象是面向对象编程的两个核心概念。

类

类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，

不能直接使用

特征其实就是一个变量，在类里我们称之为属性。

行为其实就是一个函数，在类里我们称之为方法。

类其实就是由属性和方法组成的一个抽象概念。

类就相当于制造飞机时的图纸，是一个模板。这个模板只规定了飞

机的某些特征（例如大小，颜色，型号等等）和行为（例如起飞，降落,

飞行等等），它并不是一个具体的飞机，而是对飞机的一个抽象概念。

它出现的目的，是为了让我们的创建飞机对象。

对象

对象是由类创建出来的一个具体存在，可以直接使用。由哪一个类

创建出来的对象，就拥有在哪一个类中定义的属性和方法。对

象就相当于用图纸制造的飞机。在开发中，应该先有类，在类里定

义好属性和行为，再根据类来创建对象。

类和对象的关系

类是模板，对象是根据类这个模板创建出来的，应该先有类,

再有对象。

使用同一个类，能够创建出很多对象。

类中定义了什么属性和方法，对象中就有什么属性和方法。

不同对象对应的属性值也会不同。

例如：定义了一个狗类，这个狗类有以下属性：

品种

颜色

性别

名字

现在根据这个类创建出了两条狗，这两条狗分别是哈士奇、灰色、

母、二哈和中华田园犬、黄色、公、旺财。我们发现，这两条狗

都具有品种、颜色、性别和名字这些属性，但是每条狗对应的属性

值却不一样。

类的设计

在使用面相对象开发前，应该首先分析需求，确定一下，程序中需

要包含哪些类！

在程序开发中，要设计一个类，通常需要满足一下三个要素：

1.类名这类事物的名字，安照大驼峰命名法（每个单词的首字母

大写）起名。

2.属性这类事物具有什么样的特征。

3.方法这类事物具有什么样的行为。

定义类名

名词提炼法:分析整个业务流程，出现的名词，通常就是找到的类。

属性和方法的确定

•对对象的特征描述，可以定义成属性

,对象具有的行为（动词）可以定义成方法

面向对象基本语法

在Python中，对象几乎是无处不在的，我们可以使用dir内置函

数来查看这个对象里的方法。

定义简单的类（只包含方法）

面向对象是更大的封装，在一个类中封装多个方法，这

样通过这个类创建出来的对象，就可以直接调用这些方

法了！

定义类

在Python中要定义一个只包含方法的类,语法格式如下：

class类名：

def方法l（self,参数列表）：

pass

def方法2（self,参数列表）：

pass

1.方法的定义格式和之前学习过的函数一样

2.方法里的第一个参数必须是self,大家暂时先记住，稍

后介绍self.

3.类名要遵守大驼峰命名法。

创建实例对象

当一个类定义完成之后，要使用这个类来创建对象，语法格式如下:

对象变量名=类名()

第一个面向对象代码

需求

小猫爱吃鱼，小猫要喝水

分析

定义一个猫类Cat

定义两个方法eat和drink

按照需求——不需要定义属性

classCat:

"""这是个猫类"""

defeat(self):

print("小猫在吃东西")

defdrink(self)：

print("小猫在喝水")

tom=Cat()#创建了一个Cat对象

tom.eat()

tom.drinkO

hello.kitty=Cat()#又创建了一个新的Cat对象

hello_kitty.eat()

hello_kitty.drink()

思考：tom和hello_kitty是同一个对象吗？

self的使用

给对象添加属性

python支持动态属性，当一个对象创建好了以后，直接使用对象.

属性名=属性值就可以很方便的给对象添加一个属性。

tom=Cat()

='Tom'#可以直接给tom对象添加一个name

属性

这种方法很方便，但是，不建议使用这种方式给对象添加属性。

self的概念

哪个对象调用了方法，方法里的self指的就是谁。通过self.属性

名可以访问到这个对象的属性；通过self.方法名()可以调用这个对

象的方法。

classCat:

defeat(self):

print("%s爱吃鱼"%)

tom=Cat()

='Tom'#给tom对象添加了一个name属性

tom.eatO#Tom爱吃鱼

lazy_cat=Cat()

lazy_="大懒猫"

Iazy_cat.eat()#大懒猫爱吃鱼

直接给对象添加属性的缺点

上述代码中，我们是先创建对象，然后再给对象添加name属性,

但是这样做会有问题。

tom=Cat()

tom.eatO

tom.anme="Tom"

程序运行时会报错：

AttributeError:'Cat'objecthasnoattribute'name'

错误提示：'Cat‘对象没有‘name'属性

在日常开发中，不推荐在类的外部直接给对象添加属性这种方式。

对象应该具有哪些属性，我们应该封装在类的内部。

魔法方法

Python里有一种方法，叫做魔法方法。Python的类里提供的，

两个下划线开始，两个下划线结束的方法，就是魔法方法，魔法方

法在恰当的时候就会被激活，自动执行。魔法方法的两个特点：

两侧各有两个下划线；

"咒语”名字已经由Python官方定义好，我们不能乱写。

方法

_init_()方法，在创建一个对象时默认被调用，不需要手动调用。

在开发中，如果希望在创建对象的同时，就设置对象的属性，可以

对_init_方法进行改造。

classCat:

"""这是一个猫类"""

def_init_(self,name):#重写了_init_魔法方法

=name

defeat(self):

return"%s爱吃鱼"％

defdrink(self):

return'%s爱喝水'％

tom=Cat()

TypeError:__init_()missing1requiredpositional

argument:'name'

这种写法在运行时会直接报错！因为_init_方法里要求

在创建对象时，必须要传递name属性，如果不传入会直接报错!

11IIII

tom=Cat("Tom")#创建对象时，必须要指定name属性的值

tom.eat()#tom爱吃鱼

注意：

1._init_()方法在创建对象时，会默认被调用，不需要手动的调

用这个方法。

2._init_()方法里的self参数，在创建对象时不需要传递参数,

python解释器会把创建好的对象引用直接赋值给self

3.在类的内部，可以使用self来使用属性和调用方法；在类的

外部，需要使用对象名来使用属性和调用方法。

4.如果有多个对象，每个对象的属性是各自保存的，都有各自独

立的地址。

5.方法是所有对象共享的，只占用一份内存空间，方法被调用时

会通过self来判断是哪个对象调用了实例方法。

2._del_方法

创建对象后，python解释器默认调用_init_()方法；

而当删除对象时，python解释器也会默认调用一个方法，这个方

法为_del_()方法。

classStudent:

def_init_(self,name,score):

print('_init_方法被调用了')

=name

self.score=score

def_del_(self):

print('_del_方法被调用了')

s=Student('lisi',95)

dels

input('请输入内容')

3._str_方法

_str_方法返回对象的描述信息，使用print。函数打印对象时，其

实调用的就是这个对象的_str_方法。

classCat:

def_init_(self,name,color):

=name

self.color=color

tom=CatCTom'/white')

#使用print方法打印对象时，会调用对象的_str_方法，默认

会打印类名和对象的地址名

print(tom)#<_main_.Catobjectat

0x0000021BE3B9C940>

如果想要修改对象的输出的结果，可以重写_str_方法。

classPerson:

def_init_(self,name,age):

=name

self.age=age

def_str_(self):

return'哈哈'

p=Person，张三',18)

print(p)#哈哈打印对象时，会自动调用对象的_str_方法

一般情况下，我们在打印一个对象时，可能需要列出这个对象的所

有属性。

classStudent:

def_init_(selfname,score):

=name

self.score=score

def_str_(self):

return'姓名是：｛｝,成绩是｛｝分

'.format(,self.score)

s=Student('lisi',95)

print⑸#姓名是:lisi,成绩是95分

4.__repr_方法

_repr_方法和_str_方法功能类似，都是用来修改一个对象的默

认打印内容。在打印一个对象时，如果没有重写_str_方法，它会

自动来查找_repr_方法。如果这两个方法都没有，会直接打印这

个对象的内存地址。

classStudent:

def_init_(self,name,score):

=name

self.score=score

def_repr_(self):

return'helllo'

classPerson:

def_repr_(self):

return'hi'

def_str_(self)：

return'good'

s=Student('lisi1,95)

print(s)#hello

p=Person()

print(p)#good

5._call_方法

对象后面加括号，触发执行。

classFoo:

def_init_(self):

pass

def_call_(self*args,**kwargs):

print('_call_')

obj=Foo()#执行_init_

obj()#执行_call_

总结

1.当创建一个对象时，会自动调用_init_方法，当删除一个对

象时，会自动调用_del_方法。

2.使用_str_和_repr_方法，都会修改一个对象转换成为字符

串的结果。一般来说，_str_方法的结果更加在意可读性，而

_repr_方法的结果更加在意正确性(例如:datetime模块里的

datetime类)

运算相关的魔法方法

思考：

classPerson:

def_init_(self,name,age):

=name

self.age=age

pl=Person('zhangsan',18)

p2=Person('zhangsan',L8)

print(pl==p2)

上述代码中，使用==运算符比较两个对象，结果是True还是

False?==到底比较的是什么？

比较运算符相关魔法方法

classStudent:

def_init_(self,name,age):

=name

self.age=age

def_eq_(self,other):

return==andself.age==

other.age

#def_ne_(self,other):

def_lt_(self,other):

returnself.age<other.age

#def_gt_(self,other):

def_le_(self,other):

returnself.age<=other.age

#def_ge_(self,other):

si=Student('zhangsan',18)

s2=Student('zhangsan',18)

s3=Student('lisi',20)

print(sl==s2)

print(sl!=s2)

print(sl>s2)

print(sl>=s2)

print(sl<=s2)

print(sl<=s2)

算数运算符相关魔法方法

classStudent:

def_init_(self,name,age):

=name

self.age=age

def_add_(self,other):

returnself.age+other

def_sub_(self,other):

returnself.age-other

def_mul_(self,other):

returnself.age*other

def_truediv_(self,other):

returnself.age/other

def_mod_(self,other):

returnself.age%other

def_pow_(self,power,modulo=None):

returnself.age**power

s=Student('zhangsan',18)

print(s+)#19

print(s-)#16

print(s*2)#36

print(s/)#3.6

print(s%5)#3

print(s**2)#324

类型转换相关魔法方法

classStudent:

def_init_(self,name,age):

=name

self.age=age

def_int_(self):

returnself.age

def_float_(self):

returnself.age*

def_str_(self):

return

def_bool_(self):

returnself.age>18

s=Student('zhangsan',18)

print(int(s))

print(float(s))

print(str(s))

print(bool(s))

ifs:

print('hello')

内置属性

使用内置函数dir可以查看一个对象支持的所有属性和方法，

Python中存在着很多的内置属性。

_slots_

Python中支持动态属性，可以直接通过点语法直接给一个对象添

加属性，代码更加的灵活。但是在某些情况下，我们可能需要对属

性进行控制，此时，就剋使用_slots_实现。

classPerson(object):

_slots_=('name','age')

def_init_(self,name,age):

=name

self.age=age

p=PersonC张三'，18)

='李四’

#对象p只能设置name和age属性，不能再动态添加属性#

p.height=180#报错

_doc_

表示类的描述信息。

classFoo:

"""描述类信息，这是用于看片的神奇

deffunc(self):

pass

print(Foo._doc_J#输出:类的描述信息

_module_和_class_

_module_表示当前操作的对象在那个模块;_class_表示当前

操作的对象的类是什么。

test.pyclassPerson(object):

def_init_(self):

='laowang'

main.pyfromtestimportPerson

obj=Person()

print(obj._module_)#输出test即：输出模块

print(obj._class_J#输出test.Person即：输出类

_dict_

以字典的形式，显示对象所有的属性和方法。

classProvince(object):

country='China'

def_init_(self,name,count):

=name

self.count=count

deffunc(self,*args,**kwargs):

printCfunc')

#获取类的属性，即：类属性、方法、

print(Province._dict_)

#输出:{'_dict_':ottribute'_dict_'of'Province'objects>,

'_module_':'_main_','country':'China','_doc_':None,

'_weakref_':<attribute'_weakref_'of'Province'objects>,

"func':<functionProvince.funcat0xl01897950>,

<functionProvince._init_at0xl018978c8>}

objl=Province('山东'，10000)

print(objl._dict_)

#获取对象objl的属性

#输出:{'count':10000,'name':'山东'}

obj2=Province('山西'，20000)

print(obj2._dict_)

#获取对象objl的属性

#输出:{'count':20000,'name':'山西'}

getitem_>l_setitem_和_delitem_方法

这三个方法，是将对象当做字典一样进行操作。

classFoo(object):

def_getitem_(self,key):

print('_getitem—key)

def_setitem_(self,key,value):

print('_setitem—key,value)

def_delitem_(self,key):

print('_delitem―key)

obj=Foo()

result=obj['kl']#自动触发执行_getitem_

obj['k2']='laowang'#自动触发执行_setitem_del

obj['kl']#自动触发执行_delitem_

实例属性、类属性

在面向对象开发中，使用类创建出来的实例是一个对象，那么，类是否是一个

对象呢？

实例属性

通过类创建的对象被称为实例对象，对象属性又称为实例属性，记录对象各

自的数据，不同对象的同名实例属性，记录的数据各自独立，互不干扰。

classPerson(object):

def_init_(selfname?age):

#这里的name和age都属于是实例属性，每个实例在创建时，都有自己的属性

=name

self.age=age

#每创建•个对象，这个对象就有自己的name和age属性

pl=Person('张三'，18)

p2=Person("李四”，20)

类属性

类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有，类属性可

以通过类对象或者实例对象访问。

classDog:

type="狗"#类属性

dogl=Dog()

dog2=Dog()

#不管是dogl>dog2还是Dog类，都可以访问到type属性

print(Dog.type)#姑栗：的

print(dogl.type)#结果:狗

print(dog2.type)#结果:狗

使用场景：

1.类的实例记录的某项数据始终保持一致时，则定义类属性。

2./实例属性要求每个对象为其单独开辟一份内存空间来记录数据，而类属

性为全类所共有，仅占用一份内存，更加节省内存空间。

注意点：

1＞尽量避免类属性和实例属性同名。如果有同名实例属性，实例对象会优先

访问实例属性。

classDog(object):

type="狗"#类属性

def_init_(self):

self.type="dog"#对象属性

#创建对象

dogl=Dog()

print(dogl.type)#站袅为"dog”类属性和实例属性同冬，使用实例对象访问的是实例屈性

2＞类属性只能通过类对象修改，不能通过实例对象修改

lassDog(object):

type="狗"#类属性

#创建对象

dogl=Dog()

dogl.type="dog"#使用实例对象创建了对象屈性type

print(dogl.type)#结果为“dog”类属性和实例属性同名，访问的是实例属性

print(Dog.type)#结果为“狗”访问类属性

#只有使用类名才能修改类属性

Dog.type="土狗”

print(Dog.type)#L狗

dog2=Dog()

print(dog2.type)#上狗

3＞类属性也可以设置为私有，前边添加两个下划线。如:

classDog(object):

count=0#公有的类属性

_type="狗"#私有的类属性

print(Dog.count)#正确

print(Dog.—type)#错%私有属性，外部无法访问,

私有属性和方法

在实际开发中，对象的某些属性或者方法可能只希望在对象的内部别使用，而

不希望在外部被访问到，这时就可以定义私有属性和私有方法。

定义方法

在定义属性或方法时，在属性名或者方法名前增加两个下划线定义的就是

私有属性或方法。

classPerson:

def_init_(self,name,age):

=name

self.age=age

self._money=2000#使用_修饰的属性，是私有属性

def_shopping(self,cost):

self.—money-=cost#_money只能在对象内部使用

print('还剩下％d'%self._money)

deftest(self):

self._shopping(200)#_shopping方法也只能在对象内部使用

p=Person('张18)#print(p._money)这里.会报错,