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

stiggg

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

毛小驴

顶起

你去哪里

我也想知道这个。

你去哪里

我也想知道这个。

scirem

1. #!/usr/bin/env python3
   : M1 |' j: B; m, R" Z' p
2. # -*- coding: utf-8 -*-
   
3. 
   . G9 l0 j: F; X# x$ M
4. import os
   , b& Q. H2 ]9 G. E7 x0 a+ U$ e
5. import requests
   
6. import re
   
7. import time
   9 s% y: B! o, M7 Y. Z
8. import sqlite3
   1 n7 D& u# q- y2 {8 M
9. 
   9 k. l/ v7 i; O& l9 B* f: u& g
10. from string import ascii_lowercase
    
11. 
    " p* B* g; X; l9 u" m9 ~1 d
12. from pathlib import Path
    / }2 D- p$ D* w1 l9 i$ a( h; ^  a1 Q
13. from urllib.parse import urljoin
    
14. from html.parser import HTMLParser
    + |1 u6 ?4 [5 r$ A( t3 O
15. from bs4 import BeautifulSoup
    
16. 
    
17. webster_url = "https://www.merriam-webster.com/browse/dictionary/"
    # A2 u! @( N( n! Y4 t
18. oxford_url = "https://www.oxfordlearnersdictionaries.com/browse/english/"
    1 k& E; h& I& B. [; p6 W4 D- Q
19. macmillan_url = "https://www.macmillandictionary.com/browse/british/"
    7 t+ H2 U& Y: l6 d! v8 o7 J! {$ H
20. cambridge_url ="https://dictionary.cambridge.org/browse/english/"
    - Q( L( k2 H. n/ R$ R2 @- B" s
21. 
    
22. cambridge_english_chinese_url = "https://dictionary.cambridge.org/browse/english-chinese-simplified/"
    ) q) h$ R" ?7 s0 v+ a$ ]+ h+ ~
23. 
    
24. base_url = "https://dictionary.cambridge.org/search/direct/"
    % K' ^! g# J6 J& e0 q( ~
25. header = {"User-Agent": "Chrome/87.0.4280.88 Safari/537.36"}
    
26. payload = {'datasetsearch': 'english-chinese-simplified', 'q': ""}
    
27. 
    
28. conn = sqlite3.connect("Cambridge Advanced Learner's English-Chinese Dictionary.db")
    
29. 
    
30. conn.execute("""
    
31. CREATE TABLE IF NOT EXISTS cambridge (
    
32.     entry TEXT PRIMARY KEY
    9 K$ v/ ]( u1 D+ L; C* ^0 X2 v
33.                UNIQUE
    
34.                NOT NULL,
    
35.     url   TEXT NOT NULL,
    ( {# H0 \6 K% s8 U9 L
36.     html  TEXT NOT NULL,
    
37.     latex TEXT
    9 b9 U6 \& _; J$ Q" t* u
38. );
    
39. """)
    + K0 O  V& M% F# n; f8 [
40. 
    9 ^  H1 j, \7 l  T
41. conn.commit()
    ( T9 H8 O/ S' n* g6 q
42. 
    
43. 
    - Z8 d, i( Q1 J) j- E0 F
44. def latexify(string):
    6 h. l6 l6 t6 ?' V
45.     result = ""
      @% E; a7 J) H* D2 O
46.     trimmed_string = re.sub(r"\s{2,}", " ", string)
    3 A) Q  E! z, F. L2 ^. l2 }; T
47.     for char in re.sub(r"\s+([^\w'"({[])", r"\1", trimmed_string):
    
48.         if char == "%":
    
49.             result += r"\%"
    9 k0 S( }  Q  B# ^4 |# c
50.         elif char == "\":
    
51.             result += r"\textbackslash{}"
    ' ~' L) ]" w6 ]2 _% _! Y
52.         elif char == "$":
    
53.             result += r"\$"
    + O' Q0 Y7 Q2 z4 [8 @5 P
54.         elif char == "#":
    
55.             result += r"\#"
    
56.         elif char == "&":
    
57.             result += r"\&"
    % O& G+ N2 g0 F( }
58.         elif char == "{":
    8 n% u- c) L: {9 N- W+ X
59.             result += r"\{"
    
60.         elif char == "}":
    
61.             result += r"\}"
    " ]3 e7 t5 u7 p. Y+ k
62.         elif char == "^":
    
63.             result += r"\^"
    * C+ R: P( z8 _. Z+ v( e. Z
64.         elif char == "_":
    - H& B* B" q# ^! K4 d
65.             result += r"\_"
    
66.         elif char == "~":
    $ M2 M: t$ t4 V& W
67.             result += "r\textasciitilde{}"
    
68.         else:
    ! M- z/ j0 i7 k! B' K3 G
69.             result += char
    
70.     return result
    ; t. l( q* @0 O% w9 }7 S+ M
71. 
    % n' }1 q' |0 B/ z2 h
72. def latexify_html(beautifulsoup_object):
    
73.     try:
    7 o/ K) M% p" g. Z7 I' y2 W
74.         return latexify(re.sub(r"\s{2,}", " ", beautifulsoup_object.get_text().replace("\n", " ")).strip())
    3 }8 Q+ w1 z% m6 q% m0 ~4 |
75.     except:
    
76.         return latexify(beautifulsoup_object)
    
77. 
    / q* G( W! C- T2 Y0 K* U. Z; r
78. 
    
79. class CambridgeDictionaryScraper:
    9 a2 E- {6 E  {% b* L. g% c
80.     """ Scraper for Cambridge Dictionary """
    & {+ Z4 j) G2 @3 ?) r# m! u
81.     url_set = set() ## Shared by all instance
    
82. 
    
83.     def __init__(self):
    
84.         for item in conn.execute("SELECT url FROM cambridge;"):
    5 I: R& ]4 A& L( B/ t( H
85.             self.url_set.add(item[0])
    
86.         print("Already Downloaded " + str(len(self.url_set)) + " Words!")
    
87. 
    
88. 
    % W; F' C$ i3 w# K
89.     def __del__(self):
    3 F' Z- X8 X, d* C+ u
90.         conn.commit()
    
91. 
    
92. 
    
93.     def get_word_page(self, url):
    " B" j& D7 F  j1 u2 d/ M( F
94.         r = requests.get(url, headers=header)        
    : [: \/ i8 K$ B# V. X7 V
95.         bs_obj = BeautifulSoup(r.text, "html.parser")
    
96.         entry_tag = bs_obj.find("div", {"class": "entry"})
    
97.         if not entry_tag:
    
98.             entry_tag = bs_obj.find("div", {"class": "di-body"})
    ( c1 B( J, m. ]) f
99.         if not entry_tag:
    . ^5 W, B4 g* v
100.             ## Beta Words
     9 y9 P! \5 G, Y; B, A, r/ n
101.             entry_tag = bs_obj.find("div", {"id": "entryContent"})
     
102.         if not entry_tag:
     
103.             entry_tag = bs_obj
     
104. 
     
105.         if not entry_tag:
     
106.             entry_tag = bs_obj
     
107.         
     * d( Q; j/ m" u1 I7 z/ w0 d& I% N: c
108.         for tag in entry_tag.find_all("script"):
     
109.             tag.extract()
     ' F/ Y+ C1 @+ h" N
110.             
     
111.         result_string = str(entry_tag)
     : N1 |+ V9 q6 b. Q& g
112.         return result_string
     ) B1 p. d5 Q+ K6 R+ G
113. 
     # K6 K' y( l9 ^# R# ?
114.    
     + v, I/ t& u9 p) o. f
115.     def start(self, url):
     
116.         r = requests.get(url, headers=header)
     
117. 
     ) L) E- t# S, L3 E& y. Q3 _
118.         bs_obj = BeautifulSoup(r.text, "html.parser")
     : r: k/ R6 |. a( K' i
119. 
     
120.         for li_tag in bs_obj.select("li.lpr-10"):
     8 X: a5 c; u8 j
121.             child_url = urljoin(cambridge_url, li_tag.a.attrs["href"])
     7 S' w# U  e: V( k8 Q1 o# t9 K
122.             print(child_url)
     3 c- u  I3 s7 h. v8 |
123.             self.find_child_entry(child_url)
     
124. 
     $ _4 `" F2 F  ^+ F  B4 M( C8 O
125. 
     
126.     def find_child_entry(self, url):
     
127.         r = requests.get(url, headers=header)
     
128.         bs_obj = BeautifulSoup(r.text, "html.parser")
     
129.         for li_tag in bs_obj.select("li.t-i"):
     % n$ o  b' l) X3 v8 H1 Y) a; s- p: ]. r
130.             child_url = urljoin(url, li_tag.a.attrs["href"]).strip()
     
131.             child_text = li_tag.get_text().strip()
     ; o' L, c# c, y
132.             if "..." in child_text:
     ; I8 N$ g5 f/ K, {9 y+ e2 d& U. y
133.                 self.find_child_entry(child_url)
     
134.             else:
     
135.                 if child_url in self.url_set:
     $ }9 L) r4 J  Z) W4 b3 y& |! U
136.                     continue
     0 W' i3 `1 @5 Y  O
137.                 print(child_text + "\t" + child_url)
     
138.                 conn.execute("INSERT INTO cambridge (entry, url, html) VALUES (?, ?, ?);",
     
139.                 (child_text, child_url, self.get_word_page(child_url)))
     4 Z' |& @, a) Z7 E
140.                 conn.commit()
     
141.                 self.url_set.add(child_url)
     
142. 
     
143. 
     4 S" b: S% s; S; n+ o
144. class CambridgeDictionaryExtractor():
     
145.     def __init__(self, entry, entry_html = ""):
     
146.         self.entry = latexify(entry)
     % }7 `. X1 v* e2 u/ C
147.         self.entry_html = entry_html
     
148.         self.result = ""
     
149. 
     
150.     # def __del__(self):
     
151.     #     pass
     4 M+ {" L# S" o, q# H7 ]9 h
152. 
     
153. 
     
154.     def extract(self):
     ) [4 ?5 L- z4 h0 p( h  w- g
155.         """
     
156.         <div class="pr idiom-block">
     " ]. U( O3 E; R- C) S
157.             <div class="idiom-block"></div>
     6 |! Z& q$ f5 A8 a. a" B" H/ Z" {
158.         </div>
     
159.         """
     
160.         bs_obj = BeautifulSoup(self.entry_html, "html.parser")
     ( Q# j" T8 P7 d! C5 ]
161.         self.result += "\\begin{entry}{" + self.entry + "}"
       a8 {  w* ?( i( F. {/ E
162.         for part_of_speech_tag in bs_obj.find_all("div", {"class": "entry-body__el"}):
     
163.             self.result += "\n\\begin{Partofspeech}\n" + self.process_part_of_speech(part_of_speech_tag) + "\n\\end{Partofspeech}"
     " u9 J! J& L" F8 n
164.         idiom_block = bs_obj.find("div", {"class": "idiom-block"})
     # \8 x* M; q; r6 Y: m
165.         if idiom_block:
     
166.             for idiom_block in idiom_block.find_all("div", {"class": "idiom-block"}):
     . _1 v/ y, G6 o# I! B$ o5 [
167.                 self.result += "\n\\begin{idiom}" + self.process_idiom_block(idiom_block) + "\n\\end{idiom}"
     
168.         self.result += "\n\\end{entry}\n\n"
     
169. 
     
170.    
     
171.     def process_idiom_block(self, idiom_block):
     2 w- z) I9 @6 e5 `7 N4 t
172.         result = ""
     
173.         idiom_body = idiom_block.find("span", {"class": "idiom-body"})
     
174.         if idiom_body:
     
175.             for sense_tag in idiom_body.find_all("div", {"class": "dsense"}):
     : V# a2 ~2 o& W2 F
176.                 result += self.process_sense_tag(sense_tag)
     
177.         return result
     
178. 
     ! i$ m/ |* P5 i/ z
179.    
     
180. 
     ; V% S# k$ g8 `4 B
181.     def get_smart_vocabulary(self, smart_vocabulary_tag):
     
182.         result = ""
     3 O, P9 g) U( R& T
183.         for li_tag in smart_vocabulary_tag.find_all("li"):
     ) O7 W" ?. }$ f/ Q5 x
184.             result += "\\smart{" + latexify_html(li_tag) + "}\n"
     
185.         return "\n\\begin{smartvocabulary}\n" + result + "\\end{smartvocabulary}\n"
     - L$ x$ c1 T6 V8 U
186. 
     3 P! K1 b0 u% D; U1 x& k/ v
187. 
     ) g' r" V5 _5 b& P2 z- y% m
188.     def process_part_of_speech(self, part_of_speech_tag):
     
189.         """
     ; `3 p; [. v, Q9 x5 l1 t
190.         <div class="entry-body__el">
     
191.             <div class="pos-header"></div>
     ' R6 i6 r3 w9 c9 u7 S1 t
192.             <div class="pos-body"></div>
     , `. v1 p) L7 f! M7 {% F" ~) d
193.             <div class="pr relativDiv"></div>
     , Z0 o' x" r9 s$ \* G7 s
194.         <div>
     
195.         """
     9 d9 [( _0 W, j9 a. {
196.         result = ""
     
197.         header_tag = part_of_speech_tag.find("div", {"class": "pos-header"})
     
198.         if header_tag:
     
199.             result += self.process_part_of_speech_header(header_tag)
     ! c( Q5 \; m" S- C  B
200.         body_tag = part_of_speech_tag.find("div", {"class": "pos-body"})
     ( M, I1 e9 o' z: ^' m( k' `2 Y
201.         if body_tag:
     
202.             result += self.process_part_of_speech_body(body_tag)
     & e8 n- ?( t' u6 K$ _
203.         pv_block_tag = part_of_speech_tag.find("div", {"class": "pv-block"})
     0 e( W* R0 ?3 `& v  I( x! f
204.         if pv_block_tag:
     
205.             result += self.process_pv_block(pv_block_tag)
     
206.         return result.strip()
     
207. 
     ) @7 c- X0 e: T) R+ }. G$ T' k
208.    
     1 e4 Q* U. K( Z1 D! k
209.     def process_pv_block(self, tag):
     
210.         """
     3 _1 W9 b% _+ H; }
211.         <div class="pv-block">
     
212.             <div class="di-title"></div>
     * w. N% {4 q: h" O, A
213.             <span clss="di-info"></span>
     5 n% E1 k1 \5 N0 `" m; i
214.             <span class="pv-body dpv-body">
     8 s5 M2 K- n: G' Z$ n
215.                 <div class="pr dsense dsense-noh">
     
216.             <span>
     / Y4 r5 U. k3 b8 s$ ]1 F' K1 w
217.         <div>
     ) O% s3 M. O: I
218.         """
     1 t" S8 ^  y. j- D9 {
219.         result = ""
     
220.         for item in tag.find_all("div",{"class", "sense-body"}):
     ) K$ t# f2 h$ B& f
221.             result += self.process_sense_body(item)
     
222.         return result
     7 V: S7 A$ r- W0 R# }
223. 
     9 |# S5 F+ @( Y' |6 i4 X
224. 
     : z6 s/ R6 `' J3 O  c" x0 e$ @
225.    
     # n0 m( C; I8 `  G. c% Y
226.     def process_part_of_speech_header(self, header_tag):
     % G) G( V# Z  l' l8 q9 m) O' d
227.         result = ""
     ; v) [7 S6 J3 g2 e
228.         # title_tag = header_tag.find("div", {"class": "di-title"})
     
229.         # if title_tag:
     
230.         #     result += process_header_title(title_tag)
     
231.         posgram_tag = header_tag.find("div", {"class": "posgram"})
     
232.         if posgram_tag:
     ' r4 E) l2 s, w: e3 a( A" b
233.             result += self.process_part_of_speech_grammar(posgram_tag)
     
234.         for pronunciation_tag in header_tag.find_all("span", {"class": "dpron-i"}):
     $ Z, @9 A/ {2 o# t/ n* n9 F. K# d
235.             result += self.process_pronunciation(pronunciation_tag)
     & A3 v/ {: t. `+ z5 H' x8 |
236. 
     & j- q% g9 U2 ], \6 T+ T
237.         return result.strip()
     
238. 
     
239. 
     
240.     def process_header_title(self, title_tag):
     # N; Z6 N% i; k0 l
241.         ## <span class="hw dhw">record</span>
     ( m8 z: f/ S8 [3 A" d
242.         result = ""
     
243.         headword_tag = title_tag.find("span", {"class": "hw"})
     % ~; r5 k. \5 C6 x5 t
244.         if headword_tag:
     / s% g2 T$ y$ v( k3 U: J  @0 B
245.             result += "\\entry{" + latexify_html(headword_tag) + "}\n"
     
246.         else:
     
247.             result += "\\entry{" + latexify_html(title_tag) + "}\n"
     
248.         return result
     
249. 
     
250.     def process_part_of_speech_grammar(self, posgram_tag):
     
251.         result = ""
     : Z; }- u6 l' c$ Y% f% E
252.         part_of_speech_tag = posgram_tag.find("span", {"class": "pos"})
     . L* S' [7 u2 w
253.         if part_of_speech_tag:
     
254.             result += "\n\\pos{" + latexify_html(part_of_speech_tag) + "}"
     
255.         gram_tag = posgram_tag.find("span", {"class": "gc"})
     % K1 [& I# Y7 _) p5 |
256.         if gram_tag:
     + o; c3 Q) B* T6 f3 l4 F
257.             result += "\n\\posgram{" + latexify_html(gram_tag)  + "}"
     
258.         return result
     
259. 
     % K/ d4 [& y5 Q" E$ ?
260.     def process_pronunciation(self, pronunciation_tag):
     
261.         is_us_pronunciation = False
     4 E& ]) L1 z' W2 z5 r
262.         if "us" in pronunciation_tag.attrs["class"]:
     8 F) }& b0 ]9 g" d% l! I$ c8 T$ O% T
263.             is_us_pronunciation = True
     
264.         result = ""
     
265.         audio_tag = pronunciation_tag.find("source", {"type": "audio/mpeg"})
     
266.         
     
267.         ipa_tag = pronunciation_tag.find("span", {"class": "ipa"})
     
268.         if ipa_tag:
     8 A" D+ A# A- Z7 n  h* m& E+ n# R, u: F
269.             if is_us_pronunciation:
     6 W: M  l# B1 R2 d$ ]5 A) }' \  J
270.                 result += "\n\\ipaus{" + latexify_html(ipa_tag) + "}"
     
271.             else:
     
272.                 result += "\n\\ipauk{" + latexify_html(ipa_tag) + "}"
     4 h7 l* I+ m. ]9 B
273.         if audio_tag:
     9 N# L0 r2 n) b7 c/ O2 R8 f
274.             audio_url = urljoin("https://dictionary.cambridge.org/", audio_tag.attrs["src"])
     
275.             result += "\n\pronuniation{" + audio_url + "}"
     
276.         return result
     2 y% @, I8 I. ?+ ~. P0 F
277. 
     
278. 
     + G; i' Y# @9 |6 ]
279. 
     1 U5 A8 Q6 ^& {. S
280.     def process_sense_head(self, tag):
     
281.         text = latexify_html(tag)
     
282.         if "(" in text:
     
283.             left_bracket_index = text.index("(")
     5 ~+ c, s! m( I; n( U  q
284.         else:
     0 Y3 I8 A$ v/ d0 g7 R  C6 z* E( ~
285.             left_bracket_index = 0
     - c% j9 \5 c; X. u& a0 x4 i. k' }" y# ?3 G
286.         if ")" in text:
     
287.             right_bracket_index = text.index(")")
     
288.         else:
     
289.             right_bracket_index = len(text)
     7 `; ^3 ]3 K5 _
290.         return "\n\\shortmeaning{" + text[left_bracket_index + 1:  right_bracket_index].strip() + "}"
     
291. 
     - i6 q" k+ t& v! ~
292. 
     
293.     def get_definition(self, tag):
     3 r# m' q: e# b5 X
294.         result = ""
     ! {: N! ~, d( Z7 ?$ a; W
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"):
     , r0 I/ U  D. Z8 J* A
298.             result += latexify_html(def_tag)
     ! N. r* k0 J* T: M/ k# I$ i) q
299.         return result
     6 u( U' r4 P# q' P' v( g8 Y. x  w
300. 
       H9 H7 j3 q' n
301. 
     + d; F8 v: B; y' \( g
302.     def process_def_block(self, tag):
     
303.         result = ""
     $ S: O! k5 L# C& ~
304.         def_tag = tag.find("div", {"class": "ddef_h"})
     
305.         if def_tag:
     
306.             result += "\n\\meaningen{" + self.get_definition(def_tag) + "}"
     6 J. O( X. i3 V1 z' b# q' @
307.         try:
     
308.             def_trans_tag = tag.select("span.trans")[0]
     , }8 c! i% b" O6 s
309.             if def_trans_tag:
     3 F" v  e5 [- C; b- ]9 n
310.                 result += "\n\\meaningcn{" + latexify_html(def_trans_tag) + "}"
     
311.         except:
     ' q& ?/ b: P! W# v5 V" j
312.             pass
     3 E. d' j) H- A1 E* L
313.         for example_tag in tag.select("span.eg"):
     3 M/ u" X, V/ E+ N
314.             result += "\n\\example{" + latexify_html(example_tag) + "}"
     
315.         return result
     + D/ g1 y1 f; _  F8 u; `' @; |# ^  V4 [
316. 
     / n$ h; `! l! U! E, `% \. g
317. 
     
318.     def process_phrase_block(self, phrase_block_tag):
     9 J8 p. a/ f& M/ C
319.         """
     $ m8 u; h3 I( K4 K6 N" O3 C& Q
320.         <div class="phrase-head dphrase_h">...</div>
     
321.         <div class="phrase-body dphrase_b">...</div>
     + |, J3 v/ U8 [9 k( c6 r6 d
322.         <div class="bb hax">...</div>
     7 X7 ]( x# ?: d/ v" A+ a' b
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):
     1 J* |; V. r4 S, {% Q$ S
329.         """
     
330.         <div class="pr phrase-block dphrase-block">...</div>
     
331.         <div class="def-block ddef_block">...</div>
     
332.         <div class="bb hax">...</div>
     + g  S+ J$ O9 M4 C3 |8 B* V# Z
333.         """
     
334.         result = ""
     
335.         for def_block in tag.select("div.def-block"):
     
336.             result += self.process_def_block(def_block)
     / V! m* m% T0 O6 K" g) x
337.         for phrase_block in tag.select("div.pharse-block"):
     
338.             result += self.process_phrase_block(phrase_block)
     
339.         return result
     ! i9 _6 d+ g, P) H+ z: `
340.         
     . Q' S# M# l. {# t7 K# S' C
341.     def process_sense_tag(self, sense_tag):
     ' |. x3 l% V6 n. I
342.         """
     
343.         <h3 class="dsense_h">...</h3>
     
344.         <div class="sense-body dsense_b">...</div>
     8 N$ w2 j, N1 x' c. B
345.         <div class="smartt daccord">...</div>           # Smart Vocabulary
     % t6 ]5 o$ ^  t1 X: g* W, {2 m
346.         <div class="bb hax">...</div>
     
347.         """
     - R6 t7 h( h8 C. U+ j) Z" p
348.         result = ""
     
349.         sense_head_tag = sense_tag.find("h3", {"class": "dsense_h"})
     
350.         if sense_head_tag:
     7 A" e9 R/ E' K* `' [
351.             result += self.process_sense_head(sense_head_tag)
     
352.         for sense_body_tag in sense_tag.select("div.sense-body"):
     6 `2 l6 f* d1 W3 S
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)
     
356.             
     . p* M4 y+ _( q2 \
357.         return result
     
358. 
     
359.     def process_part_of_speech_body(self, body_tag):
     
360.         """
     , {# N' O6 d. j9 F
361.         <div class="pr dsense">...</div>
     0 S( P# T8 z* R6 c$ `# W! e
362.         <div class="pr dsense">...</div>
     
363.         """
     
364.         result = ""
     
365.         for sense_tag in body_tag.select("div.dsense"):
     $ Y6 x& v; v( a% t+ y& e: X' f/ q
366.             result += self.process_sense_tag(sense_tag)
     * q, f. d$ ^3 a- r3 k1 i9 H" i
367.         return result
     4 e/ |/ ?* i& w4 l: Y+ {
368.    
     
369. 
     
370. if __name__ == "__main__":
     
371.     string = ""
     - T" x6 `7 g4 ?& n2 i) l
372.     CambridgeDictionaryScraper().start(cambridge_english_chinese_url)
     ! h0 n' _- n- `: A$ M: R
373.     for row in conn.execute("SELECT entry, url, html FROM cambridge;"):
     $ _$ `! B& F8 N* E2 x2 v
374.         entry = row[0]
     
375.         print(entry)
     5 F. s8 a2 X! B& X
376.         url = row[1]
     
377.         html = row[2]
     
378.         record = CambridgeDictionaryExtractor(entry, entry_html=html)
     . p# c& \" }: T) F  v  a
379.         record.extract()
     
380.         string += record.result + "\n"
     3 K6 v- B9 ^: Y
381.         #print(record.result)
     : e" M+ k& O% M2 j
382. 
     ' Z7 _! {" ~# D5 f: J
383.     with open("./final.tex", "w", encoding="utf-8") as f:
     ) s! u# }6 ^* j7 X( A8 a
384.         try:
     , B- {3 ?/ |3 {; S+ T2 r4 s" u
385.             for char in ascii_lowercase:
     
386.                 string = string.replace("\\begin{entry}{" + char, "\\section{" + char + "}\n\n\\begin{entry}{" + char, 1)
     
387.         except:
     / p" R& J# u! d3 }: p: ~, E
388.             pass
     
389.         
     9 G. s: L  M, N+ I9 G. O
390.         f.write(string.replace("", ""))
     
391. 
     , k- g: o( l: _" S8 T, K4 k
392. 
     
393.         

复制代码