b = a 应当理解为在标注为 a 的对象上再贴一个标志 b。也因此，对于引用式变量，赋值的准确描述应该是把变量分配给对象。同时按照 Python 是先执行表达式右边的内容也可以很好理解，对象是先创建再赋值的。当两个不同的变量指向同一个对象时，这两个变量就互为对方的别名，同时你可以用 is 运算符和 id 函数来确定这一点。但如果两个不同的变量绑定的是具有相同内容的不同对象时，这两个变量就只具有相等性了，== 运算符会返回 True，is 则会返回 False。（在 CPython 中，id 函数返回的是对象的内存地址，其他类型的 Python 则可能不是）
而在面对 == 和 is 时，我们应该如何选择呢？一般来说，== 比较的是两个对象的值，is 则是比较两个对象的标识，所以一般我们都用 == 更多。但当比较一个变量和一个单例时，is 更合适，比如 x is None 这样的比较。毕竟 is 比 == 速度更快，因为它不能重载。（a == b 其实是语法糖，等同于 a.__eq__(b)。）
对于元组，大家的第一个印象应该就是不可变的。而更熟悉 Python 的程序员会知道元组并非完全不可变，元组与大多数 Python 容器一样，存储的都是对对象的引用。因此，当你在元组中存储像列表这样不可哈希的容器时，元组本身就会变为不可哈希的了，你也可以通过改变存储在元组的列表来改变元组的值。也就是说，元组的不可变性其实是指 tuple 数据结构的物理内容不可变，与引用的对象无关。
要复制列表或多数内置的可变容器很简单，只需要 list(a) 或者 a[:] 即可。但是这种复制默认是浅拷贝，也就是说它只会复制最外层的容器，内部引用的项还是和原容器一样的。这样就可能会造成一些意想不到的问题。比如改变复制后的列表中内部的一个可变容器的内容时，原列表也会因此改变。而为了解决这个问题，我们就有了深拷贝。copy 模块提供的 copy 和 deepcopy 就分别是浅拷贝和深拷贝，深拷贝复制时就会连着容器的项一起复制了。
注意，深拷贝并不是一件简单的事，如果对象有引用循环，那么简单的算法会出现死循环。当然，deepcopy 能优雅地解决这个问题（引用循环指 a = [10, 20]; b = [a, 30]; a.append(b)）。
Python 唯一支持的参数传递模式就是共享传参。也就是说函数的形参获得的是实参的引用副本，是实参的别名，也因此在函数内部对传入的列表就地修改时，列表本身就会发生变化。
而与之相关的一个问题就是默认值。可选参数具有默认值，但如果你给的默认值是一个可变的值，会发生什么情况呢？答案就是在不指定默认值的内容时，函数内部与默认值相关的变量都会是默认值的别名。举个例子，你给一个类的默认值设置为空列表，并在类中实现了 append 方法。如果你创建实例时使用了默认值，那你使用 append 方法时就会改变这个类本身默认值的内容，新创建的实例的默认值也会包含另一个实例添加的内容。这也是为什么通常用 None 作为接收可变值参数的默认值。
很多人对 del 有个误解，认为使用 del 就能删除对象。但实际上，del 语句删除的是引用。del 可能导致对象被当作垃圾回收，但是仅仅是当删除的变量是保存对象的最后一个引用时才会发生。重新绑定也能导致引用数量归零而对象被销毁。在 CPython 中，垃圾回收主要就是引用计数，引用计数归零时就会销毁对象。而有些 Python 的垃圾回收原理则更复杂，不依赖引用计数。
如果想要演示对象生命结束是怎么样的，可以使用弱引用库 weakref，用它对对象产生的引用不会被作为引用计数，也就是说使用它时，对象依然可能会因为引用计数归零而被销毁，这样你就可以监控对象生命了。
值得一提的是，Python 对元组进行如 tuple(a) 或 a[:] 这样的操作时并不会复制，返回的依然是对象本身，因为元组毕竟不可变，复制了也没什么意义。如果你进行测试，会发现副本的 id 不会发生任何变化。当然，不止元组，其他不可变容器像 str，bytes 以及 frozenset 也一样（frozenset 就没有什么 [:] 的用法了，不过使用 a.copy() 也是一样的结果）。
除此之外，str 还有一种驻留机制，当你给不同变量赋值内容相同的 str 时，一般它们的 id 也会是相等的，在 CPython 中整型也有驻留机制，一些热门数字也会使用同一个对象而不是重新创建。但是注意，这些驻留机制并不对所有 str 或 int 都起作用，这种和它本身的技术实现有关了，所以不要认为 str 就可以使用 is 了。
]]>Tips：在使用
+=或*=时，如果对象可变那会直接就地操作，如果不可变比如元组则会创建一个新元组。对于元组这种容器，因为其内部没有对对象是否可哈希进行判断，因此是相对不可变的。但是像frozenset这种内部对象都要求必须可哈希，就是完全不可变的了（set也是内部对象必须可哈希，因此你不能嵌套set，这也是frozenset出现的一个原因）。
b = a 应当理解为在标注为 a 的对象上再贴一个标志 <]]>
Python 中的数据类可通过三种数据类构建器来构建，分别为 collections.namedtuple，typing.NamedTuple 以及 dataclasses.dataclass（前两者还有个名字叫具名元组）。
数据类的一大好处就是已经定义好了一些魔法方法，比如 __str__、__eq__ 什么的，正常的类你 print 出来的东西是其内存地址（在 CPython 中），而数据类则是构造函数形式展示的字符串；而且正常类你无法对其进行比较（只能比较 id，和 is 差不多了），而数据类则是值相同的实例就能被 == 判断为 True，这就很方便了。刚好可以作为数据的载体（特别是一些数据类是可哈希的（毕竟是不可变的））。
先说 collection 的，它是 tuple 的子类，无法使用 class 字面量来定义，只能通过 DataClass = namedtuple('DataClass', 'data content') 来创建，然后你就可以通过 data_1 = DataClass(data, text) 来创建一个数据类实例（type 为 tuple，因此它不可变）。不过正因为它无法使用 class 字面量定义，所以使用者应该不多（因为这样不好加方法，当然它也是能通过注入方法来加方法的）。不过有一说一，构造函数其实比 class 字面量更快，毕竟 class 字面量是要进行多行检测的。
接下来是 typing 的，这个数据类一个好处就是方便加类型提示（但是每个属性都需要类型提示）。你可以像 collection 的那样直接用构造函数来创建 DataClass = NamedTuple('DataClass', [('data', dict), ('content', str)])，这和上一个没什么区别。你还可以通过另一种方式构建，也就是 class 字面量，这正是它比上一个的优势所在：
1 | class Dataclass(NamedTuple): |
这样的形式你就可以相当方便地添加一些方法了，而且可读性也更高（其中还有默认值相关未介绍，其实默认值没什么好说的，content: str = '' 就能创建默认值了）。当然，你看到 (NamedTuple) 后可能会认为这是继承，这其实是一个误区，DataClass 并不是 NamedTuple 的子类，它还是 tuple 的子类，而 NamedTuple 实际上是一个元类（元类这玩意比较复杂，具体是什么我还没学捏），所以本质上这种行为和继承无任何关系。
最后是 dataclasses 的了，我感觉这个应该是最合适使用的了，它就不是 tuple 的子类了，它父类是 object，和正常的类一致，这也表示它其实是可变的（当然你也可以让它不可变，但是你还是可以通过一些方法来改变其中的内容）。它无法通过构造函数来构建，而是使用了类装饰器：
1 |
|
如果你需要不可变的就要给装饰器加上参数 @dataclass(frozen=True)，这样就无法给它构造的类加属性了（但是这种不可变还是比较局限的）。你可以像 content: str = '' 这样来给它加上默认值，但需要注意的是，content: str = '' 创建的为实例属性，而不是类属性；但是如果你是像 content = '' 这样创建的话，它就又成了类属性，这是需要警惕的。如果你想要类型注释和默认值但又要类属性，你就需要 typing.ClassVar，通过 content: ClassVar[str] = '' 创建的就是类属性啦。同时，数据类如果要使用可变的容器（如 dict 和 list）的话，不能直接将它们作为默认值，而是需要使用 dataclasses.field(default_factory=list) 来创建默认值，比如 data: dict = field(default_factory=dict)，这样能防止实例共用属性，直接用 [] 的话会直接报错。
除此之外，有关数据类其实有个说法，就是，数据类属于一种代码“异味”，正如一句话所说“数据类就像一个小孩子，如果要在一个复杂的系统使用，数据类就得承担一些责任”，这句话所表示的也就是不要把数据类当作一个单纯的数据的载体，有关里面数据的调用都应当由数据类自身的方法实现，而不应该在外部创建一个函数来处理。数据类固然好用，但是也不能滥用。
]]>Python 中的数据类可通过三种数据类构建器来构建，分别为 collections.namedtuple，typing.NamedTuple 以及 dataclasse]]>
首先是 Python 3 的 str，它其实就是 Python 2 的 unicode 类（我记得是完全一样的），而 Python 2 的 str 则和 Python 3 的 bytes 类似（不完全一样）。所以 Python 3 对字符的支持可能更多、更好。不过鉴于 Python 3 的内部灵活表示机制（PEP 393），也可能存在一些需要注意的细节，比如纯 ASCII 字符串内部使用 1 字节存储，一旦出现更大的码点字符，整个字符串的内部存储单元会相应扩大。
关于 Unicode，其实有很多字符是可以通过码点组合而来的，虽然显示都一样，但是 Python 解释器可不吃你这套，使用 == 照样为 False。但这就有一个问题了：如果要实现对字符的搜索，这样难道不会搜索不到吗？
所以，我们有了规格化操作，有 4 种方式，分别为：
它们都能起到一个不错的规格化作用（其实 NFC 最常用），但是还是不够适合搜索。于是我们有了 NFKC 和 NFKD（不过可能只适合搜索就是了，因为会改变一些原字符含义），它们会将一些字符拆分，比如 ½ 会被拆分为 1/2，4⁵（4 和上标 5）会被拆分为普通字符 45（这种已经完全改变原义了），但是这样很方便用户搜索。
接下来是 Unicode 的一个重要处理原则：Unicode 三明治原则。
这个原则应该能解决很多 Unicode 相关的问题，它的要求是：
bytes → str）strstr → bytes）这是一个相当合理的操作，能有效减少一些出问题的可能性。open() 函数就遵循了这样的原则，它会在读取文件时获取 bytes 内容再解码为指定编码内容，写入时则是将需要写入的 str 转为 bytes 再写入。
\N{} 转义字符Python 还支持一种与 Unicode 相关的特殊转义字符 \N{}，它会将 {} 内的 Unicode 名字变为对应的 Unicode 字符，有些时候可能挺方便的。
1 | print("\N{GREEK SMALL LETTER ALPHA}") # 输出: α |
还有一些编码的文件，你去看它的 bytes 会发现其中有些原本"不存在"的字符，其中 BOM 就是一个很有用的标记。它代表文件所使用的编码是哪个，比如 UTF-16（带 BOM）就有 BOM 来区分 UTF-16LE 和 UTF-16BE，这样 BOM 就很重要了。不过也有不带 BOM 的一些编码格式（带上 BOM 其实也没区别），比如 UTF-8。但是鉴于一些文档软件会自动给编码生成 BOM，所以解码时建议使用 utf-8-sig，有没有 BOM 它都能正常解码。
]]>注意：千万不要给 Python 代码文件的 UTF-8 加上 BOM，这会导致一些潜在的问题。
首先是 Python 3 的 str
模式匹配还支持卫语句，也就是在模式语句之后的 if 语句，模式匹配要同时满足模式语句以及卫语句（可选）才能成功匹配，不然就会转到下一个 case。
_ 在模式匹配上下文中有特殊含义，它可以匹配任何模式，也就是说，你可以使用 case _ 来作为 if 语句的 else 使用。除此之外，模式匹配上下文中 str()，float() 等并不是构造函数，而是作为类型检查，也就是说 case [str(text)] 表示匹配只含 1 项的序列（这也叫做序列匹配），且那一项必须为 str。
必须说明的是，序列匹配只能匹配序列（str，bytes 以及迭代器都不支持解构，其中 str 和 bytes 是因为它们属于“原子”值，也就是一个整体），像列表、元组、range 以及数组等都是可以正常解构的。
1 | metro_areas = [ |
当然，匹配中也可以将 str(name) 改为确定的字符串如 'Shanghai'，这样就只会匹配 'Shanghai' 一个了。
模式匹配在某些情况下其实挺好用的，if 语句是比不了的，事实上它对 if 语句还能进一步简化。
]]>一个有意思的事实是，Python 的字典的 .keys() 和 .items() 方法返回的是两个内置的视图对象，且无法被外部直接拿去使用（但可以获取该实例）。它们属于字典视图（在 Python 2 中是以列表形式显现的，因为无意义占用内存，所以在 Python 3 中被改为了现在的视图）。
当然，因为字典使用的是哈希表，所以其查询速度比序列更快（但是占用内存也更大，因为哈希表需要保留约 1/3 的空间）。
值得一提的是，创建字典字面量 {a:1, b:2} 比使用构造函数 dict(a=1, b=2) 效率更高（书中写的是 set，不过我想字典应该也差不多）。而且在创建一个类实例时，内部也会构建一个哈希表，因此应当在 __init__ 中来创建字典实例，这样字典与实例就是共用的同一个哈希表（在方法中创建会新建一个哈希表），这样可以节省内存（不过好像一个进程只有效一次？这部分我没太看懂）。
很有意思的是，Python 的 set 实现了数学意义上对集合的所有使用方法，包括交集、并集、差集、对称差集等，且 set 里面的内容必须是可哈希的（但 set 本身不可哈希，因此 set 无法嵌套，而 frozenset 是可哈希的）。不过鉴于 Python 每次创建进程时哈希码都会有所不同，因此 set 里面的元素是完全无序的。
如果想消除一个序列中的重复项同时保持顺序，可以使用 dict.fromkeys(l)，其中 l 为序列。此方法会把 l 映射为字典的 .keys() 视图，该视图会像集合一样删除重复项，但重要的是它能保留顺序（Python 3.7+ 中字典保持插入顺序），因此你可以把它转为序列重新使用。当然，鉴于 .keys() 和 .items() 的这种特性，它们是可以和 set 进行集合运算的！
一个有意思的事实是，Python 的字典的 .keys() 和 .items() 方法返回的是两个内置的视图对象，且无法被外部直接拿去使用（但可以获取该实例）。它们属于]]>
Python 的很多东西其实都是基于 dict（函数的形参在内部就使用了 dict 结构），有人说过 Python 其实就是个包裹在一堆语法糖中的字典，也正因此 Python 对 dict 进行了特殊优化，处理速度非常快。set 也是同理，Python 的 set 比其他语言高级不少，支持了基本数学上所有的集合方法，在检索方面相较于列表也是速度更快的。
列表虽然功能强大，理论上可以作为大部分容器来使用，但实际上在针对很多问题时列表并不是最好的选择。比如针对 FIFO 的问题时，deque（双端队列）是更好的选择，因为它从左边以及右边增删元素都是 O(1)，还可以设置 maxlen 可选参数来指定队列长度，队列满时左边新增右边就删，反之同理。deque 还有一些特殊方法如 rotate，可以从某一端取出指定数量的元素加到另一端，也是相当有意思的（注意，deque 从中间取元素的效率并不高）。
当然，queue 模块中的队列在一些情况下也是不错的选择，但需要注意的是，queue.Queue 指定 maxsize 满后并不会删除元素，而是会阻塞等待元素取走再添加。
asyncio 中的队列底层是基于 deque 等数据结构实现的，并非专有的异步队列，而是结合了异步等待机制（我一直以为会有完全专属于异步的队列呢）。
还有，Python 的排序算法是 Timsort，是一个非常高效的算法，创始人 Tim 同样也是 Python 的老行家了，Python 之禅就出于他手。
说到排序，就不得不提到 key 关键参数了，这在很多语言中并不常见，它可以通过指定 key 来实现一些特殊的排序，比如可以用 key=int 对一个只包含数字字符串的列表进行数值排序（key 需要是一个函数），它最大的优点是排序过程中每个元素只会被调用一次 key 函数。（值得一提的是，max 和 min 函数也有 key 可选参数）
]]>Python 的很多东西其实都是基于 dict（函数的形参在内部就使用了 dict 结构），有人说过 Python 其实就是个包裹在一堆语法糖中的字典，也正因此 Python 对 dict 进行了特殊优化，处理速度非常快。set 也是同]]>
切片远比你想象的强大。你常见的惯用法可能是 list[start:stop:step]，但事实上 Python 支持多维切片，也就是 [i, j]，它会作为元组传入。之所以 Python 原生库很少见到多维切片，是因为基本所有序列都是一维的（memoryview 有可能不是），而对于 numpy 来说，它就可以通过多维切片来进行更方便的处理，比如：
1 | array[3:, :3] |
可变序列（如列表）的切片可以被同一种序列的内容替换，这也是相当方便的处理。
1 | list = [1, 2, 3, 4, 5] |
序列的切片实际上是使用了 slice 函数，list[:] 等同于 list[slice(None, None)]。
这有什么好处呢？好处就是你可以对切片进行命名。比如对于比较规整的字符串，你可以给一个专门切名字的切片命名为：
1 | name = slice(None, 10) |
调用时只需使用 list[name] 就可以完成切片，大大增加了可读性。
对于嵌套列表，需要注意的是，最好不要使用 * 来复制嵌套列表，而应该使用列表推导式，以防止内部嵌套的列表指向的是同一个列表导致的错误。
例如 [[[], []], [[], []]] 就是一个需要预防这种问题的嵌套列表——如果用乘法构造类似结构，很容易让子列表共享同一引用，造成意外修改。
切片远比你想象的强大。你常见的惯用法可能是 list[start:stop:step]，但事实上 Python 支持多维切片，也就是 [i, j]，它会作为元组传入。之所以 Pytho]]>
作为本站第一个正式博客技术分享，我觉得应该很多人会想了解像这样一个博客站是如何搭建的。
其实很简单，按接下来的步骤一步步来，你也能0成本搭建一个属于自己的博客站点。
接下来让我们进入正题。
首先，要能0成本搭建一个博客站点，那我们就只能通过静态博客来搭建。而Hexo便是这样一个很不错的静态博客框架，所以我们需要先在本地搭建一个Hexo。
如果你想要了解关于Hexo更详细的内容，可以看看它的文档来获得更全面的信息。
为了能正常访问GitHub，你可以下载并安装Watt Toolkit，这是一款免费的加速器，可以对Steam、GitHub等进行加速。
为了能部署Hexo，我们需要首先安装Node.js（建议版本12.0及以上，推荐使用最新LTS版本）。
相关安装教程可以自行在Node.js或Hexo文档查看，这里就不多赘述了。
安装完成后可以运行以下命令来检测是否成功：
1 | node -v |
为了让npm下载速度更快，我们也可以通过以下指令来换源：
1 | npm config set registry https://registry.npmmirror.com |
如果返回 https://registry.npmmirror.com 代表成功更改镜像源。
接下来是Git的安装，安装Git是为了方便之后将静态博客推送到GitHub Pages（如果不理解没关系，照着步骤做就行）。
Windows系统需要下载并安装Git。
Mac系统可以使用安装程序。
Linux (Ubuntu, Debian)只需执行以下命令：
1 | $ sudo apt-get install git-core |
Linux (Fedora, Red Hat, CentOS)则需要执行如下命令：
1 | $ sudo yum install git-core |
把这两个安装完成后，我们便可以进行下一步了。
安装Hexo相当简单，我们只需使用npm命令：
1 | npm install -g hexo-cli |
这样一来，我们便完成了所有需要的安装任务。
安装完Hexo后，我们便可以正式搭建静态博客了。
首先按顺序执行以下命令：
1 | hexo init <folder> |
其中<folder>改为你所想要的文件名，比如my_blog（最好使用英文，且不要使用特殊字符）。
初始化完成后你应该能看到以下项目文件夹目录：
1 | . |
那么恭喜你，你已经完成了最基础的博客站搭建（海豹拍肚皮声.wav）。
如果你已经迫不及待想看看搭建完成的网站，可以运行以下命令来看看效果如何：
1 | hexo s |
等终端输出完信息，把 http://localhost:4000/ 输入进网页便打开啦~
打开刚部署好的博客，你会发现，显示的东西相当简约，而且与自己一点关系没有，全是英文看得云里雾里。
这其实是因为我们还没配置好博客。
所以接下来你可以在相关文件夹根目录中寻找_config.yml这个文件，并在其中进行一些基础配置。
配置完后，你只需刷新一下网页，就会发现博客已经变成符合你信息的样子了。
当然，你可能还是很不满意，觉得Hexo这个默认的主题很不好看。
那你就可以尝试一下换个主题。
首先，你可以在这个网站寻找自己喜欢的主题。
比如本站使用的是Solitude这个主题。
要下载主题，你可以使用这个指令（这里以Solitude为例）：
1 | npm install hexo-theme-solitude |
但需要注意的是，这样安装的主题会安装在node_modules文件夹里面，在配置主题时可能会相当不方便。
你可以尝试把整个主题文件移动到themes文件夹中以方便配置。
当然，如果你就是想放在node_modules文件夹中，那在根目录的_config.yml文件的theme配置一定要填对应主题名字如solitude，而不是文件夹名字。
而在themes文件夹中的主题则需要在根目录的_config.yml文件的theme配置中填入对应文件夹名，如hexo-theme-solitude，这样才能正常使用。
你可能发现了，即使切换了主题，整个页面依然是相当简约。
所以，接下来你需要配置主题。
首先，在对应主题文件夹中找到主题的_config.yml文件，一般你都可以在对应主题的官网寻找到主题的配置文档。
比如Solitude的配置文档。
但有些不愿折腾的小白可能看完就想直接放弃。
所以一个小妙招就是你可以让AI帮你完成一些配置。
比如GitHub Copilot或Windsurf这类代码Agent软件，而你只需要在输入框让它先搜索对应主题文档再帮你完成配置就可以啦~
在完成这一切后，你就能拥有一个像本站这样美观的一个博客。
在搭建完博客后，你便可以通过一些指令来实现最基础的编写。
比如通过以下指令创建一个新文章：
1 | hexo new <title> |
然后你就可以在根目录的source文件夹中的_posts文件夹找到对应的md文件，打开这个文件你便可以通过编写markdown文档来写博客啦~
当然，如果你需要的是生成一个新界面而不是文章，就可以使用以下命令（这里以about界面举例）：
1 | hexo new page about |
更多的内容这里就不多赘述了，感兴趣可以看看Hexo写作文档教程。
之所以我们能0成本搭建一个博客，正是因为我们能通过GitHub Pages来蹭一个域名。
而在那之前，我们需要先对git进行配置。
首先你需要一个GitHub账号，然后你需要输入以下命令，分别是你的GitHub用户名和登录GitHub的邮箱：
1 | git config --global user.name "<Your GitHub username here>" |
接着创建SSH密钥，按如下命令：
1 | ssh-keygen -t rsa -C "<Your GitHub email here>" |
对应密钥存储目录会在终端显示，例如Windows系统为 C:\Users<Your user name>.ssh\id_rsa.pub。
接下来你只需要用文本编辑器打开并完整复制里面的内容即可。
接着点击这个链接，并点击 New SSH key。
把复制好的密钥填进去即可，Title可以随便写。
最后点击 Add SSH Key 即可完成。
为了验证是否配置成功，请输入以下指令。
注意：在进行这一步时请关闭Watt Toolkit加速器，否则会出现连接不上的错误。
1 | ssh -T git@github.com |
如果显示询问 Are you sure you want to continue connecting (yes/no/[fingerprint])?，这是正常现象，直接输入yes即可。
若出现以下内容即为配置成功：
1 | Hi <username>! You've successfully authenticated, but GitHub does not provide shell access |
点击这个链接新建一个仓库。
仓库名字选择 <你的GitHub用户名>.github.io，然后直接Create即可。
创建完成后点击对应仓库的 Settings 选项。
接着点击下面的 Pages 选项。
你会在写着 Build and deployment 下方找到一个框，点击它并选择为 Deploy from a branch（更合适的做法是使用Github Actions，具体做法请自行查阅），然后选择分支为 main（如果没有则选 master，或后续推送后会出现 main）。
这样一来你便完成了GitHub Pages仓库的搭建并白嫖到了一个域名 https://<你的GitHub用户名>.github.io/。
首先我们在本地博客文件夹找到 _config.yml 文件。
打开后翻到最底下找到 deploy 部分，并将其中的内容改为：
1 | deploy: |
保存后我们还需安装一个小插件以通过Git来推送静态博客：
1 | npm install hexo-deployer-git --save |
接着依次输入：
1 | hexo clean # 清除已有的静态博客内容 |
完成后，你便可以通过 https://<你的GitHub用户名>.github.io 来访问博客了。
完成上述步骤后你会发现，自己这博客站慢成这样用鸡毛啊。
但是没关系，我们可以通过Netlify来进行加速，并且完全免费哦。
首先需要先打开Netlify的官网进行登录。
登录完成后点击右上角的 Add new project。
在下面的 Import a Git repository 中选择 GitHub。
在允许Netlify访问仓库后就可以选择 <你的GitHub用户名>.github.io 这个仓库来搭建啦。
接着在 deploy project 界面中你需要设置 Project name，这边建议可以使用 <你的GitHub用户名>。
接着滑到最底下并点击 Deploy xxx 就可以完成搭建啦。
搭建完成后，你便可以通过 https://<你的GitHub用户名>.netlify.app/ 来访问博客啦，而且速度快得多哦。
当你在本地更新了博客后，你只需运行以下指令：
1 | hexo clean # 清除已有的静态博客内容 |
然后再打开自己的博客网站，你就会发现博客界面已经成功更新，相当的简单。
在经过这些操作以后，你就成功搭建了一个属于自己的博客了。
如果你最终成功了，那么就让我给你鼓个掌（海豹拍肚皮声.wav）。
而之后，你就可以尽情的进行博客的创作啦~
最后，如果你发现了这篇文章有任何纰漏，可以在评论中告知我，我会相当感谢并及时更改。
因为这是我的首篇正式博客，所以有所缺陷也请见谅。
希望大家看完后能有所收获并成功搭建一个属于自己的博客，感谢阅读~
本篇博客参考了Hexo 静态博客搭建教程的部分内容。
最后感谢XXY提供的一些技术支持。
作为本站第一个正式博客技术分享，我觉得应该很多人会想了解像这样一个博客站是如何搭建的。
其实很简单，按接下来的步骤一步步来，你也能0成本搭建一个属于自己的博客站点。
接下来让我们进入正题。
接下来，我也会创作各种各样有意思的技术内容或有趣知识
内容包括但不限于：
Python
机器学习
编程开发
学习心得
技术教程
LLM相关
…
最后希望大家能多多支持，多多关照捏~
]]>接下来，我也会创作各种各样有意思的技术内容或有趣知识
内容包括但不限于：
Python
机器学习
编程开发
学习心得
技]]>