zoukankan      html  css  js  c++  java
  • 初识面向对象

    一、面向过程 VS 面向对象

    面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西。
    优点是:极大的降低了写程序的复杂度,只需要顺着要执行的步骤,堆叠代码即可。
    缺点是:一套流水线或者流程就是用来解决一个问题,代码牵一发而动全身。
    应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等。

    面向对象的程序设计的核心是对象(上帝式思维),要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的属性和方法),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保驾护航,这些都是对象。然后取经开始,师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。
    面向对象的程序设计的
    优点是:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。
    缺点:可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现,一刀砍死3个人,这个游戏就失去平衡。

    应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方。

    在python 中面向对象的程序设计并不是全部。
    面向对象编程可以使程序的维护和扩展变得更简单,并且可以大大提高程序开发效率 ,另外,基于面向对象的程序可以使它人更加容易理解你的代码逻辑,从而使团队开发变得更从容。
    了解一些名词:类、对象、实例、实例化
    类:具有相同特征的一类事物(人、狗、老虎)
    对象/实例:具体的某一个事物(隔壁阿花、楼下旺财)
    实例化:类——>对象的过程

    二、面向对象初始例子
    python中一切皆为对象,类型的本质就是类,所以,不管你信不信,你已经使用了很长时间的类了
    >>> dict #类型dict就是类dict
    <class 'dict'>
    >>> d=dict(name='eva') #实例化
    >>> d.pop('name') #向d发一条消息,执行d的方法pop
    'eva'

    从上面的例子来看,字典就是一类数据结构,我一说字典你就知道是那个用{}表示,里面由k-v键值对的东西,它还具有一些增删改查的方法。但是我一说字典你能知道字典里具体存了哪些内容么?不能,所以我们说对于一个类来说,它具有相同的特征属性和方法。
    而具体的{'name':'eva'}这个字典,它是一个字典,可以使用字典的所有方法,并且里面有了具体的值,它就是字典的一个对象。对象就是已经实实在在存在的某一个具体的个体。


    三、类和对象相关知识

    3.1固定格式:

    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   #查看对象的属性,直接用 对象名.属性名 即可
    对象名.方法名()     #调用类中的方法,直接用 对象名.方法名() 即可
    	
    

      


    例子一:

    class Person:   #定义一个人类
        role = 'person'  #人的角色属性都是人
        def __init__(self,name):
            self.name = name  # 每一个角色都有自己的昵称;
            
        def walk(self):  #人都可以走路,也就是有一个走路方法
            print("person is walking...")
    
    
    print(Person.role)  #查看人的role属性
    print(Person.walk)  #引用人的走路方法,注意,这里不是在调用
    

     

    实例化的过程就是类——>对象的过程

    原本我们只有一个Person类,在这个过程中,产生了一个egg对象,有自己具体的名字、攻击力和生命值。
    语法:对象名 = 类名(参数)
    egg = Person('egon') #类名()就等于在执行Person.__init__()
    #执行完__init__()就会返回一个对象。这个对象类似一个字典,存着属于这个人本身的一些属性和方法。

    查看属性&调用方法
    print(egg.name) #查看属性直接 对象名.属性名
    print(egg.walk()) #调用方法,对象名.方法名()

    关于self
    self:在实例化时自动将对象/实例本身传给__init__的第一个参数(这个例子中:id(egg) ==id(self)),(你也可以给self起个别的名字,但是正常人都不会这么做。因为你瞎改别人就不认识)


    3.2类属性的补充
    一:我们定义的类的属性到底存到哪里了?有两种方式查看
    dir(类名):查出的是一个名字列表
    类名.__dict__:查出的是一个字典,key为属性名,value为属性值

    二:特殊的类属性
    类名.__name__# 类的名字(字符串)
    类名.__doc__# 类的文档字符串
    类名.__base__# 类的第一个父类(在讲继承时会讲)
    类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
    类名.__dict__# 类的字典属性
    类名.__module__# 类定义所在的模块
    类名.__class__# 实例对应的类(仅新式类中)

    3.3对象之间的交互

    现在我们已经有一个人类了,通过给人类一些具体的属性我们就可以拿到一个实实在在的人。
    现在我们要再创建一个狗类,狗就不能打人了,只能咬人,所以我们给狗一个bite方法。
    有了狗类,我们还要实例化一只实实在在的狗出来。
    然后人和狗就可以打架了。现在我们就来让他们打一架吧!


    例子二:

    class Person:  # 定义一个人类
        role = 'person'  # 人的角色属性都是人
    
        def __init__(self, name, aggressivity, life_value):
            self.name = name  # 每一个角色都有自己的昵称;
            self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
            self.life_value = life_value  # 每一个角色都有自己的生命值;
    
        def attack(self,dog):
            # 人可以攻击狗,这里的狗也是一个对象。
            # 人攻击狗,那么狗的生命值就会根据人的攻击力而下降
            dog.life_value -= self.aggressivity
    
    class Dog:  # 定义一个狗类
        role = 'dog'  # 狗的角色属性都是狗
    
        def __init__(self, name, breed, aggressivity, life_value):
            self.name = name  # 每一只狗都有自己的昵称;
            self.breed = breed  # 每一只狗都有自己的品种;
            self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
            self.life_value = life_value  # 每一只狗都有自己的生命值;
    
        def bite(self,people):
            # 狗可以咬人,这里的狗也是一个对象。
            # 狗咬人,那么人的生命值就会根据狗的攻击力而下降
            people.life_value -= self.aggressivity
    
    egg = Person('egon',10,1000)  #创造了一个实实在在的人egg
    ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2
    print(ha2.life_value)         #看看ha2的生命值
    egg.attack(ha2)               #egg打了ha2一下
    print(ha2.life_value)         #ha2掉了10点血
    

      

    例子三

    from math import pi
    
    class Circle:
        '''
        定义了一个圆形类;
        提供计算面积(area)和周长(perimeter)的方法
        '''
        def __init__(self,radius):
            self.radius = radius
    
        def area(self):
             return pi * self.radius * self.radius
    
        def perimeter(self):
            return 2 * pi *self.radius
    
    
    circle =  Circle(10) #实例化一个圆
    area1 = circle.area() #计算圆面积
    per1 = circle.perimeter() #计算圆周长
    print(area1,per1) #打印圆面积和周长
    

      

      

    3.4类命名空间与对象、实例的命名空间
    创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性

    而类有两种属性:静态属性和动态属性

    静态属性就是直接在类中定义的变量
    动态属性就是定义在类中的方法
    其中类的数据属性是共享给所有对象的
    >>>id(egg.role)
    4341594072
    >>>id(Person.role)
    4341594072

    而类的动态属性是绑定到所有对象的
    >>>egg.attack
    <bound method Person.attack of <__main__.Person object at 0x101285860>>
    >>>Person.attack
    <function Person.attack at 0x10127abf8>
    创建一个对象/实例就会创建一个对象/实例的名称空间,存放对象/实例的名字,称为对象/实例的属性

    在obj.name会先从obj自己的名称空间里找name,找不到则去类中找,类也找不到就找父类...最后都找不到就抛出异常

    class Dog:  # 定义一个狗类
        role = 'dog'  # 狗的角色属性都是狗
        def __init__(self, name):
            self.name = name  # 每一只狗都有自己的昵称;
        def bite(self):
            print('test')
    
    egg = Dog('xiao')
    
    
    print(id(Dog.role),id(egg.role))
    print(id(Dog.bite),id(egg.bite))
    print(egg.__dict__)
    print(Dog.__dict__)
    '''
    D:pycharm_dataday07venvScriptspython.exe D:/pycharm_data/day07/test.py
    3033788981968 3033788981968
    3033789667936 3033759431816
    {'name': 'xiao'}
    {'__module__': '__main__', 'role': 'dog', '__init__': <function Dog.__init__ at 0x000002C25BF496A8>, 'bite': <function Dog.bite at 0x000002C25BF49A60>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': None}
    
    Process finished with exit code 0
    '''
    

      

    3.5面向对象的组合用法
    软件重用的重要方式除了继承之外还有另外一种方式,即:组合
    组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合

    圆环是由两个圆组成的,圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
    这个时候,我们就首先实现一个圆形类,计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用

    from math import pi
    
    class Circle:
        '''
        定义了一个圆形类;
        提供计算面积(area)和周长(perimeter)的方法
        '''
        def __init__(self,radius):
            self.radius = radius
    
        def area(self):
             return pi * self.radius * self.radius
    
        def perimeter(self):
            return 2 * pi *self.radius
    
    
    circle =  Circle(10) #实例化一个圆
    area1 = circle.area() #计算圆面积
    per1 = circle.perimeter() #计算圆周长
    print(area1,per1) #打印圆面积和周长
    
    class Ring:
        '''
        定义了一个圆环类
        提供圆环的面积和周长的方法
        '''
        def __init__(self,radius_outside,radius_inside):
            self.outsid_circle = Circle(radius_outside)
            self.inside_circle = Circle(radius_inside)
    
        def area(self):
            return self.outsid_circle.area() - self.inside_circle.area()
    
        def perimeter(self):
            return  self.outsid_circle.perimeter() + self.inside_circle.perimeter()
    
    
    ring = Ring(10,5) #实例化一个环形
    print(ring.perimeter()) #计算环形的周长
    print(ring.area()) #计算环形的面积
    

      

  • 相关阅读:
    237. Delete Node in a Linked List
    430. Flatten a Multilevel Doubly Linked List
    707. Design Linked List
    83. Remove Duplicates from Sorted List
    160. Intersection of Two Linked Lists
    426. Convert Binary Search Tree to Sorted Doubly Linked List
    142. Linked List Cycle II
    类之间的关系
    初始化块
    明确类和对象
  • 原文地址:https://www.cnblogs.com/linux985/p/10444405.html
Copyright © 2011-2022 走看看