zoukankan      html  css  js  c++  java
  • Python OOP(1)

    • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
    • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
    • 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
    • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
    • 实例变量:定义在方法中的变量,只作用于当前实例的类。
    • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
    • 实例化:创建一个类的实例,类的具体对象。
    • 方法:类中定义的函数。
    • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

    创建类

    class ClassName:
       '类的帮助信息'   #类文档字符串
       class_suite  #类体
    #!python2
    #-*- coding:utf-8 -*-
    
    class Employee:
        #类说明,可以通过className.__doc__ 查看
        "员工类" 
        #类变量
        empCount=0
        
        #构造函数或初始化函数,当创建这个类的instance的时候就会调用
        #所有类的方法,第一个函数必须是self
        def __init__(self,name,salary):
            self.name=name
            self.salary=salary
            Employee.empCount+=1
            
        def displayCount(self):
            print "Total Employee %d " % Employee.empCount
            
            
        def displayEmployee(self):
            print "Name: %s, Salay: %s " % (self.name,self.salary)
            
    
    #创建类 Employee的第一个实例对象
    emp1=Employee("Martin","20000")
    #创建类 Employee的第二个实例对象
    emp2=Employee("Sui",10000)
    
    
    emp1.empCount
    emp1.displayCount()
    emp1.displayEmployee()
    
    emp2.empCount
    emp2.displayCount()
    emp2.displayEmployee()
    
    Employee.empCount
    
    #增加修改和删除属性
    emp1.age=20
    print emp1.age
    emp1.age=22
    print emp1.age
    del emp1.age
    
    #函数方式访问属性
    #getattr(obj, name[, default]) : 访问对象的属性。
    #hasattr(obj,name) : 检查是否存在一个属性。
    #setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性。
    #delattr(obj, name) : 删除属性。
    
    
    hasattr(emp1,"age")
    getattr(emp1,"age")
    setattr(emp2,"sex","M")
    getattr(emp2,"sex")
    delattr(emp2,"sex")
    hasattr(emp2,"sex")
      
    #内置类属性
    # __dict__ : 类的属性(包含一个字典,由类的数据属性组成)
    # __doc__ :类的文档字符串
    # __name__: 类名
    # __module__: 类定义所在的模块(类的全名是'__main__.className',如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)
    # __bases__ : 类的所有父类构成元素(包含了一个由所有父类组成的元组)
    
    print Employee.__doc__
    print Employee.__dict__
    print Employee.__name__
    print Employee.__module__
    print Employee.__bases__

    类的继承

    面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

    需要注意的地方:继承语法 class 派生类名(基类名)://... 基类名写在括号里,基本类是在类定义的时候,在元组之中指明的。

    在python中继承中的一些特点:

    • 1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。
    • 2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
    • 3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找,简单说就是按照“由下到上,由左至右”的顺序搜索该对象上的所有类)。

    如果在继承元组中列了一个以上的类,那么它就被称作"多重继承" 

    class SubClassName (ParentClass1[, ParentClass2, ...]):
       'Optional class documentation string'
       class_suite
    #!python2
    #-*- coding:utf-8 -*-
    
    #定义父类
    class Parent:
        
        parentAttt=1
        
        def __init__(self):
            print "父类构造函数"
            
        def parentMethon(self):
            print "call parent methon"
            
        def setAttr(self,attr):
            Parent.attr=attr
            
        def getAttr(self):
            print "父类属性: ",Parent.attr
            
            
    class Child(Parent):
        
        def __init__(self):
            print "子类构造函数"
            
        def childMethod(self):
            print "call children method"
            
    #实例化子类       
    c=Child()
    #调用呢子类方法
    c.childMethod()
    #调用父类方法
    c.parentMethon()
    #再次调用父类方法
    c.setAttr("test")
    c.getAttr()
    
    
    #issubclass(B,A) B是A类的子类, 返回True。否则返回False
    #判断是否是derive class
    issubclass(Child,Parent)
    
    
    #isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true
    #判断是对象,实例
    
    isinstance(c,Parent)
    
        

    继承多个类

    class A:        # 定义类 A
    .....
    
    class B:         # 定义类 B
    .....
    
    class C(A, B):   # 继承类 A 和 B
    .....

    方法重写

    如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法:

    #!python2
    #-*-coding:utf-8-*-
    
    class Parent:
        def myMethod(self):
            print "call parent Method"
            
            
    class Child(Parent):
        def myMethod(self):
            print "call rewrite child method"
            
    c=Child()
    c.myMethod()
    
    call rewrite child method
    
    p=Parent()
    p.myMethod()
    
    call parent Method

    基础重载

    __init__ ( self [,args...] )
    构造函数
    简单的调用方法: obj = className(args)

    __del__( self )
    析构方法, 删除一个对象
    简单的调用方法 : dell obj

    __repr__( self )
    转化为供解释器读取的形式
    简单的调用方法 : repr(obj)

    __str__( self )
    用于将值转化为适于人阅读的形式
    简单的调用方法 : str(obj)

    __cmp__ ( self, x )
    对象比较
    简单的调用方法 : cmp(obj, x)

    运算符重载

    #!python2
    #-*-coding:utf-8-*-
    
    class Vector:
        
        def __init__(self,a,b):
            self.a=a
            self.b=b
            
        def __str__(self):
            return "Vector(%d,%d)" % (self.a,self.b)
        
        def __add__(self,others):
            return Vector(self.a+others.a,self.b+others.b)
            
            
    v1=Vector(10,20)
    v2=Vector(1,2)
    print v1+v2
    
    Vector(11,22)

    类属性与方法
    类的私有属性
    __private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
    类的方法
    在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数
    类的私有方法
    __private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 self.__private_methods

    #!python2
    #-*- coding:utf-8 -*-
    
    
    class JustCounter:
        __privateid=0
        publicid=0
        
        def counter(self):
            self.__privateid+=1
            self.publicid+=1
            print self.__privateid
            self.__privatecounter()
            
        def __privatecounter(self):
            self.__privateid+=1
            print "call privatecounter"
            
        
    c=JustCounter()
    c.counter()
    c.publicid
    1
    #实例不能访问私有变量
    c.__privateid
    #Python不允许实例化的类访问私有数据,但你可以使用 
    #object._className__attrName 
    #object._className__method()
    #访问属性或者方法
    
    c._JustCounter__privateid
    
    2
    
    c._JustCounter__privatecounter()
    
    call privatecounter
  • 相关阅读:
    程序员:不要自称为码农
    SpringBoot对静态资源配置
    LeetCode 572. Subtree of Another Tree(子树)
    LeetCode 437. Path Sum III(统计路径和等于sum的路径数量)
    LeetCode 112. Path Sum(判断路径和是否等于一个数)
    LeetCode 617. Merge Two Binary Trees(归并两棵二叉树)
    LeetCode 226. Invert Binary Tree(翻转二叉树)
    Failure to transfer org.apache.maven.plugins:maven-resources-plugin:pom:2.6 的解决办法
    linux-查询某软件的安装的目录
    WebService概念解释
  • 原文地址:https://www.cnblogs.com/dadadechengzi/p/6347485.html
Copyright © 2011-2022 走看看