python tips

可变对象与不可变对象

在python中，可变对象有数值类型（int,float），字符串（str），元组（tuple），可变对象有列表（list），字典（dict），集合（set）。在赋值操作中 可变对象是复制的对象本身，相当于复制了对象的指针，对赋值后的修改会修改原来的对象 例如：
```
In [1]: b = [1,2,3,4]

In [2]: _b = b

In [3]: id(_b)

Out[3]: 4519417736

In [4]: id(b)

Out[4]: 4519417736

In [5]: _b.append(6) # 修改_b，b也会跟着一起变化，因为_b和b指向的是同一个地址

In [6]: b

Out[6]: [1, 2, 3, 4, 6]
```

可以看出修改了_b的值，也修改了b的值，如果想仅仅修改_b的值，需要使用 _b = copy.copy(b) 而不是简单的_b = b。

对于不可变对象，对象本身的值是不能修改的，每次对其的操作都会生成一个新的对象，保存新的值。如下：

```python

In [1]: a = "sss"

In [2]: id(a)

Out[2]: 4338243040

In [3]: a += "c" # 不可变对象的赋值并不会使用同一个地址，所以id会发生变化

In [4]: id(a)

Out[4]: 4338242704

```

所以在函数中传入可变对象的时候，要小心，因为可能修改原有的对象。

元编程（metaclass）

在正常业务开发时很少使用，但在一些库中经常遇到，例如Django的ORM，其主要功能是在类初始化（不是实例化）的时候，定义一些行为和操作，代码如下

import os

import numpy

import random

class MetaClass(type):

    def __init__(self, *args, **kwargs):

        print('Meta Init')

    def __new__(cls, name, base, attr):

        print('class_name is :' , name)

        print(base,' is the Base *****')

        print(cls.v, getattr(cls, 'b', 99 ))

        print('==========')

        del cls.v

        return super(MetaClass, cls).__new__(cls, name, base, attr)

class Model(metaclass=MetaClass): # python3中指定metaclass指定方式

    __metaclass__ = MetaClass # python2中指定方式

    MetaClass.v = 100

    MetaClass.b = '-------------'

    c = 9

    def __new__(cls, name, base, attrs):

        print('Model New---')

        return super(Model, cls).__new__(cls, name, base, attrs)

    def __init__(self, *args, **kwargs):

        self.arg = args

        self.kwargs = kwargs

    def __str__(self):

        return "test Models ----->>>>>>"

class Test(metaclass=MetaClass):

    __metaclass__ = MetaClass

    MetaClass.v = 888

class Serial(Model):

    MetaClass.v = 777

class test(Serial):

    MetaClass.v = 666

在import 或者直接运行的时候，我们没有做任何类的实例化操作，但还是会有下面的打印信息，会发现，继承的每个类都运行了metaclass中的__new__和__init__方法

class_name is : Model

()  is the Base *****

100 -------------

==========

Meta Init

class_name is : Test

()  is the Base *****

888 -------------

==========

Meta Init

class_name is : Serial

(<class '__main__.Model'>,)  is the Base *****

777 -------------

==========

Meta Init

class_name is : test

(<class '__main__.Serial'>,)  is the Base *****

666 -------------

==========

Meta Init

slots

在python中，一般我们可以*的给类，实例添加属性，然而有时候我们并不希望这样，我们需要指定的类只能有我们要求的这些属性，在这种情况下，我们引入了__slots__ 例如：

class R(object):

    """在这个类中，我们只能添加prev，next等的属性，

    当尝试添加别的的时候，会报AttributeError"""

    __slots__ = 'prev', 'next', 'key', '__weakref__'

class Link(R)：

    “”“__slots__ 不会被继承，所以在这个类中可添加指定之外的属性”“”

    pass

class Node(R):

    """添加了 __slots__ 之后，父类的 __slots__也会生效，此时，

    限制的属性为 value， prev, next 等

    """

     __slots__ = "value",

Django Queryset 切片

我们知道Django 的queryset是lazy的，只有当真正使用的时候才会去数据库取数据，并且缓存取出来的数据。

所以对于没有执行的queryset，切片操作之后仍然是queryset，执行sql之后的queryset，切片会变成list。
```
In [2]: qs = Order.objects.all()

In [3]: qs_1 = qs[10:20]

In [4]: type(qs_1)

Out[4]: django.db.models.query.QuerySet

In [5]: _qs = list(qs) # 会查询数据

In [6]: qs_2 = qs[10:20]

In [7]: type(qs_2)

Out[7]: list
```

秒客网

python tips（持续更新中）

python tips

相关文章