新人報到

manhong2112

之前寫的一堆排序算法...

1. import random
   
2. import timeit
   
3. 
   
4. 
   
5. def printf(string, *obj):
   
6.     return print(string.format(*obj))
   
7. 
   
8. 
   
9. def bubble_sort(arr):
   
10.     arr = arr[:]
    
11.     for i in range(len(arr) - 1, 0, -1):
    
12.         for j in range(i):
    
13.             if arr[j] > arr[j + 1]:
    
14.                 arr[j], arr[j + 1] = arr[j + 1], arr[j]
    
15.     return arr
    
16. 
    
17. 
    
18. def quick_sort(arr):
    
19.     if len(arr) <= 1:
    
20.         return arr
    
21.     a = arr[0]
    
22.     b = []
    
23.     c = []
    
24.     for i in arr[1:]:
    
25.         (b if i < a else c).append(i)
    
26.     return quick_sort(b) + [a] + quick_sort(c)
    
27. 
    
28. 
    
29. def swap(arr, x, y):
    
30.     arr[x], arr[y] = arr[y], arr[x]
    
31. 
    
32. def quicksort_inplace_iter(arr):
    
33.     stack = [(0, len(arr))]
    
34.     while stack:
    
35.         s, e = stack.pop()
    
36.         s1, e1 = s, e
    
37.         if s >= e:
    
38.             continue
    
39.         i = s
    
40.         x = arr[e-1]
    
41.         while s+1 < e1:
    
42.             if arr[s] > x:
    
43.                 swap(arr, s, e1 - 1)
    
44.                 e1 -= 1
    
45.             else:
    
46.                 swap(arr, s, s1)
    
47.                 s1 += 1
    
48.             s += 1
    
49.         stack.append((i, s))
    
50.         stack.append((s+1, e))
    
51. 
    
52. def random_arr(length):
    
53.     arr = []
    
54.     for i in range(length):
    
55.         arr.append(random.randint(0, length ** 2))
    
56.     return arr
    
57. 
    
58. 
    
59. def merge_sort(arr):
    
60.     def merge(arr1, arr2):
    
61.         result = []
    
62.         i = 0
    
63.         j = 0
    
64.         while True:
    
65.             if i == len(arr1):
    
66.                 result.extend(arr2[j:])
    
67.                 break
    
68.             if j == len(arr2):
    
69.                 result.extend(arr1[i:])
    
70.                 break
    
71.             if arr1[i] < arr2[j]:
    
72.                 result.append(arr1[i])
    
73.                 i += 1
    
74.             else:
    
75.                 result.append(arr2[j])
    
76.                 j += 1
    
77.         return result
    
78. 
    
79.     length = len(arr)
    
80.     if length <= 1:
    
81.         return arr
    
82.     return arr if length <= 1 else merge(
    
83.         merge_sort(arr[:int(length / 2)]),
    
84.         merge_sort(arr[int(length / 2):]))
    
85. 
    
86. 
    
87. def select_sort(arr):
    
88.     for i in range(len(arr)):
    
89.         for j in range(i, len(arr)):
    
90.             if arr[j] < arr[i]:
    
91.                 arr[i], arr[j] = arr[j], arr[i]
    
92.     return arr
    
93. 
    
94. 
    
95. def time(fun, *arr):
    
96.     s = timeit.default_timer()
    
97.     fun(*arr)
    
98.     e = timeit.default_timer()
    
99.     return((e - s) * 1000)
    

复制代码

manhong2112

筆記本

1. import os
   
2. import math
   
3. import pickle
   
4. sum = lambda x: 0 if len(x) == 0 else x[0] + sum(x[1:])
   
5. 
   
6. 
   
7. class Reader(object):
   
8. 
   
9.     def __init__(self, path=None):
   
10.         self.Note = NoteManager.get_note(path)
    
11.         self.Note.load()
    
12.         pass
    
13. 
    
14.     def read(self):
    
15.         return self.Note.Context
    
16. 
    
17.     def write(self, context):
    
18.         self.Note.Context = context
    
19.         pass
    
20. 
    
21.     def write_line(self, context):
    
22.         self.Note.Context += context
    
23.         self.Note.Context += "\n"
    
24.         pass
    
25. 
    
26.     def append(self, context):
    
27.         self.Note.Context += context
    
28.         pass
    
29. 
    
30.     def save(self):
    
31.         with open(self.Note.nPath, "wb+") as f:
    
32.             pickle.dump((self.Note.Context, self.Note.Type), f)
    
33. 
    
34. 
    
35. class Note(object):
    
36.     storageLoc = "./note"
    
37. 
    
38.     def __init__(self, path, name, file_type="Text"):
    
39.         assert type(name) is str
    
40.         assert type(path) is str
    
41.         assert type(file_type) is str
    
42.         self.Name = name
    
43.         self.Type = file_type
    
44.         self.id = path
    
45.         self.nPath = os.path.join(self.storageLoc, path)
    
46.         self.Context = ""
    
47. 
    
48.     def load(self):
    
49.         os.makedirs(os.path.dirname(self.nPath), exist_ok=True)
    
50.         if not os.path.isfile(self.nPath):
    
51.             with open(self.nPath, "wb+") as f:
    
52.                 pickle.dump(("", self.Type), f)
    
53.         with open(self.nPath, "rb+") as f:
    
54.             self.Context, self.Type = pickle.load(f)
    
55. 
    
56. 
    
57. class NoteManager(object):
    
58.     note_pool_loc = "./NoteList.db"
    
59.     __note_pool = {}
    
60. 
    
61.     @staticmethod
    
62.     def get_note(path):
    
63.         pool, name = NoteManager.parse_path(path)
    
64.         return pool[name]["Note"]
    
65.         pass
    
66. 
    
67.     @staticmethod
    
68.     def new_note(path, name, file_type="Text"):
    
69.         n = Note(path, name, file_type)
    
70.         NoteManager.add_note(path, n)
    
71.         pass
    
72. 
    
73.     @staticmethod
    
74.     def filter(dir, f):
    
75.         assert type(dir) is str
    
76.         result = []
    
77.         pool, name = NoteManager.parse_path(dir)
    
78.         for i in pool:
    
79.             if i[-1] == "/":
    
80.                 result.extend(NoteManager.filter(dir + i, f))
    
81.             elif (pool[i]["Tag"] & f) == f:
    
82.                 result.append(dir + i)
    
83.         return sorted(result)
    
84.         pass
    
85. 
    
86.     @staticmethod
    
87.     def save():
    
88.         tmp = {}
    
89. 
    
90.         def _f(path, pool):
    
91.             for p in pool:
    
92.                 if p[-1] == "/":
    
93.                     _f(path + p, pool[p])
    
94.                 else:
    
95.                     x = pool[p]
    
96.                     tmp[p] = {"Tag": x["Tag"], "Name": x["Note"].Name}
    
97.         _f("", NoteManager.__note_pool)
    
98.         with open(NoteManager.note_pool_loc, "wb+") as f:
    
99.             pickle.dump(tmp, f)
    
100.         pass
     
101. 
     
102.     @staticmethod
     
103.     def add_note(path, note):
     
104.         pool, name = NoteManager.parse_path(path)
     
105.         pool[name] = {"Tag": 0, "Note": note}
     
106.         pass
     
107. 
     
108.     @staticmethod
     
109.     def del_note(path):
     
110.         os.remove(os.path.join(Note.storageLoc, path))
     
111.         pool, name = NoteManager.parse_path(path)
     
112.         pool.remove(name)
     
113.         pass
     
114. 
     
115.     @staticmethod
     
116.     def add_tag(path, *tag):
     
117.         pool, name = NoteManager.parse_path(path)
     
118.         t = sum(tag)
     
119.         if (pool[name]["Tag"] & t) != t:
     
120.             pool[name]["Tag"] += t
     
121. 
     
122.     @staticmethod
     
123.     def del_tag(path, *tag):
     
124.         pool, name = NoteManager.parse_path(path)
     
125.         t = sum(tag)
     
126.         if (pool[name]["Tag"] & t) == t:
     
127.             pool[name]["Tag"] -= t
     
128. 
     
129.     @staticmethod
     
130.     def get_tag(path):
     
131.         pool, name = NoteManager.parse_path(path)
     
132.         t = pool[name]["Tag"]
     
133.         tag = set({})
     
134.         while t != 0:
     
135.             x = int(math.log(t, 2))
     
136.             t -= x
     
137.             tag.add(TagManager.tag(x))
     
138.             pass
     
139.         return tag
     
140. 
     
141.     @staticmethod
     
142.     def parse_path(path):
     
143.         x = path.split("/")
     
144.         pool = NoteManager.__note_pool
     
145.         for i in x[:-1]:
     
146.             if i + "/" not in pool:
     
147.                 pool[i + "/"] = {}
     
148.             pool = pool[i + "/"]
     
149.         return pool, x[-1]
     
150. 
     
151.     if not os.path.isfile(note_pool_loc):
     
152.         with open(note_pool_loc, "wb+") as f:
     
153.             pickle.dump(__note_pool, f)
     
154.     else:
     
155.         with open(os.path.join(note_pool_loc), "rb+") as f:
     
156.             tmp = pickle.load(f)
     
157.         for i in tmp:
     
158.             x = i.split("/")
     
159.             pool = __note_pool
     
160.             for i in x[:-1]:
     
161.                 if i + "/" not in pool:
     
162.                     pool[i + "/"] = {}
     
163.                 pool = pool[i + "/"]
     
164.             name = x[-1]
     
165.             pool[name] = {"Tag": tmp[i]["Tag"],
     
166.                           "Note": Note(i, tmp[i]["Name"])}
     
167. 
     
168. 
     
169. class TagManager(object):
     
170.     tag_pool_loc = "TagList.db"
     
171.     __tag_pool = []
     
172. 
     
173.     @staticmethod
     
174.     def mk_filter(*tag):
     
175.         return sum(tag)
     
176. 
     
177.     @staticmethod
     
178.     def new_tag(tag_name):
     
179.         if tag_name not in TagManager.__tag_pool:
     
180.             TagManager.__tag_pool.append(tag_name)
     
181.         pass
     
182. 
     
183.     @staticmethod
     
184.     def tag(x):
     
185.         if type(x) is str:
     
186.             return 2**TagManager.__tag_pool.index(x)
     
187.         elif type(x) is int:
     
188.             return TagManager.__tag_pool[math.log(x, 2)]
     
189. 
     
190.     @staticmethod
     
191.     def save():
     
192.         with open(os.path.join(TagManager.tag_pool_loc), "wb+") as f:
     
193.             pickle.dump(TagManager.__tag_pool, f)
     
194.         pass
     
195. 
     
196.     if os.path.isfile(tag_pool_loc):
     
197.         with open(os.path.join(tag_pool_loc), "rb+") as f:
     
198.             __tag_pool = pickle.load(f)
     
199.     else:
     
200.         with open(os.path.join(tag_pool_loc), "wb+") as f:
     
201.             pickle.dump(__tag_pool, f)
     
202. 
     

复制代码

manhong2112

Brainfuck 解釋器(+半個編譯器)

1. 
   
2. import msvcrt
   
3. 
   
4. 
   
5. def interp(expr):
   
6.     ptr = 0
   
7.     ram = dict()
   
8.     loopStack = []
   
9.     excapingLoop = 0
   
10.     i = 0
    
11.     while(i < len(expr)):
    
12.         # print(ram, loopStack, excapingLoop)
    
13.         x = expr[i]
    
14.         if not (ptr in ram) or ram[ptr] > 127 or ram[ptr] < -128:
    
15.             ram[ptr] = 0
    
16.         if x == "[":
    
17.             if excapingLoop > 0:
    
18.                 excapingLoop += 1
    
19.             elif ram[ptr] != 0:
    
20.                 loopStack.append(i)
    
21.             else:
    
22.                 excapingLoop = 1
    
23.         elif x == "]":
    
24.             if excapingLoop > 0:
    
25.                 excapingLoop -= 1
    
26.             elif ram[ptr] != 0:
    
27.                 i = loopStack[-1]
    
28.             else:
    
29.                 loopStack.pop()
    
30.         elif excapingLoop > 0:
    
31.             pass
    
32.         elif x == "+":
    
33.             ram[ptr] += 1
    
34.         elif x == "-":
    
35.             ram[ptr] -= 1
    
36.         elif x == ">":
    
37.             ptr += 1
    
38.         elif x == "<":
    
39.             ptr -= 1
    
40.         elif x == ".":
    
41.             print(chr(ram[ptr]), end="")
    
42.             pass
    
43.         elif x == ",":
    
44.             ram[ptr] = ord(msvcrt.getch())
    
45.         i += 1
    
46. 
    
47. version = 0x01
    
48. header = [0x00, 0x10, 0x26, 0xBF, version, 0x00]
    
49. # null, id, id, ver, id, mem_len
    
50. 
    
51. 
    
52. class ID():
    
53.     START_LOOP = 0
    
54.     END_LOOP = 1
    
55.     INC = 2
    
56.     DEC = 3
    
57.     NEXT = 4
    
58.     BACK = 5
    
59.     GETC = 6
    
60.     PUTC = 7
    
61. 
    
62.     ADD = 8
    
63.     MOVE = 9
    
64. 
    
65. 
    
66. def compile(expr):
    
67.     result = header.copy()
    
68.     state = 0
    
69.     tmp = 0
    
70.     memloc = 0
    
71.     mmemloc = 0
    
72.     loopStack = []
    
73.     i = 0
    
74.     while i <= len(expr):
    
75.         # print(ram, loopStack, excapingLoop)
    
76.         if memloc > mmemloc:
    
77.             mmemloc = memloc
    
78.         x = expr[i] if i != len(expr) else 0xFF
    
79.         if state == 0:
    
80.             if x == "[":
    
81.                 loopStack.append(len(result))
    
82.                 result.append(ID.START_LOOP)
    
83.                 result.append(0)
    
84.                 if memloc == 0:
    
85.                     memloc = 1
    
86.             elif x == "]":
    
87.                 a = loopStack.pop()
    
88.                 result[a + 1] = len(result) - a - 1
    
89.                 result.append(ID.END_LOOP)
    
90.                 result.append(len(result) - a + 1)
    
91.             elif x == "+":
    
92.                 state = ID.ADD
    
93.                 tmp += 1
    
94.             elif x == "-":
    
95.                 state = ID.ADD
    
96.                 tmp -= 1
    
97.             elif x == ">":
    
98.                 state = ID.MOVE
    
99.                 tmp += 1
    
100.             elif x == "<":
     
101.                 state = ID.MOVE
     
102.                 tmp -= 1
     
103.             elif x == ".":
     
104.                 result.append(ID.PUTC)
     
105.             elif x == ",":
     
106.                 result.append(ID.GETC)
     
107.         elif state == ID.ADD:
     
108.             if x in "+-":
     
109.                 if x == "+":
     
110.                     tmp += 1
     
111.                 elif x == "-":
     
112.                     tmp -= 1
     
113.             else:
     
114.                 if tmp == 0:
     
115.                     pass
     
116.                 elif tmp == 1:
     
117.                     result.append(ID.INC)
     
118.                 elif tmp == -1:
     
119.                     result.append(ID.DEC)
     
120.                 else:
     
121.                     result.append(ID.ADD)
     
122.                     result.append(tmp)
     
123.                 state = 0
     
124.                 i -= 1
     
125.                 tmp = 0
     
126.         elif state == ID.MOVE:
     
127.             if x in "><":
     
128.                 if x == ">":
     
129.                     tmp += 1
     
130.                 elif x == "<":
     
131.                     tmp -= 1
     
132.             else:
     
133.                 if tmp == 0:
     
134.                     pass
     
135.                 elif tmp == 1:
     
136.                     result.append(ID.NEXT)
     
137.                     memloc += 1
     
138.                 elif tmp == -1:
     
139.                     result.append(ID.BACK)
     
140.                     memloc -= 1
     
141.                 else:
     
142.                     result.append(ID.MOVE)
     
143.                     result.append(tmp)
     
144.                     memloc += tmp
     
145.                 i -= 1
     
146.                 state = 0
     
147.                 tmp = 0
     
148.         i += 1
     
149.     result[5] = mmemloc
     
150.     result.append(0xFF)
     
151.     return result
     
152. 
     
153. 
     
154. class Env(object):
     
155.     def __init__(self, mem_len):
     
156.         self.data = [0] * (mem_len + 1)
     
157.         self.ptr = 0
     
158. 
     
159.     def move(self, val):
     
160.         self.ptr += val
     
161. 
     
162.     def read(self):
     
163.         return self.data[self.ptr]
     
164. 
     
165.     def write(self, val):
     
166.         self.data[self.ptr] = val if -128 <= val <= 127 else 0
     
167. 
     
168. 
     
169. def execute(compiledExpr):
     
170.     expr = compiledExpr
     
171.     i = len(header)
     
172.     env = Env(expr[5])
     
173.     while i < len(expr) - 1:
     
174.         x = expr[i]
     
175.         if x == ID.INC:
     
176.             env.write(env.read() + 1)
     
177.         elif x == ID.DEC:
     
178.             env.write(env.read() - 1)
     
179.         elif x == ID.NEXT:
     
180.             env.move(1)
     
181.         elif x == ID.BACK:
     
182.             env.move(-1)
     
183.         elif x == ID.PUTC:
     
184.             print(chr(env.read()), end="")
     
185.         elif x == ID.GETC:
     
186.             env.write(ord(msvcrt.getch()))
     
187.         else:
     
188.             if x == ID.START_LOOP and env.read() == 0:
     
189.                 i += expr[i + 1]
     
190.             elif x == ID.END_LOOP and env.read() != 0:
     
191.                 i -= expr[i + 1]
     
192.             elif x == ID.ADD:
     
193.                 env.write(env.read() + expr[i + 1])
     
194.             elif x == ID.MOVE:
     
195.                 env.move(expr[i + 1])
     
196.             i += 1
     
197.         i += 1
     
198. 
     
199. import timeit
     
200. 
     
201. 
     
202. def time(fun, *arr):
     
203.     s = timeit.default_timer()
     
204.     fun(*arr)
     
205.     e = timeit.default_timer()
     
206.     return((e - s) * 1000)
     
207. 
     
208. expr = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
     
209. cexpr = compile(expr)
     
210. 
     
211. x1, x2 = 0, 0
     
212. for i in range(0, 100):
     
213.     x1 += time(execute, cexpr)
     
214. for i in range(0, 100):
     
215.     x2 += time(interp, expr)
     
216. 
     
217. print(x1 / 100)
     
218. print(x2 / 100)
     

复制代码

manhong2112

寫了一個爬蟲, 一開始用lxml總是報錯(貌似是網站的HTML有問題)...就轉用BeautifulSoup了...
雖然能用, 但總感覺哪裡不太對勁..
EDIT: 相對路徑沒被簡化, 組成了一個迴圈....
EDIT: 找到了urljoin這函數, 希望不再出bug

1. 
   
2. # from lxml import etree
   
3. from bs4 import BeautifulSoup
   
4. import urllib as request
   
5. from urlparse import urljoin
   
6. import re
   
7. import os
   
8. 
   
9. 
   
10. def getHtml(url):
    
11.     res = request.urlopen(url)
    
12.     try:
    
13.         return url, res.read().decode("utf-8")
    
14.     except Exception:
    
15.         return url, res.read().decode("big5")
    
16. 
    
17. 
    
18. def extractLink(url, html):
    
19.     soup = BeautifulSoup(html, "html.parser")
    
20.     return set(map(lambda i: re.sub("#.*$", "", urljoin(url, i["href"])), soup.findAll('a')))
    
21.     # return set(etree.HTML(html).xpath("//a/@href"))
    
22. 
    
23. 
    
24. target = "http://example.com/" # 目標網站
    
25. startAt = "http://example.com/index.html" # 起始網頁
    
26. output = "output" # 輸出
    
27. downloadedLink = set()
    
28. toBeDownload = set()
    
29. toBeDownload.add(startAt)
    
30. p = re.compile("https?://.*?/(.*)")
    
31. 
    
32. while len(toBeDownload) != 0:
    
33.     try:
    
34.         url = toBeDownload.pop()
    
35.         downloadedLink.add(url)
    
36.         if (url.startswith("http") or url.startswith("https")) and not url.startswith(target):
    
37.             continue
    
38.         print "Downloading " + url
    
39.         _, content = getHtml(url)
    
40.         m = re.match(p, url)
    
41.         m = m.group(1)
    
42.         path, file = os.path.split(m)
    
43.         try:
    
44.             os.makedirs(os.path.join(output, path))
    
45.         except Exception:
    
46.             pass
    
47.         with open(os.path.join(output, m), "w") as f:
    
48.             f.write(content.encode('utf8'))
    
49.         newUrl = extractLink(url, content).difference(downloadedLink)
    
50.         toBeDownload = toBeDownload.union(newUrl)
    
51.     except Exception:
    
52.         print "Failed to Download " + url
    

复制代码

manhong2112

原本想弄個筆記本, 然後架個站自用...然後寫着寫着寫成了vcs(算嗎?算吧)......
話說混亂到自己都看不太下去了XDDD
EDIT: 換成if-else...感覺不想再看到python的lambda了....
EDIT: 大改了一下, 和把index的rollback功能刪了

1. import hashlib
   
2. import os
   
3. import json
   
4. import datetime
   
5. import time
   
6. 
   
7. dataLoc = "data"
   
8. 
   
9. class Enitiy(object):
   
10. 
    
11.     def __init__(self, name, dtype, hashcode, history):
    
12.         self.name = name
    
13.         self.dtype = dtype
    
14.         self.hashcode = hashcode
    
15.         self.history = history
    
16. 
    
17. class Index(Enitiy):
    
18. 
    
19.     def __init__(self, name, jsons=None, hashcode=None):
    
20.         self.name = name
    
21.         self.index = dict()
    
22.         if jsons is not None:
    
23.             for i in jsons["index"]:
    
24.                 if i["type"] == "Index":
    
25.                     self.index[i["name"]] = Index(
    
26.                         i["name"],
    
27.                         json.loads(read(i["hashcode"])),
    
28.                         i["hashcode"])
    
29.                 else:
    
30.                     self.index[i["name"]] = Enitiy(
    
31.                         i["name"],
    
32.                         i["type"],
    
33.                         i["hashcode"],
    
34.                         i["history"] if "history" in i else dict())
    
35. 
    
36.         super().__init__(name, "Index", hashcode, None)
    
37. 
    
38.     def __str__(self):
    
39.         return str(self.index)
    
40. 
    
41.     def __getitem__(self, k):
    
42.         return self.index[k]
    
43. 
    
44.     def __setitem__(self, k, v):
    
45.         self.index[k] = v
    
46. 
    
47.     def __contains__(self, item):
    
48.         return item in self.index
    
49. 
    
50.     def __len__(self):
    
51.         return len(self.index)
    
52. 
    
53.     def items(self):
    
54.         return self.index.items()
    
55. 
    
56.     def dumpJsons(self):
    
57.         result = dict()
    
58.         result["index"] = []
    
59.         result["name"] = self.name
    
60.         for k, v in self.index.items():
    
61.             obj = dict()
    
62.             obj["name"], obj["type"], obj["hashcode"], obj["history"] = v.name, v.dtype, v.hashcode, v.history
    
63.             result["index"].append(obj)
    
64.         return json.dumps(result)
    
65. 
    
66. _open = open
    
67. def open(hashcode, type="w+"):
    
68.     path = getPath(hashcode)
    
69.     os.makedirs(os.path.dirname(path), exist_ok=True)
    
70.     if os.path.isfile(path):
    
71.         type = "r+"
    
72.     else:
    
73.         type = "w"
    
74.     return _open(path, type, encoding="UTF-8")
    
75. 
    
76. def getPath(hashcode):
    
77.     return os.path.join(dataLoc, hashcode[:2], hashcode)
    
78. 
    
79. def hash(str):
    
80.     return hashlib.sha1(str).hexdigest()
    
81. 
    
82. def hashStr(str):
    
83.     return hash(str.encode("utf-8"))
    
84. 
    
85. def hashFile(name, content):
    
86.     return hash((name + "|" + content).encode("utf-8"))
    
87. 
    
88. def read(hashcode):
    
89.     with open(hashcode) as f:
    
90.         return f.read()
    
91. 
    
92. def init():
    
93.     root = None
    
94.     path = getPath("root")
    
95. 
    
96.     name = "/"
    
97. 
    
98.     if not os.path.isfile(path):
    
99.         root = Index(name)
    
100.         root_json = root.dumpJsons()
     
101.         hashcode = hashFile(name, root_json)
     
102.         with open(hashcode) as f:
     
103.             f.write(root_json)
     
104.         with open("root") as f:
     
105.             f.write(json.dumps({"hashcode": hashcode, "name": name, "type": "Index"}))
     
106.     else:
     
107.         with open("root") as f:
     
108.             accessPt = json.loads(f.read())
     
109.             hashcode = accessPt["hashcode"]
     
110.             with open(hashcode) as f:
     
111.                 root = Index(name, json.loads(f.read()), hashcode)
     
112.     return [root]
     
113. 
     
114. def end(indexStack):
     
115.     root = indexStack[0]
     
116.     date = datetime.datetime.now().strftime("%Y/%m/%d-%H:%M:%S")
     
117.     name = "/"
     
118.     content = root.dumpJsons()
     
119.     hashcode = hashFile(name, content)
     
120.     with open(hashcode) as f:
     
121.         f.write(content)
     
122.     with open("root") as f:
     
123.         accessPt = json.loads(f.read())
     
124.         f.seek(0)
     
125.         accessPt["hashcode"] = hashcode
     
126.         f.write(json.dumps(accessPt))
     
127.         f.truncate()
     
128. 
     
129. helpCmd = {
     
130.     "update": ["Usage>> update <name> <type> <content>",
     
131.                "Usage>> Update or create a file"],
     
132.     "rollback": ["Usage>> rollback <name> <id>",
     
133.                  "Usage>> Rollback to the specified id"],
     
134.     "ls": ["Usage>> ls [name]",
     
135.            "Usage>> list all file in current dir or specified dir"],
     
136.     "cd": ["Usage>> cd <dir|'..'>",
     
137.            "Usage>> cd to specified dir"],
     
138.     "mkdir": ["Usage>> mkdir <dir>",
     
139.               "Usage>> create a new dir at current dir"],
     
140.     "read": ["Usage>> read <name>",
     
141.              "Usage>> read the content of specified file"],
     
142.     "history": ["Usage>> history <name>",
     
143.                 "Usage>> List modifiy history of specified file"],
     
144.     "help": ["Usage>> <cmd>", "Usage>> Print the usage of cmd",
     
145.              "Usage>> all cmd[update, rollback, ls, cd, mkdir, read, history, help]"]
     
146. }
     
147. mainCmd = {"update", "rollback", "ls", "cd",
     
148.            "mkdir", "read", "history", "help", }
     
149. 
     
150. def update(indexStack, name, dtype, content):
     
151.     index = indexStack[-1]
     
152.     date = datetime.datetime.now().strftime("%Y/%m/%d %H:%M:%S")
     
153.     dateid = hashStr(date)[:6]
     
154.     entity_hashcode = hashFile(name, content)
     
155. 
     
156.     with open(entity_hashcode) as f:
     
157.         f.write(content)
     
158. 
     
159.     if name not in index:
     
160.         if dtype == "Index":
     
161.             index[name] = Index(name, hashcode=entity_hashcode)
     
162.         else:
     
163.             index[name] = Enitiy(name, dtype, entity_hashcode, dict())
     
164.     else:
     
165.         entity = index[name]
     
166.         entity.history[dateid] = (date, entity.hashcode)
     
167.         entity.hashcode = entity_hashcode
     
168. 
     
169. def rollback(indexStack, name, datetimeid):
     
170.     """
     
171.     indexStack
     
172.     name = file/dir name
     
173.     datetimeid = date
     
174.     """
     
175.     index = indexStack[-1]
     
176.     assert type(index[name]) is not Index
     
177.     history = index[name].history
     
178.     assert datetimeid in history
     
179.     with open(history[datetimeid][1]) as f:
     
180.         update(indexStack, name, index[name].dtype, f.read())
     
181. 
     
182. def ls(indexStack, name=None):
     
183.     if name is not None:
     
184.         index = Index(name, json.loads(read(indexStack[-1][name].hashcode)))
     
185.     else:
     
186.         index = indexStack[-1]
     
187.     assert type(index) is Index
     
188.     return index.name, sorted([(e.name, e.dtype) for _, e in index.items()])
     
189.    
     
190. def cd(indexStack, name):
     
191.     """
     
192.     indexStack
     
193.     name = file/dir name
     
194.     """
     
195.     assert type(indexStack) is list
     
196.     assert type(name) is str
     
197.     if name == "..":
     
198.         indexStack.pop()
     
199.     else:
     
200.         index = indexStack[-1]
     
201.         assert type(index[name]) is Index
     
202.         indexStack.append(index[name])
     
203. 
     
204. def getHistory(indexStack, name):
     
205.     """
     
206.     indexStack
     
207.     name = file name
     
208.     """
     
209.     assert type(indexStack) is list
     
210.     assert type(name) is str
     
211.     index = indexStack[-1]
     
212.     assert type(index[name]) is not Index
     
213.     return index[name].history
     
214. 
     
215. def mkdir(indexStack, name):
     
216.     assert name not in indexStack[-1]
     
217.     update(indexStack, name, "Index", Index(name).dumpJsons())
     
218. 
     
219. if __name__ == '__main__':
     
220.     indexStack = init()
     
221.     try:
     
222.         while True:
     
223.             cmd = input("/".join([i.name for i in indexStack]) + ">> ").split(" ")
     
224.             args = cmd[1:] if len(cmd) > 1 else []
     
225.             if cmd[0] in mainCmd:
     
226.                 if cmd[0] == "update":
     
227.                     update(indexStack, *args)
     
228.                 elif cmd[0] == "rollback":
     
229.                     rollback(indexStack, args[0], args[1])
     
230.                 elif cmd[0] == "ls":
     
231.                     if len(args) == 1:
     
232.                         i = ls(indexStack, *args)
     
233.                     else:
     
234.                         i = ls(indexStack)
     
235.                     print(i[0] + " :"),
     
236.                     print("\n".join(["\t" + n + " | " + t for n, t in i[1]]))
     
237.                 elif cmd[0] == "cd":
     
238.                     cd(indexStack, *args)
     
239.                 elif cmd[0] == "mkdir":
     
240.                     if len(args) != 1:
     
241.                         print("E>")
     
242.                     else:
     
243.                         mkdir(indexStack, args[0])
     
244.                 elif cmd[0] == "read":
     
245.                     if len(args) != 1:
     
246.                         print("E>")
     
247.                     else:
     
248.                         print(read(indexStack[-1][args[0]].hashcode)),
     
249.                 elif cmd[0] == "history":
     
250.                     if len(args) == 1:
     
251.                         history = getHistory(indexStack, args[0])
     
252.                         print(args[0] + " :")
     
253.                         print("id\t|date")
     
254.                         print("\n".join(
     
255.                              ["{}\t|{}".format(x[0], x[1]) for x in
     
256.                                sorted([(dateid, v[0]) for dateid, v in history.items()], key=lambda x: x[1])]))
     
257.                     else:
     
258.                         print("E>")
     
259.                 elif cmd[0] == "help":
     
260.                     exit = False
     
261.                     while not exit:
     
262.                         cmd = input("Help>> ")
     
263.                         if cmd == "exit" or cmd == "quit":
     
264.                             exit = True
     
265.                         elif cmd in helpCmd:
     
266.                             list(map(lambda x: print(x), helpCmd[cmd]))
     
267.                         else:
     
268.                             print("E> Invalid command")
     
269.             elif cmd[0] == "exit" or cmd[0] == "quit":
     
270.                 break
     
271.             else:
     
272.                 print("E> Invalid command")
     
273.     except Exception:
     
274.         raise
     
275.     finally:
     
276.         end(indexStack)

复制代码

manhong2112

和之前的筆記本一系列的, 用來抽取指定網址的內容!
目前只做了知乎, 以後再慢慢拓展
#註解掉的是md轉html的

1. from bs4 import BeautifulSoup
   
2. import urllib.request as urllib
   
3. import re
   
4. #import markdown
   
5. 
   
6. 
   
7. def getContext(url):
   
8.     data = parse(url, getRule(url))
   
9.     md = """\
   
10. {title}
    
11. {author}
    
12. {url}
    
13. 
    
14. {content}\
    
15. """.format(
    
16.         title=("#" + data["title"]) if "title" in data else "",
    
17.         author=("###" + data["author"]) if "author" in data else "",
    
18.         url=("#####[Link](" + data["url"] + ")") if "url" in data else "",
    
19.         content=("<hr><br>" + data["content"]) if "content" in data else "")
    
20.     #return "<meta charset='UTF-8'>\n" + markdown.markdown(md, output_format="html5")
    
21.     return md
    
22. 
    
23. rule = [
    
24.     (re.compile(r"https?://www.zhihu.com/question/\d*?/answer/\d*?#?.*"),
    
25.      {"content": {"selector": "div#zh-question-answer-wrap .zm-editable-content"},
    
26.       "title": {"selector": "div#zh-question-title > h2.zm-item-title > a"},
    
27.       "author": {"selector": "span.author-link-line > a.author-link"},
    
28.       "url": {"selector": "meta['http-equiv'='mobile-agent']", "attr": "content", "matching": re.compile(".*url=(.*)")}
    
29.       })
    
30. ]
    
31. 
    
32. 
    
33. def getRule(url):
    
34.     for k, v in rule:
    
35.         if k.match(url):
    
36.             return v
    
37. 
    
38. 
    
39. def getHtml(url, encoding="utf-8"):
    
40.     res = urllib.urlopen(url)
    
41.     return res.read()
    
42. 
    
43. 
    
44. def parse(url, rule):
    
45.     result = dict()
    
46.     soup = BeautifulSoup(getHtml(url), "html.parser")
    
47.     for (k, v) in rule.items():
    
48.         content = None
    
49.         if "attr" in v:
    
50.             content = str(soup.select(v["selector"])[0][v["attr"]]).strip(' \t\n\r')
    
51.         else:
    
52.             content = str(soup.select(v["selector"])[0].get_text()).strip(' \t\n\r')
    
53.         if "matching" in v:
    
54.             m = v["matching"].match(content)
    
55.             if m:
    
56.                 result[k] = m.group(1)
    
57.         else:
    
58.             result[k] = content
    
59.     return result
    
60. 
    
61. print(getContext("http://www.zhihu.com/question/51266789/answer/125952575"))

复制代码