我的Python基本语法

python国内镜像

pip install --index https://pypi.mirrors.ustc.edu.cn/simple/ gevent==1.4.0 
pip install -i https://pypi.douban.com/simple gevent==1.4.0 

安装python

# 官方地址
wget https://www.python.org/ftp/python/3.9.0/Python-3.9.0.tgz
# 国内镜像（下载速度更快，建议使用国内镜像）
wget http://npm.taobao.org/mirrors/python/3.9.0/Python-3.9.0.tgz

声明编码：

_*_ coding:utf-8 _*_		python3不用写这一行了

linux下执行Python脚本,第一行为:

#!/usr/bin/env python   //env系统寻找系统环境变量中的python来作为解释器
    或 #!/usr/bin/python
### 各种语言的Hell World写法：
	python的hello world 写法：
		print("Hello World")
	C++下的hello world写法： 
		#include <iostream>
		 int main(void)
		 {
	 		std::cout<<"Hello World";
		 }
	C的hello world 写法：	  
	#include <stdio.h>
		int main(void)
    	{
		printf("\nhello world!");
		return 0;
		}
	JAVA的hello world 写法：  
		public class HelloWorld{                         //定义一个类
		// 程序的入口
		pubilc static void main(String args[]){			 //定义一个函数
		//向控制台输出信息
		System.out.println("Hello World");			     //输出
		}	
		}
	php的hello world 写法：	  
		<?php
			echo "Hello World"
		?>
	RUBY的hello world 写法： 
		puts "Hello World"
	GO的hello world 写法：    
		package main
		import "fmt"
		func main(){
			fmt.Printf("Hello World!\n God Bless You!");
		}

不能定义为变量的关键字：
and、as、assert、break、class、continue、def、del、elif、else、except、exec、finaly、for、from、global、if、import、in、is、lambda、not、or、pass、print、raise、return、try、while、with、yield

变量定义和输出：

例如：

_name = "Zhao xioameng"
print ("My girl friend is",_name)

字符编码：

ASCII 255 1bytes
--> 1980 gb2312	7000+
--> 1995 GBk1.0 2W+
--> 2000 GB18030 2.7W+
--> unicode 2bytes(统一占2字节)			#万能编码,支持全世界各个国家的语言,包含gb2312、GBk、等编码集
--> utf8 en:1bytes cn:3bytes
				
# -*- var1:utf-8 -*-				//不支持中文,要声明编码(python 2.x)

注释单行内容用一个#,注释多行内容,用''' '''括起来

python交互式输入输出：

username = input ("username:")
password = input ("password:")
print (username,password)

input接收的内容默认为str字符串,变为整形的话需要用int再变化一次
将字符串(str)转换成整形(%d)用int,age=int(input("23")),print(type(age))		     	<class 'int'>
将整形(int)转换成字符串(%s)用str,age=str(int(inout("23"))),print(type()age)		<class 'str'>

字符拼接输出:

name = input ("username:")
age = input ("age:")
job = input ("job:")
salary = input ("salary:")

#方法一：
info = '''
---------- info of Name:%s      #s代表string(字符串),d代表只能是数字,f代表浮点型(小数)
Name:%s
Age:%s
Job:%s
Salary:%s
''' % (name,name,age,job,salary)
print (info)
	
#方法二：
	
info2 = '''-----info of {_name} --------
Name:{_name}
Age:{_age}
Job:{_job}
Salary:{_salary}
'''.format(_name=name,
           _age=age,
           _job=job,
           _salary=salary)
		   print  (info2)

#方法三：
info3 = '''------info of {0}--------
Name:{0}
Age:{1}
Job:{2}
Salary:{3}
	'''.format(name,age,job,salary)
	print (info3)
	

引入getpass库,使密码变成密文

import getpass
username = input ("username:")
password = getpass.getpass ("password:")

print (username,password)

while循环猜数字,count计数且退出

#1、
	age_of_oldboy = 56
	    count = 0

	while True:					         可优化为：#2  while count <3:
		if count == 3:				   				  guess_age = int(input ("guess age: "))
			break															.
		guess_age = int(input ("guess age: "))								.
		if guess_age == age_of_oldboy :										.
			print ("yes, you get it...")			  count +=1
			break
		elif guess_age > age_of_oldboy :
			print ("please think smaller...")
		else:
			print ("please think bigger")
		count +=1
#3、
    age_of_oldboy = 56
	count = 0
	while count <3:
		guess_age = int(input ("guess age: "))
		if guess_age == age_of_oldboy :
			print ("yes, you get it...")
			break
		elif guess_age > age_of_oldboy :
			print ("please think smaller...")
		else:
			print ("please think bigger")
		count +=1
	else:
		print ("you have tried too many time...fuck off")

for循环：

for i in range(0,10,2):			#range(0,10,2)是从0到9，2是步长(默认为1)
	print ("loop:",i)
会输出0、2、4、6、8

continue:跳出此次循环,进行下一次循环

break:结束整个循环,包含break的子循环，并非外面的大循环

三元运算：

三元运算：
	a,b,c = 1,3,5
	d = a if a>b else c
	d=5                       //如果a>b,d=a；否则d=c

字符编码和解码：

string(字符串)--->bytes(二进制): encode(编码)
bytes(二进制)--->string(字符串): decode(解码)
	msg = "我爱北京天安门"
	print (msg)
	print (msg.encode(encoding="utf-8"))                              //将字符串转成二进制的bytes形式
	print (msg.encode(encoding="utf-8").decode(encoding="utf-8"))	  //再将二进制的bytes形式转成字符串

将字符串编程bytes字节有三种方式：

1、b"ffffff"
2、bytes("fffff",encoding='utf-8')
3、"ffffff".encode('utf-8')

列表的操作：

深浅copy
	浅copy：列表2对列表1做一次浅copy,列表2的元素对列表1的所有元素的一次引用
name = "my \tname is {name} and I am {year} years old."

print(name.capitalize())    			#首字母大写
print(name.count("a"))      			#统计a的个数
print(name.center(50,"-"))  			#输出50个字符,用-补全,把name放在中心位置
print(name.endswith("ng"))  			#是否以ng结尾
print(name.expandtabs(tabsize=30))  	#把\转成30个空格
print(name.find("name"))    			#返回name字符的下标
print(name.format(name='Lishang',year='22'))  #
print(name.format_map({'name':'lishang','year':'22'}))
print('123'.isalnum())        			#是阿拉伯数字和字母吗？
print('ab'.isalpha())         			#是英文字母吗(含大写)？
print('1A'.isdecimal())       			#是十进制数吗？
print('22.1'.isdigit())                 #是整数吗？
print('aa还是'.isidentifier())          #是不是一个合法的变量名？
print ('abcd'.islower(),"sss")          #是不是小写
print('11.2'.isnumeric())               #是不是数字,小数会报错
print('My Name Is Lishang'.istitle())   #是不是title,每个词首字母大写才可以
print('AABBCCDD'.isupper())             #是不是全为大写？
print('+'.join(  ['1','2','3','4'])  )  #在列表中的变量之间添加 +
print( name.ljust(50,'*') )             #总长度为50,不足在后面用*补齐
print( name.rjust(50,'-') )             #总长度为50,不足在前面用-补齐
print('LIShang'.lower()  )              #大写转为小写
print('LIShang'.upper()  )              #小写转为大写
print('\nLIShang'.lstrip())             #从最左侧去掉空格和回车
print('LIShang\n'.rstrip())             #从最右侧去掉空格和回车
print('    LIShang\n'.strip())         #左右两侧都去掉空格和回车
p = str.maketrans("abcdef",'123456')
print("lishang".translate(p) )

print('-----')

列表可以嵌套列表,可以嵌套字典
字典是无序的,通过他的key来找值,不需要通过下标            集合、文件、字符编码

集合：

集合：
集合是一个无序的、不重复的数据组合,主要作用是：
	①去重,把一个列表变成集合,就自动去重了
	②关系测试,测试两组数据之前的交集、差集、并集等关系
集合间的关系测试:
	# Author: li Shang
	list_1=[1,3,5,7,9,3,5,9,6]
	list_1=set(list_1)
	list_2=set([2,6,0,66,22,8,1])
	print(list_1,list_2)

	print(list_1.intersection(list_2))    #交集
	print(list_1.union(list_2))           #并集
	print(list_1.difference(list_2))      #差集,in list_1 but not in list_2
	print(list_2.difference(list_1))      #差集,in list_2 but not in list_1
	list_3=set([1,3,7])
	print(list_1.issubset(list_2))        #子集,判断list_1是不是list_2的子集
	print(list_1.issuperset(list_2))      #父集,判断list_1是不是list_2的父集
	print(list_1.issuperset(list_3))

	print(list_1.symmetric_difference(list_2))   #对称差集,并集中去掉交集
	print("--------------------------------------------")
	print(list_1.isdisjoint(list_2))      #无交集就返回true
集合间的运算:(用关系运算符运算)
	print(list_1 & list_2)              #交集
	print(list_1 | list_2)              #并集
	print(list_1 - list_2)              #差集,in list_1 but not in list_2
	print(list_1 ^ list_2)              #对称差集,并集中去掉交集
基本操作:            ----增删改查
	list_1.add(999)                    #添加一项
	list_1.update([111,222,333])       #添加多项
	print(list_1)
	list_1.remove(222)                 #删除一项,不存在的话会报错
	print(list_1)
	print("-----------------------------------------------")
	print(len(list_1))                 # len取set的长度
	print(333 in list_1)               # x in s ,测试x是否为s的成员
	print(444 not in list_1)           # x not in s ,测试x是否不是s的成员
	print(list_1.pop())                # 删除任意一个,返回删除的元素
	list_1.discard(333)                # 删除元素,不存在不报错,对比remove
	print(list_1)

文件操作,打开文件用open

	f = open("yesterday2",'w',encoding="utf8")          #文件句柄,'w'操作方式是write,默认为r(read)
	f.write("我爱北京天安门,\n")                        #写入文件,但会覆盖掉原文件内容
	f.write("天安门上太阳升.")                          
	
	f = open("yesterday2",'r',encoding="utf8")          #文件句柄,'r'操作方式为read
	data = f.read()                                     #读文件,读和写不能同时进行
	print(data)                                         
	
	f = open("yesterday2",'a',encoding="utf8")          #文件句柄,a为append(追加模式),可以在最后追加写入,不覆盖原内容
	f.write("1 2 3 4 5,上山打老虎,\n")
	f.write("老虎不吃肉,逮只小松鼠.") 
	
	f = open("yesterday2",'r',encoding="utf8")          #文件句柄,r为读操作
	print(f.readline())                                 #读取前几行,几段该代码就是读前几行
	######### for i in range(5):
				print(f.readline())                     #利用 for 循环,取前5行
	
-------------------文件修改--------------------------------------------------------------------------------	
	
	f = open("yesterday3","r",encoding = "utf8")
	f_new = open("yesterday3.bak","w",encoding="utf8")
	for line in f:
		if "肆意的快乐等我去享受" in line:
			line = line.replace("肆意的快乐等我去享受","肆意的快乐等李尚去享受")
		f_new.write(line)
	f.close()
	f_new.close()
	
----------------- 文件修改-----------------------------------------------------------------------------------

	with open("yesterday3","r",encoding = "utf8") as f:    #这样打开文件，最后不用关闭，能同时打开多个
		for line in f:
			print (line)
	
	with open('log') as obj1,open('log2') as obj2:         #可以同时打开多个文件

面向对象:--->类---->class定义
面向过程:--->过程--->def定义------>将一段段的逻辑和过程包含到由一个def定义的过程中
函数式编程:--->函数--->def定义

------------------------------------------------------------------------------------------
import time                                       #调用时间模块
def logger():                                     #定义过程
    time_format = '%Y-%m-%d %X'                   #定义时间格式
    time_current = time.strftime(time_format)
    with open('a.txt','a+') as f:                 #写入一个文件
    f.write('%s end action\n' %time_current)

def test1():                                      #定义过程test1
    print('in the test1')
    logger()
def test2():                                      #定义过程test2
    print('in the test2')
    logger()
def test3():                                      #定义过程test3
    print('in the test3')
    logger()
test1()
test2()
test3()
-------------------------------------------------------------------------------------------
	test(1,y=2)		可以
	test(x=1,2)		错,  关键字参数调用不能在位置参数调用的前面
	
	def test(x,y=2) 默认参数特点：调用参数时，非必须传递参数
	                默认参数用途：①、安装软件时的默认安装
								  ②、连接数据库时默认端口号3306

*args接收N个位置参数，转换成元组的形式
**kwargs接收N个关键字参数，转换成字典的方式

在传多个实参(数目不固定),形参定义的时候前面加 " * ",它可以接受多个实参,把他们放入一个元组里
	def test(*args):
		print(args)
	test(1,2,3,4,5,5)
	test(*[1,2,3,4,5,])     #也可以按照*[]，*跟元组的方式传递
接收元组：参数组定应用：在参数不固定、未知数量时,可以设置
	def test1(x,*args)
		print(x)
		print(args)
	test1(1,2,3,4,5,6,7)

接收字典：
	def test2(**kwargs):
		print(kwargs)
	test2(name='lishang',age=23,sex='man')
	test2(**{'name':'xiaomeng','age':18,'sex':'girl'})     #也可以按照**{}，**跟字典的方式传递
接收参数与字典的混合：
	def test3(name,**kwargs):
		print(name)
		print(kwargs)
	test3('lishang',age=18)
字典与默认参数混合：
	def test4(name,age=18,**kwargs):
		print(name)
		print(age)
		print(kwargs)
	test4('xiaomeng',sex='girl',hobby='lishang')

形参、默认参数、元组、字典混合接收：
	def test4(name,age=18,*args,**kwargs):
		print(name)
		print(age)
		print(args)
		print(kwargs)
	test4('xiaomeng',24,'she likes Lishang',sex='girl',hobby='lishang')

局部变量：
	school = "Beida qingniao"
	def change_name(name):
		global school                    #在函数里声明之后可以改全局变量
		school = "Mage Linux"    
		print("before change is :",name,school)
		# 下面的name是局部变量只在函数里生效，这个函数是这个变量的作用域
		name="Lishang"
		print("after change is :",name)

	name="alex"
	change_name(name)
	print(name)
	print(school)

递归：
	①:必须有一个明确的结束条件
	②:每次进入更深一层递归时，问题规模相比上次递归都应有所减少
	③:递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈(stack)这种数据结构实现的，
  每当进入一个函数调用，栈就会增加一层栈帧，每当函数返回，栈就会减一层栈帧.由于栈的大小不是无限的，
  所以，递归调用的次数过多，会导致溢出)

高阶函数：
	def fx(a,b,f):
		return f(a) + f(b)
	
	res = fx(4,-6,abs)             #abs为绝对值函数
	print (res)                    #结果为            ---> 10
	
	f = open   #打开文件的模式：r,w,a,r+,w+,a+   跨平台打开文件用 --- rb,wb(二进制格式),ab
	           --> r(只读),w(创建一个文件，若存在将会覆盖),a(追加),r+(读写,写会追加),w+(以写的模式打开,追加)
	f.
	f.close

装饰器：

装饰器：本质是函数,装饰其他函数,为其他函数添加附加功能
	原则:①不能修改被装饰的函数的源代码
          ②不能修改被装饰的函数的调用方式
实现装饰器知识储备：
	①函数即"变量"
	②高阶函数:
		a:把一个函数名当做实参传给另一个函数(不修改被修饰函数源代码的情况下，添加新功能)
		b:返回值中包含函数名(不修改函数的调用方式，添加新功能)
	③嵌套函数
	高阶函数+嵌套函数 --> 装饰器
  装饰器装饰函数test1,增加记录程序执行时间的功能
	import time
	def timer(func):
		def deco():
			start_time=time.time()
			func()
			stop_time=time.time()
			print("the time run is %s" %(stop_time-start_time))
		return deco
	@timer                    #test1=timer(test1)
	def test1():
		time.sleep(3)
		print('in the test1')
	test1()
加强版：
	import time
	def timer(func):
		def deco(*args,**kwargs):
			start_time=time.time()
			func(*args,**kwargs)
			stop_time=time.time()
			print("the time run is %s" %(stop_time-start_time))
		return deco
	@timer                    #test1=timer(test1)
	def test1():
		time.sleep(1)
		print('in the test1')

	@timer
	def test2(name,age):
		time.sleep(1)
		print('test2',name,age)
	test1()
	test2('lishang',18)
列表生成式(让代码变简单，装B)：
	a = []
	for i in range(10):
		a.append(i*2)
	print(a)                               #循环10次,会输出0..9的两倍
	print([ i*2 for i in range(15)])       #与上面三行效果相同,更简洁-----列表生成式
  c=( i*2 for i in range(10000) )
  c.__next__()                             #一条一条调用
  特点：只有在调用时才会产生相应的数据,只记录当前位置,只有一个__next__方法

	可直接作用于for循环的数据类型,一类是集合数据类型,如list(列表)、tuple(元组)、dict(字典)、set(集合)、
str(字符串)等;一类是generator,包括生成器和带yield的generator function等.他们统称为可迭代对象:Iterable.
迭代器：可以被next()函数调用并不断返回下一个值的对象成为迭代器：Iterator
  
  >>>from collections import Iterable
  >>>isinstance([],Iterable)                #判断[]是不是一个可迭代对象
  
  >>>from collections import Iterator
  >>>ininstance([],Iterator)                #判断[]是不是一个迭代器
  生成器一定是迭代器,迭代器不一定是生成器
  生成器都是Iterator对象,但list、dict、str是Iterable,但不是Iterator
  把list、dict、str等Iterable变成Iterator可以使用iter()函数
因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到
没有数据时抛出StopIteration错误.可以把这个数据流看做是一个有序数序列,但我们不能提前知道序列的长度,只能
不断通过next()函数实现计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算.
Iterator甚至可以表示一个无限大的数据流,入全体自然数.而使用list是永远不可能储存全体自然数的.

@

目录

• • • • python国内镜像
      • 安装python
      • 声明编码：
      • linux下执行Python脚本,第一行为:
      • 变量定义和输出：
      • 注释单行内容用一个#,注释多行内容,用''' '''括起来
        • python交互式输入输出：
      • 字符拼接输出:
        • 引入getpass库,使密码变成密文
  • while循环猜数字,count计数且退出
  • for循环：
    • • • • continue:跳出此次循环,进行下一次循环
          • break:结束整个循环,包含break的子循环，并非外面的大循环
          • 三元运算：
        • 字符编码和解码：
          • 将字符串编程bytes字节有三种方式：
        • 列表的操作：
          • 集合：
          • 文件操作,打开文件用open
        • 装饰器：
• 欢迎使用Markdown编辑器
  • 新的改变
  • 功能快捷键
  • 合理的创建标题，有助于目录的生成
  • 如何改变文本的样式
  • 插入链接与图片
  • 如何插入一段漂亮的代码片
  • 生成一个适合你的列表
  • 创建一个表格
    • 设定内容居中、居左、居右
    • SmartyPants
  • 创建一个自定义列表
  • 如何创建一个注脚
  • 注释也是必不可少的
  • KaTeX数学公式
  • 新的甘特图功能，丰富你的文章
  • UML 图表
  • FLowchart流程图
  • 导出与导入
    • 导出
    • 导入

欢迎使用Markdown编辑器

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

1. 全新的界面设计 ，将会带来全新的写作体验；
2. 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
3. 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
4. 全新的 KaTeX数学公式 语法；
5. 增加了支持甘特图的mermaid语法^[1] 功能；
6. 增加了 多屏幕编辑 Markdown文章功能；
7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
8. 增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G

合理的创建标题，有助于目录的生成

直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

删除文本

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片:

带尺寸的图片:

居中的图片:

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

• 项目
  • 项目
    • 项目

1. 项目1
2. 项目2
3. 项目3

• 计划任务
• 完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	'Isn't this fun?'	'Isn't this fun?'
Quotes	"Isn't this fun?"	"Isn't this fun?"
Dashes	-- is en-dash, --- is em-dash	-- is en-dash, --- is em-dash

创建一个自定义列表

Markdown

Text-to-HTML conversion tool

Authors

John

Luke

如何创建一个注脚

一个具有注脚的文本。^[2]

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma(n) = (n-1)!\quad\forall
n\in\mathbb N$ 是通过欧拉积分

$$
\Gamma(z) = \int_0^\infty t^{z-1}edt,.
$$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

gantt dateFormat YYYY-MM-DD title Adding GANTT diagram functionality to mermaid section 现有任务 已完成 :done, des1, 2014-01-06,2014-01-08 进行中 :active, des2, 2014-01-09, 3d 计划一 : des3, after des2, 5d 计划二 : des4, after des3, 5d

• 关于 甘特图 语法，参考 这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

sequenceDiagram 张三 ->> 李四: 你好！李四, 最近怎么样? 李四-->>王五: 你最近怎么样，王五？ 李四--x 张三: 我很好，谢谢! 李四-x 王五: 我很好，谢谢! Note right of 王五: 李四想了很长时间, 文字太长了<br/>不适合放在一行. 李四-->>张三: 打量着王五... 张三->>王五: 很好... 王五, 你怎么样?

这将产生一个流程图。:

graph LR A[长方形] -- 链接 --> B((圆)) A --> C(圆角长方形) B --> D{菱形} C --> D

• 关于 Mermaid 语法，参考 这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

flowchat st=>start: 开始 e=>end: 结束 op=>operation: 我的操作 cond=>condition: 确认？ st->op->cond cond(yes)->e cond(no)->op

• 关于 Flowchart流程图 语法，参考 这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

---

1. mermaid语法说明 ↩︎

2. 注脚的解释 ↩︎