Django基礎筆記

1.準備工做

1.虛擬環境設置
    python3
        pip install virtualenv
        python -m venv env（虛擬環境文件名）
        env\Scripts\activate
        pip install Django    
    python2.7
        python -m pip install --user virtualenv
        virtualenv env（虛擬環境文件名）
        env\Scripts\activate
        pip install Django
　　1.1、linux版本
　　　　1.爲工程建立一個虛擬環境
　　　　　　virtualenv venv　　#venv爲虛擬環境目錄名，目錄名自定義
　　　　2.選擇使用一個Python解釋器
　　　　　　virtualenv -p python3 venv　　　　# -p參數指定Python解釋器程序路徑
　　　　3.激活虛擬環境
　　　　　　source venv/bin/activate　　
2.建立Django項目： django-admin startproject project_name（項目名） cd project_name
3.建立APP：
        Django-adim startapp app_name（APP名）
4.建立數據庫：
        mysql:pip install pymysql
        python manage.py migrate
        python manage.py makemigrations
5.建立超級用戶
        python manage.py createsuperuser
        輸入用戶，郵箱，密碼
6.運行Django：
        Python manage.py runserver

 

2.經過pycharm執行python manage.py前綴的命令

　

1.修改pycharm：
    Tools--> Run manage.py Test
2.命令執行前綴Python manage.py 能夠忽略

3.經過pycharm鏈接mysql數據庫：

　

View -->Tool windows --> database
2.左上角添加：
1.data Source -->mysql
2.下載mysql鏈接器：https://dev.mysql.com/downloads/connector/j/
3.MySQL -->添加 jar文件到Driver files中
4.輸入內容

 

模塊的使用：

對HTML內容的渲染的模板 ：

1.render
　　from django.shortcuts import render
　　def r(request)：
　　　　return render(request,'index.html')
2.render_to_string
　　from django.template.loader import render_to_string
　　from django.http import HttpResponse
　　def r(request):　　
　　　　html = render_to_string('index.html')
　　　　return HttpResponse(html)

　　

模板查找路徑配置：
　　settings.py 下的TEMPLATES配置，包含了模塊引擎的配置
　　DIRS：一個列表，能夠存放全部的模塊路徑，之後在視圖中使用render渲染模板的時候，會在這個列表的路徑中查找模板
　　APP_DIRS：默認爲True，設置爲True，會在INSTALLED_APPS的安裝了的APP下的templates文件夾中查找模板
　　INSTALLED_APPS：配置的做用是相似DIRS做用，讓他尋找當前apps下的templates文件下的模塊
DTL模塊語法：

模塊中變量的引用：
1.直接傳遞字典

views.py
　　def index(request):
　　　　context = {
　　　　　　'username' : 'ziliao'
　　　　　}
　　　　return render(request,'index.html',context=context)
index.html
　　{{ username }}

 

2.經過函數方式

views.py
    class Person(object):
　　　　def __init__(self,username):
　　　　　　self.username = username
　　def index(request):
　　　　p = Person('ziliao')
　　　　context = {
　　　　　　'person' : p
　　　　}
　　　　return render(request,'index.html',context=context)
index.py
　　{ person.username }}

　　

3.字典中包含字典

views.py：
　　def index(request):
　　　　context = {
　　　　　　'persion' : {
　　　　　　'username' : 'ziliao'
　　　　　　　}
　　　　}
　　　　return render(request,'index.html',context=context)
index.html
        {{ persion.username }}    

　　

　　

4.字典中包含列表

views.py：
　　def index(request):
　　　　context = {
　　　　'persion' : [
　　　　　　'圖書館',
　　　　　　'廣州'
　　　　　]
　　}	
index.html
　　{{ persion.0 }}	

從上述中，能夠獲得結論，不管後臺傳入的參數是字典，對象仍是列表等
在前端的調用傳入參數，都是經過 xxx.xxx的方式進行調用

標籤的使用：if、for、url

if標籤：（判斷符 < = ... in ）

views.py
　　def index(request):
　　　　context = {
　　　　'age': 18
　　}
　　return render(request,'index.html',context=context)	
index.html
　　{% if age < 18 %}
　　　　<p>未成年人</p>
　　{% elif age > 18 %}
　　　　<p>成年人</p>
　　{% else %}
　　　　<p>18歲騷年</p>
　　{% endif %}

 

for標籤：

views.py
　　def index(request):
　　context = {
　　　　'books':[
　　　　'三國演義',
　　　　'水滸傳',
　　　　'紅樓夢',
　　　　]
　　}
　　return render(request,'index.html',context=context)
index.html
　　<ul>
　　　　{% for book in books %} #在books 後加reversed表明翻轉輸出
　　　　　　<li>{{ book }}</li>
　　　　{% endfor %}
　　</ul>

 

在for循環中，DTL提供一些變量可供使用，變量以下：

forloop.counter：當前循環的下標，以1做爲其始值

{% for book in books %}
　　<tr>
　　　　<td>{{ forloop.counter }}</td> 　　#變量的例子
　　　　<td>{{ book.name }}</td>
　　　　<td>{{ book.author }}</td>
　　　　<td>{{ book.price }}</td>
　　</tr>
{% endfor %}

　　

在for循環中其內容爲空：可加 empty

{% for comment in comments %}
　　<li>{{ comment }}</li>
{% empty %} 
　　<li>沒有任何評論</li>
{% endfor %}

 

懵懂

url標籤：

views.py
　　#登陸
　　def login(request):
　　　　next = request.GET.get('next')
　　　　text = '登陸頁面，登陸完成後要跳轉的url是： %s' % next
　　　　return HttpResponse(text)

　　#首頁
　　def index(request):
　　　　return render(request, 'index.html')

　　#最火的一篇文章
　　def book_detail(request,book_id):
　　　　text = '您的圖書的id是：%s' % book_id
　　　　return HttpResponse(text)
index.html
　　<li><a href="{% url 'city' %}">首頁</a></li>
　　<li><a href="{% url 'detail' book_id='1' %}">最火的一篇文章</a></li>
　　<li><a href="{% url 'login' %}?next=/">登陸</a></li>

　　

解析：在登陸中的url爲： http://127.0.0.1:8000/login/?next=/
在最火的一篇文章的url爲： http://127.0.0.1:8000/book/detail/1/
兩個的不一樣之處在於，一個從前端獲取參數值，一個傳遞參數值給前端

DTL過濾器：
　　在模板中，有時候須要對一些數據進行處理之後才能使用，通常在python中咱們是經過函數的形式來實現，
　　而在模板中，則經過過濾器來實現，過濾器使用是 | 來使用

add
　　將傳進來的參數添加到原來的值上面,列表則是添加到一個列表中

views.py
　　def index(request):
　　　　context = {
　　　　'value1':['1','2','3'],
　　　　'value2':['4','5','3']
　　　　}
　　　　return render(request,'add.html', context=context)
index.html
　　<p>{{ "1"|add:"2"}}</p>
　　<p>{{ value1 | add:value2 }}</p>
結果爲：3	
　　　　['1', '2', '3', '4', '5', '6']　　

  

cut
　　移除值中全部指定的字符串，相似於python中的replace(arg,'')

views.py
　　def index(request):
　　　　return render(request,'index.html')
index.html
　　　　{{"hello / world"|cut:"/" }}
結果：hello world

 

date

views.py
　　from datetime import datetime
　　def index(request):
　　　　context = {
　　　　'today':datetime.now()
　　　　　}
　　　　return render(request,'index.html', context=context)
index.html
　　{{ today|date:"Y/m/d" }}
結果：2018/09/09

　　

模板繼承

base.html
　　<body>
　　　　<li>公共部分</li>
　　　　<li>
　　　　　　{% block content %}
　　　　　　{% endblock %}
　　　　</li>
　　</body>
index.html
　　{% extends 'base.html' %}
            父模板內容   #子繼承時，調用 block.super能夠獲取此內容
　　{% block comment %}
　　　　新添加的內容
　　{{ block.super }} #繼承父模板在 block中寫的內容

　　{% endblock %}        

　　

　

加載靜態文件

1.在setting設置 INSTALLED_APPS 添加 'django.contrib.staticfiles'　　

2.

#在瀏覽器中請求靜態文件的url
#127.0.0.1/static/xx.jpg

STATIC_URL = '/static/' 

綁定在app下的靜態文件

3.

在調用某app中的靜態文件，須要在 INSTALLED_APPS 中添加 其app名

4.加載靜態文件
　　

方式一、直接調用
　　　　　　<img src='/static/1.jpg' alt=''>
方式二、經過static方式調用
　　　　　　{% load static %}
　　　　　　<img src="{% static '1.jpg' %}" alt="">
方式三、調用另外一個app下同名的靜態文件
　　　　  能夠經過在不一樣app下建立如下目錄結構
　　　　　　--app1
　　　　　　　　--static
　　　　　　　　　　--app1	
　　　　　　　　　　　　1.jpg
　　　　　　--app2
　　　　　　　　--static
　　　　　　　　　　--app2
　　　　　　　　　　　　1.jpg
　　　　　　{% load static %}
　　　　　　<img src="{% static 'app1/1.jpg' %}" alt="">

　　

沒有和app綁定的靜態文件,在和app同級目錄下建立static目錄

5.從新在setting.py文件下指定配置

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

6.在加載靜態文件時，須要頭添加{% load static %},若是不想在每個文件都添加此內容，能夠作如下操做　　　

在setting.py 文件下的TEMPLATES 配置下添加 ，能夠把static添加到django內置中
　　　　'builtins':['django.templatetags.static']

　　

數據庫的操做：

1.簡單的操做數據庫：

　　在調用數據庫mysql是，有的須要在project的app下__init__.py添加：

　　　　import 　pymysql

　　　　pymysql.install_as_MySQLdb()

 

　　在定義字段時，若是沒有指定null=True，默認狀況下 null=False ，即非空

 

建立數據庫：
    class Book(models.Model):
        id = models.AutoField(primary_key=True)
        author = models.CharField(max_length=100,null=False)
        price = models.FloatField(default=0)
添加數據：
    1.book = Book(name='西遊記', author='吳承恩', price=100)
　　2.book_dic = {'name'='三國演義', 'author'='羅貫中','price'=100}
　　　　Book.object.create(**book_dic)

查詢數據：pk --> primary key
    1.book = Book.objects.get(pk=2)
    2.book = Book.objects.filter(name='三國演義')
刪除數據：
     book.delete()
修改數據：
    book.price = 200
在增刪改查操做中，最後須要保存，即 book.save()

 

 

 

 

2.模塊經常使用屬性

 

AutoField:
    映射到數據庫是int類型，能夠有自動增加的特性，通常不須要使用這個類型，
    不指定主鍵，那麼模型會自動的生成一個叫id的自動增加的主鍵
    若是想指定一個其餘名字的而且具備自動增加的主鍵，也可以使用
BigButoField:
    64位整形，自增加
BooleanField: 布爾值類型
　　在模塊層面接收的是True/False,在數據庫層面是tinyint類型

NullBooleanField：
　　能夠爲空的布爾值

CharField: （max_length）:
　　在數據庫層面是varchar類型，在python層面就是普通的字符串，須要指定最大長度，即必須傳遞max_length參數值

　EmailFiled：
　　　郵箱，默認大小爲254
　　　可輸入其餘字符串格式，主要用處在前端提交表單
　FlotField:
　　　浮點類型，映射到數據庫類型float
　TextField:
　　　映射到數據庫類型是longtext，用於文章類存儲
　DateField:
　　　日期類型，映射到數據庫是date類型
　　　參數：
　　　　　　auto_now_add：是在第一次添加數據進去的時會自動獲取當前時間
　　　　　　auto_now：每次這個對象調用save方法的時候都會將當前時間更新
　DateTimeField:
　　　日期時間類型，不只能夠存儲日期，還能夠存儲時間，映射到數據庫是datetime類型
　　　可以使用auto_now_add, auto_now參數
　TimeField：
　　　時間類型，在數據庫中time類型

 3.外鍵和表的關係

　　表名的設置：

在建立表名時，Django默認是表名格式爲 app名_表名
若是須要重定義表名，則重寫Meta模塊
class Classes(models.Model):
    id = models.AutoField(primary_key=True)

    class Meta: 
        db_table = 'Classes'        

 

　兩張表的關聯操做

　　建立表

book/model.py
class Category(models.Model):
    name = models.CharField(max_length=100)

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    category = models.ForeignKey("Category",on_delete=models.CASCADE)  #on_delete是設置兩張表的級別，CASCADE爲級別關聯    （同app下的設置外鍵）
　　 autor = models.ForeignKey("front.Front",on_delete=models.CASCADE,null=True)                      #對front下的Front表設置外鍵

建立另外一個app下的表

 

front/model.py
class Front(models.Model):
    username = models.CharField(max_length=100)

 

1.添加表數據

book/views.py
def index(request):
    article = Article(title='abc',content='111')
    category = Category(name='最新文章')
    category.save()
    article.category = category
    article.save()
    return HttpResponse("seccess")

 添加數據後的

2.另外一種添加表數據：

def one_to_many_view(request):
    category = Category.objects.first()
    article = Article(title='大神片', content='沒得看')
    article.author = Front.objects.first()
    category.articles.add(article,bulk=False)      #bulk的做用在於：自動保存數據庫article,category
    return HttpResponse("success")

兩種方式的不一樣之處在於，第一種是經過article調用添加，第二種是category調用添加 

 

 對自身的外鍵引用

book/model.py
class Conment(models.Model):
    content = models.TextField()
    origin_comment = models.ForeignKey('self',on_delete=models.CASCADE)
    #或者：origin_comment = models.ForeignKey('Conment',on_delete=models.CASCADE)

 

 4.一對多關係表操做：

在Django中，假設存在 A表，B表，其中A表被B表引用並設置外鍵
   即：A：id、username
         B：id、concent、author_id（外鍵A中id）
   Django會在A模型中建立一個以B_set()的函數

實例操做：

model.py
class Category(models.Model):
    name = models.CharField(max_length=100)

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
　　#能夠修改article_set():category = models.ForeignKey("Category",on_delete=models.CASCADE,related_name='articles')
    category = models.ForeignKey("Category",on_delete=models.CASCADE) 

views.py:
#獲取某個分類下全部的文章
def index(request):
    category = Category.objects.first()
    article = category.article_set.first()  #article_set能夠被修改
    print(article.title)
    return HttpResponse("success")
結果：三國演義

表內容以下