django 订阅
《被解救的姜戈》是由美国韦恩斯坦国际影业公司出品的西部动作片,由昆汀·塔伦蒂诺执导,杰米·福克斯、克里斯托弗·瓦尔兹、莱昂纳多·迪卡普里奥、塞缪尔·杰克逊、凯丽·华盛顿领衔主演。该片讲述了德国医生金·舒尔茨将黑奴姜戈从奴隶贩子手里解救,并且帮助姜戈救出他的妻子。该片于2012年12月25日在美国上映,2013年5月12日在中国上映 [1]  。 展开全文
《被解救的姜戈》是由美国韦恩斯坦国际影业公司出品的西部动作片,由昆汀·塔伦蒂诺执导,杰米·福克斯、克里斯托弗·瓦尔兹、莱昂纳多·迪卡普里奥、塞缪尔·杰克逊、凯丽·华盛顿领衔主演。该片讲述了德国医生金·舒尔茨将黑奴姜戈从奴隶贩子手里解救,并且帮助姜戈救出他的妻子。该片于2012年12月25日在美国上映,2013年5月12日在中国上映 [1]  。
信息
主    演
杰米·福克斯,莱昂纳多·迪卡普里奥,克里斯托弗·瓦尔兹,凯莉·华盛顿,塞缪尔·杰克逊
上映时间
2012年12月25日(美国)
色    彩
彩色
制片成本
1亿美元
导    演
昆汀·塔伦蒂诺
其它译名
被解放的迪亚戈、黑杀令(台湾)、决杀令(香港)
类    型
西部、剧情、冒险、动作
分    级
USA:R
出品公司
韦恩斯坦国际影业公司、哥伦比亚电影公司(美国)
拍摄日期
2012年1月
中文名
被解救的姜戈
片    长
165分钟
发行公司
韦恩斯坦国际影业公司(美国)
imdb编码
tt1853728
外文名
Django Unchained
编    剧
昆汀·塔伦蒂诺
对白语言
英语、德语、法语、意大利语
出品时间
2012年
制片人
雷吉纳·哈德林、皮拉尔·萨富隆
制片地区
美国
数据分析简介
收起全文
精华内容
参与话题
问答
  • Django实例 —— 搭建一个博客(超详细)

    万次阅读 多人点赞 2018-12-07 12:50:22
    # django-admin startproject 项目名称 django-admin startproject mysite  进入mysite目录,工程目录结构默认如图 与项目同名的目录,此处为mysite,包含项目的配置文件  manage.py : Django 项目里面的...

    创建mysite工程项目,创建项目的命令如下:

    # django-admin startproject 项目名称
    django-admin startproject mysite

     进入mysite目录,工程目录结构默认如图

    与项目同名的目录,此处为mysite,包含项目的配置文件 

    • manage.py : Django 项目里面的工具,是项目运行的入口,指定配置文件路径,通过它可以调用django shell和数据库等。
    • setting.py : 包含了项目的默认配置,包括数据库信息,调试标志以及其他一些工作的变量,是项目的整体配置文件。
    • urls.py : 负责把URL模式映射到应用程序,是项目的URL配置文件。
    • init.py是一个空文件,作用是这个目录test1可以被当作包使用。
    • wsgi.py是项目与WSGI兼容的Web服务器入口。

    运行服务

    • 运行服务器命令如下:
    # python manage.py runserver ip:端口
    python manage.py runserver
    
    • 可以不写ip
    • 默认端口为8000
    • 服务器成功启动后如下图

    浏览器访问 http://127.0.0.1:8000/,运行结果如图所示

     

    创建blog应用

    python manage.py startapp blog

    blog目录结构如图所示

     

    • init.py是一个空文件,表示当前目录blog可以当作一个python包使用
    • tests.py文件用于开发测试用例,在实际开发中会有专门的测试人员,这个事情不需要我们来做

    安装添加应用

    • 应用创建成功后,需要安装才可以使用
    • 在mysite/settings.py文件中INSTALLED_APPS下添加应用的名称就可以完成安装
    • 在元组列表末尾中添加一个新的项,当前示例为blog

     

     

    设计模型

    现在打开blog目录下的models.py文件,这是定义blog数据结构的地方。

    from django.db import models
    
    # Create your models here.
    class BlogPost(models.Model):
        # 博客标题
        title=models.CharField(max_length=150)
        # 博客正文
        body=models.TextField()
        # 博客创建时间
        timestamp=models.DateTimeField()

    创建BlogPost博客类,继承django.db.models.Model父类,定义3个变量:title(博客标题)、body(博客正文)、timestamp(博客创建时间)

    迁移

    • 默认采用sqlite3数据库
    • 迁移前目录结构如下图:

    • 迁移由两步完成
      • 1.生成迁移文件:根据模型类生成创建表的语句
      • 2.执行迁移:根据第一步生成的语句在数据库中创建表
    • 生成迁移文件命令如下:
    python manage.py makemigrations

     

    • 执行迁移命令如下:
    python manage.py migrate

    • 迁移后目录结构如下图:

    管理界面本地化

    • 本地化是将显示的语言、时间等使用本地的习惯,这里的本地化就是进行中国化,中国大陆地区使用简体中文,时区使用亚洲/上海时区,注意这里不使用北京时区表示
    • 打开mysite/settings.py文件,找到语言编码、时区的设置项,将内容改为如下
    LANGUAGE_CODE = 'zh-Hans'
    TIME_ZONE = 'Asia/Shanghai'

    创建管理员

    • 创建管理员的代码如下,按提示输入用户名、邮箱、密码
    python manage.py createsuperuser

    • 启动服务器
    python manage.py runserver
    • 打开浏览器,在地址栏中输入如下地址后回车
    http://127.0.0.1:8000/admin
    • 输入前面创建的用户名、密码完成登录

    • 登录成功后界面如下,但是并没有BlogPost的管理入口,接下来进行增加BlogPost的管理入口操作

     

    注册模型类

    • 登录后台管理后,默认没有我们创建的应用中定义的模型类,需要在自己应用中的admin.py文件中注册,才可以在后台管理中看到,并进行crud操作
    • 打开booktest/admin.py文件,编写如下代码
    from django.contrib import admin
    from blog.models import BlogPost
    
    admin.site.register(BlogPost)
    
    • 到浏览器中刷新页面,可以看到模型类BlogPost的管理了

     

    • 点击类名称“BookInfo”可以进入列表页,

    • 在列表页中点击“增加”可以进入增加页,Django会根据模型类的不同,生成不同的表单控件,按提示填写表单内容后点击"保存",完成数据创建,创建成功后返回列表页

     自定义管理页面

    • Django提供了自定义管理页面的功能,比如列表页要显示哪些值
    • 打开mysite/admin.py文件,自定义类,继承自admin.ModelAdmin类
    • 属性list_display表示要显示哪些属性

    自定义管理页面之前

    打开mysite/admin.py文件,自定义类,继承自admin.ModelAdmin类

    from django.contrib import admin
    from blog.models import BlogPost
    
    class BlogPostAdmin(admin.ModelAdmin):
        # pk:索引
        # 属性list_display表示要显示哪些属性
        list_display = ['pk','title','body','timestamp']
    
    admin.site.register(BlogPost,BlogPostAdmin)
    

     自定义管理界面之后

    创建blog的公共部分

     从django的角度来看,一个页面具有3个典型的组件

    • templates (模板) :模板负责把传递进来的信息显示出来
    • view (视图) :视图负责从数据库获取需要显示的数据
    • url (URL模式) :URL模式负责把收到的请求与视图函数匹配,有时也会向视图传递一些参数

    创建模板

    在blog项目中创建templates文件夹目录(mysite/blog/templates/)在目录中创建模板文件archive.html,代码如下

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    {% for post in posts %}
        <h2>{{ post.title }}</h2>
        <p>{{ post.timestamp }}</p>
        <p>{{ post.body }}</p>
    {% endfor %}
    </body>
    </html>

    设置模板路径,打开mysite/settings.py文件,修改设置

    创建视图函数

    打开mysite/blog/views.py文件

    from django.shortcuts import render
    from blog.models import BlogPost
    
    def archive(request):
        posts=BlogPost.objects.all()
        return render(request, 'archive.html', {'posts': posts})

    posts=BlogPost.objects.all()  :获取数据库里面所有的BlogPost对象

    return render(request, 'archive.html', {'posts': posts})  :渲染模板,数据是一个字典型的对象(键值对)

    创建blog的URL模式

    在mysite/urls.py文件中添加blog的URL

    from django.contrib import admin
    from django.urls import path
    from django.conf.urls import include,url
    urlpatterns = [
        url(r'^blog/',include('blog.urls')),
        path('admin/', admin.site.urls),
    ]
    

    在mysite/blog/目录下创建urls.py文件

    from django.conf.urls import url
    from . import views
    
    urlpatterns=[
        url(r'^archive$',views.archive),
    ]

    再次启动服务python manage.py runserver,访问http://127.0.0.1:8000/blog/archive

    页面如图所示

     这样一个简单的博客就搭建完成了

    展开全文
  • Django入门(一)

    千次阅读 2019-07-11 14:16:10
    跟书《python编程:从入门到实践》,学习用Django编写名为“学习笔记”的Web应用程序。 建立项目 项目路径:learning_log 安装python3.7: 此处省略,参考这里:...

    跟书《python编程:从入门到实践》,学习用Django编写名为“学习笔记”的Web应用程序。

    建立项目

    项目路径:learning_log

    • 安装python3.7:

    此处省略,参考这里:https://blog.csdn.net/miss1181248983/article/details/90779786

    • 建立虚拟环境:
    # cd /opt/
    
    # mkdir learning_log && cd learning_log
    
    # python -m venv 11_env
    
    • 激活虚拟环境:
    # source ll_env/bin/activate
    

    进入虚拟环境终端。

    要停止使用虚拟环境,可执行:

    # deactivate
    
    • 安装Django:
    # pip3 install Django
    

    Django仅在虚拟环境处于活动状态时才可用。

    下面与书中不同部分是由于Django版本更新导致,照着操作即可。本人Django版本为2.2.3,可通过命令python -m django --version查看Django版本。

    • 在Django中创建项目:
    # django-admin.py startproject learning_log .
    
    # ls
    learning_log  ll_env  manage.py
    
    # ls learning_log/
    __init__.py  settings.py  urls.py  wsgi.py
    

    Django新建了一个名为learning_log的目录。它还创建了一个名为manage.py的文件,这是一个简单的程序,它接受命令并将其交给Django的相关部分去运行。

    目录learning_log包含4个文件,其中最重要的是settings.pyurls.pywsgi.py

    文件settings.py指定Django如何与你的系统交互以及如何管理项目。
    文件urls.py告诉Django应创建哪些网页来响应浏览器请求。
    文件wsgi.py帮助Django提供它创建的文件,这个文件名是web server gateway interface(Web服务器网关接口)的首字母缩写。

    • 创建数据库:
    # python manage.py migrate
    

    报错:

    django.core.exceptions.ImproperlyConfigured: SQLite 3.8.3 or later is required (found 3.7.17).
    

    查看系统的sqlite3版本:

    # sqlite3 --version
    3.7.17 2013-05-20 00:56:22 118a3b35693b134d56ebd780123b7fd6f1497668
    

    系统自带的sqlite3版本比较低,需要更新版本。

    • 更新sqlite3版本:
    #下载安装
    # cd /software
    
    # wget https://www.sqlite.org/2019/sqlite-autoconf-3270200.tar.gz
    
    # tar -zxf sqlite-autoconf-3270200.tar.gz
    
    # cd sqlite-autoconf-3270200
    
    # ./configure --prefix=/usr/local/
    
    # make && make install
    
    #更换版本
    # find /usr -name sqlite3
    
    /usr/bin/sqlite3
    /usr/lib64/python2.7/sqlite3
    /usr/local/bin/sqlite3
    /usr/python/lib/python3.7/sqlite3
    
    # /usr/local/bin/sqlite3 --version
    3.27.2 2019-02-25 16:06:06 bd49a8271d650fa89e446b42e513b595a717b9212c91dd384aab871fc1d0f6d7
    
    # mv /usr/bin/sqlite3 /usr/bin/sqlite3.bak
    
    # ln -s /usr/local/bin/sqlite3 /usr/bin/sqlite3
    
    # sqlite3 --version
    3.27.2 2019-02-25 16:06:06 bd49a8271d650fa89e446b42e513b595a717b9212c91dd384aab871fc1d0f6d7
    
    #路径传递给共享库
    # echo 'export LD_LIBRARY_PATH="/usr/local/lib"' >> ~/.bashrc
    
    # source !$
    
    # cd /opt/learning_log/
    
    # rm -rf /software/sqlite-autoconf-3270200*
    
    • 继续创建数据库:
    # python manage.py migrate
    
    # ls
    db.sqlite3  learning_log  ll_env  manage.py
    
    • 查看项目:

    对于虚拟机环境,建议指定本机IP和端口,否则默认是127.0.0.1:8000,浏览器会无法访问。

    # python manage.py runserver 192.168.30.128:8000
    
    # vim learning_log/settings.py
    ALLOWED_HOSTS = ['192.168.30.128']              #允许主机中,添加本机IP或*(任意主机)
    

    Django启动一个服务器,让你能够查看系统中的项目,了解它们的工作情况。当你在浏览器中输入URL以请求网页时,该Django服务器将进行响应:生成合适的网页,并将其发送给浏览器。

    打开浏览器,输入192.168.30.128:8000访问Django项目,如下图:

    在这里插入图片描述


    创建应用程序

    应用路径:learning_logs

    Django项目由一系列应用程序组成,它们协同工作,让项目成为一个整体。我们暂时只创建一个应用程序,它将完成项目的大部分工作。


    激活虚拟环境

    虚拟机再打开一个终端

    # cd /opt/learning_log/
    
    # source ll_env/bin/activate
    
    # python manage.py startapp learning_logs
    
    # ls
    db.sqlite3  learning_log  learning_logs  ll_env  manage.py
    
    # ls learning_logs/
    admin.py  apps.py  __init__.py  migrations  models.py  tests.py  views.py
    

    上面新增了learning_logs目录,其中models.py用来定义我们要在应用程序中管理的数据。


    定义模型

    # vim learning_logs/models.py
    
    from django.db import models
    
    class Topic(models.Model):
        """用户学习的主题"""
        text = models.CharField(max_length=200)
        date_added = models.DateTimeField(auto_now_add=True)
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text
    

    创建了一个名为Topic的类,它继承了Model——Django中一个定义了模型基本功能的类。Topic类只有两个属性:textdate_added

    属性text是一个CharField——由字符或文本组成的数据,需要存储少量的文本,如名称、标题或城市时,可使用CharField。定义CharField属性时,需要告诉Django该在数据库中预留多少空间,这里设置为200个字符。

    属性date_added是一个DateTimeField——记录日期和时间的数据。传递了实参auto_add_now=True,每当用户创建新主题时,这都让Django将这个属性自动设置成当前日期和时间。


    激活模型

    要使用模型,必须让Django将应用程序包含到项目中。

    # vim learning_log/settings.py
    
    INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        # 我的应用程序
        'learning_logs',                #增加该行
    ]
    

    还需要让Django修改数据库,使其能够存储于模型Topic相关的信息。

    # python manage.py makemigrations learning_logs
    
    # python manage.py migrate
    

    在这里,Django确认为learning_logs 应用迁移时一切OK。

    每当需要修改项目管理的数据时,都采取如下三个步骤:

    1. 修改models.py
    2. learning_logs调用makemigrations
    3. 让Django迁移项目。

    Django管理网站

    • 创建超级用户:Django允许创建具备所有权限的用户——超级用户。
    # python manage.py createsuperuser
    
    Username (leave blank to use 'root'): ll_admin              #自定义用户名
    Email address:              #可为空
    Password:               #自定义密码,不小于8位
    Password (again): 
    Superuser created successfully.
    
    • 向管理网站注册模型:非自动创建的模型需要手工注册。
    # vim learning_logs/admin.py
    
    from django.contrib import admin
    
    from learning_logs.models import Topic
    
    admin.site.register(Topic)
    

    导入我们要注册的模型Topic,让Django通过管理网站管理我们的模型。使用超级用户访问管理网站:192.168.30.128:8000/admin/

    在这里插入图片描述

    在这里插入图片描述

    • 添加主题:注册Topic后,添加主题Chess和Rock Climbing。

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述


    定义模型Entry

    要记录学到的Chess和Rock Climbing知识,需要为用户可在“学习笔记”中添加的条目定义模型。每个条目都与特定主题相关联,这种关系被称为多对一关系,即多个条目可关联到同一个主题。

    # vim learning_logs/models.py
    
    from django.db import models
    
    class Topic(models.Model):
        """用户学习的主题"""
        text = models.CharField(max_length=200)
        date_added = models.DateTimeField(auto_now_add=True)
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text
    
    class Entry(models.Model):
        """学到的有关某个主题的具体知识"""
        topic = models.ForeignKey(Topic)
        text = models.TextField()
        date_added = models.DateTimeField(auto_now_add=True)
        
        class Meta:
            verbose_name_plural = 'entries'
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text[:50] + "..."
    

    像Topic一样,Entry也继承了Django基类Model。属性topic是一个ForeignKey实例,外键引用了数据库中的另一条记录,这些代码将每个条目关联到特定的主题。每个主题创建时,都给它分配了一个键(ID),在两项数据之间需要建立联系时,Django使用与每项信息相关联的键。

    属性text是一个TextField实例,这个字段不需要限制长度。属性date_added能够按创建顺序呈现条目,且在每个条目旁边放置时间戳。

    在Entry类中嵌套Meta类,Meta类存储用于管理模型的额外信息,使用一个特殊属性让Django在需要时使用Entries来表示多个条目;如果没有这个类,Django将使用Entrys来表示多个条目。方法__str__()告诉Django在呈现条目时应显示text的前50个字符,超出则用...显示。


    迁移模型Entry

    # python manage.py makemigrations learning_logs
    

    报错:

    TypeError: __init__() missing 1 required positional argument: 'on_delete'
    

    解决——修改models.py

    from django.db import models
    
    class Topic(models.Model):
        """用户学习的主题"""
        text = models.CharField(max_length=200)
        date_added = models.DateTimeField(auto_now_add=True)
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text
    
    class Entry(models.Model):
        """学到的有关某个主题的具体知识"""
        topic = models.ForeignKey(Topic, on_delete=models.CASCADE)
        text = models.TextField()
        date_added = models.DateTimeField(auto_now_add=True)
    
        class Meta:
            verbose_name_plural = 'entries'
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text[:50] + "..."
    

    models.CASCADE这个参数在老版本中是默认值。
    on_delete有CASCADE、PROTECT、SET_NULL、SET_DEFAULT、SET()五个可选择的值:
    CASCADE:此值设置,是级联删除;
    PROTECT:此值设置,是会报完整性错误;
    SET_NULL:此值设置,会把外键设置为null,前提是允许为null;
    SET_DEFAULT:此值设置,会把设置为外键的默认值;
    SET():此值设置,会调用外面的值,可以是一个函数。

    再次迁移模型Entry:

    # python manage.py makemigrations learning_logs
    
    # python manage.py migrate
    

    向管理网站注册模型Entry

    # vim learning_logs/admin.py 
    
    from django.contrib import admin
    
    from learning_logs.models import Topic, Entry
    
    admin.site.register(Topic)
    admin.site.register(Entry)
    

    查看网页,添加条目

    在这里插入图片描述

    下拉选择对应的Topic,Text添加任意内容

    在这里插入图片描述

    在这里插入图片描述

    继续添加主题Chess的条目,然后再添加主题Rock Climbing的条目

    在这里插入图片描述


    使用Django shell

    Django shell用于测试项目及排除项目故障,要退出shell会话,可按Ctr + D。

    # python manage.py shell
    
    >>> from learning_logs.models import Topic
    
    >>> Topic.objects.all()
    <QuerySet [<Topic: Chess>, <Topic: Rock Climbing>]>
    

    在活动的虚拟环境中执行时,命令python manage.py shell启动一个Python解释器,可使用它来探索存储在项目数据库中的数据。

    在这里,我们导入了模块learning_logs.models中的模型Topic,然后使用方法Topic.objects.all()来获取模型Topic的所有实例;它返回的是一个列表,称为查询集(queryset)。

    • 查看分配给每个主题对象的ID:
    >>> topics = Topic.objects.all()
    
    >>> for topic in topics:
    ...     print(topic.id, topic)
    ... 
    1 Chess
    2 Rock Climbing
    

    可以看到,主题Chess的ID为1,而Rock Climbing的ID为2。

    • 获取任意属性的值:

    知道对象的ID后,就可以获取该对象并查看其任何属性。

    >>> t = Topic.objects.get(id=1)
    
    >>> t.text
    'Chess'
    
    >>> t.date_added
    datetime.datetime(2019, 7, 9, 2, 5, 18, 289746, tzinfo=<UTC>)
    
    • 查看与主题相关联的条目:
    >>> t.entry_set.all()
    <QuerySet [<Entry: The opening is thefirst part ofthe game, roughly t...>, <Entry: In the opening phase ofthe game, it's important to...>]>
    
    >>> t2 = Topic.objects.get(id=2)
    
    >>> t2.entry_set.all()
    <QuerySet [<Entry: One ofthe most importantconcepts in climbing is to...>]>
    

    创建主页网页

    使用Django创建网页的过程通常分三个阶段:定义URL、编写视图和编写模板。

    首先,你必须定义URL模式。URL模式描述了URL是如何设计的,让Django知道如何将浏览器请求与网站URL匹配,以确定返回哪个网页。每个URL都被映射到特定的视图——视图函数获取并处理网页所需的数据。视图函数通常调用一个模板,后者生成浏览器能够理解的网页。


    映射URL

    用户通过在浏览器中输入URL以及单击链接来请求网页,因此我们需要确定项目需要哪些URL。主页的URL最重要,它是用户用来访问项目的基础URL。

    # vim learning_log/urls.py
    
    from django.contrib import admin
    from django.urls import path, include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('', include('learning_logs.urls', namespace='learning_logs')),
    ]
    

    这里保存完文件之后会报ModuleNotFoundError: No module named 'learning_logs.urls'错误,不用理会,继续往下做。

    在文件夹learning_logs中创建另一个urls.py文件

    # vim learning_logs/urls.py
    
    """定义learning_logs的URL模式"""
    
    from django.urls import path
    from . import views
    
    app_name='learning_logs'
    urlpatterns = [
        # 主页
        path('', views.index, name='index'),
    ]
    

    编写视图

    视图函数接受请求中的信息,准备好生成网页所需的数据,再将这些数据发送给浏览器——这通常是使用定义了网页是什么样的模板实现的。

    # vim learning_logs/views.py
    
    from django.shortcuts import render
    
    from .models import Topic
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    

    导入了函数render(),它根据视图提供的数据渲染响应。URL请求与刚才定义的模式匹配时,Django将在文件views.py中查找函数index(),再将请求对象传递给这个视图函数。

    • 编写模板:

    模板定义了网页的结构。模板指定了网页是什么样的,而每当网页被请求时,Django将填入相关的数据。模板让你能够访问视图提供的任何数据。

    # mkdir -p learning_logs/templates/learning_logs
    
    # vim learning_logs/templates/learning_logs/index.html
    
    <p>Learning Log</p>
    <p>Learning Log helps you keep track of your learning, for any topic you're learning about.</p>
    

    标签<p></p>标识段落;标签<p>指出了段落的开头位置,而标签</p>指出了段落的结束位置。

    • 访问网页:

    访问基础URL——192.168.30.128:8000,可以看到刚刚定义的模板index.html。

    在这里插入图片描述


    创建其它网页

    在创建完主页之后,继续创建两个显示数据的网页,其中一个列出所有的主题,另一个显示特定主题的所有条目。对于每个网页,我们都将指定URL模式,编写一个视图函数,并编写一个模板。


    模板继承

    创建网站时,几乎都有一些所有网页都将包含的元素。在这种情况下,可编写一个包含通用元素的父模板,并让每个网页都继承这个模板。

    • 父模板:首先来创建一个名为base.html的模板,并将其存储在index.html所在的目录中。这个文件包含所有页面都有的元素;其他的模板都继承base.html。
    # vim learning_logs/templates/learning_logs/base.html
    
    <p>
      <a href="{% url 'learning_logs:index' %}">Learning Log</a>
    </p>
    
    {% block content %}{% endblock content %}
    

    第一部分创建一个包含项目名的段落,该段落也是一个到主页的链接,为创建链接,我们使用了一个模板标签。模板标签{% url 'learning_logs:index' %}生成一个URL,该URL与learning_logs/urls.py中定义的名为index的URL模式匹配。

    第二部分插入了一对块标签。这个块名为content,是一个占位符,其中包含的信息将由子模板指定。

    • 子模板:现在要重新编写index.html,使其继承base.html。
    # vim learning_logs/templates/learning_logs/index.html
    
    {% extends "learning_logs/base.html" %}
    
    {% block content %}
      <p>Learning Log helps you keep track of your learning, for any topic you're learning about.</p>
    {% endblock content %}
    

    子模板的第一行必须包含标签{% extends %},让Django知道它继承了哪个父模板。

    然后插入了一个名为content 的{% block %}标签,以定义content块,不是从父模板继承的内容都包含在content块中。


    显示所有主题

    • URL模式:

    定义显示所有主题的页面的URL。

    # vim learning_logs/urls.py
    
    """定义learning_logs的URL模式"""
    
    from django.urls import path
    from . import views
    
    app_name='learning_logs'
    urlpatterns = [
        # 主页
        path('', views.index, name='index'),
    
        # 显示所有的主题
        path('topics/', views.topics, name='topics'),
    ]
    

    只在用于主页URL的正则表达式中添加了topics/,Django检查请求的URL时,这个模式与这样的URL匹配:基础URL后面跟着topics。其URL与该模式匹配的请求都将交给views.py中的函数topics()进行处理。

    • 修改视图:

    函数topics()需要从数据库中获取一些数据,并将其发送给模板。

    # vim learning_logs/views.py
    
    from django.shortcuts import render
    
    from .models import Topic
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = {'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    

    函数topics() 包含一个形参:Django从服务器那里收到的request对象。然后查询数据库——请求提供Topic对象,并按属性date_added对它们进行排序。我们将返回的查询集存储在topics中。

    接着定义了一个将要发送给模板的上下文。上下文是一个字典,其中的键是我们将在模板中用来访问数据的名称,而值是我们要发送给模板的数据。在这里,只有一个键—值对,它包含我们将在网页中显示的一组主题。创建使用数据的网页时,除对象request和模板的路径外,我们还将变量context传递给render()

    • 编写模板:

    显示所有主题的页面的模板接受字典context,以便能够使用topics()提供的数据。

    # vim learning_logs/templates/learning_logs/topics.html
    
    {% extends "learning_logs/base.html" %}
    
    {% block content %}
    
      <p>Topics</p>
      
      <ul>
        {% for topic in topics %}
          <li>{{ topic }}</li>
        {% empty %}
          <li>No topics have been added yet.</li>
        {% endfor %}
      </ul>
      
    {% endblock content %}
    

    首先使用标签{% extends %}来继承base.html,接着开始定义content块。在标准HTML中,项目列表被称为无序列表,用标签<ul></ul>表示。

    然后使用一个相当于for循环的模板标签,它遍历字典context中的列表topics。在模板中,每个for循环都必须使用{% endfor %}标签来显式地指出其结束位置。

    在循环中,要将每个主题转换为一个项目列表项。要在模板中打印变量,需要将变量名用双花括号括起来。HTML标签<li></li>表示一个项目列表项,在标签对<ul></ul>内部,位于标签<li></li>之间的内容都是一个项目列表项。

    修改父模板,使其包含到显示所有主题的页面的链接:

    # vim learning_logs/templates/learning_logs/base.html
    
    <p>
      <a href="{% url 'learning_logs:index' %}">Learning Log</a> -
      <a href="{% url 'learning_logs:topics' %}">Topics</a>
    </p>
    
    {% block content %}{% endblock content %}
    

    在到主页的链接后面添加了一个连字符-,然后添加了一个到显示所有主题的页面的链接,使用的也是模板标签url。

    • 访问网页:

    访问基础URL——192.168.30.128:8000,可以看到定义的模板index.html及Topics链接。

    在这里插入图片描述

    点击Topics链接,查看主题

    在这里插入图片描述


    显示特定主题页面

    接下来,重复之前步骤,创建一个专注于特定主题的页面——显示该主题的名称及该主题的所有条目。同样的,我们将定义一个新的URL模式,编写一个视图并创建一个模板。

    • URL模式:

    显示特定主题的页面的URL模式与前面的所有URL模式都稍有不同,因为它将使用主题的id属性来指出请求的是哪个主题。

    # vim learning_logs/urls.py
    
    """定义learning_logs的URL模式"""
    
    from django.urls import path, re_path
    from . import views
    
    app_name='learning_logs'
    urlpatterns = [
        # 主页
        path('', views.index, name='index'),
    
        # 显示所有的主题
        path('topics/', views.topics, name='topics'),
    
        # 特定主题的详细页面
        re_path(r'^topics/(?P<topic_id>\d+)/$', views.topic, name='topic'),
    ]
    

    这里用到了python正则表达式,/(?P<topic_id>\d+)/与包含在两个斜杠内的整数匹配,并将这个整数存储在一个名为topic_id的实参中。?P<topic_id>将匹配的值存储到topic_id中;而表达式\d+与包含在两个斜杆内的任何数字都匹配,不管这个数字为多少位。

    发现URL与这个模式匹配时,Django将调用视图函数topic(),并将存储在topic_id中的值作为实参传递给它。

    • 修改视图:
    # vim learning_logs/views.py
    
    from django.shortcuts import render
    
    from .models import Topic
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = {'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    
    def topic(request, topic_id):
        """显示一个主题及其详细页面"""
        topic = Topic.objects.get(id=topic_id)
        entries = topic.entry_set.order_by('-date_added')
        context = {'topic': topic, 'entries': entries}
        return render(request, 'learning_logs/topic.html', context)
    

    第一个除request对象外还包含另一个形参的视图函数。这个函数接受正则表达式(?P<topic_id>\d+)捕获的值,并将其存储到topic_id中。

    使用get()来获取指定的主题,获取与该主题相关联的条目,并将它们按date_added排序:date_added前面的减号指定按降序排列,即先显示最近的条目。将主题和条目都存储在字典context中,再将这个字典发送给模板topic.html。

    • 编写模板:
    # vim learning_logs/templates/learning_logs/topic.html
    
    {% extends 'learning_logs/base.html' %}
    
    {% block content %}
    
      <p>Topic: {{ topic }}</p>
    
      <p>Entries:</p>
      <ul>
      {% for entry in entries %}
        <li>
          <p>{{ entry.date_added|date:'M d, Y H:i' }}</p>
          <p>{{ entry.text|linebreaks }}</p>
        </li>
      {% empty %}
        <li>
          There are no entries for this topic yet.
        </li>
      {% endfor %}
      </ul>
    
    {% endblock content %}
    
    • 修改topics模板:

    将显示示所有主题的页面中的每个主题都设置为链接

    # vim learning_logs/templates/learning_logs/topics.html
    
    {% extends "learning_logs/base.html" %}
    
    {% block content %}
    
      <p>Topics</p>
    
      <ul>
        {% for topic in topics %}
          <li>
            <a href="{% url 'learning_logs:topic' topic.id %}">{{ topic }}</a>
    	  </li>
        {% empty %}
          <li>No topics have been added yet.</li>
        {% endfor %}
      </ul>
    
    {% endblock content %}
    

    使用模板标签url 根据learning_logs中名为topic的URL模式来生成合适的链接。这个URL模式要求提供实参topic_id,因此在模板标签url中添加了属性topic.id

    • 访问网页:

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述


    展开全文
  • 面向初级开发一套含有角色,权限,内容为一体的学员管理,抛弃传统的每个页面繁琐的增删改查,开发公共组件,使得开发者根据配置文件即可完成复杂的搜索以及增删改查。
  • 本课程是基于Python3.8和Django2.1.5框架进行讲解,主要内容有: 1、模型模块学习内容大概是:模型分析、模型创建、模型迁移、模型查询等操作 2、视图模块学习内容大概是:Request、Response、Cookie、Session等...
  • Django无疑是Python领域,最热的Web开发框架,功能强大,开发效率高,提供了强大的后台管理和ORM设计。但是发现很多同学都停留在Django的Hello World层面,能做出完整项目的是少之又少。基于这个原因,我开设了...
  • 本系列课程是从零基础开始并深入讲解Django,最终学会使用Django框架开发企业级的项目。课程知识点全网最详细,项目实战贴近企业需求。本系列课程除了非常详细的讲解Django框架本身的知识点以外,还讲解了web开发中...
  • Django 从入门到精通

    万人学习 2019-12-11 10:23:28
    本课程从Django环境搭建讲起,详细讲述了Django开发的各个环节,内容包括:创建Django项目、创建Django应用、Django数据库、Django视图、Django模型、Django表单和Django模板。
  • Python+Django框架Web应用开发

    千人学习 2018-06-28 12:02:01
    系统介绍使用Django框架开发Web应用程序,当然,依然水煮风格
  • Django博客

    2019-01-18 08:13:43
    作为一个Python初学者,Django是我学习的第一个网站框架,个人博客是我的第一个Python Web项目,不成熟的地方还请谅解。
  • 记录一次完整的基于django的实例

    万次阅读 2018-08-03 17:53:14
    win10 + pycharm + python3.5 + django1.10 项目配置流程: 安装pymysql→Settings配置→(databases,templates下的dirs,新建statixfiles_dirs)→migration生成数据表→编写views.py→配置urls.py...

    实例内容:
    一个简单的将前端页面数据提交到数据库,从数据库取出数据展示到前端页面。

    环境:
    win10 + pycharm + python3.5 + django1.10

    项目配置流程:
    安装pymysql→Settings配置→(databases,templates下的dirs,新建statixfiles_dirs)→migration生成数据表→编写views.py→配置urls.py→(1.HTNL个css文件分离,2.css文件分离与地址修改)

    第一步:创建项目djangostart

    Paste_Image.png

    第二步:创建app-> message

    首先按照图所示,调出运行窗口

    Paste_Image.png

    然后在窗口中输入:startapp message
    这时会生成对应的app,并将app添加到setting配置文件。

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

    第三步:创建static目录,用于存放静态文件(CSS,JS等文件)

    Paste_Image.png

    至此我们已经创建好项目的基本目录。

    第四步:将前端页面配置到模板,将CSS文件配置到static目录

    目录结构为

    前端页面代码逻辑为;

    <head>
        <meta charset="UTF-8">
        <title></title>
        <link rel="stylesheet" href="/static/css/style.css">
    </head>
    

    第五步:配置setting文件中的静态文件和模板文件路径

    当配置好第四步之后,我们如果运行程序不会加载出页面,因为我们需要配置文件路径。
    对于静态文件:

    STATIC_URL = '/static/'
    #仅有上面的设置,只说明了样式放在static文件,需要指定和项目根目录的关系
    
    #设置静态文件的目录,设置为列表形式
    STATICFILES_DIRS = [
        os.path.join(BASE_DIR,'static')
    ]
    

    对于模板文件:

    TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            #根据根目录设置templates目录
            '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',
                ],
            },
        },
    ]
    

    其中的BASE_DIR为当前目录的绝对路径

    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__)))
    

    配置完这两项,我们就可以加载出页面,否则加载不出。

    第六步:配置django连接mysql数据库

    因为我们的项目是需要连接数据库的,因此我们需要配置连接数据库。
    python3连接MySQL不再使用MySQLdb,现在大部分都是使用PyMySQL用于连接MySQL数据库。
    首先安装PyMySQL用于替代MySQLdb。
    然后在工程目录的init.py中填写下面两句话

    import pymysql
    pymysql.install_as_MySQLdb()
    

    接着配置setting文件,连接数据库

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql', #主要是这里,将默认的sqlite3改为mysql
            'NAME': "testdjango", #数据库的名字
            'USER': "root",#数据库用户名
            'PASSWORD': "root",#数据库密码
            'HOST': "127.0.0.1",数据库地址,默认本机
            'PORT': "",数据库端口,默认3306
        }
    }
    

    配置好数据库之后,可以根据django来生成默认的数据表。
    同样是在Tools -> Run manage.py Task 打开运行窗口
    我们运行makemigrations(检查要修改的数据库字段),migrate(生成数据表)
    当运行完上述两个命令之后,就会在数据库中创建一些默认的基本数据表。

    第七步:配置urls.py和views.py

    在views.py中配置函数

    def getform(request):
        return  render(request,'message.html')
    

    在urls.py中配置url映射

    from django.conf.urls import url
    from django.contrib import admin
    from message.views import getform
    
    urlpatterns = [
        url(r'^admin/', admin.site.urls),
        url(r'^form/$',getform,name='go_form')
    ]
    

    配置好以上两个文件,我们就可以调试程序了,Run -> Debug
    然后在浏览器中输入:<a>http://127.0.0.1:8000/form/</a>

    Paste_Image.png

    第八步:django model层的配置

    我们使用django的ORM机制,使类和数据库里的表相对应。
    我们在models.py中进行以下配置:

    # Create your models here.
    class UserMessage(models.Model):
        object_id = models.CharField(primary_key=True,verbose_name=u"主键",max_length=20,default="")
        name = models.CharField(max_length=20,null=True,blank=True,default="",verbose_name=u"用户名")
        email = models.EmailField(verbose_name=u"邮箱")
        address = models.CharField(max_length=100,verbose_name=u"联系地址")
        message = models.CharField(max_length=500,verbose_name=u"留言信息")
    
        class Meta:
            verbose_name = u"用户留言信息"
            verbose_name_plural = verbose_name
            #指定数据库的表名
            #db_table = "user_message"
            #排序
            #ordering = "-object_id"
    

    根据前端页面表单的数据,我们创建了四个属性。
    里面的object_id 为主键。
    配置好之后,我们配置生成数据表,Tools -> Run manage.py Task 打开运行窗口:

    makemigrations  message
    之后运行
    migrate message
    

    我们可以通过navicat查看生成的数据表:

    Paste_Image.png

    第九步:通过ORM对数据库进行增删改查

    首先我们在views.py中引用我们刚才创建的类

    from .models import UserMessage
    

    如何获取数据库中的数据:
    我们通过类UserMessage的数据表管理器objects获取数据。

    获取数据库的所有数据,返回的是可以进行循环的QuerySet类型    数据表管理器objects
    all_message = UserMessage.objects.all()
    for message in all_message:
        print(message.name)
    这里的message其实就是UserMessage的实例
    我们还可以根据条件取出数据
    all_message = UserMessage.objects.filter(name=u"王二小",address=u"杭州")
    

    如何删除数据:
    我们可以使用delete()函数删除所取的值

    all_message = UserMessage.objects.all()
    #删除所有
    #all_message.delete()
    for message in all_message:
        #删除单一值
        #message.delete()
    

    如何往数据库里面添加数据:
    我们通过实例化UserMessage对象,通过属性赋值,通过save()方法往数据库里赋值。

    user_message = UserMessage()
    user_message.name = u"王小二"
    user_message.message = u"放羊娃"
    user_message.address = u"杭州"
    user_message.object_id = "2"
    user_message.email = "2@2.com"
    user_message.save()
    

    完成上面的代码之后,我们运行项目,然后刷新页面,这时数据将会保存进数据库。

    如何提取前端页面表单中的数据保存到数据库中:
    我们使用POST将表单数据提交。

    #首先判断request的方式
    if request.method == "POST":
        #通过request的get()函数,获得提交的值
        name = request.POST.get('name','')#当属性值不存在,则赋空值
        message = request.POST.get('message','')
        email  = request.POST.get('email','')
        address = request.POST.get('address','')
    
        user_message = UserMessage()
        user_message.name = name
        user_message.message = message
        user_message.address = address
        user_message.object_id = "3" #这里的主键我们随便设置
        user_message.email = email
    
        #将值保存到数据库
        user_message.save()
    

    我们提交的数据都保存在POST中,通过get方法获得。
    代码中get('name','')这里的name是前端页面表单里面name="name"的name。

    想要完成数据的提交在前端页面要有下面两项配置:

    <form action="/form/}" method="post" class="smart-green">
    

    以及表单的提交允许

        #加了csrf_token之后才能够往后台提交数据
        {% csrf_token %}
    

    完成上面的代码配置之后,运行调试,然后在表单中输入数据然后提交,数据被保存到数据库中。

    如何将数据库中的数据显式到前端页面中:
    通过render()方法,添加字典形式的参数。

        #将后台数据库里的数据提取到前端页面
        message = None
        all_message = UserMessage.objects.filter(name=u"王二小")
        返回的Queryset可以做切片操作
        if all_message:
            message = all_message[0]
    
        return  render(request,'message.html',{"my_message":message})
    

    在前端页面中,我们使用的是字典的键。
    在前端页面的调用:

    value="{{ my_message.name }}"
    

    好了,至此为止,我们基本完成了一个简单的表单提交(里面有很多坑)。还有url的命名等其它知识



    作者:海贼之路飞
    链接:https://www.jianshu.com/p/335121af76d3
    來源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • django博客

    2017-09-13 20:19:07
    django,mysql,博客项目,完整的,可用的项目! django,mysql,博客项目,完整的,可用的项目! django,mysql,博客项目,完整的,可用的项目!
  • django开发个人博客系统

    万次阅读 多人点赞 2019-02-18 22:08:37
    Django版本:2.0 数据库工具:sqlite 开发工具:Pycharm+sublime-text 写在开头:这是我第一次使用Django进行web开发,在此之前并无任何web开发经验。其中,Django以及html/css都属于边学边用阶段,因此项目中...

    目录

    前言
    项目预览
    项目版本
    项目构思
    项目实战
         登录子系统
         后台美化
    完整项目获取
    尾言

    前言

        当初是在2018年写下的这篇文章,那时的django更新到了版本2.0,使用人数还是比较少的,网上的教程大多也很少。而现在随着python web框架的流行,越来越多人开始接触到了django这门技术。如今,django已经更新到了版本3.0,添加了支持异步等重要特性,但是这些特性和本篇文章基本无关。写下这篇文章的初衷是为了让刚接触django框架的童鞋可以入门上手一个项目,了解如何快速搭建一个项目,毕竟python web的优势便是快速易上手嘛【最近接触了springboot后的感触】。如今再次更新这篇博文(2020-2月),希望能够给予大家入门一定的帮助。
        
        
    p.s:其实建立一个web项目需要处理的事情比较杂,我就按照我的建立习惯给大家写下这篇教程。
    另外,本项目是我在重新写时完整重新搭建,所以一定可以跑通,我会写的比较仔细一点,如果你能耐心看完,必定有所收获。
    【-------------------------原创不易,请勿侵权------------------------------------------------------------------】

    项目预览

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
        
        

    项目版本

    运行平台:windows
    Python版本:3.7
    Django版本:3.0
    数据库工具:sqlite
    开发工具:Pycharm+vscode
    依赖:pillow,django-simpleui,django_summernote
        
        

    项目构思

        个人博客系统属于一个非常小型的项目,不会存在高并发的情况,同时注册用户主要也就是为了评论博客内容,其实用户账号安全性也可以完全不用考虑。项目采取前后端分离的形式进行开发,前后端信息交互多数采取ajax形式(按理说动态更新页面比较友好交互,但是为了让大家感受一下这两种方式,在登录这一块采取静态跳转)。剩下的部分一次性在这里写下来大家也不一定能看的很明白,在建立项目的过程中再给大家介绍。
        
        

    项目实战

    请先下载静态文件 下载连接:https://pan.baidu.com/s/1Er2S63MThOfzhlbuUkTEkw 之后替换相应的文件

    我们首先给我们的项目起个名字:Ericam
        
    (1)利用命令行创建项目。
        

    django-admin startproject Ericam
    

        
    (2)创建APP
        
    解释一下:项目中会存在登录子系统,博文管理子系统等,这些子系统每个都可以作为一个app,如此分离方便日后开发维护。但是作为一个入门项目,便不如此麻烦了。我们在整个项目只建立一个app。
    由于我们准备搭建的是一个博客系统,所以就给这个APP起名为:blog
        
    在命令行下继续输入

    python manage.py startapp blog
    

        
    此时文件目录结构:
    在这里插入图片描述
        
    介绍一下各个文件的用处
    在这里插入图片描述
        
    删除test.py,新建一个urls.py文件
    在这里插入图片描述
    为什么需要两个urls.py文件呢?方便分层管理,类似于一级目录,二级目录。
        
        
    (3)注册app并配置静态文件目录
    在这里插入图片描述
        
    在settings.py文件里添加如下内容
        

    # 配置静态文件目录
    STATICFILES_DIRS = [
            os.path.join(BASE_DIR, 'static'),
        ]
    

        
    【静态文件:css,js和图片文件等,我们在这里配置了文件目录路径】
    此时运行项目,用浏览器访问 http://127.0.0.1:8000/
    在这里插入图片描述
    出现一个小火箭代表我们的项目搭建成功了。
        
        
    (4)
    新建文件夹,如下所示(建议直接将static文件夹复制过来,本博客不会讲解css以及js):
    在这里插入图片描述
    (所有html文件存放于templates文件夹下)
    新建index_unlog.html文件【作为首页,未登录时显示的页面】
    我们先简单测试一下,给大家展示一下django如何通过view.py视图层显示html页面。
    在index_unlog.html里:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>首页</title>
    </head>
    <body>
        个人博客系统测试
    </body>
    </html>
    

    在views.py文件里:

    def index_unlog(request):
        return render(request,'index_unlog.html')
    

    最后我们添加一下路由地址,在与settings.py同级目录的urls.py:

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('blog/',include('blog.urls')),
        path('',views.index_unlog,name='index_unlog')
    ]
    

    在新建的urls.py文件【以后我加个标号2代表该文件】里添加如下内容:

    app_name = 'blog'
    urlpatterns = [
    ]
    

    ps:在pycharm里按alt+enter可以添加未引入的类包。
    此时刷新项目,用浏览器访问 http://127.0.0.1:8000/

    在这里插入图片描述

    搞懂了每个文件的大致作用,我们便可以开始正式开发博客系统啦。
    我们按照模块化进行开发。
        
        
        

    登录子系统开发

    (1)首页(未登录)-编写index_unlog.html
        

    {% load static %}
    <html lang="zh">
      <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta name="author" content="Ericam_">
    
        <!-- CSS -->
    	<title>Ericam_blog</title>
    	<link rel="shortcut icon" href="{% static 'images/gt_favicon.png' %}">
    	<link rel="stylesheet" media="screen" href="http://fonts.googleapis.com/css?family=Open+Sans:300,400,700">
    	<link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
    	<link rel="stylesheet" href="{% static 'css/font-awesome.min.css' %}">
    	<!-- Custom styles for our template -->
    	<link rel="stylesheet" href="{% static 'css/bootstrap-theme.css'%}"  >
    	<link rel="stylesheet" href="{% static 'css/log.css'%}">
    	<link rel="stylesheet" href="{% static 'css/blog.css'%}">
    	</head>
    
    
    <body class="back">
      <!--导航栏-->
    	<div class="navbar navbar-inverse navbar-fixed-top headroom" >
    		<div class="container">
    			<div class="navbar-header">
    				<!-- Button for smallest screens -->
    				<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse"><span class="icon-bar"></span> <span class="icon-bar"></span> <span class="icon-bar"></span> </button>
    				<a class="navbar-brand"><img src="{%static 'css/images/lo.png'%}" alt="Progressus HTML5 template"></a>
    			</div>
    			<div class="nav navbar-nav navbar-right">
    								<!--在这里填写登录提交  1-->
    			</div>
    		</div>
    	</div>
    
    	  <center>
        <div class="container" style="padding-top:300px;min-height:800px">
          <div class="row">,.
            <p class="lead"><font color="white"">个人博客系统,尽情的享用吧(〃'▽'〃)</font></p>
            <p class="tagline"><font color="white">如果您有优秀的建议,欢迎投递哦</font></p>
    							<!--在这里填写登录提交  2-->
          </div>
        </div>
    	</center>
    
    
       <footer id="footer" class="top-space">
    		<div class="footer2">
    			<div class="container">
    				<p class="text-center">Copyright &copy; 2020, Ericam_blog</p>
    			</div>
    		</div>
      </footer>
    </body>
    </html>
    

    第一句话{%load static%}代表引入静态文件(css,js等)
    img,css,js等文件的引用与下述语句类似:

     <link rel="stylesheet" href="{%static 'css/log.css' %}">
    

    此时打开浏览器查看效果:
    在这里插入图片描述
        
        
    (2)登录页-login.html
        

    {%load static%}
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>登录</title>
        <link rel="shortcut icon" href="{% static 'images/gt_favicon.png' %}">
        <link rel="stylesheet" href="{%static 'css/log.css' %}">
        <link rel="stylesheet" href="{%static 'css/semantic.css' %}">
        <link rel="stylesheet" href="{% static 'css/font-awesome.min.css' %}">
    </head>
    <body class="login">
        <div class="ui center aligned grid" style="margin-top: 200px">
            <div class="ui six wide column">
                <h1 class="ui teal header">Ericam blog-登录</h1>
                <div class="ui segment">
                    <div class="ui content">
        <form class="ui large form" method="post" action="{%url 'login'%}">
          <div class="ui stacked segment">
            <div class="field">
              <div class="ui left icon input">
                <input type="text" name="username" placeholder="请输入用户名">
              </div>
            </div>
            <div class="field">
              <div class="ui left icon input">
                <input type="password" name="password" placeholder="请输入密码">
              </div>
            </div>
            {{ error }}<br>
            <a class="pull-right field" >忘记密码</a>
            <button class="ui fluid large teal button" type="submit">登陆</button>
          </div>
    
          <div class="ui error message"></div>
        </form>
    
        <div class="ui message">
          New to us? <a>注册</a>
        </div>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>
    

        
    添加路由信息:
        

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('blog/',include('blog.urls')),
        path('',views.index_unlog,name='index_unlog'),
        path('login',views.login,name='login')
    ]
    

        
    添加视图层views.py内容:
        

    def login(request):
        return render(request,'login.html')
    

        
    此时预览:
        
    在这里插入图片描述
        
    在index_unlog.html里添加内容:

    	<!--在这里填写登录提交  1-->
    <a class="btn" href="{% url 'login' %}">登录 / 注册</a></li>
    
        <!--在这里填写登录提交  2-->
    <p><a class="btn btn-action btn-lg" role="button" href="{% url 'login' %}">START NOW</a></p>
    

        
    为了实现登录功能,我们首先需要构造一个用户表
        
    打开models.py文件

    from django.db import models
    from django.contrib import  admin
    from django.urls import reverse
    from django.utils.timezone import now
    
    # Create your models here.
    
    class User(models.Model):
        username = models.CharField(max_length = 50)
        password = models.CharField(max_length = 200)
        nickname = models.CharField(max_length = 50,default='匿名')
        email = models.EmailField()
        created_time = models.CharField(max_length=50,default=now)
        comment_num = models.PositiveIntegerField(verbose_name='评论数', default=0)
        avatar = models.ImageField(upload_to = 'media', default="media/default.png")
    
        def __str__(self):
            return self.username
    
        def comment(self):
            self.comment_num += 1
            self.save(update_fields=['comment_num'])
    
        def comment_del(self):
            self.comment_num -= 1
            self.save(update_fields=['comment_num'])
    
    class UserAdmin(admin.ModelAdmin):
        list_display = ('username','email')
    #修饰器
    

    然后打开命令行

    python manage.py makemigrations
    python manage.py migrate
    

    这便生成了sqlite数据库文件
    在这里插入图片描述
    通过sqliteStudio打开浏览:
    在这里插入图片描述
        
    在views.py文件里编写登录逻辑

    def login(request):
        if request.method == 'POST':
            user_name = request.POST.get('username','')
            pass_word = request.POST.get('password','')
            user = User.objects.filter(username=user_name)  #查看数据库里是否有该用户名
            if user:#如果存在
                user = User.objects.get(username = user_name)#读取该用户信息
                if pass_word==user.password:#检查密码是否匹配
                    request.session['IS_LOGIN'] = True
                    request.session['nickname'] = user.nickname
                    request.session['username'] = user_name
                    return render(request,'index.html',{'user':user})
                else:
                    return render(request,'login.html',{'error': '密码错误!'})
            else:
                return render(request, 'login.html', {'error': '用户名不存在!'})
        else:
            return render(request,'login.html')
    

    因为我们需要记录cookies,所以我们打开settings.py文件,注释该语句
    在这里插入图片描述
    此时登录功能已经实现了。登录成功我们希望页面进行跳转,所以我们需要新建一个index.html

    {% load static %}
    <html lang="zh">
      <head>
        <meta charset="utf-8">
        <title>首页-Ericamblog</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta name="author" content="Ericam_">
    
        <!-- CSS -->
    	<link rel="shortcut icon" href="{% static 'images/gt_favicon.png' %}">
    	<link rel="stylesheet" media="screen" href="http://fonts.googleapis.com/css?family=Open+Sans:300,400,700">
    	<link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
    	<link rel="stylesheet" href="{% static 'css/font-awesome.min.css' %}">
    	<!-- Custom styles for our template -->
    	<link rel="stylesheet" href="{% static 'css/bootstrap-theme.css'%}" media="screen" >
    	<link rel="stylesheet" href="{% static 'css/blog.css' %}">
    	<link rel="stylesheet" href="{% static 'css/log.css' %}">
    </head>
    
    <body class="back">
      <script src = "E:/bootstrap/bootstrap-3.3.7-dist/bootstrap-3.3.7-dist/js/jquery.min.js"></script>
      <!--导航栏-->
    	<div class="navbar navbar-inverse navbar-fixed-top headroom" >
    		<div class="container">
    			<div class="container-fluid">
    			  <div class="navbar-header">
    				<!-- Button for smallest screens -->
    				  <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse"><span class="icon-bar"></span> <span class="icon-bar"></span> <span class="icon-bar"></span> </button>
    				  <a class="navbar-brand"><img src="{%static 'css/images/lo.png'%}" alt="Progressus HTML5 template"></a>
    			  </div>
    
            <ul class="nav navbar-nav navbar-right">
                <li><a><font size="4" color="white">{{user.nickname}}</font></a></li>
                <li><a href="{%url 'index_unlog'%}"><i class="fa fa-sighout"></i><font size="4">注销</font></a></li>
            </ul>
        </div>
    	</div>
    </div>
    
    	  <center>
        <div class="container" style="padding-top:300px;min-height:800px">
          <div class="row">,.
            <p class="lead"><font color="white"">Easy-Download,这里有好多好多资源喔,尽情的享用吧(〃'▽'〃)</font></p>
            <p class="tagline"><font color="white">如果您有优秀的资源,欢迎投递哦</font></p>
            <p><a class="btn btn-action btn-lg" role="button" href="#">START NOW</a></p>
          </div>
        </div>
    	</center>
    
       <footer id="footer" class="top-space">
    		<div class="footer2">
    			<div class="container">
    				<p class="text-center">Copyright &copy; 2020, Ericamblog</p>
    			</div>
    		</div>
      </footer>
    </body>
    </html>
    

    views.py

    def logsuccess(request):
        return render(request,'index.html')
    

    添加路由信息

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('blog/',include('blog.urls')),
        path('',views.index_unlog,name='index_unlog'),
        path('login',views.login,name='login'),
        path('/log',views.logsuccess,name='login-success')
    ]
    

    手动在数据库中添加一个用户信息
    在这里插入图片描述
    我们进行预览
    在这里插入图片描述
        
        
    完成了登录验证功能后,我们就需要添加注册功能,因为刚才用户的信息是我们手动在数据库内添加的,正常情况下应该是前端页面将内容发送给后端,后端经过处理存储在数据库内。
        
        
    注册模块
        
        
    (1)views.py

    def register(request):
        if request.method =='POST':
            user_name = request.POST.get('username','')
            pass_word_1 = request.POST.get('password_1','')
            pass_word_2 = request.POST.get('password_2','')
            nick_name = request.POST.get('nickname','')
            email = request.POST.get('email','')
            avatar = request.FILES.get('avatar')
            if User.objects.filter(username = user_name):
                return render(request,'register.html',{'error':'用户已存在'})
                #将表单写入数据库
            if(pass_word_1 != pass_word_2):
                return render(request, 'register.html', {'error': '两次密码请输入一致'})
            user = User()
            if avatar:
                user.avatar = 'media/' + user_name + '.png'
                img = Image.open(avatar)
                size = img.size
                print(size)
                # 因为是要圆形,所以需要正方形的图片
                r2 = min(size[0], size[1])
                if size[0] != size[1]:
                    img = img.resize((r2, r2), Image.ANTIALIAS)
                # 最后生成圆的半径
                r3 = int(r2/2)
                img_circle = Image.new('RGBA', (r3 * 2, r3 * 2), (255, 255, 255, 0))
                pima = img.load()  # 像素的访问对象
                pimb = img_circle.load()
                r = float(r2 / 2)  # 圆心横坐标
                for i in range(r2):
                    for j in range(r2):
                        lx = abs(i - r)  # 到圆心距离的横坐标
                        ly = abs(j - r)  # 到圆心距离的纵坐标
                        l = (pow(lx, 2) + pow(ly, 2)) ** 0.5  # 三角函数 半径
    
                        if l < r3:
                            pimb[i - (r - r3), j - (r - r3)] = pima[i, j]
                img_circle.save('blog/static/media/'+user_name+'.png')
            user.username = user_name
            user.password = pass_word_1
            user.email = email
            user.nickname = nick_name
            user.save()
                #返回注册成功页面
            return render(request,'index_unlog.html')
        else:
            return render(request,'register.html')
    

        
        
    代码含义很好理解,就是将前端提交的信息以user对象存储到数据库中,中间一部分代码是将用户提交的头像切割成圆形(无需理解)
        
        
    (2)添加路由信息

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('blog/',include('blog.urls')),
        path('',views.index_unlog,name='index_unlog'),
        path('login',views.login,name='login'),
        path('log',views.logsuccess,name='login-success'),
        path('register',views.register,name='register')
    ]
    

    (3)添加register.html

    {%load static%}
    <!DOCTYPE html>
    <html lang="zh-hans">
    <head>
        <meta charset="UTF-8">
        <title>注册</title>
        <link rel="shortcut icon" href="{% static 'images/gt_favicon.png' %}">
        <link rel="stylesheet" href="{%static 'css/log.css' %}">
        <link rel="stylesheet" href="{%static 'css/semantic.css' %}">
    </head>
    <body class="register">
        <div class="ui center aligned grid" style="margin-top: 200px">
            <div class="ui six wide column">
                <h1 class="ui teal header"><font color="black">EricamBlog-用户注册</font></h1>
                <div class="ui segment">
                    <div class="ui content">
                        <form class="ui form" method="post" action="{%url 'register'%}"  enctype="multipart/form-data">
                            <div class="field">
                                <input type="text" name="username" placeholder="请输入用户名"><br>
                            </div>
                            <div class="field">
                                <input type="password" name="password_1" placeholder="请输入密码"><br>
                            </div>
                            <div class="field">
                                <input type="password" name="password_2" placeholder="请确认密码"><br>
                            </div>
                            <div class="field">
                                <input type="text" name="nickname" placeholder="请输入昵称"><br>
                            </div>
                            <div class="field">
                                <input type="text" name="email" placeholder="请输入邮箱"><br>
                            </div>
                            <div>头像<input type="file" name="avatar"></div>
                            {{ error }}<br>
                            <button class="ui fluid large teal button" type="submit">注册</button>
                        </form>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>
    

        
        
    现在注册模块已经完成了,但是刚才我们在编写登录页面时没有添加对于注册页面的超链接跳转,现在需要进行添加。
    在login.html里修改如下内容:
    在这里插入图片描述
    此时注册功能已经完成,大家可以自行测试。
        
        
    接下来我们再来添加忘记密码模块。
    正常情况下,忘记密码时应该发送邮件给邮箱,邮箱确认后再填写新密码。这里为了简易操作,便忽略。
    (1)添加views.py内容

    def forget_password(request):
        if request.method == 'POST':
            user_name = request.POST.get('username','')
            email = request.POST.get('email','')
            user = User.objects.filter(username = user_name)
            if user:
                user = User.objects.get(username = user_name)
                if(user.email == email):
                    request.session['user_name'] = user_name
                    return render(request,'reset.html')
                else:
                    return render(request,'forget.html',{'error':'您的用户名和邮箱不匹配!'})
            else:
                return render(request,'forget.html',{'error':'请输入正确的用户名'})
        else:
            return  render(request,'forget.html')
    
    def reset(request):
        if request.method == 'POST':
            pass_word1 = request.POST.get('password1','')
            pass_word2 = request.POST.get('password2','')
            user_name = request.session['user_name']
            user = User.objects.get(username = user_name)
            if pass_word1 == pass_word2:
                user.password = pass_word1
                user.save()
                return render(request,'login.html')
            else:
                return render(request,'reset.html', {'error': '两次密码输入不一致!'})
        else:
            return render(request,'reset.html')
    

    (2)添加forget.html和reset.html
    forget.html

    {%load static%}
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>忘记密码</title>
        <link rel="stylesheet" href="{%static 'css/log.css' %}">
        <link rel="stylesheet" href="{%static 'css/semantic.css' %}">
    </head>
    <body class="forget">
        <div class="ui center aligned grid" style="margin-top: 200px">
            <div class="ui six wide column">
                <h1 class="ui teal header">Ericam blog-忘记密码</h1>
                <div class="ui segment">
                    <div class="ui content">
                        <form class="ui form" method="post" action="{%url 'forget'%}">
                            <div class="field">
                                <input type="text" name="username" placeholder="请输入用户名"><br>
                            </div>
                            <div class="field">
                                <input type="text" name="email" placeholder="请输入邮箱"><br>
                            </div>
                            {{ error }}<br>
                            <button class="ui fluid large teal button" type="submit">下一步</button>
                        </form>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>
    

        
        
    reset.html

    {%load static%}
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>重置密码</title>
        <link rel="shortcut icon" href="{% static 'images/gt_favicon.png' %}">
        <link rel="stylesheet" href="{%static 'css/semantic.css' %}">
        <link rel="stylesheet" href="{%static 'css/log.css' %}">
    </head>
    <body class="reset">
        <div class="ui center aligned grid" style="margin-top: 200px">
            <div class="ui six wide column">
                <h1 class="ui teal header">Ericam blog-重置密码</h1>
                <div class="ui segment">
                    <div class="ui content">
                        <form class="ui form" method="post" action="{%url 'reset'%}">
                            <div class="field">
                                <input type="password" name="password1" placeholder="请输入新密码"><br>
                            </div>
                            <div class="field">
                                <input type="password" name="password2" placeholder="请确认新密码"><br>
                            </div>
                            {{ error }}<br>
                            <button class="ui fluid large teal button" type="submit">确认修改</button>
                        </form>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>
    

        
        
    (3)添加路由

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('blog/',include('blog.urls')),
        path('',views.index_unlog,name='index_unlog'),
        path('login',views.login,name='login'),
        path('log',views.logsuccess,name='login-success'),
        path('register',views.register,name='register'),
        path('forget',views.forget_password,name='forget'),
        path('reset',views.reset,name='reset')
    ]
    

        
        
    到了这里忘记密码功能已经完成,最后我们还需要添加一下超链接跳转
    打开login.html文件,修改:
    在这里插入图片描述
        
        
    【至此,登录子系统已经全部完成】

    后台美化

    django默认自带后台管理系统
    创建一个超级管理员账户:

    python manage.py createsuperuser
    

    访问:http://127.0.0.1:8000/admin/
    在这里插入图片描述
    接下来我们对后台进行美化

    pip install django-simpleui
    pip install django_summernote
    

    然后在settings.py添加:

    INSTALLED_APPS = [
        "simpleui",   #添加内容,一定要加在admin前
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'blog',
        'django_summernote'#后台富文本
    ]
    
    SUMMERNOTE_CONFIG = {
        # Using SummernoteWidget - iframe mode
        'iframe': True,  # or set False to use SummernoteInplaceWidget - no iframe mode
    
        # Using Summernote Air-mode
        'airMode': False,
    
        # Use native HTML tags (`<b>`, `<i>`, ...) instead of style attributes
        'styleWithSpan': False,
    
        # Change editor size
        'width': '80%',
        'height': '480',
    
        # Use proper language setting automatically (default)
        'lang': 'zh-CN',
    }
    

    刷新,重新进入admin页面:
    在这里插入图片描述
    给后台添加注册,方便管理数据内容:
    修改admin.py文件

    from django.contrib import admin
    from blog.models import Article,User,Category,Tag,ArticleComment,Message
    from django_summernote.admin import SummernoteModelAdmin
    
    # Register your models here.
    class PostAdmin(SummernoteModelAdmin):
        summernote_fields = ('content')  # 给content字段添加富文本
        list_display = ['article_id', 'title', 'created_time']
        search_fields = ['title']  # 搜索框
        list_filter = ['created_time']  # 过滤器
    
    #ass ArticleAdmin(admin.ModelAdmin):
    class CommentAdmin(admin.ModelAdmin):
        list_display = ['username', 'body', 'title']
        search_fields = ['title']  # 搜索框
    
    
    admin.site.register(Article, PostAdmin)
    admin.site.register(Category)
    admin.site.register(Tag)
    admin.site.register(User)
    admin.site.register(ArticleComment,CommentAdmin)
    

    修改models.py文件(完整版):

    from django.db import models
    from django.contrib import  admin
    from django.urls import reverse
    from django.utils.timezone import now
    
    
    #---------------------------------用户---------------------------------------
    class User(models.Model):
        username = models.CharField(max_length = 50)
        password = models.CharField(max_length = 200)
        nickname = models.CharField(max_length = 50,default='匿名')
        email = models.EmailField()
        created_time = models.CharField(max_length=50,default=now)
        comment_num = models.PositiveIntegerField(verbose_name='评论数', default=0)   #评论数
        avatar = models.ImageField(upload_to = 'media', default="media/default.png")  #用户头像
    
        def __str__(self):
            return self.username
    
        def comment(self):
            self.comment_num += 1
            self.save(update_fields=['comment_num'])
    
        def comment_del(self):
            self.comment_num -= 1
            self.save(update_fields=['comment_num'])
    
    #---------------------------------文章评论---------------------------------------
    class ArticleComment(models.Model):
        body = models.TextField()
        username = models.CharField(max_length=50)
        userimg = models.CharField(max_length=70)
        nickname = models.CharField(max_length=50,default="匿名")
        createtime = models.DateTimeField(verbose_name='创建时间', default=now)
        article = models.CharField(max_length=50)
        title = models.CharField(max_length=50)
        # 使对象在后台显示更友好
        def __str__(self):
            return self.article
    
        class Meta:
            ordering = ['-createtime']
            verbose_name = '评论'  # 指定后台显示模型名称
            verbose_name_plural = '评论列表'  # 指定后台显示模型复数名称
            db_table = "comment"  # 数据库表名
    
        list_display = ('article', 'body')
    
    #---------------------------------博客文章标签---------------------------------------
    class Tag(models.Model):
        name = models.CharField(verbose_name='标签名', max_length=64)
    
        # 使对象在后台显示更友好
        def __str__(self):
            return self.name
    
        class Meta:
            ordering = ['name']
            verbose_name = '标签名称'  # 指定后台显示模型名称
            verbose_name_plural = '标签列表'  # 指定后台显示模型复数名称
            db_table = "tag"  # 数据库表名
    
    #---------------------------------博客文章分类---------------------------------------
    class Category(models.Model):
        name = models.CharField(verbose_name='类别名称', max_length=64)
    
        class Meta:
            ordering = ['name']
            verbose_name = "类别名称"
            verbose_name_plural = '分类列表'
            db_table = "category"  # 数据库表名
    
        # 使对象在后台显示更友好
        def __str__(self):
            return self.name
    
    #---------------------------------博客文章---------------------------------------
    class Article(models.Model):
        STATUS_CHOICES = (
            ('d', '草稿'),
            ('p', '发表'),
        )
        article_id = models.CharField(verbose_name='标号', max_length=100)
        title = models.CharField(verbose_name='标题', max_length=100)
        content = models.TextField(verbose_name='正文', blank=True, null=True)
        status = models.CharField(verbose_name='状态', max_length=1, choices=STATUS_CHOICES, default='p')
        views = models.PositiveIntegerField(verbose_name='浏览量', default=0)
        created_time = models.DateTimeField(verbose_name='创建时间', default=now)
        category = models.ForeignKey(Category, verbose_name='分类', on_delete=models.CASCADE, blank=False, null=False)
        tags = models.ManyToManyField(Tag, verbose_name='标签集合', blank=True)
    
        # 使对象在后台显示更友好
        def __str__(self):
            return self.title
    
        # 更新浏览量
        def viewed(self):
            self.views += 1
            self.save(update_fields=['views'])
    
        # 下一篇
        def next_article(self):  # id比当前id大,状态为已发布,发布时间不为空
            return Article.objects.filter(id__gt=self.id, status='p', pub_time__isnull=False).first()
    
        # 前一篇
        def prev_article(self):  # id比当前id小,状态为已发布,发布时间不为空
            return Article.objects.filter(id__lt=self.id, status='p', pub_time__isnull=False).first()
    
        class Meta:
            ordering = ['-created_time']  # 按文章创建日期降序
            verbose_name = '文章'  # 指定后台显示模型名称
            verbose_name_plural = '文章列表'  # 指定后台显示模型复数名称
            db_table = 'article'  # 数据库表名
            get_latest_by = 'created_time'
    
    

    记得使用python manage.py migrate进行生成数据库文件。
    此时访问后台:
    在这里插入图片描述
    写文章时富文本工具也加载了出来:
    在这里插入图片描述

    完整项目获取

    重构了代码,同时更新了博客内容,关键难点已经写下来了。
    如果有问题欢迎在评论区提问。
    如果想要获取完整项目,请扫码赞助该项目。
    获取方式:扫码赞助,留言邮箱地址。
    在这里插入图片描述

    尾言

    其他子模块和该模块大同小异,暂时就不写了。
    其中评论提交和删除采取的是ajax交互形式。
    如果大家看了觉得有帮助请点赞,为了大家重新写了这篇文章,同时重构了代码,确保一定能跑通。

     

    展开全文
  • Django

    万次阅读 多人点赞 2019-09-02 15:36:17
    Django 一,简介 Django是一个开放源代码的Web应用框架,由Python写成。采用了MTV的框架模式,即模型M,视图V和模版T。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的,即是CMS(内容管理...
  • Django框架实现在线考试系统

    万次阅读 多人点赞 2019-06-21 19:30:00
    遇见Django框架之简单版在线考试系统1.Django的简介2.项目的设计思路3.搭建你的开发环境4.分模块设计5.总结 1.Django的简介 Django是一个基于MVC构造的框架。但是在Django中,控制器接受用户输入的部分由框架自行...
  • django-allauth是最受欢迎的管理用户登录与注册的第三方Django安装包。它非常强大,能实现以下核心功能。今天我么就来看看如何使用它,简化我们用户注册,登录及账户管理。用户注册用户登录退出登录第三方auth登录...
  • Django-Form组件

    2020-10-20 13:27:26
    Django前端数据与服务器数据交互 一、服务器数据传递给客户端 1、服务器 def class_list(request): cla_list=models.Classes.objects.all() return render(request,‘cla_list.html/’,{‘cla_list’:cla_list}) 2、...
  • windows中Django安装教程

    千次阅读 2016-06-13 11:34:58
    一、下载 ...Django下载地址:https://www.djangoproject.com/download/ 二、安装 默认已经安装了Python,这里就只将django的安装 ...(1)下载django压缩包后,解压并且将文件夹放入python的安装目录中,然后进入d
  • Python进阶(二十三)-Django使用pymysql连接MySQL数据库做增删改查  IDE说明:   Python:3.5   Django:1.10   Pymysql:0.7.10   Mysql:5.5   注:Django1.10默认使用的是mysqlDB模块来操作数据库,...
  • Python进阶(三十六)-Web框架Django项目搭建全过程

    万次阅读 多人点赞 2017-04-15 08:53:16
    Python Web框架Django项目搭建全过程   IDE说明: Win7系统 Python:3.5 Django:1.10 Pymysql:0.7.10 Mysql:5.5   Django 是由 Python 开发的一个免费的开源网站框架,可以用于快速搭建高性能,优雅的网站!...
  • Django缓存Cache详解

    万次阅读 多人点赞 2018-07-30 12:48:17
    今天我们就来看看缓存Cache应用场景及工作原理吧,并详细介绍如何在Django中设置Cache并使用它们。 什么是缓存Cache 缓存是一类可以更快的读取数据的介质统称,也指其它可以加快数据读取的存储方式。一般用来...

空空如也

1 2 3 4 5 ... 20
收藏数 280,898
精华内容 112,359
关键字:

django