`

Django之路由、模板和模型增删查改

阅读更多

        

一、路由系统

浏览器会自动给url后加一个“/”
django会自动给路由的正则表达式前面加一个“/”
django会给任何不带“/”结尾的url语句添加“/”(可设置)
短路路由规则:匹配到第一条就忽略后面所有!
所以路由顺序很重要!

1.普通路由

url(r'^index/', views.index),

2.正则路由

url(r'^page/\d+', views.page),

3.正则加括号

提供参数传递,按顺序接收,接收到的都是字符串

# urls.py
url(r'^page/(\d+)', views.page),

# views.py
def page(request, index):
page = index
return HttpResponse("page: 第%s页" % page)

4.正则加括号加指定参数名

提供指定参数传递,按参数名字进行接收,顺序可变,但参数名必须相同,接收到的都是字符串

urls.py

url(r'^page/(?P<page>\d+)/(?P<number>\d+)', views.page),

views.py

def page(request, page, number):
p = page
n = number
return HttpResponse("page: 第%s页 第%s条" %(p, n))

5.分级路由include

在app01中新建urls文件

from django.conf.urls import include
url(r'index/', include(app01.urls)),

二、模板系统

在html文件中使用模板语言

1. 普通变量

{{var}}

调用数组元素:(圆点加下标)

list1 = [1,2,3]
{{list.0}}
{{list.1}}
{{list.2}}

调用字典元素: (圆点加键值)

dict1 = {"k1":"v1","k2":"v2"}
{{dict1.k1}}
{{dict1.k2}}

2. if语句

在结构体内引用变量,不需要再加双大括号

{% if 判断 %}
......
{% else %} 
......
{% endif %}

3. for循环

{% for i in data %}
......
{% endfor %}

django内置特殊的用于for循环的变量:

forloop.counter
forloop.counter0
forloop.first
forloop.last 

  

4. 内置函数

lower    first    last    divisibleby等等。例如:
{{ “AAA”|lower}}    
使用管道符引用函数名,左边的‘AAA’自动当作参数传递给lower函数
又或:判断当前循环的次数是否能被2整除
{% if forloop.counter0|divisibleby:"2" %}
    <tr class="success">
{% else %}
    <tr>
{% endif %}

5. 自定义函数

templatetags
register
simple_tag
filter等等
忘记这个偏门功能吧,有学它的时间不如拓展点别的知识或提高点情商。

6. 继承模板

{% extends "xxxx.html" %}

7. 重写模板

在母版和子版式中使用同样的:
{% block 取个名字 %}
    (每个子版专属的代码)
{% endbloack %}

8.导入html代码

{% include "xxx.html" %}

与继承模板不同的是,导入的是xxx.html的完全代码,因此xxx.html中最好没有头部,title等代码,只有实际的功能代码。

三、模型(model)

1. 类结构

(1)基础类型

from django.db import models

class userinfo(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    memo = models.TextField()

(2)连表类型

一对多:models.ForeignKey("其他表")
多对多:models.ManyToManyField("其他表")
一对一:models.OneToOneField("其他表")

(3) 字段类型

1、models.AutoField  自增列 = int(11)
  如果没有的话,默认会生成一个名称为 id 的列,如果要显示的自定义一个自增列,必须将给列设置为主键 primary_key=True。
2、models.CharField  字符串字段
  必须 max_length 参数
3、models.BooleanField  布尔类型=tinyint(1)
  不能为空,Blank=True
4、models.ComaSeparatedIntegerField  用逗号分割的数字=varchar
  继承CharField,所以必须 max_lenght 参数
5、models.DateField  日期类型 date
  对于参数,auto_now = True 则每次更新都会更新这个时间;auto_now_add 则只是第一次创建添加,之后的更新不再改变。
6、models.DateTimeField  日期类型 datetime
  同DateField的参数
7、models.Decimal  十进制小数类型 = decimal
  必须指定整数位max_digits和小数位decimal_places
8、models.EmailField  字符串类型(正则表达式邮箱) =varchar
  对字符串进行正则表达式
9、models.FloatField  浮点类型 = double
10、models.IntegerField  整形
11、models.BigIntegerField  长整形
  integer_field_ranges = {
    'SmallIntegerField': (-32768, 32767),
    'IntegerField': (-2147483648, 2147483647),
    'BigIntegerField': (-9223372036854775808, 9223372036854775807),
    'PositiveSmallIntegerField': (0, 32767),
    'PositiveIntegerField': (0, 2147483647),
  }
12、models.IPAddressField  字符串类型(ip4正则表达式)
13、models.GenericIPAddressField  字符串类型(ip4和ip6是可选的)
  参数protocol可以是:both、ipv4、ipv6
  验证时,会根据设置报错
14、models.NullBooleanField  允许为空的布尔类型
15、models.PositiveIntegerFiel  正Integer
16、models.PositiveSmallIntegerField  正smallInteger
17、models.SlugField  减号、下划线、字母、数字
18、models.SmallIntegerField  数字
  数据库中的字段有:tinyint、smallint、int、bigint
19、models.TextField  字符串=longtext
20、models.TimeField  时间 HH:MM[:ss[.uuuuuu]]
21、models.URLField  字符串,地址正则表达式
22、models.BinaryField  二进制
23、models.ImageField   图片
24、models.FilePathField 文件

(4)参数类型

1、null=True
  数据库中字段是否可以为空
2、blank=True
  django的 Admin 中添加数据时是否可允许空值
3、primary_key = False
  主键,对AutoField设置主键后,就会代替原来的自增 id 列
4、auto_now 和 auto_now_add
  auto_now   自动创建---无论添加或修改,都是当前操作的时间
  auto_now_add  自动创建---永远是创建时的时间
5、choices
GENDER_CHOICE = (
        (u'M', u'Male'),
        (u'F', u'Female'),
    )
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
6、max_length
7、default  默认值
8、verbose_name  Admin中字段的显示名称
9、name|db_column  数据库中的字段名称
10、unique=True  不允许重复
11、db_index = True  数据库索引
12、editable=True  在Admin里是否可编辑
13、error_messages=None  错误提示
14、auto_created=False  自动创建
15、help_text  在Admin中提示帮助信息
16、validators=[]
17、upload-to

2. 表操作

(1)基本操作

    # 增
    #
    # models.Tb1.objects.create(c1='xx', c2='oo')  增加一条数据,可以接受字典类型数据 **kwargs

    # obj = models.Tb1(c1='xx', c2='oo')
    # obj.save()

    # 查
    #
    # models.Tb1.objects.get(id=123)         # 获取单条数据,不存在则报错(不建议)
    # models.Tb1.objects.all()               # 获取全部
    # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据

    # 删
    #
    # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

    # 改
    # models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新,均支持 **kwargs
    # obj = models.Tb1.objects.get(id=1)
    # obj.c1 = '111'
    # obj.save()                                                 # 修改单条数据

(2)进阶操作

# 获取个数
    #
    # models.Tb1.objects.filter(name='seven').count()

    # 大于,小于
    #
    # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
    # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
    # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

    # in
    #
    # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
    # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

    # contains
    #
    # models.Tb1.objects.filter(name__contains="ven")
    # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
    # models.Tb1.objects.exclude(name__icontains="ven")

    # range
    #
    # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

    # 其他类似
    #
    # startswith,istartswith, endswith, iendswith,

    # order by
    #
    # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
    # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

    # limit 、offset
    #
    # models.Tb1.objects.all()[10:20]

    # group by
    from django.db.models import Count, Min, Max, Sum
    # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
    # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

# F 使用查询条件的值
    #
    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)

    # Q 构建搜索条件
    from django.db.models import Q
    # con = Q()
    #
    # q1 = Q()
    # q1.connector = 'OR'
    # q1.children.append(('id', 1))
    # q1.children.append(('id', 10))
    # q1.children.append(('id', 9))
    #
    # q2 = Q()
    # q2.connector = 'OR'
    # q2.children.append(('c1', 1))
    # q2.children.append(('c1', 10))
    # q2.children.append(('c1', 9))
    #
    # con.add(q1, 'AND')
    # con.add(q2, 'AND')
    #
    # models.Tb1.objects.filter(con)

    #
    # from django.db import connection
    # cursor = connection.cursor()
    # cursor.execute("""SELECT * from tb where name = %s""", ['Lennon'])
    # row = cursor.fetchone()

其他操作

(3) 连表操作

models.py

#_*_coding:utf-8_*_
from django.db import models

# Create your models here.

class Colors(models.Model):
    colors=models.CharField(u'颜色',max_length=10)
    def__unicode__(self):
        return self.colors

class Ball(models.Model):
    color=models.OneToOneField("Colors")  #与颜色表为一对一,颜色表为母表
    description=models.CharField(u'描述',max_length=10)
    def__unicode__(self):
        return self.description

class Clothes(models.Model):
    color=models.ForeignKey("Colors")   #与颜色表为外键,颜色表为母表
    description=models.CharField(u'描述',max_length=10)
    def__unicode__(self):
        return self.description    
    
class Child(models.Model):
    name=models.CharField(u'姓名',max_length=10)   
    favor=models.ManyToManyField('Colors')    #与颜色表为多对多

一对一

#子表查询母表,找到红球对应的颜色
#写法1:
print(models.Ball.objects.get(description="红球").color.colors)  #返回红,通过子表查询母表,写法:"子表对象.母表表名的小写.母表字段名" ;通过Ball表查到description为"红球",查找到对应colors
#写法2,反向从母表入手:
print(models.Colors.objects.get(ball__description="红球").colors) #返回红,通过子表查询母表,但形式上是从母表对象自身直接获取字段,写法:"母表.objects.get(子表名小写__子表字段="xxx").母表字段名" ;效果和上边完全一致,另一种形式


#母表查询子表,找到红色对应的球的名字
#写法1:
print(models.Colors.objects.get(colors="红").ball.description)  #返回红球,通过母表查询子表,写法:"母表对象.子表表名的小写.子表字段名";找到颜色为红色的Ball的description
#写法2,反向从子表入手:
print(models.Ball.objects.get(color__colors="红").description)  #返回红球,通过母表查询子表,但形式上是从子表对象自身直接获取字段,写法:"子表.objects.get(一对一的子表字段__母表字段="xxx").子表字段";效果和上边完全一致,另一种形式

增:

#添加一种颜色黑,并添加黑球
color_obj=models.Colors.objects.create(colors="黑")  #先在母表中创建颜色,并实例化给颜色表对象
models.Ball.objects.create(color=color_obj,description="黑球")  #更新Ball表,color字段为颜色表对象,添加description字段

#增添数据的三种写法:
#写法1:
color_obj=models.Colors.objects.create(colors="黑")
models.Ball.objects.create(color=color_obj,description="黑球")
#写法1补充:
color_id=models.Colors.objects.create(colors="黑").id
models.Ball.objects.create(color_id=color_id,description="黑球")
#写法2:
color_obj=models.Colors.objects.create(colors="黑")
ball_obj=models.Ball(color=color_obj,description="黑球")
ball_obj.save()
#写法3(字典导入):
color_obj=models.Colors.objects.create(colors="黑")
ball_dic={'description':"黑球"}
models.Ball.objects.create(color=color_obj,**ball_dic)

改:

color_obj=models.Colors.objects.get(colors="黑") #.get()等同于.filter().first()
color_obj.colors="灰"
color_obj.save()
models.Ball.objects.filter(description="黑球").update(color=color_obj,description="灰球") #update(),delete()是QuerySet的方法


#更新一条数据
color_obj=models.Colors.objects.get(colors="黑")
color_obj.colors="灰"
color_obj.save()
#更新多条数据,把满足条件的球的description都变为灰球
#写法1:
models.Ball.objects.filter(color__colors="红").update(description="灰球")
#写法2:
up_dic={"description":"灰球"}
models.Ball.objects.filter(id__gt=0).update(**up_dic)

删:

models.Ball.objects.get(description="灰球").delete() #对象和QuerySet都有方法delete()
models.Colors.objects.filter(colors="灰").delete()

models.Colors.objects.all().delete() #清空一张表

 

一对多(外键)

 

查:

#外键表联合查询:

#外键子表查询母表,与一对一子表查询母表形式一致
#找到红裤衩所属的颜色表中的颜色--返回:红
#写法1:
print(models.Clothes.objects.get(description="红内裤").color.colors)  #返回红,通过子表查询母表,写法:"子表对象.母表表名的小写.母表字段名" ;通过Clothes表查到description为"红内裤",查找到对应colors
#写法2,反向从母表入手:
print(models.Colors.objects.get(clothes__description="红内裤").colors)  #返回红,通过子表查询母表,但形式上是从母表对象自身直接获取字段,写法:"母表.objects.get(子表名小写__子表字段="xxx").母表字段名" ;效果和上边完全一致,另一种形式

#外键母表查询子表,与一对一形式不同,因为母表为"多",不能像一对一一样通过.get().子表.子表字段的方式获取,但与多对多母表查询子表一致
#找到颜色为红的所有服装--返回:[<Clothes: 红内衣>, <Clothes: 红内裤>]
#写法1:
color_obj=models.Colors.objects.get(colors="红")
print(color_obj.clothes_set.all())  #注意:子表小写_set的写法,它实际上是一个QuerySet,可以用update,delete,all,filter等方法
#写法2:
print(models.Clothes.objects.filter(color=models.Colors.objects.get(colors="红")))
#写法2简便写法(推荐):
print(models.Clothes.objects.filter(color__colors="红"))  #写法:filter(子表外键字段__母表字段='过滤条件')
#写法3:
color_id=models.Colors.objects.get(colors="红").id  #通过母表获取到颜色为红的id
print(models.Clothes.objects.filter(color_id=color_id))  #filter得到QuerySet,写法:filter(子表外键字段_母表主键=母表主键对象)

 备注:通过QuerySet的.values()方法,将QuerySet转化为ValuesQuerySet

print(models.Clothes.objects.filter(color=models.Colors.objects.get(colors="红")).values('color__colors','description'))  #获取子表的description字段,和母表的colors字段,获取母表字段写法: 子表外键字段名__母表字段名--适用于values()或filter()
#简写形式补充:
print(models.Clothes.objects.filter(color__colors="红").values('color__colors','description'))
#返回:
[{'description': u'\u7ea2\u5185\u8863', 'color__colors': u'\u7ea2'}, {'description': u'\u7ea2\u5185\u88e4', 'color__colors': u'\u7ea2'}]
#如果不加values(),返回的是[<Clothes: 红内衣>, <Clothes: 红内裤>]这样一个QuerySet集合,通过values可以形成一个列表,列表中的每一个元素是一个字典,可以通过list()将ValuesQeurySet转化为列表,之后返回给templates


#另外可通过.values_list()将QuerySet转化为ValuesListQuerySet。返回:[(u'\u7ea2', u'\u7ea2\u889c\u5b50'), (u'\u7ea2', u'\u7ea2\u889c\u5b50')]
#得到的是一个列表,列表中是多个元组,每个元组是ValuesQuerySet中字典的value,常用于从models里将数据取出后动态添加到前端模板中的select选项中。
#通过forms.py从models取值传给前端select选项,需重启django后,select选项才能更新,可在定义form时,添加如下关键字保障动态更新select选项
#forms.py
from django import forms
from test1 import models
class ClothesForm(forms.Form):
    color=forms.IntegerField(required=True,widget=forms.Select(),)
    def __init__(self,*args,**kwargs):  #定义这个关键字段,当使用form时,colors表新增了颜色,前端ClothesForm的color字段的选项会自动更新
        super(ClothesForm, self).__init__(*args,**kwargs)
        self.fields['color'].widget.choices=models.Colors.objects.all().order_by('id').values_list('id','colors')

增:

 #增添子表数据,形式与一对一一致
#添加颜色为绿的服装:绿裤头
#方法1:
models.Clothes.objects.create(color=models.Colors.objects.get(colors="绿"),description="绿裤头")
#方法1补充:
models.Clothes.objects.create(color_id=models.Colors.objects.get(colors="绿").id,description="绿裤头")
#方法2:
c_obj=models.Clothes(color=models.Colors.objects.get(colors="绿"),description="绿裤头")
c_obj.save()
#方法3:字典方式录入..参考一对一

改:

 #颜色为红的服装,description都更新为红袜子
#写法1:
models.Clothes.objects.filter(color__colors="红").update(description="红袜子")
#写法2:
models.Clothes.objects.filter(color_id=models.Colors.objects.get(colors="红").id).update(description="红袜子")
#写法3:
colors_obj=models.Colors.objects.get(colors="红")
colors_obj.clothes_set.filter(id__gte=1).update(description="红袜子")
#其他写法参照一对一的修改和外键的查询

删:

 models.Clothes.objects.get(description="灰裙子").delete() #对象和QuerySet都有方法delete()
models.Colors.objects.filter(colors="灰").delete()

多对多

查:

 #多对多子表查询母表,查找小明喜欢哪些颜色--返回:[<Colors: 红>, <Colors: 黄>, <Colors: 蓝>]
#与一对多子表查询母表的形式不同,因为一对多,查询的是母表的“一”;多对多,查询的是母表的“多”
#写法1:
child_obj=models.Child.objects.get(name="小明")  #写法:子表对象.子表多对多字段.过滤条件(all()/filter())
print(child_obj.favor.all())
#写法2,反向从母表入手:
print(models.Colors.objects.filter(child__name="小明")) #母表对象.filter(子表表名小写__子表字段名="过滤条件")


#多对多母表查询子表,查找有哪些人喜欢黄色--返回:[<Child: 小明>, <Child: 丫蛋>]
#与一对多母表查询子表的形式完全一致,因为查到的都是QuerySet,一对多和多对多,都是在查询子表的“多”
#写法1:
color_obj=models.Colors.objects.get(colors="黄")
print(color_obj.child_set.all())
#写法2:
print(models.Child.objects.filter(favor=models.Colors.objects.get(colors="黄")))
#写法2简便写法(推荐):
print(models.Child.objects.filter(favor__colors="黄"))  #写法:filter(子表外键字段__母表字段='过滤条件')
#写法3:
color_id=models.Colors.objects.get(colors="黄").id  #通过母表获取到颜色为红的id
print(models.Child.objects.filter(favor=color_id))  #filter得到QuerySet,写法:filter(子表外键字段=母表主键对象),此处和一对多略有不同,是子表外键字段而不是外键字段_母表主键

增与改(增添子表或母表数据参照一对一的增,多对多重点在于关系表的对应关系变更):

#添加子表关联关系
#添加小呆并让他喜欢所有颜色
#写法1:
child_obj=models.Child.objects.create(name="小呆")  #如果是已有用户,使用.get()
colors_obj=models.Colors.objects.all()  #创建颜色表的所有颜色QuerySet对象
child_obj.favor.add(*colors_obj)  #添加对应关系,将小呆和所有颜色进行关联,写法:子表对象.子表多对多字段.add(*QuerySet对象)
#写法2:
child_obj=models.Child.objects.get(name="小呆")
colors_obj=models.Colors.objects.all()
child_obj.favor=colors_obj
child_obj.save()
#让小呆喜欢黄色和蓝色(2种写法和上边一致,只展示一种写法)
child_obj=models.Child.objects.get(name="小呆")
colors_obj=models.Colors.objects.filter(colors__in=["蓝","黄"])  #models默认只能用这种方式得到并集,如需更复杂的过滤逻辑,需使用模块Q
child_obj.favor.clear()  #清空小呆已经喜欢的颜色
child_obj.favor.add(*colors_obj)  #add是追加模式,如果当前小呆已经喜欢绿色,那么执行后,小呆会额外喜欢蓝,黄
#让小呆喜欢绿色(2种写法和上边一致,只展示一种写法)
child_obj=models.Child.objects.get(name="小呆")
colors_obj=models.Colors.objects.get(colors="绿")
child_obj.favor.clear()
child_obj.favor.add(colors_obj)  #此处没有*


#添加母表关联关系
#让喜欢蓝色的人里添加小呆,可以用上边的方法,一个效果,让小呆喜欢蓝色,下边介绍反向插入(从母表入手)的写法
child_obj=models.Child.objects.get(name="小呆")
colors_obj=models.Colors.objects.get(colors="蓝")
colors_obj.child_set.add(child_obj)  #从colors表插入小呆,写法:母表对象.子表名小写_set.add(子表对象)。 让喜欢蓝色的child_set集合添加name="小呆"
#让所有人都喜欢蓝色
children_obj=models.Child.objects.all()
colors_obj=models.Colors.objects.get(colors="蓝")
colors_obj.child_set.add(*children_obj)
#关于_set写法,是否已经有些晕了,究竟什么时候使用_set,简单记忆,只有子表才有"子表名小写_set"的写法,得到的是一个QuerySet集合,后边可以接.add(),.remove(),.update(),.delete(),.clear()
#另外备注一下,colors_obj.child_set.clear()是让所有人喜欢的颜色里去掉蓝色,colors_obj.child_set.all().delete()是删除.child_set的所有人

删:
删除多对多表关系

#删除子表与母表关联关系
#让小呆不喜欢任何颜色
#写法1:
child_obj=models.Child.objects.get(name="小呆")
colors_obj=models.Colors.objects.all()
child_obj.favor=''
child_obj.save()
#写法2:
child_obj=models.Child.objects.get(name="小呆")
colors_obj=models.Colors.objects.all()
child_obj.favor.remove(*colors_obj)
#写法3:
child_obj=models.Child.objects.get(name="小呆")
child_obj.favor.clear()
#其他例子参照多对多的增与改案例,这里不做举例

#删除母表与子表关联关系
#让所有人不再喜欢蓝色
#写法1:
children_obj=models.Child.objects.all()
colors_obj=models.Colors.objects.get(colors="蓝")
colors_obj.child_set.remove(*children_obj)
#写法2:
colors_obj=models.Colors.objects.get(colors="蓝")
colors_obj.child_set.clear()

删除多对多表数据:

#删除子表数据
#喜欢蓝色的所有人都删掉
colors_obj=models.Colors.objects.get(colors="蓝")
colors_obj.child_set.all().delete()  #注意有.all()
#删除所有child
models.Child.objects.all().delete()

删除母表数据:

默认情况下,如此例中,删除“红”色,那么子表与颜色表是一对一或外键关系的,子表对应数据会自动删除,如:红球,红内裤
与颜色表是多对多关系的话,不会自动删除喜欢红色的人,而是去掉红色已选
如果想让与母表外键关联的子表在删除外键之后依旧可以保留子表数据,需要子表建表时加入以下字段:

class Clothes(models.Model):
    color=models.ForeignKey("Colors",null=True,on_delete=models.SET_NULL))  #可为空,如果外键被删后,子表数据此字段置空而不是直接删除这条数据,同理也可以SET_DEFAULT,需要此字段有默认值
    description=models.CharField(u'描述',max_length=10) 

choice

#choices相当于实现一个简化版的外键,外键的选项不能动态更新,如可选项目较少,可以采用
#先在models添加choices字段
class Child(models.Model):
    sex_choice=((0,"男"),(1,"女"))
    name=models.CharField(u'姓名',max_length=10)
    favor=models.ManyToManyField('Colors')    #与颜色表为多对多
    sex=models.IntegerField(choices=sex_choice,default=0)
    def __unicode__(self):
        return self.name

#在views.py中调用
child_obj=models.Child.objects.get(name="小呆")
print(child_obj.sex)  #返回0或1
print(child_obj.get_sex_display())  #返回男或女

转自:http://www.cnblogs.com/feixuelove1009/p/5855295.html

 

分享到:
评论

相关推荐

    Django的Web的增删查改

    本话题将深入探讨Django中的“增删查改”操作,以及如何实现分页显示。 1. 增(Create): 在Django中,创建数据主要通过模型(Model)类来完成。首先,你需要定义一个模型,声明数据库中的字段类型,如CharField、...

    Python基于Django框架图书管理系统(源码+数据库+前端+文档)

    5. 实现图书的增删查改功能:编写视图函数来处理图书的增删查改操作,使用Django的表单功能实现查询和图书添加、编辑的表单。 6. 用户认证和权限管理:使用Django提供的用户认证系统,实现用户登录和注册功能,并对...

    python Django web 实训项目的实验报告

    - **文件结构**: 项目通常遵循标准的Django应用结构,包括`app1`等应用目录,其中包含了模型(models.py)、视图(views.py)、模板(templates)和静态文件(static)等。 - **SETTINGS配置**: Django的settings.py...

    基于Django的教务信息管理系统源码

    接着,系统中的增删查改功能是通过Django的ORM(对象关系映射)实现的。ORM允许开发者使用Python对象来操作数据库,无需直接编写SQL语句,极大地提高了开发效率。例如,我们可以通过定义课程、学生、教师等模型,...

    基于Python Django框架的后台服务设计源码

    2. **Django框架基础**:掌握模型(Models)、视图(Views)、模板(Templates)和URLs之间的MVT(Model-View-Template)架构。 3. **数据库操作**:通过Django ORM(对象关系映射)进行数据库的增删改查操作。 4. *...

    Django Web开发指南 python

    通过定义模型,你可以轻松地与数据库交互,进行增删查改操作。 2. **视图(Views)**:视图是应用程序处理HTTP请求并返回响应的部分。它们通常负责获取数据、处理用户输入,并根据需要调用模板来生成HTML响应。 3....

    Django爬虫后台管理系统

    Django框架提供了方便的数据库操作接口,可以轻松地进行数据的增删查改操作。 **后台管理系统**是项目的核心部分,它允许用户监控和管理爬虫任务。用户可以通过系统查看爬虫的状态,启动或停止爬虫,查看已爬取的...

    django的实战练习.rar

    然后,在后台中就能对User模型进行增删查改操作。 十、部署与性能优化 Django项目可以通过Gunicorn、uWSGI等WSGI服务器部署在Nginx上。此外,还可以通过缓存、数据库优化、异步任务等手段提升性能。 通过以上这些...

    Python-基于Django开发的商场后端管理系统

    你可以通过模型实例进行增删查改操作,如`save()`,`delete()`,`objects.get()`,`objects.filter()`等。 6. **表单处理**:Django提供了一套强大的表单系统,可以自动处理HTML表单的验证和数据绑定。通过定义模型...

    django step by step

    3. **数据操作**:通过Django的ORM,可以方便地进行增删查改操作,如`save()`, `get()`, `filter()`, `delete()`等。 模板系统也是Django的一大特色: 1. **创建模板**:在应用的templates目录下创建HTML模板文件...

    一步一步学Django

    1. **高级的ORM(对象关系映射)**:Django自带一套完善的ORM系统,能够帮助开发者快速地与数据库交互,实现数据模型的增删查改操作。 2. **强大的模板系统**:Django拥有自己的模板引擎,支持条件语句、循环等逻辑...

    python Django.zip

    Django提供了内置的管理界面,方便对模型进行增删查改操作。只需在应用的`admin.py`文件中注册模型: ```python from django.contrib import admin from .models import MyModel admin.site.register(MyModel) ```...

    Python基于Django的地标美食导游系统源码.zip

    6. RESTful API设计:如果系统需要支持移动应用或与其他服务交互,可以利用Django Rest Framework构建RESTful API,实现数据的增删查改。 7. 跨站请求伪造(CSRF)和跨站脚本(XSS)防护:Django内置了对这些常见...

    django学习资料

    - `admin.py`:用于设置后台管理界面,方便对数据进行增删查改。 6. **Django工作流程** - 用户发送HTTP请求到服务器,Django的URL路由器解析请求并调用相应的视图函数。 - 视图函数处理请求,可能涉及与数据库...

    管理系统系列--python django 人事信息管理系统.zip

    了解如何定义模型,以及如何进行增删查改操作。 4. **表单和验证**:在人事管理系统中,数据输入和验证是关键。Django的表单系统允许开发者创建基于模型的表单,以及自定义的表单字段和验证规则。 5. **用户认证和...

    python棉花数据平台建设与可视化系统(django)源码数据库演示.zip

    通过定义模型类,Django会自动生成数据库表结构,并提供增删查改等操作的API。这大大简化了数据库操作流程。 数据库部分,可能是基于关系型数据库如MySQL或SQLite,用于存储棉花相关的各种数据,如种植面积、产量、...

    Python基于Django的企业IT资产管理系统源码.zip

    Django是一个高级的Python Web框架,它遵循模型-视图-控制器(MVC)架构模式,提供了丰富的功能,包括数据库管理、URL路由、表单处理和模板引擎等,使得开发者能够快速地构建功能强大的Web应用。在本项目中,Django...

    Python库 | django-lazycrud-1.7.2.tar.gz

    `django-lazycrud` 是一个基于Python的Web开发框架Django的扩展库,它的主要目的是简化数据操作,特别是数据库的增删查改(CRUD)操作。在Django中,尽管已经提供了强大的ORM(对象关系映射)系统,但`django-...

    Python基于Django在线音乐网站设计源码案例设计.zip

    在这个音乐网站中,可能包含了歌曲、艺术家、专辑等模型,通过ORM进行增删查改操作。 3. 用户认证与授权:Django提供了一套完整的用户认证系统,包括用户注册、登录、密码重置等功能。在本案例中,用户可能可以创建...

    基于Django开发的学生管理系统源代码+数据库,Python毕业设计

    1. Django框架:学习Django的基本结构,包括URL路由、视图函数、模板引擎以及模型的创建和使用。 2. ORM操作数据库:理解如何通过Django的ORM进行数据模型定义,以及如何执行SQL查询,包括增删改查操作。 3. 用户...

Global site tag (gtag.js) - Google Analytics