入门基础

1、WEB框架

MVC  Model  View    Controller
     数据库 模板文件  业务处理

MTV  Model  Template   View
     数据库  模板文件  业务处理

2、Django
安装：pip3 install django
备注： 确认环境变量是否真确添加

    # 1、创建项目：
      django-admin startproject mysite
      进入目录： cd mysite
      启动服务器：python manage.py runserver [217.0.0.1:8000(可选)]

    目录：
        mysite
            - mysite            # 对整个程序进行配置
                - __init__.py   #py3 里边可有可无，py包
                - settings.py   # 配置文件
                - url.py        # url对应关系
                - wsgi.py       # 遵循wsgi规范  uwsgi + nginx
            - manage.py         # 管理程序
                - python manage.py

    # 2、创建app：
    python manage.py startapp appname

    目录：
        blog
            - migrations  # 修改表结构记录
            - __init__    #
            - admin       # 后台管理
            - apps        # 配置当前app
            - models      # ORM 创建数据表
            - tests       # 单元测试
            - views       # 业务代码

   # 3、配置模板路径
        TEMPLATES  'DIRS': [os.path.join(BASE_DIR, 'templates')]

   # 4、配置静态文件路径
        STATIC_URL = '/static/'
        STATICFILES_DIRS = [
            os.path.join(BASE_DIR, "static"),
        ]

   # 5、seetings -> middlerware 注释csrf
   # 6、定义路由规则urls.py
   # 7、定义视图函数views.py
        request.method GET / POST

   # 8、模板渲染，模板语言

Django请求的生命周期：

   请求 -> 路由系统 -> 视图函数 -> 渲染返回render(templates + static + database)

备注：返回的是字符串

   作业：
        sql 8列
        主机管理： ip port ...
        用户表： 用户名，密码
        功能：
            1.登陆
            2.主机管理页面
                - 查看所有的主机信息（4列）
                - 增加主机信息 模态对话框
            3.查看详情
            4.删除  确认对话框
        代码：mymanager

进阶内容

1、路由系统
url(正则) path（字符串）

# （1）路由匹配
    from django.urls import path       普通匹配
    from django.conf.urls import url   正则匹配
    实例：
    path("index", views.index)            处理函数
    path("index", views.Index.as_view())  处理类

# （2）带参路由
    正则匹配  位置参数接收
    ulr("^page-(\d+)-(\d+).html", views.page)  

    命名正则  关键字参数接收
    ulr("^page-(?P<uid>\d+)-(?P<nid>\d+).html", views.page)  

    视图函数接收方式：
    def page(request, uid, nid)
    def page(request, *args)
    def page(request, *kwargs)
    def page(request, *args, *kwargs)

# （3）路由分发
    include("app_name.urls")  一级路由 -> 二级路由

# （4）name参数 对url命名，便于生成url

    path('index', views.index, name="index"),
    url(r'detail-(\d+).html', views.detail, name="detail"),  # 正则
    url(r'page-(?P<uid>\d+)-(?P<nid>\d+).html', views.page, name="page"),

    # views视图中使用：
    from django.urls import reverse
    url1 = reverse("index")                               # index
    url2 = reverse("detail", args=(12))                   # detail/12
    url2 = reverse("page", kwargs={"uid": 12, "nid":13})  # page/12/13

   # 模板语言中使用：
    {% url "index" %}                # index
    {% url "detail" 12%}             # detail/12
    {% url "page" uid=12 nid=13 %}   # page/12/13

# （5）默认值
# （6）命名空间

2、视图

# 1、FBV  function base view  url -> function函数

        def index(request, *args, **kwargs):
            pass

# 2、CBV url -> class类

class Index(views.View):
    def get(self, request,  *args, **kwargs):
        pass
    def dispath():
        pass

数据交互

# 获取用户请求中的数据
        ?name=Tom&age=12
        name = request.GET.get("name", None)
        name = request.POST.get("name", None)

        request.GET.get()
        request.POST.get()
        request.FILES.get()

        checkbox等多选内容
        request.POST.getlist()

        request.path_info  显示当前url

# 文件对象
           obj = request.FILES.get()
           obj.name
           obj.size
           obj.chunks()
           # <form enctype="multipart/form-data"></form>
# 给用户返回数据：
        render(request, 模板文件路径, 字典)
        redirect("url")
        HttpResponse(字符串)

        # 返回字符串
        返回return HttpResponse("字符串")
        渲染模板：return render(request, "html文件", {"data": data})
        重定向：return redirect("url")

3、模板语言

    render(request, "index.html", {"data", data})
    变量{{ variable }}
    列表取值 lst.index
    字典取值 dct.key
    for循环{% for row in data%}循环体{% endfor %}
    列表循环 for i in lst
    字典循环
        for key in dct;
        for key in dct.keys;
        for value in dct.values;
        for key, value in dct.items;

    条件 {% if age %}{% else %}{% endif %}
        大于> 小于< 等于==

4、ORM操作
code first # ok
db first

    #（1）创建类和字段models.py
        a.需要继承自 models.Model
        class User(models.Model):
            id = models.IntegerField()
            name = models.CharField(max_length=32) # 字段长度

        b.注册app
        settings 中配置INSTALLED_APPS  和  DATABASES

        c.执行命令（新建和更新）
        python manage.py makemigrations
        python manage.py migrate

        注意：
            django默认使用MySQLdb 链接mysql  2.0是不是修改了？
            主动修改为pymysql 在project 同名的__init__ 添加如下代码：
            import pymysql
            pymysql.install_as_MySQLdb()

    # （2）根据类对数据表中的数据进行操作

    增
        models.UserInfo.objects.create(name="Jimi", age=24)

        obj = models.UserInfo(name="Tom", age=24)
        obj.save()

        dct = {"name": "Mike", "age": 24}
        models.UserInfo.objects.create(**dct)

    删
        models.UserInfo.objects.filter(id=3).delete()
    改
        models.UserInfo.objects.filter(id=4).update(age=25)

        dct = {"name": "Mike", "age": 24}
        models.UserInfo.objects.filter(id=4).update(**dct)

    查
        select * from tb where id>1
        # 对应：

        models.tb.objects.filter(id=1)
        models.tb.objects.filter(id__gt=1)
        models.tb.objects.filter(id__lt=1)
        models.tb.objects.filter(id__gte=1)
        models.tb.objects.filter(id__lte=1)

        dct = {"username": "Mike", "id__gt": 2}
        models.tb.objects.filter(**dct)

        v1 = models.Business.objects.all()
        # QuerySet  内部是对象

        v2 = models.Business.objects.all().values("id", "caption")
        # QuerySet  内部是字典

        v3 = models.Business.objects.all().values_list("id", "caption")
        # QuerySet  内部是元组

        models.Business.objects.get()  # 获取对象，不存在报错
        lst = models.UserInfo.objects.all() 获取QuerySet对象
        dct = models.UserInfo.objects.filter().first()获取对象或者None

5、外键

    class UserType(models.Model):
        caption = models.CharField(max_length=32)

    class User(models.Model):
        name = models.CharField(max_length=10)
        age = models.IntegerField()
        # user_type_id = models.IntegerField() # 约束
        user_type = models.ForeignKey("UserType", to_field="id")


    数据类型
        数字 字符串ChairField 时间 二进制
        AutoField(primary_key=True)  #重写自增字段

    参数字段
    null                是否可以为空
    db_column           列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         是否为主键
    db_index            是否建立索引
    unique              是否建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
    auto_now            创建时，自动生成时间
    auto_now_add        更新时，自动更新为当前时间

        obj = models.UserInfo.object.filter().first()
        obj.caption = "CEO"
        obj.save()

    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          自定义错误验证（列表类型），从而定制想要的验证规则


    admin
    创建后台用户：
    python manage.py createsuperuser
    一对多关系 外键 外键字段_id
    多对多关系

规则：
GET: 获取数据
POST: 提交数据

作业：用户管理
    1.用户组的增删改查
    2.用户的增删改查
        添加，修改，删除（需显示默认值，模态对话框）
    3.比较好看的页面

ajax

    $.ajax({
        url:"/update",
        type:"post",
        data:$("#edit-form").serialize()
        //打包发送
     });

多对多关系
1、自定义关系表 建立第三张表

models.ForeignKey

2、自动创建关系表

 r = models.ManyToManyField("tablename")
obj = Application.objects.get(id=1)
obj.name

操作第三张表

obj.r.add(1)
obj.r.add(2,3,4)
obj.r.add(*[2, 3, 4])

obj.r.remove(1)
obj.r.remove(2,3,4)
obj.r.remove(*[2, 3, 4])

obj.r.clear()

obj.r.set([2, 3, 4])

获取所有相关的主机对象列表  QuerySet对象
obj.r.all()

作业：
    1.主机管理：增删改查
    2.应用管理：增删改查
    3.ajax方式
    4.新url方式

知识点概要：
urls

views

        请求的其他信息
            request: from django.core.handlers.wsgi import WSGIRequest
            获取信息
            request.environ
            request.environ["HTTP_USER_AGENT"]

models
一对多操作
多对多操作
templates
自定义函数

        # 模板继承
            {% extends "master.html"%}
            {% block title %}需要替换的内容{% endblock %}
            {% include "tag.html" %}
        # 模板函数
            {{ time|date:"Y-m-d H:i:s" }}
            {{ string|truncatewords:"30" }}
            {{ list|first|upper }}
            {{ name|lower }}
            {{ name|safe }}  # 安全代码，可以解析网页标签
        # 自定义函数
            # simple_tag
                a.app下新建文件夹：templatetags
                b.任意py文件
                c.创建template对象 register
                d.创建函数
                    from django import template
                    register = template.Library()
                    @register.simple_tag
                    def func(arg1, arg2, ...):
                        return "xxoo"
                e.settings中注册app
                f.html文件顶部{% load py文件名 %}
                g.html调用{% 函数名 arg1 arg2 %}
                优点： 任意个参数
                缺点：不能用在if语句

            # filter
                a.app下新建文件夹：templatetags
                b.任意py文件
                c.创建template对象 register
                d.创建函数
                    from django import template
                    register = template.Library()
                    @register.filter
                    def func(arg1, arg2):
                        return "xxoo"
                e.settings中注册app
                f.html文件顶部{% load py文件名 %}
                g.html调用{{ arg1|函数名:arg2 }}
                优点：能用在if语句
                缺点：只能有两个参数，不能加空格

装饰器
cookie
form验证
缓存
中间件
信号
csrf
admin

上节内容回顾
1、请求周期：
url -> 路由 -> 函数或类 -> 返回字符串或模板语言

Form表单提交
提交 -> url -> 函数或类中的方法
HttpResponse(“…”)
render(request, “index.html”)
redirect(“/index”) 当收到redirect自动发起另一个请求
用户 <- 字符串 <-
当收到redirect自动发起另一个请求 -> url

Ajax提交

        $.ajax({
            url: "/index",
            data: {"k", "v", "list": [1, 2, 3, 4]}, //$(form对象).serialize()
            type: "POST",
            dataType: "JSON",
            traditional: true，  # 让后台支持列表获取
            success: function(d){
                location.reload() 刷新页面
                location.href ="" 跳转
            }
        })

    提交 -> url -> 函数或类中的方法
                    HttpResponse()  返回字符串json.dumps()
                    render()  # 前端不能修改的字符串
                    redirect()  # 不可以
    用户 <- 字符串  <-

2、路由系统URL

    a./index/                          -> 函数或类
    b./index/(\d+)                     -> 函数或类
    c./index/(?P<nid>\d+)              -> 函数或类
    d./index/(?P<nid>\d+) name="root"  -> 函数或类
        reverse()          反转url
        {% url "root" 1%}  模板语言
    e./crm/   include("app.urls")      -> 路由分发
    f.默认值
        /index/, views.index, {"name": "root"}
        def func(request, name):
            print(name) # "root"
    g.命名空间
        /a/   include("app.urls", namespace="m1")
        /b/   include("app.urls", namespace="m2")

        app.urls
        app_name = "app"
        /index/  name="n1"

        reverse("m1:n1")    反转url
        {% url "m1:n1" 1%}  模板语言

3、request

    def func(request):
        request.method
        request.GET
        request.POST
        request.FILES
        request.get()
        request.getlist()
        request.path_info  # 当前url

        return HttpResponse render redirect

4、模板引擎

    render(request, "index.html")
    # for
    # if
    # 索引(.) keys values items all

5、数据库操作

    class User(models.Model):
        username = models.CharField(max_length=32)
        email = models.EmailField()

    有验证功能：
        DjangoAdmin
    无验证功能：
    models.User.objects.create(username="root",email="xxx@qq.com")
    models.User.objects.filter(id=1).update(email="yyy@qq.com")

    # 一对多关系
    class UserType(models.Model):
        name = models.CharField(max_length=32)

    class User(models.Model):
        username = models.CharField(max_length=32)
        email = models.EmailField()
        user_type = ForeignKey("UserType")  # 默认创建 user_type_id 字段

    user_list = models.User.objects.all()  # select * from user;
    for user in user_list:
        user.username  user.email user.user_type_id   # 字段
        user.user_type.name  user.user_type.id   # 对象  通过 "." 访问

    user = models.User.objects.get(id=1)
    user.属性

    models.User.objects.all().values("username", "user_type__name") # 通过 "__" 访问

    # 多对多关系
    class UserType(models.Model):
        name = models.CharField(max_length=32)

    class User(models.Model):
        username = models.CharField(max_length=32)
        email = models.EmailField()
        user_type = models.ForeignKey("UserType")  # 默认创建 user_type_id 字段
        m = models.ManyToMany("UserGroup")  # 放在两张关系表任意一张都行
        # 创建第三张表

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

    user = models.User.objects.get(id=1)
    user.m.add(2)
    user.m.add(2, 3, 4)
    user.m.add(*[2, 3, 4])

    user.m.clear()

    user.m.remove()

    user.m.set([1, 2, 3])

    user.m.all()  # 多个组 UserGroup对象
    user.m.filter(name="CTO")

作业：
    主机管理
        1.单表操作
        2.1对多
        3.多对多
        要求：
           1. 删除对话框
            2. 修改，添加新url
            3. 基于cookie进行用户验证
            4. 定制显示个数
            5. 分页