有没有合适的PYTHON抓字典的案例可参考？

stiggg

懂点PYTHON,想学学前人怎么爬字典的。目前只看到BT4BAIDU大大的开源，大大的代码很典范，可是代码四五年了，似乎网站也改版，具体细节的作用比较难揣摩了。不知道还有其它的比较好可参考学习？

毛小驴

顶起

你去哪里

我也想知道这个。

你去哪里

我也想知道这个。

scirem

1. #!/usr/bin/env python3
   
2. # -*- coding: utf-8 -*-
   
3. 
   
4. import os
   
5. import requests
   
6. import re
   ; y3 G6 f7 m% b( y/ i
7. import time
   0 B3 R; V0 ^2 P+ a: `( j" j; c
8. import sqlite3
   
9. 
   
10. from string import ascii_lowercase
    & }, Y$ J- C! D- u3 n  {& K0 q
11. 
    
12. from pathlib import Path
    ( M6 I: J( y% Z1 ]7 A* y
13. from urllib.parse import urljoin
    3 R2 i5 N; N# V3 u
14. from html.parser import HTMLParser
    : w; h0 T. b* ^# m( ]
15. from bs4 import BeautifulSoup
    
16. 
    4 d8 y7 A1 p; a8 W
17. webster_url = "https://www.merriam-webster.com/browse/dictionary/"
    
18. oxford_url = "https://www.oxfordlearnersdictionaries.com/browse/english/"
    ; X% T/ R0 m; f: K/ P3 i
19. macmillan_url = "https://www.macmillandictionary.com/browse/british/"
    
20. cambridge_url ="https://dictionary.cambridge.org/browse/english/"
    3 i' H+ ]  G6 W+ ?$ [/ t1 k" }
21. 
    , @: g+ S; Q: T6 ?1 P" ^- a# S
22. cambridge_english_chinese_url = "https://dictionary.cambridge.org/browse/english-chinese-simplified/"
    
23. 
    
24. base_url = "https://dictionary.cambridge.org/search/direct/"
    
25. header = {"User-Agent": "Chrome/87.0.4280.88 Safari/537.36"}
    
26. payload = {'datasetsearch': 'english-chinese-simplified', 'q': ""}
    - }3 m1 ^. g7 K; k# P# z
27. 
    % B" f/ }$ o: Q5 |
28. conn = sqlite3.connect("Cambridge Advanced Learner's English-Chinese Dictionary.db")
    
29. 
    
30. conn.execute("""
    # X8 e+ i) `/ _# \5 L% ^
31. CREATE TABLE IF NOT EXISTS cambridge (
    ( ?% j7 E. p6 t) Y
32.     entry TEXT PRIMARY KEY
    
33.                UNIQUE
    
34.                NOT NULL,
    
35.     url   TEXT NOT NULL,
    
36.     html  TEXT NOT NULL,
    ) u, o, P: ^1 U( Q# d$ D
37.     latex TEXT
    $ ]. F3 R# n! q" C6 h# M; {
38. );
    4 \: J' N  Z' f
39. """)
    
40. 
    # l, ~- w; \  e
41. conn.commit()
    
42. 
    4 A& l; e" u1 `# R; g' \9 L
43. 
    
44. def latexify(string):
    
45.     result = ""
    % R* E8 `  N- `  Y/ c0 e+ ~# V" t- I
46.     trimmed_string = re.sub(r"\s{2,}", " ", string)
    
47.     for char in re.sub(r"\s+([^\w'"({[])", r"\1", trimmed_string):
    
48.         if char == "%":
    * \$ @. l6 L0 p, ?" f
49.             result += r"\%"
    
50.         elif char == "\":
    4 b* m7 h( X! Q/ S
51.             result += r"\textbackslash{}"
    
52.         elif char == "$":
    " {$ Y& [: |) g1 g
53.             result += r"\$"
    
54.         elif char == "#":
    3 X! X% g% U- `6 ]0 z
55.             result += r"\#"
    
56.         elif char == "&":
    $ E! r. m, ~1 ~' q. W: |  T
57.             result += r"\&"
    : I, U1 i! v1 v# F  h- M5 L8 T1 x
58.         elif char == "{":
    
59.             result += r"\{"
    
60.         elif char == "}":
    
61.             result += r"\}"
      v4 k3 C5 T3 o/ \6 A
62.         elif char == "^":
    $ A0 i* d; L: R' m* Q
63.             result += r"\^"
    % z. a. x& L5 {
64.         elif char == "_":
    
65.             result += r"\_"
    " \5 s/ w( l' O3 J
66.         elif char == "~":
    
67.             result += "r\textasciitilde{}"
    $ d" }( t6 q  w# @
68.         else:
    
69.             result += char
    # Q) [9 e: w* s' p* W+ _5 \4 v8 F0 S
70.     return result
    
71. 
    
72. def latexify_html(beautifulsoup_object):
    
73.     try:
    
74.         return latexify(re.sub(r"\s{2,}", " ", beautifulsoup_object.get_text().replace("\n", " ")).strip())
    9 e2 ]9 I$ q: ]& Z' H9 e& b
75.     except:
    ; X8 H, o1 v5 ^) r  c$ ?
76.         return latexify(beautifulsoup_object)
    
77. 
    . K2 G( f2 B% [  A
78. 
    
79. class CambridgeDictionaryScraper:
    
80.     """ Scraper for Cambridge Dictionary """
    
81.     url_set = set() ## Shared by all instance
    
82. 
    5 y# ~; I. X  u$ p4 M$ O0 K8 z0 E! I
83.     def __init__(self):
    
84.         for item in conn.execute("SELECT url FROM cambridge;"):
    
85.             self.url_set.add(item[0])
    
86.         print("Already Downloaded " + str(len(self.url_set)) + " Words!")
    
87. 
    " j) J7 H5 P/ h" U$ _% z4 p4 x
88. 
    $ ?- \5 X) A5 P+ ^
89.     def __del__(self):
    " A3 F) S+ U6 u3 k4 D
90.         conn.commit()
    # h5 v; }+ j+ L: o. B
91. 
    
92. 
    4 e- ~+ f6 G# l2 _* B: S
93.     def get_word_page(self, url):
    + a8 o, P, R* p$ ^( E# o: |
94.         r = requests.get(url, headers=header)        
    
95.         bs_obj = BeautifulSoup(r.text, "html.parser")
    ( T6 v2 ?6 L5 p( u6 y. c
96.         entry_tag = bs_obj.find("div", {"class": "entry"})
    
97.         if not entry_tag:
    
98.             entry_tag = bs_obj.find("div", {"class": "di-body"})
    ; s/ V/ \1 I2 V* L
99.         if not entry_tag:
    
100.             ## Beta Words
     $ ]1 d0 M; m0 L: g* o! n9 t3 y! f
101.             entry_tag = bs_obj.find("div", {"id": "entryContent"})
     
102.         if not entry_tag:
     
103.             entry_tag = bs_obj
     - l; b# J1 S$ I' N
104. 
     4 t* c) r3 H+ P" a( B: i, ~- _# M
105.         if not entry_tag:
     
106.             entry_tag = bs_obj
     ) D% F* v- _" z
107.         
     ; y2 z/ Q- Q- K, v9 u
108.         for tag in entry_tag.find_all("script"):
     8 a$ |3 k& b, T; I- L: a+ \4 T
109.             tag.extract()
     8 ^/ {& ?! x- _- x
110.             
     9 P) T, @7 p4 {
111.         result_string = str(entry_tag)
     
112.         return result_string
     
113. 
     + c% V' N3 ]' T5 }& f, L5 Q
114.    
     2 e, h' ^! K% o$ M
115.     def start(self, url):
     
116.         r = requests.get(url, headers=header)
     
117. 
     + G3 ~. t& M1 W1 y$ Y/ |( K
118.         bs_obj = BeautifulSoup(r.text, "html.parser")
     ( h; N, c4 @& U9 e$ a5 L- A# g; R5 C
119. 
     * l/ k$ M9 @8 ?$ K7 Y) B
120.         for li_tag in bs_obj.select("li.lpr-10"):
     
121.             child_url = urljoin(cambridge_url, li_tag.a.attrs["href"])
     
122.             print(child_url)
     
123.             self.find_child_entry(child_url)
     
124. 
     2 H) A. V9 K5 Z
125. 
       ]; G& P1 ~1 }, q" Z& Y" h3 f
126.     def find_child_entry(self, url):
     9 y( o8 c4 |. a$ w# M
127.         r = requests.get(url, headers=header)
     
128.         bs_obj = BeautifulSoup(r.text, "html.parser")
     + `, t. o% K4 f
129.         for li_tag in bs_obj.select("li.t-i"):
     * {% N0 U" `9 d5 L" d
130.             child_url = urljoin(url, li_tag.a.attrs["href"]).strip()
     
131.             child_text = li_tag.get_text().strip()
     ' G, m2 `1 O0 N' Y. a
132.             if "..." in child_text:
     
133.                 self.find_child_entry(child_url)
     
134.             else:
     1 n8 ~( z' U% A- S" D) a5 \$ D
135.                 if child_url in self.url_set:
     : G+ y  L7 c0 |& y9 `* n
136.                     continue
     7 d1 R/ I% p$ e, l8 H/ L9 ?) T8 ?
137.                 print(child_text + "\t" + child_url)
     4 `- b' }9 |' y. ?2 a* m3 Z
138.                 conn.execute("INSERT INTO cambridge (entry, url, html) VALUES (?, ?, ?);",
     % X+ J8 Q; s3 ]+ `
139.                 (child_text, child_url, self.get_word_page(child_url)))
     
140.                 conn.commit()
     
141.                 self.url_set.add(child_url)
     8 a7 z0 @: c0 ]
142. 
     $ ?5 Z; Q; G& \+ K8 K
143. 
     9 o" u% j! K7 \
144. class CambridgeDictionaryExtractor():
     + m/ \7 d* e4 A* _" X$ d
145.     def __init__(self, entry, entry_html = ""):
     
146.         self.entry = latexify(entry)
     2 _. ]; U# I  O0 W% z
147.         self.entry_html = entry_html
     
148.         self.result = ""
     
149. 
     - `/ r. U" L( Y/ L! {" a: M7 M- f
150.     # def __del__(self):
     
151.     #     pass
     % y* @/ Q0 O0 b* y7 n4 v% y
152. 
     
153. 
     0 A% K, x9 d9 x8 G+ V8 W! D
154.     def extract(self):
     0 n7 R! g/ U# L& g, v
155.         """
     
156.         <div class="pr idiom-block">
     
157.             <div class="idiom-block"></div>
     
158.         </div>
     / ]' |6 t) Z7 a0 L; U
159.         """
     0 s' D* j5 x8 }/ Q5 b8 _. }3 V2 x' j! O
160.         bs_obj = BeautifulSoup(self.entry_html, "html.parser")
     
161.         self.result += "\\begin{entry}{" + self.entry + "}"
     ( G9 g: F, S1 v* A) `) G
162.         for part_of_speech_tag in bs_obj.find_all("div", {"class": "entry-body__el"}):
     + M5 k* Q! E1 B  X7 I' @
163.             self.result += "\n\\begin{Partofspeech}\n" + self.process_part_of_speech(part_of_speech_tag) + "\n\\end{Partofspeech}"
     
164.         idiom_block = bs_obj.find("div", {"class": "idiom-block"})
     # j- s# T0 f( {9 k+ C1 H$ c% H7 \
165.         if idiom_block:
     
166.             for idiom_block in idiom_block.find_all("div", {"class": "idiom-block"}):
     8 g0 a& ]7 u" c/ d/ {
167.                 self.result += "\n\\begin{idiom}" + self.process_idiom_block(idiom_block) + "\n\\end{idiom}"
     ; t. e: J7 ?: D- B# }
168.         self.result += "\n\\end{entry}\n\n"
     
169. 
     
170.    
     
171.     def process_idiom_block(self, idiom_block):
     
172.         result = ""
     
173.         idiom_body = idiom_block.find("span", {"class": "idiom-body"})
     7 ]$ [2 K( {. J3 J) h' h' s1 [
174.         if idiom_body:
     
175.             for sense_tag in idiom_body.find_all("div", {"class": "dsense"}):
     
176.                 result += self.process_sense_tag(sense_tag)
     
177.         return result
     - h$ N& }; @! P
178. 
     5 |' P3 B2 l1 f8 W0 i
179.    
     * a3 P- c* \% h9 t* Y! s) m8 v$ o
180. 
     
181.     def get_smart_vocabulary(self, smart_vocabulary_tag):
     
182.         result = ""
     
183.         for li_tag in smart_vocabulary_tag.find_all("li"):
     
184.             result += "\\smart{" + latexify_html(li_tag) + "}\n"
     3 S& Z+ P% B7 P; ^. ]! P& X+ g
185.         return "\n\\begin{smartvocabulary}\n" + result + "\\end{smartvocabulary}\n"
     : I( x) W5 i* I5 z1 b  J) ^, f
186. 
     ( c2 a  ^4 F0 h9 N- w
187. 
     / v9 r  m) |$ `7 `2 {* r
188.     def process_part_of_speech(self, part_of_speech_tag):
     
189.         """
     9 Z+ L9 t; X, ~
190.         <div class="entry-body__el">
     ) s7 b- h" q4 ~# y! ]' L
191.             <div class="pos-header"></div>
     ( ]6 `# a) M  I7 j
192.             <div class="pos-body"></div>
     
193.             <div class="pr relativDiv"></div>
     # L  L# p: ?0 G" n
194.         <div>
     
195.         """
     
196.         result = ""
     
197.         header_tag = part_of_speech_tag.find("div", {"class": "pos-header"})
     ! E, |# A) s7 k2 W- A$ d/ F' J
198.         if header_tag:
     
199.             result += self.process_part_of_speech_header(header_tag)
     9 @# m1 R% Q8 |. u$ v. m  o4 o( h
200.         body_tag = part_of_speech_tag.find("div", {"class": "pos-body"})
     
201.         if body_tag:
     / @& d% U2 E5 |* Z
202.             result += self.process_part_of_speech_body(body_tag)
     + R# W2 c7 \, D3 K( t
203.         pv_block_tag = part_of_speech_tag.find("div", {"class": "pv-block"})
     
204.         if pv_block_tag:
     ( z. I9 r/ w5 U# x7 D8 ?6 a/ w& `
205.             result += self.process_pv_block(pv_block_tag)
     * M+ ~6 q, a6 y1 ~2 v
206.         return result.strip()
     - ^2 G3 ~; M2 H6 i: ]2 ^$ |; v
207. 
     
208.    
     
209.     def process_pv_block(self, tag):
     
210.         """
     1 l8 C. ~! q; c* J* @3 w
211.         <div class="pv-block">
     
212.             <div class="di-title"></div>
     9 f6 y8 p, w4 _  G5 R
213.             <span clss="di-info"></span>
     
214.             <span class="pv-body dpv-body">
     
215.                 <div class="pr dsense dsense-noh">
     ' Q. g& ]1 j5 b& I& c* K
216.             <span>
     
217.         <div>
     
218.         """
     
219.         result = ""
     ; `$ N4 a2 d' `) I6 f
220.         for item in tag.find_all("div",{"class", "sense-body"}):
     9 i- b* l  E" j! I* y9 O' o* y
221.             result += self.process_sense_body(item)
     
222.         return result
     
223. 
     1 E8 D( [/ L3 w  u$ x$ K
224. 
     ( r  Z& s% G1 ~% K* y& R
225.    
     
226.     def process_part_of_speech_header(self, header_tag):
     
227.         result = ""
     
228.         # title_tag = header_tag.find("div", {"class": "di-title"})
     3 Z$ w3 c- v$ U
229.         # if title_tag:
     9 }2 A% h* J7 |
230.         #     result += process_header_title(title_tag)
     
231.         posgram_tag = header_tag.find("div", {"class": "posgram"})
     
232.         if posgram_tag:
     : C1 i8 a. o& J) o( \2 Q2 k
233.             result += self.process_part_of_speech_grammar(posgram_tag)
     
234.         for pronunciation_tag in header_tag.find_all("span", {"class": "dpron-i"}):
     7 v% }) u$ Q+ J" |
235.             result += self.process_pronunciation(pronunciation_tag)
     
236. 
     3 q2 V" S- ^* ~  P7 s& S
237.         return result.strip()
     2 j5 p+ d* H) D  g
238. 
     
239. 
     ' [( H0 m' O$ Y" f/ [
240.     def process_header_title(self, title_tag):
     
241.         ## <span class="hw dhw">record</span>
     0 q$ x  s5 O) Z* z% ~; o
242.         result = ""
     
243.         headword_tag = title_tag.find("span", {"class": "hw"})
     
244.         if headword_tag:
     
245.             result += "\\entry{" + latexify_html(headword_tag) + "}\n"
       N( R3 a' Z" U4 ?
246.         else:
     ; S- b; x  j5 a* Y# S8 ^5 p7 ^
247.             result += "\\entry{" + latexify_html(title_tag) + "}\n"
     
248.         return result
     * M) ^5 o  s4 l7 _, I- O
249. 
     5 u* F- ^# E3 I0 j. v
250.     def process_part_of_speech_grammar(self, posgram_tag):
     , B% n* u' a1 y
251.         result = ""
     
252.         part_of_speech_tag = posgram_tag.find("span", {"class": "pos"})
     1 E+ ?# m! Z) C1 m
253.         if part_of_speech_tag:
     
254.             result += "\n\\pos{" + latexify_html(part_of_speech_tag) + "}"
     / v# {9 v: s; ?7 C" ^% m$ F+ h5 C* ~
255.         gram_tag = posgram_tag.find("span", {"class": "gc"})
     
256.         if gram_tag:
     
257.             result += "\n\\posgram{" + latexify_html(gram_tag)  + "}"
     ' D1 W# w4 Y3 x, k7 N
258.         return result
     
259. 
     
260.     def process_pronunciation(self, pronunciation_tag):
     
261.         is_us_pronunciation = False
     
262.         if "us" in pronunciation_tag.attrs["class"]:
     . K8 T5 Z6 N4 T+ e0 ]
263.             is_us_pronunciation = True
     
264.         result = ""
     # Q: v7 ]+ F9 H) \; x
265.         audio_tag = pronunciation_tag.find("source", {"type": "audio/mpeg"})
     ! p, Z0 c1 r, R, B! W$ ?
266.         
     3 N8 S/ J3 N! g: J
267.         ipa_tag = pronunciation_tag.find("span", {"class": "ipa"})
     9 W) Z& O. E  t4 k
268.         if ipa_tag:
     
269.             if is_us_pronunciation:
     9 l3 _3 I% {$ T  t  q, `+ @/ g% z! J- M
270.                 result += "\n\\ipaus{" + latexify_html(ipa_tag) + "}"
     5 O4 U0 u! \, x' T; D1 H
271.             else:
     
272.                 result += "\n\\ipauk{" + latexify_html(ipa_tag) + "}"
     
273.         if audio_tag:
     
274.             audio_url = urljoin("https://dictionary.cambridge.org/", audio_tag.attrs["src"])
     
275.             result += "\n\pronuniation{" + audio_url + "}"
     
276.         return result
     
277. 
     
278. 
     
279. 
     
280.     def process_sense_head(self, tag):
     ; V$ @  m, m+ r0 |) w) b0 L+ j
281.         text = latexify_html(tag)
       `+ O! g6 h1 j0 R
282.         if "(" in text:
     
283.             left_bracket_index = text.index("(")
     
284.         else:
     
285.             left_bracket_index = 0
     $ `  ^. D; X) B
286.         if ")" in text:
     - b6 Q1 C! E: ?2 }& _3 m
287.             right_bracket_index = text.index(")")
     
288.         else:
     + q3 |1 R. N; \' X! [! `
289.             right_bracket_index = len(text)
     
290.         return "\n\\shortmeaning{" + text[left_bracket_index + 1:  right_bracket_index].strip() + "}"
       L2 Z3 |3 \- B1 ~
291. 
     : A4 Z1 \6 Y4 N
292. 
     3 o# y9 a( a5 p9 W$ Z" _% }1 M
293.     def get_definition(self, tag):
     
294.         result = ""
     
295.         for def_info_tag in tag.select("span.def-into"):
     
296.             result += latexify_html(def_info_tag)
     
297.         for def_tag in tag.select("div.def"):
     
298.             result += latexify_html(def_tag)
     
299.         return result
     
300. 
     4 c3 \0 u: Q+ X3 d; L
301. 
     
302.     def process_def_block(self, tag):
     
303.         result = ""
     , v- X( H4 R$ z/ R6 H' |3 @
304.         def_tag = tag.find("div", {"class": "ddef_h"})
     
305.         if def_tag:
     
306.             result += "\n\\meaningen{" + self.get_definition(def_tag) + "}"
     % W4 V4 U& i* T8 V4 L' p
307.         try:
     
308.             def_trans_tag = tag.select("span.trans")[0]
     
309.             if def_trans_tag:
     6 L6 d* R8 l; f$ M4 r$ _+ V! G3 ?0 g
310.                 result += "\n\\meaningcn{" + latexify_html(def_trans_tag) + "}"
     - M$ a4 \3 _/ L$ Y+ e4 F# l
311.         except:
     3 k$ o% v/ W! Z3 T
312.             pass
     ( [. C2 \3 r  h5 J6 u* s& E; R" Z8 ^
313.         for example_tag in tag.select("span.eg"):
     / \1 X# R2 [% z/ g4 ?$ o
314.             result += "\n\\example{" + latexify_html(example_tag) + "}"
     
315.         return result
     ; c' L3 T6 C6 M6 H- O) Z) a- U
316. 
     4 R" |' @% L9 i# K4 V% j
317. 
     
318.     def process_phrase_block(self, phrase_block_tag):
     6 O1 c% j5 h& I2 ?: R/ Y# m# e3 _
319.         """
     / a2 u" S3 m3 Z* B. ^0 b: s% J
320.         <div class="phrase-head dphrase_h">...</div>
     + B% P; F7 H5 z! V3 N* c
321.         <div class="phrase-body dphrase_b">...</div>
     ! q% D' ]; M3 m6 G( \
322.         <div class="bb hax">...</div>
     & y* O3 f% l- B) Q2 R/ x
323.         """
     
324.         result = "\\begin{phrase}{"
     
325.         result += phrase_block_tag.select("span.phrase-title")[0].get_text().strip() + "}"
     
326.         return result + "\\end{pharse}\n"
     
327. 
     
328.     def process_sense_body(self, tag):
     
329.         """
     
330.         <div class="pr phrase-block dphrase-block">...</div>
     & U" L2 m/ S5 H* a4 |
331.         <div class="def-block ddef_block">...</div>
     
332.         <div class="bb hax">...</div>
     # [, z# J* _" M: L  T
333.         """
     8 L: [3 H! J6 i/ G& `9 a2 j
334.         result = ""
     0 {6 h+ @6 Q/ R0 [9 m9 a: P
335.         for def_block in tag.select("div.def-block"):
     , C# M6 G5 k5 A
336.             result += self.process_def_block(def_block)
     
337.         for phrase_block in tag.select("div.pharse-block"):
     
338.             result += self.process_phrase_block(phrase_block)
       m, f/ o* Y0 p/ w: v: Q
339.         return result
     0 k, W0 E- ^" K6 |' Q6 w& L: X$ [
340.         
     
341.     def process_sense_tag(self, sense_tag):
     
342.         """
     3 m9 n0 H2 _7 y, U, R! u3 c
343.         <h3 class="dsense_h">...</h3>
     " \, a7 p* l6 e5 Y
344.         <div class="sense-body dsense_b">...</div>
     , @/ i/ q7 A! ], g8 i8 C
345.         <div class="smartt daccord">...</div>           # Smart Vocabulary
     2 X; D& X6 I; n5 \! B
346.         <div class="bb hax">...</div>
     
347.         """
     ( @& Y& `- t7 P+ y' _+ W6 G
348.         result = ""
     
349.         sense_head_tag = sense_tag.find("h3", {"class": "dsense_h"})
     $ a5 v8 x) P; g9 p4 ?
350.         if sense_head_tag:
     $ d) q- i+ K! }: O4 k
351.             result += self.process_sense_head(sense_head_tag)
     . \6 X+ ~' H2 {4 f7 n: d
352.         for sense_body_tag in sense_tag.select("div.sense-body"):
     % ^6 I) |# L# Z! a9 r+ g5 y
353.             result += self.process_sense_body(sense_body_tag)
     
354.         for smart_vocabulary_tag in sense_tag.find_all("div", {"class": "smartt"}):
     
355.             result += self.get_smart_vocabulary(smart_vocabulary_tag)
     * L  u3 K( r: I0 ?4 T0 @
356.             
     
357.         return result
     " |; t0 r! U, Q# s, U( a
358. 
     
359.     def process_part_of_speech_body(self, body_tag):
     / R" Q" @; u- n8 l* D
360.         """
     * G1 H$ A' b( E. i6 ]/ I0 `$ j
361.         <div class="pr dsense">...</div>
     
362.         <div class="pr dsense">...</div>
     ( `! D: P6 z, Z7 P$ U5 R/ ?
363.         """
     
364.         result = ""
     
365.         for sense_tag in body_tag.select("div.dsense"):
     9 w% }! a3 x: y6 K' {* G1 J; [
366.             result += self.process_sense_tag(sense_tag)
     1 H( _; o# r& o+ P
367.         return result
     - ]; N1 `) s4 |5 x" {
368.    
     
369. 
     ! E, P/ b5 l% W) e5 b; c; f- y) C
370. if __name__ == "__main__":
     
371.     string = ""
     
372.     CambridgeDictionaryScraper().start(cambridge_english_chinese_url)
     2 \6 ?6 m7 \8 S. q$ @, [" `1 n
373.     for row in conn.execute("SELECT entry, url, html FROM cambridge;"):
     ; H- s9 U7 s) j9 h
374.         entry = row[0]
     
375.         print(entry)
     
376.         url = row[1]
     
377.         html = row[2]
     
378.         record = CambridgeDictionaryExtractor(entry, entry_html=html)
     
379.         record.extract()
     0 @; W: z! P( G) I
380.         string += record.result + "\n"
     
381.         #print(record.result)
     
382. 
     
383.     with open("./final.tex", "w", encoding="utf-8") as f:
     
384.         try:
     
385.             for char in ascii_lowercase:
     6 A. r0 `( a6 m5 k8 C! `
386.                 string = string.replace("\\begin{entry}{" + char, "\\section{" + char + "}\n\n\\begin{entry}{" + char, 1)
     * C/ v! L( }: w" g4 f. T% d9 u0 a
387.         except:
     
388.             pass
     ; z* K% @1 Z0 y
389.         
     ' n$ L+ N9 M$ e
390.         f.write(string.replace("", ""))
     
391. 
     9 W+ i' V7 {- P% I5 J
392. 
     1 ~- \/ Y, g9 F
393.         

复制代码