python_Django之模板模型

发布时间：2020-04-01 21:23:09 阅读：347 作者：lc994811089 栏目：数据库

Python开发者专用服务器限时活动，0元免费领，库存有限，领完即止！点击查看>>

主要文件

manage.py 创建服务器

settings.py 项目的配置信息

urls.py URL分发器（URLconf----URL和函数的映射表）

view.py 视图（函数）

启动manage.py创建简单的服务器，用于调测

python manage.py runserver 0.0.0.0:8000

urls.py

patterns：第一个是空字符串（后面会解释）

include：

urls：

from django.conf.urls.defaults import patterns, include, url
from mysite.views import hello      # 通常是导*  views. 调用
urlpatterns = patterns('',
    url(r'^hello/$', hello),
    )

 url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),

view.py

一个视图就是Python的一个函数。这个函数第一个参数的类型是HttpRequest；它返回一个HttpResponse实例。

request 是一个触发这个视图、包含当前Web请求信息的对象，是类django.http.HttpRequest的一个实例。

from django.http import HttpResponse
def hello(request):
    return HttpResponse("Hello world")    # 直接返回字符串
---------------------------------------------------------------------
from django.shortcuts import render
def be_001(request):
    return render(request,'001.html')    # 返回template文件下的001.html

settings.py

设置指定URLconf （url分发器）

ROOT_URLCONF = 'mysite.urls'     # 即mysite/urls.py

进来的请求转入/hello/.

Django通过在ROOT_URLCONF配置来决定根URLconf.

Django在URLconf中的所有URL模式中，查找第一个匹配/hello/的条目。

如果找到匹配，将调用相应的视图函数，并把HttpRequest 对象作为第一个参数

视图函数返回一个HttpResponse

Django转换HttpResponse为一个适合的HTTP response，以Web page显示出来

指定模板路径

TEMPLATE_DIRS = (
    os.path.join(os.path.dirname(__file__), 'templates').replace('\\','/'),
    
    # 自动获取settings.py的路径，并拼接得到模板路径
)
# 单元素元组中必须使用逗号，以此消除与圆括号表达式之间的歧义。

模板

在project目录（django-admin.py startproject）中输入命令 python manage.py shell启动交互界面（会自动加载相关配置）

循环判断

{% for item in item_list %} # 表示当前循环的执行次数的整数计数器。这个计数器是从1开始的， forloop.counter0从零开始

<p>` forloop`.`counter `: ` item `</p> # forloop.revcounter 是表示循环中剩余项的整型变量,forloop.revcounter0

{% endfor %} #forloop.first 是一个布尔值，如果该迭代是第一次执行，那么它被置为true，forloop.last

# forloop.parentloop 是一个指向当前循环的上一级循环的 forloop 对象的引用（在嵌套循环的情况下）

{% if ordered_warranty %} # 只能用一种逻辑操作符 and 或 or ，两个一起用不可以的

{% else %}

{% endif %}

{% ifequal user currentuser %}      # 判断 user currentuser 是否相等，字符串要“”，只能判断两个变量是否相等    <h2>Welcome</h2>                # 不能用于判断变量是否等于什么，True {op:123} [1,2,3]等等{% endifequal %}

变量赋值

{{ person_name }} 称为变量(variable) 。这意味着在此处插入指定变量的值。

>>> from django import template                # Template 可用render方法传 Context 参数
>>> t = template.Template('My name is {{ name }}.')
>>> c = template.Context({'name': 'Adrian'})
>>> print t.render(c)
My name is Adrian.
>>> c = template.Context({'name': 'Fred'})
>>> print t.render(c)                    # 返回的是Unicode r''
My name is Fred.

Django模板系统的基本规则：写模板，创建 Template 对象，创建 Context ，调用 render() 方法。

>>> from django.template import Template, Context
>>> import datetime
>>> person = {'name': 'Sally', 'age': '43'}
>>> t = Template('{{ person.name }} is {{ person.age }} years old.')
>>> c = Context({'person': person})
>>> t.render(c)
u'Sally is 43 years old.'
>>> d = datetime.date(1993, 5, 2)        #时间也可以这么用 
>>> d.year
1993
>>> t = Template('Item 2 is {{ items.2 }}.')            # 列表索引（不能用负数）
>>> c = Context({'items': ['apples', 'bananas', 'carrots']})

#调用方法时并没有使用圆括号 而且也无法给该方法传递参数；
>>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')    # var变量，调用upper和isdigit方法
>>> t.render(Context({'var': 'hello'}))
u'hello -- HELLO -- False'

字典类型查找（比如 foo["bar"] )
属性查找 (比如 foo.bar )
方法调用（比如 foo.bar() )
列表类型索引查找 (比如 foo[bar] )

系统使用找到的第一个有效类型。这是一种短路逻辑。

一个变量不存在，模板系统会把它展示为空字符串，不做任何事情来表示失败。

方法调用

抛异常

在方法查找过程中，如果某方法抛出一个异常的话它将被传播（报错）。

若该异常有一个 silent_variable_failure 属性并且值为True ，模板里的指定变量会被置为空字符串（不报错）

模版中避免关键函数的误操作

def delete(self):

# Delete the account

delete.alters_data = True

# 把delete看成一个对象，设置它的alters_data属性。这样在渲染的时候，就会变成failed silent。不会执行

注释

单行

{# This is a comment #}

多行

{% comment %}
This is a
multi-line comment.
{% endcomment %}

过滤器

常用的几个

模板过滤器是在变量被显示前修改它的值的一个简单方法。

{{ my_list|first|upper }}
{{ bio|truncatewords:"30" }}

addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。这在处理包含JavaScript的文本时是非常有用的。
date : 按指定的格式字符串参数格式化 date 或者 datetime 对象，范例：

{{ pub_date|date:"F j, Y" }}

格式参数的定义在附录F中。
length : 返回变量的长度。对于列表，这个参数将返回列表元素的个数。对于字符串，这个参数将返回字符串中字符的个数。你可以对列表或者字符串，或者任何知道怎么测定长度的Python 对象使用这个方法（也就是说，有 __len__() 方法的对象）
详细 https://www.douban.com/note/145065606/

模板加载

settings.py

import os.path

TEMPLATE_DIRS = (
    os.path.join(os.path.dirname(__file__), 'templates').replace('\\','/'),
)

在视图中

from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponse
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    t = get_template('current_datetime.html')
    html = t.render(Context({'current_date': now}))
    return HttpResponse(html)

更为简洁的视图

from django.shortcuts import render_to_response
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    return render_to_response('current_datetime.html', {'current_date': now})
    # 返回HttpResponse 对象；
    # 第一个参数必须是要使用的模板名称；
    # 第二个参数，那么该参数必须是为该模板创建 Context 时所使用的字典，默认是空字典

locals() 技巧

def current_datetime(request):
    now = datetime.datetime.now()        # 多余的变量名...
    return render_to_response('current_datetime.html', {'current_date': now})

def current_datetime(request):       
    current_date = datetime.datetime.now()        # 这个变量名和模板中的一致
    return render_to_response('current_datetime.html', locals())
         # locals()囊括了函数执行到该时间点时所定义的一切变量。

get_template()-模板子目录

t = get_template('dateapp/current_datetime.html')

return render_to_response('dateapp/current_datetime.html', {'current_date': now})

`include` 模板标签（笨笨的嵌套网页）

{% include template_name %}

如果{% include %}标签指定的模板没找到，Django将会在下面两个处理方法中选择一个：

如果 DEBUG 设置为 True ，你将会在 Django 错误信息页面看到 TemplateDoesNotExist 异常。

如果 DEBUG 设置为 False ，该标签不会引发错误信息，在标签位置不显示任何东西。

模板继承（更加优雅的策略）

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">        # base.html
<html lang="en">                                     
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <h2>My helpful timestamp site</h2>
</body>
</html

{% extends "base.html" %}                        # 继承模板，替换同名block即可

{% block title %}The current time{% endblock %}

{% block content %}
<p>It is now {{ current_date }}.</p>
{% endblock %}

要点：

基础模板中的 {% block %} 标签越多越好。

子模板不必定义父模板中所有的代码块。

不允许在同一个模板中定义多个同名的 {% block %} 。

模型

为了提供方便的数据访问API， Django需要以某种方式知道数据库层内部信息，有两种实现方式。

第一种方式是用Python明确地定义数据模型

第二种方式是通过自省来自动侦测识别数据模型。

（自省（运行时自动识别数据库）会导致过载和有数据完整性问题。）

笨方法数据库查询

from django.shortcuts import render_to_response        # 重复同样的代码
import MySQLdb                                         # 绑定死了MySQL 

def book_list(request):
    db = MySQLdb.connect(user='me', db='mydb', passwd='secret', host='localhost')
    cursor = db.cursor()
    cursor.execute('SELECT name FROM books ORDER BY name')
    names = [row[0] for row in cursor.fetchall()]
    db.close()
    return render_to_response('book_list.html', {'names': names})

Django数据库层

from django.shortcuts import render_to_response        # 由Django数据库层来处理
from mysite.books.models import Book                   # 底层数据库代码更为优化，数据库选择更灵活                
def book_list(request):
    books = Book.objects.order_by('name')
    return render_to_response('book_list.html', {'books': books})

settings.py 中数据库的设置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': '',                      # Or path to database file if using sqlite3.
        'USER': '',                      # Not used with sqlite3.
        'PASSWORD': '',                  # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }}

MVC 模式

控制器(controller) ---->>> 模型(model) ---->>> 视图(view)

MTV

" C 由框架自行处理（URLconf）" ---->>> 模型（Model）---->>> 视图（Views）---->>> 模板(Template)

APP

理一理project和app：一个project包含多个app，为app提供相关配置，但model必须在各自的app中

python manage.py startapp books    # 创建APP

from django.db import models

class Publisher(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()

class Author(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=40)
    email = models.EmailField()

class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()

与下面的sql效果一样

CREATE TABLE "books_publisher" (
    "id" serial NOT NULL PRIMARY KEY,
    "name" varchar(30) NOT NULL,
    "address" varchar(50) NOT NULL,
    "city" varchar(60) NOT NULL,
    "state_province" varchar(30) NOT NULL,
    "country" varchar(50) NOT NULL,
    "website" varchar(200) NOT NULL
);

settings.py 激活app

MIDDLEWARE_CLASSES = (                                        # 注释部分后续解释
    # 'django.middleware.common.CommonMiddleware',
    # 'django.contrib.sessions.middleware.SessionMiddleware',
    # 'django.contrib.auth.middleware.AuthenticationMiddleware',
)

INSTALLED_APPS = (
    # 'django.contrib.auth',
    # 'django.contrib.contenttypes',
    # 'django.contrib.sessions',
    # 'django.contrib.sites',
    'mysite.books',                        
)

检查上面模型的语法和逻辑（正常返 0 erros found）

python manage.py validate

生成 CREATE TABLE 语句

python manage.py sqlall books

提交到数据库客户端执行

python manage.py syncdb        # 此命令不能用做修改删除

基本数据访问

python manage.py shell

>>> from books.models import Publisher            # 导入Publisher模型类，与数据表进行交互
>>> p1 = Publisher(name='Apress', address='2855 Telegraph Avenue',
...     city='Berkeley', state_province='CA', country='U.S.A.',
...     website='http://www.apress.com/')
>>> p1.save()
>>> p2 = Publisher(name="O'Reilly", address='10 Fawcett St.',
...     city='Cambridge', state_province='MA', country='U.S.A.',
...     website='http://www.oreilly.com/')
>>> p2.save()
>>> publisher_list = Publisher.objects.all()
>>> publisher_list
[<Publisher: Publisher object>, <Publisher: Publisher object>]

下面不需要save，直接完成对象的创建与存储至数据库

>>> p1 = Publisher.objects.create(name='Apress',
...     address='2855 Telegraph Avenue',
...     city='Berkeley', state_province='CA', country='U.S.A.',
...     website='http://www.apress.com/')

重写__unicode__，方便

class Author(models.Model):
    **def __unicode__(self):**        # __unicode__() 方法可以进行任何处理来返回对一个对象的字符串表示
        **return u'%s %s' % (self.first_name, self.last_name)**    # 必须返回Unicode，数字什么的会报错

插入更新

>>> p = Publisher(name='Apress',
...         address='2855 Telegraph Ave.',
...         city='Berkeley',
...         state_province='CA',
...         country='U.S.A.',
...         website='http://www.apress.com/')

>>> p.save()        #相当于执行INSERT INTO books_publisher***  会把主键赋值给实例对象 p

>>> p.id
52    # this will differ based on your own data

>>> p.name = 'Apress Publishing'        # 根据这个对象可更新数据
>>> p.save()                            # 并不是只更新修改过的那个字段，所有的字段都会被更新。
                                        # 部分更新后面再说

查询

>>> Publisher.objects.all()
[<Publisher: Apress>, <Publisher: O'Reilly>]

数据过滤（filter--返回列表）

>>> Publisher.objects.filter(country="U.S.A.", state_province="CA")
[<Publisher: Apress>]

多个参数会被转换成 AND SQL从句， 因此上面的代码可以转化成这样：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher  
WHERE country = 'U.S.A.'
AND state_province = 'CA';

>>> Publisher.objects.filter(name__contains="press")    # 在 name 和 contains 之间有双下划线
[<Publisher: Apress>]                                   # 这里，contains部分会被Django翻译成LIKE语句：
         
注意，SQL缺省的 = 操作符是精确匹配的， 其他类型的查找也可以使用
WHERE name LIKE '%press%';

获取单个对象

>>> Publisher.objects.get(name="Apress")
<Publisher: Apress>

MultipleObjectsReturned  # 结果是多个对象，抛出异常
DoesNotExist   #  DoesNotExist 异常 是 Publisher 这个 model 类的一个属性，即 Publisher.DoesNotExist。在你的应用中，你可以捕获并处理这个异常

数据排序

>>> Publisher.objects.order_by("-state_province", "address")
 [<Publisher: Apress>, <Publisher: O'Reilly>]
 # 减号 - 前缀逆向排序，第二个字段会在第一个字段的值相同的情况下被使用到

class Publisher(models.Model):
    **class Meta:**
        **ordering = ['name']**
 # 在模型类（需要设置默认排序的）中，设置默认的排序方式，上述当你使用 Django 的数据库 API 去检索时，
 # Publisher对象的相关返回值默认地都会按 name 字段排序

连锁查询

>>> Publisher.objects.filter(country="U.S.A.").order_by("-name")
[<Publisher: O'Reilly>, <Publisher: Apress>]
# 即为SQL查询 WHERE 和 ORDER BY 的组合

限制返回数据

>>> Publisher.objects.order_by('name')[0:2]        # 即为OFFSET 0 LIMIT 2;

>>> Publisher.objects.order_by('-name')[0]        # 不能用负索引，但可以这样变通

更新

>>> p = Publisher.objects.get(name='Apress')
>>> p.name = 'Apress Publishing'
>>> p.save()                    # 这样操作会更新所有的列（不仅仅是name列的值）

指定更新

>>> Publisher.objects.filter(id=52).update(name='Apress Publishing')    # id=52的表的name字段

>>> Publisher.objects.all().update(country='USA')        # 所有Publisher的country字段值
2            # update()方法会返回一个整型数值，表示受影响的记录条数。

删除对象

>>> p = Publisher.objects.get(name="O'Reilly")    # 删除指定记录
>>> p.delete()

>>> Publisher.objects.filter(country='USA').delete()    # 同时删除多条记录
>>> Publisher.objects.all().delete()

多对多用两个循环获取 .all 获取所有（列表） .first 获取首个

<img src="`i`.`p_w_picpath`.`all`.`0`.`p_w_picpath`.`url`" alt="`i`.`title`"/>

{% for im in i.p_w_picpath.all %}<img src="`im`.`p_w_picpath`.`url`" alt="`im`.`name`"/>{% endfor %}

亿速云「云服务器」，即开即用、新一代英特尔至强铂金CPU、三副本存储NVMe SSD云盘，价格低至29元/月。点击查看>>

向AI问一下细节

python_Django之模板模型

循环判断

变量赋值

方法调用

注释

过滤器

locals() 技巧

get_template()-模板子目录

include 模板标签（笨笨的嵌套网页）

模板继承（更加优雅的策略）

猜你喜欢

最新资讯

相关推荐

开发者交流群：

相关标签

`include` 模板标签（笨笨的嵌套网页）