django面试七

Dango model 几种继承形式
抽共享继承
不能等实例化，抽象方法必须在子类中实现，Django不对其建立对应的表。
class Animal(models.Model):
name = models.CharField(max_length=50)
age = models.PositiveIntegerField()

# 下面这句决定了Animal是一个抽象类/Model
class Meta:
abstract = True

class Human(Animal):
kind_hearted = models.BooleanField()
sex = models.CharField('sex', choices=(('m','male'), ('f', 'female')), max_length=1)
#...
正常继承
父类可以被实例化，Django也生成对应的表。
代理
Django 的代理类不会生成对应的表，与父类公用一张表，并且代理类不能增加属性，只能增加方法。
from django.db import models

# Create your models here.

class Person(models.Model):
name=models.CharField(max_length=8)

class ProxyPerson(Person):
class Meta:
proxy=True

def doSomething(self):
pass

# 定义了一个ProxyPerson类、proxy 和abstract 写法上并没有什么不一样；
# 只是把abstract=True 变成proxy=True就行了

自定义manage类
# new manager
class OrderManager(models.Manager):
def title_count(self, keyword):
return self.filter(title__icontains=keyword).count()

class Order(models.Models):
title = models.CharField(max_length=100)
# ...
#objects = models.Manager()
objects = OrderManager()
#此处相当重写了计数函数
def __unicode__(self):
return self.title

Django 级联删除
一个对象被对个对象当做外键引用，当删除指个对象后，默认把所有包含此对象外键的对象也删除，称作级联删除，为了避免级联删除，进行如下设置：
class Host(models.Model):
hostname = models.CharField(max_length=20,primary_key=True, blank=False)
static_ip = models.CharField(max_length=20,unique = True)

class CCRole(models.Model):
name = models.CharField(max_length = 20,primary_key = True)
host = models.ForeignKey(Host,null=True,blank=True,on_delete=models.SET_NULL)
# 增加了on_delete=models.SET_NULL这样就阻止了级联删除，但前提是null=True
Django日志
此处只使用一种作为示例
import logging
from django.db import models
from django.db.models.signals import pre_save
from django.dispatch import receiver

class Order(models.Model):
# ...
logger = logging.getLogger(__name__)

@receiver(pre_save, sender=Order)
def pre_save_handler(sender, **kwargs):

# 我们可以在Order这个Model保存之前输出想要的信息了
logger.debug("{},{}".format(sender, **kwargs))

Django session & cookies
相对于session，cookies是不安全的，所以Django只在cookies中存放session_id，将重要的信息加密存到服务器端。
session / cookies 操作
#给本地保存session
request.session['order_id'] = order_id
#删除session
del request.session['order_id']
#读取session
session.get['order_id',False]

python 三种类方法
实例方法、类方法、静态方法
class A(object):
def foo(self, x):
print('实例方法，使用的时候必须传递实例，即这块的self')

@classmethod
def class_foo(cls, x):
print ('类方法，使用的时候必须传递类对象，eg: A.class_foo(x)')

@staticmethod
def static_class(x):
print ('静态方法')

python 自省
type()#输出对象类型
dir()#输出对象的所有方法
hasattr()#判断是否有属性
isinstance(1,(int,float))#是否是某一类型

下划线
__foo__:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突.

_foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.

*args and **kwargs
*args 作为函数参数意为参数为不确定数量的变量
**kwargs 作为函数的变量意为不确定的字典型变量

Python的单例模式
单例模式

python 闭包函数
-在Python中创建一个闭包可以归结为以下三点：

闭包函数必须有内嵌函数
内嵌函数需要引用该嵌套函数上一级namespace中的变量
闭包函数必须返回内嵌函数

闭包函数参考

函式编程与lambda
#coding:utf8
#函数是编程+lambda
#fileter是一个过滤器,输出100内的偶数
print filter(lambda x:x%2==0 ,range(1,101))
#map是对每一项依次调用函数
print map(lambda x:x*x , [1,2,3])
#reduce是对序列每一项进行迭代，改式子是计算100以内的和
print reduce(lambda x,y:x+y ,range(1,101))
#生成斐波那契数列
f = [1,1]
print [f.append(f[-1]+f[-2]) or f.pop(0) for i in range(100)]

copy deepcopy
简单总结：一般的直接赋值相当于把a开辟的内存地址传给另一个变量b，当在对a进行修改操作时候相当于在该内存中进行操作，所以b也随之变化。
copy是仿照a也开辟一块内存将a中的值进行复制，不过当a中有数组时，c复制的也是内存地址，所以当a中的数组变化时候c中的数组也会变化。
deepcopy是进行深层次的复制，将a里面的数组也进行了复制，不同于copy的复制内存地址，所以a怎么变都不会影响d。
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象

b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝

a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象

print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d

输出结果：
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]
is ==
is 比较地址
== 比较值

match search
match 只匹配头部
search 匹配所有

下划线问题
_ 私有属性
__ 只能通过类中获取，dict可以查看属性

封装
其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容

多态
不同子类对同一方法的重写有各自的特色。

Python2 Python3区别
print 由语句变为函数
2中分新式类(object)和就旧式类,新广度优先、旧深度优先。
3中/除 //整除
字典排序
dic = {'key2':2, 'key3':3, 'key4':1,}
print(sorted(dic.items(),key = lambda item : item[1]))
1
2
复制 浅拷贝 深拷贝
赋值
只拷贝引用
浅拷贝
没有拷贝子对象，所以子对象会随着原始对象改变，比如listl里面的list会随着之前的变化。
深拷贝
就是子对象也拷贝了的