python的 cursor 函数 python cursor.description

转载

是大魔术师 2024-02-10 01:42:31

文章标签 python高级编程 python属性控制 python描述符 文章分类 Python 后端开发

本文声明：python的描述符descriptor，这是属于python高级编程的一些概念和实现方法，可能有很多的小伙伴还并没有用到过，但是在Python的面试过程中有可能会出现，究竟什么是python描述符，有什么作用，使用有什么意义，它的诞生背景是什么，很少有文章专门介绍这一块，有的文章介绍的太过粗浅，以至于看过之后依然不能够理解描述符的本质。鉴于此，我寻思着出一期专门讲解python描述符的系列文章，跟前面的python装饰器系列文章一样，因为涉及到的内容偏多，本文依然是分为上、中、下、补充篇四个系列部分进行讲解，本文是第一篇——上篇，介绍Python的对象的属性访问优先级与对象属性的简单控制。

一、从对象的dict属性开始说起

1、首先看一个很奇怪的现象，从习以为常的现象说起——类属性or实例属性？。

我们都知道，在Python的面向对象里面，他的灵活程度是比其他语言更加灵活的，为什么这么说呢？因为一下几点：

（1）python面向对象中，类属性，我既可以通过类名访问，也可以通过实例访问（这与C#不同，C#的静态属性只能够通过类访问，不能够通过实例访问）

（2）python中的类方法（@classmethod装饰的方法），我也可以通过类名访问，也可以通过实例访问（这与C#中的静态方法也不一样）

我们可以通过一个例子来说明，代码如下：

class Animal:
    name='老虎'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        return '我需要吃东西！'

    @classmethod
    def sleep(cls):
        return '我需要睡觉'

a=Animal('老虎',5)   #构造对象
print(a.name)        
print(a.age)
print(a.eat())
print(a.sleep())    #实例也可以访问类方法哦！
#----------------------------------
print(Animal.name)
print(Animal.sleep())

上面的运行结果为：

老虎
5
我需要吃东西！
我需要睡觉
老虎
我需要睡觉

细心的小伙伴应该发现了一个问题，在Animal中我定义了两个属性name，一个是类属性、一个是实例属性，这里因为这二者的值都是“老虎”，我没有办法辨别，a.name 到底是输出的类属性还是实例属性啊，如果我们改一下，改成如下：

a=Animal('狮子',5)   #构造对象
print(a.name)

发现运行结果为：

狮子

得到的结论是，a.name 访问的是实例属性。那到底怎么判断呢？通过我的__dict__属性去判断。

2、再看一个关于类继承的例子——子类属性or父类属性？

先看一个例子，代码如下：

class Animal:
    name='老虎'
    def __init__(self,name='老虎',age=5):
        self.name=name
        self.age=age
    def eat(self):
        return '我需要吃东西！'

    @classmethod
    def sleep(cls):
        return '我需要睡觉'

class Dog(Animal):
    #name_='小狗'
    def __init__(self,age):
        self.age=age

d=Dog(8)
print(d.name)  
print(d.age)

运行结果为：

老虎 #说明子类继承了父类的类属性

两种关系

关系一：类成员与实例成员的关系（包括属性和方法这两种成员）

关系二：父类和子类的关系

那这二者具体的关系到底是怎么样的呢？先告诉你答案吧！

对于关系一而言，实例是可以访问类的成员的，但是类不能访问实例成员；对于关系二而言，子类继承父类的类成员和实例成员。

3、python对象的__dict__属性

上面的两个例子所反映出的实际上是一个“属性的优先级问题”，即什么样的属性优先访问。

Python一切皆对象，故而都有__dict__属性，包括对象实例、函数、类本身。我们可以通过对象的__dict__查看，它返回的是一个字典对象，对于下面的代码，

class Animal:
    name='老虎'
    def __init__(self,name='老虎',age=5):
        self.name=name
        self.age=age
        self.weight=200
    def eat(self):
        self.height=100
        return '我需要吃东西！'

    @classmethod
    def sleep(cls):
        return '我需要睡觉'

class Dog(Animal):
    def __init__(self,age):
        self.age=age

a=Animal()
d=Dog(8)
print(Animal.__dict__.keys())
print(a.__dict__.keys())
print(Dog.__dict__.keys())
print(d.__dict__.keys())

运行结果为：

dict_keys(['__module__', 'name', '__init__', 'eat', 'sleep', '__dict__', '__weakref__', '__doc__'])
dict_keys(['name', 'age', 'weight'])
dict_keys(['__module__', '__init__', '__doc__'])
dict_keys(['age'])

由此可见，实例a最先直接访问的属性就只有name,age,weight，并不包含类属性name，我们可以这么，name、age、weight是属于a的，但是类属性name是不属于a的。

那么，对象对属性的访问到底遵循怎样一个优先级呢？先告诉你答案！

①.实例属性

②.类属性

③.父类的类属性

④.__getattr__()方法（访问一个不存在的属性的时候发生的行为）

二、对象属性访问的优先级——这里只考虑“属性”，方法就不去考虑了。

根据上面的描述，我们来做一个实验，

class Animal:
    name='老虎'
    def __init__(self):
        pass

class Dog(Animal):
    age=10
    def __init__(self,height):
        self.height=height
    def __getattr__(self,propertyname):
        if propertyname=='weight':
            return 200
        else:
            raise AttributeError

d=Dog(150)
print(d.height)
print(d.age)
print(d.name)
print(d.weight)

运行结果为：

150 #第一优先级访问，访问实例属性
10 #第二优先级访问，访问类属性
老虎 #第三优先级访问，访问父类的类属性
200 #第四优先级访问，如果这里改成d.sex，则会抛出异常
总结：对象属性的访问优先级顺序为：

①.实例属性

②.类属性

③.父类的类属性

④.__getattr__()方法

三、python中的“对象的控制方法”

我们经常看见下面的一些魔术方法，比如__getattribute__、__getattr__、__setattr__、__delattr__，那么他们每一个函数代表什么意思呢，在什么样的使用场景下使用呢？他们到底有什么样的作用，使用这些方法有什么意义？本文都将一一讨论。

1、__getsttribute__方法：当一个属性被访问的时候发生的行为，称之为“属性拦截器”

Python中只要定义了继承object的类，就默认存在属性拦截器，只不过是拦截后没有进行任何操作，而是直接返回。所以我们可以自己改写__getattribute__方法来实现相关功能，比如查看权限、打印log日志等

Python的属性访问方式很直观，使用点属性运算符。在新式类中，对对象属性的访问，都会调用特殊方法__getattribute__。__getattribute__允许我们在访问对象属性时自定义访问行为，但是使用它特别要小心无限递归的问题。

通过一个简单的例子来说明：‘

class Animal(object):
    run = '我会跑'
    def die(self):
        return '我会死'
class Dog(Animal):
    color='Blue'
    def __init__(self, name,age):
        self.name=name
        self.age = age
    # 重写__getattribute__。需要注意的是重写的方法中不能
    # 使用对象的点运算符访问属性，否则使用点运算符访问属性时，
    # 会再次调用__getattribute__。这样就会陷入无限递归。
    # 可以使用super()方法避免这个问题。
    def __getattribute__(self, key):
        print('调用了__getattribute__属性')
        return super(Dog, self).__getattribute__(key)
    def sound(self):
        return "汪汪汪"

dog=Dog('泰迪',4)
print(dog.name,end='\n------------------------------\n') #调用实例属性
print(dog.age,end='\n------------------------------\n')
print(dog.color,end='\n------------------------------\n') #调用方法属性
print(dog.run,end='\n------------------------------\n')   #调用父类的类属性
print(dog.sound(),end='\n------------------------------\n') #调用实例方法
print(dog.die(),end='\n------------------------------\n')  #调用父类的方法

运行结果为：

调用了__getattribute__属性
泰迪
------------------------------
调用了__getattribute__属性
4
------------------------------
调用了__getattribute__属性
Blue
------------------------------
调用了__getattribute__属性
我会跑
------------------------------
调用了__getattribute__属性
汪汪汪
------------------------------
调用了__getattribute__属性
我会死
------------------------------

从上面的例子中，我们可以看出，不管是访问对象的实例属性、类属性、父类的类属性、对象方法、父类方法，总是需要先过__getattribute__着一关的，即如果定义了__getattribute__魔法方法，他总是优先调用，要不怎么称之为“属性拦截器”呢。

2、__getsttribute__方法的升级实现

事实上，关于__getattribute__的重写，并不是一定要按照上面的格式，他可以有更加灵活的方式去实现的，上面的拦截方式太简单了，不管我做什么都是打印同样一句话，这很没特点，我要使得调用不同的属性，显示不同的信息该怎么做呢？比如我也可以这样，将上面的__getattribute__函数体重新定义如下：

def __getattribute__(self, key):
        if key=='name':
            print('name属性被调用了')
            return super(Dog, self).__getattribute__(key)
        elif key=='age':
            print('age属性被调用了')
            return super(Dog, self).__getattribute__(key)
        elif key=='color':
            print('color属性被调用了')
            return super(Dog, self).__getattribute__(key)
        elif key=='run':
            print('run属性被调用了')
            return super(Dog, self).__getattribute__(key)
        elif key=='sound':
            print('sound方法被调用了')
            return super(Dog, self).__getattribute__(key)
        elif key=='die':
            print('die方法属性被调用了')
            return super(Dog, self).__getattribute__(key)
        else:
            print('调用了__getattribute__属性')
            return super(Dog, self).__getattribute__(key)
    def sound(self):
        return "汪汪汪"

dog=Dog('泰迪',4)
print(dog.name,end='\n------------------------------\n') #调用实例属性
print(dog.age,end='\n------------------------------\n')
print(dog.color,end='\n------------------------------\n') #调用方法属性
print(dog.run,end='\n------------------------------\n')   #调用父类的类属性
print(dog.sound(),end='\n------------------------------\n') #调用实例方法
print(dog.die(),end='\n------------------------------\n')  #调用父类的方法
print(dog.height,end='\n------------------------------\n')  #调用一个不存在的属性

运行结果为：

name属性被调用了
泰迪
------------------------------
age属性被调用了
4
------------------------------
color属性被调用了
Blue
------------------------------
run属性被调用了
我会跑
------------------------------
sound方法被调用了
汪汪汪
------------------------------
die方法属性被调用了
我会死
------------------------------
调用了__getattribute__属性
Traceback (most recent call last):显示没有定义height属性。

注意：没一个条件分支一定要返回父类的__getattribute__方法哦，如果没有返回，会发现虽然打印了相关的提示信息，但是并没有返回属性或方法的值，而是返回的一个None。

3、__getsttribute__方法的使用陷阱——“无限递归”问题

def __getattribute__(self, key):
        if key=='sound':
            print('sound方法被调用了')
            return self.sound()
        else:
            print('调用了__getattribute__属性')
            return super(Dog, self).__getattribute__(key)
    def sound(self):
        return "汪汪汪"

比如改成如上代码：上面的代码运行并不会出现预期的结果，即

sound方法被调用了

汪汪汪

为什么呢？因为调用self.sound()方法的时候一定会先调用__getattribute__方法，然后__getattribute__里面又调用sound方法，然后又调用__getattribute__方法。。。。。。如此递归循环下去，而且没有退出机制，知道程序崩溃。

4、__getattribute__的注意事项

（1）一定要在每一个需要访问的属性里面设置返回值，否则会返回None，一般有两种做法，

即：return super(Dog, self).__getattribute__(key)这种形式

或：return object.__getattribute__(self,key)

即返回父类的__getattribute__方法。

（2）不要再在__getattribute__方法的定义内部显示使用self.成员这种方法，这样可能会造成无限递归，导致系统崩溃。