当前位置: 澳门新濠3559 > 操作系统 > 正文

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

时间:2019-12-26 00:20来源:操作系统
  一、面向过程 VS 面向对象  s1 =Student( "SanJiang" , 24 , "Female" , "python" , 15000 ) s2 =Student( "BaoAn" , 23 , "F" , "python" , 5000 ) 面向过程编程(Procedural Programming)      Procedural programming uses a list o

          图片 1

一、面向过程 VS 面向对象 

     s1 = Student("SanJiang",24,"Female","python",15000)
     s2 = Student("BaoAn",23,"F","python",5000)

面向过程编程(Procedural Programming)

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

    根据业务逻辑从上到下写垒代码。基本设计思路就是程序一开始是要着手解决一个大的问题,然后把一个大问题分解成很多个小问题或子过程,这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。   

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

         5>反射的妙用:

编程范式

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

      if __name__ =="__main__":
        server = WebServer('localhost',333)
        *#print(sys.argv[1])
        *if hasattr(server,sys.argv[1]):
          func = getattr(server,sys.argv[1])
#获取server.start内存地址
          func()
*#server.start()
        # setattr(server,"run",test_run) #类的实例,属性,方法名
        # server.run(server,"che")

Python-Day6 面向对象,python-day6

                        图片 2

二、面向对象三大特性:封装、继承和多态

        图片 3 

2.继承

    它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展

 图片 4

#!/usr/bin/python3  

#类定义  
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,grade):  
        #调用父类的构函  
        people.__init__(self,n,a,w)  
        self.grade = grade
    #覆写父类的方法  
    def speak(self):  
        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)  
s.speak()

图片 5 1 class SchoolMember(object): 2 members = 0 #初始学校人数为0 3 def __init__(self,name,age): 4 self.name = name 5 self.age = age 6 7 def tell(self): 8 pass 9 10 def enroll(self): 11 '''注册''' 12 SchoolMember.members +=1 13 print("33[32;1mnew member [%s] is enrolled,now there are [%s] members.33[0m " %(self.name,SchoolMember.members)) 14 15 def __del__(self): 16 '''析构方法''' 17 print("33[31;1mmember [%s] is dead!33[0m" %self.name) 18 class Teacher(SchoolMember): 19 def __init__(self,name,age,course,salary): 20 super(Teacher,self).__init__(name,age) 21 self.course = course 22 self.salary = salary 23 self.enroll() 24 25 26 def teaching(self): 27 '''讲课方法''' 28 print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12')) 29 30 def tell(self): 31 '''自我介绍方法''' 32 msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course) 33 print(msg) 34 35 class Student(SchoolMember): 36 def __init__(self, name,age,grade,sid): 37 super(Student,self).__init__(name,age) 38 self.grade = grade 39 self.sid = sid 40 self.enroll() 41 42 43 def tell(self): 44 '''自我介绍方法''' 45 msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy') 46 print(msg) 47 48 if __name__ == '__main__': 49 t1 = Teacher("Alex",22,'Python',20000) 50 t2 = Teacher("TengLan",29,'Linux',3000) 51 52 s1 = Student("Qinghua", 24,"Python S12",1483) 53 s2 = Student("SanJiang", 26,"Python S12",1484) 54 55 t1.teaching() 56 t2.teaching() 57 t1.tell() 继承实例

  在多继承中从父类继承初始化属性时,顺序从左到右开始初始化,只要初始化到属性数据就不再向后继续,所以越往前越优先;当父类有初始化,子类也有初始化时,执行子类的初始化,父类的不生效。

# 类的继承-多继承

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)

class Relation(object):
    def make_friends(self,obj):
        print("%s is making friends with %s"%(self.name,obj.name))

class Man(Relation,People):             #多继承
    def play(self):
        print("%s is playing...." % self.name)

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

m1 = Man("lianzhilie", 22)
w1 = Woman("Alex", 33)

m1.make_friends(w1)
#lianzhilie is making friends with Alex

    经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了跟多的功能,也是之后推荐的写法,从写法上区分的话,如果 当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。

#经典类

class A():
    def __init__(self):
        print("A")
class B(A):
    pass

class C(A):
    def __init__(self):
        print("C")

class D(B,C):
    pass

obj = D()
#A


#新式类

class A(object):
    def __init__(self):
        print("A")

class B(A):
    pass

class C(A):
    def __init__(self):
        print("C")

class D(B,C):
    pass

obj = D()
#C

 经典类在python2.X中为深度优先,新式类广度优先。

图片 6

*        import sys         class WebServer(object):           def** __init__(self,host,port):
            self.host = host
            self.port = port

面向对象编程

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

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

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

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

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

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

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

                     图片 7

1.封装

    封装最好理解了。封装是面向对象的特征之一,是对象和类概念的主要特性。

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

 

    很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法(构造方法),像下面这样:

>>> class Foo:
    def __init__(self,name,age):   #构造方法,根据类创建对象时自动执行
        self.name = name
        self.age = age

>>> obj1 = Foo('小明',12) #将小明和12放到obj1/self的name和age中
>>> obj2 = Foo('小花',10)
#self 是一个形式参数,当执行 obj1 = Foo('小明',12) 时,self 等于 obj1
  当执行 obj2 = Foo('小花',10) 时,self 等于 obj2
>>> print (obj1)
<__main__.Foo object at 0x0000000003164A90> #内存地址
#通过对象直接调用被封装的内容,对象.属性名
>>> print (obj1.name)
小明
>>> print (obj1.age)
12
>>> print ( obj2.name,obj2.age)
小花 10

  #通过self间接调用被封装的内容

  #执行类中的方法时,需要通过self间接调用被封装的内容

 

class Foo:

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

    def detail(self):
      print self.name
      print self.age

obj1 = Foo('小明',12) 

obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 小明 ;self.age 是 12

类的方法:

#!/usr/bin/python3  

#类定义  
class people:  
    #定义基本属性  
    name = ''  
    age = 0  
    #定义私有属性,私有属性在类外部无法直接进行访问  
    __weight = 0  
    #定义构造方法  
    def __init__(self,name,age,weight):  
        self.name = name  
        self.age = age
        self.__weight = weight  
    def speak(self):  
        print("%s 说: 我 %d 岁。" %(self.name,self.age))  

# 实例化类  
p = people('小明',10,30)  
p.speak()
print (p.weight)

 

                            图片 8

3.多态

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

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

    @staticmethod
    def animal_talk(obj):
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('%s:Meow!'%(self.name))

class Dog(Animal):
    def talk(self):
        print('%s:Woof! Woof!'%(self.name))

c = Cat('Missy')
d = Dog('Lassie')

Animal.animal_talk(c)
Animal.animal_talk(d)

# Missy:Meow!
# Lassie:Woof! Woof!

 

面向对象,python-day6 一、面向过程 VS 面向对象 编程范式 编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何...

                            类的属性,将方法变为属性:

       t1.tell()
       t1.teaching()
       s1.tell()
       s1.pay_tuition()***

                            图片 9

        3>类的继承:
        class SchoolMember(object):
            membur_nums = 0
        def __init__(self,name,age,sex):
          self.name = name
          self.age = age
          self.sex = sex
          self.enroll()
        def enroll(self):
          SchoolMember.membur_nums +=1
    # print("33[32:1m The [%s] memburs SchoolMember [%s] is enrolled!33[0m" %(self.membur_nums,self.name))
          print("The [%s] memburs SchoolMember [%s] is enrolled!"
*% (**self*.membur_nums, *self**.name))
      def tell(self):
            print(
"Hello my name is %s"%self.name)
      class Teacher(SchoolMember):       def __init__(self,name,age,sex,course,salary):
        super(Teacher,self).__init__(name,age,sex)
        self.course = course
        self.salary = salary       
def teaching(self):
        print(
"Teacher [%s] is teaching [%s]"%(self.name,self.course))
      class Student(SchoolMember):       def __init__(self,name,age,sex,course,tuition):
        super(Student,self).__init__(name,age,sex)
        self.course = course
        self.tuition = tuition       
def pay_tuition(self):
        print(
"cao,student [%s] paying tuition [%s]"%(self.name,self.tuition))
       t1 = Teacher("Alex",22,'F',"PY",1000)
     t2 = Teacher("Tenglan",25,'N/A',"PY",900)

        4)__dict__ 以字典形式遍历出类下的所有变量;

                          给属性设置值:

        # delattr(server,"host") #删除实例中的对象
        # print(server.host)

        delattr(WebServer,"start"**)#删除类中的方法
          print(server.restart())         # cmd_dic = {
            # "start":server.start,
            # "stop":server.stop,
            # "restart":server.restart,
            # }
      #if sys.argv[1] == "start":
      # if sys.argv[1] in cmd_dic:
      # cmd_dic[sys.argv[1]]() 

       4>新式类和经典类:
      1)多继承:新式类用广度优先查找,经典类用深度优先查找(3.0中都是广度优先);        

     4>类的静态方法类方法及属性:
      
***python不支持多态并且也用不到多态,多态用于java和c#中;
      多态的应用: *

1》面向对象编程(Object-Oriented Programming):
  对于编程语言的初学者而言,OOP不是一个很容易理解的编程方式,OPP的三大特性有继承,封装,多态,OOP也使得我们对代码的修改和扩展变得更容易;
     封装:把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或对象操作,对不可信的进行信息隐藏;
     继承:可以使用现有类的所有功能,并在无须重新编写原来的类的情况下对这些功能进行扩展;一般情况下,一个子类只能有一个基类,要实现多重继承,                        可以通过多级继承来实现;继承概念的实现方式有三类:实现继承,接口继承和可视继承;
      实现继承:使用基类的属性和方法而无需额外编码的能力;
      接口继承:仅使用属性和方法的名称,但是子类必须提供实现的能力;
      可视继承:子类使用基类的外观和实现代码的能力;
      OOP开发范式大致为: 划分对象->抽象类->将类组织成为层次化结构(继承和合成)->用类与实例进行设计和实现;
  多态:允许将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运行;简单的                    说,允许将子类类型的指针赋值给父类类型的指针;
  封装和继承是为了代码重用,而多态则是为了接口重用;
  把一个抽象的类变成一个具体的对象的过程叫实例化;                                          

        3)类中实例销毁:__del__(析构函数),一直将程序执行完之后会执行实例销毁;

        图片 10

          图片 11

         图片 12

          图片 13

        图片 14

            1>类和构造方法:

                      2)类的描述信息:__doc__; 

            删除属性的设置值:

      1)字段:字段包括普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,普通字段属于对象,静态                                字段属于类,普通字段需要通过对象来访问,静态字段通过类访问;
      静态字段在内存中只保存一份,普通字段在每个对象中都要保存一份;
      静态字段===类变量,普通字段====实例变量;
    2)属性(类方法):其中的装饰器将方法变为类方法,只能通过类来调用,实例不可以直接调用;
      属性的基本使用:  

         图片 15

               图片 16

          def start(self):
            print("Server is starting...")
          def
stop(self):
            print("Server is stopping...")
          def
restart(self):
            self.stop()
            self.start()

           类的成员可以分为三大类:字段,方法和属性;

                                       图片 17

          图片 18

        2>类的变量与实例变量:

        图片 19

           图片 20

          图片 21

                         类的静态方法:不能访问类变量,也不能访问实例变量;

          图片 22

        def test_run(self,name):
          print(**"running...",name,self.host)

          图片 23

          图片 24

编辑:操作系统 本文来源:两种最重要的编程范式分别是面向过程编程和面

关键词: