templates_templatespace - CSDN
  • templates

    2011-12-23 09:16:17
    函数模板( Function templates) 模板(Templates)使得我们可以生成通用的函数,这些函数能够接受任意数据类型的参数,可返回任意类型的值,而不需要对所有可能的数据类型进行函数重载。这在一定程度上实现了宏...
    
    

    函数模板( Function templates)

    模板(Templates)使得我们可以生成通用的函数,这些函数能够接受任意数据类型的参数,可返回任意类型的值,而不需要对所有可能的数据类型进行函数重载。这在一定程度上实现了宏(macro)的作用。它们的原型定义可以是下面两种中的任何一个:

    template <class identifier> function_declaration;
    template <typename identifier> function_declaration;

    上面两种原型定义的不同之处在关键字class 或 typename的使用。它们实际是完全等价的,因为两种表达的意思和执行都一模一样。

    例如,要生成一个模板,返回两个对象中较大的一个,我们可以这样写:

    template <class GenericType>

    GenericType GetMax (GenericType a, GenericType b) { return (a>b?a:b); }

    在第一行声明中,我们已经生成了一个通用数据类型的模板,叫做GenericType。因此在其后面的函数中,GenericType 成为一个有效的数据类型,它被用来定义了两个参数a和 b ,并被用作了函数GetMax的返回值类型。

    GenericType 仍没有代表任何具体的数据类型;当函数 GetMax 被调用的时候,我们可以使用任何有效的数据类型来调用它。这个数据类型将被作为pattern来代替函数中GenericType 出现的地方。用一个类型pattern来调用一个模板的方法如下:

    function <type> (parameters);

    例如,要调用GetMax 来比较两个int类型的整数可以这样写:

    int x,y;
    GetMax <int> (x,y);

    因此,GetMax 的调用就好像所有的GenericType 出现的地方都用int 来代替一样。

    这里是一个例子:

    // function template

    #include <iostream.h>

    template <class T> T GetMax (T a, T b) {

        T result;

        result = (a>b)? a : b;

        return (result);

    }

    int main () {

        int i=5, j=6, k;

        long l=10, m=5, n;

        k=GetMax(i,j);

        n=GetMax(l,m);

        cout << k << endl;

        cout << n << endl;

        return 0;
    }

    6
    10

    (在这个例子中,我们将通用数据类型命名为T 而不是 GenericType ,因为T短一些,并且它是模板更为通用的标示之一,虽然使用任何有效的标示符都是可以的。)

    在上面的例子中,我们对同样的函数GetMax()使用了两种参数类型:int 和 long,而只写了一种函数的实现,也就是说我们写了一个函数的模板,用了两种不同的pattern来调用它。

    如你所见,在我们的模板函数 GetMax() 里,类型 T 可以被用来声明新的对象

    T result;

    result 是一个T类型的对象, 就像a 和 b一样,也就是说,它们都是同一类型的,这种类型就是当我们调用模板函数时写在尖括号<> 中的类型。

    在这个具体的例子中,通用类型 T 被用作函数GetMax 的参数,不需要说明<int>或 <long>,编译器也可以自动检测到传入的数据类型,因此,我们也可以这样写这个例子:

    int i,j;
    GetMax (i,j);

    因为i 和j 都是int 类型,编译器会自动假设我们想要函数按照int进行调用。这种暗示的方法更为有用,并产生同样的结果:

    // function template II

    #include <iostream.h>

    template <class T> T GetMax (T a, T b) {

        return (a>b?a:b);

    }

    int main () {

        int i=5, j=6, k;

        long l=10, m=5, n;

        k=GetMax(i,j);

        n=GetMax(l,m);

        cout << k << endl;

        cout << n << endl;

        return 0;

    }

    6
    10

    注意在这个例子的main() 中我们如何调用模板函数GetMax() 而没有在括号<>中指明具体数据类型的。编译器自动决定每一个调用需要什么数据类型。

    因为我们的模板函数只包括一种数据类型 (class T), 而且它的两个参数都是同一种类型,我们不能够用两个不同类型的参数来调用它:

    int i;
    long l;
    k = GetMax (i,l);

    上面的调用就是不对的,因为我们的函数等待的是两个同种类型的参数。

    我们也可以使得模板函数接受两种或两种以上类型的数据,例如:

    template <class T>

    T GetMin (T a, U b) { return (a<b?a:b); }

    在这个例子中,我们的模板函数 GetMin() 接受两个不同类型的参数,并返回一个与第一个参数同类型的对象。在这种定义下,我们可以这样调用该函数:

    int i,j;
    long l;
    i = GetMin <int, long> (j,l);

    或者,简单的用

    i = GetMin (j,l);

    虽然 j 和 l 是不同的类型。

     

    类模板(Class templates)

    我们也可以定义类模板(class templates),使得一个类可以有基于通用类型的成员,而不需要在类生成的时候定义具体的数据类型,例如:

    template <class T>

    class pair {

        T values [2];

    public:

        pair (T first, T second) {

            values[0]=first;

            values[1]=second;

        }

    };

    上面我们定义的类可以用来存储两个任意类型的元素。例如,如果我们想要定义该类的一个对象,用来存储两个整型数据115 和 36 ,我们可以这样写:

    pair<int> myobject (115, 36);

    我们同时可以用这个类来生成另一个对象用来存储任何其他类型数据,例如:

    pair<float> myfloats (3.0, 2.18);

    在上面的例子中,类的唯一一个成员函数已经被inline 定义。如果我们要在类之外定义它的一个成员函数,我们必须在每一函数前面加template <... >。

    // class templates

    #include <iostream.h>

    template <class T> class pair {
         T value1, value2;
    public:
        pair (T first, T second) {

            value1=first;

            value2=second;

        }

        T getmax ();

    };

    template <class T>

    T pair::getmax (){

        T retval;

        retval = value1>value2? value1 : value2;

        return retval;

    }

    int main () {

        pair myobject (100, 75);

        cout << myobject.getmax();

        return 0;

    }

    100

    注意成员函数getmax 是怎样开始定义的:

    template <class T>
    T pair::getmax ()

    所有写 T 的地方都是必需的,每次你定义模板类的成员函数的时候都需要遵循类似的格式(这里第二个T表示函数返回值的类型,这个根据需要可能会有变化)。

     

    模板特殊化(Template specialization)

    模板的特殊化是当模板中的pattern有确定的类型时,模板有一个具体的实现。例如假设我们的类模板pair 包含一个取模计算(module operation)的函数,而我们希望这个函数只有当对象中存储的数据为整型(int)的时候才能工作,其他时候,我们需要这个函数总是返回0。这可以通过下面的代码来实现:

    // Template specialization

    #include <iostream.h>

    template <class T> class pair {

        T value1, value2;

    public:

        pair (T first, T second){

            value1=first;

            value2=second;

        }

        T module () {return 0;}

    };

    template <>

    class pair <int> {

        int value1, value2;

    public:

        pair (int first, int second){

            value1=first;

            value2=second;

        }

        int module ();

    };

    template <>

    int pair<int>::module() {

        return value1%value2;

    }

    int main () {

        pair <int> myints (100,75);

        pair <float> myfloats (100.0,75.0);

        cout << myints.module() << '\n';

        cout << myfloats.module() << '\n';

        return 0;

    }

    25
    0

    由上面的代码可以看到,模板特殊化由以下格式定义:

    template <> class class_name <type>

    这个特殊化本身也是模板定义的一部分,因此,我们必须在该定义开头写template <>。而且因为它确实为一个具体类型的特殊定义,通用数据类型在这里不能够使用,所以第一对尖括号<> 内必须为空。在类名称后面,我们必须将这个特殊化中使用的具体数据类型写在尖括号<>中。

    当我们特殊化模板的一个数据类型的时候,同时还必须重新定义类的所有成员的特殊化实现(如果你仔细看上面的例子,会发现我们不得不在特殊化的定义中包含它自己的构造函数 constructor,虽然它与通用模板中的构造函数是一样的)。这样做的原因就是特殊化不会继承通用模板的任何一个成员。

     

    模板的参数值(Parameter values for templates)

    除了模板参数前面跟关键字class 或 typename 表示一个通用类型外,函数模板和类模板还可以包含其它不是代表一个类型的参数,例如代表一个常数,这些通常是基本数据类型的。例如,下面的例子定义了一个用来存储数组的类模板:

    // array template

    #include <iostream.h>

    template <class T, int N>

    class array {

        T memblock [N];

    public:

        void setmember (int x, T value);

        T getmember (int x);

    };

    template <class T, int N>

    void array<T,N>::setmember (int x, T value) {

        memblock[x]=value;

    }

    template <class T, int N>

    T array<T,N>::getmember (int x) {

        return memblock[x];

    }

    int main () {

        array <int,5> myints;

        array <float,5> myfloats;

        myints.setmember (0,100);

        myfloats.setmember (3,3.1416);

        cout << myints.getmember(0) << '\n';

        cout << myfloats.getmember(3) << '\n';

        return 0;

    }

    100
    3.1416

    我们也可以为模板参数设置默认值,就像为函数参数设置默认值一样。

    下面是一些模板定义的例子:

    template <class T> // 最常用的:一个class 参数。

    template <class T, class U> // 两个class 参数。

    template <class T, int N> // 一个class 和一个整数。

    template <class T = char> // 有一个默认值。

    template <int Tfunc (int)> // 参数为一个函数。

     

    模板与多文件工程 (Templates and multiple-file projects)

    从编译器的角度来看,模板不同于一般的函数或类。它们在需要时才被编译(compiled on demand),也就是说一个模板的代码直到需要生成一个对象的时候(instantiation)才被编译。当需要instantiation的时候,编译器根据模板为特定的调用数据类型生成一个特殊的函数。

    当工程变得越来越大的时候,程序代码通常会被分割为多个源程序文件。在这种情况下,通常接口(interface)和实现(implementation)是分开的。用一个函数库做例子,接口通常包括所有能被调用的函数的原型定义。它们通常被定义在以.h 为扩展名的头文件 (header file) 中;而实现 (函数的定义) 则在独立的C++代码文件中。

    模板这种类似宏(macro-like) 的功能,对多文件工程有一定的限制:函数或类模板的实现 (定义) 必须与原型声明在同一个文件中。也就是说我们不能再 将接口(interface)存储在单独的头文件中,而必须将接口和实现放在使用模板的同一个文件中。

    回到函数库的例子,如果我们想要建立一个函数模板的库,我们不能再使用头文件(.h) ,取而代之,我们应该生成一个模板文件(template file),将函数模板的接口和实现 都放在这个文件中 (这种文件没有惯用扩展名,除了不要使用.h扩展名或不要不加任何扩展名)。在一个工程中多次包含同时具有声明和实现的模板文件并不会产生链接错误 (linkage errors),因为它们只有在需要时才被编译,而兼容模板的编译器应该已经考虑到这种情况,不会生成重复的代码。

    展开全文
  • Templates

    2020-02-16 21:26:25
    • There are two main types of templates: function templates and class templates Function Templates • Function template: specifies a function where types are a special kind of parameter. template <...

    • There are two main types of templates: function templates and class
    templates

    Function Templates

    • Function template: specifies a function where types are a special kind
    of parameter.

    template <class type> functionName(parameter list) { }
    

    eg:

    #include <iostream>
    #include <string>
    using namespace std;
    template <typename T>
    T const& Max (T const& a, T const& b) {
    return a < b ? b:a;
    } 
    int main () {
    int i = 39;
    int j = 20;
    cout << "Max(i, j): " << Max(i, j) << endl;
    double f1 = 13.5;
    double f2 = 20.7;
    cout << "Max(f1, f2): " << Max(f1, f2) << endl;
    string s1 = "Hello";
    string s2 = "World";
    cout << "Max(s1, s2): " << Max(s1, s2) << endl;
    return 0;
    }
    

    Class Templates

    template <typename T> class XYZ {
    public:
    T myProperty;
    T& myMethod();
    };
    

    • vector is an example of this.

    vector<double> V1;
    vector<MyClass> V2;
    
    展开全文
  • 1.介绍templates

    2019-10-08 07:57:56
    我们现在要计算int和double类型数据的平方,我们就需要2个函数: #include <iostream> using namespace std; int square(int x) { return x*x; } double square(double x) { ......

    我们现在要计算int和double类型数据的平方,我们就需要2个函数:

    #include <iostream>
    using namespace std;
    
    int square(int x) {
        return x*x;
    }
    
    double square(double x) {
        return x*x;
    }
    
    int main() {
        cout << square(5) << endl;    
        cout << square(5.5) << endl;    
        system("pause");
    }

    我们完成了任务,但是是用一种非常不方便的方式,如果还要计算long long和float类型的数据平方,我们还需要添加2个函数。

    这就是我们为什么需要template。使用template我们只需要1个函数,就能完成所有任务。

    #include <iostream>
    using namespace std;
    
    template <class T>
    T square(T x) {
        return x*x;
    }
    
    int main() {
        cout << square<int>(5) << endl;    
        cout << square<double>(5.5) << endl;    
        system("pause");
    }

    注意:在使用template function时候,我们不必明确指示参数类型,编译器能根据函数的参数自动判断类型。 所以 square(5)和square(5.5)也是正确的写法。

    1.template有一个负面效果:code bloat(代码膨胀)

    即使我们只有一个template方法。但是由于square(5)和square(5.5)参数类型不一样,在最终的代码中有2个不同的square函数。如果你使用了很多不同类型参数的

    square函数,最终的代码size,就会比较大。

     

    下面我们来介绍模版类:class template。

    template除了可以用在函数上,也可以在类中使用。编写一个简单的MyVector类。

    #include <iostream>
    using namespace std;
    
    template <class T>
    class MyVector{
        int size;
        T arr[1000];
    public:
        MyVector() : size (0) { }
        void push(T x) {
            arr[size] = x;
            size++;
        }
        void print() const {
            for(int i=0; i<size; i++)
                cout << arr[i] << endl;
        }
    };
    
    /* 在类外部实现函数的写法。
    template <class T>
    void MyVector<T>::push(T x) {
        arr[size] = x;
        size++;
    }
    */
    
    int main() {
        MyVector<int> My;
        My.push(2);
        My.push(5);
        My.push(8);
        My.push(9);
        My.print();
        system("pause");
    }

    2.不同于模板函数,模版类你必须明确指定类型。

     

    现在我们希望square函数能够作用与MyVector类。 思考:

    1.square函数是2个相同类型的相乘,所以我们要重载MyVector类的 *操作符。它的参数是两个MyVector类,返回值是一个新的MyVector类。

    所以函数原型如下:

    template <class T>

    MyVector<T> operator *(const MyVector<T> v1, const MyVector<T> v2)

    2.因为square函数是自己乘自己。所以size一定是相同的。

    获取size: int getSize() const

    获取每个位置的值 T get(int i) const

    然后我们把每个位置的值相乘,返回值放在一个新的MyVector中,返回新的MyVector就完成任务。

    #include <iostream>
    using namespace std;
    
    
    template <class T>
    T square(T x) {
        return x*x;
    }
    
    template <class T>
    class MyVector{
        int size;
        T arr[1000];
    public:
        MyVector() : size (0) { }
        void push(T x) {
            arr[size] = x;
            size++;
        }
        void print() const {
            for(int i=0; i<size; i++)
                cout << arr[i] << endl;
        }
        int getSize() const { return size; }
        T get(int i) const { return arr[i]; }
    };
    
    template <class T>
    MyVector<T> operator *(const MyVector<T> &v1, MyVector<T> &v2) {
        MyVector<T> ret;
        int size = v1.getSize();
        for(int i=0; i<size; i++) {
            T x = v1.get(i) * v2.get(i);
            ret.push(x);
        }
        return ret;
    }
    
    int main() {
        MyVector<int> My;
        My.push(2);
        My.push(5);
        My.push(8);
        My.push(9);
        My.print();
        cout << "After square" << endl;
        MyVector<int> NewVector;
        NewVector = square(My);
        NewVector.print();
        system("pause");
    }

     

    转载于:https://www.cnblogs.com/billxyd/p/7442818.html

    展开全文
  • 模板templates的使用

    2019-02-19 14:55:30
    目录 模板及其渲染 模板查找路径 DTL模板语法 常用的模板标签 DTL常用过滤器 模块结构优化 ...目前市面上有非常多的模板系统,其中最知名最好用的就是DTL和Jinja2。DTL 是 Django Templat...

    目录

    模板及其渲染

    模板查找路径

    DTL模板语法

    常用的模板标签

    DTL常用过滤器

    模块结构优化

    加载静态文件


    模板及其渲染

    视图函数只是直接返回文本,而在实际生产环境中其实很少这样用,因为实际的页面大多是带有样式的HTML代码,这可以让浏览器渲染出非常漂亮的页面。目前市面上有非常多的模板系统,其中最知名最好用的就是DTLJinja2。DTL  是 Django Template Language  三个单词的缩写,也就是Django自带的模板语言。当然也可以配置Django支持Jinja2等其他模板引擎,但是作为Django内置的模板语言,和Django可以达到无缝衔接而不会产生一些不兼容的情况。

    DTL与普通的HTML文件的区别

    DTL模板是一种带有特殊语法的HTML文件,这个HTML文件可以被Django编译,可以传递参数进去,实现数据动态化。在编译完成后,生成一个普通的HTML文件,然后发送给客户端。


    渲染模板:
    渲染模板有多种方式。这里讲下两种常用的方式。

    • render_to_string  :找到模板,然后将模板编译后渲染成Python的字符串格式。最后再通过 HttpResponse  类包装成一个 HttpResponse  对象返回回去。示例代码如下
    from django.template.loader import render_to_string
    from django.http import HttpResponse
    
    def index(request):
        html=render_to_string("index.html")          #渲染成html页面
        return HttpResponse(html)
    
    • 以上方式虽然已经很方便了。但是django还提供了一个更加简便的方式,直接将模板渲染成字符串和包装成 HttpResponse  对象一步到位完成。示例代码如下:
    from django.shortcuts import render
    
    def index(request):
        return render(request,"index.html")

    模板查找路径

    在项目的 settings.py  文件中。有一个 TEMPLATES  配置,这个配置包含了模板引擎的配置,模板查找路径的配置,模板上下文的配置等。模板路径可以在两个地方配置。

    • DIRS  :这是一个列表,在这个列表中可以存放所有的模板路径,以后在视图中使用 render  或者 render_to_string  渲染模板的时候,会在这个列表的路径中查找模板。
    • APP_DIRS  :默认为 True  ,这个设置为 True  后,会在 INSTALLED_APPS  的安装了的 APP  下的 templates  文件加中查找模板。

    查找顺序:比如代码 render(request,"index.html")  。首先会在 DIRS  这个列表中依次查找路径下有没有这个模板,如果有,就返回。如果 DIRS  列表中所有的路径都没有找到,那么会先检查当前这个视图所处的 app  是否已经安装,如果已经安装了,那么就先在当前这个 app  下的 templates  文件夹中查找模板,如果没有找到,那么会在其他已经安装了的 app  中查找。如果所有路径下都没有找到,那么会抛出一个 TemplateDoesNotExist  的异常。

    settings.py中的 INSTALLED_APPS ,我们需要把自己的app加入其中

    INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
    ]

    settings.py 中的 TEMPLATES 配置项

    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',
                ],
            },
        },
    ]

    :如果我们是在命令行下新建的项目,则DIRS这一行是空的,运行的时候会显示如下报错。所以我们需要手动加上DIRS这一行的内容 

    DTL模板语法

    变量:
    模板中可以包含变量, Django  在渲染模板的时候,可以传递变量对应的值过去进行替换。变量的命名规范和 Python  非常类似,只能是阿拉伯数字和英文字符以及下划线的组合,不能出现标点符号等特殊字符。变量需要通过视图函数渲染,视图函数在使用 render  或者 render_to_string  的时候可以传递一个 context  的参数,这个参数是一个字典类型。以后在模板中的变量就从这个字典中读取值的。示例代码如下:

    # profile.html模板代码
    <p>{{ username }}</p>
    
    # views.py代码
    def index(request):
        content={ 'username':'谢公子' }
        # return render(request,"index.html",context=content)
        html=render_to_string("index.html",context=content)
        return HttpResponse(html)

    模板中的变量同样也支持 点(.)  的形式。在出现了点的情况,比如 person.username  ,模板是按照以下方式进行解析的:

    • 如果 person  是一个字典,那么就会查找这个字典的 username这个 key  对应的值。
    • 如果 person  是一个对象,那么就会查找这个对象的 username  属性,或者是 username  这个方法。
    • 如果出现的是 person.1  ,会判断 persons  是否是一个列表或者元组或者任意的可以通过下标访问的对象,如果是的话就取这个列表的第1个值。如果不是就获取到的是一个空的字符串。

    当是一个对象时

    # profile.html模板代码
    <p>{{ person.username }}</p>
    
    # views.py代码
    class Person(object):
        def __init__(self,username):
            self.username=username;
    def index(request):
        p=Person("谢公子")
        content={'person':p}
        return render(request,"index.html",context=content)

    当是一个字典时 

    # profile.html模板代码
    <p>{{ person.username }}</p>    #不能 person['username']
    
    # views.py代码
    def index(request):
        p={'username':'谢公子'}
        content={'person':p}
        return render(request,"index.html",context=content)

    当是列表或者元组时 

    # profile.html模板代码
    <p>{{ person.0 }}</p>    #不能 person['0']
    
    # views.py代码
    def index(request):
        p=[1,2,3,4,5,6]
        content={'person':p}
        return render(request,"index.html",context=content)

    :不能通过中括号的形式访问字典和列表中的值,比如 dict['key'] 和 list[1] 是不支持的!因为使用点(.)语法获取对象值的时候,可以获取这个对象的属性,如果这个对象是一个字典,也可以获取这个字典的值。所以在给这个字典添加key的时候,千万不能和字典中的一些属性重复。比如items,items是字典的方法,那么如果给这个字典添加一个items作为key,那么以后就不能再通过item来访问这个字典的键值对了

    常用的模板标签

    1、 if  else标签: if  标签相当于 Python  中的 if  语句,有 elif  和 else  相对应,但是所有的标签都需要用标签符号 {% %}  进行包裹。 if  标签中可以使用 ==、!=、<、<=、>、>=、in、not
    in、is、is not  等判断运算符。示例代码如下:

    {% if age < 18 %}
            未成年
    {% elif age == 18 %}
            成年人
    {% else %}
            大人 
    {% endif %}   #结束符

    2、 if...in... 标签

    {% if '谢' in names %}
        one
    {% else %}
        two
    {% endif %}

    3、  for...in...  标签: for...in...  类似于 Python  中的 for...in...  。可以遍历列表、元组、字符串、字典等一切可以遍历的对象。示例代码如下:

    #views.py文件中content
    content={'books':['西游记','水浒传','三国演义','红楼梦']}
    
    #index.html中
    {% for book in books %}
        <li>{{ book }} </li>
    {% endfor %}

    如果想要反向遍历,那么在遍历的时候就加上一个 reversed  。示例代码如下:

     {% for book in books reversed %}
         <li> {{ book }} </li>
     {% endfor %}

    遍历字典的时候,需要使用 items  、 keys  和 values  等方法。在 DTL  中,执行一个方法不能使用圆括号的形式。遍历字典示例代码如下:

    #views.py文件中的content
    content = {
            'person':{
                'username':'谢公子',
                'age': 20,
                'sex':'men'
            }
        }
    return render(request, "index.html", context=content)
    
    #index.html文件
    {% for key in person.keys %}
        <li>{{ key }}</li>
    {% endfor %}
        <hr>
    
    {% for value in person.values %}
        <li>{{ value }}</li>
    {% endfor %}
        <hr>
    
    {% for key,value in person.items %}
        <li>{{ key }}:{{ value }} </li>
    {% endfor %}

    在 for  循环中, DTL  提供了一些变量可供使用。这些变量如下:

    • forloop.counter  :当前循环的下标。以1作为起始值。
    • forloop.counter0  :当前循环的下标。以0作为起始值。
    • forloop.revcounter  :当前循环的反向下标值。比如列表有5个元素,那么第一次遍历这个属性是等于5,第二次是4,以此类推。并且是以1作为最后一个元素的下标。
    • forloop.revcounter0  :类似于forloop.revcounter。不同的是最后一个元素的下标是从0开始。
    • forloop.first  :是否是第一次遍历。
    • forloop.last  :是否是最后一次遍历。
    • forloop.parentloop  :如果有多个循环嵌套,那么这个属性代表的是上一级的for循环。
    #views.py文件
    def index(request):
        content = {
            'books':[
                {
                    'name':'三国演义',
                    'author':'罗贯中',
                    'price':199
                },
                {
                    'name':"水浒传",
                    'author':'施耐庵',
                    'price':109
                },
                {
                    'name':"红楼梦",
                    'author':'曹雪芹',
                    'price':100
                },
                {
                    'name':"西游记",
                    'author':"吴承恩",
                    'price':90
                }
            ]
        }
        return render(request, "index.html", context=content)
    #index.html 
    <table>
            <thead>
                <tr>
                    <td>序号1</td>
                    <td>序号2</td>
                    <td>序号3</td>
                    <td>书名</td>
                    <td>作者</td>
                    <td>价格</td>
                </tr>
            </thead>
            <tbody>
                {% for book in books %}
                    {% if forloop.first %}                       {#是否是第一次遍历#}
                        <tr style="background: red;">
                    {% elif forloop.last %}                      {#是否是最后一次遍历#}
                        <tr style="background: pink">
                    {% else %}
                        <tr style="background: yellow;">
                    {% endif %}
                        <td>{{ forloop.counter0 }}</td>          {#当前循环的下标,从0开始#}
                        <td>{{ forloop.counter }}</td>           {#当前循环的下标,从1开始#}
                        <td>{{ forloop.revcounter0 }}</td>       {#反向当前循环的下标,从0开始#}
                        <td>{{ forloop.revcounter }}</td>        {#反向当前循环的下标,从1开始#}
    
                        <td>{{ book.name }}</td>
                        <td>{{ book.author }}</td>
                        <td>{{ book.price }}</td>
                    </tr>
                {% endfor %}
            </tbody>
        </table>

     

    4、  for...in...empty  标签:这个标签使用是一样的,只不过是在遍历的对象如果没有元素的情况下,会执行 empty  中的内容。示例代码如下:

    #views.py文件中的content
    content={'comment':"" }
    
    #index.html文件
    <ul>
        {% for comment in comments %}
             <li>{{ comment }}</li>
        {% empty %}
             <li>没有任何评论</li>
        {% endfor %}
    </ul>

    5、 with  标签:在模版中定义变量。有时候一个变量访问的时候比较复杂,那么可以先把这个复杂的变量缓存到一个变量上,以后就可以直接使用这个变量就可以了。示例代码如下:

    context = {
        "persons": ["张三","李四"]
    }
    {% with li=persons.0  si=persons.1%}
        {{ li }},{{ si }}
    {% endwith %}

     
    注:在 with  语句中定义的变量,只能在 {%with%}{%endwith%}  中使用,不能在这个标签外面使用。定义变量的时候,不能在等号左右两边留有空格。比如 {% with lisi = persons.1%}  是错误的。
    还有另外一种写法同样也是支持的:

    {% with persons.0 as li %}
        {{ li }},{{ si }}
    {% endwith %}

    6、  url  标签:在模版中,我们经常要写一些 url  ,比如某个 a  标签中需要定义 href  属性。当然如果通过硬编码的方式直接将这个 url  写死在里面也是可以的。但是这样对于以后项目维护可能不是一件好事。因此建议使用这种反转的方式来实现,类似于 django  中的 reverse  一样。示例代码如下:

    <a href="{% url 'book:list' %}">图书列表页面</a>

    如果 url  反转的时候需要传递参数,那么可以在后面传递。但是参数分位置参数和关键字参数。位置参数和关键字参数不能同时使用。示例代码如下:

    # path部分
    path('detail/<book_id>/',views.book_detail,name='detail')
    
    # url反转,使用位置参数
    <a href="{% url  'book:detail'  1  %}">图书id</a>
    
    # url反转,使用关键字参数
    <a href="{% url  'book:detail'  book_id=1  %}">图书id</a>

    如果想要在使用 url  标签反转的时候要传递查询字符串的参数,那么必须要手动在在后面添加。示例代码如下:

    <a href="{% url 'book:detail' book_id=1 %}?page=2">图书详情页面</a>
    
    #views.py中
    def book_detail(request,book_id):
        page=request.GET.get("page")
        text="书籍id是:%s,页面是:%s " % (book_id,page)
        return HttpResponse(text)

    如果需要传递多个参数,那么通过空格的方式进行分隔。示例代码如下:

    <a href="{% url 'book:detail' book_id=1  page=2 %}">图书详情页面</a>
    
    #views.py中
    def book_detail(request,book_id,page):
        text="书籍id是:%s,页面是:%s " % (book_id,page)
        return HttpResponse(text)

    7、 spaceless  标签:移除html标签中的空白字符。包括空格、tab键、换行等。示例代码如下:

    {% spaceless %}
    <p>
    <a href="foo/">Foo</a>
    </p>
    {% endspaceless %}

    那么在渲染完成后,会变成以下的代码:

    <p><a href="foo/">Foo</a></p>

    spaceless  只会移除html标签之间的空白字符。而不会移除标签与文本之间的空白字符。看以下代码:

    {% spaceless %}
    <strong>
    Hello
    </strong>
    {% endspaceless %}

    这个将不会移除 strong  中的空白字符。
    8、 autoescape  标签:开启和关闭这个标签内元素的自动转义功能。自动转义是可以将一些特殊的字符。比如 <  转义成 html  语法能识别的字符,比如 <  会被转义成 &lt;  ,而 >  会被自动转义成 &gt;  。模板中默认是已经开启了自动转义的。 autoescape 的示例代码如下:

    # 传递的上下文信息
    context = {
        "info":"<a href='www.baidu.com'>百度</a>"
    }
    # 模板中开启自动转义
    {% autoescape on %}
    {{ info }}
    {% endautoescape %}

    那么就会显示成一个普通的字符串

    如果把 on  成 off  ,那么就会显示百度的一个超链接。
    示例代码如下:

    {% autoescape off %}
    {{ info }}
    {% endautoescape %}

    9、verbatim  标签:默认在 DTL  模板中是会去解析那些特殊字符的。比如 {%  和 %}  以及 {{  等。如果你在某个代码片段中不想使用 DTL  的解析引擎。那么你可以把这个代码片段放在 verbatim  标签中。示例代码下:

    {% verbatim %}
    {{if dying}}Still alive.{{/if}}
    {% endverbatim %}

    10、更多标签请参考官方文档: https://docs.djangoproject.com/en/2.0/ref/templates/builtins/

    DTL常用过滤器

    在模版中,有时候需要对一些数据进行处理以后才能使用。一般在 Python  中我们是通过函数的形式来完成的。而在模版中,则是通过过滤器来实现的。过滤器使用的是 |  来使用。比如使用 add  过滤器,那么示例代码如下:

    {{ value|add:"2" }}

    在开发中常用的过滤器:

    add
    将传进来的参数添加到原来的值上面。这个过滤器会尝试将 值  和 参数  转换成整形然后进行相加。如果转换成整形过程中失败了,那么会将 值  和 参数  进行拼接。如果是字符串,那么会拼接成字符串,如果是列表,那么会拼接成一个列表。示例代码如下:

    {{ value|add:"2" }}

    如果 value  是等于4,那么结果将是6。如果 value  是等于一个普通的字符串,比如 abc  ,那么结果将是 abc2  。 add  过滤器的源代码如下:

    def add(value, arg):
    """Add the arg to the value."""
    try:
        return int(value) + int(arg)
    except (ValueError, TypeError):
        try:
            return value + arg
    except Exception:
        return ''

    cut
    移除值中所有指定的字符串。类似于 python  中的 replace(args,"")  。示例代码如下:

    {{ value|cut:"xie" }}

    以上示例将会移除 value  中所有的空格字符。 cut  过滤器的源代码如下:

    def cut(value, arg):
    """Remove all values of arg from the given string."""
        safe = isinstance(value, SafeData)
        value = value.replace(arg, '')
        if safe and arg != ';':
            return mark_safe(value)
        return value

    date
    将一个日期按照指定的格式,格式化成字符串。示例代码如下:
    # 数据

    context = {
        "birthday": datetime.now()
    }

    # 模版

    {{ birthday|date:"Y/m/d" }}

    那么将会输出 2018/02/01  。其中 Y  代表的是四位数字的年份, m  代表的是两位数字的月份, d  代表的是两位数字的日。
    还有更多时间格式化的方式。见下表。
    格式字符 描述 示例

    • Y 四位数字的年份 2018
    • m 两位数字的月份 01-12
    • n 月份,1-9前面没有0前缀 1-12
    • d 两位数字的天 01-31
    • j 天,但是1-9前面没有0前缀 1-31
    • g 小时,12小时格式的,1-9前面没有0前缀 1-12
    • h 小时,12小时格式的,1-9前面有0前缀 01-12
    • G 小时,24小时格式的,1-9前面没有0前缀 1-23
    • H 小时,24小时格式的,1-9前面有0前缀 01-23
    • i 分钟,1-9前面有0前缀 00-59
    • s 秒,1-9前面有0前缀 00-59

    default
    如果值被评估为 False  。比如 [ ]  , ""  , None  , {}  等这些在 if  判断中为 False  的值,都会
    使用 default  过滤器提供的默认值。示例代码如下:

    {{ value|default:"nothing" }}

    如果 value  是等于一个空的字符串。比如 ""  ,那么以上代码将会输出 nothing  。
    default_if_none
    如果值是 None  ,那么将会使用 default_if_none  提供的默认值。这个和 default  有区别, default  是所有被评估为 False  的都会使用默认值。而 default_if_none  则只有这个值是等于 None  的时候才会使用默认值。示例代码如下:

    {{ value|default_if_none:"nothing" }}

    如果 value  是等于 ""  也即空字符串,那么以上会输出空字符串。如果 value  是一个 None  值,以上代码才会输出 nothing  。
    first
    返回列表/元组/字符串中的第一个元素。示例代码如下:

    {{ value|first }}

    如果 value  是等于 ['a','b','c']  ,那么输出将会是 a  。
    last
    返回列表/元组/字符串中的最后一个元素。示例代码如下:

    {{ value|last }}

    如果 value  是等于 ['a','b','c']  ,那么输出将会是 c  。
    floatformat
    使用四舍五入的方式格式化一个浮点类型。如果这个过滤器没有传递任何参数。那么只会在小数点
    后保留一个小数,如果小数后面全是0,那么只会保留整数。当然也可以传递一个参数,标识具体
    要保留几个小数。
    1. 如果没有传递参数:

    | value | 模版代码 | 输出 | | --- | --- | --- | | 34.23234 |  {{ value\|floatformat }}  | 34.2 | |34.000 |  {{ value\|floatformat }}  | 34 | | 34.260 |  {{ value\|floatformat }}  | 34.3 |

    2. 如果传递参数:

    | value | 模版代码 | 输出 | | --- | --- | --- | | 34.23234 |  {{value\|floatformat:3}}  |34.232 | |34.0000 |  {{value\|floatformat:3}}  | 34.000 | | 34.26000 |  {{value\|floatformat:3}}  |34.260 |

    join
    类似与 Python  中的 join  ,将列表/元组/字符串用指定的字符进行拼接。示例代码如下:

    {{ value|join:"/" }}

    如果 value  是等于 ['a','b','c']  ,那么以上代码将输出 a/b/c  。
    length
    获取一个列表/元组/字符串/字典的长度。示例代码如下:

    {{ value|length }}

    如果 value  是等于 ['a','b','c']  ,那么以上代码将输出 3  。如果 value  为 None  ,那么以上将返回 0  。
    lower
    将值中所有的字符全部转换成小写。示例代码如下:

    {{ value|lower }}

    如果 value  是等于 Hello World  。那么以上代码将输出 hello world  。
    upper
    类似于 lower  ,只不过是将指定的字符串全部转换成大写。
    random
    在被给的列表/字符串/元组中随机的选择一个值。示例代码如下:

    {{ value|random }}

    如果 value  是等于 ['a','b','c']  ,那么以上代码会在列表中随机选择一个。
    safe
    标记一个字符串是安全的。也即会关掉这个字符串的自动转义。示例代码如下:

    {{value|safe}}

    如果 value  是一个不包含任何特殊字符的字符串,比如 <a>  这种,那么以上代码就会把字符串正常的输入。如果 value  是一串 html  代码,那么以上代码将会把这个 html  代码渲染到浏览器中。
    slice
    类似于 Python  中的切片操作。示例代码如下:

    {{ some_list|slice:"2:" }}

    以上代码将会给 some_list  从 2  开始做切片操作。
    stringtags
    删除字符串中所有的 html  标签。示例代码如下:

    {{ value|striptags }}

    如果 value  是 <strong>hello world</strong>  ,那么以上代码将会输出 hello world  。
    truncatechars
    如果给定的字符串长度超过了过滤器指定的长度。那么就会进行切割,并且会拼接三个点来作为省略号。示例代码如下:

    {{ value|truncatechars:5 }}

    如果 value  是等于 北京欢迎您~  ,那么输出的结果是 北京...  。可能你会想,为什么不会 北京欢迎您...  呢。因为三个点也占了三个字符,所以 北京  +三个点的字符长度就是5。
    truncatechars_html
    类似于 truncatechars  ,只不过是不会切割 html  标签。示例代码如下:

    {{ value|truncatechars:5 }}

    如果 value  是等于 <p>北京欢迎您~</p>  ,那么输出将是 <p>北京...</p>  。

    模块结构优化

    引入模版
    有时候一些代码是在许多模版中都用到的。如果我们每次都重复的去拷贝代码那肯定不符合项目的规范。一般我们可以把这些重复性的代码抽取出来,就类似于Python中的函数一样,以后想要使用这些代码的时候,就通过 include  包含进来。这个标签就是 include  。示例代码如下:

    # header.html
    <p>我是header</p>
    
    # footer.html
    <p>我是footer</p>
    
    # main.html
    {% include 'header.html' %}
    <p>我是main内容</p>
    {% include 'footer.html' %}

    include  标签寻找路径的方式。也是跟 render  渲染模板的函数是一样的。
    默认 include  标签包含模版,会自动的使用主模版中的上下文,也即可以自动的使用主模版中的变量。如果想传入一些其他的参数,那么可以使用 with  语句。示例代码如下:

    # header.html
    <p>用户名:{{ username }}</p>
    # main.html
    {% include "header.html" with username='huangyong' %}

    模板继承:
    在前端页面开发中。有些代码是需要重复使用的。这种情况可以使用 include  标签来实现。也可以使用另外一个比较强大的方式来实现,那就是模版继承。模版继承类似于 Python  中的类,在父类中可以先定义好一些变量和方法,然后在子类中实现。模版继承也可以在父模版中先定义好一些子模版需要用到的代码,然后子模版直接继承就可以了。并且因为子模版肯定有自己的不同代码,因此可以在父模版中定义一个block接口,然后子模版再去实现。以下是父模版的代码:

    这个模版,我们取名叫做 base.html  ,定义好一个简单的 html  骨架,然后定义好两个 block  接口,让子模版来根据具体需求来实现。

    {% load static %}
    <!DOCTYPE html>
    <html lang="en">
    <head>
    <link rel="stylesheet" href="{% static 'style.css' %}" />
    <title>{% block title %}我的站点{% endblock %}</title>
    </head>
    <body>
    <div id="sidebar">
    {% block sidebar %}
    <ul>
    <li><a href="/">首页</a></li>
    <li><a href="/blog/">博客</a></li>
    </ul>
    {% endblock %}
    </div>
    <div id="content">
    {% block content %}{% endblock %}
    </div>
    </body>
    </html>

    子模板然后通过 extends  标签来实现,示例代码如下:

    {% extends "base.html" %}
    {% block title %}博客列表{% endblock %}
    {% block content %}
    hello,word!
    {% endblock %}

    需要注意的是:extends标签必须放在模版的第一行。子模板中的代码必须放在block中,否则将不会被渲染。如果在某个 block  中需要使用父模版的内容,那么可以使用 {{block.super}}  来继承。比如上例, {%block title%}  ,如果想要使用父模版的 title  ,那么可以在子模版的 title block  中使用 {{ block.super }}  来实现。在定义 block  的时候,除了在 block  开始的地方定义这个 block  的名字,还可以在 block  结束的时候定义名字。比如 {% block title %}{% endblock title %}  。这在大型模版中显得尤其有用,能让你快速的看到 block  包含在哪里。

    加载静态文件

    在一个网页中,不仅仅只有一个 html  骨架,还需要 css  样式文件, js  执行文件以及一些图片等。因此在 DTL  中加载静态文件是一个必须要解决的问题。在 DTL  中,使用 static  标签来加载静态文件。要使用 static  标签,首先需要 {% load static %}  。加载静态文件的步骤如下:
    1、首先确保 django.contrib.staticfiles  已经添加到 settings.INSTALLED_APPS  中,默认是添加的了。
    2、确保在 settings.py  中设置了 STATIC_URL,默认是添加的了  。
    3、在已经安装了的 app  下创建一个文件夹叫做 static  ,然后再在这个 static  文件夹下创建一个当前 app  的名字的文件夹,再把静态文件放到这个文件夹下。例如你的 app  叫做 polls  ,有一个静态文件叫做 style.css  ,那么路径为polls/static/polls/style.css  。(为什么在 app  下创建一个 static  文件夹,还需要在这个 static  下创建一个同 app  名字的文件夹呢?原因是如果直接把静态文件放在 static  文件夹下,那么在模版加载静态文件的时候就是使用style.css  ,如果在多个 app  之间有同名的静态文件,这时候可能就会产生混淆。而在 static  文件夹下加了一个同名 app  文件夹,在模版中加载的时候就是使用 app/style.css ,这样就可以避免产生混淆。)

    注:这里已安装app是指在settings.py文件中的INSTALLED_APPS中需要加上我们的polls。
    4、如果有一些静态文件是不和任何 app  挂钩的。那么可以在 settings.py  中添加 STATICFILES_DIRS  ,以后 DTL  就会在这个列表的路径中查找静态文件。比如可以设置为:

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

    5、在模版中使用 load  标签加载 static  标签。比如要加载在项目的 static  文件夹下的 style.css  的文件。那么示例代码如下:

    {% load static %}
    <link rel="stylesheet" href="{% static 'polls/style.css' %}">
    <img src="{% static 'polls/1.jpg' %}" alt="">

    6、如果不想每次在模版中加载静态文件都使用 load  加载 static  标签,那么可以
    在 settings.py  中的 TEMPLATES/OPTIONS  添加 

     'builtins':['django.templatetags.static']

    这样以后在模版中就可以直接使用 static  标签,而不用手动的 load  了。
    7. 如果没有在 settings.INSTALLED_APPS  中添加 django.contrib.staticfiles  。那么我们就需要手动的将请求静态文件的 url  与静态文件的路径进行映射了。示例代码如下:

    from django.conf import settings
    from django.conf.urls.static import static
    urlpatterns = [   # 其他的url映射  ] + static(settings.STATIC_URL,document_root=settings.STATIC_ROOT)

     

    展开全文
  • templates模板文件

    2018-09-13 20:34:03
    templates 该目录本身没有,如果我们需要使用,需要我们自己创建,该目录名通常为templates 1、创建位置: 1.直接在应用下创建该目录,应用下的html模板,能直接在应用下的views中使用,一般也只给自己的应用使用 2....

    templates 该目录本身没有,如果我们需要使用,需要我们自己创建,该目录名通常为templates

    1、创建位置:

    1.直接在应用下创建该目录,应用下的html模板,能直接在应用下的views中使用,一般也只给自己的应用使用

    2.直接在项目下创建该目录,在项目下创建的改目录,所有的应用中的views都可以方便的使用

     3.若果是项目下的templates目录,需要配置才可以使用

     配置:1.在setting的TEMPLATES中配置

                 'DIRS': [os.path.join(BASE_DIR,'templates')],


                          2.项目不能识别templates为模板目录,需要将该目录标记成模板目录才可以使用
                             标记:  templates目录右键 ---- mark Directory  as ---- template Folder看到目录变成紫色即可

    注:如果遇到template不能识别,重新做以上操作

    2、模板语法

    1、变量

               1.变量通常在views中定义,然后传递给模板,模板中直接使用就可以
               2.使用变量: {{ 变量名 }}    用两个大括号括起来
               3.注意: 如果模板板中的变量没有定义就使用了, 模板不会报错,当作空使用

    2、语法

    1、“.”语法

    1.1、 . 可以用来调用属性 
              格式:  对象名.属性名  
    1.2.、.  可以用来调用方法
             格式: 对象名.方法名    注意不加()
    1.3、如果. 用在集合(list,tuple...)的 后面,可以连接索引, 可以获取索引位置的值 
             格式: 集合.索引    相当于python的:  集合[索引]
    1.4、如果 . 用在字典的后面, 可以连接 可以,可以获取key对应的值
            格式: 字典.key    相当于python的:  字典[key]

    2、for语句

    2.1、for 循环

         {% for 变量名 in 集合名%}

           循环体

          {% endfor %}

    2.2、

            {% for 变量名 in 集合名 %}
              循环体
            {% empty %}
               如果集合为空,应该显示的内容
            {% endfor %}

    2.3、forloop  循环的技术器
           forloop.counter  从1开始计数
           forloop.counter0  从0开始计数
           forloop.first  是否是第一个数据
           forloop.last  是否是最后一个数据
           forloop.revcounter  从1开始计数, 倒着计数,即最大数是第一个
           forloop.revcounter0  从0开始计数, 倒着计数,即最大数是第一个

    3、判断语句

    3.1、if语句
           {% if 判断表达式1 %}
                    如果满足条件1就执行表达式1
           {% elif 判断表达式2 %}
                        如果满足条件2就执行表达式2 
            {% else %}    
                       否则执行表达式3
            {% endif %}

     注:elif与else可以省略

    3.2、判断2个值是否相等

    {% ifequal valu1 value2 %}
             如果value1 等于value2执行表达式

    {% endifequal %}
    注意: 当value1与value2值相等,且类型也一样的时候才成立

    3.3、比较运算符

    >    <    >=    <=     ==    !=

    比较运算符可用在if语句中作判断使用

    4、运算方法

    4.1、加法/减法  {% 值1|add值2 %}    值1 + 值2    注:当值2为负数时,即为减法

    4.2、乘法/除法  {% widthratio value 分母 分子 %}    注:格式为: value * 分子 / 分母

    4.3、整除   格式:{{ value|divisibleby:值  }}    value是否能整除 值

    4.4、大小写转换 
             转换成小写:{{ value|lower }}
             转换成大写:{{ value|upper }}

    4.5、字符串拼接: {{ 集合|join:"拼接的字符" }}

    5、转义字符

    5.1、在模板中  使用{{ 变量|safe }}    是得变量的字符串中的html标签生效

    5.2、使用 autoescape 
      ①    {% autoescape on %}
              {#     这里面的内容就是不生效的HTML字符串#}
              {{ strHtml }}
              {% endautoescape %}

       ②   {% autoescape off %}
              {#     这里面的内容就是可以生效的HTML字符串#}
              {{ 变量 }}                                                                                                                                                                                              {% endautoescape %}

    6、模板的继承

    6.1、继承

    在子模板首行写入{% extends '父模板路基' %} ,即可继承父模板

    例:

    6.2、在父模板中为子模板预留位置

    6.2.1、在父模板中预留位置

    在需要填充子模板内容的地方 写上 :

    {% block 坑的名字  %}

        父模板可在此写入内容

    {% endblock %}

    6.2.2、在子模板中将数据填入预留的位置

    {% block 坑的名字  %}

           填充的内容

    {% endblock %}

    注:子模板填充内容会将父模板的内容覆盖

    6.2.3、在子模板填充内容的同时希望保留父模板的内容

    在填充内容的首行加上 {{ block.super }}

    例:{% block head %}
                {{ block.super }}
                <h1>xxxx</h1>
             {% endblock %}

    6.3、将多个分散的html使用include合并成一个完整的html

    格式:{% include 'html文件' %}

    例:将head.html、body.html、foot.html三个html文件合并

    head.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        这是头
    </body>
    </html>

    bady.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <div style="height: 200px; width: 200px; background: pink">
        身子
    </div>
    </body>
    </html>

    foot.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        这是臭脚丫子
    </body>
    </html>

    将三者合并:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    {#    将零散的html拼接成一个完整的html #}
        {% include 'head.html' %}
        {% include 'bannar.html' %}
        {% include 'foot.html' %}
    </body>
    </html>

    效果图:

    7、模板的简单加载原理
    模板的加载过程
    def loadTem(request):
       # 7.1、先将模板加载到views函数中
        template = loader.get_template("HTML文件")
        # 7.2、把数据给模板,并转换成html形式的字符串
        htmlData = template.render(context={"content":"内容xxxxxx"})
        # 7.3、把数据作为相应体,给客户端   html本质就是字符串
         return  HttpResponse(htmlData)

    展开全文
  • 模板(Templates)是ANSI-C++ 标准中新引入的概念。如果你使用的 C++ 编译器不符合这个标准,则你很可能不能使用模板。     函数模板( Function templates) 模板(Templates)使得我们可以生成通用的...
  • 和上一种方法一样,首先 添加路由,来到urls添加, 然后到 views去写视图函数 ,不一样的是templates 的路径不一样了 所以需要添加templates的路径, 到 settings中找到TEMPLATES 中的DIRS 这个列表 在里面添加 os. ...
  • C++ Templates 第二版英文版的AZW3格式, 适用于kindle阅读. Templates are among the most powerful features of C++, but they are too often neglected, misunderstood, and misused. C++ Templates: The ...
  • Templates are among the most powerful features of C++, but they remain misunderstood and underutilized, even as the C++ language and development community have advanced. In C++ Templates, Second Editi...
  • 目的:最近项目使用的是MVP设计模式,而采用这种模式会造成很多模板化的代码,如果每个新的模块都要把这些代码敲一边,是件非常痛苦的事情,做为懒癌深度患者,我们可以根据我们日常工作的需要,来制作 Templates ...
  • Templates are among the most powerful features of C++, but they remain misunderstood and underutilized, even as the C++ language and development community have advanced. In C++ Templates, Second ...
  • templates下的资源是不能直接访问的,没有开放访问权限。这是因为templates文件夹,是放置模板文件的,因此需要视图解析器来解析它。所以必须通过服务器内部进行访问,也就是要走控制器  ->  服务 &...
  • IDEA的Live Templates代码模板 一、简介 本着“复杂的事情简单化,简单的事情标准化”的做事基本指导原则,我们发现日常编码中,有大量的代码可以提炼出模板进而简单化/自动化。 1.可以大大提高编码效率; 2.统一了...
  • Live Templates的介绍   实时代码模板只是为了让我们更加高效的写一些固定模式的代码,以提高编码效率,同时也可以增加个性化 调用常规的实时代码模板主要是通过两个快捷键:Tab 和 Ctrl + J。虽然 IntelliJ ...
  • 最近一直学习django框架,在开始学习模板时,需要在自己的app文件夹下建立一个templates文件夹,里面用来存放html文件,但是楼主粗心大意,开始建立了一个template文件夹,就是因为少了一个s导致模板导入不成功,...
  • C++ Templates中文版

    2020-07-30 23:31:23
    《C++ Templates中文版》陈伟柱,人民邮电出版社,扫描版。
  • Django中templates的使用

    2018-09-13 19:23:36
    1、templates用来放置模板文件 1、templates 该目录本身没有,如果我们需要使用,需要我们自己创建,该目录名通常为templates 2、创建位置: 1、直接在应用下创建该目录,应用下的html模板,能直接在应用下的views...
  • 作者,时间等信息,以及通过Action template添加注释,对于平时经常使用IDEA发布开源项目或Demo实例的人,这个还是挺有用的,在这里介绍两种实现方法,上面的实现方式是通过IDEA的Live Templates实现的,先介绍第一种...
  • templates目录 前面了解过了在Django中HTML文件可以放在项目目录下的templates目录下,这个目录名字翻译过来就是模板的意思,对这一情况不太明白。 实际上这个目录下理应放的正是一种HTML模板,对于网站而言,很多...
  • springboot整合了springmvc的拦截功能。拦截了所有的请求。默认放行的资源是:resources/static/ 目录下所有静态资源。(不走controller控制器就...如果你想将templates变得像static一样,就可以在application.properti
1 2 3 4 5 ... 20
收藏数 172,267
精华内容 68,906
关键字:

templates