1，安装django : python setup.py install
2，django-admin.py startproject csvt01---》表示新建一个项目csvt01
3，有以下目录：
1，__init__.py 初始化
2，settings.py django的设置
DEBUG=TRUE 表示开启debug功能
LANGUAGE_CODE=‘zh-cn‘ 语言为中文
TIME_ZONE=‘Asia/Shanghai’地区为中国上海
INSTALLED_APPS 把用户的应用添加到此中，本例为blog
‘blog’,
3，urls.py url配置文件
url(r‘^blog/index/$‘,‘blog.views.index‘), -->此为映射测试。意为访问csvt01的blog的index则转移到blog（app）的views.index
4，manage.py 管理配置
4，django-admin.py startapp blog -->新建app，名为blog。同上一样.进入工程目录下创建
1，编辑blog目录下的views.py文件
定义一个方法
from django.http import HttpResponse
def index(req):
return HttpResponse(‘<h1>welcome to django </h1>‘)
2，使用命令 python manage.py runserver启动服务
5，建立模板集合 blog/templates。并把需要发布的文件移动到此,本例为hello.html
6，静态加载模板文件 vim blog/views.py
方法一：
from django.template import loader,Context --》导入模板模块
def index(req):
t=loader.get_tempplate(‘hello.html‘) --》加载模版文件
c=Context({}) --
return HttpResponse(t.render(c)) -->渲染context数据，然后通过response返回
方法二：from django.shortcuts import render_to_response
def index(req):
return render_to_response(‘index.html‘,{})
7，动态加载文件（配合字典使用）
在源文件中使用变量，在映射的文件中views.py定义变量
还可以使用字典，key作为变量
动态变量为用大括号包住： 例： ｛｛title｝｝，{{user}}
方法三：from django.shortcuts import render_to_response
def index(req):
return render_to_response(‘index.html‘,{‘title‘:‘my page‘,‘user‘:‘tom‘})
方法四：from django.shortcuts import render_to_response
def index(req):
user={‘age‘：23,‘name‘:‘tom‘,‘sex‘:‘male‘}
return render_to_response(‘index.html‘,{‘title‘:‘my page‘,‘user‘:user})
可以在原动态变量文件中直接引用：例： user.name 等等
方法五：
class Person(object):
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def say(self):
return “i‘m”+self.name
def index(req)：
user=Person(‘tom‘,24,‘male‘)
return render_to_response(‘index.html‘,{‘title‘:‘my page‘,‘user‘:user})
8，模板标签的使用。在模板文件中配置。index.html
1,{% if user %} if中的and和or不能直接连用；bool；==，！=；in，not in；
<li>name:{{user.name}}</li>
{% else %}
用户不存在
{% endif %}
2，{% for book in book_list %}
........
{% empty %}
........
{% endfor %}
例：{% for k,v in user.items %}
<li>{{k}}:{{v}}</li>
9，URLconfig urls.py文件
使用方式;
1,url(r‘^blog/index/$‘,‘blog.views.index‘),正则表达式
2,from blog.views import index 直接导入的方式
url(r‘^blog/index/$‘,index),
3,urlpatterns=patterns(‘blog.views‘,
url(r‘^blog/index/$‘,‘index‘),
)
4,urlpatterns=patterns(‘blog.views‘,
url(r‘^blog/index/\d{2}/$‘,‘index‘),
)
5,urlpatterns=patterns(‘blog.views‘,
url(r‘^blog/index/?P<id>\d{2}/$‘,‘index‘), -->参数分组id
10，模板的使用
1，新建项目
2，进入项目，创建应用blog
3，配置settings.py文件。添加应用
4，进入到应用目录中，创建一个默认的文本目录templates
5，编辑urls.py。建立一个测试的url. url(r‘^index/$‘,‘blog.views.index‘)
6，编辑应用下面的views.py文件，创建index方法
模板的使用步骤：
1，模板文件的加载
from django.template import loader,Context
from django.http import HttpResponse
def index(req):
t=loader.get_template(‘index.html‘) ->载入模板文件。需要建立文件
c=Context({‘uname‘:‘alen‘}) ->创建context对象，变量(字典)渲染。此处uname为key.
html=t.render(c) ->渲染数据
return HttpResponse(html) ->输出
也可以使用shell测试。
ipython manage.py shell
2，直接使用template类
from django.template import Template,Context
def index(req):
t=Template(‘<h1>{{uname}}</h1>‘)
c=Context({‘uname‘:‘csvt‘})
return HttpResponse(t.render(c))
3，使用render_to_response方法
from django.shortcuts import render_to_response
def index(req):
return render_to_response(‘index.html‘,{‘uname‘:‘csvt02‘}) --->参数一为模板文件，参数二为渲染的变量
11，数据库的基本使用
安装数据库：yum -y install mysql*
启动数据库：service mysqld start。
使用root用户登录数据库：mysql -uroot -p。
创建数据库
create database csvt default charset=utf8
安装MySQL-python.在python下，import MySQLdb.连接数据库
1，创建新工程，进入工程并创建应用
2，配置settings。添加应用，添加数据库 。
在默认的引擎下把mysql添加上
name项添加database名csvt
用户名root
password,host,port可以使用默认。mysql端口默认为3306
3，编辑应用目录下的models.py文件
class Employee(models.Model): -->当数据库同步后，此为一张表，表名为应用名+类名
name=models.CharField(max_length=20)
4,数据库同步.会创建多个表（重要为blog_employe）
python manage.py syncdb -->自动检测应用，检查应用下是否有models，如果有则自动创建表
5,使用数据库use csvt
show tables;desc blog_employee
12，数据库的基本使用2:
python manage.py shell -->进入python的交互界面
配置数据库记录方式一：
1，导入类对象： from app1.models import Employee
2，创建实例对象：emp=Employee()
3，创建属性： emp.name=‘alen‘
4，保存： emp.save()
配置数据库记录方式二;
1，实例化对象:emp=Employee(name=‘tom‘)
2,保存：emp.save()
配置数据库记录方式三：
1，直接通过类方法：Employee.objects.create(name=‘max‘)
查看:
emps=Employee.objects.all()
emps
emps[0].id[name]
在类文件app1.models.py中增加方法:
def __unicode__(self):
return self.name
然后再次查看
使得在浏览器上可以查看：
在url文件中新增记录：
url(r‘^index/$‘,‘app1.views.index‘)
然后在app1的views文件下，定义index方法：
from app1.models import Employee
from django.shortcuts import render_to_response
def index(req):
emps=Employee.objects.all() -->获取记录
return render_to_response(‘index.html‘,{‘emps‘:emps}) -->渲染数据
接着创建模版集template/index.html
编辑配置模板文件index.html
可以配合模板标签，规范显示
{% for emp in emps %}
<div>{{forloop.counter}}{{emp}}</div>
{% endfor %}
<div>共有｛｛emps.length｝｝记录</div>
13，model之间的关系
1，manytoone：多对一
1，创建项目，进入项目内创建app，修改settings文件，配置db数据库，apps添加
2，配置model对象：
class Entry(models.Model):
name=models.CharField(max_length=30)
def __unicode__(self):
return self.name
class Blog(models.Model):
name=models.CharField(max_length=30)
entry=models.ForeignKey(Entry) -->此处Entry为one
def __unicode__(self):
return self.name
3,进入数据库，创建数据库
4，数据库同步 python manage.py syncdb
5，进入交互界面 python manage.py shell
from blog.models import Entry,Blog
entry1=Entry.objects.create(name=‘alen‘) -->首先创建one对象
entry2=Entry.objects.create(name=‘max‘)
entry3=Entry.objects.create(name=‘max1‘)
blog1=Blog.objects.create(name=‘alen-blog‘,entry=entry1)
blog1查找；
blog1.entry ; blog_entry_id -->many端进行的查询
entry1.blog_set.all() -->one端进行的查询
14，后台管理数据库
1，创建工程csvt05，进入工程目录；创建应用blog，配置settings文件，数据库为sqlite3；添加应用
然后把django.contrib.admin应用启用
2，修改url.py文件.加入一下内容
from django.contrib import admin
admin.autodiscover()
url(r‘^admin/‘,include(admin.site.urls))
3，修改models文件：
from django.db import models
sex_choices=(
(‘f‘,‘female‘),
(‘m‘,‘male‘),
)
class User(models.Model):
name=models.CharField(max_length=20)
sex=models.CharField(max_length=1,choices=sex_choices)
def __unicode__(self):
return self.name
4，数据库的同步 python manage.py syncdb
5，运行开发服务器 python manage.py runserver
6，创建文件 blog/admin.py
from django.contrib import admin
from blog.models import User
admin.site.register(User)
7，测试
sqlite3 csvt04.db
.help查看帮助
.tables显示所有表
15，model中多对多的关系
1，创建工程，进入工程目录，创建应用；修改settings，设置数据库sqlite3,加入应用admin及需要的应用
2，编辑models，
from django.db import models
class Author(models.Model):
name=models.CharField(max_length=20)
def __unicode__(self):
return self.name
class Book(models.Model):
name=models.CharField(max_length=30)
authors=models.ManyToManyField(Author)
def __unicode__(self):
3，数据库同步 python manage.py syncdb
4，进入数据库 sqlite3 db
5，管理数据.
进入解释器 python manage.py shell
from blog.models import Author,Book
Author.objects.create(name=‘alen‘)
Author.objects.create(name=‘ben‘)
Author.objects.create(name=‘carl‘)
authors=Author.objects.all()
b1=Book()
b1.name=‘python book1‘
b1.save()
alen=Author.objects.get(name__exact=‘alen‘) =====alen=authors[0]-->获取作者
b1.authors.add(alen) -->添加书的作者为alen
b1.authors.add(authors[1]) -->添加书的作者
b1.authors.all() -->查看b1的所有作者
b1.authors.remove(alen) -->删除作者
b1.authors.filter(name__exact=‘carl‘)
alen.book_set.all() -->查看alen的所有书
alen.book_set.add(b1) -->alen添加一本书b1
alen.book_set.create(name=‘python book2‘) ->添加书
books=Book.objects.all() -->查看所有书
alen.book_set.remove(books[0]) -->删除书
16，数据呈现在页面
承接上文内容
for author in Author.objects.all():
for book in author.book_set.all():
print book
1,创建模板目录，并创建模板文件show_author.html
{% for author in authors %}
<div>
<h3>{{author.name}}</h3>
{% for book in author.book_set.all() %}
<li>{{ book }}</li>
{% endfor %}
</div>
模板文件show_book.html
{% for book in books %}
<div>
<h1>{{book.name}}</h1>
{% for author in book.authors.all %}
<li>{{author}}</li>
{% endfor %}
</div>
2，编辑views.py
from blog.models import Author,Book
from django.shortcuts import render_to_response
def show_author(req):
authors =Author.objects.all()
return render_to_response(‘show_author.html‘,{‘authors‘:authors})
def show_book(req):
books =Book.objects.all()
return render_to_response(‘show_book.html‘,{‘books‘:books})
3,配置url.py文件
url(r‘^blog/show_author/$‘,‘blog.views.show_author‘)
url(r‘^blog/show_book/$‘,‘blog.views.show_book‘)
4,开启开发服务器 python manage.py runserver
17，表单form
1，创建项目，进入该目录，创建应用；修改settings文件sqlite3,name,app添加
2，编辑url文件
url(r‘^blog/register/$‘,‘blog.views.register‘)
3，编写views文件
from django import forms
from django.http import HttpResponse
from django.shortcuts import render_to_response
class UserForm(forms.Form)
name=forms.CharField()
def register(req):
if req.method==‘POST‘ -->数据提交动作
form = UserForm(req.POST) -->绑定数据
if form.is_valid():
print form.cleaned_data ->数据获取
return HttpResponse(‘ok‘)
else: -->数据获取动作(get)
form =UseForm()
return render_to_response(‘register.html‘,{‘form‘:form})
4，创建模板文件register.html
<body>
<form method="post">
{{form}}
<input type="submit" value="ok">
</form>
</body>
5，启动服务python manage.py runserver
6,配置settings文件，把MIDDLEWARE_CLASSES中的csrf那行注释掉
本文出自 “ciscle” 博客，请务必保留此出处http://ciscle.blog.51cto.com/6219171/1591546
原文地址：http://ciscle.blog.51cto.com/6219171/1591546
