Innehållsförteckning
I den första delen av vår handledning lyckades vi få vårt program att ta en textfil och generera block med styckena som den innehöll, vi lyckades också få den att kunna exportera det vi byggde i en extern fil.Andra iterationen
Som vi sa i början måste vi göra det det mest modulära programmet och för att uppnå detta måste vi utföra vårt objektorienterad kod.
För detta måste vi göra nödvändiga abstraktioner så att vi kan bygga klasser som innehåller de metoder som uppnår våra mål.
Krav
Låt oss göra en lista över de komponenter som vi behöver bygga, med detta vet vi vad vi måste ha så att vårt program blir mer komplett:
- A parser, med detta objekt kan vi läsa texten och hantera de andra klasserna.
- Regler, Vi kommer att göra en regel för varje typ av block, detta gör att vi kan upptäcka vilken typ av block vi har och vilket format vi ska tillämpa på det.
- Filter, med dem kommer vi att införliva reguljära uttryck för att kunna hantera några interna element.
- Hanterare, dessa hanterare kommer att användas av parser för att generera den bearbetade utmatningen. Varje hanterare det kommer att kunna hantera en annan typ av etiketter.
Denna klass kommer att tillåta oss att hantera vissa typer av etiketter för utgångarna, låt oss se koden som den kan innehålla:
class Handler: def callback (self, prefix, name, * args): method = getattr (self, prefix + name, None) if callable (method): return method ( * args) def start (self, name): self. callback ('start_', namn) def end (self, name): self.callback ('end_', name) def sub (self, name): def substitution (match): result = self.callback ('sub_', name, match) default = match.group (0) return result or default return substitution Om vi nu gör en liten övning kan vi se våra framsteg hittills:
>>> från hanterare importera HTMLRenderer >>> handler = HTMLRenderer () >>> import re >>> re.sub (r '\ * (. +?) \ *', handler.sub ('betoning'), ' Detta * är * ett test ')' Detta är en bevis' Som vi ser i föregående samtal importerar vi först vår klass HTMLRenderer vad är vårt hanterare, sedan importerar vi re som vi kommer att hantera de reguljära uttrycken, sedan går vi till re.sub uttrycket och metoden som det ska tillämpas på, sedan texten och slutligen ser vi att utmatningen har genererat den nödvändiga HTML -koden.
Regler
När vi väl har hanterarna är det dags att göra reglerna, de hjälper oss att ge en destination till de olika blocken, men det måste vara objektorienterat så att vi inte hamnar med ett stort antal block häckat om att validera alla ärenden.
Vi måste också ha en superklass som hanterar våra regler, låt oss se följande kod som innehåller superklassen.
klassregel: def action (self, block, handler): handler.start (self.type) handler.feed (block) handler.end (self.type) return True
Som vi ser metoden åtgärd () tar emot blocket och typen av hanterare som det måste använda, med detta kommer det att kunna skilja vilket block det måste tillämpa på vad det tar emot med parametrar och därmed slutföra koden som måste skrivas ut.
Med detta avslutar vi handledningen och lämnar upp till alla att fortsätta tills vi har projektet klart enligt de riktlinjer som ges i början i den första delen av denna handledning.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng
