python-django基础教程

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