码迷,mamicode.com
首页 > 其他好文 > 详细

Django进阶

时间:2017-07-02 14:19:17      阅读:128      评论:0      收藏:0      [点我收藏+]

标签:快速   mysql   意思   lap   list   回调函数   oca   filter   log   

 

HTTP请求周期

客户端发送请求(数据头)--》服务端接收提取URl--》路由关系匹配--》执行对应函数(模板+数据渲染)--》返回客户端(处理结果,数据头+数据体)

一,路由分发

#from django.conf.urls import url,include
 url(r^app01, include("app01.urls")),

二,模板语言

#有后台传到前段的数据,

#单值
{% item %}

#字典{"user":"钢弹"}
{% item.user%}

#多数据的时候可以遍历,需要加上结束语句endfor,if也要叫上结束语句endif

{% for item in user_list %}
    {% if item %}        
        {{ item.id }}
     {% else %}
        {{ itme.name }}
    {% endif %}       
{% endfor %}


#----------母版 --------------#
#所有模板共有的,把他们提取出来,放到一块

#创建母版
{% block 名字 %}

{% endblock %}

#子板继承母版

{% extends "母版文件" %}

{% block 母版定义的名字 %}
    可以写自己的内容
{% endblock %}

一般都是有三个母版文件,即css一个,内容一个,js一个

{% block css %}
#css    
{% endblock %}

{% block xx %}
#内容
{% endblock %}


{% block js %}
#js
{% endblock %}

三,AJAX

一般用于少量的输入框,数据少,登陆的时候,

#新URL提交form表单是,页面对刷新


#AJAX提交时页面不会刷新

#AJAX是jQuery下的一个组件

#AJAX格式
$.ajax({
    url:"要提交的地址",
    type:"请求类型",  #GET或POST
    data:{"信息":提交信息},
    success:function(data){
                 //当服务器处理完后,自动执行的回调函数
                //data是返回的数据,随便命名
    }    
})

#location.href = "要跳转的页面"
#location.reload() #刷新当前页面

js中自带JSON
#JSON.stringify() //序列化字符串
#JSON.parse(data); //反序列化字符串

四,后台管理布局(Bootstrap,font-awesome)

1,Bootstrap,来自 Twitter,是目前很受欢迎的前端框        架。Bootstrap 是基于 HTML、CSS、JAVASCRIPT  的,它简洁灵活,使得 Web 开发更加快捷。

2,Font Awesome提供可缩放的矢量图标,您可以使用CSS所提供的所有特性对它们进行更改,包括:大小、颜色、阴影或者其它任何支持的效果。

 

五,Cookie

1,保存在客服端的“键值对”

2,服务端可以向用户浏览器写Cookie

3,客服端每次发送请求时,都会携带Cookie去访问

4,Cookie一般应用于投票,用户登录

技术分享
1,html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<form method="post" action="/login/">
    用户名:<input type="text" name="username">
    密  码:<input type="password" name="password">
    <input type="submit" value="登录">

</form>
</body>
</html>



2,#路由关系对应执行函数

def login(request):

    if request.method == "GET":
        return render(request,"login.html")
    else:
        user = request.POST.get("username")
        pwd = request.POST.get("password")
        if user == "alex" and pwd == "123":
            obj = redirect("/classes/")
            obj.set_cookie("ticket",user+pwd) #写cookie
            return obj
        else:
            return render(request,"login.html")

3,登陆成功返回页面的执行函数

def classes(request):
    tk = request.COOKIES.get("ticket") #获取cookie
    print(tk)
    if not tk:  
        return redirect("/login/")
    class_list = get_list("select * from class",[])
    return render(request,"classes.html",
                  {"class_list":class_list})
用户登录

六,ORM,

ORM,即Object-Relational Mapping(对象关系映射),它的作用是在关系型数据库和业务实体对象之间作一个映射,这样,我们在具体的操作业务对象的时候,就不需要再去和复杂的SQL语句打交道,只需简单的操作对象的属性和方法。

2.ORM的优缺点是什么?

优点:摆脱复杂的SQL操作,适应快速开发;让数据结构变得简洁;数据库迁移成本更低(如从mysql->oracle)

缺点:性能较差、不适用于大型应用;复杂的SQL操作还需通过SQL语句实现

 

技术分享
from django.shortcuts import render,HttpResponse,redirect
from django.views import View
from app01 import models


def test(request):

    #---------------增 -----------------------

    # for i in range(300):
    #     user_name = "root" + str(i)
    #     models.User.objects.create(name=user_name)

    # models.UserType.objects.create(type="普通用户")
    # models.UserType.objects.create(type="白银用户")
    # models.UserType.objects.create(type="黄金用户")

    # models.UserInfo.objects.create(name="张三1",age=12,ut_id=1)
    # models.UserInfo.objects.create(name="赵四2",age=12,ut_id=2)
    # models.UserInfo.objects.create(name="王五3",age=12,ut_id=3)
    # models.UserInfo.objects.create(name="王五3",age=12,ut_id=3)
    # models.UserInfo.objects.create(name="王五3",age=12,ut_id=3)
    # models.UserInfo.objects.create(name="王五3",age=12,ut_id=3)
    # models.UserInfo.objects.create(name="王五3",age=12,ut_id=3)

    # models.Foo.objects.create(title="钢弹")
    # models.Foo.objects.create(title="铁蛋")
    # models.UserType.objects.all().update(uf_id=1)
    #models.UserType.objects.filter(id=2).update(uf_id=2)

#----------------查-------------------------#
    #对象跨表正向查询
    # result = models.UserInfo.objects.all()
    # for i in result:
    #     print(i.id,i.name,i.age,i.ut.type,i.ut.id)

    #三张表一块查
    # result = models.UserInfo.objects.all()
    # for i in result:
    #     print(i.id,i.name,i.age,i.ut.id,i.ut.type)
    #     print(i.ut.uf.id)
    #     print(i.ut.uf.title)
    #     print(i.ut_id)

# ------------- 大于小于 -------
    # __gt  大于
    # result = models.UserInfo.objects.filter(id__gt=4).all()
    # for i in result:
    #     print(i.id,i.name,i.age)

    #__gte 大于等于

    # result = models.UserInfo.objects.filter(id__gte=2).all()
    # for i in result:
    #     print(i.id,i.name)


    # __lt 小于
    # result = models.UserInfo.objects.filter(id__lt=3).values("id","name")
    # print(result)

    # __lte 小于等于

    # result = models.UserInfo.objects.filter(id__lte=3).all()
    # for i in result:
    #     print(i.id,i.name)

    #a获取id大于2,并且小于10的数据,逗号隔开的是并且的意思
    # result = models.UserInfo.objects.filter(id__gt=2,id__lt=10)
    # for i in result:
    #     print(i.id,i.name)


    # 获取个数

    # result = models.UserInfo.objects.all().count()
    # print("数据行数:",result)


    # ----------- in 获取在列表内的

    # result  = models.UserInfo.objects.filter(id__in=[12,3,2,1,4,5,])
    # print(result)
    # for i in result:
    #     print(i.id,i.name)


    # ---------- not in 获取不在列表内的 exclude
    # result = models.UserInfo.objects.exclude(id__in=[12,3,2,1,4,5,])
    # for i in result:
    #     print(i.id,i.name)


    # -----  range 跟bettwen and  范围 1-10
    # result = models.UserInfo.objects.filter(id__range=[1,10])
    # for i in result:
    #     print(i.id,i.name,i.age)

    # ------ order_by  排序
    #  从小到大 asc
    # result = models.UserInfo.objects.order_by("id").all()
    # for i in result:
    #     print(i.id,i.name)
    #
    # #从大到小,desc 倒序 加个-
    # result1 = models.UserInfo.objects.order_by("-id")
    # for k in result1:
    #     print(k.id,k.name)

    # annotate 是 group by 分组
    # from django.db.models import Count,Max,Min
    #
    # result = models.UserInfo.objects.values("ut_id").annotate(xxx=Count("ut_id"))
    # print(result.query)
    # print(result)
    # for i in result:
    #     print("ut_id:%s,个数:%s"%(i["ut_id"],i["xxx"]))


    #字典格式 正向查询,无法跨表,
    # result = models.UserInfo.objects.all().values("id","name")
    # for i in result:
    #     print(i)
    #     print(i["id"],i["name"])

        #字典跨表
    # result = models.UserInfo.objects.all().values("id","name","ut__type")
    # for i in result:
    #     print(i)
    #     print(i["id"],i["name"],i["ut__type"])

    #元组格式,正向查询,无法跨表, 跨表需要在获取的时候添加上
    # result = models.UserInfo.objects.all().values_list("id","name","age")
    # for i in result:
    #     print(i)
    #     print(i[0],i[1],i[2])

        #元组跨表---- 外键名__ 双下换线列名
    # result = models.UserInfo.objects.all().values_list("id", "name", "age","ut__type")
    # for i in result:
    #     print(i[0],i[1],i[2],i[3])



  #-----------------反向查询------------------------#

    #------ 对象----------------
    # result = models.UserType.objects.all().last()
    # result1 = models.UserType.objects.all().first()
    # print(result)
    # print(result.id,result.type)
    # print(result1.id,result1.type)
    # for i in result.userinfo_set.all():
    #     print(i.name,i.age,i.id,)


    # -------------反向 小写表名__列名
    # result = models.UserType.objects.values("id","type","userinfo__name","userinfo__age","userinfo__id")
    # print(result)
    # for i in result:
    #     print(i)

    # result = models.UserType.objects.values("id","type","userinfo__name","userinfo__age")
    # print(result)

#---------------------  F ----------------------------------

    from django.db.models import F,Q

    # # 批量增加
    # models.UserInfo.objects.update(age=F("age")+1)


# ----------------Q 两种方式-----------------

    #方式一 :对象

    # conditions = {
    #     "id":1,
    #     "name":"root"
    # }
    #
    # ret = models.UserInfo.objects.filter(**conditions)
    # print(ret)

    #获取id大于1的数据
    # ret = models.UserInfo.objects.filter(Q(id__gt=1))
    # for i in ret:
    #     print(i.id,i.name)

    # 获取id=2 或者 id=4的数据
    # ret = models.UserInfo.objects.filter(Q(id=2) | Q(id=4))
    # for i in ret:
    #     print(i.id,i.name)


    #获取id=1并且age=13的数据
    # ret = models.UserInfo.objects.filter(Q(id=1) & Q(age=13))
    # for i in ret:
    #     print(i.id,i.name)



    # 方式2
    # q1 = Q()
    # q1.connector = "OR"
    # q1.children.append(("id__gt",1))
    # q1.children.append(("id",9))
    # q1.children.append(("id",10))
    # print(q1)
    #
    # q2 = Q()
    # q2.connector = "OR"
    # q2.children.append(("id",10))
    # q2.children.append(("id",2))
    # q2.children.append(("id",1))
    #
    # print(q2)
    #
    # con = Q()
    # con.add(q1,"AND")
    # con.add(q2,"AND")
    #
    # print(con)
    #
    # models.User.objects.filter(con)



#  多对多 操作
    # objs = [
    #     models.Gril(name="小花"),
    #     models.Gril(name="小芳"),
    #     models.Gril(name="小草"),
    #     models.Gril(name="小小翠"),
    # ]
    #
    # obj = [
    #     models.Boy(name="张三"),
    #     models.Boy(name="赵四"),
    #     models.Boy(name="王五"),
    #     models.Boy(name="李六"),
    # ]
    # models.Gril.objects.bulk_create(objs,4)
    # models.Boy.objects.bulk_create(obj,5)

    # models.Love.objects.create(b_id=1,g_id=1)
    # models.Love.objects.create(b_id=1,g_id=2)
    # models.Love.objects.create(b_id=2,g_id=3)
    # models.Love.objects.create(b_id=2,g_id=2)
    # models.Love.objects.create(b_id=3,g_id=3)
    # models.Love.objects.create(b_id=4,g_id=4)

 # 跟张三有关系的女人

    #第一种
    # obj = models.Boy.objects.filter(name="张三").first()
    # love_list = obj.love_set.all()
    # print(love_list)
    # for i in love_list:
    #     print(i.g.name)

    #第二种
    # love_list = models.Love.objects.filter(b__name="赵四")
    # for i in love_list:
    #     print(i.g.name)

    #第三种
    # love_list = models.Love.objects.filter(b__name="王五").values("g__name")
    # for i in love_list:
    #     print(i)
    #     print(i["g__name"])

    #第四种
    # love_list1 = models.Love.objects.filter(b__name="李六").select_related("g","b")
    # print(love_list1)
    # for i in love_list1:
    #     print(i)
    #     print(i.g.name)


#--------- django内置关系表 -----------------#

    #需要间接的去操作表

    #添加 add
    #obj = models.Gril.objects.filter(name="小小翠").first()
    #print(obj)
    # obj.m.add(1)
    # obj.m.add(*[1,2,3,4])#批量添加

    #删除 remove
    #obj.m.remove(1) #删除boy_id为1的数据
    # obj.m.remove(2,3) #还可以删多个
    #obj.m.remove(*[1,2,3]) #批量删除

    # 重写 set 清除表内原有数据,再把新的数据写进去
    # obj.m.set([1,2,])


    # ret = obj.m.all() # boy对象
    # print(ret)
    # for i in ret:
    #     print(obj.name,i.name)

# -------- 自定义关系表 ------------
    # class Love(models.Model):
    #   #自定义关系表
    #     b = models.ForeignKey("Boy")
    #     g = models.ForeignKey("Gril")

# ------ 内置和自定义一块用,指多了clear清空,和查询,其他的内置操作没有了

    # models.Love.objects.create(b_id=1,g_id=1)
    # models.Love.objects.create(b_id=1,g_id=2)
    # models.Love.objects.create(b_id=1,g_id=3)
    # models.Love.objects.create(b_id=2,g_id=1)
    # models.Love.objects.create(b_id=3,g_id=4)
    # models.Love.objects.create(b_id=4,g_id=2)
    #
    # obj = models.Boy.objects.filter(name="张三").first()

    #

    # ret = obj.m.all() #所有
    # for i in ret:
    #     print(i.name)
    # ret = obj.m.filter(name="钢弹") #条件查找
    # print(ret)
    #
    #清空,关联的所有数据
    #obj.m.clear()
ORM操作

 

七,Django的CBV,FBV

1,CBV(class based view),基于class类

2,FBV(function based view),基于函数

# FBV

def index(request):
    return HttpResponse("hello world")


#CBV

from django.views import View
#使用CBV时,需要继承View类 class Login(View): def get(self,request): return render(request,"login.html") def post(self,request): user_name = request.POST.get("user") print(user_name) return HttpResponse("login.post")

 

八,表操作,Model

1,创建表

# 基本表

from django.db import models

class Boy(models.Model):
    username = models.CharField(max_length=64)
    password = models.CharField(max_length=64)
技术分享
AutoField(Field)
        - int自增列,必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列,必须填入参数 primary_key=True

        注:当model中如果没有自增列,则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ~ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ~ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ~ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ~ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807

    自定义无符号整数字段

        class UnsignedIntegerField(models.IntegerField):
            def db_type(self, connection):
                return integer UNSIGNED

        PS: 返回值为字段在数据库中的属性,Django字段默认的值为:
            AutoField: integer AUTO_INCREMENT,
            BigAutoField: bigint AUTO_INCREMENT,
            BinaryField: longblob,
            BooleanField: bool,
            CharField: varchar(%(max_length)s),
            CommaSeparatedIntegerField: varchar(%(max_length)s),
            DateField: date,
            DateTimeField: datetime,
            DecimalField: numeric(%(max_digits)s, %(decimal_places)s),
            DurationField: bigint,
            FileField: varchar(%(max_length)s),
            FilePathField: varchar(%(max_length)s),
            FloatField: double precision,
            IntegerField: integer,
            BigIntegerField: bigint,
            IPAddressField: char(15),
            GenericIPAddressField: char(39),
            NullBooleanField: bool,
            OneToOneField: integer,
            PositiveIntegerField: integer UNSIGNED,
            PositiveSmallIntegerField: smallint UNSIGNED,
            SlugField: varchar(%(max_length)s),
            SmallIntegerField: smallint,
            TextField: longtext,
            TimeField: time,
            UUIDField: char(32),

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数, max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField):
        - 字符串类型,Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数:
            protocol,用于指定Ipv4或Ipv6, both,"ipv4","ipv6"
            unpack_ipv4, 如果指定为True,则输入::ffff:192.0.2.1时候,可解析为192.0.2.1,开启刺功能,需要protocol="both"

    URLField(CharField)
        - 字符串类型,Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号)

    CommaSeparatedIntegerField(CharField)
        - 字符串类型,格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数:
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串,路径保存在数据库,文件上传到指定目录
        - 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串,路径保存在数据库,文件上传到指定目录
        - 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名(字符串)
            height_field=None   上传图片的宽度保存的数据库字段名(字符串)

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数:
            max_digits,小数总长度
            decimal_places,小数位长度

    BinaryField(Field)
        - 二进制类型
字段
技术分享
null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作
                        如:gf = models.IntegerField(choices=[(0, 何穗),(1, 大表姐),],default=1)

    error_messages      自定义错误信息(字典类型),从而定制想要显示的错误信息;
                        字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如:{null: "不能为空.", invalid: 格式错误}

    validators          自定义错误验证(列表类型),从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如:
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    c1: 优先错信息1,
                                    c2: 优先错信息2,
                                    c3: 优先错信息3,
                                },
                                validators=[
                                    RegexValidator(regex=root_\d+, message=错误了, code=c1),
                                    RegexValidator(regex=root_112233\d+, message=又错误了, code=c2),
                                    EmailValidator(message=又错误了, code=c3), ]
                            )

参数
参数

 

Django进阶

标签:快速   mysql   意思   lap   list   回调函数   oca   filter   log   

原文地址:http://www.cnblogs.com/gaoyuan111/p/7105855.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!