Django回顧

day60 2018-04-27

1. 今日內容
    1. 歸納
        1. 98%的時間都是在寫例子 幫你理解Django  --> 由咱們寫的例子對比理解Django框架
        2. 安裝Django
    2. 寫例子
        
        
        
        用戶的瀏覽器(socket客戶端)
            3. 客戶端往服務端發消息
            
            6. 客戶端接收消息
            
            7. 關閉
        
        
        
        JD的服務器(socket服務端)
            1. 啓動,監聽
            2. 等待客戶端鏈接
            
            4. 服務端收消息
            5. 服務端回消息
            
            7. 關閉
        
        
        
        FTP做業:
            
            FTP客戶端:  PUT,1024.avi,2048
            
            FTP服務端:  .split("|")
    
        瀏覽器和服務端通訊都要遵循一個HTTP協議(消息的格式要求).
        
        
        關於HTTP協議:
            1. 瀏覽器往服務端發的叫 請求(request)
                請求的消息格式:
                    請求方法 路徑 HTTP/1.1\r\n
                    k1:v1\r\n
                    k2:v2\r\n
                    \r\n
                    請求數據
                
            2. 服務端往瀏覽器發的叫 響應(response)
                響應的消息格式:
                    HTTP/1.1 狀態碼 狀態描述符\r\n
                    k1:v1\r\n
                    k2:v2\r\n
                    \r\n
                    響應正文   <-- html的內容
    
    動態的網頁:
        本質上都是字符串的替換
    字符串替換髮生在什麼地方:
        在服務端替換完再返回給瀏覽器!!!
        
    總結一下:
        1. web框架的本質:
            socket服務端  與 瀏覽器的通訊
        2. socket服務端功能劃分:
            a. 負責與瀏覽器收發消息(socket通訊)  --> wsgiref/uWsgi/gunicorn...
            
            b. 根據用戶訪問不一樣的路徑執行不一樣的函數
            
            c. 從HTML讀取出內容,而且完成字符串的替換  --> jinja2(模板語言)
            
        3. Python中 Web框架的分類:
            
            1. 按上面三個功能劃分:
                1. 框架自帶a,b,c                 --> Tornado
                2. 框架自帶b和c,使用第三方的a    --> Django
                3. 框架自帶b,使用第三方的a和c    --> Flask
            2. 按另外一個維度來劃分:
                1. Django   --> 大而全(你作一個網站能用到的它都有)
                2. 其餘     --> Flask 輕量級
        
        
        
    3. 新建Django項目
        命令行建立:
            django-admin startproject mysite
        pycharm建立:
            1. File --> New project --> 左側選Django --> 右側填項目路徑,而且勾選python.exe
        
    4. 設置Django項目:
        1. settings.py
            1. 配置HTML文件存放的位置
            2. 配置靜態文件存放的位置
    

2. 做業
    1. 用Django框架把咱們以前寫過登陸的頁面返回給瀏覽器

View Code

 

day61 2018-04-28

1. 內容回顧

    1. HTTP協議消息的格式:
        1. 請求(request)
            請求方法 路徑 HTTP/1.1\r\n
            k1:v1\r\n
            ...\r\n
            \r\n
            請求體        <-- 能夠有,能夠沒有
        
        2. 響應(response)
            HTTP/1.1 狀態碼 狀態描述符\r\n
            k1:v1\r\n
            Content-Type: text/html; charset=utf8\r\n
            \r\n
            響應正文       <-- HTML內容

    2. Python web框架的本質:
        a. 收發socket消息    --> 按照HTTP協議消息格式去解析消息
        
        b. 路徑和要執行的函數的對應關係   --> 主要的業務邏輯
        
        c. 字符串替換                     --> 模板(特殊符號 --> 數據)
        
    3. 一個完整得請求流程:
        0. 啓動服務端,等待客戶端(用戶的瀏覽器)來鏈接
        1. 在瀏覽器地址欄輸入URL,與服務端創建鏈接,瀏覽器發送請求
        2. 服務端收到請求消息,解析請求消息,根據路徑和函數的對應關係,找到將要執行的函數
        3. 執行函數,打開HTML文件,進行字符串替換,獲得一個最終要返回的HTML內容
        4. 按照HTTP協議的消息格式要求,把HTML內容回覆給用戶瀏覽器(發送響應)
        5. 瀏覽器收到響應的消息以後,按照HTML的規則渲染頁面.
        6. 關閉鏈接
        
    
2. Django昨日內容梳理:
    0. Django安裝
        pip3 install django==1.11.11
        
        pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple/ django==1.11.11
    
        PyCharm安裝的時候:
            注意不要勾選那個選項 (大家懂得)

    1. Django項目的啓動:
        1. 命令行啓動
            在項目的根目錄下(也就是有manage.py的那個目錄),運行:
            python3 manage.py runserver IP:端口--> 在指定的IP和端口啓動
            python3 manage.py runserver 端口   --> 在指定的端口啓動
            python3 manage.py runserver        --> 默認在本機的8000端口啓動
        
        2. PyCharm啓動
            點綠色的小三角,直接能夠啓動Django項目(前提是小三角左邊是你的Django項目名)
        
    2. 配置相關   項目名/settings.py文件
        1. Templates(存放HTML文件的配置)       <-- 告訴Django去哪兒找個人HTML文件
        
        2. 靜態文件(css/js/圖片)
            # 靜態文件保存目錄的別名
            STATIC_URL = '/static/'

            # 全部靜態文件(css/js/圖片)都放在我下面你配置的文件夾中
            STATICFILES_DIRS = [
                os.path.join(BASE_DIR, "static"),
            ]
        3. 註釋掉setting.py中 帶有 csrf 的那一行(大概45~47行)
        
        
3. 今日內容
    1. 登陸的完整示例
        
        
    複習:
        form表單日後端提交數據須要注意哪三點:  五一回來默寫    <-- 誰寫錯成from誰就請你們吃雪糕
            1. form不是from,全部獲取用戶輸入的標籤都應該放在form裏面, 而且必需要有name屬性
            2. action屬性控制往哪兒提交,method通常都設置成post
            3. 提交按鈕必須是type=submit,不能是別的類型


    2. GET請求和POST請求
        GET請求:
            1. 瀏覽器請求一個頁面
            2. 搜索引擎檢索關鍵字的時候
            
        POST請求:
            1. 瀏覽器向服務端提交數據,好比登陸/註冊等

    3. Django中的APP:
        什麼是APP?以及爲何要用APP?
        
        project  --> 項目  (老男孩教育大學校)
        
        APP      --> 應用  (Linux學院/Python學院/大數據學院/Java學院)
        
        方便咱們在一個大的Django項目中,管理實現不一樣的業務功能.
        
        1. 建立APP的命令
            1. 命令行,在Django項目的根目錄輸入:
                python3 manage.py startapp app名字
        
    4. ORM
    
    import pymysql
    pymysql.connect(
     ...
     ...
    )
    
    1. 不一樣的程序員寫的SQL水平良莠不齊
    2. 執行效率也良莠不齊
    
    python語法   --自動翻譯-->  SQL語句
    
    jQuery                      DOM
    $("#d1")     --自動翻譯-->  document.getElementById("d1")
    
    ORM: 
        優勢:
            1. 簡單,不用本身寫SQL語句
            2. 開發效率高
        缺點:
            1. 記憶你這個特殊的語法
            2. 相對於大神些的SQL語句,確定執行效率有差距
        
    ORM的對應關係:
        類          --->      數據表
        對象        --->      數據行
        屬性        --->      字段

    ORM能作的事兒:
        1. 操做數據表    --> 建立表/刪除表/修改表
            操做models.py裏面的類
        
        2. 操做數據行    --> 數據的增刪改查
            
        
        不能建立數據庫,本身動手建立數據庫
        
    使用Django的ORM詳細步驟:
        1. 本身動手建立數據庫
            create database 數據庫名;
        2. 在Django項目中設置鏈接數據庫的相關配置(告訴Django鏈接哪個數據庫)
            # 數據庫相關的配置
            DATABASES = {
                'default': {
                    'ENGINE': 'django.db.backends.mysql',  # 鏈接的數據庫類型
                    'HOST': '127.0.0.1',  # 鏈接數據庫的地址
                    'PORT': 3306,  # 端口
                    'NAME': "day61",  # 數據庫名稱
                    'USER': 'root',  # 用戶
                    'PASSWORD': '123456'  # 密碼
                }
            }
        3. 告訴Django用pymysql代替默認的MySQLDB 鏈接MySQL數據庫
            在項目/__init__.py文件中,寫下面兩句:
                import pymysql
                # 告訴Django用pymysql來代替默認的MySQLdb
                pymysql.install_as_MySQLdb()
        4. 在app下面的models.py文件中定義一個類,這個類必須繼承models.Model
            class 類名(models.Model):
                ...
        5. 執行兩個命令
            1. python3 manage.py makemigrations
            2. python3 manage.py migrate


    ORM單表的增長和查詢:
        1. 查詢
            models.UserInfo.objects.all()
            
        2. 增長
            models.UserInfo.objects.create(name="張三")

    
            

View Code

 

day62 2018-05-02

1. 內容回顧
    Django
        1. 安裝
            1. Django版本 1.11.xx
            2. 安裝方式
                1. 命令行        --> Python環境(雙版本,pip的使用)
                2. PyCharm安裝
        2. 建立Django項目
            1. 建立方式
                1. 命令行建立方式
                    1. cd到你要保存Django項目的目錄
                    2. Django-admin startproject 項目名   --> 會在當前目錄建立Django項目
                2. PyCharm建立方式
                    1. File --> new project --> ...
                    2. 建立完以後必定要選在新窗口打開!!!
        3. 配置Django項目
            1. settings.py文件
                1. templates文件夾的位置
                2. 靜態文件
                    1. STATIC_URL         --> 靜態文件夾的別名(在HTML文件中用的)
                    2. STATICFILES_DIRS   --> 靜態文件夾的真正路徑
                3. 註釋掉 csrf 相關的中間件
                4. Django項目鏈接的數據庫信息
        4. Django WEB請求流程(簡版)    
            1. 啓動Django項目,等待用戶鏈接
            2. 瀏覽器在地址欄輸入URL,來鏈接個人Django項目
            3. 在urls.py中 找 路徑和函數的 對應關係
            4. 執行對應的函數
            5. 返回響應
        5. views.py
            1. 專門用來定義處理請求的函數
                1. 基本必備三件套
                    from django.shortcuts import HttpResponse, render, redirect
                    1. HttpResponse("要返回的內容")            --> 一般用於直接返回數據
                    2. render(request, "html文件", {"k1": v1}) --> 返回一個HTML文件或者打開文件進行字符串替換
                    3. redirect("URL")                         --> 告訴用戶的瀏覽器去訪問其餘的URL
            
                2. request相關
                    1. request.method     --> 查看請求的方法
                    2. request.POST       --> 獲取POST請求的數據
                    
        6. ORM使用
            1. 什麼是ORM? 
                是一種編程的方法論(模型), 和語言無關.(其餘的語言也有相似的實現.)
                
            2. ORM的本質:
                類    --->    數據表
                對象  --->    數據行
                屬性  --->    字段
                
                按照規定的語法寫,自動翻譯成對應的SQL語句.
                
            3. ORM的功能:    
                ORM操做數據表
                ORM操做數據行
                
            4. Django裏ORM的使用:
                1. 手動建立數據庫
                2. 在settings.py裏面,配置數據庫的鏈接信息
                    DATABASES = {
                        'default': {
                            'ENGINE': 'django.db.backends.mysql',
                            'NAME': 'day62',
                            'HOST': '127.0.0.1',
                            'PORT': 3306,
                            'USER': 'root',
                            'PASSWORD': '123456',
                        }
                    }
                3. 在項目/__init__.py告訴Django用pymysql模塊代替MySQLdb來鏈接MySQL數據庫
                    import pymysql
                    pymysql.install_as_MySQLdb()
                4. 在app/models.py裏面定義類
                    # 出版社
                    class Publisher(models.Model):
                        id = models.AutoField(primary_key=True)  # 自增的ID主鍵
                        # 建立一個varchar(64)的惟一的不爲空的字段
                        name = models.CharField(max_length=64, null=False, unique=True)
                5. 執行兩個命令
                    1. python3 manage.py makemigrations   --> 把models.py裏面的更改記錄到小本本上
                    2. python3 manage.py migrate  --> 把更改翻譯成SQL語句,去數據庫執行

2. 今日內容
    1. GET請求和POST請求
        都屬於HTTP協議規定的請求方法
        
    2. 何時用GET請求?
        1. 瀏覽器想要獲得一個HTML頁面的時候
        2. 搜索引擎查詢關鍵字的時候       www.sogo.com/web/?query=迪麗熱巴
        
    3. 何時用POST?
        1. 向後端提交數據
            1. 大段的數據
            2. 包含隱私的數據
            3. 上傳文件
            
    4. 實際中GET和POST的應用場景
        1. GET:
            1. 直接在瀏覽器地址欄輸入URL訪問網站
            2. a標籤
        2. POST:
            1. 登陸註冊
            2. 修改(新增)大段的數據
            3. 上傳文件

3. 今日做業
    1. 上課的刪除和編輯功能本身獨立寫出來
    2. 組內討論:
        1. 每一個組員依次說一下Django的請求怎麼走的?
    3. 用Bootstrap把課上的頁面寫一下
        
                    
                    
                    
                    

View Code

 

day63 2018-05-03


1. 內容回顧
    1. 單表的增刪改查
        1. 刪和改
            1. GET請求 URL傳值
                1. 格式
                    127.0.0.1:8000/delete_publisher/?name=alex&id=7
                2. Django後端取值
                    request.GET   --> 大字典
                    request.GET["name"]/request.GET["id"]   --> key不存在就報錯了
                    request.GET.get("name", "sb")           --> 推薦用這個方法取值
                    
            2. 複習一下POST方法提交的數據怎麼取:
                request.POST.get("key")
            3. ORM操做
                1. 刪除
                    1. 先找到對象,調用對象的.delete()方法
                        publisher_obj = models.Publisher.objects.get(id=7)
                        publisher_obj.delete()
                    或者
                        models.Publisher.objects.get(id=7).delete()
                
                2. 修改
                    1. 找到對象,經過修改對象的屬性來修改數據庫中指定字段的值,要保存
                        publisher_obj = models.Publisher.objects.get(id=7)
                        publisher_obj.name = "新的出版社名字"
                        publisher_obj.save()  --> 把修改提交到數據庫
                        
        2. GET和POST
            1. GET請求:
                1. GET請求攜帶的數據都拼在了URL上
                2. GET請求攜帶的數據有長度限制 40k
            2. POST請求
                1. form表單提交數據
                2. 上傳文件
                
            3. 幾個GET請求具體的應用場景:
                1. 瀏覽器地址欄直接輸入URL
                2. 點擊a標籤
                3. 搜索引擎檢索
        3. request相關的知識點
            1. request.method
                1. GET
                2. POST
            2. request.POST   --> 全部和post請求相關的數據
            3. request.GET    --> 全部和GET請求相關的數據
            
2. 今日內容
    1. 圖書管理系統表結構設計
        圖書管理系統的三種角色
            1. 出版社
            2. 書
            3. 做者
        總結關係:
            1. 一本書   只能   有一個出版社
            2. 一本書   能有   多個做者
            3. 一個做者 能寫   多本書
        
            出版社和書: 一對多    --> 外鍵
            書和做者:   多對多    --> 用第三張表作關聯
        
        表結構圖在excel中:
        
        
    2. 查看書籍列表
    3. 添加書籍
        將全部的出版社在頁面上以select標籤的形式展現出來
    4. 刪除書籍
        如何在後端獲取要刪除的是那一個書籍?
        經過URL傳參數的形式
    5. 編輯書籍
        將全部的出版社在頁面上以select標籤的形式展現出來
        將當前編輯的書籍對象的書名和出版社在頁面上展現出來
        
        
        
        
        
        
        
            
            
                        
                    
                    
                    
                        

View Code

 

day64 2018-05-04

1. 內容回顧
    1. ORM外鍵操做
        圖書表和出版社表  多對一 的關係
        
    # 書
    class Book(models.Model):
        id = models.AutoField(primary_key=True)  # 自增的ID主鍵
        # 建立一個varchar(64)的惟一的不爲空的字段
        title = models.CharField(max_length=64, null=False, unique=True)
        # 和出版社關聯的外鍵字段
        publisher = models.ForeignKey(to="Publisher")
        
    2. 查\增\刪\改操做
        1. 查
            book_list = models.Book.objects.all()  --> 書對象的列表
            
        2. 增
            new_book_obj = models.Book.objects.create(
                title="新書的名字",
                # publisher=publusher_obj,
                publisher_id=7
            )
        3. 刪除
            models.Book.objects.get(id=10).delete()
            
        4. 修改
            book_obj = models.Book.objects.get(id=9)
            book_obj.title=request.POST.get("book_title")
            book_obj.publisher_id=9
            book_obj.save()
            
2. 今日內容
    多對多
    做者表的增刪改查
    
    
3. 週末做業
    1. 圖書管理系統寫完
        1. 出版社的增刪改查
        2. 書籍的增刪改查
        3. 做者的增刪改查
    
        班級管理系統
            1. 班級
            2. 學生
            3. 老師
            
    2. 應用Bootstrap樣式
    
    
4. 下週內容預習
    http://www.cnblogs.com/liwenzhou/p/8296964.html
    
            
            
        

View Code

 

「 xss攻擊」

 

django模板語言：

day66 2018-05-08

1. 內容回顧
    1. 模板系統（字符串替換）
        1. 語法
            1. 變量相關： {{ name }}，{{name|length}}，{{name|default:"默認值"}}
            2. 邏輯相關：
                1. if判斷
                    {% if a > b %}
                    {% endif %}
                    
                    {% if a > b %}
                    {% else %}
                    {% endif %}
                    
                    {% if a > b %}
                    {% elif %}
                    {% else %}
                    {% endif %}
                2. for循環
                    1. for循環的基本用法：
                        {% for i in name_list %}
                            {{ i }}
                        {% endfor %}
                        
                        {% for i in name_list %}
                            {{ i }}
                        {% empty %}
                            空空如也
                        {% endfor %}
                    
                    2. for循環可用的屬性：
                        forloop.counter
                        forloop.counter0
                        forloop.revcounter
                        forloop.revcounter0
                        
                        forloop.first 
                        forloop.last 
                        
                        forloop.parentloop  --> 兩層for循環，內層循環引用外層循環
                        
        2. filter
            1. 經常使用的內置filter
                1. length
                2. filesizeformat       --> 格式化文件大小的
                3. date:'Y-m-d H:i:s'   --> 格式化時間的
                4. slice
                5. safe                 --> XSS攻擊（跨站腳本攻擊）
                6. truncatechars:20     --> 截取字符，超過的用...表示
                7. default
                    
            2. 自定義的filter
                示例：
                    1. addsb
                    2. addstr
                具體的實現方式：
                    1. 定義階段
                        1. 在app下面新建一個python的包：templatetags
                        2. 在上面的Python包中新建一個Python文件，名字隨意
                        3. 在上述python文件中：
                            from django import template
                            
                            # 生成一個註冊用的實例
                            register = template.Library()
                            # 定義並註冊一個自定義的filter函數
                            @register.filter(name='addsb')
                            def add_sb(arg):
                                return "{} sb".format(arg)
                    2. 調用階段：
                        1. 在Django的模板文件中，導入剛纔新建的python文件
                            {% load py文件名 %}
                        2. 按照filter的語法調用
                            {{ name|addsb }}
                        
2. 今日內容
    1. 母版和繼承
        1. 爲何要有模板和繼承：
            把多個頁面公用的部分提取出來，放在一個 母版 裏面。
            其餘的頁面只須要 繼承 母版就能夠了。
        2. 具體使用的步驟：
            1. 把公用的HTML部分提取出來，放到base.html文件中
            2. 在base.html中，經過定義block，把每一個頁面不一樣的部分區分出來
            3. 在具體的頁面中，先繼承母版
            4. 而後block名去指定替換母版中相應的位置
        
        3. 使用母版和繼承的注意事項：
            1. {% extends 'base.html' %} --> 母版文件:base.html要加引號
            2. {% extends 'base.html' %}必須放在子頁面的第一行！！！
            3. 能夠在base.html中定義不少block，一般咱們會額外定義page-css和page-js兩個塊
            4. view.py相應的函數中返回的是對應的子頁面文件 不是否是不是 base.html
    2. 組件
        {% include 'xxx.html'%}
        
    3. 靜態文件的靈活寫法
        1.
            {% load static %}
            {% static 'jQuery-3.3.1.js' %}
        2. {% get_static_prefix %}jQuery-3.3.1.js
        
    4. 自定義simple_tag和inclusion_tag
    
    
                
                
                
                
                    
                    

View Code

 

day67 2018-05-09

1. 內容回顧
    1. 模板語言（字符串替換）
        1. 母版和繼承
            1. 何時用母版？
                html頁面有重複的代碼，把它們提取出來放到一個單獨的html文件。
                （好比：導航條和左側菜單）
            2. 子頁面如何使用母版？
                {% extends 'base.html' %}   --> 必需要放在子頁面的第一行
                
                母版裏面定義block(塊)，子頁面使用block(塊)去替換母版中同名的塊
        2. 組件
            1. 何時用組件？
                重複的代碼,包裝成一個獨立的小html文件。
            2. 如何使用？
                {% include 'nav.html' %}
                
        3. Django模板語言中關於靜態文件路徑的靈活寫法
            1. 利用Django模板語言內置的static方法幫我拼接靜態文件的路徑
                {% load static %}
                <link href="{% static 'bootstrap/css/bootstrap.min.css' %}" rel="stylesheet">
            2. 利用內置的get_static_prefix獲取靜態文件路徑的別名，咱們自行拼接路徑
                {% load static %}
                <link href="{% get_static_prefix %}bootstrap/css/bootstrap.min.css" rel=stylesheet>
            3. as語法(一個路徑屢次用到，可使用as保存到一個變量，後面就直接使用變量代替具體路徑)
        4. 自定義的simple_tag
            比filter高級一點點
            它能夠接受的參數個數大於2
        
        5. 自定義的inclusion_tag
            用來返回一段html代碼（示例：返回ul標籤）
            
            1. 定義階段
                在app下面新建templatetags 文件夾（注意是Python包）
                新建一個py文件
                
                from django import template
                # 生成註冊示例，名字必須是register
                register = template.Library()
                @register.inclusion_tag("ul.html")
                def show_ul(num):
                    num = 1 if num < 1 else int(num)
                    data = ["第{:0>3}號技師".format(i) for i in range(1, num+1)]
                    return {"data": data}

            2. 調用階段
                {% load xx %}
                {% show_ul 10 %}
            
2. 今日內容
    1. 視圖（接收請求返回響應那部分）
        1. CBV(class base view)和FBV(function base view)
    
        2. request對象
            1. 以前學過的
                1. request.method    --> 獲取請求的方法（GET、POST等）
                2. request.GET       --> 一般用來獲取URL裏面的參數  
                    127.0.0.1:8000/edit_book/?id=1&name=yimi
                    request.GET --> {"id":1, "name":"yimi"}
                    request.GET.get("id")
                3. request.POST      --> 用來獲取POST提交過來的數據
                    request.POST.get("book_name")
            2. 補充其餘經常使用的：
                1. request.path_info   --> 獲取用戶請求的路徑(不包含IP和端口和URL參數)
                2. request.body     
    
        3. response
            基礎必備三件套(求學要嚴謹)
            1. HttpResponse        --> 返回字符串內容
            2. render              --> 返回一個html頁面             
            3. redirect            --> 返回一個重定向（告訴瀏覽器再去訪問另外的網址）
            
            4. JsonResponse
            
    2. 路由系統（urls.py）  http://www.cnblogs.com/liwenzhou/p/8271147.html
        1. 正則表達式的模糊匹配
        2. 分組匹配        --> 至關於給視圖函數傳遞位置參數
        3. 分組命名匹配    --> 至關於給視圖函數傳遞關鍵字參數
            (兩個不要混合使用)
            
---------------------------- 這裏是坎 ------------------------------------
            
        4. 反向解析URL
            本質上就是給url匹配模式起別名，而後用過別名拿到具體的URL路徑
            
            1. 怎麼起別名?
                在url匹配模式中，定義name="別名"
            2. 如何使用？
                1. 在模板語言裏面使用：
                    {% url "別名" %}  --> 獲得具體的URL路徑
                2. 在視圖中如何使用：
                    from django.urls import reverse
                    
                    reverse("別名")  --> 獲得具體的URL路徑
            3. 如何傳參數？
                1. 模板語言中：
                    {% url "別名" 2018 "nb" %}
                2. 視圖函數中
                    傳位置參數：
                        reverse("別名", args=(2018, "nb"))
                
                    傳關鍵字參數：
                        reverse("別名" kwargs={"year": 2018, "title": "nb"})
            4. namespace
                爲了防止不一樣的app下面的url匹配模式有重複的別名
                
            
3. 今日做業

    1. 把以前圖書管理系統的編輯和刪除功能用url分組匹配的形式修改一下！
    
    2. 把編輯按鈕的連接改爲反向解析URL的形式
        
    
    
    
    
    
    
    
    
    
    
    
        
            
                



        
        
                
                

View Code

 

django視圖的CBV和FBV

http://www.cnblogs.com/liwenzhou/articles/8305104.html

 

day68 2018-05-10

來老男孩教育學習必經的四個階段：
    第一個階段：信心滿滿（我必定能學會，我爲啥學不會）
    第二個階段：自我懷疑（臥槽！還真很差學！）
    第三個階段：極其浮躁（臥槽！怎麼還不畢業！這講師連Django都講不明白！）
    第四個階段：極其焦慮（臥槽！怎麼要畢業了？我什麼都不會，怎麼找工做？）
    
永遠不要高估本身！

1. 內容回顧（趙導專場）
    1. ORM已經的學過的內容：
        1. Django項目如何使用ORM鏈接MySQL
            1. 手動建立數據庫
            2. 在settings.py裏面配置一下數據庫的鏈接信息（告訴Django鏈接哪個數據庫）
                DATABASES = {
                    'default': {
                        'ENGINE': 'django.db.backends.mysql',  # 鏈接數據庫的類型
                        'NAME': 'day62xiawu',  # 數據庫名字
                        'HOST': '127.0.0.1',  # IP
                        'PORT': 3306,  # 端口
                        'USER': 'root',  # 用戶名
                        'PASSWORD': '123456',  # 密碼
                    }
                }
            3. 在和settings.py同目錄下的__init__.py文件中，告訴Django用pymysql代替MySQLdb來鏈接數據庫
                import pymysql
                pymysql.install_as_MySQLdb()
            4. 在app/models.py中，定義類，類必定要繼承models.Model
                class Book(models.Model):
                    id = models.AutoField(primary_key=True)
                    title = models.CharField(max_length=32)
            5. 執行兩條命令
                1. 在哪兒執行？
                    在項目的根目錄（有manage.py文件的那個目錄）
                2. 命令
                    python manage.py makemigrations   --> 將models.py文件中的改動記錄在小本本（app/migrations/00xx_****.py）上
                    
                    python manage.py migrate           --> 將改動翻譯成SQL語句，去數據庫中執行
        2. 表和表之間的關係
            1. 一對多（出版社和書）
                publisher = models.ForeignKey(to="Publisher")
                
                在數據庫中：
                    有沒有publisher這個字段？
                    數據庫中實際 生成的是一個 publisher_id 字段
                
            2. 多對多（做者和書）
                books = models.ManyToManyField(to="Book")
                
                在數據庫中：
                    是經過第三張表創建的關係

        3. 增刪改查操做
            1. 單表增刪改查
                增：
                    models.Publisher.objects.create(name="沙河出版社")
                查：
                    models.Publisher.objects.get(id=1)
                    models.Publisher.objects.get(name="沙河出版社")
                刪：
                    models.Publisher.objects.get(id=1).delete()
                改：
                    obj = models.Publisher.objects.get(id=1)
                    obj.name = "沙河第二齣版社"
                    obj.save()
            2. 外鍵的增刪改查
                增、刪、查同上
                
                book_obj = models.Book.objects.get(id=1)
                
                book_obj.publisher 是什麼？    *****
                    和我這本書關聯的出版社對象
                    
                    book_obj.publisher.id    和我這本書關聯的出版社的id值
                    book_obj.publisher.name  和我這本書關聯的出版社的名稱
                    
                book_obj.publisher_id 是什麼？
                    和我這本書關聯的出版社的id值
                    
            3. 多對多操做
                
                1. 查id爲1的做者都寫過的書？
                    author_obj = models.Author.objects.get(id=1)
                    author_obj.books.all()     --> 和我這個做者關聯的全部書對象
                2. 想給做者綁定多本書？
                    author_obj = models.Author.objects.get(id=1)
                    author_obj.books.set([1,2,3]) --> 把id是一、二、3的書和我這個做者關聯上
                
2. 今日內容

        1. Django ORM經常使用字段：
            1. AutoField       --> 自增
            2. CharField       --> varchar(xx)
            3. ForeignKey      --> 外鍵
            4. ManyToManyField --> 多對多關聯
            
            5. DateField
            6. DateTimeField
            
            7. IntegerField
            
            
        2. 自定義char字段
            class FixedCharField(models.Field):
                """
                自定義的char類型的字段類
                """
                def __init__(self, max_length, *args, **kwargs):
                    self.max_length = max_length
                    super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs)

                def db_type(self, connection):
                    """
                    限定生成數據庫表的字段類型爲char，長度爲max_length指定的值
                    """
                    return 'char(%s)' % self.max_length

            
            
        3. 經常使用的字段參數
            1. null
            2. default
            3. unique
            4. db_index
            
            5. DateField和DateTimeField纔有的參數：
                auto_now_add=True     --> 建立數據的時候自動把當前時間賦值
                auto_add=True         --> 每次更新數據的時候更新當前時間
                
                上述兩個不能同時設置！！！
            
            5. class Meta:
                 db_table = "表名"
        
                
                
                
    

    
    
    
    

View Code

 

day69 2018-05-11

1. ORM增刪改查操做
    http://www.cnblogs.com/liwenzhou/p/8660826.html
    
    
    
    
    1. 單表增刪改查
    
    
    2. 單表的雙下劃線操做
    
    
    3. 外鍵的跨表查詢
        1. 正向查詢
        
        
        2. 反向查詢
    4. 多對多的跨表查詢
        1. 正向查詢
        
        
        2. 反向查詢
    5. 分組和聚合
    
    6. F和Q
    
    7. 事務
    
    8. 執行原生SQL語句
    
        
        
飼養員 還讓 老母豬 笑話着了。

做業：
    把ORM查詢操做多寫幾個例子！！！




後面的項目：
    1. BBS 仿博客園  練手的
    2. CRM   --> 權限系統、Django admin、 Startk組件
    3. 路飛學城   --> Django REST Framework(API)   --> Vue(MVVM框架)
    4. Flask   --> 發佈系統
    5. 爬蟲
    6. 算法+金融那些 
    7. Linux

    
    

View Code

day69補充

"""
ORM小練習

如何在一個Python腳本或文件中 加載Django項目的配置和變量信息
"""

import os

if __name__ == '__main__':
    # 加載Django項目的配置信息
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ormday69.settings")
    # 導入Django，並啓動Django項目
    import django
    django.setup()

    from app01 import models
    # # 查詢全部的人
    # ret = models.Person.objects.all()
    # print(ret)
    # # get查詢
    # ret = models.Person.objects.get(name="小黑")
    # print(ret)
    # # filter
    # ret = models.Person.objects.filter(id=100)  # 不存在返回一個空的QuerySet，不會報錯
    # print(ret)
    # # 就算查詢的結果只有一個，返回的也是QuerySet，咱們要用索引的方式取出第一個元素
    # ret = models.Person.objects.filter(id=1)[0]
    # print(ret)
    # print("exclude".center(80, "*"))
    # # exclude
    # ret = models.Person.objects.exclude(id=1)
    # print(ret)
    # print("values".center(80, "*"))
    # # values 返回一個QuerySet對象，裏面都是字典。 不寫字段名，默認查詢全部字段
    # ret = models.Person.objects.values("name", "birthday")
    # print(ret)
    # print("values_list".center(80, "*"))
    # # values_list 返回一個QuerySet對象，裏面都是元祖。 不寫字段名，默認查詢全部字段
    # ret = models.Person.objects.values_list()
    # print(ret)
    # print("order_by".center(80, "*"))
    # # order_by 按照指定的字段排序
    # ret = models.Person.objects.all().order_by("birthday")
    # print(ret)
    # print("reverse".center(80, "*"))
    # # reverse 將一個有序的QuerySet 反轉順序
    # # 對有序的QuerySet才能調用reverse
    # ret = models.Person.objects.all().reverse()
    # print(ret)
    # print("count".center(80, "*"))
    # # count 返回QuerySet中對象的數量
    # ret = models.Person.objects.all().count()
    # print(ret)
    # print("first".center(80, "*"))
    # # first 返回QuerySet中第一個對象
    # ret = models.Person.objects.all().first()
    # print(ret)
    # print("last".center(80, "*"))
    # # last 返回QuerySet中最後一個對象
    # ret = models.Person.objects.all().last()
    # print(ret)
    # print("exists".center(80, "*"))
    # # exists 判斷表裏有沒有數據
    # ret = models.Book.objects.exists()
    # print(ret)


    # 單表查詢之神奇的雙下劃線
    # # 查詢id值大於1小於4的結果
    # ret = models.Person.objects.filter(id__gt=1, id__lt=4)
    # print(ret)
    # # in
    # # 查詢 id 在 [1, 3, 5, 7]中的結果
    # ret = models.Person.objects.filter(id__in=[1, 3, 5, 7])
    # print(ret)
    # ret = models.Person.objects.exclude(id__in=[1, 3, 5, 7])
    # print(ret)
    # # contains 字段包含指定值的
    # # icontains 忽略大小寫包含指定值
    # ret = models.Person.objects.filter(name__contains="小")
    # print(ret)
    # # range
    # # 判斷id值在 哪一個區間的 SQL語句中的between and  1<= <=3
    # ret = models.Person.objects.filter(id__range=[1,3])
    # print(ret)
    # # 日期和時間字段還能夠有如下寫法
    # ret = models.Person.objects.filter(birthday__year=2000)
    # print(ret)
    # ret = models.Person.objects.filter(birthday__year=2000, birthday__month=5)
    # print(ret)


    # 外鍵的查詢操做

    # 正向查詢
    # 基於對象 跨表查詢
    # book_obj = models.Book.objects.all().first()
    # ret = book_obj.publisher  # 和我這本書關聯的出版社對象
    # print(ret, type(ret))
    # ret = book_obj.publisher.name  # 和我這本書關聯的出版社對象
    # print(ret, type(ret))

    # 查詢id是1的書的出版社的名稱
    # 利用雙下劃線 跨表查詢
    # 雙下劃線就表示跨了一張表
    # ret = models.Book.objects.filter(id=1).values_list("publisher__name")
    # print(ret)

    # 反向查詢
    # 1. 基於對象查詢
    # publisher_obj = models.Publisher.objects.get(id=1)  # 獲得一個具體的對象
    # # ret = publisher_obj.book_set.all()
    # ret = publisher_obj.books.all()
    # print(ret)
    #
    # # 2. 基於雙下劃線
    # ret = models.Publisher.objects.filter(id=1).values_list("xxoo__title")
    # print(ret)

    # 多對多
    # 查詢
    # author_obj = models.Author.objects.first()
    # print(author_obj.name)
    # 查詢金老闆寫過的書
    # ret = author_obj.books.all()
    # print(author_obj.books, type(author_obj.books))
    # print(ret)
    # 1. create
    # 經過做者建立一本書,會自動保存
    # 作了兩件事：
    # 1. 在book表裏面建立一本新書，2. 在做者和書的關係表中添加關聯記錄
    # author_obj.books.create(title="金老闆自傳", publisher_id=2)
    # 2. add
    # 在金老闆關聯的書裏面，再加一本id是4的書
    # book_obj = models.Book.objects.get(id=4)
    # author_obj.books.add(book_obj)
    # 添加多個
    # book_objs = models.Book.objects.filter(id__gt=5)
    # author_obj.books.add(*book_objs)  # 要把列表打散再傳進去
    # 直接添加id
    # author_obj.books.add(9)


    # remove
    # 從金老闆關聯的書裏面把 開飛船 刪掉
    # book_obj = models.Book.objects.get(title="跟金老闆學開飛船")
    # author_obj.books.remove(book_obj)
    # 從金老闆關聯的書裏面把 id是8的記錄 刪掉
    # author_obj.books.remove(8)

    # clear
    # 清空
    # 把景女神 關聯的全部書都刪掉
    # jing_obj = models.Author.objects.get(id=2)
    # jing_obj.books.clear()


    # 額外補充的，外鍵的反向操做

    # 找到id是1的出版社
    # publisher_obj = models.Publisher.objects.get(id=2)
    # publisher_obj.books.clear()

    # 聚合
    from django.db.models import Avg, Sum, Max, Min, Count
    # ret = models.Book.objects.all().aggregate(price_avg=Avg("price"))
    # print(ret)
    #
    # ret = models.Book.objects.all().aggregate(price_avg=Avg("price"), price_max=Max("price"), price_min=Min("price"))
    # print(ret)
    # print(ret.get("price_max"), type(ret.get("price_max")))

    # 分組查詢

    # 查詢每一本書的做者個數
    # ret = models.Book.objects.all().annotate(author_num=Count("author"))
    # # print(ret)
    # for book in ret:
    #     print("書名：{}，做者數量：{}".format(book.title, book.author_num))

    # 查詢做者數量大於1的書
    # ret = models.Book.objects.all().annotate(author_num=Count("author")).filter(author_num__gt=1)
    # print(ret)

    # 查詢各個做者出的書的總價格
    # ret = models.Author.objects.all().annotate(price_sum=Sum("books__price")).values_list("name", "price_sum")
    # ret = models.Author.objects.all().annotate(price_sum=Sum("books__price"))
    # print(ret)
    # for i in ret:
    #     print(i, i.name, i.price_sum)
    # print(ret.values_list("id", "name", "price_sum"))

    # F和Q
    # ret = models.Book.objects.filter(price__gt=9.99)
    # print(ret)

    # 查詢出 庫存數 大於 賣出數的 全部書（兩個字段作比較）
    from django.db.models import F
    # ret = models.Book.objects.filter(kucun__gt=F("maichu"))
    # print(ret)
    # 刷單 把每一本書的賣出數都乘以3
    # obj = models.Book.objects.first()
    # obj.maichu = 1000 * 3
    # obj.save()
    # 具體的對象沒有update()，QuerySet對象纔有update()方法。

    # models.Book.objects.update(maichu=(F("maichu")+1)*3)

    # 給每一本書的書名後面加上 初版
    # from django.db.models.functions import Concat
    # from django.db.models import Value
    #
    # models.Book.objects.update(title=Concat(F("title"), Value("初版")))


    # Q查詢
    from django.db.models import Q
    # 查詢 賣出數大於1000，而且 價格小於100的全部書
    # ret = models.Book.objects.filter(maichu__gt=1000, price__lt=100)
    # print(ret)
    # 查詢 賣出數大於1000，或者 價格小於100的全部書
    # ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100))
    # print(ret)
    # Q查詢和字段查詢同時存在時， 字段查詢要放在Q查詢的後面
    # ret = models.Book.objects.filter(Q(maichu__gt=1000) | Q(price__lt=100), title__contains="金老闆")
    # print(ret)


    # Django ORM 事務

    # try:
    #     from django.db import transaction
    #
    #     with transaction.atomic():
    #         # 先建立一個出版社
    #         new_publisher = models.Publisher.objects.create(name="火星出版社")
    #         # 建立一本書
    #         models.Book.objects.create(
    #             title="橘子物語",
    #             price=11.11,
    #             kucun=10,
    #             maichu=10,
    #             publisher_id=1000  # 指定一個不存在的出版社id
    #         )
    # except Exception as e:
    #     print(str(e))

    # 沒有指定原子操做
    # try:
    #
    #     # 先建立一個出版社
    #     new_publisher = models.Publisher.objects.create(name="火星出版社")
    #     # 建立一本書
    #     models.Book.objects.create(
    #         title="橘子物語",
    #         price=11.11,
    #         kucun=10,
    #         maichu=10,
    #         publisher_id=1000  # 指定一個不存在的出版社id
    #     )
    # except Exception as e:
    #     print(str(e))

    # 執行原生SQL
    # 更高靈活度的方式執行原生SQL語句
    # from django.db import connection
    # cursor = connection.cursor()  # cursor = connections['default'].cursor()
    # cursor.execute("SELECT * from app01_book where id = %s", [1])
    # ret = cursor.fetchone()
    # print(ret)


    # 在QuerSet查詢的基礎上本身指定其餘的SQL語句(瞭解便可)
    ret = models.Book.objects.extra(
        # 把出版社計數 賦值給newid
        select={'newid': 'select count(1) from app01_publisher where id>%s'},
        select_params=[1, ],

        where=["app01_book.id=%s"],

        params=[1, ],
        tables=['app01_publisher']
    )

    print(ret)
    for i in ret:
        print(i)

View Code

 ORM模塊一對一 ，多對多：

day70 2018-05-14

1. 內容回顧
    1. ORM
        1. ORM經常使用字段和屬性
            1. AutoField(primary_key=True)
            2. CharField(max_length=32)
            3. IntgerField()
            
            4. DateField()
            5. DateTimeField()
                1. auto_now_add    --> 建立的時候自動填充當前時間
                2. auto_now        --> 每次修改的時候自動把當前時間更新
                
        2. 關係字段
            1. ForeignKey(to="類名"，related_name=「xx」)   --> 1對多  ，外鍵一般設置在多的那一邊、
            2. ManyToMany(to="類名",related_name="xx")    --> 多對多，一般設置在正向查詢多的那一邊
            

        3. ORM通常操做
            1. 必知必會13條
                1. 返回QuerySet對象的
                    1. all()
                    2. filter()
                    3. values()
                    4. values_list()
                    5. exclude()
                    6. order_by()
                    7. reverse()
                    8. distinct()
                2. 返回具體對象的
                    1. get()
                    2. first()
                    3. last()
                3. 返回布爾值的
                    1. exists()
                4. 返回具體數值的
                    1. count()
            2. 單表查詢的雙下劃線
                1. models.Book.objects.filter(id__gt=1)
                2. models.Book.objects.filter(id__in=[1,2,3])
                3. models.Book.objects.filter(id__range=[1,5])
                4. models.Book.objects.filter(title__contains="沙河")
                5. models.Book.objects.filter(title__icontains="沙河")
                6. models.Book.objects.filter(title__startswith="沙河")
                7. models.Book.objects.filter(title__endswith="沙河")
                8. models.Book.objects.filter(publish_date__year=2017)
                9. models.Book.objects.filter(publish_date__month=2)
            3. 外鍵的跨表查詢
                1. 正向查找
                    1. 基於對象
                        book_obj = models.Book.object.get(id=1)
                        book_obj.publisher.name
                    
                    2. 基於雙下劃線的
                        models.Book.object.filter(id=1).values("publisher__name")
                    
                2. 反向查找（由出版社查書）
                    1. 基於對象
                        publisher_obj = models.Publisher.objects.get(id=1)
                        默認反向查找的時候是表名加_set
                            publisher_obj.book_set.all()
                        若是在外鍵中設置了related_name="books"
                            publisher_obj.books.all()
                    
                    2. 基於雙下劃線
                        models.Publisher.objects.filter(id=1).values("book__title")
                        若是配置了related_query_name="books"
                        models.Publisher.objects.filter(id=1).values("books__title")
                    
            4. 分組和聚合
                1. 聚合
                    from django.db.models import Avg, Sum, Max, Min, Count
                    models.Book.objects.all().aggregate(Avg("price"))
                2. 分組
                    book_list = models.Book.objects.all().annotate(author_num=Count("author"))
            
            5. F和Q
                1. 當須要字段和字段做比較的時候用F查詢
                2. 當查詢條件是 或 的時候 用Q查詢，由於默認的filter參數都是且的關係
                
            6. 事務
                1. 保證數據的原子性操做！！！
            
            7. 執行原生的SQL語句（瞭解便可）

2. ORM 一對一
    1. 何時用一對一？
        當 一張表的某一些字段查詢的比較頻繁，另一些字段查詢的不是特別頻繁
        把不怎麼經常使用的字段 單獨拿出來作成一張表 而後用過一對一關聯起來
        
    2. 優點
            既保證數據都完整的保存下來，又能保證大部分的檢索更快
            
    3. ORM中的用法
        OneToOneField(to="")

3. ORM 多對多的三種方式
    多對多的方式：
        1. ORM自動幫我建立第三張表
        
        
        2. 本身建立第三張表， 利用外鍵分別關聯做者和書
            關聯查詢比較麻煩，由於沒辦法使用ORM提供的便利方法
            
        3. 本身建立第三張表，使用ORM 的ManyToManyFiled()
             使用此種方式建立多對多表的時候，沒有 add() remove() 等方法
             
        
        
    咱們應該用哪一種？
        看狀況：
            1. 若是你第三張表沒有額外的字段，就用第一種
            2. 若是你第三張表有額外的字段，就用第三種或第一種
        
        
        相親網站：
            Boy
                girls = ManyToManyField(to=「Girl")
            
            Girl
            
            約會記錄：多對多
                id  boy_id girl_id  date

4. ORM查詢的練習題
    1. 跨表查詢
    2. 跨多張表查詢
    
5. csrf簡單用法

    什麼是CSRF ?
        跨站請求僞造，
        
        
    問題：
        1. 釣魚網站的頁面和正經網站的頁面對瀏覽器來講有什麼區別？ （頁面是怎麼來的？）
            釣魚網站的頁面是由 釣魚網站的服務端給你返回的
            
            正經網站的網頁是由 正經網站的服務端給你返回的
            
            
        2. Django中內置了一個專門處理csrf問題的中間件
            django.middleware.csrf.CsrfViewMiddleware
            
            這個中間件作的事情：
                1. 在render返回頁面的時候，在頁面中塞了一個隱藏的input標籤
                
                用法：
                    咱們在頁面上 form表單 裏面 寫上 {% csrf_token %}
                    
                <input type="hidden" name="csrfmiddlewaretoken" value="8gthvLKulM7pqulNl2q3u46v1oEbKG7BSwg6qsHBv4zf0zj0UcbQmpbAdijqyhfE">
                
                2. 當你提交POST數據的時候，它幫你作校驗，若是校驗不經過就拒絕此次請求

                
做業：
    1. 多對多的三種狀況 本身整理下筆記
    2. ORM查詢練習 
        1. 正向查
        2. 反向查
        3. 跨表查
    3. 預習

預習：
http://www.cnblogs.com/liwenzhou/p/8343243.html

View Code

 

day71 

csrf：防止惡意提交，作檢驗，正確的說明是我這個服務器下提供的頁面

分頁，cookie（裝飾器版本登錄校驗） 和 session

 day71裏面的課堂項目，是關於session和cooki的案例

CBV模式中要用到方法裝飾器（VS以前都是函數裝飾器）

 

day72 

AJAX頁面局部刷新

day72 2018-05-16

1. 內容回顧
    1. Cookie是什麼
        保存在瀏覽器端的鍵值對
        
        爲何要有Cookie?
            由於HTTP請求是無狀態的
        
        Cookie的原理？
            服務端能夠在返回響應的時候 作手腳
            在瀏覽器上寫入鍵值對（Cookie）
            
            瀏覽器發送請求的時候會自動攜帶該網站保存在我瀏覽器的鍵值對（Cookie）
            
        Django 從請求攜帶的Cookie中取值：
            request.COOKIES.get("is_login")
            request.get_signed_cookie(key, default=None, salt="xxx")
        Django中設置Cookie:(針對的是響應對象)
            rep = HttpResponse()/render(request, "test.html)/redirect()
            rep.set_signed_cookie(key, value, salt="xxx", max_age=7)
        Django中刪除Cookie:(註銷)
            rep.delete_cookie(key)

    2. Session是什麼
        Session保存在服務端的鍵值對
        
        Session依賴於Cookie
        
        dsadasdsadsafsjkndf: {"is_login": 1, "name": "xiaohei", "age":18}
        dsaasdaknfgreryywdf: {"is_login": 1, "name": "xiaobai", "age":20}
        wqrqrteknfgzddasqfg: {"is_login": 0, "name": "xiaohui", "age":48}
        
        給瀏覽器寫入Cookie:
            sessionid:wqrqrteknfgzddasqfg
            
        1. 從用戶發來的請求的Cookie中 根據 sessionid 取值， 取到 wqrqrteknfgzddasqfg
        2. 根據特殊字符串找到對應的 Session 數據  --> {"is_login": 0, "name": "xiaohui", "age":48}
        3. request.session.get("is_login")    --> 從Session取值
        
        
        Django中設置Session:
            request.session["is_login"] = 1
            request.session.set_expiry(7)  # 設置超時時間 (Cookie和Session數據的)
            
            
            在settings.py中設置，每次請求都刷新Session超時時間
            SESSION_SAVE_EVERY_REQUEST = True 
        
        Django中刪除Session:
            request.session.flush()     清除Cookie和Session數據
            
            request.session.clear_expired()  將全部Session失效日期小於當前日期的數據刪除
            
2. 今日內容
    AJAX
    
    1. 預備知識 JSON
    
    
    2. 咱們以前已經學過的發請求的方式：
        1. 直接在地址欄輸入URL回車     GET請求
        2. a標籤                       GET請求
        3. form表單                    GET/POST請求
        4. AJAX                        GET/POST請求
        
    3. AJAX 特色：
        1. 異步
        2. 局部刷新瀏覽器（偷偷發請求）
        
    
        
3. 今日做業
絕知此事要躬行！！！

1. 檢測用戶名是否已經存在！
2. 把Sweetalet插件
3. 複習jQuery的內容

 
        
        
        
        
        
        
        

View Code

 

day73 Form組件

day73 2018-05-17

1. 內容回顧
    1. 回顧了一下json數據格式
        1. JS對象        和 json數據格式的互相轉換
        2. Python中數據  和 json數據格式的互相轉換
    2. AJAX
        1. 咱們前端日後端發請求的方式：
            1. 直接在地址欄輸入URL
            2. a標籤
            3. form表單
            4. AJAX
            
            HTTP請求的類型：
                GET
                POST
        2. AJAX特色：
            1. 異步
            2. 局部刷新（偷偷發請求）
            
        3. AJAX缺點：
            請求零碎，濫用對服務端壓力大
        
        4. jQuery封裝的AJAX方法：
            先導入 jquery.js 
            
            $.ajax({
                url: "/test/",
                type: "post",
                data: {"key": "value", "key2":[[1, 2, 3], [4, 5, 6]]},
                success: function(arg){
                    // 請求獲得響應的時候，自動執行這個回調函數
                    console.log(arg);
                }
            })
            
2. 今日內容
    1. form組件的介紹
        
    以前web開發的模式，以註冊爲例：
        1. 要有一個註冊的頁面，頁面裏面要有form表單        --> 生成HTML代碼
        2. form表單要能提交數據到後端，後端要作有效性校驗  --> 數據有效性校驗
        3. 要把校驗的提示信息展現在頁面上                  --> 校驗信息返回並展現，保存原來填寫的內容
        
        
        關於校驗：
            1. 前端經過JS代碼作校驗    --> 最好有
            2. 後端作校驗              --> 必需要有（由於前端的校驗能夠被跳過）
        
        
    2. form組件的用法
        1. from django import forms
        2， 定義一個form類
            class RegForm(forms.Form):
                user = forms.CharField()
                pwd = forms.CharField()
                email = forms.EmailField()
        
        生成HTML：
            3. 實例化一個form對象， 傳遞到模板語言中
            4. 在目標語言中調用form對象的響應方法和屬性
            
            三種方式：
                1. {{ form_obj.as_p }}
                2. 單獨寫
                    {{ form_obj.pwd.label }}
                    {{ form_obj.pwd }}
        
        
        作校驗：
            1. form_obj = RegForm(request.POST)
            2. form_obj.is_valid()
            
        內置的正則校驗器的使用
            mobile = forms.CharField(
                label="手機",
                # 本身定製校驗規則
                validators=[
                    RegexValidator(r'^[0-9]+$', '手機號必須是數字'),
                    RegexValidator(r'^1[3-9][0-9]{9}$', '手機格式有誤')
                ],
                widget=widgets.TextInput(attrs={"class": "form-control"}),
                error_messages={
                    "required": "該字段不能爲空",
                }
            )
    
    看源碼：
        
    
        form_obj.is_valid()都幹了什麼？
        
        
        self._errors = ErrorDict()  --> {}
        self.cleaned_data = {}     

        self.fields.items()
            字段名  字段對象
        
        
        若是有錯誤：
            self._errors["name"] = ""
        
        沒有報錯：
            self.cleaned_data["name"] = value（用戶填寫的值）
            
        注意：
        鉤子函數（hook）的使用
        
        def clean_xx():
            """具體字段的自定義校驗方法"""
            pass
        
        def clean():
            """全局的自定義校驗方法"""
            pass
        

errors:
        
<ul class="errorlist">
    <li>name
        <ul class="errorlist">
            <li>不符合社會主義核心價值觀！</li>
        </ul>
    </li>
    <li>__all__
        <ul class="errorlist nonfield">
            <li>兩次密碼不一致</li>
        </ul>
    </li>
</ul>

View Code

 form組件經常使用的字段和字段參數

form組件校驗功能

form組件內的正則校驗器

form源碼剖析以及自定義校驗

form組件動態從數據庫取choices數據

 

day74 2018-05-21

課程安排
週一：    
    中間件
    auth模塊+分析BBS項目需求（小組討論把表結構設計出來）
    

1. 今日內容
    中間件：http://www.cnblogs.com/liwenzhou/p/8761803.html
    
        1. URL的白名單 url = ["/xx/", "/oo/", "/haha/"]
        2. 登錄以後才能訪問某些URL    以前使用裝飾器

    
    中間件的定義：
        wsgi以後 urls.py以前 在全局 操做Django請求和響應的模塊！
        
    中間件的使用：
        5個固定的方法
            process_request(self, request)
                執行順序：
                    按照註冊的順序（在settings.py裏面設置中 從上到下的順序）
                什麼時候執行：
                    請求從wsgi拿到以後
                返回值：
                    返回None，繼續執行後續的中間件的process_request方法
                    返回response , 不執行後續的中間件的process_request方法
                    
            process_response
                執行順序：
                    按照註冊順序的倒序（在settings.py裏面設置中 從下到上的順序）
                什麼時候執行：
                    請求有響應的時候
                返回值：
                    必須返回一個response對象
                    
            process_view(self, request, view_func, view_args, view_kwargs):
                執行順序：
                    按照註冊的順序（在settings.py裏面設置中 從上到下的順序）
                什麼時候執行：
                    在urls.py中找到對應關係以後 在執行真正的視圖函數以前
                返回值：
                    返回None，繼續執行後續的中間件的process_view方法
                    返回response,
                    
                    
            process_exception(self, request, exception)
                執行順序：
                    按照註冊順序的倒序（在settings.py裏面設置中 從下到上的順序）
                什麼時候執行：
                    視圖函數中拋出異常的時候才執行
                返回值：
                    返回None,繼續執行後續中間件的process_exception
                    返回response，
                    
                    
                    
            process_template_response(self, request, response)
                執行順序：
                    按照註冊順序的倒序（在settings.py裏面設置中 從下到上的順序）
                什麼時候執行：
                    視圖函數執行完，在執行視圖函數返回的響應對象的render方法以前 
                返回值：
                    返回None,繼續執行後續中間件的process_exception
                    返回response，
    
    
        Django調用 註冊的中間件裏面五個方法的順序：
            1. process_request
                urls.py
            2. process_view
                view
            3. 有異常就執行 process_exception
            4. 若是視圖函數返回的響應對象有render方法,就執行process_template_response
            5. process_response
    

Django已經學過的知識點：
    1. Urls.py 路由系統：
    
        正則
            分組匹配     --> 位置參數
            分組命名匹配 --> 關鍵字參數
        
        分級路由
            include
        
        給路由起別名
            name="xx"
            
        反向解析url
            view
                from django.urls import reverse
                
                reverse("xx", args=[1, 2, 3])
                reverse("xx", kwargs={」k": "v"})
                
        自取其辱
        
    2. 視圖 views.py
        request
            request.method
            request.GET     --> URL裏面的參數
            request.POST    --> post請求的數據
            
            request.path_info        --> 路徑
            request.get_full_path()  --> 路徑加路徑的參數
        
        
        response
            新手必備3件套
            render(request, "xx.html"， {「k」: "v", ...})
            HttpResponse("響應")
            redirect("/index/")
            redirect("http://www.luffycity.com")
            
            from django.http import JsonResponse
            JsonResponse()
            
            FBV和CBV
            
            函數裝飾器和方法裝飾器的區別
            
    3. 模板
        
        filter
            內置的filter方法
            自定義的filter方法
            
        tag
            內置的tag
            自定義的simpleTag
            自定義的inclusionTag
            
        母版和繼承
        
        {% extends ‘base.html’ %}
        
        {% block page-main %}
            {% block small %}
            {% endblock small %}
        {% endblock page-main %}
        
        
        組件 {% include nav %}
        
        
        靜態文件相關的tag
        
        在模板語言裏面反向解析url
        
            {% url 'url的別名' xx %}
    
        
    4. ORM
        
        對應關係
            類   --> 數據表
            對象 --> 數據行
            屬性 --> 字段
            
        
        Django鏈接MySQL數據庫的步驟：
            1. 手動建立庫
            2. 配置settings.py中數據庫的鏈接信息
            3. 修改settings.py同目錄下的__init__.py文件，添加兩句
                import pymysql
                pymysql.install_as_MySQLdb()
            4. 在app下面的models.py中定義類，類必定要繼承mdoels.Model
            5. 執行兩句命令
                1. python manage.py makemigrations
                2. python manage.py migrate
    
        操做數據表
        
        操做數據行（增刪改查）
            單表
            外鍵
            多對多
            一對一
            
        
        ORM高級：
            經常使用字段和方法
            必知必會13條
            神奇的雙下劃線
            跨表的正向查詢反向查詢
            
            F和Q
            
            聚合和分組
            
            事務
            
            執行原生的SQL語句
    
    5. Cookie和Session,分頁
    
    
    6. AJAX
        
        $.ajax({
            url： 「」,
            type: "post",
            data: {"k1": JSON.stringify([1,2,3])},
            success:function(data){
                
            }
        })
    7. form表單
    
    8. 中間件
    
        
            
            
            
    

View Code