Django基礎筆記

時間 2019-11-13

標籤 django 基礎筆記欄目 Python 简体版

原文原文鏈接

django隨記：
Django URL配置原則：鬆耦合原則，鬆耦合是一個重要的保證互換性的軟件開發方法。
例如urls.py 是用來配置url的     views.py是用來配置視圖函數的，兩者之間是鬆耦合的！
Django中時區的設置，在Django中加入在/home/zhou中經過django-admin.py   startproject mysite建立一個mysite的應用
此時在/home/zhou文件夾下會生成一個manage.py文件，同時會有一個mysite的文件夾。 manage.py所在的目錄會自動被加入進python的path.   這個設置對於整個python工程有效
mysite文件夾下的文件以下：
__init__.py
urls.py
settings.py
wsgi.py
本身添加部分文件後次文件以下所示：
__init__.py
models.py      --
views.py       --
settings.py
wsgi.py
templates （模板文件夾）
settings.py內時區設置：默認的時區爲TIME_ZONE="America/Chicago"修改成TIME_ZONE="Asia/Shanghai"北京時區。
2015sjgc1314
USE_TZ=False    （若不這樣設置，結果數據庫主動填充的仍是錯了8個小時！）
LANGUAGE_CODE="zh-CN"     可使djangoadmin變成中文版本
django中捕獲get中參數：
從技術上說，所捕獲值老是unicode objects，而不是簡單的str
舉例以下：
urls.py中   r"^time/(\d+)",timeAhead
views.py中：
def timeAhead(request,dt):
    pass
django中模板的設置在：
例如：mysite應用中設置template文件夾爲 templates
settings.py中
TEMPLATE_DIRS=(os.path.join(os.path.dirname(__file__),"templates")，)
且能夠添加多個目錄。
8.214     !@#$!&$%UJNAV
進入django的shell:
python manage.py shell能夠進入django的shell終端，在此終端內能夠對django的模板系統進行練習，其是按照setting.py中的配置進行啓動的，其依賴於配置文件
一：關於正則表達式
^匹配開始
$匹配結束
^hello/$僅僅對hello/進行匹配
^hello 對以hello開頭的全部字符串進行匹配
.任意單個字符
\d任意一位數字
[a,z]a-z中任意一個
[A-Z] A-Z中任意一個
[a-zA-Z]a-z中任意一個，且不區分大小寫
+ 匹配一個或更多   \d+
? 匹配0個或1個    \d+
{1,3} 匹配1-3個
（）小括號用來括起來的部分會被提取出來。用來提取字符串。例如
url(r"hello/(\d{1,2})/",views.num)
二：django模板系統：
模板一般用於產生HTML，可是django的模板也可以產生任何給予文本格式的文檔。
template.Template類用於產生模板
template.Context類用於產生上下文環境，相似於python的字典數據類型。
舉例：
from django import template
t=template.Template("my name is {{name}}")
c=template.Context({"name":"zhou"})
print t.render(c)
{{name}}    name爲變量
{%if name%}   if name 爲模板標籤   相似的還有for item in itemlist模板標籤。
django模板系統舉例2：
from django import template
t=template.Template("my name is {{name.upper}}")
c=template.Context({"name":"abcd"})
print t.render(c)
相似的還有
templaget.get_template("index.html")
1. 在django的模板系統中是支持方法調用或屬性調用的。固然其是沒法傳入參數的。僅僅能夠調用無參數的方法或者普通屬性。調用是要注意，避免delete方法。   這樣會致使異常。
若是用t.render(template.Context())
方法進行渲染時，結果爲my name is   變量不會顯示。
同時.也能夠進行列表索引。
例如name.1   將會用列表的第一個元素
若是爲name.abc
此時系統會按照以下順序進行查找：
字典類型查找： name["abc"]
屬性查找：name.abc
方法查找：name.abc()
列表索引查找： name[abc]
利用模板進行方法調用時要注意:若是此方法引起一個異常會致使整個頁面拋出異常，除非該異常有一個屬性silent_variable_failure屬性，而且值爲True
若是一個變量不存在，模板系統會把它展現位空字符串。不作任何事情來表示失敗。
2.基本的模板標籤和過濾器
if：
{%if name%}
...........
{%else%}
.....
{%endif%}
if能夠和and or not配合使用。and or not不要混用    else是可選的。
for:
{% for item in list%}
..............
{%endfor%}
{% for item in list reversed %}
..............
{%endfor%}
django不支持退出循環，若是想要退出循環，能夠改變正在迭代的變量，讓其僅僅包含須要迭代的項目
在每一個{% for %}循環內部有一個成爲forloop的模板變量，這個變量有一些提示循環進度信息的屬性。
{%for item in todo_list%}
   <p>{{forloop.counter}}:{{item}}</p>
{%endfor%}
相似的變量還有forloop.counter0
forloop.revcounter
forloop.revcounter0
forloop.first
forloop.last
ifequal:
{%ifequal a "abc"%}
....
{%else%}
........
{%endifequal%}
ifnotequal:
{%ifnotequal a "abc"%}
.....
{%else%}
....
{%endifnotequal%]
3.註釋：
{#this is a comment#}
4.過濾器
{{name|lower}}   顯示的內容是變量name通過濾器處理過的結果。 javascript

5.常見的特殊符號的輸出： css

openblock {%
closeblock %}
openvariable {{
closevariable }}
openbrace {
closebrace }
opencomment {#
closecomment #} html

{{bio|truncatewords:"30"}} 過濾器能夠有參數。
最經常使用的過濾器：
addslashes:添加反斜槓到任何反斜槓、單引號或者雙引號前面，這在包含javascript的文本時是很是有用的
length:返回變量的長度，列表、元祖、字符串都可。
django模板的理解：
from django import template
from django.template import context
a=template.Template("{{a}}悉知")
b=context.Context({"a":"鄭州"})
c=a.render(b)
len(c) ----4   print c   鄭州悉知
aa=template.Template(u"{{a}}悉知")
bb=context.Context({"a":"鄭州"})
cc=aa.render(bb)
len(cc)   ----4   print cc 鄭州悉知
在django中能夠作以下理解：
template.Template（args）會先把args轉化爲Unicode字符串（根據當前的文件的字符編碼）
context.Context(args) 也會先把args轉化爲Unicode字符串（根據當前的文件的字符編碼）
而後再django的模板渲染器（純unicode環境）中進行渲染，最後返回一個類Unicode字符串。（其實就是Unicode字符串，只不過其歸屬類不是Unicode）你能夠輕易的用unicode() 把其轉化爲python的unicode字符串。
HttpResponse()或者render_to_response()等相似的,其實都是把unicode()轉化爲Utf-8返回給瀏覽器的。！
綜上：
在html中要用utf8編碼。
在python文件中要用Utf8編碼
django的這些特性使得在網頁中使用中文很是容易。   其老是返回給瀏覽器Utf8類型的Html，其在內部渲染器老是unicode環境
三：模板的使用
from django.shortcuts import render
# Create your views here.
from django.http import HttpResponse
from django import template
from django.template.loader import get_template
from django.shortcuts import render_to_response
import datetime
def hello(request):
    return HttpResponse(str(datetime.datetime.now()))
def num(requset,offset):
    #temp=get_template("num.html")
    #html=temp.render(template.Context({"num":123}))
    #return HttpResponse(html)
    return        render_to_response("num.html",template.Context({"num":456}))
四：模板的繼承
定義一個base.html文件
<html lang="en">
<title>{%block title%}hello world{%endblock%}
</title>
<body>
{{text}}
</body>
</html>
人後在extend.html中
{% extends "base.html"}
{%block title%}THE CURRENT TIME {% endblock%}
在使用的時候能夠用render_to_response("entend.html",template.Context({"text":"hello world!"}))
五：模型
1.django中模型也就是和數據庫相關的抽象。
django和數據庫鏈接時和settings.py有很大關係。
其中例如django和mysql數據庫進行鏈接的時候要配置好這個文件：
例如
DATABASES={
'default':{
'ENGINE':'django.db.backends.mysql',
'NAME':'test',
'USER':'root',
'PASSWORD':'123456',
'HOST':'192.168.8.137',
'PORT':'3306',
}
}
注意： host部分最好要填ip地址，即使是本機！
測試是否設置正確了：
python manage.py shell
from django.db import connection
cursor=connection.cursor()
若是上面兩個語句執行沒有錯誤，那麼數據庫鏈接已經成功了。
2.在django中項目--- 應用--
python manange.py startapp users
在項目中建立一個應用
user目錄中的結構以下：
__init__.py
models.py
tests.py
views.py
models.py是用於建立應用的。 views.py是用於建立視圖函數。
整個建立一個django項目的流程應該以下：
建立一個項目mysite在/home/zhou下
/home/zhou/mysite下面會存在
manage.py
mysite 文件夾
進入mysite文件夾
python ../manage.py startapp schoop
此時在/home/zhou/mysite/mysite下面會存在一個文件夾
school   內有__init__.py models.py tests.py views.py
對於settings.py文件通常要設置時區 TEMPLATE_DIRS      INSTALLED_APPS DATABASES數據庫   一切和路徑相關的都是以manage.py所在位置爲準的。
python manage.py sqlall school
3.from mysite.school.models import Teacher
a=Teacher(name="zhou",age=22)
a.save()       #更新全部更該到數據庫，記住，加入你僅僅改了某一列，其會更新全部列！
4.每個模型，例如Teacher Student 都具備一個管理器，
Teacher.object 就是Teacher模型的管理器，
經常使用的如：
a=Teacher.object.all()
for i in a:
    print i.name,i.age
b=Teacher.object.filter(name="zhou)
for i in b:
    print i.name,i.age
c=Teacher.object.filter(name_contains="ou") #相似的還有name_icontains name_startwith name_endwith   range等
d=Teacher.object.get(name="zhou")     #返回耽擱對象，不是列表，若是結果是多個對象則會拋出異常，查詢沒有結果也會拋出異常
e=Teacher.objects.order_by("age")    #「-age」表示逆序
for i in e:
    print i.name,i.age 前端

DecimalField java

固定精度的十進制數，通常用來存金額相關的數據。對應python的Decimal，額外的參數包括DecimalField.max_digits 位數和DecimalField.decimal_places 小數位數，這個仍是要參照一下mysql的Decimal類型，http://database.51cto.com/art/201005/201651.htm python

例如：price = models.DecimalField(max_digits=8,decimal_places=2) mysql

5.在Teacher模型下能夠新建一個類class Meta來附加一些說明性的信息。
class Teacher:
    *****
    *****
    class Meta:
        ordering=['name']
表示在進行排序的時候order_by()函數會默認用"name"做爲參數
6.連續查詢
a=Teacher.objects.filter().order_by("age") #先查後排序
7.限制返回的數據
c=Teacher.objects.filter()[0]
8.更新多個對象
a=Teacher.objects.filter(name="li").update(name="wang")
update用於更新一個或多個對象的制定列
9.刪除多個對象
a=Teacher.objects.filter()
a.delete()
__author__ = 'Administrator'
from django.db import models
class test(models.Model):
    name=models.CharField(null=True,max_length=20)
    name_1=models.CharField(null=False,max_length=20)
    age=models.IntegerField(null=True)
    age_1=models.IntegerField(null=False)
若是容許某一列字段爲空能夠按照以下的規則：
對於非日期、非數字型的來講(如CharField，FilePathField)：
null=True 是用來指定此field能夠爲null ,當save時，不指定此filed則會插入null
null=Flase 是用來指定此field不能夠爲null,當save是，不指定此field則會插入''
對於日期型、數字型的來講：
null=True 是用來指定此field能夠爲null, 當save時，若是不指定此field則會插入null
null=False 是用來指定此field不能夠爲null，當save時，若是不指定此field則會報錯
blank的做用是指定在admin頁面中這個字段是否能夠不填。
Meta類經常使用的參數：
    class Meta:
        db_table="test_table"
        verbose_name="test_table"   #如 User model對應於————User，主要用於admin頁面中
        verbose_name_plural="test_tables" #如User model 對應於---- Users，主要用於admin頁面中
每一個APP中若是須要用到admin頁面管理數據庫的話，那麼每一個APP中都應該有一個admin.py的文件：
一個例子以下：
#coding:utf-8
__author__ = 'python'
from django.contrib import admin
from models import test,test_main
admin.site.register([test,test_main])
10. order_by的使用：
Teacher.objects.filter(***).order_by()
11. group_by的使用
result=Teacher.objects.filter(***)
result.query.group_by=["author"]
或者：
result=Teacher.objects.filter(***)
result.query.group_by=["author"]
queryresult=Querset(query=result.query,model=Teacher)
注意：第一種方式在author有空值得花，方式1會報錯。 git

12 many-to-many字段filter時的用法ajax

#yanfa=Group.objects.get(name="研發")
#User.objects.filter(groups=yanfa)       many -to -many 字段的 filter的使用

若是想要篩選到 groups 爲yanfa 而且爲yunwei的用戶。能夠經過下面的鏈式搜索：

User.object.filter(groups=yanfa).filter(groups=yunwei)
六：表單
1.從request中獲取數據：
request.path           除域名之外的請求路徑，以/開頭例如 /hello/
request.get_host()     服務器的域名或ip
request.get_full_path()      完整的的請求路徑,帶有get參數
request.is_secure()          客戶端是不是經過HTTPS訪問的
request.META是一個字典，起包含了全部本次HTTP請求的header信息，好比用戶的ip地址，用戶agent例如：
HTTP_REFERER    進站前連接網頁
HTTP_USER_AGENT 用戶瀏覽器user-agent字符串。
REMOTE_ADDR 客戶端IP，若是申請是通過代理服務器的話，它多是一個以都好分割的多個IP地址。
12.111.67.89,23.22.22.22
request.META僅僅是一個普通的python字典，當試圖訪問一個不存在的鍵時會觸發一個異常，這是一個用戶提交的、不該該給予信任的額外的數據。
request.GET    是一個類字典，用來訪問GET的數據,可能來自於form標籤提交的，也多是來自於url重的查詢字符串
request.POST   是一個類字典，用來訪問POST的數據，來自於form標籤提交正則表達式

username=request.GET.get("username")

username_list=request.GET.getlist("username")
當提交的表單僅僅須要獲取數據時就能夠用GET，而當咱們提交表單時須要更改服務器數據的狀態，或者說發送e-mail，或者不只僅是獲取並顯示數據的時候就可使用post.
例如：<form action="/test/" method="get">
<form action="" method="post">
在模板中使用request變量的方法：
TEMPLATE_CONTEXT_PROCESSORS模板處理器中加入：
"django.core.context_processors.request"
而後利用render_to_response("test.html",{"name":name},context_instance=RequestContext(request))
七：views.py url.py高級配置
1.在urls.py中能夠這樣設置：
urlpatterns=patterns('',
(r"^hello/$","mysite.views.hello"),
)
2.一樣也能夠這樣設置：
urlpatterns=patterns('mysite.views',
(r"^hello/$",'hello'),)
urlpatterns+=patterns('yousite.views',
(r"^hello/$",'hello'),)
3.甚至能夠這樣：
urlpatterns=patterns('mysite.views',
(r"^hello/$",'hello',{'template_name':'template1.html'}),)
視圖函數：
def hello(request,template_name):
pass
4.還能夠這樣：
urlpatterns=patterns("",
(r"^hello/(P?<id>\d+)",hello,{"id":123}),)
在此狀況下字典內的Id比捕獲到的id的優先級高。捕獲到的那個不起做用

(r"^robots\.txt$",lambda request:HttpResponse("User-agent: *\nDisallow: /",mimetype="text/plain")), #robots

八：template的高級進階：
1.在模板的渲染中經常使用renter_to_response("index.html",{"name":name})等形式進行模板的渲染。
若是name中含有<b>li</b>   這一部分會直接被渲染出來，li被html解析，這些<>符號被django轉義了！
若是想要某個變量關閉這種轉義特性有兩種方法：
    1.{{name|safe}}
    2.{%autoescape off%} {{name}} {%endautoescape%}
2.django中能夠經過配置settings.py中TEMPLATE_LOADER設置模板加載器
     1.django.template.loaders.filesystem.load_template_source根據TEMPLATE_DIRS的設置從文件系統中加載模板，默承認用！
     2.django.template.loaders.app_directories.load_template_source根據文件系統中django應用中加載模板，對INSTALLED_APPS中的每個應用加載器會尋找templates子目錄，若此目錄存在，django就在那裏尋找模板！
這兩個最爲經常使用，django按照TEMPLATE_LOADERS設置中的順序使用模板加載器，它逐個使用每一個加載器直到找到一個匹配的模板
和此很相似的就是STATICFILES_DIRS配置，
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
第一個加載器表明從STATICFILES_DIR中尋找
第二個加載器表明從每一個APP的static目錄中尋找。
3.django直至自定義過濾器、自定義標籤、等完成高級功能！！
自定義過濾器：
{{var|foo:"bar"}}
過濾器foo穿入了兩個參數：
for(value,arg):   var傳到value "bar"傳入arg.
大多數的過濾器是不須要參數的。
在school應用下新建一個目錄：
templatetags
   -- __init__.py
   -- test.py
test.py中
from django import template
register=template.Libary()
@register.filter(name="cut")
def cut(value):
    return value.upper
使用時模板中加上
{%load test%} 就開業使用cut過濾器了
自定義標籤：

from django import template

class AtmCssNode(template.Node):
def __init__(self,path):
self.path=path
def render(self, context):
try:
            request=context["request"]
return AtmFrame(self.path,request).get_css()
except Exception as e :
return  str(e),"PATH:%s"%self.path

@register.tag("atmjs")
def  atmjs_handle(parser,token):
try:
        tag_name,path=token.split_contents()
except:
return ''
else:
return AtmJsNode(path)

token.split_contents 用空格把其分開。若是{% atmjs main %} . token爲 atmjs main . 而後利用token.split_contents()函數將其分割爲一個元組。

（自定義標籤輸出的值不會被轉義！）

4.自定義處理器：
定義一個處理器：
#coding:utf-8
__author__ = 'Administrator'
from settings import DEBUG
from django.shortcuts import render_to_response
def custom_proc(request):
    "自定義的處理器，     包含了 debug_status "
    return {
        "debug_status":DEBUG
    }
加入到settings.py中
TEMPLATE_CONTEXT_PROCESSORS = (
            "django.contrib.auth.context_processors.auth",
            "django.core.context_processors.debug",
            "django.core.context_processors.i18n",
            "django.core.context_processors.media",
            "django.core.context_processors.static",
            "django.contrib.messages.context_processors.messages",
            "django.core.context_processors.request",
            "digger.context_processors.custom_proc"
)
九：models高級進階：
1.模型中外鍵（ForeignKey）的做用
from django.db import models
# Create your models here.
class ScoreTable(models.Model):
    yuwen=models.CharField(max_length=30)
    shuxue=models.IntegerField()
class Info(models.Model):
    name=models.CharField(max_length=30)
    score=models.ForeignKey(ScoreTable)
python manage.py shell
>>from school.models import *
>>a=ScoreTable(yuwen="98",shuxue=90)
>>a.save()
>>b=Info(name="zhou",score=a)
>>b.save()
>>b.score.yuwen,b.score.shuxue
這就是外鍵的做用，外鍵用於存儲一些詳細信息。具備外鍵的表，必須外鍵已經創建才能夠爲這個表插入一些東西。
如上所示，要創建b必需要有a做爲參數。
2.訪問外鍵的值
b.score.yuwen
3.經過外鍵回溯
>>c=Info(name="zhou",score=a)
score做爲一個外鍵，其對應了主表內的兩行
>>e=ScoreTable.objects.get(yuwen="98",shuxue=90)
>>f=e.info_set.all()
>>for i in f:    print i.name
zhou
zhou
結果輸出了兩行。
4.ManyToManyField的使用
對於上面的例子的深思：一個學生信息中有一個學生名字一門課的成績。
若是是一個學生信息中一個學生名字多門課的成績該如何應對？
簡單來講一個學生一個信息用ForeignKey
         一個學生多個信息時用ManyToMany
舉例子以下：
class Kemu(models.Model):
    name=models.CharField(max_length=30)
    value=models.IntegerField()
class StudentScore(models.Model):
    name=models.CharField(max_length=30)
    score=models.ManyToManyField(Kemu)
通常對於不含喲ManyToManyField的類，創建對象的時候參數必需要傳遞滿，且正確。而後save
對於含有ManyToManyField的類必需要先不傳參數，save，再添加數據，save
例如：
a=Kemu(name="yuwen",value=23)
b=Kemu(name="shuxue",value=24)
a.save()
b.save()
c=StudentScore()
c.save()
c.name="zhou"
c.score=[a,b]
c.save()
5.數據庫中添加列
   1.在模型中添加字段
   2.manage.py sqlall youapp 查看模型新的CREATE TABLE語句，注意新字段的定義
   3.進入數據庫的交互命令界面執行ALTER TABLE語句增長新的列
   4.manage.py shell驗證新的字段是否被正確的添加。
6.數據庫中刪除列
   1.在模型中刪除字段
   2.在數據庫中刪除對應列
十：會話、用戶和註冊
1.cookie中不該該存儲一些過於敏感的信息！敏感的信息應該存儲在session中
通常cookie默認爲會話cookie
取：
a=request.COOKIES
print a["lover"]
存：
response=render_to_response("index.html")
response.set_cookie("lover":"baby")
return response
cookie的存取大概就是這樣
在set_cookie中有許多可選的參數
max_age cookies的持續有效時間，默認爲None
erpires cookies的過時時間,默認爲None
path     cookie生效的路徑前綴,默認爲「/」
domain     cookie生效的站點，默認只能由設置它的站點讀取,默認爲None
secure     HTTPS傳輸，    默認爲False
在使用cookie時候通常不須要本身制定這些參數，除非是用途特殊用途,沒有設置過時時間的cookie是回話cookie,在瀏覽器關閉的時候就失效了。
2.session功能
session使用時，MIDDLEWARE_CLASSES: django.contrib.sessions.middleware.SessionMiddleware
INSTALLED_APPS:
django.contrib.sessions
只要session激活後，每一個view中的request參數都有幾個session屬性。
是一個字典型的對象。session中儘可能少用下劃線開頭的
存：
request.session["lover"]="baby"
取：
print request.session["lover"]
settiongs.py中經常使用的sission配置以下：
SESSION_EXPIRE_AT_BROWSER_CLOSE=True
SESSION_COOKIE_AGE=1209600        #session的cookie的生效時間，僅僅在SESSION_EXPIRE_AT_BROWSER_CLOSE爲False時有效
SESSION_COOKIE_NAME="wolover"             #session的cookie變量名
SESSION_COOKIE_DOMAIN=None #session的cookie_生效的域名
SESSION_COOKIE_SECURE=True          #僅僅經過HTTPS傳輸session相關的COOKIE
3.自帶的認證系統
user=request.user
if user.is_authenticated()
user.authenticate() 登陸
user.login() 退出
經常使用的user屬性：
user.username
user.email
user.password
user.is_active
經常使用的user方法：
user.is_authenticated()
user.is_anonymous()
user.get_full_name()
user.set_passwd()
4. 認證的form表單一般以下：（next變量會被login函數自動傳進去，不須要本身傳，若是忘記了用next會致使登陸後自動重定向到next功能失效。）
        <form action="/login/?next={{ next }}" method="post" autocomplete="off" class="login-form">
            {% csrf_token %}
            <div class="text-box">
                <input type="text" name="username" class="login-name"/>
                <input type="password" name="password" class="login-password"/>
            </div>
            <div class="login-tip">{{ request.login_message }}</div>
            <input class="login-submit button" type="submit" value="登錄"/>
        </form>
5. 經常使用login_required裝飾器時要帶上login_ulr="~~"參數。

6.login 的配置；

settings.py中加入：

LOGIN_URL="/login/"                #指定登陸的URL
LOGIN_REDIRECT_URL = "/"

urls.py中加入：

url(r"^login/$",login,{"template_name":"login.html"}),
url(r"^logout/$",logout,{"next_page":"/login/"}),

或者在action後，加入 {{ next }} 。
十一：django json序列化對象
在django中json用於序列化對象，把對象序列化以後能夠永久存儲。
JSON構建了兩種結構：字典（又能夠叫作對象、哈希表）、列表。
這種數據格式在一樣基於這些結構的編程語言之間交換成爲了可能。
簡單類型經過JSONencode編碼以後和睦原始的str()輸出結果很是類似，可是有些類型發生了改變。
具體以下：
Python To Json:
python     json
dict        object
list,tuple array
str,unicode string
int,long,float number
True             true
False           false
None            null
Json To Python:
object         dict
array          list
string         unicode
int            int,long
real           float
true           True
false          False
null           None
例如：
#coding:gbk
import json
a="工廠網"
a_json=json.dumps(a,encoding="gbk")
a_python=json.loads(a_json)
ensure_ascii參數做用：若是ensureascii爲True的時候，返回的字符串通常是str類型
若是爲False, 返回的字符串是Unicode類型。
JSON loads時，老是把一切字符串轉化爲unicode字符串，其編碼默認爲utf8。能夠本身制定編碼
以下：
#coding:utf8
import json
a_json=json.dumps(a)
a_python=json.loads(a_json)
dumps的可選參數：
json.dumps(data,indent=4,separators=(',',":"))   indent用於縮進，這樣看起來美觀，可是其增大了數據量，separators用於制定壓縮項。
自定義類JSON序列化和反序列化：
#coding:utf8
import json
class test:
    def __init__(self,name,age):
        self.name=name
        self.age=age
_u=test("zhou",22)
print type(_u),_u.__class__.__name__,_u.__module__
def object_to_dict(obj):
    d={}
    d["__class__"]=obj.__class__.__name__
    d["__module__"]=obj.__module__
    d.update(obj.__dict__)
    return d
def dict_to_object(obj):
    print obj
    module_=__import__(obj["__module__"])
    class_=getattr(module_,obj["__class__"])
    buff=[]
    for i in obj:
        if "__" in i:
            buff.append(i)
    for i in buff:
        obj.pop(i)
    args={}
    for i in obj:
        args[str(i)]=obj[i]
    return test(**obj)
_u_dict=object_to_dict(_u)
a=json.dumps(_u_dict)
b=json.loads(a)
c=dict_to_object(b)
print c.name,c.age
十二：memcache隨記
easy_install 'python-memcached'便可安裝
使用：
import memcache
conn=memcache.Client(["192.138.8.137:11211"],debug=0)
conn.set("a",1)
conn.get("a")
conn.set_multi({"k1":1,"k2":2},key_prefix="test")
conn.get_multi(["k1","k2"],key_prefix="test")
conn.delect("k1")
十三： redis隨記
easy_install 'redis'
或者pip install redis
pip uninstall redis
redis中2.10的版本比較好用，沒什麼大的問題。低版本可能有問題。
redis中有四種數據類型
key,value     list   set(集合) zset（有序集合，多了一個順序屬性）
使用：
import redis
conn=redis.Redis(host="192.168.8.137",port=6379,db=1) #進入1數據庫
conn.set("a",1)
conn.set("b",2)
conn.dbsize()   #1數據庫的大小   2
conn.select(2)
conn.dbsize()   # 2數據庫的大小 0
conn.select(1)
conn.move("a",2) #移動鍵"a"的信息到數據庫2,數據庫1的鍵"a"消失
conn.select(2)
conn.get("a")
conn.save()   #強行把數據庫保存草硬盤。保存時會堵塞。
conn.flushdb() 刪除當前數據庫中的全部數據
conn.exists("a")    #看當前數據庫中是否存在這個鍵值
conn.keys()       列出全部鍵的名字。返回一個列表
例如：可能返回['a','b']
conn.set("a",1) 同 conn["a"]=1
conn.get("b")   同 conn["a"]
conn.delete("c")同 del conn["c"]
conn.getset("a",123) 返回老的數據，並塞入新的數據
conn.rename("c","_c") 鍵值更名
r.mset({"a":123,"b":456})
r.mget(["a","b"])######## [123,456]
#------------------------------------------------------------------------------
r.push("g","a")            [a]
r.push("g","b")        [b,a]
r.llen("g")      #返回長度，至關於列表長度
r.lrange("g",start=0,end=-1)   #返回在此範圍內的元素，至關於列表切片
r.ltrim("g",start=0,end=100)   #對此序列進行修剪，至關於列表中的a=a[0:101]
r.lrem("g","a",count=0)       #從序列中刪除全部等於"a"的元素
#-------------------------------------------------------------------------------
r.sadd("s","a") #向集合中添加元素
r.scard("s")      #判斷一個集合長度
r.sismember("s","a")#判斷集合中"a"是否存在
r.srem("s","a")   從集合中刪除此元素
r.sinter("s1","s2") #兩個集合的交集
http://stackoverflow.com/questions/1780003/import-error-on-boost-python-hello-program
十四：重定向
django中302臨時重定向：
from django.http import HttpResponseRedirect
return HttpResponseRedirect("http://www.baidu.com")
301永久重定向：
from django.http import HttpResponsePermanentRedirect("http://www.baidu.com")
十五：django工程的組織。
a. 能夠這樣組織，新建一個工程mysite 會自動具備一個app mysite.    能夠再新建一個文件夾。
且其和mysite在相同目錄下，而後再seting中加入這個新的app，例如yousite
b. 也能夠這樣足足，新建一個工程Mysite，而後其自動具備一個app mysite，再在mysite這個文件夾下新建一個目錄，加入叫作yousite，而後再settings中加入這個新的app，例如mysite.yousite。
這兩種方法各有利弊，目前來講對於不是超大型的工程，建議採用第二種方式。只有在預估本身的代碼量超大的時候才用第一種方式。由於少許的代碼採用第一種方式會使得整個架子太大，太空。
還有對於，django中app的理解， django中一個app能夠算做爲一個小的獨立功能，好比主機監控和數據庫監控。   按照標準每一個app中都應該具備views.py models.py __init__.py 。而後把整個app加入settings.py中django就會爲這個應用添加數據庫映射 templatefinder等相關信息。不要忘記添加app。
在Nginx和django配合使用的時候，前端部分用到 js httprequest對象儘可能用post方式，get方式有問題.
十六： Django安全系統
csrf:     django內部帶有csrf中間件，且 'django.middleware.csrf.CsrfViewMiddleware',通常是默認開啓的中間件，
每一次在模板中使用時，若是是post方式，通常在模板中加一個 {% csrf_token %}的標籤，    若是是用ajax的方式而且也是用post方式的話，須要加一個
X_CSRFTOKEN的header.其值是cookie中的csrftoken的值。
csrf是跨站點請求僞造，   django對於csrf的防止是經過 cookie的   csrftoken+post中取到的csrftoken的值進行對比，若是相同的話，那麼這是一個正經常使用戶，若是不一樣，那麼就
極可能是csrf跨站請求。因此， get請求通常對於查詢時使用，post對於寫入時使用。
sql注入：通常常見於經過get形式進行查詢時，沒有對get的參數進行有效的轉義，信任了各戶端，致使可能會使客戶端獲取到不應獲取的信息甚至是刪除了你的數據庫。
解決方案就是：查詢的sql遊標最好只給讀的權限，同時對用戶輸入的參數進行有效的轉義和篩選。毫不信任用戶提交的數據！
XSS跨站腳本：舉個例子：若是一個用戶在本身的簡歷中假如了一段不被信任的JS腳本，其餘用戶在查看其簡歷的時候就會自動運行這些腳本，這是咱們不肯意看到的！
解決方案就是：老是對從數據庫中取出的數據進行轉義，除非你有其餘特別的用途！！！
十七：django json的使用
************************************
json=simplejson.dumps(buff,ensure_ascii=False)    #ensure_ascii爲了保證中文不亂碼的問題
return HttpResponse(json,mimetype="application/javascript")
十八。django中引入第三方認證：
settings.py中加入：
AUTHENTICATION_BACKENDS=("django.contrib.auth.backends.ModelBackend",
"digger.auth.SelfBackend")
__author__ = 'python'
from django.contrib.auth.models import User,check_password
import MySQLdb
def get_mysql_conn():
    conn=MySQLdb.connect(host="192.168.1.101",port=3306,user="zhou",passwd="13523136191",charset="utf8")
    return conn
class SelfBackend(object):
    def authenticate(self,username=None,password=None):
        if username=="zhou" and password=="123456":
            try:
                user=User.objects.get(username=username)
            except User.DoesNotExist:
                user=User(username=username,password="get from self")
                user.is_staff=True   #具備進入admin的權限
                user.is_superuser=True #具備進入admin而且可以更改設置的權限，超級管理員，和初級的admin 同樣
                user.is_active=True#帳號處於激活狀態
                user.save()
            return user
        else:
            conn=get_mysql_conn()
            sqlstring="select * from test.auth WHERE user='%s' AND passwd='%s'"%(username,password)
            cursor=conn.cursor()
            cursor.execute(sqlstring)
            result=cursor.fetchall()
            if result!=None:
                try:
                    user=User.objects.get(username=username)
                except User.DoesNotExist:
                    user=User(username=username,password=password)
                    user.is_active=True
                    user.is_staff=True
                    user.is_active=True
                    user.save()
                return user
            else:
                return None
    def get_user(self,user_id):
        try:
            return User.objects.get(pk=user_id)
        except User.DoesNotExist:
            return None
19. setting.py中Debug設置
在正式發佈的時候Debug通常要設置爲False，   可是在設置完False以後，極可能會出現500的問題，此時只須要設置成以下便可！
ALLOWED_HOSTS = ['*']
20. django中直接操做SQL：
1. 能夠直接用MySQLdb進行處理， conn=connect() conn.cursor. execute(sqlstring,***)
2. conn=connections["default"] cursor=conn.cursor() conn.cursor.execute (sqlstring, ***)
sqlstring的寫法：
（「select from_unixtime(begintime,'%%Y%%m%%d') as begitdate ,count(*) as countnum from datamining.digger_djt_middle 」）
*** 的寫法：
（）
爲了保持兼容性，就算是沒有參數，args也要寫上一個空的元組。
若是有參數那就直接用%s進行替代便可。經常使用的以下：
cursor.execute("selcet * from test",())
cursor.execute("select from_unixtime(begintime,'%%Y%%m%%d') as begitdate ,count(*) as countnum from datamining.digger_djt_middle where id = %s ",(3,))
21. django中 routers配置
DATABASE_ROUTERS=['myblog.routers.Router'] #Database router 配置
而後再規定位置寫好這個Router。其中model._meat.app_label 爲models文件所在的包名。若在myblog下面有models.py那麼若是用models.py裏面的內容orm時就會其model的app_label就是 myblog
class Router(object):
    def db_for_read(self, model, **hints):
        print locals()
        print model._meta.app_label
        return 'default'
    def db_for_write(self, model, **hints):
        print locals()
        return 'default'
22.django中小於
aaa__lt    aaa__gt大於     lte小於等於   gte大於等於