python学习笔记--面向对象的编程和类

Posted 2020-09-27

一、面向对象的编程
    面向对象程序设计--Object Oriented Programming，简称oop，是一种程序设计思想。
二、面向对象的特性
类：class
类，对比现实世界来说就是一个种类，一个模型。
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。
在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法。

对象：object
对象，也就是指模型造出来的具体的东西。
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同。

实例化：
初始化一个类，造了一个对象。把一个类变成一个具体的对象的过程，叫做实例化。
以下是一段小代码讲解实例化和调用

 1 class BuyCar(object):
 2     def sale(self):
 3         print(‘卖车‘)
 4         return 100
 5     def insurance(self):
 6         print(‘买保险‘)
 7     def check(self):
 8         print(‘验车‘)
 9     def card(self):
10         print(‘选牌‘)
11     def pay(self):
12         print(‘付款‘)
13     def done(self):
14         print(‘上牌完成‘)
15 
16 me = BuyCar()
17 #实例化
18 r = me.sale()
19 接收函数返回值
20 print(r)
21 me.check()
22 me.card()
23 me.pay()
24 me.done()

# 如果是函数名加括号的话，调用函数
# 如果是类名加括号的话，实例化对象

封装：
把一些功能的实现细节不对外暴露，类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。
比如说造的一个人，你把他身体内部的什么心肝脾肺肾都封装起来了，其他人都看不到，你直接找这个人。

继承：
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。比如说你继承了你父亲的姓。

python3中多继承都是广度优先，python2中经典类的多继承是深度优先，新式类的多继承是按照广度优先的。

继承是为了代码的重用

多态：
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。

一种接口，多种实现。
三、类
一些概念：
属性：属性就是类里面的一个变量，有类变量和实例变量，类变量是类在定义的时候就有的，实例变量是在实例化的时候才产生的变量。这个可以理解为，人是一个类，他的名字、年龄、性别就是它的属性。

方法：方法就是类的功能，也就是定义在类里面的函数，它实现了某个功能，比如说人有睡觉的功能。

构造函数：什么是构造函数，就是类在实例化的时候做的某些初始化操作，比如说人，你造一个汽车的时候，它得有颜色、型号等等。

析构函数：析构函数就是这个实例在销毁的时候做的一些操作。

定义类：
定义类使用class关键字，类名一般我们开发的时候首字母要大写。python中有经典类和新式类，他俩在python3中没有区别，在python2中经典类在多继承的时候是深度优先，新式类是广度优先。python3中统一是广度优先，这个后面在说继承的时候会说。

 1 class Cay(object):
 2     # wheel = 4
 3     #类变量，所有的实例都可以使用
 4     def __del__(self):
 5         # 析构方法
 6         # 作用是对象被销毁时执行
 7         # 这个实例被销毁的时候执行的，也就是不在内存里面
 8         print(‘over、、、‘)
 9     def __init__(self,color,pl,pz):
10         #构造方法,是类在实例化对象的做的操作
11         #如果你想在类初始化的给它传一些参数，那么就要在
12         #构造方法里面写参数
13         self.color = color
14         #给实例化的对象添加属性
15         # 对象的color等于我传进来的color
16         self.pl = pl
17         self.pz = pz
18     #     这些都是实例变量
19     def run(self):
20         print(‘run‘)
21         print(‘汽车的颜色是：‘,self.color)
22     def driver(self):
23         #self就是代表实例化之后的这个对象，为了节省内存
24         #代表本类对象
25         print(‘driver‘)
26     def movie(self):
27         print(‘movie‘)
28     def p(self):
29         self.wheel = 8
30         print(self.wheel)
31 
32 ywn_car = Cay(‘red‘,‘5.0‘,‘悍马‘)
33 ywn_car.p()
34 ywb_car = Cay(‘red‘,‘5.0‘,‘悍马‘)
35 # print(ywb_car.wheel)

1.在此处说明一下self。在我们进行实例化的时候可以无穷无尽的实例化对象，在这个类里面所有的对象都有run，driver，movie和
p的功能，所有的功能都是一样的，但是这些color，pl，pz的属性可以是不一样的，如果每个对象实例化的时候都保存一遍这些公共
没变的东西就会特别浪费内存，就不需要对每一个实例化对象的时候对公共的功能进行定义。
那么如果不定义的话怎么知道究竟是谁调用的这些方法呢？所以用到了self。谁调用的话把谁传进去就行了。这样的话就知道是谁调用了。
所以把self传进去，self就是代表实例化之后的这个对象，使用self是为了节省内存。self作为必填参数在调用的时候不需要传，自动
会把这个对象加进去。也就是self代表的是本类对象.
2.__init__。这个叫做构造方法，实在类的实例化的时候做的操作，如果你想在类初始化的时候就给它传一些参数就要用到__init__了。
比如说我造汽车，你不给我说我哪知道你要什么样的汽车，所以这些东西你必须要先跟我说，想要实现这个就要使用__init__。
在self里面的写的东西，不论在哪都能用点能点出来
3.object是基类。实例化，在内存中存储，都是通过object来实现的
4.__del__。这个叫做析构方法，实例被销毁时所执行的。当程序执行完，对象才会被销毁掉。那么这个方法什么时候能用到呢？比如在关数据库连接的时候，当数据库不用了
的时候这个类运行后就会自动关了。
5.类变量：在类里面定义的变量就是类变量，类变量是所有的实例变量都能用，相当于公共的。用的时候还是self.wheel，和实例变量一样

通过下面这段代码介绍一下私有方法和私有变量，变量名前面加两个下划线就是私有变量,方法名前面加两个下划线就是私有变量.

 1 import xlrd
 2 class ReadCase(object):
 3     __name=‘haha‘
 4     # 私有变量
 5     # 类变量,只能在类里面访问,出了类就不行了
 6     def __init__(self,f_name):
 7         self.fname=f_name
 8     def __set(self):
 9         self.money=1999999
10     #    私有方法就是在函数名前面加俩下划线,只能在类里面调用,出了类访问不了
11         print(‘这个是私有方法:‘,self.money)
12     def read_case(self):
13           self.__set()
14         # book=xlrd.open_workbook(self.fname)
15         print(‘私有变量name的值:‘,self.__name)
16         self.__name=‘panyang‘
17         print(‘私有变量name的值:‘, self.__name)
18 r=ReadCase(‘a.xls‘)
19 # print(r.__name)     这句报错
20 r.read_case()
21 # print(r.name)
22 r.__set()
23 # 私有变量只能在类里面使用,出了类就不能用了
24 # 所有的私有方法和私有类,出了这个类就用不了了

面向对象的三大特点:封装,继承,多态
封装:就相当于给你封装好了功能,你看不见,只能用.
继承：
继承就是父类有的方法，子类都可以用。看一下下面这段代码：

 1 class Person(object):
 2     def __init__(self,name,sex):
 3         self.name=name
 4         self.sex=sex
 5     def Cry(self):
 6         print(‘%s[哭]‘%self.name)
 7 class Man(Person):
 8     def Work(self):
 9         print(‘working‘)
10 class Women(Person):
11     def shopping(self):
12         print(‘shopping‘)
13 class Children(Man,Women):    # 多继承
14     pass
15 panyang=Women(‘panyang‘,‘nv‘)
16 panyang.shopping()
17 panyang.Cry()

那么问题来了,如果继承的两个父类有相同的属性,那继承的是哪个父类的属性呢?看下面的代码:

 1 class A(object):
 2     def say(self):
 3         print(‘A‘)
 4 class B(A):
 5     def say(self):
 6         print(‘B‘)
 7 class C(A):
 8     def say(self):
 9         print(‘c‘)
10 class D(C, B):
11     pass
12 d = D()
13 d.say()

python3里面多继承的时候，都是广度优先
python2里面多继承的时候，如果用的是经典类，那么是深度优先；如果是新式类的话，是广度优先。深度优先和广度优先会在下一篇博客里面说到。

多态：
在python里面没有多态，不能直接实现多态，但是可以间接实现多态，代码如下：

 1 class Person(object):
 2     def __init__(self,name,sex):
 3         self.name=name
 4         self.sex=sex
 5     def Cry(self):
 6         print(‘%s[哭]‘%self.name)
 7 class Man(Person):
 8     def Work(self):
 9         print(‘working‘)
10 class Women(Person):
11     def shopping(self):
12         print(‘shopping‘)
13 class Children(Man,Women):
14     pass
15 panyang=Women(‘panyang‘,‘nv‘)
16 panyang.shopping()
17 panyang.Cry()
18 python间接实现多态

修改父类的方法:

 1 class Animal(object):
 2     def __init__(self,name):
 3         self.name = name
 4         print(‘这个是animal里面的init‘)
 5 class Cat(Animal):
 6     def speak(self):
 7         print(‘喵喵喵‘)
 8 class Dog(Animal):
 9     #在父类方法的基础上添加新功能
10     def __init__(self,name,color):
11         # 在重写父类方法的时候，先要调用一下父类的这个方法
12           把父类里面的方法重写了,如果子类里面重写了父类的方法就直接调用子类重写的方法
13         Animal.__init__(self,name)
14         #把父类里面的方法重写
15         #如果子类里面重写了父类的方法，那么直接调用子类的重写后的方法
16         self.color = color
17     def speak(self):
18         print(‘【%s】汪汪汪‘%self.name,self.color)
19 xh = Dog(‘小黑‘,‘black‘)
20 xh.speak()
21 一种方法，多种实现
22 c1 = Cat()
23 d1 = Dog()
24 obj = [c1,d1]
25 for i in obj:
26     i.speak()

下面再说一下静态方法和类方法:

 1 class Stu(object):
 2     country = ‘china‘  # 类变量
 3     def __init__(self, name):
 4         self.name = name
 5     @staticmethod
 6     # 静态方法和普通的函数没有任何区别,只不过是写在类里面而已
 7     # 静态方法，和类本身没有什么关系了，就相当于在类里面定义了一个方法而已
 8     def say():
 9         print(‘xxx‘)
10     @classmethod
11     # 类方法
12     # 静态方法，和类方法不同的是，它可以使用类变量，必须要传一个值，代表的就是这个类
13     def hello(cls):
14         print(cls.country)
15     def hi(self):
16         # 这个是实例方法
17         print(self.name)
18 t = Stu(‘name‘)
19 Stu.hello()
20 Stu.say()
21 t.hi()   # 类方法可以不进行实例化,直接调用
22 t.say()
23 t.hello()