Python 全栈开发七 面向对象

一、编程范式

　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 ， 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式，也可以将编程范式理解为武功秘籍，现在常见的编程范式有：面向过程编程，函数式编程，面向对象编程。

• 面向过程：指的是实现任务时从上到下一步步执行，从头至尾解决问题，将大问题分解成若干个小问题，将小问题继续分解直到问题可以被解决为止。总的来说就是：自顶向下，逐步求精。
• 函数式编程：就是数学意义上的函数和编程语言上的函数的结合。(也可以理解为，有返回值的函数编程)
• 面向对象编程：OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述。也可以理解为，是对象属性和方法封装在一起的思想。

电影霍元甲有一句话：没有最强的武功，只有最强的人。

编程范式也是如此，没有最好的方式，只有最好的程序员，三种编程范式各有各的有点，不同的是使用的人而已。

二、面向过程编程

比如：学生早上起床这件事情来说

• 起床
• 穿衣
• 洗脸刷牙
• 去学校

 def getup(name):
     print(" %s 起床" % name)

 def cloth(name):
     print(" %s 穿衣" % name)

 def washtooth(name):
     print(" %s 洗脸刷牙" % name)

 def go_school(name):
     print(" %s 去学校" % name)

 gt = getup("wallace")
 cl = cloth("wallace")
 sa = washtooth("wallace")
 gs = go_school("wallace")

将起床去学校，化简为一个一个小问题，由上而下的执行。

三、函数式编程

函数式编程代码简洁，但相对来说不易理解：

 def foo(name):
     print("name")

 def fun(func):
     return func

 a = fun(foo("wallce"))

四、面向对象设计

对于Python来说是一门纯面向对象的语言，有class方法来定义类，但是这不意味着面向对象设计就是用class定义类这种方式来编程。

例如：

 def student(name,age,school):
     def init(name,age,school):
         stu={
             "stu_name":name,
             "stu_age":age,
             "stu_school":school,
             "go_school":go_school,
             "do_homework":do_homework
         }
         return stu

     def go_school(student):
         print("%s 去 %s 上学" %(student["stu_name"],student["stu_school"]))

     def do_homework(name):
         print("%s 正在做作业" % name)

     return init(name,age,school)

 wallace = student("wallace",18,"浙江大学")
 name = wallace["stu_name"]
 esc = wallace["go_school"](wallace)

以上就是一个面向对象设计思想实现的一个学生对象。即面向对像设计思想，将同一对象的属性和方法进行封装。

对应面向对象而言：世界万物，皆可分类；世界万物，皆为对象；只要是对象，就肯定属于某种品类；只要是对象，就有属性。

五、Python面向对象语言

面向对象常见的特性：

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

Object 对象 
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

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

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

Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

六、类的进阶

1、定义类

 '''
 在定义学生类的时候，我们考虑到学生有姓名，年龄等
 就个学生统一的属性和方法
 '''

 class student(object):  #定义一个学生类
     def __init__(self,name,age):
         self.name = name      #学生的属性
         self.age = age
     def learning(self):       #学生的方法
         print("%s is learning" % self.name)

 Wallace= student("wallace",18)  #创建一个学生实例，根据传入参数的不同，学生也就不同
 print(Wallace.name)    #调用学生的属性
 Wallace.learning()     #调用学生的方法

2.类的方法

类的内置方法一：

 class student(object):  #定义一个学生类
     '''
     这是一个学生类
     '''
     def __init__(self,name,age):
         self.name = name      #学生的属性
         self.age = age
     def learning(self):       #学生的方法
         print("%s is learning" % self.name)

 Wallace= student("wallace",18)  #创建一个学生实例，根据传入参数的不同，学生也就不同
 print(Wallace.name)    #调用学生的属性
 Wallace.learning()     #调用学生的方法

 print(student.__name__)    #student  返回的是对应的类名
 print(student.__doc__)     #打印文档字符串
 print(student.__bases__)   #返回基类
 print(student.__dict__)    #返回对应的属性以字典的形式
 print(student.__module__)  #返回对应的模块名
 #以上方法实例都可以使用
 print(Wallace.__dict__)    #返回实例对应的属性
 print(Wallace.__dict__['name']) #Wallace.name实际的调用就是Python内部使用了字典进行调用，若在
 #Wallace.__dict__字典里没有，就会去student.__dict__找对应的属性

类的内置方法二：

 class Dog(object):
     '''
     __doc__ 用于打印文档字符串
     '''

     def __del__(self):
         print('我自动删除了这实例')
     '''
     当实例的指向别删除，即没有变量指向该实例，就会触发该函数
     当程序运行结束时也会触发该函数，来删除内存中的实例对象
     '''
     def __call__(self, *args, **kwargs):
         print('对象加括号就可以触发')
     def __str__(self):
         print('在打印对象时，默认输出该方法的返回值')
         return 'str返回值'

类的特殊方法：

• 属性方法

 class student(object):  #定义一个学生类
     '''
     这是一个学生类
     '''
     def __init__(self,name,age):
         self.name = name      #学生的属性
         self.age = age
     def learning(self):       #学生的方法
         print("%s is learning" % self.name)
     @property
     def eat(self):
         print("%s is eating" % self.name)

 #@property的作用是更改类所定义方法的调用方式，使其的调用方变为类似调用普通类属性的方式

 wallace = student("wallace",18)
 wallace.eat

• 类方法

 class student(object):  #定义一个学生类
     '''
     这是一个学生类
     '''
     name = "wallace"
     def __init__(self,name,age):
         self.name = name      #学生的属性
         self.age = age
     def learning(self):       #学生的方法
         print("%s is learning" % self.name)
     @classmethod
     def eat(self):
         print("%s is eating" % self.name)

 #@classmethod类无法调用实例的属性，只能调用类里面定义的属性

 wallace = student("wallace",18)
 wallace.eat()

• 静态方法

 class student(object):  #定义一个学生类
     '''
     这是一个学生类
     '''
     name = "wallace"
     def __init__(self,name,age):
         self.name = name      #学生的属性
         self.age = age
     def learning(self):       #学生的方法
         print("%s is learning" % self.name)
     @staticmethod
     def eat(self):
         print("%s is eating" % self.name )

     @staticmethod
     def play(name):
         print("%s is playing" % name)

 #@staticmethod的装饰后，变成一个完全独立于类的方法，调用的时候不会调用自身,需要自己传入参数

 wallace = student("wallace",18)
 wallace.eat(wallace)
 wallace.play("wallace")

3、类的特性

类的特性：继承

 #class People:  老式类
 class People(object):  #带object的就是新式类
     def __init__(self,name,age):
         self.name = name
         self.age = age
         self.friends = []
         print("--doesn't run--")
     def eat(self):
         print("%s is eating..." % self.name)
     def talk(self):
         print("%s is talking..." % self.name)
     def sleep(self):
         print("%s is sleeping..."% self.name)

 class Relation(object):   #传入的是一个实例
     # def __init__(self,n1,n2):
     #     print("init is relation")
     def make_friends(self,obj):
         print("%s is making friends with %s" % (self.name,obj.name))   #实例调用属性
         self.friends.append(obj.name)
 class Man(Relation,People):
     # def __init__(self,name,age,money):    #当你需要重构构造函数是
     #    #People.__init__(self)            #这种无需知道基类的属性
     #     super(Man,self).__init__(name,age) #需要知道基类的属性
     #     self.money = money
     def piao(self):
         print("%s is piaoing...20s...done."% self.name)
     def sleep(self):
         People.sleep(self)
         print('Man is sleeping')
 class Woman(People,Relation):
     def get_borth(self):
         print("%s is borthing a baby..."% self.name)

 r = Man('qiang',23)    #根据新式类的广度优先继承，会报错
 r1 = Woman('wallace',24)
 r1.make_friends(r)
 r1.sleep()

新式类与经典类继承区别：

 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

 r = D()

 '''
 广度优先，即bca
 经典类py2：深度优先bac
 '''

多态

 class Animal:
     def __init__(self,name):
         self.name = name
     def talk(self):
         pass
     @staticmethod
     def animal_talk(obj):
         obj.talk()
 class Cat(Animal):
     def talk(self):
         print('meow')
 class Dog(Animal):
     def talk(self):
         print('wang')

 d = Dog('兰博')
 c = Cat('小米')

 Animal.animal_talk(d)

接下来是两个面向对象的例子：

 class Role:
     n = 123    #类变量
     n_list=[]
     name = '我是类name'
     def __init__(self,name,role,weapon,life_value=100,money=15000):
         #构造函数
         #是实例化时做一些类的初始化工作
         self.name = name  #实例变量，作用域就是当前实例本身
         self.role = role
         self.weapon = weapon
         self.__life_value = life_value #私有变量，外部不可以访问，只作用于内部
         self.money = money
     def __del__(self):
         #析构函数：在一实例的指向消失，或程序结束是进行删除
         print('%s 死了'% self.name) #del 关键字，可以删除一个变量的指向。
     def show_status(self):
         print('name:%s weapon:%s life_val:%s' % (self.name,self.weapon,self.__life_value))
     def __shot(self): # 类的私有方法，功能（属性）
         print('shooting...')
     def got_shot(self):
         self.__life_value -= 50
         print('%s:ah...,I got shot...' % self.name)
     def buy_gun(self,gun_name):
         print('%s just bounght %s'%(self.weapon,gun_name))

 role1 = Role('wallace','police','ak47')
 role1.buy_gun('98k')
 role1.got_shot()
 print(role1.show_status())

 class School(object):
     def __init__(self,name,addr):
         self.name = name
         self.addr = addr
         self.students = []
         self.teachers = []
     def enroll(self,stu_obj):
         print("为学员%s办理入学手续" % stu_obj.name)
         self.students.append(stu_obj)
     def hire(self,tec_obj):
         print("雇佣%s老师"%tec_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,course):
         super(Teacher,self).__init__(name,age,sex)
         self.salary = salary
         self.course = course
     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 is %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 coming pay tuition %s"% (self.name,amount))

 Sch1 = School('oldboy','北京')
 stu1 = Student('wallace','','m','','python')
 Sch1.enroll(stu1)
 stu1.pay_tuition(5000)
 print(Sch1.students)

3、反射

反射的作用是在我们仅提供字符串的前提下，如果通过给定字符串来判断一个类是否有与之对应的属性，并且访问这个属性等方便我们使用的作用。

 def bulk(self):
     print('%s is bulking' % self.name)

 class dog(object):
     def __init__(self,name):
         self.name = name

     def eat(self):
         print('[%s] is eating' % self.name)

 f = dog('wallace')
 print(hasattr(f,'name'))    #判断是否存在某属性，某方法，若存在则返回True,否则返回Flase
 gei = getattr(f,'name')   #获取对象中的某属性，某方法，方法不运行，要运行可以调用括号
 set1 = setattr(f,'age',22)    #设置一个属性，方法
 set3 = setattr(f,'bulk',bulk)
 print(getattr(f,'age'))
 set2 = setattr(f,'name','peilin')
 print(getattr(f,'name'))
 print(gei)

 delattr(f,'name')   #删除某一属性，或方法
 print(getattr(f,'name'))