剛開始學習時可在配置文件中暫時禁用csrf中間件，方便表單提交測試。
day 61 Django part-1 django的安裝,以及初學者三件套(以及settings中的mysql配置)
咱們的django究竟是什麼東西呢?css
咱們的代碼都是在後臺寫的,包括咱們的pycharm都是屬於後臺的工具,可是咱們的後端開發說究竟是須要開發完了以後拿到用戶面前的,讓咱們的用戶看到咱們的東西,首先要讓他們看到,而後纔可以在看到的基礎上來進行一些交互,而後大致的框架就算是搭建成功了,再接下來就是細節的填充,以及功能的擴展,根據業務的發展以及用戶的需求去知足,一一實現需求.html
上面說了一通的廢話,咱們的django到底跟這一切又有什麼關係呢?前端
咱們的代碼是後端的東西,它若是放到用戶的眼前是須要一些過程的,咱們的前端是可讓咱們的用戶直觀的看到效果,咱們的前端改動一些標籤就可讓用戶明顯感覺到差別,因此咱們的前端是跟用戶交互更加直接的,可是前端的功能都是一些浮於表面的東西,它是做爲裝飾的,不少的功能僅僅靠前端是沒法實現的,須要後端來進行功能的主要開發,而後前端再在後端的基礎上進行頁面的渲染,實現用戶的交互,那麼咱們的前端就須要跟後端關聯上,要怎麼實現關聯上的同時還能不出錯的無縫銜接上穩定地投入使用呢?,這個時候就須要咱們的django了,它就是讓咱們的前端和後端無縫銜接上的同時,穩定地投入使用,咱們的web框架就是幹這個事情的,下面咱們會提到web框架的本質,它最根本的就是socket套接字通訊,咱們開啓一個服務端而後它就可以永遠穩定地運行下去,接下來咱們的客戶端配好了端口和ip地址的時候就可以鏈接上它,咱們的django就封裝的有這個socket套接字功能,它自己就自帶套接字通訊功能,因此,你看咱們須要用到的東西在這個django裏面通通都會實現,它很牛逼吧,什麼都是自帶的,然而它還不只僅是這樣,它的功能遠遠比咱們想象得的要強大得多,暫且就理解它爲一個封裝了超多功能的異常龐大的模塊吧,咱們要實現先後端的交互它是少不了的.html5
它裏面有超多的封裝好的模塊.咱們只須要在使用的時候把它想起來而後就跟咱們引入模塊或者引入文件的時候同樣使用import 就能夠引入到你的代碼塊裏面進行使用了java
它核心的三件套是必需要掌握的,一切的功能都是基於這三者來實現的,python
Httpresponse,--負責來響應瀏覽器的,須要瀏覽器返回什麼就在它裏面定義什麼便可,瀏覽器的根本就是返回字符串,因此Httpresponse("str(ok)")這樣寫就能夠mysql
render, --負責接收request參數,而後還有一個渲染的頁面(也就是一個HTML標籤),以及保存數據用的一個字典數據類型的參數.這個render主要的功能就是渲染頁面,在渲染的同時咱們須要把一些參數填充到所渲染的頁面裏面去,就須要用到這個render功能,[那咱們何時須要使用到參數去填充頁面的狀況呢,咱們的頁面是提早寫好的,那是前端的時候,如今咱們須要跟後端進行一些交互,這個時候前端顯示的數據就會有所調整,根據特殊的要求來進行調整,這個時候咱們的代碼就須要後端來實現了,把後端改好的代碼填充到前端去,就須要把前端的頁面設置一塊地方用來預存參數,當個人後端須要改變功能的時候能夠啓動到前端預存的那些參數而後進行修改,這個時候就須要使用到填充參數到所渲染的頁面中去]jquery
redirect,--負責跳轉頁面,後端的代碼塊碼完以後咱們想讓頁面往何處跳轉就使用它去跳轉,return redirect("/sogo/") 這裏就是跳轉的頁面,之因此這樣寫,是由於咱們的url域名裏面都是這樣的格式,https://i.cnblogs.com/EditPosts.aspx?postid=8269914,例如這裏的http後面的域名就是這樣的格式,web
這裏還有一個很重要的點就是request,它是一個參數,是咱們在django裏面寫函數的時候須要傳入的參數,這個參數是幹什麼用的呢,它裏面包裹了大量的信息,都是關於請求的數據信息,sql
全部跟請求相關的數據都是由它來進行接收,咱們的形參就是用來接收各類的參數的,它就是那樣的一個形參,它只是接收跟請求相關的參數,咱們之後會學到它的大量的用法,包括都有哪些是跟請求相關的,請求都是有哪些,等等.
老師的筆記:
day61 1.前情回顧 1. pymysql 使用： 安裝 pip install pymysql 導入 import pymysql 具體使用： 1. 建立鏈接 conn = pymysql.connect(host="lcoalhost", port=3306, user="", password="", database="", charset="utf8") 2. cursor = conn.cursor() 3. cursor.execute(sql, (arg1, arg2 ...)) --> SQL注入問題 4. 增刪改查 增： cursor.execute("insert into ...", (arg1, arg2...)) conn.commit() --> 向數據庫提交 cursor.lastrowid --> 獲取剛插入的那條數據的ID 刪： cursor.execute(「delete ...」, (arg1, arg2...)) conn.commit() --> 向數據庫提交 改： cursor.execute("update ...」, (arg1, arg2...)) conn.commit() --> 向數據庫提交 查： cursor.execute(「select ...」, (arg1, arg2...)) cursor.fetchone() --> 查單條數據，元組類型 cursor.fetchmany(n) --> 查多條數據 cursor.fetchall() --> 查全部數據 cursor.scroll(n, mode="relative") --> 相對移動 cursor.scroll(n, mode="absolute") --> 絕對移動 批量執行： cursor.executemany("update ...」, ((arg1, arg2),(arg1, arg2),(arg1, arg2))) conn.commit() 回滾： try: cursor.execute("update ...」, (arg1, arg2...)) conn.commit() --> 向數據庫提交 except Exception as e: logging.error(str(e)) conn.rollback() cursor.close() conn.close() 2. 今日內容 Web框架（絕大部份內容） 瀏覽器 socket客戶端 4. 客戶端鏈接服務端 5. send() 客戶端發數據 8. recv() 接收服務端回覆的數據 9. close() 關閉連接 博客園服務器 socket服務端 1. bind IP和端口 2. listen() 監聽 3. accept() 等待鏈接 6. recv() 接收數據 7. send() 回覆數據 FTP上傳文件的： msg = "upload|filename|1024" 服務端解析： msg.split() -> 瀏覽器和你的web服務端通訊須要遵循一個規則，這個規則就是HTTP協議。 HTTP協議： 簡單的理解成 規定了消息的格式 瀏覽器發送 ---> 請求 （request） 服務端回覆 ---> 響應 （response） 請求和響應的格式： Header （頭）\r\n\r\n Body (體) 請求： GET請求的格式： 只有請求頭沒有請求體 "GET / HTTP/1.1\r\n k1:v1\r\n k2:v2\r\n .... " POST請求的格式： "POST / HTTP/1.1\r\n k1:v1\r\n k2:v2\r\n .... " Body 響應： Header Body 渲染 （render） 本質上： 用數據去替換HTML頁面中的特殊字符 jinja2 Flask 總結： 本身定義的web框架 a. 本身寫socket處理請求相關的數據（web服務端） wsgiref uWSGI gunicorn WSGI協議： Python Web服務端和Python 應用程序之間通信的一個標準 b. URL -> 函數 --> 函數裏面寫業務邏輯(取到數據) c. 把數據填充到HTML頁面（字符串替換） 分類： 1. a、b、c都是用本身的 --> Tornado 2. a用別人的，b和c用本身的 --> Django 3. a和c都用別人的，b用本身的 --> Flask 另一個維度的分類： 1. Django （大而全） 2. 其餘 （小而精） Django: 安裝： pip install django==1.11.9 新建Django項目： 命令行方式： > 先進入到你新建的項目要存放的目錄 > django-admin startproject s8 > cd s8 > python manage.py runserver PyCharm方式： File -> new project -> 選Django -> 起名字 -> 點右下角create 啓動Django項目： 命令行方式： python manage.py runserver 127.0.0.1:8888 python manage.py runserver 8888 PyCharm方式啓動：（PyCharm單獨打開你的Django項目） 1. 點頁面上方中部位置的綠色小三角 直接運行 Ctrl + C 中止 Django項目目錄結構： s8 -s8 -settings.py -urls.py URL --> 函數的對應關係 -wsgi.py -manage.py 新手必備三件套： from django.shortcuts import HttpResponse, render, redirect 跟request相關的方法： request.method request.POST request.POST.get("key") --> 獲取對應的值 新建Django項目三件事： 1.註釋csrf那一行 2. 配置靜態文件 3. 檢查templates配置項 3. 今日做業 把你以前用Bootstrap寫的那個登陸頁面，用Django跑起來 1. 靜態文件的擺放位置 ****** 2. 登錄用POST提交數據，使用pymysql去數據庫裏取用戶數據校驗 3. 登錄成功跳轉到 http://www.luffycity.com 4. 登陸失敗就返回當前頁面
day62 1. 前情回顧 1. Django配置相關 1. Templates文件夾配置 --> 存放全部的HTML文件 # HTML頁面存放位置 TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')] # 你的HTML文件的目錄 , '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', ], }, }, ] 2. 靜態文件 # 在HTML頁面上引用靜態文件時寫的名字 STATIC_URL = '/static/' # 靜態文件（CSS文件和JS文件）存放的實際位置 STATICFILES_DIRS = [ os.path.join(BASE_DIR, "xxx"), # F:\PythonS8\day61\mysite\xxx ] 3. 註釋掉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', ] 2. 新手必備三件套 from django.shortcuts import HttpResponse, render, redirect 1. HttpResponse("字符串") 2. render 1. render(request, "html文件") --> 至關於打開HTML文件，讀取文件內容，回覆給瀏覽器 2. render(request, "html文件", {"k1": "v1", "k2": "v2"}) --> 至關於打開HTML文件，讀取文件內容，使用字符串替換，替換完的內容回覆給瀏覽器 3. redirect("具體要跳轉的URL") 3. request這個參數 1. 封裝了全部跟請求相關的數據，是一個對象 2. 目前咱們學過 1. request.method GET,POST ... 2. request.POST.get("input name的值") 2. 今日內容 學員管理系統 學生 老師 班級 班級和老師關係表 id 姓名 cid id 姓名 id 名稱 id tid cid 1 李巖 1 1 Egon 1 1 1 2 建超 2 2 Eva_J 1 全棧8期 2 1 2 3 曉梅 3 3 WuSir 2 全棧9期 3 2 1 4 Yuan 3 全棧10期 4 4 2 5 4 3 1. 建立班級表 -- 建立班級表 CREATE TABLE class( id INT AUTO_INCREMENT PRIMARY KEY , cname CHAR(20) NOT NULL UNIQUE )ENGINE =innodb DEFAULT CHARSET="utf8"; 2. 建立老師表 -- 建立老師表 CREATE TABLE teacher( id INT AUTO_INCREMENT PRIMARY KEY , tname CHAR(20) NOT NULL UNIQUE )ENGINE=innodb DEFAULT CHARSET="utf8"; 3. 學生表 -- 建立學生表 CREATE TABLE student( id INT AUTO_INCREMENT PRIMARY KEY, sname CHAR(20) NOT NULL UNIQUE , cid INT,FOREIGN KEY (cid) REFERENCES class(id) ON DELETE CASCADE ON UPDATE CASCADE )ENGINE=innodb DEFAULT CHARSET="utf8"; 4. 班級和老師關係表 -- 建立班級和老師關係表 CREATE TABLE class_2_teacher( id INT AUTO_INCREMENT PRIMARY KEY , tid INT, FOREIGN KEY (tid) REFERENCES teacher(id) ON DELETE CASCADE ON UPDATE CASCADE, cid INT, FOREIGN KEY (cid) REFERENCES class(id) ON DELETE CASCADE ON UPDATE CASCADE )engine=innodb DEFAULT CHARSET="utf8"; 模板語言：（jinja2） 如今學到的： 1. {{ 變量名 }} # 咱們的HTML標籤裏面能夠找一個代碼邏輯合適的地方就直接寫上兩個重疊的大括號---{{}},而後在裏面寫上變量名[即函數裏面會用到的參數],若是咱們的變量名是一個字典的話,那麼咱們的這個大括號的語法是支持存入這樣的自己是一個字典的變量名的,並且支持咱們在取值的時候使用到以下的例子 若是傳過來的變量是字典--> p = {"name": "alex", "age": 18} 支持：p.name 和 p.age 取值,通常取值的話都是經過循環來取值的,這裏就引出了咱們的下面的循環用法 2. for循環 {% for i in 變量名 %} # 若是咱們的變量名是一個字典的話,咱們是能夠經過使用到i.key去取值的,就拿上面的例子來講,咱們的變量名是p,那麼就是{% for i in p %}, {{i.name}}, {{i.age}} {{% endfor %}} {{forloop.counter}} # 這裏是從0開始若是這樣寫就是 # {{forloop.counter1}}從1開始 {{ i }} {% endfor %} {{forloop.counter}} {{forloop.counter0}} GET請求傳參數的方式： /xxx/?k1=v1&k2=v2 ? 前面的是URL ？後面的是請求的參數 多個參數之間用&分隔 以下示例: https://i.cnblogs.com/EditPosts.aspx?postid=8269914 EditPosts.aspx?它後面就是key-value的格式,key是postid,value是8269914, 再以下示例:https://mbd.baidu.com/newspage/data/landingsuper?context=%7B%22nid%22%3A%22news_15802839984148081810%22%7D&n_type=0&p_from=4 這裏面的key-value對應的有: context = %7B%22nid%22%3A%22news_15802839984148081810%22%7D & # 這裏就是分割符, n_type = 0 & p_from = 4 POST請求傳數據： 是放在請求體裏面的
建立django項目使用cmd命令行執行:
django-admin startproject (項目名,自定義)
建立以後須要執行,也使用cmd命令行實現:
咱們須要把當前目錄切換到所建立的項目目錄裏面去,而後再執行下面的命令行語句,不然會報錯:no such file or directory .
切換目錄使用cd /d 所建立的項目目錄,通常咱們剛剛建立的項目就直接使用cd 項目名稱便可直接切換到所建立的項目目錄裏面去,
python manage.py runserver ip和端口:以下舉例:
python manage.py runserver 127.0.0.1:8000
若是你想查看你的django安裝的版本或者檢查你是否已經安裝了django,那麼咱們在cmd命令行裏面輸入如下信息就能夠得出結果:
python -m django --version
若是你已經安裝了,那麼它會有提示你安裝的版本,若是沒有安裝的話它會有錯誤提示信息:「No module named django」。
咱們在建立django項目的時候在cmd裏面,能夠先使用cd /d 指定的文件路徑,例如: cd /d D:\file 這樣就是改變了當前的文件路徑,而後咱們再執行建立django項目操做
咱們的django項目建立到執行的簡單步驟:
首先咱們的項目建立完以後須要在單獨的窗口打開,不能更它的項目一塊兒打開
如圖所示咱們的項目是單獨在一個窗口打開的,
咱們的static是靜態文件存放夾,全部的靜態文件都是放在這裏,咱們能夠在static裏面創建css文檔,js文檔,img文檔,專門用於存放專門的文件,還有其餘的一些存放於plugins中,其餘的好比咱們以前寫bootstrap用到的相關文檔都存放於plugins裏面
咱們本身創建的這個文件夾,這個是一開始建立以後就須要創建好的,能夠是任何其餘的名字,只不過咱們使用這個名字,你們都是約定俗成的,寫成這樣以後你們都知道它是幹什麼的,若是寫做其餘的就只有你本身知道它是幹什麼的,別人都不知道,這樣溝通的成本就會增長,
還有就是在nun_one(這自己就是我給我本身新建的django項目起的名字)裏面的py文件裏有一個views.py它是咱們本身手動添加上去的,它不是你創建項目的時候就自帶的,這裏是咱們存放咱們寫的後臺代碼塊的地方,全部的後臺的代碼都是存放於這裏的,
還有一個templates它裏面存放的都是html文件,全部的html文件都須要存放於這裏,這些都是規矩,咱們要想使用django就須要遵照它的規範,而後才能順利運行它.
setting文件的設置以下:
""" Django settings for nun_one project. Generated by 'django-admin startproject' using Django 1.11.9. For more information on this file, see https://docs.djangoproject.com/en/1.11/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/1.11/ref/settings/ """ import os # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'go7=2^)p%q!g-dviz#9i7djz6)xf-m#0a7m2)an2)vmty-_o8(' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] 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', ] ROOT_URLCONF = 'nun_one.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')] , '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', ], }, }, ] WSGI_APPLICATION = 'nun_one.wsgi.application' # Database # https://docs.djangoproject.com/en/1.11/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } } # Password validation # https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', }, { 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', }, { 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', }, { 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', }, ] # Internationalization # https://docs.djangoproject.com/en/1.11/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.11/howto/static-files/ STATIC_URL = '/static/' STATICFILES_DIRS = [ os.path.join(BASE_DIR, "static"), # 咱們須要在設置裏面查看咱們的拼接路徑, # 這個拼接路徑是須要本身手動寫的,有問題的話先來看這裏的設置路徑,先查看咱們的setting # os.path.join(BASE_DIR, "sta") ]
url文件的設置以下:
"""nun_one URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.11/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.conf.urls import url, include 2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls')) """ from django.conf.urls import url from django.contrib import admin from django.shortcuts import HttpResponse, render, redirect # 這裏是django的三件套,它的主要核心模塊內容,shortcuts是關鍵字 from .views import index, hm_btst, class_list, \ class_form, add_class, delete_class, edit_class, \ teacher_form, add_teacher, edit_teacher, delete_teacher # 這裏咱們須要使用加上. 而後就不會報錯,這裏是對當前目錄作一個限定,咱們須要引用咱們本身寫入的模塊那麼就須要另外起一行去寫 urlpatterns = [ url(r'index/', index), # 這裏r後面的引號裏面不用加上前/,只須要把後/加上便可 url(r'hm_bootstrap/', hm_btst), # 這裏的括號裏須要寫入兩個參數,一個是域名, # 放到r後面,而後還有函數名,須要放到域名後面,函數名須要在上面引入才能夠,不然這裏會報錯,不會生效的 url(r'class_list/', class_list), url(r'class_form/', class_form), url(r'add_class/', add_class), url(r'delete_class', delete_class), url(r'edit_class/', edit_class), url(r'teacher_form/', teacher_form), url(r'add_teacher/', add_teacher), url(r'edit_teacher/', edit_teacher), url(r'delete_teacher', delete_teacher), # url(r'^admin/', admin.site.urls), ]
views文件裏面是咱們寫好的後端代碼塊:
import pymysql from django.shortcuts import HttpResponse, render, redirect def index(request): # return HttpResponse("ok") error_msg = "" # 咱們以前就是把這裏的變量放到了下面的if判斷裏面了, # 然而咱們的method多是post也多是get,因此須要把這裏的變量放到if判斷外面, # 這樣就是全局的變量了,這樣咱們的get和post均可以使用到它, # 而咱們以前就是把它定義到了if判斷下面了,不只僅是放到了if post下面並且還放到了 # if post下面的else裏面,就至關於它的做用域就更加狹窄了,因此咱們報錯就會顯示咱們的這個變量沒有被定義就直接調用了, # 這樣固然不符合語法,必定會報錯的 print("--->:", request.method) if request.method == "POST": name = request.POST.get("username") pwd = request.POST.get("password") # pwd = request.POST["password"] print(request.POST) print(name, pwd) # 這裏的數據判斷應該是從數據庫裏面取出數據來進行對比的,設計到mysql的操做 conn = pymysql.connect( host="localhost", user="root", database="book_list", password="123", ) cur = conn.cursor() sql = "select name, pwd from userinfo ;" cur.execute(sql) ret = cur.fetchall() print(ret) for i in ret: if i[0] == name and i[1] == pwd: return redirect("http://www.luffycity.com") else: error_msg = "you've gotten wrong msg" return render(request, "index.html", {"error": error_msg}) def class_list(request): # conn = pymysql.connect( # host="localhost", # user="root", # password="123", # database="book_list", # charset="utf8") # cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) # sql="select id,name from class order by id;" # cursor.execute(sql) # ret = cursor.fetchall() # cursor.close() # conn.close() # print(ret) # return render(request, "class_list.html",{"class_list":ret}) return render(request, "class_list.html") def hm_btst(request): print(request.method) error_msg = "" if request.method == "POST": print(request.POST) name = request.POST.get("name") pwd = request.POST.get("pwd") print(request.POST) print(name, pwd) # 去到數據庫裏面作校驗 conn = pymysql.connect( host="localhost", user="root", database="book_list", password="123", ) cur = conn.cursor() sql = "select name,pwd from userinfo;" cur.execute(sql) ret = cur.fetchmany(4) for i in ret: if i[0] == name and i[1] == pwd: return redirect("https://www.sogo.com") else: error_msg = "you've gotten wrong msg" return render(request, "hm-bootstrap.html", {"error": error_msg}) # 這裏的參數是一個包裹着大量的請求相關的參數,全部跟請求相關的數據都會包裹在這裏, # 而error是咱們寫在頁面上的那個硬塞入的p標籤包裹着的數據,它做爲一個key存入字典, # 它對應的value就是這裏咱們在函數裏面定義的error_msg這個變量 return render(request, "hm-bootstrap.html") # 展現全部的班級列表 def class_form(request): # 這個函數是展現全部的班級列表 # 1.去數據庫裏面取出數據 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") # 指定輸出的結果類型是字典這裏的DictCursor是django裏面自帶的封裝好的功能, # 咱們把它記下來而後用的時候想到它就能夠完成咱們須要的工做 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) # cursor=conn.cursor() # 這樣寫就是獲得元祖的結果, # 咱們須要把它轉換成字典,而後咱們才能經過字典的特性鍵對值的方式去取值 sql = "select id,cname from class order by id;" cursor.execute(sql) ret = cursor.fetchall() cursor.close() conn.close() print(ret) # 2 用數據去填充HTML頁面 這裏須要去看視頻理解一下---->已經理解過了 # 這裏是key和value的方式,{key:value},class_form是變量名, # 咱們這裏寫的變量名class_form須要和HTML裏面的for i in class_form對應上, # 這兩個是必需要保持一致的,後面的ret是咱們上面mysql語句運行以後的獲得的結果賦值給這個變量了 return render(request, 'class-form.html', {"class_form": ret}) # , {"class-form": ret}這裏的變量命名不夠規範因此會報錯 # 添加班級 def add_class(request): if request.method == "POST": class_name = request.POST.get("cname") # 由於咱們的id是自增的因此咱們在這裏只須要增長cname就行了,只須要定義這一個變量就夠了 # 1.去數據庫裏面取出數據 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") # 指定輸出的結果類型是字典這裏的DictCursor是django裏面自帶的封裝好的功能, # 咱們把它記下來而後用的時候想到它就能夠完成咱們須要的工做 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "insert into class (cname) VALUES (%s);" cursor.execute(sql, class_name) conn.commit() # 增長操做,咱們須要有提交動做,由於對數據庫進行了修改 cursor.close() conn.close() return redirect("/class_form/") return render(request, 'add-class.html') # 刪除課程 def delete_class(request): # 根據班級id刪除 # 班級id從數據庫裏面取出來 print(request.GET) class_id = request.GET.get("class_id") print(class_id) # 去到數據庫裏面刪除 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "delete from class where id=%s;" cursor.execute(sql, class_id) conn.commit() # 對數據庫進行改變須要提交操做 cursor.close() conn.close() # return HttpResponse(class_id) return redirect('/class_form/') # 修改課程 def edit_class(request): if request.method == "POST": class_id = request.POST.get("id") class_name = request.POST.get("cname") # 去數據庫裏面更新 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "update class set cname=%s where id=%s;" cursor.execute(sql, (class_name, class_id)) conn.commit() cursor.close() conn.close() return redirect('/class_form/') # 取到被編輯的班級id class_id = request.GET.get("class_id") # 去數據庫裏面查詢當前班級的信息 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "select id,cname from class where id=%s;" cursor.execute(sql, class_id) ret = cursor.fetchone() cursor.close() conn.close() print(ret) return render(request, "edit-class.html", {"class_info": ret}) # 做業開始寫, # 展現全部的講師列表 def teacher_form(request): # 去到數據庫裏面取出數據 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") # 把獲得是數據以字典的形式展現出來 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) # 寫sql語句 sql = "select id, tname from teacher order by id;" cursor.execute(sql) ret = cursor.fetchall() cursor.close() conn.close() print(ret) return render(request, "teacher-form.html", {"teacher_form": ret}) def add_teacher(request): if request.method == "POST": teacher_name = request.POST.get("tname") conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") # 把獲得是數據以字典的形式展現出來這裏的DictCursor是django裏面包裹的封裝好的語法,直接用便可 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "insert into teacher (tname) VALUES (%s);" cursor.execute(sql, teacher_name) conn.commit() cursor.close() conn.close() return redirect("/teacher_form/") return render(request, "add-teacher.html") def edit_teacher(request): if request.method == "POST": teacher_id = request.POST.get("id") teacher_name = request.POST.get("tname") conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "update teacher set tname=%s where id=%s;" cursor.execute(sql, (teacher_name, teacher_id)) res = cursor.fetchone() conn.commit() cursor.close() conn.close() return redirect("/teacher_form/") # 這裏咱們把數據更新以後就回到了咱們的展現表格的頁面,可是返回以後須要獲得把數據替換掉以後的結果,這裏的代碼是沒有辦法去是現這一步的 # 因此咱們須要接着去寫代碼實現接下來的功能, # 去拿到被編輯的teacher的id teacher_id = request.GET.get("teacher_id") # 去數據庫裏面查詢當前講師的信息 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "select id, tname from teacher where id=%s;" cursor.execute(sql, teacher_id) res = cursor.fetchone() # 這裏咱們雖然是把fetchone改爲了fetchall,看起來反正個人sql語句是獲得一個結果根據個人語法是這樣的,若是是在sql裏面的話結果是同樣的 # 可是咱們的程序是沒法識別的,它只能知道你的fetchall就是獲得多個結果,它只能看到你的fetchall,並不能根據fetchall倒推出你的sql語句是獲得的一個結果而不是多個,因此咱們不可以改爲fetchall去寫 # 咱們的fetchall系統識別到它是獲得多個結果的,因此它沒法肯定把哪一個結果給你放到輸入框裏面顯示出來,因此就直接選擇的簡單粗暴的方式不去顯示了,這就是它的解決方案,因此你看,咱們的計算機甚至都不會拐彎,它一點都不夠智能, # 因此咱們必需要了解每個環節是什麼意思,甚至咱們的每個變量都須要咱們去理解爲何這裏須要使用它而不是它,否則本身隨便亂改就不會獲得預期的效果,這是無可厚非的, # 若是執意要改的話,咱們只可以花掉更多的時間去一點點找到錯處而後去調試,直至你完全理解了那些細節, cursor.close() conn.close() print(res) return render(request, "edit-teacher.html", {"teacher_info": res}) def delete_teacher(request): # 根據老師id刪除 # 講師id從數據庫裏面取出來 print(request.GET) teacher_id = request.GET.get("teacher_id") print(teacher_id) # 去到數據庫裏面刪除 conn = pymysql.connect( host="localhost", user="root", password="123", database="book_list", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) sql = "delete from teacher where id=%s;" # 咱們這裏的%s是佔位符,這裏的佔位符是爲了動態傳參, # 咱們的程序不可以寫死了,須要靈活,須要足夠的包容性,因此須要在這裏寫上一個佔位符,可是咱們的sql語句這樣一來就不夠完整了, # 因此在執行的時候須要把佔位符裏面的缺失的那一塊補齊,這樣纔可以拼湊出完整的sql語句, # 然而咱們補齊的那部分就是咱們上面定義的變量,那個變量的做用是存放咱們取出想要的數據用的, cursor.execute(sql, teacher_id) conn.commit() # 對數據庫進行改變須要提交操做 cursor.close() conn.close() # return HttpResponse(class_id) return redirect("/teacher_form/")
咱們的django項目剛剛建立的時候須要創建幾個文件件,
templates------>用於咱們存放全部的HTML頁面,它自己就是一個文件夾,在pycharm裏面咱們的文件夾是directory,
static-------->用於存放咱們全部的靜態文件,它本省也是一個文件夾,也是directory的格式
tool----------->用於存放咱們本身寫好的一些模塊,也就是一些py文件,咱們的不少複用性高的功能代碼都是須要封裝到一個函數裏面而後存放於一個單獨的文件中,實現功能解耦,因此它必須是一個包,咱們的包和文件的區別就是一個有init文件一個沒有,所謂的init就是__init__.py 它就是用於區分包和文件的關鍵點,咱們的包建立之初的時候就會有這個文件,它的存在就是讓咱們的pycharm識別出來他是一個包而不是一個文件夾,那麼咱們的包就是python Package,咱們想要包的時候就使用這個格式去創建
要想讓他跑起來須要配合相應的html文件:
相應的html文檔:
展現class_form列表:
<!DOCTYPE html> <!-- saved from url=(0042)https://v3.bootcss.com/examples/dashboard/ --> <html lang="zh-CN"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1"> <!-- 上述3個meta標籤*必須*放在最前面，任何其餘內容都*必須*跟隨其後！ --> <meta name="description" content=""> <meta name="author" content=""> <link rel="icon" href="/static/plugins/bootstrap-3.3.7/css/bootstrap.min.css"> <title>表格面板</title> <!-- Bootstrap core CSS --> {# <link href="./Dashboard_files/bootstrap-3.3.7/css/bootstrap.min.css" rel="stylesheet">#} <link rel="stylesheet" href="/static/plugins/bootstrap-3.3.7/css/bootstrap.min.css"> <!-- Custom styles for this template --> {# <link href="./Dashboard_files/dashboard.css" rel="stylesheet">#} <link rel="stylesheet" href="/static/css/dashboard.css"> <!-- Just for debugging purposes. Don't actually copy these 2 lines! --> <script src="static/ie-emulation-modes-warning.js"></script> <style> td > button { align-content: center; } </style> <script src="https://cdn.bootcss.com/html5shiv/3.7.3/html5shiv.min.js"></script> <script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script> </head> <body> <!--模態框開始--> <div class="modal fade" tabindex="-1" role="dialog" id="myModal"> <!--模態框必需要是body的直系子標籤才生效不然會報錯--> <div class="modal-dialog" role="document"> <div class="modal-content"> <div class="modal-header"> <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">×</span></button> <h4 class="modal-title">曉風乾,淚痕殘</h4> </div> <!--模態框的主體開始--> <div class="modal-body"> <form class="form-horizontal"> <div class="form-group"> <label for="inputName" class="col-sm-2 control-label">姓名</label> <div class="col-sm-10"> <input type="text" class="form-control" id="inputName" placeholder="Name"> </div> </div> <div class="form-group"> <label for="inputEmail" class="col-sm-2 control-label">郵箱</label> <div class="col-sm-10"> <input type="email" class="form-control" id="inputEmail" placeholder="Email"> </div> </div> <div class="form-group"> <label for="inputHabit" class="col-sm-2 control-label">愛好</label> <div class="col-sm-10"> <input type="text" class="form-control" id="inputHabit" placeholder="Habit"> </div> </div> </form> <div class="modal-footer"> <button type="button" class="btn btn-default" data-dismiss="modal">Close</button> <button type="button" class="btn btn-primary">Save changes</button> </div> </div> <!-- 模態框主體結束 --> </div><!-- /.modal-dialog --> </div> </div> <!--模態框結束--> <!--頁面的頭部--> <nav class="navbar navbar-inverse navbar-fixed-top"> <div class="container-fluid"> <div class="navbar-header"> <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar"> <span class="sr-only">Toggle navigation</span> <span class="icon-bar"></span> <span class="icon-bar"></span> <span class="icon-bar"></span> </button> <a class="navbar-brand" href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Project name</a> </div> <div id="navbar" class="navbar-collapse collapse"> <ul class="nav navbar-nav navbar-right"> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Dashboard</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Settings</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Profile</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Help</a></li> </ul> <form class="navbar-form navbar-right"> <input type="text" class="form-control" placeholder="Search..."> </form> </div> </div> </nav> <!--頁面的頭部--> <div class="container-fluid"> <div class="row"> <!--頁面的左邊開始--> <div class="col-sm-3 col-md-2 sidebar"> <div> <ul class="nav nav-sidebar"> <li class="active"><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Overview <span class="sr-only">(current)</span></a> </li> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Reports</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Analytics</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/#hm-2表格面板.html">Export</a></li> </ul> </div> <ul class="nav nav-sidebar"> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">Nav item</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">Nav item again</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">One more nav</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">Another nav item</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">More navigation</a></li> </ul> <ul class="nav nav-sidebar"> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">Nav item again</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">One more nav</a></li> <li><a href="https://v3.bootcss.com/examples/dashboard/hm-2表格面板.html">Another nav item</a></li> </ul> </div> <!--頁面的左邊結束--> <!--這裏開始是咱們須要作的事,表格的右邊--> <div class="col-sm-9 col-sm-offset-3 col-md-10 col-md-offset-2 main"> <div class="panel panel-default"> <!--default panel contents--> <div class="my-panel-head"> <div class="my-title">Panel heading</div> </div> <!--搜索框和添加框開始--> <div class="row"> <!--咱們要在這個搜索框裏面加上form表單而後class要設定爲form-inline--> <form class="form-inline"> <div class="form-group" style="padding-left: 16px;"> <label class="sr-only" for="table-search">table search</label> <input type="text" class="form-control" id="table-search" placeholder="search"> </div> <button type="submit" class="btn btn-primary">搜索</button> <button type="button" class="btn btn-success" data-toggle="modal" style="margin-left:640px;" data-target="#myModal">添加 </button> <a href="/add_class/" style="margin-right: 20px;" type="button" class="btn btn-info pull-right">新頁面添加</a> </form> </div> <!--搜索框和添加框結束--> <!--主體表格開始--> <div class="my-table-wrapper"> <table style="margin-bottom: 0" class="table table-striped table-bordered"> <thead> <tr> <th>#</th> <th>課程id</th> <th>課程名</th> <th>操做</th> </tr> </thead> <tbody> {% for class in class_form %} {# 這裏是for i in 變量名,咱們的class_form是變量名因此須要符合變量命名的規範,數字字母下劃線,不能以數字開頭,#} {# 咱們在views裏面寫的函數裏須要有返回值咱們返回值裏面是本身定義的一個字典,#} {# key就是咱們在這個for循環裏面定義的這個變量,這個class_form就是咱們的views裏面的函數的返回值裏面的鍵對值裏面的key,#} {# 而key對應的value則是本身定義mysql語句執行以後獲得的結果賦值給到的那個變量,#} <tr> <td>{{ forloop.counter }}</td> <td scope="row">{{ class.id }}</td> <td>{{ class.cname }}</td> <td class="text-center"> <a href="/edit_class/?class_id={{ class.id }}" type="button" class="btn btn-sm btn-info" aria-label="Left Align"> <span class="glyphicon glyphicon-pencil" aria-hidden="true"></span>新頁面編輯 </a> <a type="button" class="btn btn-sm btn-success" aria-label="Left Align"> <span class="glyphicon glyphicon-pencil" aria-hidden="true"></span>編輯 </a> <a href="/delete_class/?class_id={{ class.id }}" type="button" class="btn btn-sm btn-danger" aria-label="Left Align"> <span class="glyphicon glyphicon-remove" aria-hidden="true"></span>刪除 </a> </td> </tr> {% endfor %} </tbody> </table> <!--分頁開始--> <div class="row" style="margin-right: -25px;margin-left: -35px;"> <div class="col-md-7 col-xs-12 pull-right"> <nav aria-label="Page navigation" style="padding-top:2px; padding-right:10px;float:right;"> <ul class="pagination"> <li> <a href="#" aria-label="Previous"> <span aria-hidden="true">«</span> </a> </li> <li><a href="#">1</a></li> <li><a href="#">2</a></li> <li><a href="#">3</a></li> <li><a href="#">4</a></li> <li><a href="#">5</a></li> <li> <a href="#" aria-label="Next"> <span aria-hidden="true">»</span> </a> </li> </ul> </nav> </div> </div> <!--分頁結束--> </div> <!--主體表格結束--> </div> </div> </div> </div> <!-- Bootstrap core JavaScript ================================================== --> <!-- Placed at the end of the document so the pages load faster --> <script src="static/js/jquery-3.2.1.min.js"></script> <script src="static/plugins/bootstrap-3.3.7/js/bootstrap.min.js"></script> <script> {# $(document).ready(function(){#} {# $(".my-menu-item").on("click", "a",function () {#} {# #} {# })#} {# })#} </script> </body> </html>
展現列表需用使用到的css文件以及bootstrap文件（在網上能夠搜索cdn，在標籤中引入連接便可，這樣比較方便，節省硬盤空間）
編輯列表:
<!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>change-class</title> </head> <body> <form action="/edit_class/" method="post"> <input type="text" name="id" value="{{ class_info.id }}"> <input type="text" name="cname" value="{{ class_info.cname }}"> <input type="submit" value="put in"> </form> </body> </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>add-class</title> </head> <body> <form action="/add_class/" method="post"> <input type="text" name="cname" placeholder="課程名字"> {# <input type="text" name="id" placeholder="課程id">#} {# 咱們表格設計的時候id設置成爲了自增,#} {#因此咱們不須要本身增長它,若遇到其餘的字段值,咱們是能夠繼續在這裏接着寫input框的#} <input type="submit" value="put in"> </form> </body> </html>
不行,咱們把django搭建起來以後還用到了pymysql的內容,咱們的數據庫須要搭建好才能夠,不然是沒法使用的,
簡單寫幾句吧,關於咱們建庫建表的命令行,
mysql,(我是把個人mysql文件都配置好了,因此直接在cmd裏面就可以直接輸入這一行進入數據庫裏面進行操做)
show databases;
create database book_list;(這裏咱們把這個庫創建好,由於咱們用到的pymysq須要使用這個庫,
use book_list;查看庫
show tables;查看庫裏的表格
CREATE TABLE class(
id INT AUTO_INCREMENT PRIMARY KEY ,
cname CHAR(20) NOT NULL UNIQUE
)ENGINE =innodb DEFAULT CHARSET="utf8"; 庫已經創建好了,而後在裏面插入一些表格,
INSERT INTO class (cname) VALUES ("jumping"),
("java"),("web"),("biology"),("math"),
("python"),("linnux"); # 這裏是在表格中插入一些數據
先讓django項目起來,點擊綠色的那個三角按鈕便可,這樣咱們就能在項目起來以後的那個網頁裏輸入咱們定義好的那些函數的名字所對應的url域名網址,在url裏面咱們有設置網址的輸入內容.
全部的文件咱們都配置好了,按照使用規則去運行他們便可了,
http://www.cnblogs.com/liwenzhou/p/8258992.html
咱們能夠這樣理解：全部的Web應用本質上就是一個socket服務端，而用戶的瀏覽器就是一個socket客戶端。
這樣咱們就能夠本身實現Web框架了。
import socket sk = socket.socket() sk.bind(("127.0.0.1", 80)) sk.listen(5) while True: conn, addr = sk.accept() data = conn.recv(8096) conn.send(b"OK") conn.close()
web的框架是上面的客戶端和服務端,這就是本質的東西
因此，必須有一個統一的規則，讓你們發送消息、接收消息的時候有個格式依據，不能隨便寫。
這個規則就是HTTP協議，之後瀏覽器發送請求信息也好，服務器回覆響應信息也罷，都要按照這個規則來。
HTTP協議主要規定了客戶端和服務器之間的通訊格式，那HTTP協議是怎麼規定消息格式的呢？
讓咱們首先看下咱們在服務端接收到的消息是什麼。
而後再看下咱們瀏覽器收到的響應信息是什麼。
響應頭在瀏覽器的network窗口能夠看到，咱們看到的HTML頁面內容就是響應體。本質上仍是字符串，由於瀏覽器認識HTML，因此纔會渲染出頁面。
每一個HTTP請求和響應都遵循相同的格式，一個HTTP包含Header和Body兩部分，其中Body是可選的。 HTTP響應的Header中有一個 Content-Type代表響應的內容格式。如 text/html表示HTML網頁。
HTTP GET請求的格式：
GET /path HTTP/1.1 header1:v1\r\n header2:v2\r\n
使用 \r\n分隔多個header
HTTP POST請求格式：
POST /path HTTP/1.1 header1:v1\r\n header2:v2\r\n \r\n\r\n 請求體...
當遇到連續兩個 \r\n\r\n時，表示Header部分結束了，後面的數據是Body。
HTTP響應的格式：
200 OK Header1:v1\r\n Header2:v2\r\n \r\n\r\n 響應體...
讓咱們的Web框架在給客戶端回覆響應的時候按照HTTP協議的規則加上響應頭，這樣咱們就實現了一個正經的Web框架了。
這樣，服務器程序就須要爲不一樣的框架提供不一樣的支持。這樣混亂的局面不管對於服務器仍是框架，都是很差的。對服務器來講，須要支持各類不一樣框架，對框架來講，只有支持它的服務器才能被開發出的應用使用。
這時候，標準化就變得尤其重要。咱們能夠設立一個標準，只要服務器程序支持這個標準，框架也支持這個標準，那麼他們就能夠配合使用。一旦標準肯定，雙方各自實現。這樣，服務器能夠支持更多支持標準的框架，框架也可使用更多支持標準的服務器。
WSGI（Web Server Gateway Interface）就是一種規範，它定義了使用Python編寫的web應用程序與web服務器程序之間的接口格式，實現web應用程序與web服務器程序間的解耦。
經常使用的WSGI服務器有uwsgi、Gunicorn。而Python標準庫提供的獨立WSGI服務器叫wsgiref，Django開發環境用的就是這個模塊來作服務器。
無論是什麼內容，最後都是轉換成字節數據發送出去的。 我能夠打開HTML文件，讀取出它內部的二進制數據，而後發送給瀏覽器。
咱們經過了socket鏈接就打開了一個HTML文件,
from wsgiref.simple_server import make_server def index(): with open("index.html", "rb") as f: data = f.read() return [data, ] def home(): with open("home.html", "rb") as f: data = f.read() return [data, ] # 定義一個url和函數的對應關係 URL_LIST = [ ("/index/", index), ("/home/", home), ] def run_server(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ]) # 設置HTTP響應的狀態碼和頭信息 url = environ['PATH_INFO'] # 取到用戶輸入的url func = None # 將要執行的函數 for i in URL_LIST: if i[0] == url: func = i[1] # 去以前定義好的url列表裏找url應該執行的函數 break if func: # 若是能找到要執行的函數 return func() # 返回函數的執行結果 else: return [bytes("404沒有該頁面", encoding="utf8"), ] if __name__ == '__main__': httpd = make_server('', 8000, run_server) print("Serving HTTP on port 8000...") httpd.serve_forever()
這是一個簡單的動態，我徹底能夠從數據庫中查詢數據，而後去替換我html中的對應內容，而後再發送給瀏覽器完成渲染。 這個過程就至關於HTML模板渲染數據。 本質上就是HTML內容中利用一些特殊的符號來替換要展現的數據。 我這裏用的特殊符號是我定義的，其實模板渲染有個現成的工具： jinja2
from wsgiref.simple_server import make_server from jinja2 import Template def index(): with open("index2.html", "r") as f: data = f.read() template = Template(data) # 生成模板文件 ret = template.render({"name": "Alex", "hobby_list": ["燙頭", "泡吧"]}) # 把數據填充到模板裏面 return [bytes(ret, encoding="utf8"), ] def home(): with open("home.html", "rb") as f: data = f.read() return [data, ] # 定義一個url和函數的對應關係 URL_LIST = [ ("/index/", index), ("/home/", home), ] def run_server(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ]) # 設置HTTP響應的狀態碼和頭信息 url = environ['PATH_INFO'] # 取到用戶輸入的url func = None # 將要執行的函數 for i in URL_LIST: if i[0] == url: func = i[1] # 去以前定義好的url列表裏找url應該執行的函數 break if func: # 若是能找到要執行的函數 return func() # 返回函數的執行結果 else: return [bytes("404沒有該頁面", encoding="utf8"), ] if __name__ == '__main__': httpd = make_server('', 8000, run_server) print("Serving HTTP on port 8000...") httpd.serve_forever()
咱們先安裝上django
而後瞭解它的工做原理,
而後掌握它的一些用法,
最後使用它實現一些簡單的小功能
安裝（安裝最新LTS版）：
pip3 install django==1.11.9
咱們安裝的時候能夠就在pycharm裏面進行就能夠,
建立一個django項目：
下面的命令建立了一個名爲"mysite"的Django 項目：
django-admin startproject mysite
或者使用pycharm直接就能夠建立,反而更加簡單:
找到pycharm裏面左上角的file--->new project--->django--->create 就能夠獲得一個django項目了,注意,咱們在點擊create的時候須要選擇open in new window,這樣就是給新建立的django項目開啓新的窗口,django項目必需要開新的窗口而後才能夠運行,不然是執行不成功的,
from django.shortcuts import HttpResponse, render, redirect
這三個,是核心內容django裏面的核心
HttpResponse
內部傳入一個字符串參數，返回給瀏覽器。它是負責響應瀏覽器的數據
例如：
def index(request):
# 業務邏輯代碼
return HttpResponse("OK") # 這的括號裏面的內容就是咱們須要返回給瀏覽器的東西,能夠隨意設置的,只要是字符串就行
render(渲染)
除request參數外還接受一個待渲染的模板文件和一個保存具體數據的字典參數。
將數據填充進模板文件，最後把結果返回給瀏覽器。（相似於咱們上面用到的jinja2）
它至關於咱們把一個文件裏面的數據讀取出來而後返回給一個函數的這樣的操做
相似於
def login():
with open("login.html", encoding="utf8") as fh:
dat = fh.read()
time_str = str(time.time())
print(time_str)
new_dat = dat.replace("#$101$#", time_str)
return new_dat
這裏的操做就是render的用法,若是咱們不適用render的話,咱們須要使用一個函數去
打開一個文件,而後把文件讀出來,使用其餘的字符串去替換它,而後把替換的結果返回給函數,
這裏的打開文件-讀取文件-替換文件-返回給函數這一系列的過程都是render它內部的封裝的功能,只要引用它,咱們均可以實現這些功能,
節省代碼.
例如：
def index(request):
# 業務邏輯代碼
return render(request, "index.html", {"name": "alex", "hobby": ["燙頭", "泡吧"]})
redirect
接受一個URL參數，表示跳轉到指定的URL。(就是超連接咱們從一個鏈接按鈕跳轉到另外一個鏈接地址) # 這裏就相似於咱們的HTML標籤裏面的一個a標籤,它裏面就有一個href這個屬性,這個屬性就是負責承接跳轉的功能,咱們的redirect就是跟他同樣的,他後面的參數寫什麼,就往那個地址去跳轉
例如：
def index(request):
# 業務邏輯代碼
return redirect("/home/")
request:(參數)
全部跟請求相關的操做都是封裝到這個參數裏面的
目錄介紹：
mysite/
manage.py # 管理文件
mysite # 項目目錄
__init__.py
setting.py # 配置
urls.py # 路由--> url和函數的對應關係
wsgi.py # runserver命令就使用wsgiref模塊作簡單的web server
配置文件:
咱們的django建立以後須要把一些內部的文件進行設置,設置好了以後才能夠投入使用,須要設置的地方有:
TEMPLATES = [ # 這裏咱們是存放html文件的,全部項目裏須要用到的HTML文件都放到這裏來
{
'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',
],
},
},
]
還有須要設置的地方:
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',
]
靜態文件配置:(所謂的靜態文件就是咱們的css文件和js文件,以及bootstrap文檔裏面的都是靜態文件)
STATIC_URL = '/static/' # HTML中使用的靜態文件夾前綴 [咱們的靜態文件在django中使用的時候,在引用的時候好比link標籤裏面的href咱們會先寫上這裏的靜態文件夾前綴,而後從這個靜態文件夾前綴裏去找其餘的文件] STATICFILES_DIRS = [ #這裏的位置是咱們本身加上去的,從這裏開始都是咱們本身寫的,咱們的靜態文件都是須要在這裏指定位置,而後用的時候好方便從這開始朝起
os.path.join(BASE_DIR, "static"), # 靜態文件存放位置 ]
數據庫配置:
咱們把參數設置好了以後還須要在咱們的項目裏面的init文件裏面把咱們的配置給改一下
import pymysql pymysql.install_as_MySQLdb()
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'book_list', 數據庫名 'USER': 'root', 'PASSWORD': '123', 'HOST': '127.0.0.1', 'PORT': '3306', } }
1 python manage.py inspectdb 2 # This is an auto-generated Django model module. 3 # You'll have to do the following manually to clean this up 4 : 5 # * Rearrange models' order 6 # * Make sure each model has one field with primary_key=T 7 rue 8 # * Make sure each ForeignKey has `on_delete` set to the 9 desired behavior. 10 # * Remove `managed = False` lines if you wish to allow D 11 jango to create, modify, and delete the table 12 # Feel free to rename the models, but don't rename db_table 13 values or field names. 14 from __future__ import unicode_literals 15 16 from django.db import models 17 18 19 20 21 ================================================================================== 22 這裏把咱們在setting裏面配置好的數據庫裏面的全部的表都生成code 23 code_first 24 25 26 class BkL(models.Model): 27 name = models.CharField(max_length=200) 28 author = models.CharField(max_length=255, blank=True, n 29 ull=True) 30 thickness = models.CharField(max_length=255) 31 how_like = models.CharField(max_length=255) 32 33 class Meta: 34 managed = False 35 db_table = 'bk_l' 36 37 38 class Class(models.Model): 39 cname = models.CharField(unique=True, max_length=20) 40 41 class Meta: 42 managed = False 43 db_table = 'class' 44 45 46 class Class2Teacher(models.Model): 47 tid = models.ForeignKey('Teacher', models.DO_NOTHING, d 48 b_column='tid', blank=True, null=True) 49 cid = models.ForeignKey(Class, models.DO_NOTHING, db_co 50 lumn='cid', blank=True, null=True) 51 52 class Meta: 53 managed = False 54 db_table = 'class_2_teacher' 55 56 57 class Dep(models.Model): 58 id = models.IntegerField(blank=True, null=True) 59 name = models.CharField(max_length=20, blank=True, null 60 =True) 61 62 class Meta: 63 managed = False 64 db_table = 'dep' 65 66 67 class Em(models.Model): 68 id = models.AutoField(unique=True) 69 name = models.CharField(max_length=20) 70 sex = models.CharField(max_length=6) 71 age = models.IntegerField() 72 hire_date = models.DateField() 73 post = models.CharField(max_length=50, blank=True, null 74 =True) 75 post_comment = models.CharField(max_length=100, blank=T 76 rue, null=True) 77 salary = models.FloatField(blank=True, null=True) 78 office = models.IntegerField(blank=True, null=True) 79 depart_id = models.IntegerField(blank=True, null=True) 80 81 class Meta: 82 managed = False 83 db_table = 'em' 84 85 86 class Loginuser(models.Model): 87 name = models.CharField(max_length=32, blank=True, null 88 =True) 89 pwd = models.CharField(max_length=32, blank=True, null= 90 True) 91 extra = models.CharField(max_length=32, blank=True, nul 92 l=True) 93 94 class Meta: 95 managed = False 96 db_table = 'loginuser' 97 98 99 class Student(models.Model): 100 sname = models.CharField(unique=True, max_length=20) 101 cid = models.ForeignKey(Class, models.DO_NOTHING, db_co 102 lumn='cid', blank=True, null=True) 103 104 class Meta: 105 managed = False 106 db_table = 'student' 107 108 109 class Teacher(models.Model): 110 tname = models.CharField(unique=True, max_length=20) 111 112 class Meta: 113 managed = False 114 db_table = 'teacher' 115 116 117 class Userinfo(models.Model): 118 pwd = models.CharField(max_length=10) 119 name = models.CharField(max_length=10) 120 121 class Meta: 122 managed = False 123 db_table = 'userinfo' 124 125 126 class Users(models.Model): 127 id = models.IntegerField(primary_key=True) 128 name = models.CharField(max_length=30) 129 age = models.IntegerField(blank=True, null=True) 130 131 class Meta: 132 managed = False 133 db_table = 'users' 134 135 136 class Whatever(models.Model): 137 name = models.CharField(unique=True, max_length=10) 138 age = models.IntegerField() 139 140 class Meta: 141 managed = False 142 db_table = 'whatever'
相關文章
- 1. django安裝以及配置
- 2. 【Django】settings（django中settings設置）
- 3. Django簡介以及安裝
- 4. Django的settings配置
- 5. Django中間件以及csrf
- 6. django-debug-toolbar的配置以及使用
- 7. Mysql安裝以及配置
- 8. Django---SETTINGS配置(***)
- 9. python3 ubuntu16.04虛擬環境的配置以及Django的安裝
- 10. Django的安裝以及創建項目
- 更多相關文章...
- • MySQL的版本以及版本號 - MySQL教程
- • Spring Bean的配置及常用屬性 - Spring教程
- • 適用於PHP初學者的學習線路和建議
- • 漫談MySQL的鎖機制
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
