Installera och konfigurera Flask

Det finns tillfällen då vi vill utveckla applikationer men vi vill inte börja om från början, för det finns oändligheter av ramar på marknaden, desto mer komplett och kraftfull ramverkJu större ditt fotavtryck och din inlärningskurva kan vara. Detta gör att vi tappar intresset för att utveckla vår applikation eller så kan vi lägga mer tid än nödvändigt.
Med ovanstående i åtanke ett stort antal s.k mikroramverk, som är arbetsekosystem som har de nödvändiga elementen för att undvika att behöva börja om från början när vi utvecklar vår applikation, men deras storlek är minimal, vilket ger oss bara det som är nödvändigt för att börja utan att behöva översvämma våra huvuden med mycket material.
I Pytonorm det finns många sådana mikroramverkmen det finns en som sticker ut tack vare sin stora dokumentation och gemenskap, detta är Flaska, som med några bibliotek och komponenter gör att vi kan starta en utveckling utan att tappa skalbarhet och modularitet ur sikte.
InstallationDen formella installationen av Flaska knappt och tar några minuter, men för maximal nytta måste vi först etablera vår arbetsmiljö, för detta måste vi installera och konfigurera virtualenv, vilket är ett verktyg som gör att vi kan ha olika miljöer under Pytonorm i vårt system så att vi inte behöver installera något globalt.
För installation virtualenv vi måste helt enkelt uppfylla följande krav:
1- Installera Python 2.7 eller högre, beroende på vårt operativsystem kommer processen att vara annorlunda, men för de flesta distributioner Linux detta är redan installerat som standard. I Windows du behöver bara installera med den nedladdning som motsvarar vårt system.
2- När vi har Pytonorm, vi måste installera pip, detta är ett verktyg som gör att vi kan göra installationen på ett enkelt sätt och via kommandokonsolen för de olika paketen till Pytonorm. I Ubuntu till exempel, lägg bara in kommandokonsolen:

 apt-get install python-setuptools

Och så kör vi:

 easy_install pip

I Windows du måste helt enkelt hitta motsvarande nedladdningsbara setuptools.py och senare getpip.py båda filerna måste köras med Pytonorm från kommandokonsolen.
3- Äntligen kan vi installera virtualenv vid placering på konsolen pip installera virtualenv, vilket ger oss möjligheten att skapa våra virtuella miljöer.
För att skapa en virtuell miljö måste vi helt enkelt skapa en mapp som innehåller vårt projekt och sedan placera kommandot i den:

 virtualenv vårt projekt

Var "vårt projekt”Kommer att vara namnet på den virtuella miljön.
En gång virtualenv skapade miljön, måste vi aktivera den, för detta beroende på vilket system vi befinner oss i måste vi göra följande, i Ubuntu till exempel placerar vi oss helt enkelt inuti vår miljö och placerar följande kommando:

 källfack / aktivera

Om vi ​​är i Windows skulle vi göra följande:

 Skript / aktivera

I slutändan skulle vi ha en aktiverad miljö som vi ser i följande bild:

Hur vi kan visualisera i konsolen namnet på vår redan aktiverade miljö visas inom parentes.
Eftersom vi har alla tidigare krav uppfyllda, nu om vi kan göra installationen av mikroramverk FlaskaFör att göra detta i vår virtuella miljökonsol skriver vi helt enkelt följande:

 pip installera kolv

Om allt har gått bra kommer vi att få något som det vi ser i följande bild:

Vi ser hur det i slutändan berättar att det installerades framgångsrikt Flaska förutom dess beroenden, med detta är vi redo att börja utveckla våra applikationer med detta mikroramverk.
Vi ska nu skapa vår första applikation, i det här fallet kommer vi att göra det klassiska "Hej världen!" som vi kan förstå några intressanta saker om att arbeta med Flaska. Vi kommer att behöva en vanlig textredigerare eller kanske några SDI vilket stöd Pytonorm, rekommenderar vi att du använder Sublim text, eller kanske Anteckningsblock ++ båda alternativen låter oss markera språkets nyckelord.
Inom vår miljö kommer vi att skapa en fil som heter app.py och inuti detta ska vi placera följande kod:

 från kolvimport Flaskapp = Kolv (__ namn __) @ app.route ('/') def hello_world (): returnera 'Hello World !!!' if __name__ == '__main__': app.run ()

Vi börjar med att importera ramverket, för detta indikerar vi först det från biblioteket flaska låt oss importera klassen Flaska. Sedan definierar vi att vår app kommer att vara en instans av den klassen. Vi skapar en dekoratör @ app.route (/) vilket indikerar att sökvägen som ska definieras för att använda funktionen nedan är roten.
Nästa akt skapar vi vår funktion Hej världen() och det kommer att returnera ett meddelande i form av en sträng. Slutligen kör vi metoden app.run () som vår ansökan kommer att lyftas med.
För att se detta fungera går vi helt enkelt till konsolen i vår virtuella miljö och skriver:

 python app.py

Detta bör visa ett meddelande som följande på konsolen:

Vi ser att det berättar att programmet körs 127.0.0.1 i hamnen 5000 så vi lägger den informationen i vår webbläsare så ser vi resultatet som i följande bild:

Med detta har vi vår första ansökan gjord med Flaska och det tog inte ett par minuter.
På grund av mikronaturen hos Flaska och också att dess mål är att låta oss arbeta på det sätt som vi känner oss mest bekväma, till att börja med genererar det ingen mappstruktur för vår applikation, så det ger oss friheten att skapa vår struktur på det sätt vi tycker passar.
RestriktionDen enda begränsningen är att vi inte kan använda namnet kolv.py för våra filer, eftersom detta skulle stå i konflikt med huvudfilen i vårt ramverk, är allt annat ganska flexibelt.
Den grundläggande konfigurationen av rekommenderade mappar består av en huvudmapp med projektets namn, inom denna kommer vi att ha huvudfilen som startar programmet, samt ett par ytterligare mappar, den första är den för statiska filer precis som bilder och formatmallar, den andra är mallarna för mappen mallar, där vi kommer att ha de filer som hjälper oss att generera vyerna med HTML för slutanvändaren av applikationen. Låt oss se i följande bild hur denna struktur ser ut:

Standard Flaska användningsområden jinja2 som mallmotor kan den dock ändras av en annan, men innan vi kastar den kan vi se vad den erbjuder oss.
Jinja2Det är en komplett motor som erbjuder möjlighet att tolka några instruktioner för att göra våra mallar till dynamiska element som kompletterar de olika delarna av vår applikation, målet är att behöva skriva minst mängd kod, men täcker det största antalet fall och funktioner .
Syntaxen liknar mycket mallmotorn för Django, så om vi har arbetat med denna ram kommer vi förmodligen att känna oss väldigt bekväma.
Standard Flaska har ingen ORM, så om vi ska arbeta med Databaser, eller så bygger vi vårt eget ORM eller om vi använder en som redan är tillgänglig i gemenskapen, om vi tar det andra alternativet kan vi överväga Flask-SQLAlchemy.
Detta är en förlängning för att kunna använda det populära SQLAlchemy vilket gör att vi kan upprätta förbindelser genom Pytonorm med de olika motorerna Databaser, Vad MySQL eller till och med andra icke-relationsmotorer som MongoDB.
Tanken bakom a ORM är att kunna fråga på ett sätt som inte gör det beror på SQL -syntax, så om vi när som helst vill byta motor Databas, vår ansökan bör inte genomgå några ändringar, till skillnad från om vi skriver direkt SQL -kodi så fall bör vi ändra instruktionerna i enlighet därmed.
Med detta har vi avslutat den här handledningen, vi har bara sett en liten andel av vad vi kan uppnå med FlaskaDet är dock tillräckligt för att inse dess stora potential, särskilt när vi behöver starta ett projekt snabbt och utan mycket bagage. Dess stora popularitet beror på det faktum att den med sin modulära och utbyggbara struktur gör att vi kan använda många komponenter som vi kanske redan känner till från andra utvecklingar och inte begränsar oss att arbeta på ett visst sätt, till skillnad från ramar som t.ex. Django där vi har ett mycket speciellt sätt att göra saker, förutom alla komponenter som måste ärvas inledningsvis för att skapa en applikation.