Python学习笔记 Day 20 - Django基础知识汇总

最新推荐文章于 2021-06-05 08:29:29 发布
最新推荐文章于 2021-06-05 08:29:29 发布
阅读量325 收藏 1
点赞数
分类专栏： Django WEB应用程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/steventian72/article/details/85221008
版权

Day 20 - Django部分基础知识汇总

部分内容来自：Django框架全面讲解，感谢原文作者。

1、常用命令

    虚拟环境的安装激活命令代码

功能描述命令代码
测试是否安装虚拟环境python -m vent ll_env
安装虚拟环境pip install --user virtualenv
Windows安装虚拟环境python -m pip install --user virtualenv
建立虚拟环境virtualenv ll_env
激活虚拟环境source ll_env/bin/activate
Windows激活虚拟环境ll_env\Scripts\activate

    Django常用命令代码

功能描述命令代码
安装Djangopip install Django
启动服务器，默认ip和端口为http://127.0.0.1:8000/python manage.py runserver ip:port
新建 apppython manage.py startapp appname
同步数据库命令，Django 1.7及以上版本需要用以下的命令python manage.py syncdb
显示并记录所有数据的改动python manage.py makemigrations
将改动更新到数据库python manage.py migrate
创建超级管理员python manage.py createsuperuser
数据库命令行python manage.py dbshell
查看命令列表python manage.py

2、目录内容示例（项目名称为learning_log, 应用名称为learning_logs)

learning_log

migrations

templates

3、数据库配置

    Django默认使用SQLite 3，如果需要使用其它关系型数据库，修改’learning_log’目录下的’settings.py’

# 默认是SQLit 3 的配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# MySQL的配置

DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME':'dbname',   #注意这里的数据库应该以utf-8编码
    'USER': 'xxx',
    'PASSWORD': 'xxx',
    'HOST': '',
    'PORT': '',
    }
}

# 对于python3的使用者们还需要再加一步操作
# 由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替
  
# 如下设置放置的与project同名的配置的 __init__.py文件中
  
import pymysql
pymysql.install_as_MySQLdb()


# PostgreSQL配置
DATABASES = {
    'default': {
        'NAME': 'app_data',
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'USER': 'XXX',
        'PASSWORD': 'XXX'
    }


# Oracle配置
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.oracle',
        'NAME': 'xe',
        'USER': 'a_user',
        'PASSWORD': 'a_password',
        'HOST': '',
        'PORT': '',
    }
}

    官方配置指南：Using a 3rd-party database backend

4、模型（models）的基本操作

   模型，完成数据库的操作。

   4-1 创建表

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

   参数说明

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

   字段的定义说明

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 文件

   元信息

class UserInfo(models.Model):
        nid = models.AutoField(primary_key=True)
        username = models.CharField(max_length=32)
        class Meta:
            # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
            db_table = "table_name"

            # 联合索引
            index_together = [
                ("pub_date", "deadline"),
            ]

            # 联合唯一索引
            unique_together = (("driver", "restaurant"),)

            # admin中显示的表名称
            verbose_name

            # verbose_name加s
            verbose_name_plural

   其它

1.触发Model中的验证和错误提示有两种方式：
        a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
        b. 调用Model对象的 clean_fields 方法，如：
            # models.py
            class UserInfo(models.Model):
                nid = models.AutoField(primary_key=True)
                username = models.CharField(max_length=32)

                email = models.EmailField(error_messages={'invalid': '格式错了.'})

            # views.py
            def index(request):
                obj = models.UserInfo(username='11234', email='uu')
                try:
                    print(obj.clean_fields())
                except Exception as e:
                    print(e)
                return HttpResponse('ok')

           # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。

    2.Admin中修改错误提示
        # admin.py
        from django.contrib import admin
        from model_club import models
        from django import forms


        class UserInfoForm(forms.ModelForm):
            username = forms.CharField(error_messages={'required': '用户名不能为空.'})
            email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})
            age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})

            class Meta:
                model = models.UserInfo
                # fields = ('username',)
                fields = "__all__"


        class UserInfoAdmin(admin.ModelAdmin):
            form = UserInfoForm


        admin.site.register(models.UserInfo, UserInfoAdmin)

django官方文档

    4-2 连表结构（表与表之间的关系）

    关系型数据库常见的表与表之间的关系：
        一对多：models.ForeignKey(其他表)
        多对多：models.ManyToManyField(其他表)
        一对一：models.OneToOneField(其他表)
   

ForeignKey(ForeignObject) # ForeignObject(RelatedField)
to,                         # 要进行关联的表名
to_field=None,              # 要关联的表中的字段名称
on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
- models.CASCADE，删除关联数据，与之关联也删除
- models.DO_NOTHING，删除关联数据，引发错误IntegrityError
- models.PROTECT，删除关联数据，引发错误ProtectedError
- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
- models.SET，删除关联数据，
a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

def func():
    return 10

class MyModel(models.Model):
    user = models.ForeignKey(
        to="User",
        to_field="id"
    on_delete=models.SET(func),)
related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
# 如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5}

from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
db_constraint=True          # 是否在数据库中创建外键约束
parent_link=False           # 在Admin中是否显示关联数据


OneToOneField(ForeignKey)
to,                         # 要进行关联的表名
to_field=None               # 要关联的表中的字段名称
on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为

###### 对于一对一 ######
# 1. 一对一其实就是 一对多 + 唯一索引
# 2.当两个类之间有继承关系时，默认会创建一个一对一字段
# 如下会在A表中额外增加一个c_ptr_id列且唯一：
class C(models.Model):
    nid = models.AutoField(primary_key=True)
    part = models.CharField(max_length=12)

class A(C):
    id = models.AutoField(primary_key=True)
    code = models.CharField(max_length=1)

ManyToManyField(RelatedField)
to,                         # 要进行关联的表名
related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
# 如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5}

from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
# 做如下操作时，不同的symmetrical会有不同的可选字段
models.BB.objects.filter(...)

# 可选字段有：code, id, m1
class BB(models.Model):

code = models.CharField(max_length=12)
m1 = models.ManyToManyField('self',symmetrical=True)

# 可选字段有: bb, code, id, m1
class BB(models.Model):

code = models.CharField(max_length=12)
m1 = models.ManyToManyField('self',symmetrical=False)

through=None,               # 自定义第三张表时，使用字段用于指定关系表
through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
from django.db import models

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

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(
        Person,
        through='Membership',
        through_fields=('group', 'person'),
    )

class Membership(models.Model):
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    inviter = models.ForeignKey(
        Person,
        on_delete=models.CASCADE,
        related_name="membership_invites",
    )
    invite_reason = models.CharField(max_length=64)
db_constraint=True,         # 是否在数据库中创建外键约束
db_table=None,              # 默认创建第三张表时，数据库中表的名称

    4-3 表操作

#基本操作
    # 增
    #
    # 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()                                                 # 修改单条数据

#------------------
#进阶操作  
# 获取个数
        #
        # models.Tb1.objects.filter(name='seven').count()

        # 大于，小于
        #
        # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
        # models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
        # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
        # models.Tb1.objects.filter(id__lte=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

        # isnull
        # Entry.objects.filter(pub_date__isnull=True)

        # 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

        # 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"

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

        # regex正则匹配，iregex 不区分大小写
        #
        # Entry.objects.get(title__regex=r'^(An?|The) +')
        # Entry.objects.get(title__iregex=r'^(an?|the) +')

        # date
        #
        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
        # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year
        #
        # Entry.objects.filter(pub_date__year=2005)
        # Entry.objects.filter(pub_date__year__gte=2005)

        # month
        #
        # Entry.objects.filter(pub_date__month=12)
        # Entry.objects.filter(pub_date__month__gte=6)

        # day
        #
        # Entry.objects.filter(pub_date__day=3)
        # Entry.objects.filter(pub_date__day__gte=3)

        # week_day
        #
        # Entry.objects.filter(pub_date__week_day=2)
        # Entry.objects.filter(pub_date__week_day__gte=2)

        # hour
        #
        # Event.objects.filter(timestamp__hour=23)
        # Event.objects.filter(time__hour=5)
        # Event.objects.filter(timestamp__hour__gte=12)

        # minute
        #
        # Event.objects.filter(timestamp__minute=29)
        # Event.objects.filter(time__minute=46)
        # Event.objects.filter(timestamp__minute__gte=29)

        # second
        #
        # Event.objects.filter(timestamp__second=31)
        # Event.objects.filter(time__second=2)
        # Event.objects.filter(timestamp__second__gte=31)
#------------------
#其它操作
# extra
    #
    # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    #    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    #    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    #    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    #    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

    # F
    #
    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)


    # Q
    #
    # 方式一：
    # Q(nid__gt=10)
    # Q(nid=8) | Q(nid__gt=10)
    # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
    # 方式二：
    # 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)


    # 执行原生SQL
    #
    # from django.db import connection, connections
    # cursor = connection.cursor()  # cursor = connections['default'].cursor()
    # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    # row = cursor.fetchone()

    4-3 表之间关联操作

#表结构实例
class UserProfile(models.Model):
    user_info = models.OneToOneField('UserInfo')
    username = models.CharField(max_length=64)
    password = models.CharField(max_length=64)

    def __unicode__(self):
        return self.username


class UserInfo(models.Model):
    user_type_choice = (
        (0, u'普通用户'),
        (1, u'高级用户'),
    )
    user_type = models.IntegerField(choices=user_type_choice)
    name = models.CharField(max_length=32)
    email = models.CharField(max_length=32)
    address = models.CharField(max_length=128)

    def __unicode__(self):
        return self.name

class UserGroup(models.Model):

    caption = models.CharField(max_length=64)

    user_info = models.ManyToManyField('UserInfo')

    def __unicode__(self):
        return self.caption

class Host(models.Model):
    hostname = models.CharField(max_length=64)
    ip = models.GenericIPAddressField()
    user_group = models.ForeignKey('UserGroup')

    def __unicode__(self):
        return self.hostname
#------------------
#一对一操作
user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.password
 
user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
print user_info_obj.keys()
print user_info_obj.values()
#------------------
#一对多操作
# 添加一对多
    dic = {
        "hostname": "名字1",
        "ip": "192.168.1.1",
        "user_group_id": 1,   # 加对象则为"user_group"
    }
    models.Host.objects.create(**dic)

    # 正向查一对多
    host_obj = models.Host.objects.all()
    print(type(host_obj),     # <class 'django.db.models.query.QuerySet'>
          host_obj)           # <QuerySet [<Host: 名字1>]>
    for item in host_obj:
        print(item.hostname)
        print(item.user_group.caption)
        print(item.user_group.user_info.values())
        # <QuerySet [{'name': 'nick', 'user_type': 1, 'id': 1, 'email': '630571017@qq.com', 'address': '128号'}]>
    
    usergroup_obj = models.Host.objects.filter(user_group__caption='标题1')
    print(usergroup_obj)


    # 反向查一对多
    usergroup_obj = models.UserGroup.objects.get(id=1)
    print(usergroup_obj.caption)
    ret = usergroup_obj.host_set.all()  # 所有关于id=1的host
    print(ret)
    
    obj = models.UserGroup.objects.filter(host__ip='192.168.1.1').\
        values('host__id', 'host__hostname')
    print(obj)      # <QuerySet [{'host__id': 1, 'host__hostname': '名字1'}]>
#------------------
#多对多
user_info_obj = models.UserInfo.objects.get(name='nick')
user_info_objs = models.UserInfo.objects.all()
 
group_obj = models.UserGroup.objects.get(caption='CTO')
group_objs = models.UserGroup.objects.all()
 
# 添加数据
#group_obj.user_info.add(user_info_obj)
#group_obj.user_info.add(*user_info_objs)
 
# 删除数据
#group_obj.user_info.remove(user_info_obj)
#group_obj.user_info.remove(*user_info_objs)
 
# 添加数据
#user_info_obj.usergroup_set.add(group_obj)
#user_info_obj.usergroup_set.add(*group_objs)
 
# 删除数据
#user_info_obj.usergroup_set.remove(group_obj)
#user_info_obj.usergroup_set.remove(*group_objs)
 
# 获取数据
#print group_obj.user_info.all()
#print group_obj.user_info.all().filter(id=1)
 
# 获取数据
#print user_info_obj.usergroup_set.all()
#print user_info_obj.usergroup_set.all().filter(caption='CTO')
#print user_info_obj.usergroup_set.all().filter(caption='DBA')

    # 添加多对多
    # userinfo_id_1 = models.UserInfo.objects.filter(id=1)
    # usergroup_id_1 = models.UserGroup.objects.filter(id=1).first()
    # usergroup_id_1.user_info.add(*userinfo_id_1)

5、路由模版URLs

    URL模版就是整个网站的“地图”，django系统能够根据URL模版响应用户的URL地址，找到对应的视图和函数（views.functions()），剩下的工作就是视图函数调用模型（models）获取数据，再调用模版（templates）生产HTML文件，最后沿着URL模版逆向返回给用户HTML文件。
    URL模版格式如下：

urlpatterns = [
	url(正则表达式， view函数, 参数, 别名)
]
#参数说明：
	#一个正则表达式字符串
	#一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
	#可选的要传递给视图函数的默认参数（字典形式）
	#一个可选的name参数

   示例：

from django.conf.urls import url
from . import views

app_name = 'learning_logs'

urlpatterns = [
	#主页
	url(r'^$', views.index, name='index'),
	#显示所有主题
	url(r'^topics/$', views.topics, name = 'topics'),
	#显示特定主题的页面
	url(r'^topics/(?P<topic_id>\d+)/$', views.topic, name = 'topic'),
	#用于添加新主题的网页
	url(r'^new_topic/$', views.new_topic, name='new_topic'),
	#用于添加新条目的页面
	url(r'^new_entry/(?P<topic_id>\d+)/$', views.new_entry, name = 'new_entry'),
]

   URL模版可以多级调用，上面的URL模版是应用程序learning_logs目录下的URLs.py（注意app_name = 'learning_logs’这句定义，就是为了给上级URL模版调用使用的），而它上一级的项目目录中的URL模版定义如下：

from django.conf.urls import include, url
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('learning_logs.urls', namespace='learning_logs'))
]

   5-1 命名组

    上面的例子‘url(r’^new_entry/(?P<topic_id>\d+)/$’, views.new_entry, name = ‘new_entry’)’中，使用正则分组来匹配URL，并且将分组值通过参数传递给view函数。
    在Python的正则表达式中，分组的语法是 (?P<name>pattern), name表示分组名，pattern表示一些匹配正则。
    还是用上面的例子说明：(?P<topic_id>\d+)，topic_id是分组名，、d+是正则表达式规则。

   5-2 别名

    还是在上面的例子‘url(r’^new_entry/(?P<topic_id>\d+)/$’, views.new_entry, name = ‘new_entry’)’中，“name = ‘new_entry’”就是定义了该URL的别名为“new_entry”，在模版（Template）中，可使用别名代替这个URL。

6、Views

http请求中产生两个核心对象：
    1: http请求：HttpRequest对象
    2: http响应：HttpResponse对象

def new_entry(request, topic_id):
	"""在特定的主题中添加新条目"""
	topic =  Topic.objects.get(id=topic_id)

	if request.method != 'POST':
		#未提交数据，则创建一个空表单
		form = EntryForm()
	else:
		#POST提交的数据，对数据进行处理
		form = EntryForm(data=request.POST)
		if form.is_valid():
			new_entry = form.save(commit=False)
			new_entry.topic = topic
			new_entry.save()
			return HttpResponseRedirect(reverse('learning_logs:topic', 
				args=[topic_id]))
	context = {'topic': topic, 'form': form}
	return render(request, 'learning_logs/new_entry.html', context)

6-1 HttpRequest对象属性

    在view创建时，HttpRequest对象自动创建，参考上面代码中的‘request’。

path：       请求页面的全路径，不包括域名

method：     请求中使用的HTTP方法的字符串表示。全大写表示。例如

                   if  req.method=="GET":

                             do_something()

                   elseif req.method=="POST":

                             do_something_else()

GET:         包含所有HTTP GET参数的类字典对象

POST：       包含所有HTTP POST参数的类字典对象

             服务器收到空的POST请求的情况也是可能发生的，也就是说，表单form通过
             HTTP POST方法提交请求，但是表单中可能没有数据，因此不能使用
             if req.POST来判断是否使用了HTTP POST 方法；应该使用  if req.method=="POST"



COOKIES:     包含所有cookies的标准Python字典对象；keys和values都是字符串。

FILES：      包含所有上传文件的类字典对象；FILES中的每一个Key都是<input type="file" name="" />标签中 
            name属性的值，FILES中的每一个value同时也是一个标准的python字典对象，包含下面三个Keys：

            filename：      上传文件名，用字符串表示
            content_type:   上传文件的Content Type
            content：       上传文件的原始内容


user：       是一个django.contrib.auth.models.User对象，代表当前登陆的用户。如果访问用户当前
             没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你
             可以通过user的is_authenticated()方法来辨别用户是否登陆：
             if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware
             时该属性才可用

session：    唯一可读写的属性，代表当前会话的字典对象；自己有激活Django中的session支持时该属性才可用。

META：       一个标准的Python字典包含所有可用的HTTP头。可用标题取决于客户端和服务器，但这里是一些例子：

            CONTENT_LENGTH       – 请求体的长度（一个字符串）。
            CONTENT_TYPE         – 请求体的类型。
            HTTP_ACCEPT          - 为响应–可以接受的内容类型。
            HTTP_ACCEPT_ENCODING – 接受编码的响应
            HTTP_ACCEPT_LANGUAGE – 接受语言的反应
            HTTP_HOST            – 客户端发送的HTTP主机头。
            HTTP_REFERER         – 参考页面
            HTTP_USER_AGENT      – 客户端的用户代理字符串。
            QUERY_STRING         – 查询字符串，作为一个单一的（分析的）字符串。
            REMOTE_ADDR          – 客户端的IP地址
            REMOTE_HOST          – 客户端的主机名
            REMOTE_USER          – 用户通过Web服务器的身份验证。
            REQUEST_METHOD       – 字符串，如"GET"或"POST"
            SERVER_NAME          – 服务器的主机名
            SERVER_PORT          – 服务器的端口（一个字符串）。

6-2 HttpResponse对象

   每个view请求处理方法必须返回一个HttpResponse对象。
   返回HttpResponse对象的常用方法：

context = {'topics': topics}
return_string = 'OK'
return HttpResponse(return_string)
return render(request, 'learning_logs/topics.html', context) 
return redirect("http://www.google.com")
6-2-1 HttpResponse()

    返回，并将作为参数的字符串发给浏览器。

6-2-2 render()
render(request, template_name, context=None, content_type=None, status=None, using=None)[source]
# render方法可接收三个参数：
# 第一个是request参数
# 第二个是待渲染的html模板文件
# 第三个是保存具体数据的字典参数。
# 它的作用就是将数据填充进模板文件，最后把结果返回给浏览器
#可选参数
#content_type    MIME类型用于生成文档。
#status    为响应状态代码。默认值为200
#using    这个名字一个模板引擎的使用将模板。
6-2-3 redirect

   让浏览器跳转去指定的URL.

7、Template

   模版，视图（view）读取模版（其中嵌套着模版标签），然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户。

7-1 模版语言

{{ item }}
   定义变量，这变量通常是view函数通过render传递过来的context里面的一个键

for循环

<ul>
    {% for topic in topics%}
        <li>
            <a href="{% url 'learning_logs:topic' topic.id %}">{{ topic }} </a>
        </li>
    {% empty %}
        <li> No topics have been added yet.</li>
    {% endfor %}
</ul>

if

{% if ordered_warranty %}  {% else %} {% endif %}

过滤器

   过滤器： 用于对模版变量进行操作，使用格式：

模版变量|过滤器：参数

<ul>
    {% for entry in entries%}
        <li>
	    <p>{{ entry.date_added|date:'M d, Y H:i' }}</p>
	    <p>{{ entry.text|linebreaks }}</p>
	    <p><a href = "{% url 'learning_logs:edit_entry' entry.id %}" >edit entry</a></p>
	</li>
    {% empty %}
        <li> No entries have been added yet.</li>
    {% endfor %}
</ul>

7-2 模版继承

    模版继承： 为了重用html页面内容
    格式： {% extends 父模版文件路径 %}
下面定义一个父模版的例子：

# base.html
<p>
    <a href = "{% url 'learning_logs:index' %}" >Learning Log</a> -
    <a href = "{% url 'learning_logs:topics' %}" >Topics</a>
</p>

{% block content %} {% endblock content %}

7-3 块的使用

    在父模版里可以定义块：

{% block 块名 %}
    块中的内容（也可以没有）
{% endblock 块名%}

    在子模版头部声明继承父模版：

{% extends "learning_logs/base.html" %}

    在子模板中，重写父模板中的块（也可以不重写）：

     {% block 块名 %}
	    {{ block.super}} #获取父模板中块的默认内容
	    重写的内容
      {% endblock 块名%}

    例子：

{% extends "learning_logs/base.html" %}

{% block content %}
    <p>Add a new topic:</p>
    <form action = "{% url 'learning_logs:new_topic' %}" method='post'>
        {% csrf_token %}	#防御csrf攻击的方式
        {{ form.as_p }}		#把form表单在前端页面渲染成p标签的形式展示，此外还有as_ul,as_table等
        <button name='submit'>add topic</button>
    </form>
{% endblock content %}

小知识点：在模板语言中字典数据类型的取值是通过dict.xxx而不是dict[xxx]

8、Form

    django中的Form一般有两种功能：
       . 生产HTML标签
       . 验证用户输入内容
   要想使用django提供的form，要在views里导入form模块

　　from django import forms

   然后再定义一个类，这个类就是要在前端html页面中生成form表单中的input标签的。

class TopicForm(forms.ModelForm):
    class Meta:
	model = Topic
	fields = ['text']
	labels = {'text': ''}

9、认证系统（auth）

    auth模块是Django提供的标准权限管理系统,可以提供用户身份认证, 用户组管理,并且可以和admin模块配合使用.

    在INSTALLED_APPS中添加’django.contrib.auth’使用该APP, auth模块默认启用.

    model

from django.contrib.auth.models import User
 
# 数据库中该表名为auth_user.
CREATE TABLE "auth_user" (
    "id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
    "password" varchar(128) NOT NULL, "last_login" datetime NULL,
    "is_superuser" bool NOT NULL,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL,
    "email" varchar(254) NOT NULL,
    "is_staff" bool NOT NULL,
    "is_active" bool NOT NULL,
    "date_joined" datetime NOT NULL,
    "username" varchar(30) NOT NULL UNIQUE
)

    新建用户

user = User.objects.create_user(username, email, password)
user.save()

# 不存储用户密码明文而是存储一个Hash值

    认证用户

from django.contrib.auth import authenticate

user = authenticate(username=username, password=password)

# 认证用户的密码是否有效, 若有效则返回代表该用户的user对象, 若无效则返回None.
# 该方法不检查is_active标志位.

   修改密码

user.set_password(new_password)

# 以下实例为先认证通过后才可以修改密码
user = auth.authenticate(username=username, password=old_password)
if user is not None:
    user.set_password(new_password)
    user.save()

    登录

from django.contrib.auth import login

# login向session中添加SESSION_KEY, 便于对用户进行跟踪:
'login(request, user)'

# login不进行认证,也不检查is_active标志位
# 实例
user = authenticate(username=username, password=password)
if user is not None:
    if user.is_active:
        login(request, user)

    退出登录

# logout会移除request中的user信息, 并刷新session

from django.contrib.auth import logout

def logout_view(request):
    logout(request)

    只允许登录的用户访问

@login_required修饰器修饰的view函数会先通过session key检查是否登录, 已登录用户可以正常的执行操作, 未登录用户将被重定向到login_url指定的位置.

若未指定login_url参数, 则重定向到settings.LOGIN_URL

from django.contrib.auth.decorators import login_required

@login_required(login_url='/accounts/login/')
def userinfo(request):
    ...

# settings 配置
LOGIN_URL = '/index/'
# views
@login_required
def userinfo(request):
    ...
steventian72
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python Django 框架知识点总结
JYliangliang的博客
04-20 506
CS/BS——客户端和服务器的交互模型 client--Browser server--Web后端--python（django、flask）、java、php、go MVC 软件架构风格--不是标准 将数据操作，业务处理，界面展示进行了拆分 核心思想：解耦合 松耦合 Model：模型--封装数据的交互操作（CRUD） View：视图--是用来将数据呈现给用户的 Contro...
Django day1
rainturbons的博客
11-22 253
djangoday1
Django_day03
bs_101的博客
06-05 154
文章目录视图层三板斧form表单上传文件及后端如何获取request对象方法FBV与CBVCBV源码刨析模板语法传值过滤器标签自定义过滤器、标签、inclusion_tag模板的继承模板的导入单表操作测试脚本查看内部sql语句的方式必知必会13条神奇的双下滑线查询一对多外键增删改多对多 外键增删改正反向的概念多表查询 视图层 三板斧 ''' HttpResponse 返回字符串类型 render 返回html页面 并且在返回给浏览器之前还可以给html文件传值 redirect 重定向 ''' 视图函
Django_day2
qq_36349372的博客
04-11 112
模板变量及过滤器 一、模板变量 1.模板变量在html文件中用{{变量名}}所表示 2.def xianshi1(request): return render(request,‘book/book_index.html’,context={‘name’:“abc”,‘age’:25}) context用来表示上下文管理 #定义一个类 class Django_day(): def _...
Django 模型（day5）
weixin_42106643的博客
04-30 141
linux 中截图工具： gnome-screenshot -a1.Diango中元选项：在模型类models中定义Meta,用于设置元信息db_table:定义数据表名，推荐小写字母，数据表名默认：项目名小写_类名小写ordering:对象的默认排序字段，获取对象的列表时使用ordering['id']升序、ordering['-id']降序db_column="age"表示在数据库中改名为ag...
Day10Django后台.rar
08-21
【标题】"Day10Django后台.rar"指的是一个关于Django后台管理系统的教程资源，可能包含源代码、笔记或教学视频。这个压缩包可能是针对初学者或有一定基础的Python开发者，帮助他们学习如何构建Django项目的后台管理...
我的笔记django！
最新发布
04-11
这些笔记内容覆盖了从Python基础到Django高级特性的广泛范围，对于想要深入学习Django的开发者来说是一份宝贵的资源。通过逐步学习和实践，可以提升Web开发技能，更好地利用Django框架构建高效、安全的Web应用程序。
老男孩第14期Day16期课堂源码实录及笔记 oldboy python全栈
04-13
【描述】中提到这是个人的课堂实录笔记，意味着这些文件可能是学员根据课堂讲解编写的代码示例和学习笔记，虽然不是官方发布的源码，但它们很可能包含了与课堂讲解同步的编程实例和关键知识点的记录。由于描述中提到...
day001.docx
09-18
在第一天的学习笔记中，我们主要探讨了Python web开发框架Django和Flask的相关知识，以及HTTP请求的基础概念。首先，让我们深入理解Django的工作流程及其配置文件。 Django是一个高级的Python Web框架，它鼓励快速...
第二天学习内容打包，亲测有效
02-09
描述中提到博主正在重新学习Django，这是一个流行的Python web开发框架，用于构建高效、可扩展的web应用。他选择跟随的是B站（哔哩哔哩）上的千锋教育课程。B站是中国知名的视频分享平台，也提供了丰富的教育内容。...
django学习笔记day1
python的神奇之旅
09-14 167
虚拟环境 创建：虚拟环境 mkvirtualenv h4 删除：虚拟环境 rmvirtualenv h4 进入：workon h4 退出：deactivate pip list 查看已经安装好的包 pip freeze 查看额外扩展的包 安装django版本 pip install django==1.8.2 查看版本：进入python shell im...
python测试开发django-38.多对多（ManyToManyField）查询
weixin_30876945的博客
03-22 402
前言 一个学生可以对应多个老师，一个老师也可以教多个学生，这就是一种多对多的关系 models建表 新建一个老师表Teacher，和一个学生表Student class Teacher(models.Model): '''老师表''' teacher_name = models.CharField(max_length=30, verbose_name="老师", default=...
几组数据的相关性python_django ManyToManyField多对多关系的实例详解
weixin_39821189的博客
11-25 292
Django 的 ORM 有多种关系：一对一，多对一，多对多各自定义的方式为 ：一对一： OneToOneField多对一： ForeignKey多对多： ManyToManyField上边的描述太过数据而缺乏人性化，我们来更人性化一些：多个属于一个，即 belong to : ForeignKey，多个属于一个一个有一个，即 has one： OneToOneField一个有很多个，即 has ...
python测试开发django-32.admin后台多对多关系ManyToManyField
weixin_30765475的博客
03-09 168
前言 一本书可以有多个作者，一个作者也可以写多本书，这种关系就是本篇要说的多对多关系。 这种场景在django里面数据库设计时候，需要用到ManyToManyField方法 多对多表设计 auther（作者）表里面放作者的基本信息，book（书本信息）表放书的相关信息，书里面book_auth（作者）关联auther表。 # models.py from django.db import mode...
Django的ManyToManyField(多对多)的使用以及through的作用
热门推荐
Leeyongbard的博客
12-31 6万+
创建一个经典的多对多关系:一本书可以有多个作者，一个作者可以有多本书（如下）      进行数据迁移，然后我们使用python manage.py sqlmigrate app(应用名) 迁移文件名 查看一下sql语句（如下）：        从图可以看出生成了三张表，一个是book（书籍）表包含id,title两个字段，一个是author（作者表）包含id，name，email三个字段，这是我们
django:Many-to-many关系
风之羽
12-20 2万+
要定义多对多关系，使用ManyToManyField字。 （注：django版本1.4）     本例中，一篇文章可以被很多出版社发表，而一个出版社也会发表多个文章。 from django.db import models class Publication(models.Model): title = models.CharField(max_length=30)
关于Django ORM ManyToManyField类型的数据的查找
就这样吧
01-10 1608
多对多关系正向查找以及反向查找
Django学习Day10——模型的使用（二）
ProQianXiao的博客
02-16 888
Django中模型的使用 上一篇博客介绍了Django中模型的基础知识，包括ORM，Django中数据库的配置，数据字段的使用方法和数据表之间的关联关系。这一篇博客介绍Django中数据库的增、删、改、查的操作。 ...
Python - Django ORM ManyToManyField 创建第三张表
Max's Note
11-26 3543
Python - Django ORM ManyToManyField 创建第三张表 Max.Bai 2020-11 当我们开发的过程中原先多对多关系不需要在Models建第三张表，Django会自动创建表，如果业务发展，需要在多对多的关系中添加属性，那就需要手动添加第三张表，并添加字段。 如果直接修改并执行的话那就会出现下面的错误： they are not compatible types (you cannot alter to or from M2M fields, or add .
PythonWeb开发基础教程-第2章-Django配置.pptx
06-11
本章对Django项目的配置文件进行了详细介绍。在开始项目之前，我们需要了解配置文件的结构和作用。Django项目的配置文件是settings.py，它...这对于实际的Python Web开发工作非常重要，希望读者能够充分掌握这些知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

steventian72

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值