python學習總結
`Python:Python學習總結
文中有些地方是用2.7開發的,如果您安裝的是3.x,有幾點需要注意:
print “xxx” 要換成 print(“xxx”)
metaclass = type 刪除掉。
型別和表示式部分
你好,世界!
1 # coding=utf-8
2
3 print “你好,世界。”
乘方
1 print 2**10
變數
1 var = 1
2 print var
3
4 var = “黃四郎”
5 print var
注:這裡的var = xxxx不叫變數賦值,而叫變數繫結,python維護了一個符號表(變數名)以及符合對應的值,這個對應關係就叫做繫結,一個符號可以繫結任意型別的值。
獲取使用者輸入
1 #獲取使用者輸入
2 x = input(“x:”)
3 y = input(“y:”)
4
5 print x*y
注:input接受的是Python程式碼,輸入中可以訪問當前執行環境中的變數,如果想獲取原始輸入需要使用 raw_input。
函式定義
1 def say_b():
2 print “b”
強型別
Javascript和Php是弱型別的,Python和Ruby是強型別的。弱型別允許不安全的型別轉換,強型別則不允許。
1 #1 + “1” 這行程式碼在Python中會報錯。
2 print 1 + int(“1”)
3 print str(1) + “1”
字串
複製程式碼
1 #字串
2 print ‘’’’ 黃
3 四
4 郎’’’
5 print r’C:\log.txt’
6 print ‘C:\log.txt’
複製程式碼
序列
這裡先介紹三種序列:列表、元祖和字串。
序列通用操作
複製程式碼
1 seq = “0123456789”
2 print seq[0] #從0開始編碼。
3 print seq[-1] #支援倒著數數,-1代表倒數第一。
4 print seq[1:5] #支援分片操作,seq[start:end],start會包含在結果中,end不會包含在結果中。
5 print seq[7:] #seq[start:end]中的end可以省略。
6 print seq[-3:] #分片也支援負數。
7 print seq[:3] #seq[start:end]中的start也可以省略。
8 print seq[:] #全部省略會複製整個序列。
9 print seq[::2] #支援步長。
10 print seq[::-2] #支援負步長。
11 print seq[9:1:-1] #支援負步長。
12 print [1, 2, 3] + [4, 5, 6] # 序列支援相加,這解釋了為啥字串可以相加。
13 print [1, 2, 3] * 3 #序列支援相乘,這解釋了為啥字串可以相稱。
14 print [None] * 10 #生成一個空序列。
15 print 1 in [1, 2, 3] #成員判斷。
複製程式碼
可變的列表
複製程式碼
1 data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
2
3 data[0] = “a” #修改元素。
4 print data
5 data[0] = 0
6
7 del data[10] #刪除元素。
8 print data
9
10 del data[8:] #分片刪除。
11 print data
12
13 data[8:] = [8, 9, 10] #分片賦值
14 print data
複製程式碼
不可變的元祖
1 print (1, 2) #元祖以小括號形式宣告。
2 print (1,) #一個元素的元祖。
字串格式化
複製程式碼
1 print “% 10s” % “----”
2
3 print ‘’’
4 %(title)s
5 %(body)s
6 ‘’’ % {“title”: “標題”, “body”: “內容”}
複製程式碼
字典
1 print {“title”: “title”, “body”: “body”}
2 print dict(title = “title”, body = “body”)
3 print dict([(“title”, “title”), (“body”, “body”)])
1 dic = {“title”: “title”, “body”: “body”};
2 print dic[“title”]
3 del dic[“title”]
4 print dic
print 語句
1 print ‘a’, ‘b’ #print可以接受多個引數,引數的輸出之間以空格相隔。
2 print ‘a’, #如果逗號之後沒有引數,則不會換行。
3 print ‘b’
序列解包
複製程式碼
1 x, y, z = 1, 2, 3
2 print x, y, z
3 (x, y, z) = (1, 2, 3)
4 print x, y, z
5 (x, y, z) = [1, 2, 3]
6 print x, y, z
複製程式碼
bool值
複製程式碼
1 #下面的輸入全部返回False。
2 print(bool(None))
3 print(bool(()))
4 print(bool([]))
5 print(bool({}))
6 print(bool(""))
7 print(bool(0))
8
9 #雖然這些值在條件運算中會當做False,但是本身不等於False。
10 print(True and “”)
11 print(not “”)
12 print(False == “”)
13 print(False == 0) #0除外,bool型別的內部表示就是int型別。
複製程式碼
bool運算
1 print(0 < 1 < 10)
2 print(0 < 1 and 1 < 10)
3 print(not(0 > 1 > 10))
4 print(not(0 > 1 or 1 > 10))
語句塊
:開始語句快,縮排的所有內容都是一個語句塊。
1 if(10 > 1):
2 print(“10 > 1”)
3 else:
4 print(“不可能發生”)
三元運算子
1 print(“10 > 1” if 10 > 1 else “不可能發生”)
相等比較
複製程式碼
1 #== 和 is的差別,==比較的是內容,is比較的是引用。
2 x = [1, 2, 3]
3 y = x
4 z = [1, 2, 3]
5 print(x == y)
6 print(x == z)
7 print(x is y)
8 print(x is z)
複製程式碼
迴圈
複製程式碼
1 #for迴圈類似C#的foreach,注意for後面是沒有括號的,python真是能簡潔就儘量簡潔。
2 for x in range(1, 10):
3 print(x)
4
5 for key in {“x”:“xxx”}:
6 print(key)
7
8 for key, value in {“x”:“xxx”}.items():
9 print(key, value)
10
11 for x, y, z in [[“a”, 1, “A”],[“b”, 2, “B”]]:
12 print(x, y, z)
複製程式碼
複製程式碼
1 #帶索引的遍歷
2 for index, value in enumerate(range(0, 10)):
3 print(index, value)
4
5 #好用的zip方法
6 for x, y in zip(range(1, 10), range(1, 10)):
7 print(x, y)
8
9 #迴圈中的的else子句
10 from math import sqrt
11 for item in range(99, 1, -1):
12 root = sqrt(item)
13 if(root == int(root)):
14 print(item)
15 break
16 else:
17 print(“沒有執行break語句。”)
複製程式碼
pass、exec和eval
複製程式碼
1 #pass、exec、eval
2 if(1 == 1):
3 pass
4
5 exec(‘print(x)’, {“x”: “abc”})
6 print(eval(‘x*2’, {“x”: 5}))
複製程式碼
函式部分
形參和實參之間是按值傳遞的,當然有些型別的值是引用(物件、列表和字典等)。
複製程式碼
1 # 基本函式定義。
2 def func():
3 print(“func”)
4
5 func()
6
7 # 帶返回值的函式。
8 def func_with_return():
9 return (“func_with_return”)
10
11 print(func_with_return())
12
13 # 帶多個返回值的函式。
14 def func_with_muti_return():
15 return (“func_with_muti_return”, “func_with_muti_return”)
16
17 print(func_with_muti_return())
18
19 # 位置引數
20 def func_with_parameters(x, y):
21 print(x, y)
22
23 func_with_parameters(1, 2)
24
25 # 收集多餘的位置引數
26 def func_with_collection_rest_parameters(x, y, *rest):
27 print(x, y)
28 print(rest)
29
30 func_with_collection_rest_parameters(1, 2, 3, 4, 5)
31
32 #命名引數
33 def func_with_named_parameters(x, y, z):
34 print(x, y, z)
35
36 func_with_named_parameters(z = 1, y = 2, x = 3)
37
38 #預設值引數
39 def func_with_default_value_parameters(x, y, z = 3):
40 print(x, y, z)
41
42 func_with_default_value_parameters(y = 2, x = 1)
43
44 #收集命名引數
45 def func_with_collection_rest_naned_parameters(args, **named_agrs):
46 print(args)
47 print(named_agrs)
48
49 func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)
50
51 #集合扁平化
52 func_with_collection_rest_naned_parameters([1, 2, 3], {“x”: 4, “y”: 4, “z”: 6}) #這會導致args[0]指向第一個實參,args1指向第二個實參。
53 func_with_collection_rest_naned_parameters([1, 2, 3], **{“x”: 4, “y”: 4, “z”: 6}) #這裡的執行相當於func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)。
複製程式碼
作用域
複製程式碼
1 # coding=utf-8
2
3 # 只有函式執行才會開啟一個作用域。
4 if(2 > 1):
5 x = 1
6
7 print(x) # 會輸出1。
8
9
10 # 使用vars()函式可以訪問當前作用域包含的變數。
11 x = 1
12 print(vars()[“x”])
13
14 # 使用globals()函式可以訪問全域性作用域。
15 x = 1
16
17 def func():
18 print(globals()[“x”])
19
20 func()
21
22 # 使用locals()函式可以訪問區域性作用域。
23 def func():
24 x = 2
25 print(locals()[“x”])
26
27 func()
28
29 # 每個函式定義時都會記住所在的作用域。
30 # 函式執行的時候會開啟一個新的作用域,函式內變數訪問的規則是:先訪問當前作用域,如果沒有就訪問函式定義時的作用域,遞迴直到全域性作用域。
31 x = 1
32
33 def func():
34 y = 2
35 print(x, y) # 輸出1 2
36
37 func()
38
39
40 # 變數賦值始終訪問的是當前作用域。
41 x = 1
42
43 def func():
44 x = 2
45 y = 2
46 print(x, y) # 輸出2 2
47
48 func()
49 print(x) #輸出 1
50
51 # 區域性變數會覆蓋隱藏全域性變數,想訪問全域性變數可以採用global關鍵字或globals()函式。
52 x = 1
53
54 def func():
55 global x
56 x = 2
57 y = 2
58 print(x, y) # 輸出2 2
59
60 func()
61 print(x) #輸出 2
複製程式碼
複製程式碼
1 # python支援閉包
2 def func(x):
3 def inner_func(y):
4 print(x + y)
5
6 return inner_func
7
8 inner_func = func(10)
9 inner_func(1)
10 inner_func(2)
複製程式碼
複製程式碼
1 #函式作為物件
2 def func(fn, arg):
3 fn(arg)
4
5 func(print, “hello”)
6 func(lambda arg : print(arg), “hello”)
複製程式碼
模組
幾個模組相關的規則:
一個檔案代表一個模組。
可以用import module匯入模組,也可以用form module import member匯入模組的成員。
如果匯入的是module,必須使用module.member進行訪問;如果匯入的member,可以直接訪問member。
匯入的module或member都會變成當前module的member。
b.py
複製程式碼
1 # coding=utf-8
2
3 print name
4
5 def say_b():
6 print “b”
複製程式碼
a.py
複製程式碼
1 # coding=utf-8
2
3 import b
4 from b import *
5
6 print name
7
8 def say_a():
9 print “a”
複製程式碼
test.py
複製程式碼
1 # coding=utf-8
2
3 import a
4
5 print name
6
7 a.say_a();
8 a.say_b();
9 a.b.say_b()
複製程式碼
輸出
複製程式碼
1 b
2 a
3 main
4 a
5 b
6 b
複製程式碼
異常管理
複製程式碼
1 # coding=utf-8
2
3 # 自定義異常
4 class HappyException(Exception):
5 pass
6
7 # 引發和捕獲異常
8 try:
9 raise HappyException
10 except:
11 print(“HappyException”)
12
13 try:
14 raise HappyException()
15 except:
16 print(“HappyException”)
17
18 # 捕獲多種異常
19 try:
20 raise HappyException
21 except (HappyException, TypeError):
22 print(“HappyException”)
23
24 # 重新引發異常
25 try:
26 try:
27 raise HappyException
28 except (HappyException, TypeError):
29 raise
30 except:
31 print(“HappyException”)
32
33 #訪問異常例項
34 try:
35 raise HappyException(“都是我的錯”)
36 except (HappyException, TypeError), e:
37 print(e)
38
39 #按型別捕獲
40 try:
41 raise HappyException
42 except HappyException:
43 print(“HappyException”)
44 except TypeError:
45 print(“TypeError”)
46
47 #全面捕獲
48 try:
49 raise HappyException
50 except:
51 print(“HappyException”)
52
53 #沒有異常的else
54 try:
55 pass
56 except:
57 print(“HappyException”)
58 else:
59 print(“沒有異常”)
60
61 #總會執行的final
62 try:
63 pass
64 except:
65 print(“HappyException”)
66 else:
67 print(“沒有異常”)
68 finally:
69 print(“總會執行”)
複製程式碼
物件導向
先上一張圖
幾個規則:
一切都是物件,python中一切都是物件,每個物件都包含一個__class__屬性以標記其所屬型別。
每個物件(記得一切都是物件啊)都包含一個__dict__屬性以儲存所有屬性和方法。
每個型別都包含一個__bases__屬性以標記其父類。
屬性和方法的訪問規則:依次搜尋instance、子類、父類、父類的父類、直到object的__dict__,如果找到就返回。
屬性和方法的設定規則:直接設定instance.dict。
以上屬性和方法訪問或設定規則沒有考慮“魔法方法”,下文會解釋。
示例
複製程式碼
1 # coding=utf-8
2
3 metaclass = type
4
5 # 型別定義
6 # 例項方法必的第一個引數代表型別例項,類似其他語言的this。
7 class Animal:
8 name = “未知” # 屬性定義。
9
10 def init(self, name): #構造方法定義。
11 self.name = name
12
13 def getName(self): # 例項方法定義。
14 return self.name
15
16 def setName(self, value):
17 self.name = value
18
19 print(Animal.name) # 未知
20 print(Animal.dict[“name”]) # 未知
21
22 animal = Animal(“狗狗”)
23 print(animal.name) # 狗狗
24 print(animal.dict[“name”]) # 狗狗
25 print(Animal.name) # 未知
26 print(Animal.dict[“name”]) # 未知
27 print(animal.class.name) # 未知
28 print(animal.class.dict[“name”]) # 未知
複製程式碼
1 # 型別定義中的程式碼會執行,是一個獨立的作用域。
2 class TestClass:
3 print(“型別定義中”) #型別定義中
繫結方法和未繫結方法
複製程式碼
1 class TestClass:
2 def method(self):
3 print(“測試方法”)
4
5 test = TestClass()
6 print(TestClass.method) #
注:使用物件訪問例項方法為何會返回繫結方法?這個還得等到學完“魔法方法”才能解釋,內部其實是攔截對方法成員的訪問,返回了一個Callable物件。
私有成員
複製程式碼
1 # 私有成員
2 class TestClass:
3 __private_property = 1
4
5 def __private_method():
6 pass
7
8 print(TestClass.dict) # {‘module’: ‘main’, ‘_TestClass__private_method’: <function __private_method at 0x0212B970>, ‘_TestClass__private_property’: 1
複製程式碼
難怪訪問不了了,名稱已經被修改了,增加了訪問的難度而已。
多重繼承
複製程式碼
1 #多重繼承
2 class Base1:
3 pass
4
5 class Base2:
6 pass
7
8 class Child(Base2, Base1):
9 pass
10
11 child = Child()
12 print(isinstance(child, Child)) # True
13 print(isinstance(child, Base2)) # True
14 print(isinstance(child, Base1)) # True
複製程式碼
如果繼承的多個型別之間有重名的成員,左側的基類優先順序要高,上例子Base2會勝出。
介面那裡去了,鴨子型別比介面更好用。
複製程式碼
1 class TestClass1:
2 def say(self):
3 print(“我是鴨子1”)
4
5 class TestClass2:
6 def say(self):
7 print(“我是鴨子2”)
8
9 def duck_say(duck):
10 duck.say()
11
12 duck_say(TestClass1()) # 我是鴨子1
13 duck_say(TestClass2()) # 我是鴨子2
複製程式碼
呼叫父類
複製程式碼
1 # 呼叫父類
2 class Base:
3 def say(self):
4 print(“Base”)
5
6 class Child(Base):
7 def say(self):
8 Base.say(self)
9 super(Child, self).say()
10 print(“Child”)
11
12 child = Child()
13 child.say()
複製程式碼
魔法方法
詳細內容參考:http://www.rafekettler.com/magicmethods.html。
物件構造相關:new、init、del。
複製程式碼
1 from os.path import join
2
3 class FileObject:
4 ‘’‘Wrapper for file objects to make sure the file gets closed on deletion.’’’
5
6 def init(self, filepath=’~’, filename=‘sample.txt’):
7 # open a file filename in filepath in read and write mode
8 self.file = open(join(filepath, filename), ‘r+’)
9
10 def del(self):
11 self.file.close()
12 del self.file
複製程式碼
運算子過載:所有運算子都能過載。
複製程式碼
1 class Word(str):
2 ‘’‘Class for words, defining comparison based on word length.’’’
3
4 def new(cls, word):
5 # Note that we have to use new. This is because str is an immutable
6 # type, so we have to initialize it early (at creation)
7 if ’ ’ in word:
8 print “Value contains spaces. Truncating to first space.”
9 word = word[:word.index(’ ')] # Word is now all chars before first space
10 return str.new(cls, word)
11
12 def gt(self, other):
13 return len(self) > len(other)
14
15 def lt(self, other):
16 return len(self) < len(other)
17
18 def ge(self, other):
19 return len(self) >= len(other)
20
21 def le(self, other):
22 return len(self) <= len(other)
23
24 print(Word(“duan”) > Word(“wei”))
複製程式碼
屬性訪問。
複製程式碼
1 class AccessCounter:
2 ‘’‘A class that contains a value and implements an access counter.
3 The counter increments each time the value is changed.’’’
4
5 def init(self, value):
6 super(AccessCounter, self).setattr(‘counter’, 0)
7 super(AccessCounter, self).setattr(‘value’, value)
8
9 def setattr(self, name, value):
10 if name == ‘value’:
11 super(AccessCounter, self).setattr(‘counter’, self.counter + 1)
12 # Make this unconditional.
13 # If you want to prevent other attributes to be set, raise AttributeError(name)
14 super(AccessCounter, self).setattr(name, value)
15
16 def delattr(self, name):
17 if name == ‘value’:
18 super(AccessCounter, self).setattr(‘counter’, self.counter + 1)
19 super(AccessCounter, self).delattr(name)
複製程式碼
集合實現。
複製程式碼
1 class FunctionalList:
2 ‘’‘A class wrapping a list with some extra functional magic, like head,
3 tail, init, last, drop, and take.’’’
4
5 def init(self, values=None):
6 if values is None:
7 self.values = []
8 else:
9 self.values = values
10
11 def len(self):
12 return len(self.values)
13
14 def getitem(self, key):
15 # if key is of invalid type or value, the list values will raise the error
16 return self.values[key]
17
18 def setitem(self, key, value):
19 self.values[key] = value
20
21 def delitem(self, key):
22 del self.values[key]
23
24 def iter(self):
25 return iter(self.values)
26
27 def reversed(self):
28 return FunctionalList(reversed(self.values))
29
30 def append(self, value):
31 self.values.append(value)
32 def head(self):
33 # get the first element
34 return self.values[0]
35 def tail(self):
36 # get all elements after the first
37 return self.values[1:]
38 def init(self):
39 # get elements up to the last
40 return self.values[:-1]
41 def last(self):
42 # get last element
43 return self.values[-1]
44 def drop(self, n):
45 # get all elements except first n
46 return self.values[n:]
47 def take(self, n):
48 # get first n elements
49 return self.values[:n]
複製程式碼
可呼叫物件,像方法一樣呼叫物件。
複製程式碼
1 class Entity:
2 ‘’‘Class to represent an entity. Callable to update the entity’s position.’’’
3
4 def init(self, size, x, y):
5 self.x, self.y = x, y
6 self.size = size
7
8 def call(self, x, y):
9 ‘’‘Change the position of the entity.’’’
10 self.x, self.y = x, y
11 print(x, y)
12
13 entity = Entity(5, 1, 1)
14 entity(2, 2)
複製程式碼
資源管理
複製程式碼
1 class Closer:
2 def enter(self):
3 return self
4
5 def exit(self, exception_type, exception_val, trace):
6 print(“清理完成”)
7 return True;
8
9 with Closer() as closer:
10 pass
複製程式碼
物件描述符。
複製程式碼
1 class Meter(object):
2 ‘’‘Descriptor for a meter.’’’
3
4 def init(self, value=0.0):
5 self.value = float(value)
6 def get(self, instance, owner):
7 return self.value
8 def set(self, instance, value):
9 self.value = float(value)
10
11 class Foot(object):
12 ‘’‘Descriptor for a foot.’’’
13
14 def get(self, instance, owner):
15 return instance.meter * 3.2808
16 def set(self, instance, value):
17 instance.meter = float(value) / 3.2808
18
19 class Distance(object):
20 ‘’‘Class to represent distance holding two descriptors for feet and
21 meters.’’’
22 meter = Meter()
23 foot = Foot()
複製程式碼
Mixin(也叫摻入)
摻入模組:playable.py
1 # coding=utf-8
2
3 def paly(self):
4 print(“遊戲中…”)
摻入目標模組:test.py
複製程式碼
1 AOP(面向切面程式設計)`@TOC
歡迎使用Markdown編輯器
你好! 這是你第一次使用 Markdown編輯器 所展示的歡迎頁。如果你想學習如何使用Markdown編輯器, 可以仔細閱讀這篇文章,瞭解一下Markdown的基本語法知識。
新的改變
我們對Markdown編輯器進行了一些功能擴充與語法支援,除了標準的Markdown編輯器功能,我們增加了如下幾點新功能,幫助你用它寫部落格:
- 全新的介面設計 ,將會帶來全新的寫作體驗;
- 在創作中心設定你喜愛的程式碼高亮樣式,Markdown 將程式碼片顯示選擇的高亮樣式 進行展示;
- 增加了 圖片拖拽 功能,你可以將本地的圖片直接拖拽到編輯區域直接展示;
- 全新的 KaTeX數學公式 語法;
- 增加了支援甘特圖的mermaid語法1 功能;
- 增加了 多螢幕編輯 Markdown文章功能;
- 增加了 焦點寫作模式、預覽模式、簡潔寫作模式、左右區域同步滾輪設定 等功能,功能按鈕位於編輯區域與預覽區域中間;
- 增加了 檢查列表 功能。
功能快捷鍵
撤銷: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
語法後生成一個完美的目錄。
如何改變文字的樣式
強調文字 強調文字
加粗文字 加粗文字
標記文字
刪除文字
引用文字
H2O is是液體。
210 運算結果是 1024.
插入連結與圖片
連結: link.
圖片:
帶尺寸的圖片:
居中的圖片:
居中並且帶尺寸的圖片:
當然,我們為了讓使用者更加便捷,我們增加了圖片拖拽功能。
如何插入一段漂亮的程式碼片
去部落格設定頁面,選擇一款你喜歡的程式碼片高亮樣式,下面展示同樣高亮的 程式碼片
.
// An highlighted block
var foo = 'bar';
生成一個適合你的列表
- 專案
- 專案
- 專案
- 專案
- 專案1
- 專案2
- 專案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公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通過尤拉積分
Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.
你可以找到更多關於的資訊 LaTeX 數學表示式here.
新的甘特圖功能,豐富你的文章
- 關於 甘特圖 語法,參考 這兒,
UML 圖表
可以使用UML圖表進行渲染。 Mermaid. 例如下面產生的一個序列圖:
這將產生一個流程圖。:
- 關於 Mermaid 語法,參考 這兒,
FLowchart流程圖
我們依舊會支援flowchart的流程圖:
- 關於 Flowchart流程圖 語法,參考 這兒.
匯出與匯入
匯出
如果你想嘗試使用此編輯器, 你可以在此篇文章任意編輯。當你完成了一篇文章的寫作, 在上方工具欄找到 文章匯出 ,生成一個.md檔案或者.html檔案進行本地儲存。
匯入
如果你想載入一篇你寫過的.md檔案,在上方工具欄可以選擇匯入功能進行對應副檔名的檔案匯入,
繼續你的創作。
註腳的解釋 ↩︎
相關文章
- Python NumPy學習總結Python
- python學習命令總結Python
- Python學習第一週學習總結Python
- Python Requets庫學習總結Python
- Python---python函式學習總結Python函式
- python學習方法總結(內附python全套學習資料)Python
- Python str型別學習總結(一)Python型別
- Python pyinstaller類庫使用學習總結Python
- Python pycryptodome類庫使用學習總結Python
- Python pymodbus類庫使用學習總結Python
- python-機器學習程式碼總結Python機器學習
- 學習總結
- python學習總結之 函式定義defPython函式
- Python clickhouse-driver 類庫使用學習總結Python
- ConstraintLayout 學習總結AI
- BOM學習總結
- tkinter學習總結
- vue學習總結Vue
- HSF學習總結
- ElasticSearch 學習總結Elasticsearch
- Storm學習總結ORM
- vue 學習總結Vue
- lua 學習總結
- Angularjs 學習總結AngularJS
- WebRTC學習總結Web
- GCD 學習總結GC
- CompletableFuture學習總結
- awk 學習總結
- MyBatis 學習總結MyBatis
- Maven學習總結Maven
- Ajax學習總結
- JVM學習總結JVM
- mysqlimport學習總結MySqlImport
- WorkFlow學習總結
- JNI 學習總結
- SVG學習總結SVG
- HTML學習總結HTML
- Mybatis學習總結MyBatis