python--面向过程 VS 面向对象

Posted 2020-11-19 wangzihong

编程范式

编程:程序 员 用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程

程序:是程序员为了得到一个任务结果而编写的一组指令的集合

编程范式:实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别

两种最重要的编程范式分别是面向过程编程和面向对象编程。

面向过程编程(Procedural Programming)

Procedural programming uses a list of instructions to tell the computer what to do step-by-step.

基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改

所以我们一般认为， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。

面向对象编程

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述,使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单

面向对象的几个核心特性:

Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

模板，一个类建一个模板

#建一个类
class Role(object): #类名
    n = 1 #类变量
    name = ‘class‘
    n_list = []
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name #r1.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

      def shot(self): #类的方法（功能 动态属性）
          print("shooting...")
      def got_shot(self):
          print("ah...,I got shot...")
      def buy_gun(self,gun_name):
          print("just bought %s" %gun_name)

print(Role.n)

#实例化：把一个类变成一个对象的过程
r1 = Role(‘python‘,‘police‘,‘AK47‘) #实例化-初始化一个类-生成一个对象
r1.name = ‘A‘ #更改实例变量
r1.bullet_prove = True #给实例加一个新的属性
print(r1.weapon)
del r1.weapon #删除实例变量
r1.n = ‘change‘ #改变类变量 在r1的内存中加了一个变量n
print(Role.n)
r1.n_list.append("from r2")

print(Role.n,r1.name,r1.bullet_prove)
r2 = Role(‘java‘,‘terrorist‘,‘B22‘) #生成一个角色 得到一个对象又叫类的实例
r2.name = ‘B‘
print(Role.n,r2.name) #name先找实例本身变量再找类变量
print(r2.n,r1.n) #改变r1的n r2的n不改变
Role.n = ‘ABC‘ #会影响r2
print(r1.n,r2.n)

#实例化一个类传参数只能通过__init__
def __init__(self):
    #名称：构造函数
    #作用：实例化时做一些类的初始化的工作
    self.name  #赋给实例 实例变量（静态属性） 作用域：实例本身

类变量的用途：大家共用的属性，节省开销

class Person:
    cn = "china"
    def __init__(self,name,age,addr):
        self.name = name
p1 = Person(‘python‘,‘33‘,‘shanghai‘)

 

析构函数：在实例释放或销毁的时候执行的，通常用于做一些结尾工作（如：关闭一些数据库连接打开的临时文件）。

class Role(object): #类名
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name #r1.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
    def __del__(self):
        print("%s die..."%self.name)
    def shot(self): #类的方法（功能 动态属性）
        print("shooting...")
    def got_shot(self):
        print("ah...,I got shot...")
    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))
r1 = Role(‘python‘,‘police‘,‘AK47‘)
r1.buy_gun("AK47")
del r1
r2 = Role(‘java‘,‘police‘,‘mb5‘)
r2.got_shot()

私有方法，私有属性（只能自己访问）

class Role(object): #类名
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name #r1.name = name
        self.role = role
        self.weapon = weapon
        #self.life_value = life_value
        self.__life_value = life_value #变成私有属性
        self.money = money
    def __del__(self):
        print("%s die..."%self.name)
    def show_status(self):
        print("name:%s life_value:%s"%(self.name,self.__life_value))
    def shot(self): #类的方法（功能 动态属性）
        print("shooting...")
    def __got_shot(self): #私有方法
        print("ah...,I got shot...")
    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))
r1 = Role(‘python‘,‘police‘,‘AK47‘)
r1.buy_gun("AK47")
print(r1.show_status())
r2 = Role(‘java‘,‘police‘,‘mb5‘)
r2.got_shot()

 

Object 对象
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

#class People: 经典类
class People(object): #新式类 
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s is eating..." %self.name)
    def sleep(self):
        print("%s is sleeping..."%self.name)
    def talk(self):
        print("%s is talking..."%self.name)

class Man(People):
    def __init__(self,name,age,money): #重构子类
        People.__init__(self,name,age) #调用父类方法一
        super(Man,self).__init__(name,age) #调用父类方法二 新式类写法
        self.money = money #money在子类实现
        print("%s chushihua money"%self.money)
    def drink(self):
        print("%s is drink..."%self.name)
    def sleep(self): #先执行父类再执行子类 父类重构
        People.sleep(self) #需要加self
        print("man is sleeping...")

class Woman(People):
    def get_birth(self):
        print("%s is baby..."%self.name)

m1 = Man("A",33,888)
m1.eat() #继承父类
m1.drink()
m1.sleep()
w1 = Woman("B",33)
w1.get_birth()

#多继承
#class People: 经典类
class People(object): #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s is eating..." %self.name)
    def sleep(self):
        print("%s is sleeping..."%self.name)
    def talk(self):
        print("%s is talking..."%self.name)

class Relation():
    def make_friend(self,obj):
        print("%s is makeing friends with %s"%(self.name,obj.name))

class Man(People,Relation):
    def __init__(self,name,age,money): #重构子类
        People.__init__(self,name,age) #调用父类方法一
        super(Man,self).__init__(name,age) #调用父类方法二 新式类写法
        self.money = money #money在子类实现
        print("%s chushihua money"%self.money)
    def drink(self):
        print("%s is drink..."%self.name)
    def sleep(self): #先执行父类再执行子类 父类重构
        People.sleep(self) #需要加self
        print("man is sleeping...")

class Woman(People,Relation):
    def get_birth(self):
        print("%s is baby..."%self.name)

m1 = Man("A",33,888)
w1 = Woman("B",33)
m1.make_friend(w1)

 新式类和经典类的区别主要在多继承上面。

 新式类和经典类的继承顺序

广度优先（pthon3经典类和新式类统一都是按广度优先继承的）

深度优先（pthon2中经典类是按深度优先继承，新式类是按广度优先继承的class A(object)）

#新式类和经典类继承顺序
class A:
    def __init__(self):
        print("A")
class B(A):
    pass
    # def __init__(self):
    #     print("B")
class C(A):
    def __init__(self):
        print("C")
class D(B,C):
    pass
    # def __init__(self):
    #     print("D")
obj = D()

继承程序练习

class School(object):
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.students = []
        self.teachers = []
        self.staffs = []
    def enroll(self,stu_obj):
        print("为学员%s 办理注册手续"%stu_obj.name)
        self.students.append(stu_obj)
    def hire(self,staff_obj):
        self.staffs.append(staff_obj)
        print("雇佣新员工%s"%staff_obj.name)

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        pass

class Teacher(SchoolMember):
    def __init__(self,name,age,sex,salary,coures):
        super(Teacher,self).__init__(name,age,sex)
        self.salary = salary
        self.course = coures
    def tell(self):
        print(‘‘‘
        ---info of Teacher:%s---
        name:%s
        Age:%s
        Sex:%s
        Salary:%s
        Course:%s
        ‘‘‘%(self.name,self.name,self.age,self.sex,self.salary,self.course))

    def Teach(self):
        print("%s is teaching course [%s]"%(self.name,self.course))
class Student(SchoolMember):
    def __init__(self,name,age,sex,stu_id,grade):
        super(Student,self).__init__(name,age,sex)
        self.stu_id = stu_id
        self.grade = grade

    def tell(self):
        print(‘‘‘
        ---info of Student:%s---
        name:%s
        Age:%s
        Sex:%s
        Stu_id:%s
        Grade:%s
        ‘‘‘%(self.name,self.name,self.age,self.sex,self.stu_id,self.grade))

    def pay_tuition(self,amount):
        print("%s has pay tuition for $%s"%(self.name,amount))

school = School("Python IT","shanghai")
t1 = Teacher(‘A‘,33,‘M‘,8888,‘python‘)
t1 = Teacher(‘B‘,33,‘M‘,6666,‘linux‘)
s1 = Student("S1",22,‘M‘,‘001‘,‘python‘)
s1 = Student("S2",23,‘F‘,‘002‘,‘python‘)

t1.tell()
s1.tell()
school.hire(t1)
school.enroll(s1)
print(school.students)
print(school.staffs)
school.staffs[0].Teach()
for stu in school.students:
    stu.pay_tuition(5000)

 

Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针

Python多态示例：

class Animal(object):
    def __init__(self, name): # Constructor of the class
        self.name = name

    def talk(self):# Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        print(‘%s: 喵喵喵!‘ %self.name)

class Dog(Animal):
    def talk(self):
        print(‘%s: 汪！汪！汪！‘ %self.name)

def func(obj): #一个接口，多种形态
    obj.talk()

c1 = Cat(‘A‘)
d1 = Dog(‘B‘)

func(c1)
func(d1)