python終極篇 --- django 初識

時間  2020-04-21
標籤 python 終極 django 欄目 Python 简体版
原文   原文鏈接

 

1. 下載： 命令行： pip install django==1.11.15 pip install -i 源 django==1.11.15 pycharm settings 解釋器 點+號 輸入django 選擇版本 2. 建立django項目 1. 命令行 cd 保存項目的目錄 django-admin startproject 項目名 2. pycharm file ——》 new project ——> 選擇django  ——> 選擇解釋器 ——》 建立django項目 3. 啓動項目 1. 命令行： cd manage.py 的目錄下 python manage.py runserver # 127.0.0.1:8000
            python manage.py runserver 80 # 127.0.0.1:80
            python manage.py runserver 0.0.0.0:80 # 0.0.0.0:80
        2. pycharm 配置項 點綠色三角啓動 4. settings配置 1. 靜態文件 STATIC_URL = '/static/'   # 別名
            STATICFILES_DIRS = [ os.path.join(BASE_DIR,'static'), os.path.join(BASE_DIR,'static1'), ] 2. TEMPLATES 模板 HTML文件 DIRS [os.path.join(BASE_DIR, 'templates')] 3. 註釋csrf中間件 4. 數據庫的配置 5. URL和函數的對應關係 ——> urls.py urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^login/', views.login), url(r'^index/', views.index), url(r'^test/', views.test) ] 6. APP 1. 建立APP 1. 命令行 python manage.py startapp app01 2. pycharm tools ——> run manage.py task ——> startapp app01 2. 註冊APP 在settings.py中的INSTALLED_APPS寫： ‘app01’ 或者 'app01.apps.App01Config'
            
                
    7. 使用MySQL數據庫 1. 建立一個MySQL數據庫 2. settings的配置： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql',   # 引擎
                    'NAME': 'day66',                        # 數據庫名
                    'USER':'root',                          # 用戶名
                    'PASSWORD':'',                          # 密碼
                    'HOST':'127.0.0.1',                     # IP
                    'PORT': 3306,                           # 端口號
 } } 3. 告訴django使用pymysql模塊鏈接數據庫 在settings.py同級目錄下的__init__.py中寫： import pymysql pymysql.install_as_MySQLdb() 4. 建表 在app01/models.py中寫類（繼承models.Model） class Userinfo(models.Model): user = models.CharField(max_length=32)  # varchar(32)
                pwd = models.CharField(max_length=32) 5. 執行數據庫遷移命令 python manage.py makemigrations # 記錄models.py中類是否是有變化 將變化的內容記錄下來 
            python manage.py migrate         # 將model的變動同步到數據庫中 
            
    8. ORM 對象和關係型數據庫的映射 經過操做對象的方式來操做數據庫 映射關係; 類 —— 》 數據表 對象 —— 》 數據行 屬性 —— 》 字段 ORM能作的事： 操做數據表 操做數據行 ORM操做： from login import models # 獲取全部數據
 models.Userinfo.objects.all() ——》 Queryset # 獲取一條數據
            models.Userinfo.objects.get(user='alex',pwd='alexdsb') 取不到數據或者取到多條數據的時候報錯 # 建立一條數據
            models.Userinfo.objects.create(user='alex',pwd='alexdsb') 9. form表單 1. method='post' action='' 請求方式 提交數據的地址 2. 全部的input的標籤要有name屬性 3. 有一個input的type=‘submit’ 或者有一個button按鈕 10. GET 和 POST GET:獲取一個頁面 ?key1=v1&key2=v2 POST: 提交數據 11. views.py 寫函數 request 跟請求相關的全部內容 request.method 字符串 請示方式 GET/POST request.POST POST請求提交的數據 字典 request.GET GET請求提交的數據 返回值 from django.shortcuts import HttpResponse,render,redirect HttpResponse('字符串')            ——》 頁面顯示的就是'字符串' render(request,'模板文件名') ——》 渲染你的HTML文件返回給瀏覽器 redirect('要跳轉的URL')         ——》 重定向  告訴瀏覽器再向URL再發一次GET請求
主要內容歸納

 

 

 

服務端與瀏覽器收發信息:html

socket 套接字 是應用層和傳輸層之間一個虛擬層,是一個接口.python

import socket sk = socket.socket() sk.bind(("127.0.0.1", 80)) sk.listen() while True: conn, addr = sk.accept() data = conn.recv(8096) conn.send(b"OK") conn.close()

 

打印一下收到的消息是什麼>???mysql

將\r\n替換成換行看得更清晰點： GET / HTTP/1.1 Host: 127.0.0.1:8080 Connection: keep-alive Cache-Control: max-age=0 Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3355.4 Safari/537.36 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8 Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9 Cookie: csrftoken=CtHePYARJOKNx5oNVwxIteOJXpNyJ29L4bW4506YoVqFaIFFaHm0EWDZqKmw6Jm8

那瀏覽器收到的消息是什麼?web

 

經過以上對比,發現收發消息的格式都是同樣的---即爲 HTTP協議格式sql

每一個HTTP請求和響應都遵循相同的格式，一個HTTP包含Header和Body兩部分，其中Body是可選的。數據庫

HTTP響應的Header中有一個 Content-Type代表響應的內容格式。它的值如text/html; charset=utf-8。django

text/html則表示是網頁，charset=utf-8則表示編碼爲utf-8。flask

 

 

　　

mport socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('127.0.0.1', 8000)) sock.listen() while True: conn, addr = sock.accept() data = conn.recv(8096) # 給回覆的消息加上響應狀態行 
    conn.send(b"HTTP/1.1 200 OK\r\n\r\n") 不加這行代碼返回不了數據 conn.send(b"OK") conn.close()
自定義web框架 
""" 根據URL中不一樣的路徑返回不一樣的內容 """  
  
import socket sk = socket.socket() sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口 
sk.listen()  # 監聽 
  
while True: # 等待鏈接 
    conn, add = sk.accept() data = conn.recv(8096)  # 接收客戶端發來的消息 
    # 從data中取到路徑 
    data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串 
    # 按\r\n分割 
    data1 = data.split("\r\n")[0] url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑 
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行 
    # 根據不一樣的路徑返回不一樣內容 
    if url == "/index/": response = b"index"  
    elif url == "/home/": response = b"home"  
    else: response = b"404 not found!" conn.send(response) conn.close()
根據不一樣的路徑返回不一樣的內容 
""" 根據URL中不一樣的路徑返回不一樣的內容--函數版 """  
  
import socket sk = socket.socket() sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口 
sk.listen()  # 監聽 
  
  
# 將返回不一樣的內容部分封裝成函數 
def func(url): s = "這是{}頁面！".format(url) return bytes(s, encoding="utf8") while True: # 等待鏈接 
    conn, add = sk.accept() data = conn.recv(8096)  # 接收客戶端發來的消息 
    # 從data中取到路徑 
    data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串 
    # 按\r\n分割 
    data1 = data.split("\r\n")[0] url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑 
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行 
    # 根據不一樣的路徑返回不一樣內容，response是具體的響應體 
    if url == "/index/": response = func(url) elif url == "/home/": response = func(url) else: response = b"404 not found!" conn.send(response) conn.close()
根據不一樣的路徑返回不一樣的內容--函數版 
""" 根據URL中不一樣的路徑返回不一樣的內容--函數進階版 """  
  
import socket sk = socket.socket() sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口 
sk.listen()  # 監聽 
  
  
# 將返回不一樣的內容部分封裝成不一樣的函數 
def index(url): s = "這是{}頁面XX！".format(url) return bytes(s, encoding="utf8") def home(url): s = "這是{}頁面。。！".format(url) return bytes(s, encoding="utf8") # 定義一個url和實際要執行的函數的對應關係 
list1 = [ ("/index/", index), ("/home/", home), ] while True: # 等待鏈接 
    conn, add = sk.accept() data = conn.recv(8096)  # 接收客戶端發來的消息 
    # 從data中取到路徑 
    data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串 
    # 按\r\n分割 
    data1 = data.split("\r\n")[0] url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑 
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行 
    # 根據不一樣的路徑返回不一樣內容 
    func = None  # 定義一個保存將要執行的函數名的變量 
    for item in list1: if item[0] == url: func = item[1] break  
    if func: response = func(url) else: response = b"404 not found!"  
  
    # 返回具體的響應消息 
 conn.send(response) conn.close()
根據不一樣的路徑返回不一樣的內容--函數進階版

 

""" 根據URL中不一樣的路徑返回不一樣的內容--函數進階版 返回獨立的HTML頁面 """  
  
import socket sk = socket.socket() sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口 
sk.listen()  # 監聽 
  
  
# 將返回不一樣的內容部分封裝成不一樣的函數 
def index(url): # 讀取index.html頁面的內容 
    with open("index.html", "r", encoding="utf8") as f: s = f.read() # 返回字節數據 
    return bytes(s, encoding="utf8") def home(url): with open("home.html", "r", encoding="utf8") as f: s = f.read() return bytes(s, encoding="utf8") # 定義一個url和實際要執行的函數的對應關係 
list1 = [ ("/index/", index), ("/home/", home), ] while True: # 等待鏈接 
    conn, add = sk.accept() data = conn.recv(8096)  # 接收客戶端發來的消息 
    # 從data中取到路徑 
    data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串 
    # 按\r\n分割 
    data1 = data.split("\r\n")[0] url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑 
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行 
    # 根據不一樣的路徑返回不一樣內容 
    func = None  # 定義一個保存將要執行的函數名的變量 
    for item in list1: if item[0] == url: func = item[1] break  
    if func: response = func(url) else: response = b"404 not found!"  
  
    # 返回具體的響應消息 
 conn.send(response) conn.close()
返回具體的HTML文件 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>index</title>
</head>
<body>
<div>這是index頁面</div>
</body>
</html>
index.html 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>index</title>
</head>
<body>
<div>這是home頁面</div>
</body>
</html>
home.html

 

""" 根據URL中不一樣的路徑返回不一樣的內容--函數進階版 返回獨立的HTML頁面 """  
  
import socket sk = socket.socket() sk.bind(("127.0.0.1", 8080))  # 綁定IP和端口 
sk.listen()  # 監聽 
  
  
# 將返回不一樣的內容部分封裝成不一樣的函數 
def index(url): # 讀取index.html頁面的內容 
    with open("index.html", "r", encoding="utf8") as f: s = f.read() # 返回字節數據 
    return bytes(s, encoding="utf8") def home(url): with open("home.html", "r", encoding="utf8") as f: s = f.read() return bytes(s, encoding="utf8") def timer(url): import time with open("time.html", "r", encoding="utf8") as f: s = f.read() s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S")) return bytes(s, encoding="utf8") # 定義一個url和實際要執行的函數的對應關係 
list1 = [ ("/index/", index), ("/home/", home), ("/time/", timer), ] while True: # 等待鏈接 
    conn, add = sk.accept() data = conn.recv(8096)  # 接收客戶端發來的消息 
    # 從data中取到路徑 
    data = str(data, encoding="utf8")  # 把收到的字節類型的數據轉換成字符串 
    # 按\r\n分割 
    data1 = data.split("\r\n")[0] url = data1.split()[1]  # url是咱們從瀏覽器發過來的消息中分離出的訪問路徑 
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 由於要遵循HTTP協議，因此回覆的消息也要加狀態行 
    # 根據不一樣的路徑返回不一樣內容 
    func = None  # 定義一個保存將要執行的函數名的變量 
    for item in list1: if item[0] == url: func = item[1] break  
    if func: response = func(url) else: response = b"404 not found!"  
  
    # 返回具體的響應消息 
 conn.send(response) conn.close()
讓網頁動態起來

 

如下內容目前隨便看看就好了,反正我沒看懂瀏覽器

 ============>>>>>>...服務器程序和應用程序<<<<<<<<<=================

對於真實開發中的python web程序來講，通常會分爲兩部分：服務器程序和應用程序。服務器

服務器程序負責對socket服務端進行封裝，並在請求到來時，對請求的各類數據進行整理。

應用程序則負責具體的邏輯處理。爲了方便應用程序的開發，就出現了衆多的Web框架，例如：Django、Flask、web.py 等。不一樣的框架有不一樣的開發方式，可是不管如何，開發出的應用程序都要和服務器程序配合，才能爲用戶提供服務。

 

這樣，服務器程序就須要爲不一樣的框架提供不一樣的支持。這樣混亂的局面不管對於服務器仍是框架，都是很差的。對服務器來講，須要支持各類不一樣框架，對框架來講，只有支持它的服務器才能被開發出的應用使用。

這時候，標準化就變得尤其重要。咱們能夠設立一個標準，只要服務器程序支持這個標準，框架也支持這個標準，那麼他們就能夠配合使用。一旦標準肯定，雙方各自實現。這樣，服務器能夠支持更多支持標準的框架，框架也可使用更多支持標準的服務器。

WSGI（Web Server Gateway Interface）就是一種規範，它定義了使用Python編寫的web應用程序與web服務器程序之間的接口格式，實現web應用程序與web服務器程序間的解耦。

經常使用的WSGI服務器有uwsgi、Gunicorn。而Python標準庫提供的獨立WSGI服務器叫wsgiref，Django開發環境用的就是這個模塊來作服務器。

 

wsgiref

咱們利用wsgiref模塊來替換咱們本身寫的web框架的socket server部分：

  1. """  
  2. 根據URL中不一樣的路徑返回不一樣的內容--函數進階版  
  3. 返回HTML頁面  
  4. 讓網頁動態起來  
  5. wsgiref模塊版  
  6. """   
  7.      
  8. from wsgiref.simple_server import make_server   
  9.      
  10.      
  11. # 將返回不一樣的內容部分封裝成函數   
  12. def index(url):   
  13.     # 讀取index.html頁面的內容   
  14.     with open("index.html", "r", encoding="utf8") as f:   
  15.         s = f.read()   
  16.     # 返回字節數據   
  17.     return bytes(s, encoding="utf8")   
  18.      
  19.      
  20. def home(url):   
  21.     with open("home.html", "r", encoding="utf8") as f:   
  22.         s = f.read()   
  23.     return bytes(s, encoding="utf8")   
  24.      
  25.      
  26. def timer(url):   
  27.     import time   
  28.     with open("time.html", "r", encoding="utf8") as f:   
  29.         s = f.read()   
  30.         s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))   
  31.     return bytes(s, encoding="utf8")   
  32.      
  33.      
  34. # 定義一個url和實際要執行的函數的對應關係   
  35. list1 = [   
  36.     ("/index/", index),   
  37.     ("/home/", home),   
  38.     ("/time/", timer),   
  39. ]   
  40.      
  41.      
  42. def run_server(environ, start_response):   
  43.     start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 設置HTTP響應的狀態碼和頭信息   
  44.     url = environ['PATH_INFO']  # 取到用戶輸入的url   
  45.     func = None   
  46.     for i in list1:   
  47.         if i[0] == url:   
  48.             func = i[1]   
  49.             break   
  50.     if func:   
  51.         response = func(url)   
  52.     else:   
  53.         response = b"404 not found!"   
  54.     return [response, ]   
  55.      
  56.      
  57. if __name__ == '__main__':   
  58.     httpd = make_server('127.0.0.1', 8090, run_server)   
  59.     print("我在8090等你哦...")   
  60.     httpd.serve_forever()  

jinja2

上面的代碼實現了一個簡單的動態，我徹底能夠從數據庫中查詢數據，而後去替換我html中的對應內容，而後再發送給瀏覽器完成渲染。 這個過程就至關於HTML模板渲染數據。 本質上就是HTML內容中利用一些特殊的符號來替換要展現的數據。 我這裏用的特殊符號是我定義的，其實模板渲染有個現成的工具： jinja2

下載jinja2:

pip install jinja2
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
</head>
<body>
    <h1>姓名：{{name}}</h1>
    <h1>愛好：</h1>
    <ul>
        {% for hobby in hobby_list %}
        <li>{{hobby}}</li>
        {% endfor %}
    </ul>
</body>
</html>
index2.html文件

使用jinja2渲染index2.html文件：

  1. from wsgiref.simple_server import make_server  
  2. from jinja2 import Template  
  3.   
  4.   
  5. def index(url):  
  6.     # 讀取HTML文件內容  
  7.     with open("index2.html", "r", encoding="utf8") as f:  
  8.         data = f.read()  
  9.         template = Template(data)   # 生成模板文件  
  10.         ret = template.render({'name': 'alex', 'hobby_list': ['抽菸', '喝酒', '燙頭']})   # 把數據填充到模板中  
  11.     return bytes(ret, encoding="utf8")  
  12.   
  13.   
  14. def home(url):  
  15.     with open("home.html", "r", encoding="utf8") as f:  
  16.         s = f.read()  
  17.     return bytes(s, encoding="utf8")  
  18.   
  19.   
  20. # 定義一個url和實際要執行的函數的對應關係  
  21. list1 = [  
  22.     ("/index/", index),  
  23.     ("/home/", home),  
  24. ]  
  25.   
  26.   
  27. def run_server(environ, start_response):  
  28.     start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 設置HTTP響應的狀態碼和頭信息  
  29.     url = environ['PATH_INFO']  # 取到用戶輸入的url  
  30.     func = None  
  31.     for i in list1:  
  32.         if i[0] == url:  
  33.             func = i[1]  
  34.             break  
  35.     if func:  
  36.         response = func(url)  
  37.     else:  
  38.         response = b"404 not found!"  
  39.     return [response, ]  
  40.   
  41.   
  42. if __name__ == '__main__':  
  43.     httpd = make_server('127.0.0.1', 8090, run_server)  
  44.     print("我在8090等你哦...")  
  45.     httpd.serve_forever()  

如今的數據是咱們本身手寫的，那可不能夠從數據庫中查詢數據，來填充頁面呢？

使用pymysql鏈接數據庫：

複製代碼 
conn = pymysql.connect(host="127.0.0.1", port=3306, user="root", passwd="xxx", db="xxx", charset="utf8")
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select name, age, department_id from userinfo")
user_list = cursor.fetchall()
cursor.close()
conn.close()
複製代碼

建立一個測試的user表：

CREATE TABLE user(
  id int auto_increment PRIMARY KEY,
  name CHAR(10) NOT NULL,
  hobby CHAR(20) NOT NULL
)engine=innodb DEFAULT charset=UTF8;

模板的原理就是字符串替換，咱們只要在HTML頁面中遵循jinja2的語法規則寫上，其內部就會按照指定的語法進行相應的替換，從而達到動態的返回內容。

 如下內容留存,一些配置信息修改: 重要

 

模板文件配置：

複製代碼 
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, "template")],  # template文件夾位置
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

 

靜態文件配置：

STATIC_URL = '/static/'  # HTML中使用的靜態文件夾前綴
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "static"),  # 靜態文件存放位置
]

 

剛開始學習時可在配置文件中暫時禁用csrf中間件，方便表單提交測試。

複製代碼 
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

1. HTTP協議
 
  1. 請求(瀏覽器發送給服務器的消息-request)
   格式:
    請求方式 URL 協議版本
    k1: v1
    k2: v2
    
    請求數據(請求體)
  
  2. 響應(服務器返回給瀏覽器的消息-response)
   格式:
    協議版本 狀態碼 狀態描述符
    k1: v1
    k2: v2
    
    響應體(HTML)


 2. web框架
  本質: socket服務端
  
  功能:
   a. socket收發消息
   b. URL和函數的對應關係,根據不一樣的URL執行不一樣的函數,返回函數的結果
   c. 讀取HTML文件,進行了一個字符替換(模板渲染)
  
  分類:
   Django flask tornado
   完成了a,b,c三個功能的  ——》 tornado
   完成了b,c 兩個功能     ——》 Django
   完成了b 一個功能       ——》 flask
   
  另外一種分類：
   1. Django  大而全
   2. 其餘   短小精悍
 3. 安裝Django
  1. pycharm
   file settings project 點加號 輸入django 選擇版本 下載
   
  2. 命令行
   pip install django==1.11.15
   
 4. 建立Django項目
  1. 命令行
   django-admin startproject 項目名
  
  2. pycharm
   file ——》 new project ——》 django ——》 項目名 ——》選擇解釋器 ——》create
   
   
 5. 啓動Django項目
  1. 命令行
   切換到有manage.py的目錄下
   python manage.py runserver     # 127.0.0.1:8000
   python manage.py runserver 80  # 127.0.0.1:80
   python manage.py runserver 0.0.0.0:80  # 0.0.0.0:80
  2. pycharm
   配置好 點綠色三角
   
 6. 配置
  靜態文件
   STATIC_URL = '/static/'   # 別名
   STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static')
   ]

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

1,form表單提交數據注意事項：
   1. input 標籤有name屬性
   2. action="" method="post"   提交的地方  提交的方式
   3. 有一個input的type="submit"  或者有一個button按鈕

  4.注意form標籤的位置,提交按鈕和輸入框必定要在同一個form表單下

2. GET 和 POST 的區別
  1. GET
   1. 獲取一個頁面
   2. 提交數據    數據顯示在URL  ?user=alex&pwd=alexdsb
   
  2. POST
   form表單提交數據   數據不顯示

3. 使用MySQL數據庫的配置
  1. DATABASES = {
   'default': {
    'ENGINE': 'django.db.backends.mysql', # 引擎
    'NAME': 'day66',                        # 數據庫名
    'USER':'root',                          # 用戶名
    'PASSWORD':'',                          # 密碼
    'HOST':'127.0.0.1',                     # IP
    'PORT': 3306,                            # 端口號
   }
  }
  2. 在與settings.py同級目錄下的__init__.py文件中寫：
   import pymysql
   pymysql.install_as_MySQLdb()
  
  
  3. 建立表：
   在models.py中寫類
   class Userinfo(models.Model):
    user = models.CharField(max_length=32)  # varchar(32)
    pwd = models.CharField(max_length=32)
  
  4. 執行兩條命令：
   python manage.py makemigrations    # 把models.py的變化記錄下來
   python manage.py migrate           # 去修改你的數據庫

 

4. ORM操做：
  from login import models
  1.  獲取數據表全部內容
   all = models.Userinfo.objects.all()
  2. 獲取一條數據
   models.Userinfo.objects.get(user='alex')
   # 沒有數據或者多條數據就報錯
   
  3. 向數據庫插入一條數據
   models.Userinfo.objects.create(user='alex',pwd='alexdsb')
   

補充:  redirect(地址)  跳轉到某地址, 若地址是文件,前邊不用加 /,如果函數,必須加 /

          建立app,必須在配置文件settings中的  INSTALLED_APPS  中加入app名稱

　　    from django.shortcuts import HttpResponse,render,redirect

          

 

def login(request): if request.method == "POST": age = request.POST.get("age") user = request.POST.get("Userame") pwd = request.POST.get("Password") if age == None: all = models.Userinfo2.objects.all() for i in all: if i.user == user and i.pwd == pwd: print("nihao a ") return redirect("/weixin/") return render(request, "login.html") else: models.Userinfo2.objects.create(user=user, pwd=pwd, age=age) return render(request, "login.html")
登陸註冊邏輯代碼
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程