PYTHON学习笔记-DAY-6

Posted 2020-08-05

编程范式

编程是 程序 员 用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 ， 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路， 大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程。

面向过程编程(Procedural Programming)
Procedural programming uses a list of instructions to tell the computer what to do step-by-step. 
面向过程编程依赖 - 你猜到了- procedures，一个procedure包含一组要被进行计算的步骤， 面向过程又被称为top-down languages， 就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题 。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改， 举个例子，如果程序开头你设置了一个变量值 为1 ， 但如果其它子过程依赖这个值 为1的变量才能正常运行，那如果你改了这个变量，那这个子过程你也要修改，假如又有一个其它子程序依赖这个子过程 ， 那就会发生一连串的影响，随着程序越来越大， 这种编程方式的维护难度会越来越高。 
所以我们一般认为， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。

 

面向对象编程

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

面向对象的几个核心特性如下

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

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

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

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

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

 

class Role():
    n=123 #类变量 大家共用的属性，节省内存空间
    name=‘我是类名称‘
    n_list=[]
    def __init__(self,name, role,weapon, money,value):
        #构造函数
        #实例变量(静态属性)的作用域就是实例本身
        self.name=name
        self.role=role
        self.weapon=weapon
        self.money=money
        self.__value=value
    def buy_gun(self,gun_name):#类的方法，功能（动态属性）
        print(‘%s bought a %s‘%(self.name,gun_name))
    def got_shot(self):
        print(‘%s has been shot‘, self.name)

    def show_status(self):
        print(‘name: %s value:  %s ‘%(self.name,self.__value))

    def got_shot(self):
        print(‘%s has been shot‘, self.name)
    #
    # 析构函数：在实例释放，销毁的时候执行的，通常用于收尾工作
    # 如：关闭数据库连接，打开的文件
    def __del__(self):
        print(‘%s彻底死了。。。。。‘%self.name)


# #实例化，Role这个类的实例
r1=Role(‘ala11‘,‘police‘,‘AK47‘,‘2500‘,‘15000‘)
r2=Role(‘ala22‘,‘terriost‘,‘AK47‘,‘500‘,‘5000‘)
# r1.got_shot()
# r1.buy_gun(‘AK47‘)
#
# r1.bullet_pro = True
#
# print(r1.bullet_pro)
# print(Role)
# print(Role.n)
# print(r1.n,r1.name)
# print(r2.n,r2.name)
#
# r1.name=‘newala‘
# r1.n=‘新的类变量‘
#
# print(r1.name,r2.name,Role.name)
# print(Role.n,r1.n,r2.n)
#
# del r1.n
#
# print(Role.n,r1.n,r2.n)
#
# r1.n_list.append(‘from r1‘)
# r2.n_list.append(‘form r2‘)
#
# print(Role.n_list,r1.n_list,r2.n_list)

#析构函数测试
# print(r1.name,r2.name)
# del r1

#私有属性 self.__value=value
#print(r1.__value) 类外部不可见，但是可以被类方法调用
r1.show_status()

#私有方法  def __show_status(self):
#r1.__show_status()
r1.got_shot()

# Author AlleyYu
#继承


class People():
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def sleep(self):
        print(‘sleep————‘)
    def eat(self):
        print(‘eat————‘)

class Relation(object):
    def makefriends(self,obj):
        print(‘%s is make friens with %s‘%(self.name, obj.name))
        self.friends.append(obj.name)

class woman(People,Relation):


    def shopping(self):
        print(‘shopping‘)

class man(People,Relation):
    friends = []
    def Detac(self):
        print(‘挖煤‘)

w1=woman(‘whaha‘,29)
m1=man(‘mlala‘,22)
w1.makefriends(m1)
#-------------------------------------------------------friends 列表
m1.name=‘aaaa‘
#print(m1.friends[0])

# Author AlleyYu

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

    def test(self):
        pass


class Student(SchoolMember):
    def __init__(self,name,age,sex,stu_id,tution,course):
        super(Student,self).__init__(name,age,sex)
        self.tution=tution
        self.course=course
        self.stu_id=stu_id
    def tell(self):
        print( ‘‘‘
        ---------------info of student %s--------------
        name: %s
        age %s
        sex: %s
        id: %s
        tution: %s
        course: %s

        ‘‘‘%(self.name,self.name,self.age,self.sex,self.stu_id,self.tution,self.course))


    def course(self):
        print(‘%s is study %s‘%(self.name,self.course))


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 course(self):
        print(‘%s is study %s‘ % (self.name, self.course))


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

    def enroll(object):
        print(‘%s 学生注册‘,object.name )

    def hire(object):
        print(‘%s 老师入职‘, object.name)


s1=Student(‘alley‘,11,‘Female‘,1001,5000,‘pyhton‘)
s2=Student(‘tongtong‘,1,‘Female‘,1002,5000,‘pyhton‘)

t1=Teacher(‘luban‘,55,‘Male‘,500000,‘Pyhton‘)
school=School(‘51CTO‘,‘beijing‘)

s1.tell()
t1.course()
school.enroll(s1)
school.hire(t1)

# Author AlleyYu

# 多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
# 那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
#
# Pyhon不直接支持多态，但可以间接实现

class Animal:
    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):
        return ‘Meow!‘


class Dog(Animal):
    def talk(self):
        return ‘Woof! Woof!‘


animals = [Cat(‘Missy‘),
           Dog(‘Lassie‘)]

for animal in animals:
    print(animal.name + ‘: ‘ + animal.talk())