Django(一)

总长由于系统

URL配置(URLconf)就比如Django
所支撑网站的目录。它的本色是URL情势以及一旦也该URL情势调用的视图函数之间的映射表;你便是因这种方法告诉Django,对于此URL调用当下段代码,对于特别URL调用这段代码。

django中的路由系统跟另语言的框架有所不同,在django中各一个告的url都设出同等长条总长由于映射,这样才会以请求提交对一个的view中之函数去处理。其他大部底Web框架则是对同一类似的url请求做一样修路由于映射,从而是路程由于乐乎得简单。

urlpatterns = [
    url(正则表达式, views视图函数,参数,别名),
]

# 参数说明
# 一个正则表达式字符串
# 一个可调用对象,通常为一个视图函数或一个指定视图函数路径的字符串
# 可选的要传递给视图函数的默认参数(字典形式)
# 一个可选的name参数

下面是一些演示:

1、单一路由分配
url(r'^index$', views.index),

2、基于正则的路由分配
url(r'^index/(\d*)', views.index),                       # 无命名传参
url(r'^manage/(?P<name>\w*)/(?P<id>\d*)', views.manage), # 有命名传参

3、添加额外的参数
url(r'^manage/(?P<name>\w*)', views.manage,{'id':333}),

4、路由映射设置名称
url(r'^home', views.home, name='h1'),
url(r'^index/(\d*)', views.index, name='h2'),

5、路由分发
如果映射url太多,全写一个在  urlpatterns 显得繁琐,so 路由分发应用而生
url(r'^blog/', include('blog.urls')),

# 需要注意
# url多传了一个参数,那views函数得多接受一个参数

HttpRequest对象(一)

#从django.http模块中导入HttpResponse类[1]
from django.http import HttpResponse
import datetime

def current_datetime(request):      #[2]
    now=datetime.datetime.now()
    html="<html><body>现在时刻:%s.</body></html>" %now
    return HttpResponse(html)

# 注意:这是一段很简单、简陋的例子
# 在这个(views.py)视图中每一个函数称作视图函数,视图函数都以一个HttpRequest对象为第一个参数,该参数通常命名为request

由于地方示例拿到视图函数第一独参数是一个HttpRequest对象,那么通过者目标好将到部分信

# 通过request.XX的方式

path             # 请求页面的全路径,不包括域名

get_full_path()  # 可以得到带数据得路径,而path就不行

method           # 请求中使用的HTTP方法的字符串表示,全大写表示。

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

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

COOKIES          # 一个标准的Python字典,包含所有cookie。键和值都是字符串。

FILES            # 通过表单上传的文件全都封装在该属性中
                   """
                   filename :字符串,表示上传文件的文件名。

                   content-type :上传文件的内容类型。

                   content :上传文件的原始内容。
                   """

META             # 一个标准的Python字典,包含所有有效的HTTP头信息
                   """
                   CONTENT_LENGTH
                   CONTENT_TYPE
                   QUERY_STRING :未解析的原始请求字符串
                   REMOTE_ADDR  :客户端IP地址
                   REMOTE_HOST :客户端主机名
                   SERVER_NAME :服务器主机名
                   SERVER_PORT :服务器端口号
                   HTTP_ACCEPT_ENCODING
                   HTTP_ACCEPT_LANGUAGE
                   HTTP_HOST :客户端发送的 Host 头信息。
                   HTTP_REFERER :被指向的页面,如果存在的。
                   HTTP_USER_AGENT :客户端的user-agent字符串。
                   HTTP_X_BENDER : X-Bender 头信息的值,如果已设的话
                   """
session           # 一个可读写的类字典对象,表示当前session

body              # POST的原始数据, 用于对数据的复杂处理

has_key()         # 返回 True 或 False ,标识 request.GET 或 request.POST 是否包含所给的键

is_secure()       # 如果请求是安全的,则返回 True 。也就是说,请求是以HTTPS的形式提交的

is_ajax()         # 待补充说明...

user              # 待补充说明..

HttpResponse对象(二)

于HttpRequest对象的话,是由于django自动创立的,不过,HttpResponse对象就是非得大家协调创造。每个view请求处理办法要回到一个HttpResponse对象。

在HttpResponse对象及扩大的常用方法:

render()

render(request, template_name, context=None, content_type=None,
status=None, using=None)[source]
结缘给定的沙盘与一个加以的上下文,重回一个字典HttpResponse在渲染文本对象

template_name
一个模板的使用依然模板系列名称全称。倘若系列是加的,存在为第一单模板将为运用。

可选参数

  • context 一组字典的值加加到模板被。默认情形下,这是一个空的字典。
  • content_type MIME类型用于转移文档。
  • status 为响应状态代码。默认值为200
  • using 这一个名字一个模板引擎的使用拿模板。

    from django.shortcuts import render
    
    def index(request_info):
        test = 1
    
        return render(request_info,'index.html',{'test':test})
    

render_to_response()

render_to_response(template_name, context=None, content_type=None,
status=None, using=None)[source]

夫和 render() 差不多,它不待传入request对象,并无推荐使用

redirect()

redirect(to, permanent=False, *args, **kwargs)[source]

这措施可称为页面跳转,可以得达到某种条件时,如再登陆Tmall界面,登陆成功未来会超越反至用户之主界面

默认情状下,为临时重定向;通过 permanent=True 设置永久重定向

from django.shortcuts import render, HttpResponse,redirect

def register(request_info):

    if request_info.method == 'POST':
        user = request_info.POST.get('user')
        pwd = request_info.POST.get('pwd')
        if user == 'leguan' and pwd == '187418':
            return redirect('/login/')
        return HttpResponse('账号或密码错误')
    return render(request_info,'register.html')


def login(request_info):
    return render(request_info,'login.html')

# 在此可能会想到用render也可以再条件达成之后进行页面的跳转。
# 那么俩者之间有什么区别呢
# 1、the most important: url没有跳转到/login/,而是还在/register/,所以当刷新后又得重新登录.

DEMO

from django.http import JsonResponse

在经过Ajax发送请求时,后端平传参时可能会师因而到JSON体系化,通过JsonResponse即可

from django.http import JsonResponse
result = {'status': True, 'data': None}
return JsonResponse(result)

# 等同于

import json
return HttpResponse(json.dumps(result))

DEMO

补充

通常再后端想要将一些变量给前端或替换一些内容
通常在views视图是这样

def index(request_info):

    user = ['苍空','波多','饭岛',16]

    return render(request_info,'index.html',{'user':user})

那么如果变量很多的情况下,还需要再组成多组键值对进行传递么,locals()很好的解决了这个问题

# 等同于上面
def index(request_info):

    user = ['苍空','波多','饭岛',16]

    return render(request_info,'index.html',locals())

# locals()
它是局部的,渲染所有的局部变量,可以将函数内所有的变量传递request对象获取到。
注意点、此时视图函数内的变量名称要和前端代码的变量名称对应

D、自定义filter和simple_tag

# 1、在app中创建templatetags模块(必须的)

# 2、创建任意 .py 文件,如:my_tags.py
from django import template
from django.utils.safestring import mark_safe

register = template.Library()  # register的名字是固定的,不可改变


@register.filter
def custom_filter(x,y):

    return x*y


@register.simple_tag
def custom_simple(x,y,z):
    return x+y+z
# 3、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py :{% load my_tags %}

# 4、使用simple_tag和filter(如何调用)
-------------------------------HTML文件
{% load xxx %}         # 位于首行,xxx代表自定义的文件名
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Hello {{ user.0 }}</h1>

    {{ user.3|custom_filter:8 }}

    {% custom_simple user.3 2 3 %}
</body>
</html>

# 5、在settings中的INSTALLED_APPS配置当前app,不然django无法找到自定义的simple_tag

# 6、注意点、filter可以用在if等语句后,simple_tag不可以
{% if num|filter_multi:30 > 100 %}
    {{ num|filter_multi:30 }}
{% endif %}

fileter simple_tag DEMO

C、模板语言的操纵语句

if AND for DEMO

# 1、{% if %} 的使用 
{% if %}标签计算一个变量值,如果是“true”,即它存在、不为空并且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的所有内容
{% if num >= 100 and 8 %}
    {% if num > 200 %}
        <p>num大于200</p>
    {% else %}
        <p>num大于100小于200</p>
    {% endif %}
{% elif num < 100%}
    <p>num小于100</p>
{% else %}
    <p>num等于100</p>
{% endif %}

# {% if %} 标签接受and,or或者not来测试多个变量值或者否定一个给定的变量
# {% if %} 标签不允许同一标签里同时出现and和or,否则逻辑容易产生歧义,例如下面的标签是不合法的:
# {% if obj1 and obj2 or obj3 %}  

# 2、{% for %}的使用
{% for %}标签允许你按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染{% for %}和{% endfor %}之间的所有内容
<ul>
{% for obj in list %}
    <li>{{ obj.name }}</li>
{% endfor %}
</ul>

#在标签里添加reversed来反序循环列表:

    {% for obj in list reversed %}
    ...
    {% endfor %}

#{% for %}标签可以嵌套:

    {% for country in countries %}
        <h1>{{ country.name }}</h1>
        <ul>
         {% for city in country.city_list %}
            <li>{{ city }}</li>
         {% endfor %}
        </ul>
    {% endfor %}

# 系统不支持中断循环,系统也不支持continue语句,{% for %}标签内置了一个forloop模板变量,
# 这个变量含有一些属性可以提供给你一些关于循环的信息

1,forloop.counter表示循环的次数,它从1开始计数,第一次循环设为1:

    {% for item in todo_list %}
        <p>{{ forloop.counter }}: {{ item }}</p>
    {% endfor %}
2,forloop.counter0 类似于forloop.counter,但它是从0开始计数,第一次循环设为0
3,forloop.revcounter
4,forloop.revcounter0
5,forloop.first当第一次循环时值为True,在特别情况下很有用:

    {% for object in objects %}   
         {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}   
         {{ object }}   
        </li>  
    {% endfor %}  

# 富有魔力的forloop变量只能在循环中得到,当模板解析器到达{% endfor %}时forloop就消失了
# 如果你的模板context已经包含一个叫forloop的变量,Django会用{% for %}标签替代它
# Django会在for标签的块中覆盖你定义的forloop变量的值
# 在其他非循环的地方,你的forloop变量仍然可用

#{% empty %}

{{li }}
      {%  for i in li %}
          <li>{{ forloop.counter0 }}----{{ i }}</li>
      {% empty %}
          <li>this is empty!</li>
      {% endfor %}

#         [11, 22, 33, 44, 55]
#            0----11
#            1----22
#            2----33
#            3----44
#            4----55

static配置

#3、STATIC文件还可以配置STATICFILES_DIRS,指定额外的静态文件存储位置。
    #  STATIC_URL的含义与MEDIA_URL类似。

    # ----------------------------------------------------------------------------
    #注意1:
        #为了后端的更改不会影响前端的引入,避免造成前端大量修改

        STATIC_URL = '/static/'               #引用名
        STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"statics")  #实际名 ,即实际文件夹的名字
        )

        #django对引用名和实际名进行映射,引用时,只能按照引用名来,不能按实际名去找
        #<script src="/statics/jquery-3.1.1.js"></script>
        #------error-----不能直接用,必须用STATIC_URL = '/static/':
        #<script src="/static/jquery-3.1.1.js"></script>

    #注意2(statics文件夹写在不同的app下,静态文件的调用):

        STATIC_URL = '/static/'

        STATICFILES_DIRS=(
            ('hello',os.path.join(BASE_DIR,"app01","statics")) ,
        )

        #<script src="/static/hello/jquery-1.8.2.min.js"></script>

    #注意3:
        STATIC_URL = '/static/'
        {% load staticfiles %}
       # <script src={% static "jquery-1.8.2.min.js" %}></script>

视图层

对逻辑负责处理用户的要并回到响应。反回可以是HTML内容之网页,或又定向,或404错,或一个XML文件,或一个映像……此代码可以歇在另外你想去之地点,只要她以公的Python路径。

于一个文书被如将视图views.py,放在项目要应用程序目录。

http请求被发出两独主旨目的:http请求:HttpRequest对象
http响应:HttpResponse对象 所在地方:django.http

A、深度变量查找

在届上述截止的例证中,通过 context
传递的简练参数值紧即便字符串,但是,模板系统能好简洁地处理越扑朔迷离的数据结构,例如list、dictionary和从定义的对象。

# python manage.py shell   首先进入Django项目环境终端

# 1、访问列表索引
>>> from django.template import Template, Context
>>> t = Template('Item 2 is {{ items.2 }}.')
>>> c = Context({'items': ['apples', 'bananas', 'carrots']})
>>> t.render(c)
'Item 2 is carrots.'

# 2、访问字典索引
>>> from django.template import Template,Context
>>> person = {"name":"Alex","age":18}
>>> t = Template("{{person.name}} is {{person.age}} years old.")
>>> c = Context({"person":person})
>>> t.render(c)
'Alex is 18 years old.'

# 3、datetime示例
>>> from django.template import Template,Context
>>> import datetime
>>> day = datetime.datetime.utcnow()
>>> day.year
>>> day.month
>>> day.day
>>> t = Template('The month is {{ date.month }} and the year is {{date.year}}')
>>> c = Context({'date':day})
>>> t.render(c)
'The month is 3 and the year is 2017'

# 4、类的实例
>>> from django.template import Template, Context
>>> class Person(object):
...     def __init__(self, first_name, last_name):
...         self.first_name, self.last_name = first_name, last_name
>>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
>>> c = Context({'person': Person('John', 'Smith')})
>>> t.render(c)
'Hello, John Smith.'

# 5、引用对象方法
>>> from django.template import Template,Context
>>> t = Template("{{var}}--{{var.upper}}--{{var.isdigit}}")
>>> t.render(Context({"var":"Hello"}))
'Hello--HELLO--False'
>>> t.render(Context({"var":"666"}))
'666--666--True'

# 注意点
调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数;你只能调用不需参数的方法。

POINT DEMO

Django

配备文件

1.静态文件

    # 在settings里修改添加,放css,js,image等文件
    # 创建static文件夹

    STATIC_URL = '/static/'  # 相当于别名

    STATICFILES_DIRS = (
            os.path.join(BASE_DIR,'static'),
    )


    # 如引用Jquery文件,有俩种形式

    1、 直接引入

    2、 {% load staticfiles %}

          {% static '文件名' %}

    # 推荐使用第二种形式,第一条代码并处理引入文件代码的上方
    # 再每个app里面我们可能会有多个文件配置信息,则可以相应的将文件夹放在app的文件夹下,并修改路径。

2.模板

    # 在settings里修改,放html文件

    TEMPLATE_DIRS = (
            os.path.join(BASE_DIR,'templates'),

3.数据库

django支持sqlite,mysql, oracle,postgresql数据库
django默认使用sqlite的数据库,默认自带sqlite的数据库驱动 ,
引擎名称:django.db.backends.sqlite3
由Django内部连接MySQL时行使的凡MySQLdb模块,而python3负尚无夫模块,所以用以pymysql来取代
安装放置的和project同名的布局的 init.py文件中

 import pymysql
pymysql.install_as_MySQLdb() 


# 在settings 中修改DATABASES

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'dbname',   # 数据库名称
        'USER': 'root',     # 用户名
        'PASSWORD': 'xxx',  # 密码
        'HOST': '',         # IP,留空默认localhost
        'PORT': '',         # 端口
    }
}

static的详实介绍

# 注意1:
        # 为了后端的更改不会影响前端的引入,避免造成前端大量修改

        STATIC_URL = '/static/'               # 引用名
        STATICFILES_DIRS = (
            os.path.join(BASE_DIR,"statics"), # 实际名 ,即实际文件夹的名字
        )

        # django对引用名和实际名进行映射,引用时,只能按照引用名来,不能按实际名去找
        # <script src="/statics/jquery-3.1.1.js"></script>
        # ------error-----不能直接用,必须用STATIC_URL = '/static/':
        # <script src="/static/jquery-3.1.1.js"></script>

# 注意2(statics文件夹写在不同的app下,静态文件的调用):

        STATIC_URL = '/static/'

        STATICFILES_DIRS=(
            ('hello',os.path.join(BASE_DIR,"app01","statics")),
        )

        # <script src="/static/hello/jquery-1.8.2.min.js"></script>

# 注意3:
        STATIC_URL = '/static/'
        {% load staticfiles %}
        # <script src={% static "jquery-1.8.2.min.js" %}></script>

# 注意4:
        配置STATIC路径时,记得要最后一个元组后面加逗号,不然会影响渲染

常用命令

终点履行的授命:

    # 查看django版本
    $ python -m django --version

    # 创建项目,名为mysite
    $ django-admin startproject mysite

    # Django项目环境终端
    $ python manage.py shell

    # 创建应用程序,确保和 manage.py 是同一目录
    $ python manage.py startapp polls

    # 启动django
    $ python manage.py runserver
    $ python manage.py runserver 8080
    $ python manage.py runserver 0.0.0.0:8000

    # 运行创造模型变化迁移
    $ python manage.py makemigrations

    # 运行应用模型变化到数据库
    $ python manage.py migrate

    # 同步数据库
    $ python manage.py syncdb

    # 清空数据库(保留空表)
    $ python manage.py flush

    # admin创建管理员用户
    $ python manage.py createsuperuser

    # 修改用户密码
    $ python manage.py changepassword username

横流:自动重新加载
runserver,依据需要支出服务器自动还加载Python代码为每个请求。您不需还起动服务器代码更改生效。然则,像长文书某些操作不接触重新开动,所以你无法不还开动于那个情况下之服务器。

下是骨干的目录结构和功效

    mysite/              # 项目的容器,名称自定义
        manage.py        # 命令行实用工具,以各种方式与该Django项目进行交互
        mysite/          # 实际的Python项目
            __init__.py  # 空文件,导入不出错
            settings.py  # 这个Django项目配置
            urls.py      # 这个Django项目的URL声明; 一个Django驱动网站的“目录”
            wsgi.py      # 一个入口点为WSGI兼容的Web服务器,以满足您的项目

3、表操作

a、基本操作

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

b、进阶操作(了不起的双双下蛋划线)

# 获取个数
        #
        # 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)

c、连表操作(了不起的双生划线)

表结构实例

# DEMO
# 班级和老师存在多对多关系、班级和学生存在一对多关系
from django.db import models

class Classes(models.Model):
    titile = models.CharField(max_length=32)
    m = models.ManyToManyField('Teachers')


class Teachers(models.Model):
    name = models.CharField (max_length=32)


class Student(models.Model):
    username = models.CharField(max_length=32)
    age = models.IntegerField()
    gender = models.BooleanField()
    cs = models.ForeignKey(Classes)

单表

# 增
# Teachers.objects.create(name='root')
# obj = Teachers(name='root')
# obj.save()
# 查
# Teachers.objects.all()
# Teachers.objects.filter(id=1)
# Teachers.objects.filter(id=1,name='root')
# result = Teachers.objects.filter(id__gt=1)
# [obj(id,name),]
# result = Teachers.objects.filter(id__gt=1).first()
# 删
# Teachers.objects.filter(id=1).delete()
# 改
# Teachers.objects.all().update(name='alex')
# Teachers.objects.filter(id=1).update(name='alex')

一对多

# 增加
# Student.objects.create(username='东北',age=18,gender='男',cs_id=1)
# Student.objects.create(username='东北',age=18,gender='男',cs= Classes.objects.filter(id=1).first() )
# 查看
"""
ret = Student.objects.all()
# []
# [ obj(..),]
# [ obj(1      东北       18     男         1),obj(2      东北1      118     男         2),obj(..),]
for item in ret:
    print(item.id)
    print(item.username)
    print(item.age)
    print(item.gender)
    print(item.cs_id)
    print(item.cs.id)
    print(item.cs.name)
"""
# 删除
# Student.objects.filter(id=1).delete()
# Student.objects.filter(cs_id=1).delete()

# cid = input('请输入班级ID')
# Student.objects.filter(cs_id=cid).delete()

# cname = input('请输入班级名称')
# Student.objects.filter(cs_id=cid).delete()
# Student.objects.filter(cs__name=cname).delete()

多对多

班级:
id  title
   3班
   4班
   5班
老师:
id   title
   Whatmini
   Tom
   Honny
   Eric
 老师班级关系表(类):
id   班级id   老师id
    1        2
    1        3
    2        2
    2        3
    2        4
    1        5


# 增
obj = Classes.objects.filter(id=1).first() #1    3班
obj.m.add(2)
obj.m.add([4,3])

# obj = Classes.objects.filter(id=2).first() #1    3班
# obj.m.add(2)
# obj.m.add([4,3])

obj = Classes.objects.filter(id=1).first() #1    3班
# 删除
# obj.m.remove([4,3])
# 清空
obj.m.clear()
# 重置
obj.m.set([2,3,5])

# 查第三张表
# 把3班的所有老师列举
obj = Classes.objects.filter(id=1).frist()
obj.id
obj.titile
ret = obj.m.all() # 第三张表
# ret是一个 [ 老师1(id,name),obj(id,name)   ]

d、其余操作

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


    # exists()方法来检查是否有数据 exists()的检查可以避免数据放入queryset的cache。
    # obj = Book.objects.filter(id=4)
    # if obj.exists():print("hello world!")

    # 执行原生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()

Q、F、exists()

e、补充

# values             取到的是字典集合
    # values_list        取到的是没有键的元祖形式

    # get                只有在能取到一条数据的时候才不会报错(不推荐)
    # filter([筛选条件])
    # all()              俩者取到的都是Query set集合对象 是可迭代、可切片、索引取值

    # iterator()         ORM的惰性机制
                         # Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet
                         # 并不会马上执行sql,而是当调用QuerySet的时候才执行。

次、Django的根原理(静态页面):

对此Django的计划性原理这里相会由此Python的Socket来演示:

    import socket


    +++++++++++C过程++++++++++++++++++++++++++    
    def f1(request):
        """
        处理用户请求,并返回相应的内容
        :param request: 用户请求的所有信息
        :return:
        """
        f = open('index.fsw','rb')
        data = f.read()
        f.close()
        return data

    def f2(request):
        f = open('aricle.tpl','rb')
        data = f.read()
        f.close()
        return data
    +++++++++++C过程++++++++++++++++++++++++++    


    +++++++++++D过程++++++++++++++++++++++++++
    routers = [
        ('/xxx', f1),
        ('/ooo', f2),
    ]
    +++++++++++D过程++++++++++++++++++++++++++


    ++++++++++++A过程++++++++++++++++++++++++++       
    def run():
        sock = socket.socket()
        sock.bind(('127.0.0.1',8080))
        sock.listen(5)

        while True:
            conn,addr = sock.accept() # hang住
            # 有人来连接了
            # 获取用户发送的数据
            data = conn.recv(8096)
            data = str(data,encoding='utf-8')
            headers,bodys = data.split('\r\n\r\n')
            temp_list = headers.split('\r\n')
            method,url,protocal = temp_list[0].split(' ')
            conn.send(b"HTTP/1.1 200 OK\r\n\r\n")
    +++++++++++++++A过程+++++++++++++++++++++++

    +++++++++++++++B过程+++++++++++++++++++++++
            func_name = None
            for item in routers:
                if item[0] == url:
                    func_name = item[1]
                    break

            if func_name:
                response = func_name(data)   
            else:
                response = b"404"

            conn.send(response)
            conn.close()

    +++++++++++++++B过程+++++++++++++++++++++++

    if __name__ == '__main__':
        run()

分析:

上述是一个概括socket加载的静态页面,也是最最基础的一个Django的一个框架雏形

A过程—循环的接受客户端的央浼,并拆分客户之呼吁新闻(message_header)那些进程是乱的。

B过程—对A过程的拆分好的客户端音举办分析,并因请求音讯重临调用对应之页面反馈让客户端

C过程–至极给Django的视图函数,经路由分配后B过程调用的履代码

D过程–就是Django的路由分配体系。

模板层

当一个Web框架,Django 需要模板。模板包含所欲的 HTML
输出静态部分以及动态内容插入。

模板由 HTML代码+逻辑控制代码
构成,既然被模板层,相应爆发一个模板语言的定义(语法格式:{{var_name}}),那么简单的刺探下

>>> python manange.py shell  (进入该django项目的环境)
>>> from django.template import Context, Template
>>> t = Template('My name is {{ name }}.')
>>> c = Context({'name': 'Tony'})
>>> t.render(c)
'My name is Tony.'


# 同一模板,多个上下文,一旦有了模板对象,你就可以通过它渲染多个context,无论何时我们都可以
# 像这样使用同一模板源渲染多个context,只进行 一次模板创建然后多次调用render()方法渲染会
# 更为高效:
# Low
for name in ('John', 'Julie', 'Pat'):
    t = Template('Hello, {{ name }}')
    print t.render(Context({'name': name}))

# Good
t = Template('Hello, {{ name }}')
for name in ('John', 'Julie', 'Pat'):
    print t.render(Context({'name': name}))

Model层

Django提供了一个抽象层(”Model”)的构建与管理Web应用程序的多少。

Django使用相同种植新的法子,即:关系对象映射(Object Relational
Mapping,简称ORM)。

  • 每个模型是一个Python类,子类django.db.models.model
  • 型中之每个属性代表一个数据库字段。

     DEMO
    
    class Student(models.Model):
        name = models.CharField(max_length=10)
        sex = models.CharField(max_length=10)
        age = models.IntegerField()
        grade = models.ForeignKey('Grade')
    

** 字段**

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)
        - 二进制类

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'), ]
                                )

2、连表结构像当建表的早晚该了然及如何

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

一、什么是web框架

框架,即framework,特指为缓解一个开放性问题而规划的富有一定约束性的支撑结构,使用框架可以帮你飞支付特定的网,简单地说,就是你用别人搭建好的戏台来进行表演。
对此有着的Web应用,本质上其实即使是一个socket服务端,用户之浏览器其实就是是一个socket客户端。

绝简易的Web应用即是优先将HTML用文件保留好,用一个成的HTTP服务器软件,接收用户要,从文本被读取HTML,再次回到。

倘假定动态生成HTML,就得把上述手续自己来促成。不过,接受HTTP请求、解析HTTP请求、发送HTTP响应都是搬运工活,假若我们好来写这一个底层代码,还未曾开首勾画动态HTML呢,就得费个将月去读HTTP规范。

不错的做法是脚代码由专门的服务器软件实现,大家用Python专注让生成HTML文档。因为大家无盼接触到TCP连接、HTTP原始请求和响应格式,所以,需要一个合之接口,让我们专心用Python编写Web业务。

斯接口就是WSGI:Web Server Gateway Interface。

E、模板继承和模板语言

时浏览天猫之许多例外页面中,导航栏一些其他一些的内容一贯是无变换的。那么,在合网站受,如何减弱并用页面区域所引起的再次和冗余代码?

Django 解决此类题材的首选办法是运用更为文雅的方针—— 模板继承

本质上吧,模板继承就是优先构造一个基础框架模板,而后在其子模板被针对她所包含站点公用部分与概念片进行重载

母板:{% block title %}{% endblock %}    # 定义盒子
子板:{% extends "base.html" %}          # 继承母板的内容,且必须放在模板第一行
   {% block title %}{% endblock %}    # 可以对盒子的内容进行修改
     {% csrf_token %}                   # 取消csrf安全保护
   {% black.super %}



     {% include '小组件路径' %}           # HTML出现相同块代码时,新建公用小组件HTML文件

Django的平底原理(动态页面)

        import socket

        def f1(request):
            """
            处理用户请求,并返回相应的内容
            :param request: 用户请求的所有信息
            :return:
            """
            f = open('index.fsw','rb')
            data = f.read()
            f.close()
            return data

        def f2(request):
            f = open('aricle.tpl','r',encoding='utf-8')
            data = f.read()
            f.close()
            import time
            ctime = time.time()
            data = data.replace('@@sw@@',str(ctime))
            return bytes(data,encoding='utf-8')

        def f3(request):
            import pymysql

            # 创建连接
            conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='db666')
            cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
            cursor.execute("select id,username,password from userinfo")
            user_list = cursor.fetchall()
            cursor.close()
            conn.close()

            content_list = []
            for row in user_list:
                tp = "<tr><td>%s</td><td>%s</td><td>%s</td></tr>" %(row['id'],row['username'],row['password'])
                content_list.append(tp)
            content = "".join(content_list)


            f = open('userlist.html','r',encoding='utf-8')
            template = f.read()
            f.close()

            # 模板渲染(模板+数据)
            data = template.replace('@@sdfsdffd@@',content)
            return bytes(data,encoding='utf-8')

        def f4(request):
            import pymysql

            # 创建连接
            conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='db666')
            cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
            cursor.execute("select id,username,password from userinfo")
            user_list = cursor.fetchall()
            cursor.close()
            conn.close()

            f = open('hostlist.html','r',encoding='utf-8')
            data = f.read()
            f.close()

            # 基于第三方工具实现的模板渲染
            from jinja2 import Template
            template = Template(data)
            data = template.render(xxxxx=user_list,user='sdfsdfsdf')
            return data.encode('utf-8')


        routers = [
            ('/xxx', f1),
            ('/ooo', f2),
            ('/userlist.htm', f3),
            ('/host.html', f4),
        ]


        def run():
            sock = socket.socket()
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            sock.bind(('127.0.0.1',8080))
            sock.listen(5)

            while True:
                conn,addr = sock.accept() # hang住
                # 有人来连接了
                # 获取用户发送的数据
                data = conn.recv(8096)
                data = str(data,encoding='utf-8')
                headers,bodys = data.split('\r\n\r\n')
                temp_list = headers.split('\r\n')
                method,url,protocal = temp_list[0].split(' ')
                conn.send(b"HTTP/1.1 200 OK\r\n\r\n")

                func_name = None
                for item in routers:
                    if item[0] == url:
                        func_name = item[1]
                        break

                if func_name:
                    response = func_name(data)
                else:
                    response = b"404"

                conn.send(response)
                conn.close()

        if __name__ == '__main__':
            run()

动态的页面和静态的页面的法则同只是扩展一个模板的导入和渲染。所以对于领会Django的底色的运行机制这一点儿独实例是老大好案例。

提醒:对我们于Django中添加css的渲染文件或者其他文件在导入到过程被之途径问题这里要了然Django的别名配置:

B、变量的过滤器(filter的动)

# 格式 {{obj|filter:param}}

   # 1  add          :   给变量加上相应的值
   #
   # 2  addslashes   :    给变量中的引号前加上斜线
   #
   # 3  capfirst     :    首字母大写
   #
   # 4  cut          :   从字符串中移除指定的字符
   #
   # 5  date         :   格式化日期字符串
   #
   # 6  default      :   如果值是False,就替换成设置的默认值,否则就是用本来的值
   #
   # 7  default_if_none:  如果值是None,就替换成设置的默认值,否则就使用本来的值

# DEMO

#value1="aBcDe"
{{ value1|upper }}<br>

#value2=5
{{ value2|add:3 }}<br>

#value3='he  llo wo r ld'
{{ value3|cut:' ' }}<br>

#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}<br>

#value5=[]
{{ value5|default:'空的' }}<br>

#value6='<a href="#">跳转</a>'
{{ value6 }}

{% autoescape off %}  # Django安全机制关闭
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}<br> # 如果标签不被渲染,加safe即可

{{ value6|striptags }}

#value7='1234'
{{ value7|filesizeformat }}<br>
{{ value7|first }}<br>
{{ value7|length }}<br>
{{ value7|slice:":-1" }}<br>

#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}<br>
value9='hello I am Tony'

Filter DEMO
网站地图xml地图