python tips（持续更新中）

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