精华内容
下载资源
问答
  • Python中定义和使用抽象及抽象方法

    原文链接:http://www.jb51.net/article/87710.htm

    本文根据自己的理解和思考,对原文略有改动。。。

    Python中我们可以使用abc模块来构建抽象类。在讲抽象类之前,先说下抽象方法的实现。

    抽象方法是基类中定义的方法,但却没有任何实现。在python中实现一个抽象方法的简单的方法是:

    class Sheep(object):
        def __init__(self):
            print '__init__ is called!'
        def get_size(self):
            raise NotImplementedError
    s=Sheep()#生成一个实例。注意实例化时,并没有抛出错误
    s.get_size()#只有调用该方法时才会抛出错误
    任何从Sheep继承下来的子类必须实现(重写)get_size方法,否则就会抛出一个错误。
    但这种实现方法有个缺点:定义的子类只有调用那个方法时才会抛错。
    这里有个简单方法可以在类被实例化时触发它:使用python提供的abc模块。

    import abc
    class Sheep(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def get_size(self):
            return
        
    class sheepson(Sheep):
        def __init__(self):
            print 'sheepson.__init__ is called!'
        
    s1=Sheep()   #报错,不能实例化抽象类
    s2=sheepson()#报错,不能实例化抽象类
    这里实例化Sheep类或实例化任意从其继承的子类(未实现get_size)时候都会抛出异常。
    因此,通过定义抽象类,可以定义子类的共同method(强制其实现)。
    如何使用抽象类:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
    通过ABCMeta元类来创建一个抽象类, 使用abstractmethod装饰器来表明抽象方法
    注册具体类:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
    
    class B(object):
        def load(self, input):
            return input.read()
        def save(self, output, data):
            return output.write(data)
    
    A.register(B)#从抽象类注册一个具体的类
     
    if __name__ == '__main__':
        print issubclass(B, A)    # print True
        print isinstance(B(), A)  # print True
    使用继承抽象类的方法来实现具体类:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
    
    class B(A):
        def load(self, input):
            return input.read()
        def save(self, output, data):
            return output.write(data)
    
    class C(A):
        def load(self, input):
            return input.read()
        def save(self, output, data):
            return output.write(data)
    
    if __name__ == '__main__':
        print issubclass(B, A)    # print True
        print isinstance(B(), A)  # print True
        print issubclass(C, A)    # print True
        print isinstance(C(), A)  # print True
    可以使用继承抽象类的方法来实现具体类,这样可以避免使用register。
    但是副作用是可以通过基类找出所有的具体类。。。。。

    print A.__subclasses__()
    for subclass in A.__subclasses__():
        print subclass.__name__
    使用继承的方式会找出所有的具体类,但如果使用register的方式则不会被找出。。。
    使用__subclasshook__ :
    使用__subclasshook__后只要具体类定义了与抽象类相同的方法就认为是他的子类。

    import abc
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def say(self):
            return 'say yeah'
        @classmethod
        def __subclasshook__(cls, C):
            if cls is A:
                if any("say" in B.__dict__ for B in C.__mro__):
                    return True
            return NotImplemented
     
    class B(object):
        def say(self):
            return 'hello'
     
    print issubclass(B, A)    # True
    print isinstance(B(), A)  # True
    print B.__dict__      # {'say': <function say at 0x7f...>, ...}
    print A.__subclasshook__(B) # True
    不完整的实现:

    import abc 
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def load(self, input):
            return
        @abc.abstractmethod
        def save(self, output, data):
            return
        
    class D(A):#类D继承了类A,重写了save方法,但没有重写load方法,因此,类D仍然是抽象类,不可实例化
        def save(self, output, data):
            return output.write(data)
     
    if __name__ == '__main__':
        print issubclass(D, A)    # print True
        print isinstance(D(), A)  # raise TypeError
    构建不完整的具体类,实际上仍然是抽象类,仍然不可实例化。。。
    具体类中使用抽象基类:

    import abc 
    from cStringIO import StringIO
    class A(object):#包含抽象方法的类称为抽象类,抽象类不可实例化
        __metaclass__ = abc.ABCMeta
        @abc.abstractmethod
        def retrieve_values(self, input):
            print 'base class reading data'
            return input.read()
    
    class B(A):
        def retrieve_values(self, input):
            base_data = super(B, self).retrieve_values(input)
            print 'subclass sorting data'
            response = sorted(base_data.splitlines())
            return response
    
    input = StringIO("""line one
    line two
    line three
    """)
    reader = B()
    print reader.retrieve_values(input)
    运行结果:
    base class reading data
    subclass sorting data
    ['line one', 'line three', 'line two']
    可以使用super来重用抽象基类中的罗辑, 但会迫使子类提供覆盖方法。
    抽象属性:

    import abc
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractproperty
        def value(self):
            return 'should never get here.'
     
    class B(A):
        @property
        def value(self):
            return 'concrete property.'
        
    try:
        a = A()#Can't instantiate abstract class A with abstract methods value
        print 'A.value', a.value
    except TypeError, err:
        print type(err)
        print err
        print str(err)
        print 'TypeError: ', str(err)
     
    b = B()
    print 'B.value:', b.value
    运行结果:
    <type 'exceptions.TypeError'>
    Can't instantiate abstract class A with abstract methods value
    Can't instantiate abstract class A with abstract methods value
    TypeError:  Can't instantiate abstract class A with abstract methods value
    B.value: concrete property.
    定义抽象的读写属性:

    import abc  
    class A(object):  
        __metaclass__ = abc.ABCMeta  
        def get_value(self):  
            return 'Should never see this.'  
        def set_value(self, value):  
            return  
        value = abc.abstractproperty(get_value, set_value)#value是 抽象的读写属性。 
       
    class B(A):  
        @abc.abstractproperty  
        def value(self):#重写value方法,但依然是抽象属性。
            return 'read-only'  
    
    class C(A):  
        _value = 'default value' #类的属性,所有实例可以共享  
        def get_value(self):  
            return self._value  
        def set_value(self, value):  
            self._value = value  
        #定义具体类的property时必须与抽象类的abstract property相同。如果只覆盖其中一个将不会工作。。  
        value = property(get_value,set_value)#此时的value是 具体的读写属性。
    
    try:  
        a = A()  
        print a.value  
    except Exception, err:  
        print str(err)  
    
    try:  
        b = B()  
        print b.value  
    except Exception, err:  
        print str(err)  
       
    c = C()  
    print C._value #通过类名 访问类的属性  
    print c.value #访问实例c自己的_value属性,但此时,实例c自己没有_value属性,因此实际访问的是类的 _value属性  
    c.value = 'hello' #为实例c添加一个_value属性,赋初值为'hello'  
    print c.value #访问实例c自己的_value属性  
    print C._value #访问类的_value属性  

    运行结果:
    Can't instantiate abstract class A with abstract methods value
    Can't instantiate abstract class B with abstract methods value
    default value
    default value
    hello
    default value
    注意:定义具体类的property时必须与抽象的abstract property相同。如果只覆盖其中一个将不会工作。
    使用装饰器语法来实现读写的抽象属性, 读和写的方法名应该相同。

    import abc
    class A(object):
        __metaclass__ = abc.ABCMeta
        @abc.abstractproperty
        def value(self):
            return 'should never see this.'
        @value.setter
        def value(self, _value):
            return
     
    class B(A):
        _value = 'default'
        @property
        def value(self):
            return self._value
        @value.setter
        def value(self, _value):
            self._value = _value
     
    b = B()
    print b.value    #尝试访问实例b的_value属性,但b自己没有该属性,因此访问的是类的_value属性。
    b.value = 'hello'#为实例b添加_value属性,初始值为'hello'
    print b.value    #访问实例b自己的_value属性
    运行结果:
    default
    hello

    (完)


    展开全文
  • Python 3.6 定义类中方法和属性

    千次阅读 2017-10-28 15:14:39
    #Python3 中类的封装,构造方法定义,实例化属性共有属性 #把具有相同特征的一东西抽象成一个 #1,定义 关键字:Class #类和方法的命名都是驼峰命名规则,但是的首字母大写,方法的首字母小写 ...
    #Python3 中类的封装,构造方法的定义,实例化属性,和共有属性
    
    #把具有相同特征的一类东西抽象成一个类
    
    #1,类的定义   关键字:Class
    
    #类和方法的命名都是驼峰命名规则,但是类的首字母大写,方法的首字母小写
    class  Animal(object):    #这里定义了一个Animal类,继承了object基类
        pass
    
    
    #注意,任何类都会继承object基类,所以定义类的时候可以 object可写可不写
    
    # 使用类的时候需要先实例化
    
    
    
    an=Animal() #实例化类  现在an这个对象就得到了Animal的所有方法和属性
    
    
    #2,类中构造方法的学习
    
    class  Animal1(object):    #这里定义了一个Animal类,继承了object基类
        def __init__(self):   #这是构造方法,构造方法中必须加参数self
            print('对象只要被实例化,我就会被调用,可以把我理解成初始化方法')
    
    
    a=Animal1()  #实例化Animal1类,自动输出构造方法
    
    #实例化构造对象的时候必调用构造方法,构造方法的写法 只能是 __init__
    
    #如果声名类的时候没有定义构造方法,那就会默认调用父类的构造方法
    
    # __init__(self) 中的self这个参数意思是实例化对象自己
    
    '''
    #实例化对象调用类中方法的时候一定会默认传一个参数,这个默认参数就是把自己传进去
    #所以说只有在类中有(self)参数的方法,才能被实例调用,
    #如果类中的方法没有self参数,
    #那么这个方法只能被类调用,不能被类的实例化调用
    '''
    
    
    #属性,实例化属性,和类属性
    #类属性又叫共有属性
    class Animal2(): #定义一个Animal2()类,虽然没写object 但是它默认继承
        def __init__(self,name):  #定义构造方法
            self.name=name        #这个叫实例化属性 在方法中定义的叫实例化属性
    
        def getName(self):
            print(self.name)     #问 为什么我getName中没有定义name属性,我可以输出
                                 #因为,类在实例化的时候得到了自己的name属性,我们把self对象穿进去就有了name属性
    #类属性
    
    class Animal3(): #定义一个Animal3()类
        age=2          #这个age是共有属性
        def __init__(self,name):  #定义构造方法
            self.name=name        #这个叫实例化属性 在方法中定义的叫实例化属性
    
        def getName(self):
            print(self.name)  
    
    '''
    当共用属性被实例化调用的时候,共用属性会变成实例化属性,切记
    
    '''
    
    
    
    
    


    展开全文
  • 定义一个Person,中要有初始化方法,方法中要有人的姓名年龄属性 # # 2. 将中的姓名是公有属性,年龄是私有属性. # # 3. 提供获取私有属性的公有方法 get_age方法. # # 4. 提供可以设置私有属性的方法 set_...
    # 1. 定义一个Person类,类中要有初始化方法,方法中要有人的姓名和年龄属性
    #
    # 2. 将类中的姓名是公有属性,年龄是私有属性.
    #
    # 3. 提供获取私有属性的公有方法 get_age方法.
    #
    # 4. 提供可以设置私有属性的方法 set_age方法,要求如果输入的年龄在 0 -- 100 之间,设置年龄,否则,提示输入不正确,.
    #
    # 5. 重写 __str__ 要求打印对象时,把 姓名和年龄都打印出来。
    
    
    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.__age = age
    
        def get_age(self):
            return self.__age
    
        def set_age(self):
            age_num = int(input("请输入的年龄在 0 -- 100 之间:"))
            if 0 < age_num < 100:
                self.__age = age_num
                print("{}年龄设置成功:{}".format(self.name, self.__age))
            else:
                print("提示输入不正确")
    
        def __str__(self):
            return "姓名:{}, 年龄:{}".format(self.name, self.__age)
    
    
    if __name__ == '__main__':
        p1 = Person("小米", 30)
        p1.set_age()
        print(p1)
    
    
    展开全文
  • 2(1)定义类Shape作为父类,并在类中定义方法求周长面积; (2)定义Shape子类圆形(circle),具有半径属性和常量PI,同时重写父类方法; (3)定义Shape子类长方形(rectangle),具有长和宽的属性,同时...

    2(1)定义类Shape作为父类,并在类中定义方法求周长和面积; (2)定义Shape子类圆形(circle),具有半径属性和常量PI,同时重写父类中的方法; (3)定义Shape子类长方形(rectangle),具有长和宽的属性,同时重写父类的方法; (4)创建图形面积周长计算器(ShapeCalculate),具有计算不同图形面积和周长的方法。 (5)对ShapeCalculate计算面积和周长方法进行测试。

    class Shape():
        def zhouchang(self):
            pass
    
        def mianji(self):
            pass
    
    class Circle(Shape):
        PI = 3.14
        def __init__(self, radius):
            self.radius = radius
    
        def zhouchang(self):
            return 2 * self.PI * self.radius
    
        def mianji(self):
                return self.PI * self.radius ** 2
    
    class Rectangle(Shape):
        def __init__(self, c, k):
            self.c = c
            self.k = k
    
        def zhouchang(self):
            return 2 * (self.c + self.k)
    
        def mianji(self):
            return self.c * self.k
    
    def ShapeCalculate(a):
        s = a.mianji()
        z = a.zhouchang()
        print('周长是{},面积是{}'.format(s, z))
    
    aa = Circle(4)
    bb = Rectangle(3, 4)
    ShapeCalculate(aa)
    ShapeCalculate(bb)
    

    在这里插入图片描述

    展开全文
  • Python类属性和实例属性定义

    千次阅读 2018-10-11 19:23:07
    类属性在类方法定义属性。 实例属性,__init__内定义属性类属性可以直接用类名访问,具有读写权限,也可以用实例名访问,但用实例访问时只能读。当实例访问不存在的属性时,会实例新建属性。 .....
  • 定义一个Person,定义nameage属性定义有参的构造方法对nameage进行初始化。测试类中创建该的2个对象,姓名、年龄分别为lili、19lucy、20,屏幕打印出2个对象的姓名年龄。 输入格式: 本题目无输入 ...
  • 抽象方法中可以有Static属性和方法吗? 对于这个问题,网上众说纷纭,其实,抽象中是可以包含static属性和static方法的,最典型的例子:Calendar 下面直接上Calendar的源码: public abstract class ...
  • Python中定义类方法

    千次阅读 2019-07-31 22:29:40
    方法也分实例方法和类方法, 与属性类似 class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。 class中定义类方法,需要这么写: class Person(object): count = 0 @classmethod def how_many...
  • Python类属性类方法和静态方法

    千次阅读 多人点赞 2019-06-05 15:12:54
    Python类属性类方法和静态方法 Python,一切皆对象。通过创建出来的对象是实例对象,本身也是对象,称为对象。 一、类属性 对象都有属性,我们常说的对象属性是实例对象拥有的属性,又称为实例属性。...
  • python类属性、实例属性类方法、实例方法

    万次阅读 多人点赞 2018-07-03 10:45:22
    定义类 class Person(): pass 创建实例 xiaoming = Person() xiaohong = Person() 实例属性 xiaoming = Person() xiaoming.name = xiaoming xiaoming.age = 24 xiaoming.sex = man xiaohong = Person() ...
  • python类和对象,属性和方法

    万次阅读 多人点赞 2018-04-26 13:18:30
    一、面向对象的概述面向对象是一种描述业务问题、设计业务实体实体之间关系的方法二、类和对象1、类和对象得区别:是对客观世界事物得抽象,而对象是实例化后的实体 例如:汽车模型就是一个,制造出来的...
  • 20.python-类属性和类方法

    千次阅读 2019-11-28 00:49:06
    类属性和类方法 目标 的结构 类属性和实例属性 类方法和静态方法 01. 的结构 1.1 术语 —— 实例 使用面相对象开发,第 1 步是设计 使用类名()创建对象,创建对象的动作有两步: 1) 内存中为对象...
  • 一、类属性声明  一个对象的外部可见部分被称其为属性。ruby通过对象的实例变量来表示对象的内部状态,即,属性。既然是对外部可见的。...Ruby是通过定义方法来访问属性。有两种方法方式:  1、直接定义类
  • Pythonclass的定义属性及其实例化

    千次阅读 2019-08-10 11:42:47
    它定义了该集合每个对象所共有的属性和方法。对象是类的实例。 方法:类定义的函数。 实例化:创建一个类的实例,类的具体对象。 对象:通过类定义的数据结构实例。 类的定义 #定义一个Person类,类名首字母一般...
  • 动态给类和对象添加属性和方法

    千次阅读 2017-10-20 15:09:30
    动态给类和对象添加属性和方法动态给类和对象添加属性定义一个Personclass Person(object): def __init__(self, name): self.name = name给对象添加属性 # 创建2个Person,分别为p1,p2p1 = Person('amy') print...
  • C#定义类属性中的getset的作用

    千次阅读 2019-09-05 11:19:17
    在定义类属性中经常能看到这种写法 private string _name; public string Name { get{return _name;} set{_name=value;} } getset就是读取写入 string NameStr= xx.Name 就是get xx.Name=“张三” 就是set 为...
  • C#类中属性定义

    千次阅读 2015-12-28 20:57:17
    属性是用来描述的特征;...需要实例化后才能使用,但我们是通过属性来访问类中的字段;字段是是用来存储数据的; 属性的作用就是代替字段与外界打交道,从而起到保护字段的作用。它的本质就是两个方法,...
  • 创建Employee在类中定义三个属性:编号,姓名,年龄,然后构造方法里初始化这三个属性,最后载实现接口定义的CompareTo方法,将对象按编号升序排列。根据已有的代码,补全程序。 输入输出说明: 输入...
  • Python:的继承,调用父类的属性和方法基础详解

    万次阅读 多人点赞 2018-12-30 11:35:01
    以下案例均表示Son继承父类的一些属性初始化参数构造等。 5个模块: (1):直接调用父类属性方法; (2):重写父类属性方法; (3):强制调用父类私有属性方法; (4):调用父类的__init__方法 (5)...
  • (3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名成绩属性值。 (4)测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓...
  • Swift类属性定义

    千次阅读 2016-09-16 20:48:18
    Swift中类属性有多种 存储属性:存储实例的常量变量 ...可以给存储属性提供一个默认值,也可以在初始化个对其进行初始化。 下面是存储属性的写法://: Playground - noun: a place where people can
  • 可以通过构造方法设置3个属性的内容,并覆写Object类中的toString()方法List集合加入5个学生对象,并将内容输出,之后使用比较器将对象的内容进行排序并显示屏幕上。 import java.util.List; import java....
  • 类属性在类中方法(也就是类中的函数)之外但又在类中定义属性;而实例属性构造函数中定义的(__init__),定义时候以self作为前缀。类属性在所有实例之间共享。在类内部和类外部都可以通过“.类属性” ...
  • 文章目录包包(package)的作用JDK主要的包包的命名规范导入(import)方法方法的使用方法的重载(Overload)以及方法的重写(Override)对象(Object)和类(class)面向过程面向对象对象的本质对象和类的概念定义...
  • javascript 定义对象、方法和属性的使用方法(prototype)

    千次阅读 热门讨论 2017-03-08 16:19:29
    prototype 属性使您有能力向对象添加属性和方法。 语法 object.prototype = { 函数名 : function(){} } object.prototype.name=value javaScript的中类和对象 定义类 例1: //第一种定义方式 var ...
  • // 方法: 显示Person对象属性信息的方法。 // 定义一个数组,用于存储Person对象,可以存储5个Person对象。 // 对象的属性信息,通过键盘录入的方式进行赋值。 // 遍历数组,显示对象的属性信息。 public ...
  • Python类属性、实例属性类方法、静态方法

    万次阅读 多人点赞 2017-05-23 14:55:27
    2、类属性就是对象所拥有的属性,它被所有对象的实例对象所共有,内存只存在一个副本,这个C++、Java中类的静态成员变量有点类似。对于公有的类属性在类可以通过对象实例对象访问 类属性 # ...
  • 定义管理员(Admin),管理员类中的 1,属性包括:姓名、账号、密码、电话; 2,方法包括: 1)登陆的方法login():要求在方法输入用户名密码,将输入的用户名管理员对象的账号、密码相比,如果相同则返回...
  • 属性和方法(内置方法

    万次阅读 2018-01-10 23:03:34
    1.的组成由属性和方法组成,属性可以称为成员变量,方法可以称为成员函数。 2.对象的创建,创建对象的过程称之为实例化。当一个对象被创建后,包含三个方面的特性:1.对象句柄 2.属性 3.方法。 句柄:用于...
  • 1、定义:  的关键字定义使用class ...2.定义一个有成员属性和操作的 Class Person{  //成员属性  $name = ''; //操 作 protected function getActionName() { return $thi

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,616,831
精华内容 646,732
关键字:

在类中可以定义属性和方法吗