python描述符_python如何计算分子描述符 - CSDN
精华内容
参与话题
  • Python 描述符

    2019-08-01 09:28:07
    描述符: 如果一个类中包含了三个魔术方法(get,set,delete)之一或者全部的类这个类就是一个描述符 描述符的作用: 描述符的作用就是对类/对象中某个成员进行详细的管理操作。 数据描述符:(完整) 同时具备三个...

    描述符:
    如果一个类中包含了三个魔术方法(get,set,delete)之一或者全部的类这个类就是一个描述符

    描述符的作用:
    描述符的作用就是对类/对象中某个成员进行详细的管理操作。

    数据描述符:(完整)
    同时具备三个魔术方法的类就是数据描述符

    非数据描述符(不完整):
    没有同时具备三个魔术方法的类就是非数据描述符

    三个魔术方法:

    __get__():
        触发时机:在访问对象成员属性(该成员已经交给描述符管理的时候)的时候触发
        作用:设置当前属性获取的值
        参数:self 描述符的对象  / 第二个 被管理成员的类的对象  / 第三个  被管理成员的类
        返回值:可有可无,有的话就是获取的值
        注意事项:无
    
    __set__():
        触发时机:在设置对象成员属性(该成员已经交给描述符管理的时候)的时候触发
        作用:对成员的值进行设置管理
        参数:self 描述符的对象  / 第二个 被管理成员的类的对象  / 第三个  要设置的值
        返回值:无
        注意事项:设置值的时候一定要设置当前描述符对象的临时变量
    
    __delete__():
        触发时机:在删除对象成员属性(该成员已经交给描述符管理的时候)的时候触发
        作用:对成员的值进行删除管理
        参数:self 描述符的对象  / 第二个 被管理成员的类的对象
        返回值:无
        注意事项:删除值的时候一定要删除当前描述符对象的临时变量
    
    例:
    class Descriptor:
        #初始化一个临时的成员属性(代替原有username的操作)
        def __init__(self):
            self.tmpvar = '匿名用户'#属性随便给,这个就是控制的入口
        #定义描述符的三个成员
        def __get__(self,obj,cls):#self 描述符的对象  obj Email对象mail  cls Email类
            #希望获取用户名的时候仅仅返回第一个和最后一个字符 其余的都隐藏
            result = self.tmpvar[0] + '*' + self.tmpvar[-1]
            return result
        def __set__(self,obj,val):#self 描述符的对象   / obj Email对象mail  /val 要设置的值
            #设置值的时候一定要设置当前描述符对象的临时变量
            #限制用户名不能超过8个字符
            #检测字符个数
            if len(val) > 8:
                self.tmpvar = val[0:8]
            else:
                self.tmpvar = val
        def __delete__(self,obj):#self 描述符的对象/ obj Email对象mail
            #删除临时变量即可
            if obj.isallowdel_username == True:
                del self.tmpvar
        #声明一个类(邮箱)
    class Email:
        #成员属性
        username = Descriptor()#用户名 交给描述符管理 [交接行为]
        #设置一个是否允许删除username的标志
        isallowdel_username = True
    # 实例化对象
    mail = Email()
    # 访问用户名
    #print(mail.username)
    # 设置用户名
    mail.username = 'lovemybaby'
    # print(mail.username)
    # 删除用户名的操作
    print(mail.username)
    del mail.username
    # print(mail.username)
    
    

    描述符和属性魔术方法:

    属性魔术方法
    _ getattribute _
    _ getattr _
    _ setattr _
    _ delattr _
    【针对当前类/对象所有成员的管理,属性魔术方法仅对当前类有效】

    描述符(是一个类):
    _ get _
    _ set _
    _ delete _
    【仅仅针对类/对象某一个成员的设置,描述符可对不同的类使用】

    展开全文
  • Python描述符 (descriptor) 详解

    千次阅读 2019-05-29 10:37:53
    python描述符是一个“绑定行为”的对象属性,在描述符协议中,它可以通过方法重写属性的访问。这些方法有 get(), set(), 和__delete__()。如果这些方法中的任何一个被定义在一个对象中,这个对象就是一个描述符。 ...

    1、什么是描述符?

    python描述符是一个“绑定行为”的对象属性,在描述符协议中,它可以通过方法重写属性的访问。这些方法有 get(), set(), 和__delete__()。如果这些方法中的任何一个被定义在一个对象中,这个对象就是一个描述符。

    以上为官方定义,纯粹为了装逼使用,一般人看这些定义都有一种问候祖先的冲动!

    没关系,看完本文,你就会理解什么叫描述符了!

    2、讲解描述符前,先看一下属性:dict (每个对象均具备该属性)

    作用:字典类型,存放本对象的属性,key(键)即为属性名,value(值)即为属性的值,形式为{attr_key : attr_value}

    对象属性的访问顺序:

    ①.实例属性

    ②.类属性

    ③.父类属性

    ④.getattr()方法

    以上顺序,切记切记!

    class Test(object):
        cls_val = 1
        def __init__(self):
            self.ins_val = 10
    
            
    >>> t=Test()
    >>> Test.__dict__
    mappingproxy({'__module__': '__main__', 'cls_val': 1, '__init__': <function Test.__init__ at 0x0000000002E35D08>, '__dict__': <attribute '__dict__' of 'Test' objects>, '__weakref__': <attribute '__weakref__' of 'Test' objects>, '__doc__': None})
    >>> t.__dict__
    {'ins_val': 10}
    
    >>> type(x)==X
    True
    
    #更改实例t的属性cls_val,只是新增了该属性,并不影响类Test的属性cls_val
    >>> t.cls_val = 20
    >>> t.__dict__
    {'ins_val': 10, 'cls_val': 20}
    >>> Test.__dict__
    mappingproxy({'__module__': '__main__', 'cls_val': 1, '__init__': <function Test.__init__ at 0x0000000002E35D08>, '__dict__': <attribute '__dict__' of 'Test' objects>, '__weakref__': <attribute '__weakref__' of 'Test' objects>, '__doc__': None})
    
    #更改了类Test的属性cls_val的值,由于事先增加了实例t的cls_val属性,因此不会改变实例的cls_val值(井水不犯河水)
    >>> Test.cls_val = 30
    >>> t.__dict__
    {'ins_val': 10, 'cls_val': 20}
    >>> Test.__dict__
    mappingproxy({'__module__': '__main__', 'cls_val': 30, '__init__': <function Test.__init__ at 0x0000000002E35D08>, '__dict__': <attribute '__dict__' of 'Test' objects>, '__weakref__': <attribute '__weakref__' of 'Test' objects>, '__doc__': None})
    

    从以上代码可以看出,实例t的属性并不包含cls_val,cls_val是属于类Test的。

    3、魔法方法:get(), set(), delete()

    方法的原型为:

    get(self, instance, owner)

    set(self, instance, value)

    del(self, instance)

    那么以上的 self, instance owner到底指社么呢?莫急莫急,听我慢慢道来!

    首先我们先看一段代码:

    #代码 1
    
    class Desc(object):
        
        def __get__(self, instance, owner):
            print("__get__...")
            print("self : \t\t", self)
            print("instance : \t", instance)
            print("owner : \t", owner)
            print('='*40, "\n")
            
        def __set__(self, instance, value):
            print('__set__...')
            print("self : \t\t", self)
            print("instance : \t", instance)
            print("value : \t", value)
            print('='*40, "\n")
    
    
    class TestDesc(object):
        x = Desc()
    
    #以下为测试代码
    t = TestDesc()
    t.x
    
    #以下为输出信息:
    
    __get__...
    self :          <__main__.Desc object at 0x0000000002B0B828>
    instance :      <__main__.TestDesc object at 0x0000000002B0BA20>
    owner :      <class '__main__.TestDesc'>
    ========================================
    

    可以看到,实例化类TestDesc后,调用对象t访问其属性x,会自动调用类Desc的 __get__方法,由输出信息可以看出:

    ① self: Desc的实例对象,其实就是TestDesc的属性x

    ② instance: TestDesc的实例对象,其实就是t

    ③ owner: 即谁拥有这些东西,当然是 TestDesc这个类,它是最高统治者,其他的一些都是包含在它的内部或者由它生出来的

    到此,我可以揭开小小的谜底了,其实,Desc类就是是一个描述符(描述符是一个类哦),为啥呢?因为类Desc定义了方法 get, set.

    所以,某个类,只要是内部定义了方法 get, set, delete 中的一个或多个,就可以称为描述符(_,简单吧)

    说到这里,我们的任务还远远没有完成,还存在很多很多的疑点?

    问题1. 为什么访问 t.x的时候,会直接去调用描述符的 get() 方法呢?

    答:t为实例,访问t.x时,根据常规顺序,

    首先:访问Owner的__getattribute__()方法(其实就是 TestDesc.getattribute()),访问实例属性,发现没有,然后去访问父类TestDesc,找到了!

    其次:判断属性 x 为一个描述符,此时,它就会做一些变动了,将 TestDesc.x 转化为 TestDesc.dict[‘x’].get(None, TestDesc) 来访问

    然后:进入类Desc的 get()方法,进行相应的操作

    问题2. 从上面 代码1 我们看到了,描述符的对象 x 其实是类 TestDesc 的类属性,那么可不可以把它变成实例属性呢?

    答:我说了你不算,你说了也不算,解释器说了算,看看解释器怎么说的。

    #代码 2
    
    class Desc(object):
        def __init__(self, name):
            self.name = name
        
        def __get__(self, instance, owner):
            print("__get__...")
            print('name = ',self.name) 
            print('='*40, "\n")
    
    class TestDesc(object):
        x = Desc('x')
        def __init__(self):
            self.y = Desc('y')
    
    #以下为测试代码
    t = TestDesc()
    t.x
    t.y
    
    #以下为输出结果:
    __get__...
    name =  x
    ========================================
    

    咦,为啥没打印 t.y 的信息呢?

    因为没有访问 get() 方法啊,哈哈,那么为啥没有访问 get() 方法呢?(问题真多)

    因为调用 t.y 时刻,首先会去调用TestDesc(即Owner)的 getattribute() 方法,该方法将 t.y 转化为TestDesc.dict[‘y’].get(t, TestDesc), 但是呢,实际上 TestDesc 并没有 y这个属性,y 是属于实例对象的,所以,只能忽略了。

    问题3. 如果 类属性的描述符对象 和 实例属性描述符的对象 同名时,咋整?

    答:还是让解释器来解释一下吧。

    #代码 3
    
    class Desc(object):
        def __init__(self, name):
            self.name = name
            print("__init__(): name = ",self.name)
            
        def __get__(self, instance, owner):
            print("__get__() ...")
            return self.name
    
        def __set__(self, instance, value):
            self.value = value
            
    class TestDesc(object):
        _x = Desc('x')
        def __init__(self, x):
            self._x = x
    
    
    #以下为测试代码
    t = TestDesc(10)
    t._x
    
    #输入结果
    __init__(): name =  x
    __get__() ...
    

    不对啊,按照惯例,t._x 会去调用 getattribute() 方法,然后找到了 实例t 的 _x 属性就结束了,为啥还去调用了描述符的 get() 方法呢?

    这就牵扯到了一个查找顺序问题:当Python解释器发现实例对象的字典中,有与描述符同名的属性时,描述符优先,会覆盖掉实例属性。

    不信?来看一下 字典 :

    >>> t.__dict__
    {}
    
    >>> TestDesc.__dict__
    mappingproxy({'__module__': '__main__', '_x': <__main__.Desc object at 0x0000000002B0BA20>, '__init__': <function TestDesc.__init__ at 0x0000000002BC59D8>, '__dict__': <attribute '__dict__' of 'TestDesc' objects>, '__weakref__': <attribute '__weakref__' of 'TestDesc' objects>, '__doc__': None})
    

    怎么样,没骗你吧?我这人老好了,从来不骗人!

    我们再将 代码3 改进一下, 删除 set() 方法试试看会发生什么情况?

     #代码 4
    
    class Desc(object):
        def __init__(self, name):
            self.name = name
            print("__init__(): name = ",self.name)
            
        def __get__(self, instance, owner):
            print("__get__() ...")
            return self.name
            
    class TestDesc(object):
        _x = Desc('x')
        def __init__(self, x):
            self._x = x
    
    
    #以下为测试代码
    t = TestDesc(10)
    t._x
    
    #以下为输出:
    __init__(): name =  x
    

    我屮艸芔茻,咋回事啊?怎么木有去 调用 get() 方法?

    其实,还是 属性 查找优先级惹的祸,只是定义一个 get() 方法,为非数据描述符,优先级低于实力属性的!!

    问题4. 什么是数据描述符,什么是非数据描述符?

    答:一个类,如果只定义了 get() 方法,而没有定义 set(), delete() 方法,则认为是非数据描述符; 反之,则成为数据描述符

    问题5. 天天提属性查询优先级,就不能总结一下吗?

    答:好的好的,客官稍等!

    getattribute(), 无条件调用

    ② 数据描述符:由 ① 触发调用 (若人为的重载了该 getattribute() 方法,可能会调职无法调用描述符)

    ③ 实例对象的字典(若与描述符对象同名,会被覆盖哦)

    ④ 类的字典

    ⑤ 非数据描述符

    ⑥ 父类的字典

    getattr() 方法

    展开全文
  • Python基本语法之描述符

    千次阅读 2019-09-07 19:07:15
    描述符定义 描述符是一种类,我们把实现了__get__()、__set__()和__delete__()中的其中任意一种方法的类称之为描述符描述符的作用是用来代理一个类的属性,需要注意的是描述符不能定义在被使用类的构造函数中...

     

     

    描述符定义

           描述符是一种类,我们把实现了__get__()、__set__()和__delete__()中的其中任意一种方法的类称之为描述符。

           描述符的作用是用来代理一个类的属性,需要注意的是描述符不能定义在被使用类的构造函数中,只能定义为类的属性,它只属于类的,不属于实例,我们可以通过查看实例和类的字典来确认这一点。

           描述符是实现大部分Python类特性中最底层的数据结构的实现手段,我们常使用的@classmethod、@staticmethd、@property、甚至是__slots__等属性都是通过描述符来实现的。它是很多高级库和框架的重要工具之一,是使用到装饰器或者元类的大型框架中的一个非常重要组件。注:装饰器和元类等概念我们在以后文章中说明。

          如下示例一个描述符及引用描述符类的代码:

    class Descriptors:
    
        def __init__(self, key, value_type):
            self.key = key
            self.value_type = value_type
    
        def __get__(self, instance, owner):
            print("执行Descriptors的get")
            return instance.__dict__[self.key]
    
        def __set__(self, instance, value):
            print("执行Descriptors的set")
            if not isinstance(value, self.value_type):
                raise TypeError("参数%s必须为%s"%(self.key, self.value_type))
            instance.__dict__[self.key] = value 
    
        def __delete__(self, instance):
            print("执行Descriptors的delete")
            instance.__dict__.pop(self.key) 
    
    class Person:
    
        name = Descriptors("name", str)
        age = Descriptors("age", int)
    
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
    
    person = Person("xiaoming", 15)
    print(person.__dict__)
    person.name
    person.name = "jone"
    print(person.__dict__)

            其中,Descriptors类就是一个描述符,Person是使用描述符的类。

            类的__dict__属性是类的一个内置属性,类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里。

            在输出描述符的变量时,会调用描述符中的__get__方法,在设置描述符变量时,会调用描述符中的__set__方法。

            如上例子的运行结果如下:

     

    描述符的种类和优先级

           描述符分为数据描述符和非数据描述符。

           至少实现了内置__set__()和__get__()方法的描述符称为数据描述符;实现了除__set__()以外的方法的描述符称为非数据描述符。

          描述符的优先级的高低顺序:类属性 > 数据描述符 > 实例属性 > 非数据描述符 > 找不到的属性触发__getattr__()。

          在上述“描述符定义”章节的例子中,实例person的属性优先级低于数据描述符Descriptors,所以在赋值或获取值过程中,均调用了描述符的方法。

          如下例子描述了类属性高于数据描述符:

    class Descriptors:
        def __get__(self, instance, owner):
            print("执行Descriptors的get")
        def __set__(self, instance, value):
            print("执行Descriptors的set")
        def __delete__(self, instance):
            print("执行Descriptors的delete")
    
    class University:
        name = Descriptors()
        def __init__(self, name):
                self.name = name
    
    University.name
    University.name = "深圳大学"
    print(University.name)
    
    my_university = University("厦门大学")
    my_university.name
    print(my_university.name)

        在该例子中,University类的变量被赋值,由于该优先级最高,所以使用的一直为University类的变量,示例运行结果如下:

        如果在这个例子中,删除University.name = "深圳大学"这一行,则打印是怎么样的?

         为什么对象的name属性没有值了呢,因为对象的的优先级没有描述符高,所以使用描述符的值,而描述符没有赋值,所以为None,所以虽然对象的属性有值,仍然无法正常获取。

         描述符相关的优先顺序,理解难度稍微大一点,请各位看官仔细品味,大家可以自己写小例子尝试打印结果,可以让您更快的理解该原理。

     

     

    如果您喜欢这篇文章,别忘了点赞和评论哦!


                            十年一梦

                       一觉醒来思未变,

                      未知恍然已十年。

                      啜啜小儿成才俊,

                      市井矗楼连成片。

     

    展开全文
  • python中文件描述符In Python, a class that implements a get, set or delete methods for an object is called descriptors. Descriptors are the way to create attributes and add managed attributes to ...

    python中文件描述符

    In Python, a class that implements a get, set or delete methods for an object is called descriptors. Descriptors are the way to create attributes and add managed attributes to objects. These are used to protect the attributes from changes and any modifications. Descriptors can able to increase the readability of a program and coding skills. They can help to validate the data.

    在Python中,实现对象的get,set或delete方法的类称为描述符描述符是创建属性并将托管属性添加到对象的方法。 这些用于保护属性免受更改和任何修改。 描述符可以提高程序的可读性和编码技巧。 他们可以帮助验证数据。

    For example, we need only positive integer values for attribute age and string values for attribute string then descriptors provides an efficient solution.

    例如 ,对于属性年龄,我们只需要正整数值,对于属性字符串,我们只需要字符串值即可,然后描述符提供了有效的解决方案。

    To create a descriptor, we need __get__, __set__ and __delete__ methods.

    创建描述符 ,我们需要__get__ , __set__和__delete__方法。

    描述符协议 (Descriptor Protocol)

    To create a descriptor, we need a descriptor protocol. By defining the following methods we can efficiently manage the attributes. They are:

    创建描述符 ,我们需要一个描述符协议 。 通过定义以下方法,我们可以有效地管理属性。 他们是:

        __get__(self, obj, type=None)
        __set__(self, obj, value)
        __delete__(self, obj)
    
    

    Here,

    这里,

    • __get__ : It gets the value from an object and returns it.

      __get__ :它从一个对象获取值并返回它。

    • __set__ : It sets a value to the object and returns none.

      __set__ :它为对象设置一个值,但不返回任何值。

    • __delete__ : It deletes the value in the object and return none.

      __delete__ :删除对象中的值,不返回任何值。

    These methods are normally referred to as getter and setter methods. Python doesn't provide private variables and by using descriptors we can achieve them. The descriptor with the only __get__ method is called non-data descriptors and these are created only for a class, not for an instance. A class can have other than these methods if necessary.

    这些方法通常称为getter和setter方法 。 Python不提供私有变量,通过使用描述符我们可以实现它们。 具有唯一__get__方法的描述符称为非数据描述符,它们仅针对类而不是针对实例创建。 如果需要,一个类可以具有这些方法以外的其他方法。

    创建和调用描述符 (Creating and calling Descriptors)

    We can create a descriptor with many ways:

    我们可以通过多种方式创建描述符:

    1. Create a class and override any of the __get__, __set__ and __delete__ methods and use them.

      创建一个类并重写__get__ , __set__和__delete__方法中的任何一个并使用它们。

    2. We can use the property type to create descriptor.

      我们可以使用属性类型来创建描述符。

    3. We can create descriptors by combining both property type and python decorators.

      我们可以通过组合属性类型和python装饰器来创建描述符。

    Let look over each way of creating descriptor.

    让我们来看看创建描述符的每种方式。

    使用类创建描述符 (Creating descriptors using class)

    class rk:
    	def __init__(self):
    		self.value=0
    		
    	def __get__(self,ob, ty):
    		print ("get method")		
    		return self.value
    		
    	def __set__(self, ob, ty):
    		self.value = ty
    		print("set method",self.value)
    	
    	def __delete__(self, ob):	
    		print("delete method")
    		del self.value
    
    class inc:
    	r=rk()
    	
    a=inc()
    print(a.r)
    a.r=3
    del a.r
    
    

    Output

    输出量

    get method
    0
    set method 3
    delete method
    
    

    In the above program, the get method will __get__ the value, the __set__ method will set the value to attribute and __delete__ method will delete the attribute.

    在上面的程序中,get方法将__get__值, __set__方法将值设置为attribute, __delete__方法将删除属性。

    使用属性类型创建描述符 (Creating descriptor using property type)

    By using property() it is easy to create descriptors.

    通过使用property() ,很容易创建描述符。

    Syntax for creating a property method is:

    创建属性方法的语法为:

        property(fget=None, fset=None, fdel=None, doc=None)
    
    

    Here,

    这里,

    • fget : Function to be used for getting an attribute value

      fget :用于获取属性值的函数

    • fset : Function to be used for setting an attribute value

      fset :用于设置属性值的函数

    • fdel : Function to be used for deleting an attribute

      fdel :用于删除属性的函数

    • doc : docstring

      doc :文档字符串

    Now, the same program can be written using property type,

    现在,可以使用属性类型编写相同的程序,

    class rk:
    	def __init__(self):
    		self.value=0
    
    	def fget(self):
    		print("Get method")
    		return self.value
    
    	def fset(self, ty):
    		print ("Set method")
    		self.value = ty
    
    	def fdel(self):
    		print("delete method")
    		del self.value       
    
    	name = property(fget, fset, fdel, "I'm the property.")
    
    r=rk()
    r.name=1
    print(r.name)
    del r.name
    
    

    Output

    输出量

    Set method
    Get method
    1
    delete method
    
    

    使用属性类型和装饰器创建描述符 (Creating descriptors using property type and decorators)

    Python decorators are callable objects used to modify functions or classes. By using decorators we can modify the attribute methods.

    Python装饰器是用于修改函数或类的可调用对象。 通过使用装饰器,我们可以修改属性方法。

    Example to create descriptors using property type and decorators:

    使用属性类型和装饰器创建描述符的示例:

    class rk(object):
    	def __init__(self):
    		self.i=0
    
    	@property
    	def inc(self):
    		print("get method")
    		return self.i
    
    	@inc.setter
    	def inc(self, ty):
    		self.i=ty
    		print ("Set method",self.i)
    
    	@inc.deleter
    	def inc(self):
    		print ("delete method")
    		del self.i
    
    r=rk()
    
    print(r.inc)
    r.inc=3
    del r.inc
    
    

    Output

    输出量

    get method
    0
    Set method 3
    delete method
    
    

    描述符的优点 (Advantages of descriptors)

    Descriptors can increase the readability of a program and it can validate the data based on our requirements. These are low-level features and by using them we can reuse the code.

    描述符可以提高程序的可读性,并且可以根据我们的要求验证数据。 这些是低级功能,通过使用它们,我们可以重用代码。

    Descriptors create a way to implement private variables and manage the data. We can protect the attributes from any modifications and any updations.

    描述符创建了一种实现私有变量和管理数据的方法。 我们可以保护属性免受任何修改和更新。

    翻译自: https://www.includehelp.com/python/descriptor.aspx

    python中文件描述符

    展开全文
  • 深入理解Python描述符

    千次阅读 2017-09-08 14:01:02
    最近在看《流畅的Python》关于描述符的章节,平时也不经意间会接触到cached_property、sqlalchemy的Column、甚至内置的property都是描述符。在网上也看到过关于描述符的讲解,但是并没有区分覆盖型描述符和非覆盖型...
  • Python描述符

    2018-10-16 12:05:04
    描述符(descriptor)是定义了__get__()、__set__()和__del__()中一个或多个方法的类。 为何叫”描述”符呢?个人理解是描述符是一个辅助类,辅助对另一个类的属性进行”描述”。 举个例子:定义一个类是Person...
  • 官方说法:python描述符是一个“绑定行为”的对象属性,在描述符协议中,它可以通过方法重写属性的访问。这些方法有 `__get__()`, `__set__()`, 和`__delete__()`。如果这些方法中的任何一个被定义在一个对象中,这...
  • python描述符详解

    千次阅读 2017-01-06 15:21:13
    本文主要介绍描述符的定义,个人的一些理解;什么是数据描述符;什么是非数据描述符描述符的检测等。希望看完这篇文章后,你对描述符...当然,最大的目的是,通过学习描述符,让你对python这门语言有更多深入的认识。
  • python描述符的理解

    2019-10-10 17:37:20
    1.代码是很基础的,自定义一个描述符中执行过程不理解,望高手解答!!! ``` class MyProperty: def __init__(self,fget=None,fset=None,fdel=None): self.fget = fget self.fset = fset self.fdel ...
  • Python:os 取分隔

    千次阅读 2018-07-19 11:12:17
    描述 linesep 用于在文件中分隔行的字符串 sep 用来分隔文件路径名的字符串 pathsep 用于分隔文件路径的字符串 curdir 当前工作目录的字符串名称 pardir (当前工作目录的)父目录字符串名称 .....
  • Python转义字符空格字符

    万次阅读 2016-05-17 17:11:22
    在需要在字符中使用特殊字符时,python用反斜杠(\)转义字符。如下表: 转义字符 描述 \(在行尾时) 续行 \\ 反斜杠符号 \' 单引号 \" 双引号 \a 响铃 \b 退格...
  • Python中的各种转义\n\r\t

    万次阅读 2018-12-24 23:46:46
    转义 描述 \ 续行(在行尾时) \\ 反斜杠符号 \’ 单引号 \” 双引号 \a 响铃 \b 退格(Backspace) \e 转义 \000 空 \n 换行 ...
  • 在需要在字符中使用特殊字符时,python用反斜杠(\)转义字符。如下表: 转义字符 描述 \(在行尾时) 续行 \\ 反斜杠符号 \' 单引号 \" 双引号 \a 响铃 \b 退格(Backsp...
  • python \r \t \n 各种转义字符

    万次阅读 多人点赞 2018-04-21 15:43:21
    转义字符描述\(在行尾时)续行\\反斜杠符号\’单引号\”双引号\a响铃\b退格(Backspace)\e转义\000空\n换行\v纵向制表\t横向制表\r回车\f换页\oyy八进制数yy代表的字符,例如:\o12代表换行\xyy十进制数yy代表的...
  • python文件行结束问题

    千次阅读 2016-03-30 17:48:00
    由于平台不同行结束不同,Python中解决了这个问题, os 模块属性 描述 linesep 用于在文件中分隔行的字符串 sep 用来分隔文件路径名的字符串 pathsep 用于分隔文件路径的字符串 curdir 当前工作目录的字符串...
  • 问题描述: 在windows中,标准分隔是 \\ , 换行是\r\n 在UNIX中,标准分隔是 / ,换行是\n   解决方法: 用python中的os模块中的变量,替换各种路径符号 换行 os.linesep \r\n 分隔 os....
  • python中的转义字符

    万次阅读 2018-11-17 12:19:26
    http://www.runoob.com/python3/python3-string.html Python转义字符 ... 描述 \(在行尾时) 续行 \\ 反斜杠符号 \' 单引号 \" 双引号 \a 响铃 \b 退格(Backspace)...
  • python中的转义\

    千次阅读 2018-03-14 20:52:51
    python允许对某些字符进行转义操作,来实现一些难以单纯用字符描述的效果。具体见python中的转义及其应用需要输入 \ 字符本身时,用 \\ 代替即可。
  • Python:文件描述符

    千次阅读 2018-11-02 16:12:48
    #!/usr/bin/env python # coding:UTF-8 "...@file: 文件描述符.py @time: 2018/11/2 16:05 """ """ 1、open()函数的file参数,除了可以接受字符串路径外...
  • 描述Python split()通过指定分隔对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串语法split()方法语法:str.split(str="", num=string.count(str)).参数str — 分隔,默认为所有的空...
1 2 3 4 5 ... 20
收藏数 85,800
精华内容 34,320
关键字:

python描述符