[使用Python编写并部署个人静态博客:(一)分析与设计](https://suiyan.cc/2023/20230410075954.html)

[使用Python编写并部署个人静态博客:(二)实现静态页面的输出](https://suiyan.cc/2023/20230420101527.html)

[使用Python编写并部署个人静态博客:(三)搜集博客数据](https://suiyan.cc/2023/20230517084718.html)

[使用Python编写并部署个人静态博客:(四)逐步输出静态页面](https://suiyan.cc/2023/20230609081842.html)

[使用Python编写并部署个人静态博客:(五)Python异步输出博文页面](https://suiyan.cc/2023/20230613193700.html)

## 生成博文页面

博客文章页面的数量可多可少，如果坚持写作，一个博客文章数目可达数百数千，对于静态博客来说，页面上的结构、css等一旦更新，所属的文章页面也需要相应的更新，所以对于页面的批量生成和更新需要更快才是最佳，这里推荐Python的异步协程文件处理方法，可以达到很不错的速度！

## 技术选择

在大批量生成页面的时候，我做了一些测试，单线程和多线程、线程池、还有异步协程，最终的测试速度在生成和保存HTML页面的操作上还是异步协程快了很多，因为IO密集型的操作异步有很大的优势。那么既然确定，就开始吧：

    import asyncio
    import aiofiles

引入依赖，aiofiles是异步的文件操作。

## 编写代码

    ct = [create_blog_html(blogdata, tagsdata, tmp, blog) for blog in blogdata]  # 列表生成式
        loop = asyncio.new_event_loop()
        loop.run_until_complete(asyncio.wait(ct))

create_blog_html()方法负责根据数据生成博文的HTML页面，创建一个列表生成式，包含了所有准备生成文章页面，调用asyncio.get_event_loop()获取事件循环对象，loop.run_until_complete(asyncio.wait(ct))用来运行事件循环，直到所有任务都完成。

create_blog_html()方法中的代码就不贴了，具体可以查看GitHub的代码仓库，地址在页面最下边哪里有。同样首页和列表页面一是采用相同的方法生成的。

## 总结

使用Python的异步大大提高了页面的生成速度，几百上千的页面瞬间就可以生成，如果不习惯异步的方式，多线程也可以的，但是速度先对来说会慢那么一丢丢的。

对于静态博客来说，对于页面的批量生成和更新需要更快的速度才是最佳，这里推荐Python的异步协程文件处理方法，可以达到很不错的速度！

使用Python编写并部署个人静态博客:(五)Python异步输出博文页面


![矩阵头像](https://suiyan.cc/assets/images/2023/ax.gif)

使用之前编写的 Matrix JavaScript 代码生成器做了一个动态的头像，效果还不错，分享给大家，喜欢的可以试一下，做好了嵌入自己的网站使用还是挺酷的！

## 生成代码

首先打开下边的网址，设置自己的头像属性，例如，尺寸 200\*200，还有下落的字符列数和每列字符的个数，起始坐标等，总之先调试出一个满意的矩阵，然后在继续镶嵌在站点内使用。



[Matrix 矩阵 JavaScript 代码生成器](https://suiyan.cc/matrix/index.html)


## 网页设置

1. 在你需要插入头像的地方，放置`<canvas id="matrix"></canvas>`
2. 复制生成的代码插入到页面中的`<script>`标签中。
3. 此时，你的页面已经显示出一个正方形的矩阵动画，为`#matrix`添加CSS`    border-radius: 50%!important;`,头像就会变成圆形的了。

好了，简单吧？赶紧试试吧，当然你也可以制作其他尺寸的矩阵来装饰页面。

使用之前编写的Matrix JavaScript代码生成器做了一个动态的头像，效果还不错，分享给大家，喜欢的可以试一下，做好了嵌入自己的网站使用还是挺酷的！

一键生成Matrix动态头像

在web日常中表单是必不可少的，处理数据的输入与交互在web站点中是非常重要的，Django提供了一系列的工具和库来帮助您构建表单来接收网站访客的输入，然后处理以及响应这些输入。

## HTML表单

表单在HTML使用`<form></form>`标签包围，它包括很多表单标签，例如输入框、单选和多选框、文本输入域等，处理表单是通过get或post方法来传输数据，在表单的action中指定一个URL，数据会提交到这个URL来进行响应，其中get会明文以键值方式，通过URL地址来发送表单中的数据。

## 使用Django的表单

Django中使用表单是非常简单的，甚至可以不用去写任何的HTML，Django封装大量的常用表单，只需要配置表单的相关选项即可使用。

### 构建Form 类

在使用Django表单前需要创建相关表单的类，例如：

    from django import forms

    class ArticleForm(forms.Form):
        title = forms.CharField(label="title", max_length=100)
        content = forms.CharField(widget=forms.Textarea(attrs={'rows':'5'}))

引入Django表单类forms，创建表单类，创建字段并设置字段的属性和widget，上边定义了两个字段。

### 视图中使用表单


    def test_form(request):
        if request.method == 'POST':
            form = ArticleForm(request.POST)
            if form.is_valid():
                return HttpResponseRedirect("/show/")
        else:
            form = ArticleForm()
            return render(request, "test_form.html", {'form': form})


    def show(request):
    if request.method == "POST":
        # print(request.POST)
        title = request.POST.get('title')
        content = request.POST.get('content')
        return HttpResponse("title:"+title+"</br>content:"+content)


`test_form`负责创建表单，`form = ArticleForm({'title':'11','content':'222'})`可以预填充表单的内容。

`show`用来响应并接收表单发来的数据，用来展示数据。

### 设置路由

    path("test_form/", views.test_form, name="test_form"),
    path("show/", views.show, name="show"),

然后运行Django的服务器，打开`http://127.0.0.1:8000/myapp/test_form/`，提交数据，在show的页面显示数，类似下边：

    title:11
    content:222

## 总结

至此，一个表单的完整使用就基本设置完成，表单类和飙到的小部件还有很多的属性，这里就不一一介绍了，可以参考下边的网址。

参考网站：

[使用表单](https://docs.djangoproject.com/zh-hans/4.2/topics/forms/)

[表单 AP](https://docs.djangoproject.com/zh-hans/4.2/ref/forms/api/)

[Widgets 小部件](https://docs.djangoproject.com/en/4.2/ref/forms/widgets/)

[使用Request and response表单](https://docs.djangoproject.com/en/4.2/ref/request-response/)


在web日常中表单是必不可少的，处理数据的输入与交互在web站点中是非常重要的，Django提供了一系列的工具和库来帮助您构建表单来接收网站访客的输入，然后处理以及响应这些输入。

Django 4.2 复习笔记(九)Django Forms 使用表单

每次看到有关独立博客的博文，都觉得这类博文比较沉闷悲观，大多都是阐述玩独立博客的人不多或是越来越少，充满着怀旧的复古气息，博主一般都会对自己从建站到现在是如何坚持过来的洋洋洒洒的写上一篇，嗯？咱就爱看这类的博文，一个博主真实的一面。

## 独立博客怎么了？

早几年还在拨号上网的时候就在网上鼓秋过几个个人博客，或者说那不能叫做博客，当年可以免费申请各种各样的在线论坛、个人主页，还有免费的域名，免费空间随处可见，整个世界都在为网民提供建立自己“博客”的有利条件，那时候个人主页如雨后春笋搬的泛滥，你有QQ吗？你的个人主页网址是撒？手里没几个域名都不好意思说自己上过网。

但是随着QQ空间、新浪博客等一些平台的出现，折腾独立个人博客的越来越少了，再往后，国内的网站都需要备案了，一下子干倒了一大片个人网站，门户网站的崛起，微博、长、短视频、网络游戏的兴起，很快改变了网民的习惯，打游戏刷视频不香么？搞什么独立博客哈？

## 回归

时尚总是轮回的，或许当年的大花花裙子没成为主流，但今天却成为了巴黎时尚的耀眼新星。人们会疲惫于一种重复的生活和习惯，当大多数人发现自己被困与当下的互联网信息之中的时候，独立和自由就会显得格外的可贵，恰好，个人独立博客正好契合这个需求。

在《十年之约》的QQ群里，我经常发现好多年轻人在打理自己的独立博客，我一直以为当代的年轻人不会去创建维护自己的独立博客，因为如今的互联网对于博客来说，可替代的产品实在太多了，能在这么热闹的互联网中选择建立并维护独立博客的孩子们是怎样想的呢？

远离互联网的喧闹，在自己的安静的“小岛”上写作，或是精神上的依托，或是烦恼的宣泄，或是灵感的并发，无所谓写什么，哪怕是一些流水账，或许那些文字不愿意发表在朋友圈，单在这里却可以尽情的写作。

## 一个人的孤独

独立博客大多都是很少有人来访的，像我这样的技术博客更是小众了，零星的流量来自Google bing，百度？噗嗤。有的时候觉得写博客很无聊也没啥用途，但有的时候觉得记下一些技术点滴，以后自己查阅也能方便他人也是极好的。

## 独立博客的未来

我对独立博客的未来还是很有信心的，随着AI的普及，独立博客就变得更加稀有了，当你读者AI生成的文字，久了，你就会想，什么时候能看到一篇作者匆忙发表的博客，哪怕有些错字，至少这是人类写的，而不是AI为了迎合我的兴趣喜好生成的爽文。

好看的博客千篇一律 有趣的博主万里挑一

独立博客，你折腾主题也好，记录生活也好，写写小诗，记录BUG的解决过程，分享资源和教程。。。。。什么都好，记得你的初心，别被SEO给魔化了，喜欢就好好的喜欢，不离不弃方得始终。加油！坚持独立博客的朋友们。

每次看到有关独立博客的博文，都觉得这类博文比较沉闷悲观，大多都是阐述玩独立博客的人不多或是越来越少，充满着怀旧的复古气息，博主一般都会对自己从建站到现在是如何坚持过来的洋洋洒洒的写上一篇，嗯？咱就爱看这类的博文，一个博主真实的一面。

好看的博客千篇一律 有趣的博主万里挑一

[使用Python编写并部署个人静态博客:(一)分析与设计](https://suiyan.cc/2023/20230410075954.html)

[使用Python编写并部署个人静态博客:(二)实现静态页面的输出](https://suiyan.cc/2023/20230420101527.html)

[使用Python编写并部署个人静态博客:(三)搜集博客数据](https://suiyan.cc/2023/20230517084718.html)

[使用Python编写并部署个人静态博客:(四)逐步输出静态页面](https://suiyan.cc/2023/20230609081842.html)

[使用Python编写并部署个人静态博客:(五)Python异步输出博文页面](https://suiyan.cc/2023/20230613193700.html)

## 啰嗦几句

使用Python编写并部署个人静态博客这个系列写第一篇的时候这是信心满满，以为会有很多同道中人，但是发现独立博客都挺少了，自己编写并部署博客的更是少的可怜。这就好比用电饭锅做饭，难道还要自己研究怎么做电饭锅？直接使用WordPress或一些静态站点生成器不好吗？嗯，挺好的，但是我还是选择自己编写并部署自己的博客。啰嗦完毕，继续讨论技术。

## 确定博客的相关页面

首先要确定博客的相关页面，例如：首页、标签页、归档、友联等页面，确定页面的结构也就是页面上该有的元素，可以用笔在纸上画画草图，大概有个框架，然后在逐一筛选和确定，对于自己编写代码，在功能上应劲量简约实用，要考虑到静态页面的输出需要哪些方法来实现，边构思边设计，切忌盲目好大喜功或是追求极致和完美，如果这样的话，估计没等你开始编写就会失去动力了，力求极简，实现主要功能为主，并为后续留下优化和补充的路子。

## 编写相关页面的输出方法

当你确定好所需的页面和功能后，就可以开始编写输出静态页面的方法了，生成器主要负责页面的数据整理，然后发送给jinja2模板引擎负责渲染，前端配合一些CSS、avaScript库或框架来进行页面的布局和美化，不要在生成器那里输出任何页面相关的HTML代码，不然后期修改会很麻烦，只有分清工作程序，之后出现问题才会知道去哪里解决。

## 具体实现

这里以实现归档页面的生成为例，首先组织页面的数据，归档页面的数据无非就是一个数组，这个数组包含了按着年月份分组的数据，每一个数组里包含着当月的博客文章数据，以时间为归类，分别展示当月份的博文，这里只是把数据整理出发送给jinja2模板，模板才负责组织HTML。

下边是完整代码：

    def create_archives_html():
        """生成archives.html"""
        blog_data = load_blogdata_json(BLOGDATAJSON)
        config = load_configjson(CONFIGJSON)
        # 设置jinja模板
        env = Environment(loader=FileSystemLoader(os.path.join(THEME, config["theme"])))
        context = create_context()
        tmp = env.get_template("archives.html")  # 模板
        archives_html_path = os.path.join(BLOGPAGES, 'archives.html')  # 首页HTML
        # 组装archives页面的上下文数据。
        data = formatdata(blog_data)
        for k in data:
            k["num"] = len(k["data"])
        context["pages_num"] = len(blog_data)
        context["update"] = blog_data[0]["time"]
        context["archives"] = data
        context["title"] = "Archives"
        with open(archives_html_path, mode='w', encoding='utf-8') as f:
            f.write(tmp.render(**context))
        logger.info('生成archives.html成功！')

首先获得所有的博文数据，然后获取jinja2模板和博客的上下文，`data = formatdata(blog_data)`这里是根据所有博客的数据进行了一个时间排序和分组返回了一个归档数据。最后组织其他相关的上下文，结合模板输出到静态页面。

## 总结

大体上每个单独的页面都是这样生成的，而有些页面则是需要批量生成，这个留到下节再说吧，这里涉及到了Python的多线程和异步编程，之后好好聊聊。

使用Python编写并部署个人静态博客这个系列写第一篇的时候这是信心满满，以为会有很多同道中人，但是发现独立博客都挺少了，自己编写并部署博客的更是少的可怜。这就好比用电饭锅做饭，难道还要自己研究怎么做电饭锅？直接使用WordPress或一些静态站点生成器不好吗？嗯，挺好的，但是我还是选择自己编写并部...

使用Python编写并部署个人静态博客:(四)逐步输出静态页面

> 复制文本到剪贴板本应该不难。它不应该需要配置的繁琐步骤或大量的加载空间。最重要的是，它不应该依赖于Flash或任何臃肿的框架。

## 简介

今天开发的时候遇到一个功能，就是把浏览器input组件中的文本复制到剪贴板，当时大概觉得应该会有现成的库类，所以一搜索，就搜到了：`clipboard.js`。`clipboard.js `是一个轻量级的 JavaScript 库，用于简化在网页中执行复制操作到剪贴板的过程。它没有依赖于任何第三方库或插件，仅仅使用原生的JavaScript。

使用 clipboard.js，您可以通过几行代码实现将文本、HTML 或其他数据复制到剪贴板。它提供了一种简单而一致的方式来处理跨浏览器的剪贴板操作，避免了处理各种浏览器兼容性问题的烦恼。

## 使用方法

1. 引入CDN：
   
    
    <script src="https://cdn.jsdelivr.net/npm/clipboard@2.0.11/dist/clipboard.min.js"></script>

2. 绑定按钮的DOM：

    new ClipboardJS('.btn');

3. HTML代码：

复制input中的字符：

    
    <input id="foo" value="https://github.com/zenorocha/clipboard.js.git">

    
    <button class="btn" data-clipboard-target="#foo">
        <img src="assets/clippy.svg" alt="Copy to clipboard">
    </button>

复制textarea中的字符：

    
    <textarea id="bar">Mussum ipsum cacilds...</textarea>

    
    <button class="btn" data-clipboard-action="cut" data-clipboard-target="#bar">
        Cut to clipboard
    </button>

嗯，就是这么简单，不要重复造轮子，很浪费时间的：）

复制文本到剪贴板本应该不难。它不应该需要配置的繁琐步骤或大量的加载空间。最重要的是，它不应该依赖于Flash或任何臃肿的框架clipboard.js。

clipboard.js 一款简单好用的将文本复制到剪贴板的现代方法

今天，有一个应用需要更高版本的node.js，但是我从来都没有升级过node.js，特意Google了一下，发现一个超级简单的升级node.js的方法，这里简单的记录一下。

## 升级方法

node有一个模块叫`n`，没错，就是一个字母：n,是专门用来管理node.js的版本的。

1. 首先安装n模块：

    npm install -g n

2. 升级node.js到最新稳定版

    n stable

如果顺利的话，你已经升级到了node.js最新稳定版了。

3. n后面也可以跟随版本号比如：

    n v18.15.0

或者

    n 18.16.0

就这么简单，无敌的一行代码升级node.js。


今天，有一个应用需要更高版本的node.js，但是我从来都没有升级过node.js，特意Google了一下，发现一个超级简单的升级node.js的方法，这里简单的记录一下。

一行代码升级你的node.js为最新稳定版

今天有一段代码需要用到JavaScript的防抖功能，忽的想起lodash中有这个功能函数，由于代码比较简单，只需直接引用CDN即可，便在网上搜了CDN直接引入，但是在使用_.debounce方法的时候却报错`_.debounce is not a function`!真是奇了个怪了！

## 问题分析及解决方法

然后我就做了一些简单的测试，通过log打印一些lodash中的方法和属性，发现`_.VERSION`可以正常的打印lodash的版本，但是`_.debounce`确报错`_.debounce is not a function`！这怎么回事？难道这个CDN的代码库里没有`debounce`这个方法？哎！还真没有！

原来是我引用的CDN的代码有问题，我引用的是`lodash.core.min.js`，这是 Lodash 的核心版本，包含了 Lodash 库中的核心函数和常用功能，但不包含一些较大或较少常用的模块。所以有些功能是没有的，后来换成`lodash.min.js`,这是 Lodash 的完整版本，包含了 Lodash 库的所有函数和功能模块。这个版本的文件大小较大，适合在拥有较大资源或需要使用 Lodash 的所有功能时使用。

总结来说，lodash.core.min.js 是 Lodash 的精简核心版本，只包含核心函数和常用功能，文件较小；而 lodash.min.js 则是完整版本，包含了所有函数和功能模块，文件较大。这下问题解决了。。。好久没写JavaScript，真的都是把学到的东西都给忘记了。太菜了！

今天有一段代码需要用到JavaScript的防抖功能，忽的想起lodash中有这个功能函数，由于代码比较简单，只需直接引用CDN即可，便在网上搜了CDN直接引入，但是在使用_.debounce方法的时候却报错`_.debounce is not a function`!真是奇了个怪了！

CDN引用lodash报错 _.debounce is not a function

![Matrix 矩阵 JavaScript代码生成器](https://suiyan.cc/Matrix/assets/images/matrix.gif)

今天写了个Matrix 矩阵 JavaScript代码生成器，其实几年前就用Python的pygame实现过一个Matrix，最近在玩JavaScript canvas，索性使用JavaScript原生代码又撸了一遍，并且做了个代码生成器，方便修改Matrix的一些参数。

## matrix动画原理

制作matrix动画是一个很有意思的过程，涉及到数组的一些基本操作，还有就是数组的循环和遍历，需要用到JavaScript数组中的一些方法，查看代码对于初学者来说可以学到一些很基础的知识。

matrix就是一个二位数组，`[[a,b],[a,b],[a,b]]`整个下落的字符就是这个二位数组，其中下落的每一列就是这个大数组中的一个小数组，每个字符就是小数组的一个元素。

我们定义每列下落的字符串样式、起始位置和下落的速度不一样，既可以达到视差效果，每列字符串消失后，就会自动创建一个新的字符串列，这样就会源源不断的下落。

理论上就是这样了，关于JavaScript canvas，只需了解文字绘制和动画的循环，就可以开始至编写代码了，具体的代码就不贴了，有需要的可以在下边的网址上自动生成。

## 相关资源

[Matrix 矩阵 JavaScript代码生成器](https://suiyan.cc/Matrix/)


[Matrix 代码生成器的仓库](https://github.com/bosichong/Matrix)

今天写了个Matrix 矩阵 JavaScript代码生成器，其实几年前就用Python的pygame实现过一个Matrix，最近在玩JavaScript canvas，索性使用JavaScript原生代码又撸了一遍，并且做了个代码生成器，方便修改Matrix的一些参数。

Matrix 矩阵 JavaScript代码生成器

web站点的上下文对于新手可能有些陌生和晦涩，这个东西有什么用？上下文就是一个变量或是函数，在整个web站点中都可以调用并获取其中定义的值。在Django中，全局上下文（Global Context）是指在每个视图中都可用的全局变量或函数，可以在模板中直接访问。Django提供了一种机制来定义全局上下文，使得这些变量或函数在所有的模板中都可以使用。

要定义全局上下文，可以使用Django的上下文处理器（context processor）。上下文处理器是一个Python函数，它接收一个HttpRequest对象作为参数，并返回一个包含上下文变量的字典。这个字典将会被添加到每个模板的上下文中。

1. 创建一个Python文件，例如"myapp/context_processors.py"。
2. 在文件中定义一个函数，接收一个HttpRequest对象作为参数，并返回一个包含上下文变量的字典。例如：



    def my_global_context(request):
            return {
                'site_name': 'suiyan_blog'
            }
    
        

3. 在Django的配置文件（settings.py）中找到TEMPLATES设置。在OPTIONS部分的context_processors列表中添加你的上下文处理器的路径。例如：


    TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [],
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    ...
                    'myapp.context_processors.my_global_context',
                    ...
                ],
            },
        },
    ]


4. 现在，你可以在任何模板中使用my_variable变量。例如，在一个模板文件中：
  
        <p>{{ my_variable }}</p>

Django的上下文可以用来定义类似博客每个页面上的站点和站长资料、分类、标签集合、底部版权信息等，这样在整个web的站点访问任何地方都可以调用，极大的方便了开发者编写开发web站点的对应功能。

web站点的上下文对于新手可能有些陌生和晦涩，这个东西有什么用？上下文就是一个变量或是函数，在整个web站点中都可以调用并获取其中定义的值。在Django中，全局上下文（Global Context）是指在每个视图中都可用的全局变量或函数，可以在模板中直接访问。Django提供了一种机制来定义全局上...

Django 4.2 复习笔记(九)使用Django的上下文处理器（context processor）

在Python中进行一些不是很复杂的数据库操作的时候我们都会选择使用一些ORM框架，主要的ORM框架包括Django ORM、SQLAlchemy、Pony ORM、Peewee和Tortoise ORM等。这里Django ORM在使用方面更为简单和人性化。但是Django ORM和Django的绑定很紧密，如何单独使用Django ORM呢？

## 安装依赖

如果需要使用Django的ORM必须安装Django的相关依赖：

### 安装Django

    pip install Django

### 创建Django的项目

    django-admin startproject mysite

### 创建模型

    from django.db import models
    class Article(models.Model):
        title = models.CharField(max_length=128,verbose_name='文章标题')
        content = models.TextField(verbose_name='文章内容')

### 配置数据库

一般创建完数据库后会有一个默认的SQLite默认数据库配置

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': BASE_DIR / 'db.sqlite3',
        }
    }

### 激活模型

定义完模型，首先需要生成相关的数据库和表，然后通过Django的命令行进行调试。

配置文件mysite/settings.py中添加`myapp`，`myapp`是你的应用名称。

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

然后，终端下运行：

    $ python manage.py makemigrations myapp
    Migrations for 'myapp':
    myapp/migrations/0001_initial.py
        - Create model Article

继续：

    $ python manage.py migrate

这个时候就会生成相关的数据库，当然Django一些自带的项目依赖的数据库也一并创建了。


## Python中使用Django ORM

终端下的交互调试这里就不介绍了，说下如何在Python的文件中使用Django ORM。

在manage.py同目录下创建一个测试的Python文件，这里暂时为ORM.py.

`ORM.py`

    import os
    import django

    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')
    django.setup()


    from myapp.models import *

    if __name__ == '__main__':
        art = Article(title="引用测试",content="这里是内容")
        art.save()
        print(art.id)

在非Django项目中使用Django ORM时需要进行的初始化步骤,主要代码就是：

    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')
    django.setup()

首先，os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings') 这行代码将环境变量 DJANGO_SETTINGS_MODULE 的值设置为 'mysite.settings'，如果该环境变量已经存在，则不进行任何更改。这个环境变量用于指定 Django 的设置模块，即包含 Django 项目配置的 Python 模块。

接下来，django.setup() 调用用于初始化 Django 的函数。它会根据 DJANGO_SETTINGS_MODULE 环境变量指定的设置模块来加载并配置 Django。这个函数通常在使用 Django ORM 之前被调用，以确保 Django 正确配置和准备就绪。

通过这两行代码，我们设置了 DJANGO_SETTINGS_MODULE 环境变量，并使用 django.setup() 进行初始化，以便在后续的代码中可以使用 Django ORM 或其他 Django 的功能。

运行ORM.py，就可以看到打印出新加入的数据的ID值了。以上就是在非Django项目中使用Django ORM的方法。

在Python中进行一些不是很复杂的数据库操作的时候我们都会选择使用一些ORM框架，主要的ORM框架包括Django ORM、SQLAlchemy、Pony ORM、Peewee和Tortoise ORM等。这里Django ORM在使用方面更为简单和人性化。但是Django ORM和Django的...

如何单独使用Django ORM 在非Django项目中使用Django ORM？

Django的页面渲染是通过Django的模板语法在模板中渲染上下文的变量来进行输出的，Django 的模板语言是为了在强大和简单之间取得平衡而设计的。它的设计让习惯于使用 HTML 的人感觉很舒服。如果你接触过其他基于文本的模板语言，如 Smarty 或 Jinja2 ，你应该会对 Django 的模板感到很舒服。

## 模板文件格式

模板是一个文本文件。它可以生成任何基于文本的格式（HTML、XML、CSV 等），模板中包含变量和标签。

一个简单的案例：

    {% extends "base_generic.html" %}

    {% block title %}{{ section.title }}{% endblock %}

    {% block content %}
    <h1>{{ section.title }}</h1>

    {% for story in story_list %}
    <h2>
    <a href="{{ story.get_absolute_url }}">
        {{ story.headline|upper }}
    </a>
    </h2>
    <p>{{ story.tease|truncatewords:"100" }}</p>
    {% endfor %}
    {% endblock %}

## 变量

模板语法：

    view：｛"HTML变量名" : "views变量名"｝
    HTML：｛｛变量名｝｝

其中变量可以为Python中的各种变量类型，例如：单一的变量，或是集合类的变量如list、dict等。

## 标签

标签是这样的： {% tag %}。标签比变量更复杂。有的在输出中创建文本，有的通过执行循环或逻辑来控制流程，有的将外部信息加载到模板中，供以后的变量使用。


## if else

    {% if condition1 %}
    ... display 1
    {% elif condition2 %}
    ... display 2
    {% else %}
    ... display 3
    {% endif %}

## 遍历 for

    <ul>
    {% for athlete in athlete_list %}
        <li>{{ athlete.name }}</li>
    {% endfor %}
    </ul>


## 过滤器

通过使用过滤器修改显示的变量。过滤器是这样的： `{{ name|lower }}`。这将显示 lower 过滤器过滤后的 `{{ name }}` 变量的值，该过滤器将文本转换为小写。使用管道（|）来应用过滤器。

例如：

    {{ value|length }}

上边会输出数组的长度。

当然过滤器有很多的，具体可以查看官方的列表：[内置过滤器参考](https://docs.djangoproject.com/zh-hans/4.2/ref/templates/builtins/#ref-templates-builtins-filters)


## 模板继承

Django 的模板引擎中最强大的——也是最复杂的——部分是模板继承。模板继承允许你建立一个基本的“骨架”模板，它包含了你网站的所有常用元素，并定义了子模板可以覆盖的块。

base.html：

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <link rel="stylesheet" href="style.css">
        <title>{% block title %}My amazing site{% endblock %}</title>
    </head>

    <body>
        <div id="sidebar">
            {% block sidebar %}
            <ul>
                <li><a href="/">Home</a></li>
                <li><a href="/blog/">Blog</a></li>
            </ul>
            {% endblock %}
        </div>

        <div id="content">
            {% block content %}{% endblock %}
        </div>
    </body>
    </html>


这个模板，我们称之为 `base.html`，它定义了一个 HTML 骨架文档，你可以用它来制作一个两栏式页面。“子”模板的工作是用内容填充空块。

在这个例子中，`block` 标签定义了三个块，子模板可以填入其中。`block` 标签所做的就是告诉模板引擎，子模板可以覆盖模板的这些部分。

子模板继承：

    {% extends "base.html" %}

    {% block title %}My amazing blog{% endblock %}

    {% block content %}
    {% for entry in blog_entries %}
        <h2>{{ entry.title }}</h2>
        <p>{{ entry.body }}</p>
    {% endfor %}
    {% endblock %}

`{% extends "base.html" %}`表示继承模板`bas.html`。`{% block title %}My amazing blog{% endblock %}`就是在改写模板中可以自定义的内容，通过这种继承的方式，可以构建复杂的网页。

## 总结

Django的模板语法还有很多功能可以使用，熟练这些功能可以大大的提高页面渲染开发的素的。

参考文章：

[Django 模板语言](https://docs.djangoproject.com/zh-hans/4.2/ref/templates/language/)

[菜鸟教程 Django 模板](https://www.runoob.com/django/django-template.html)


Django的页面渲染是通过Django的模板语法在模板中渲染上下文的变量来进行输出的，Django 的模板语言是为了在强大和简单之间取得平衡而设计的。它的设计让习惯于使用 HTML 的人感觉很舒服。如果你接触过其他基于文本的模板语言，如 Smarty 或 Jinja2 ，你应该会对 Django ...

Django 4.2 复习笔记(八)Django 模板语言语法

作为一个网络框架，Django 需要一种方便的方式来动态生成 HTML，最常见的方法是依靠模板，一个模板包含了所需HTML输出的静态部分，以及一些特殊的语法，描述了如何插入动态内容。

## 配置Django模板引擎

配置Django模板引擎：在Django项目的设置文件中（settings.py），确保'Django.template.backends.django.DjangoTemplates'引擎被包含在TEMPLATES设置的'BACKENDS'中。

这是Django创建项目后默认的模板配置：

    TEMPLATES = [
        {
            'BACKEND':  'django.template.backends.django.DjangoTemplates',
            'DIRS':     [],
            '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',
                ],
            },
        },
    ]

下面是修改添加并设置了模板目录的配置项：

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

告诉Django要启用Django自带的模板引擎。

    "BACKEND": "django.template.backends.django.DjangoTemplates",
    "APP_DIRS": True,

指定模板文件的存放目录为项目的子目录下`templates`

    'DIRS': [os.path.join(BASE_DIR, 'templates')],# 修改位置

至此，Django模板就配置好了。

## 使用Django的模板

在模板文件（例如，template.html）编写模板文件：

    <html>
    <head>
        <title>{{ title }}</title>
    </head>
    <body>
        <h1>Hello, {{ name }}!</h1>
        {% if age %}
            <p>Your age is {{ age }}.</p>
        {% else %}
            <p>Your age is not specified.</p>
        {% endif %}
    </body>
    </html>

配置好路由：

    urlpatterns = [
        path("", views.index, name="index"),
        path("test_view/", views.test_view, name="test_view"),
    ]

在上述示例中，视图函数test_view创建了一个包含'title'、'name'和'age'的上下文对象。然后使用render函数将模板文件名、上下文对象和请求作为参数传递。最后Django将渲染模板并返回最终的HTML响应。

我们启动Django的服务器来进行测试：`python manage.py runserver`

我们就可以正常的看到模板渲染出来的页面了。

## 总结

以下是使用Django模板的基本步骤：

1. 配置Django模板引擎：在Django项目的设置文件中（settings.py），确保'Django.template.backends.django.DjangoTemplates'引擎被包含在TEMPLATES设置的'BACKENDS'中。

2. 创建模板文件：在Django项目的一个目录中，创建一个包含HTML代码的模板文件。通常，模板文件位于一个名为'templates'的子目录中。

3. 定义模板变量：在模板中，可以使用双大括号（{{ variable_name }}）来包围变量名，以将其插入到模板中。

4. 控制流和逻辑：在模板中，可以使用控制结构（如if语句和for循环）来控制显示的内容。

5. 继承和包含：Django模板还支持模板继承和包含，可以在一个模板中使用{% extends %}和{% include %}指令来重用和组合模板代码。

6. 上下文传递：在Django视图函数中，可以通过上下文对象将数据传递给模板。上下文对象是一个包含键值对的字典，其中键是在模板中使用的变量名称，值是要传递给模板的实际数据。

7. 渲染模板：在Django视图函数中，使用Django的渲染器（render）将模板和上下文对象结合起来，生成最终的HTML响应。

参考文档：

[Django 模板](https://www.runoob.com/django/django-template.html)

[Django 模板 官方文档](https://docs.djangoproject.com/zh-hans/4.2/topics/templates/)

[模板配置文件选项设置 官方文档](https://docs.djangoproject.com/zh-hans/4.2/ref/settings/#templates)




作为一个网络框架，Django 需要一种方便的方式来动态生成 HTML，最常见的方法是依靠模板，一个模板包含了所需HTML输出的静态部分，以及一些特殊的语法，描述了如何插入动态内容。

Django 4.2 复习笔记(七)Django 模板(TEMPLATES)


昨天升级了macOS系统到macOS Monterey,之后每次打开终端都会提示：

    The default interactive shell is now zsh.
    To update your account to use zsh, please run `chsh -s /bin/zsh`.

其实早就不怎么使用zsh了，正好卸载了吧。

    sudo rm -rf /usr/local/bin/zsh

试了一下，但是还是有烦人的提示！

## 解决办法

后来搜的一个方法：

    chsh -s /bin/zsh

这个还是不管用的！！

最终解决方法：

在命令行输入：

    vim ~/.bash_profile

在文件内输入

    export BASH_SILENCE_DEPRECATION_WARNING=1

重启终端，完美解决！

昨天升级了macOS系统到macOS Monterey,之后每次打开终端都会有一些提示，真的好烦人啊。

macOS更新后 终端提示：The default interactive shell is now zsh.

大多数应用都会和权限与权限管理打交道,有的时候我们希望有一套拿来即用的权限管理框架,既可以在小型的个人应用中使用,又可以应付大型应用的复杂权限的管理,Casbin可以满足你的这个小小愿望.Casbin支持多种编程语言,今天我们来试试Casbin在python下的简单操作.

## Casbin 简介

> Casbin 是一个强大和高效的开放源码访问控制库，它支持各种 访问控制模型 以强制全面执行授权。

## 安装

    pip install casbin

除了安装支持的casein库,我们还需要两个配置文件, model.conf 和 policy.csv。 其中, model.conf 存储了我们的访问模型, 而 policy.csv 存储的是我们具体的用户权限配置。

test.py 

    import casbin
    import os

    # model.conf 和 policy.csv 文件地址
    model_dir = os.path.join(os.path.dirname(__file__), 'model.conf')
    policy_dir = os.path.join(os.path.dirname(__file__), 'policy.csv')

    # 加载配置文件
    e = casbin.Enforcer(model_dir,policy_dir)

model.conf文件里是一个ACL (Access Control List, 访问控制列表)的配置文件

    [request_definition]
    r = sub, obj, act

    [policy_definition]
    p = sub, obj, act

    [policy_effect]
    e = some(where (p.eft == allow))

    [matchers]
    m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

从policy.csv文件载入一些策略

    p, alice, data1, read
    p, bob, data2, write

test.py文件后边我们将进行一些关于权限的测试,下边是整个文件的代码.

    import casbin
    import os

    # model.conf 和 policy.csv 文件地址
    model_dir = os.path.join(os.path.dirname(__file__), 'model.conf')
    policy_dir = os.path.join(os.path.dirname(__file__), 'policy.csv')
    # 加载配置文件
    e = casbin.Enforcer(model_dir,policy_dir)
    sub = "alice"  # 想要访问资源的用户
    obj = "data1"  # 将要被访问的资源
    act = "read"  # 用户对资源进行的操作

    def getEnforce(sub, obj, act):
        """
        执行器的封装
        """
        if e.enforce(sub, obj, act):
            # 允许alice读取data1
            return True
        else:
            # 拒绝请求，抛出异常
            return False
            
    if __name__ == '__main__':
        print(getEnforce(sub,obj,act))

运行程序后会输出一个True,上边的代码我觉得不用过多的解释,看注释基本就可以明白运行的原理了.

## 在数据库里存放策略

将策略存放在数据库里,这样更接近实际的操作,这里我们使用casbin_sqlalchemy_adapter这个库,它封装好了很多有关casein数据库的操作的方法,可以拿来直接使用.

## 安装

    pip install casbin_sqlalchemy_adapter

然后我们吧policy_dir更换为数据库里的一个表.更改test.py文件的前半部分:

    # model.conf 和 policy.csv 文件地址
    model_dir = os.path.join(os.path.dirname(__file__), 'model.conf')
    # policy_dir = os.path.join(os.path.dirname(__file__), 'policy.csv')
    # 组装数据库的绝对地址
    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
    DB_DIR = os.path.join(BASE_DIR, 'test.db')
    # 数据库访问地址
    SQLALCHEMY_DATABASE_URL = "sqlite:///" + DB_DIR
    # 从数据库加载casbin的policy
    adapter = casbin_sqlalchemy_adapter.Adapter(SQLALCHEMY_DATABASE_URL)
    e = casbin.Enforcer(model_dir, adapter)
    e.add_policy(["alice", "data1", "read"])

这里我们注释掉了policy.csv文件的磁盘上的地址,跟换为数据库,当运行程序的时候,会创建一个数据库和一个表casbin_rule,其中casbin_rule存放的数据和policy.csv是一样的,我们可以通过e.add_policy()来添加策略,也可以批量添加,或是更新删除策略.

修改完代码后,运行程序,会发现和之前使用.csv文件是一样,是不是很方便,Casbin可以创建很多种权限控制模式,例如rbac等,网上介绍使用的教程很少,不过我个人感觉这个框架还是很不错的,用起来也方便,省去很多麻烦.

大多数应用都会和权限与权限管理打交道,有的时候我们希望有一套拿来即用的权限管理框架,既可以在小型的个人应用中使用,又可以应付大型应用的复杂权限的管理,Casbin可以满足你的这个小小愿望.Casbin支持多种编程语言,今天我们来试试Casbin在python下的简单操作.

Python权限管理框架 Casbin PyCasbin 的简单操作

我有一台老机器MacBook Pro(2015)的，最近有些软件提示如果系统不升级到macOS Monterey，软件将不再提供最新版的支持与升级了，之前升级过一回macOS Big Sur，体验非常糟糕，后来就退版本了退回了macOS Mojiave，这次我有忍不住升级了，但是这次是最后一次系统升级了，在之后的版本就不支持这个老机器了，所以豁出去了，还好升级后使用体验还不错，记录下来供有相同经历的友人参考。

## 升级方式

直接在系统-软件更新处下载，然后开始升级就好，全程傻瓜式安装，输入了一次密码就好，无人值守去喝杯咖啡，半个小时就好了。

## 系统优化

升级后查看系统的进程，发现有两个进程比较占用资源。

1. mds、mds_stores、mdworker占用很高的cpu和内存资源，风扇转的特别厉害！
2. WindewSderve 也挺占用资源的。

1. 优化mds、mds_stores、mdworker占用：

mds、mds_stores、mdworker是`聚焦 `的功能，因为我很少使用这些功能，所以我选择了禁止`聚焦`索引文件。

    sudo mdutil -a -i off

如果需要再次使用，可以通过以下命令重新开启。

    sudo mdutil -a -i on

2. WindewSderve的优化：

系统偏好设置-辅助设置-显示，勾选：减弱动态效果和降低透明度。

经过上边的优化，系统几乎和以前一样了，至于新系统的功能这里就不在详细介绍了，大家自己体验吧。


## 附录 macOS各版本支持升级机型汇总！

### 01 macOS Ventura 13.4支持安装系统型号：

1.  MacBook: 2017年款或以后的机型;
2.  MacBook Air: 2018年款或以后的机型;
3.  MacBook Pro: 2017年款或以后的机型;
4.  Mac Mini: 2018年款或以后的机型;
5.  iMac: 2017年款或以后的机型;
6.  iMac Pro: 2017年款或以后的机型;
7.  Mac Pro: 2019年款或以后的机型;
8.  Mac Studio: 2022年款或以后的机型;


### 02 macOS Monterey 12.6.2支持安装系统型号：

1. MacBook: 2016年初及以后机型；
2. MacBook Air: 2015年中及以后机型；
3. MacBook Pro: 2015年初及以后机型；
4. Mac Mini: 2014年末及以后机型；
5. iMac: 2015年末及以后机型；
6. iMac Pro: 2017年及以后机型；
7. Mac Pro: 2013年末及以后机型；

### 03 macOS Big Sur 11.7.2支持安装系统型号：
1. iMac 2014及以后机型；
2. iMac Pro 2017及以后机型；
3. Mac Pro 2013及以后机型；
4. MacMini 2014及以后机型；
5. MacBook 2015及以后机型；
6. MacBook Air 2013及以后机型；
7. MacBook Pro 2013及以后机型；

### 04 macOS Catalina 10.15.7支持安装系统型号:

1. MacBook 2015年款及以后机型；
2. MacBook Air 2012年款及以后机型；
3. MacBook Pro 2012年款及以后机型；
4. Mac Mini 2012年款及以后机型；
5. iMac 2012年款及以后机型；
6. iMac Pro 2017年款及以后机型；
7. Mac Pro 2013年款及以后机型；


### 05 macOS 10.14 Mojiave10.14.6支持安装系统型号：

1. MacBook 2015 年前期及以后机型；
2. MacBook Air 2012 年中期及以后机型；
3. MacBook Pro 2012 年中期及以后机型；
4. Mac mini 2012 年后期及以后机型；
5. iMac 2012 年后期及以后机型. ；
6. iMac Pro 2017 年及以后机型；
7. Mac Pro 2013 年及以后期机型；


### 06 macOS High Sierra 10.13.6支持安装系统型号：

1. iMac 2009年末及以后机型；
2. MacBook Air 2010年及以后机型；
3. MacBook Pro 2010年及以后机型；
4. Mac mini 2010年末及以后机型；
5. MacBook 2009年及以后机型；
6. Mac Pro 2010年及以后机型；


参考文章：

[「持续更新」macOS各版本支持升级机型汇总！](https://zhuanlan.zhihu.com/p/430705744)

[mds、mds_stores、mdworker 占用大量 cpu 和内存](https://www.xtplayer.cn/macos/mds-stores-use-high-cpu/#%E9%97%AE%E9%A2%98%E8%83%8C%E6%99%AF)

[Mac上的 WindowServer进程是什么？如何解决高CPU使用率](https://blog.csdn.net/weixin_48039619/article/details/122445823)



我有一台老机器MacBook Pro(2015)的，最近有些软件提示如果系统不升级到macOS Monterey，软件将不再提供最新版的支持与升级了，之前升级过一回macOS Big Sur，体验非常糟糕，后来就退版本了退回了macOS Mojiave，这次我有忍不住升级了，但是这次是最后一次系统升...

使用Python编写并部署个人静态博客:(五)Python异步输出博文页面

一键生成Matrix动态头像

Django 4.2 复习笔记(九)Django Forms 使用表单

好看的博客千篇一律有趣的博主万里挑一

使用Python编写并部署个人静态博客:(四)逐步输出静态页面

clipboard.js 一款简单好用的将文本复制到剪贴板的现代方法

一行代码升级你的node.js为最新稳定版

CDN引用lodash报错 _.debounce is not a function

Matrix 矩阵 JavaScript代码生成器

Django 4.2 复习笔记(九)使用Django的上下文处理器（context processor）

如何单独使用Django ORM 在非Django项目中使用Django ORM？

Django 4.2 复习笔记(八)Django 模板语言语法

Django 4.2 复习笔记(七)Django 模板(TEMPLATES)

macOS更新后终端提示：The default interactive shell is now zsh.

Python权限管理框架 Casbin PyCasbin 的简单操作

记一台老机器MacBook Pro macOS 10.14 Mojiave升级到macOS Monterey 12.6.2

使用Python编写并部署个人静态博客:(五)Python异步输出博文页面

一键生成Matrix动态头像

Django 4.2 复习笔记(九)Django Forms 使用表单

好看的博客千篇一律 有趣的博主万里挑一

使用Python编写并部署个人静态博客:(四)逐步输出静态页面

clipboard.js 一款简单好用的将文本复制到剪贴板的现代方法

一行代码升级你的node.js为最新稳定版

CDN引用lodash报错 _.debounce is not a function

Matrix 矩阵 JavaScript代码生成器

Django 4.2 复习笔记(九)使用Django的上下文处理器（context processor）

如何单独使用Django ORM 在非Django项目中使用Django ORM？

Django 4.2 复习笔记(八)Django 模板语言语法

Django 4.2 复习笔记(七)Django 模板(TEMPLATES)

macOS更新后 终端提示：The default interactive shell is now zsh.

Python权限管理框架 Casbin PyCasbin 的简单操作

记一台老机器MacBook Pro macOS 10.14 Mojiave升级到macOS Monterey 12.6.2

好看的博客千篇一律有趣的博主万里挑一

macOS更新后终端提示：The default interactive shell is now zsh.