Ik ben op zoek naar een manier om html-bestanden dynamisch te maken in python. Ik ben een galerijscript aan het schrijven, dat zich door mappen herhaalt en metagegevens van bestanden verzamelt. Ik was van plan om deze gegevens vervolgens te gebruiken om automatisch een fotogalerij te maken op basis van html. Iets heel eenvoudigs, gewoon een tabel met foto’s.
Ik denk echt niet dat handmatig naar een bestand schrijven de beste methode is, en de code kan erg lang zijn. Dus is er een betere manier om dit te doen, mogelijk html-specifiek?
Antwoord 1, autoriteit 100%
Dominateis een Python-bibliotheek voor het rechtstreeks in code maken van HTML-documenten en -fragmenten zonder gebruik te maken van sjablonen. Je zou een eenvoudige afbeeldingengalerij kunnen maken met zoiets als dit:
import glob
from dominate import document
from dominate.tags import *
photos = glob.glob('photos/*.jpg')
with document(title='Photos') as doc:
h1('Photos')
for path in photos:
div(img(src=path), _class='photo')
with open('gallery.html', 'w') as f:
f.write(doc.render())
Uitvoer:
<!DOCTYPE html>
<html>
<head>
<title>Photos</title>
</head>
<body>
<h1>Photos</h1>
<div class="photo">
<img src="photos/IMG_5115.jpg">
</div>
<div class="photo">
<img src="photos/IMG_5117.jpg">
</div>
</body>
</html>
Disclaimer: ik ben de auteur van domineren
Antwoord 2, autoriteit 24%
Als ik je goed begrijp, denk ik dat je hier “Sjablonen in Python”.
Antwoord 3, autoriteit 18%
Gebruik een template-engine zoals Genshiof Jinja2.
Antwoord 4, autoriteit 8%
Python is een taal met batterijen. Dus waarom zou u xml.dom.minidomniet gebruiken?
from typing import List
from xml.dom.minidom import getDOMImplementation, Document
def getDOM() -> Document:
impl = getDOMImplementation()
dt = impl.createDocumentType(
"html",
"-//W3C//DTD XHTML 1.0 Strict//EN",
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd",
)
return impl.createDocument("http://www.w3.org/1999/xhtml", "html", dt)
def ul(items: List[str]) -> str:
dom = getDOM()
html = dom.documentElement
ul = dom.createElement("ul")
for item in items:
li = dom.createElement("li")
li.appendChild(dom.createTextNode(item))
ul.appendChild(li)
html.appendChild(ul)
return dom.toxml()
if __name__ == "__main__":
print(ul(["first item", "second item", "third item"]))
uitgangen:
<?xml version="1.0" ?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
<html>
<ul>
<li>first item</li>
<li>second item</li>
<li>third item</li>
</ul>
</html>
De interface ziet er niet pythonisch uit, maar als je een fronted-ontwikkelaar bent geweest en JavaScript DOM-manipulatie hebt gebruikt, past het beter bij je geest en ja, het bevrijdt je van het toevoegen van een onnodige afhankelijkheid.
Antwoord 5, autoriteit 3%
Sjablonen, zoals gesuggereerd in andere antwoorden, is waarschijnlijk het beste antwoord (ik schreef een vroege, eigenzinnige sjabloonmodule genaamd yaptu, maar moderne volwassen, zoals gesuggereerd in andere antwoorden, zullen je waarschijnlijk gelukkiger maken;-).
Hoewel het echter lang geleden is sinds ik het laatst heb gebruikt, herinnerde ik me het benadering, die ongeveer een “omgekeerde sjablonen” is (embedding HTML-generatie in Python, in plaats van Viceversa als normaal sjabloneren). Misschien moet je een kijkje nemen en kijken of je het wilt, -).