16_python_面向对象

2022-10-19 20:19:13

一、面向对象和面向过程的区别

1、面向对象：一切以对象为中心。有相同属性和动作的结合体叫做对

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低

2、面向过程：一切以实物的流程为中心

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

二、面向对象的编写

 class Car:     #  class是关键字，表示类

     def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建 的是谁, 谁来访问的这个方法.那这个self就是谁.

             self.color = color

             self.pai = pai

             self.pailiang = pailiang

     def run(self, speed):

             print("车可以跑%s迈" % speed)

 c = Car("red", "京A66666", "2.0T")   # 创建对象，类名称后加括号即可，即为实例化

 c.run(100) # 这时. python会自动把对象c传递给run方法的第一个参数位置.

　　1、面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

　　2、类中的函数第一个参数必须是self（详细见：类的三大特性之封装）；类中定义的函数叫做 “方法”

　　实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

 class 类名:

     def __init__(self,参数1,参数2):

         self.对象的属性1 = 参数1

         self.对象的属性2 = 参数2

     def 方法名(self):pass

     def 方法名2(self):pass

 对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西

                   #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法

                   #括号里传参数，参数不需要传self，其他与init中的形参一一对应

                   #结果返回一个对象

 对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可

 对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

三、面向对象的三大特征 -- 封装、继承和多态

1、封装

封装: 把很多数据封装到一个对象中. 把固定功能的代码封装到一个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了一个很牛B 的函数. 那这个也可以被称为封装. 在面向对象思想中. 是把一些看似无关紧要的内容组合到一起统一进行行存储和使用. 这就是封装.

2、继承

(1) 单继承

子类可以自动拥有父类中除了私有属性外的其他所有内容

class DerivedClassName(BaseClassName1):

    <statement-1>

    . . .

    <statement-N>

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含方法

 #类定义

 class people:

     #定义基本属性

     name = ''

     age = 0

     #定义私有属性,私有属性在类外部无法直接进行访问

     __weight = 0

     #定义构造方法

     def __init__(self,n,a,w):

         self.name = n

         self.age = a

         self.__weight = w

     def speak(self):

         print("%s 说: 我 %d 岁。" %(self.name,self.age))

 #单继承示例

 class student(people):

     grade = ''

     def __init__(self,n,a,w,g):

         #调用父类的构函

         people.__init__(self,n,a,w)

         self.grade = g

     #覆写父类的方法

     def speak(self):

         print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

 s = student('ken',10,60,3)

 s.speak()

 结果：

 ken 说: 我 10 岁了，我在读 3 年级

(2) 多继承

class DerivedClassName(Base1, Base2, Base3):

    <statement-1>

     . . .

    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。(MRO算法)

 #类定义

 class people:

     #定义基本属性

     name = ''

     age = 0

     #定义私有属性,私有属性在类外部无法直接进行访问

     __weight = 0

     #定义构造方法

     def __init__(self,n,a,w):

         self.name = n

         self.age = a

         self.__weight = w

     def speak(self):

         print("%s 说: 我 %d 岁。" %(self.name,self.age))

 #单继承示例

 class student(people):

     grade = ''

     def __init__(self,n,a,w,g):

         #调用父类的构函

         people.__init__(self,n,a,w)

         self.grade = g

     #覆写父类的方法

     def speak(self):

         print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

 #另一个类，多重继承之前的准备

 class speaker():

     topic = ''

     name = ''

     def __init__(self,n,t):

         self.name = n

         self.topic = t

     def speak(self):

         print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

 #多重继承

 class sample(speaker,student):

     a =''

     def __init__(self,n,a,w,g,t):

         student.__init__(self,n,a,w,g)

         speaker.__init__(self,n,t)

 test = sample("Tim",25,80,4,"Python")

 test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

 结果：

 我叫 Tim，我是一个演说家，我演讲的主题是 Python

(3) 方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

 class Parent:        # 定义父类

    def myMethod(self):

       print ('调用父类方法')

 class Child(Parent): # 定义子类

    def myMethod(self):

       print ('调用子类方法')

 c = Child()          # 子类实例

 c.myMethod()         # 子类调用重写方法

 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

3、多态

多态: 同一个对象, 多种形态. 这个在python中其实是很不容易说明白的. 因为我们一直在用. 只是没有具体的说. 比如. 我们创建一个变量a = 10 , 我们知道此时a是整数类型. 但是我们可以通过程序让a = "alex", 这时, a又变成了字符串类型. 这是我们都知道的. 但是, 我要告诉你的是. 这个就是多态性. 同一个变量a可以是多种形态.

 class Animal:

     def chi(self):

         print("动物就知道吃")

 class Pig(Animal):

     def chi(self):

             print("猪在吃")

 class Haski(Animal):

     def chi(self):

             print("哈?士奇在吃")

 class Alasika(Animal):

     def chi(self):

         print("阿拉斯加在吃")

 class SiYangYuan:

     def yanng_animal(self, ani):

         ani.chi()

 zhu = Pig()

 erha = Haski()

 ala = Alasika()

 alex = SiYangYuan()

 alex.yanng_animal(zhu)

 alex.yanng_animal(erha)

 alex.yanng_animal(ala)

程序具有超高的可扩展性. 面向对象思想的核心与灵魂. python自带多态

四、类对象补充

 一：我们定义的类的属性到底存到哪里了？有两种方式查看

 dir(类名)：查出的是一个名字列表

 类名.__dict__:查出的是一个字典，key为属性名，value为属性值

 二：特殊的类属性

 类名.__name__# 类的名字(字符串)

 类名.__doc__# 类的文档字符串

 类名.__base__# 类的第一个父类(在讲继承时会讲)

 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)

 类名.__dict__# 类的字典属性

 类名.__module__# 类定义所在的模块

 类名.__class__# 实例对应的类(仅新式类中)

码农公寓

相关文章