Az egyik kedvencem a Djangoban az Admin felület, nézzük meg, hogy működik!

Először is, ha még nem tettétek, hozzatok létre egy usert a terminál ablakban (jegyezzétek meg a jelszót!):

python.exe manage.py createsuperuser

Mostantól beléphettek az admin felületre: http://127.0.0.1:8000/admin

Írjátok át a books/admin.py-t:

from django.contrib import admin
from models import *

admin.site.register(BOOK)

A második sorban beimportáltunk mindent a books/models.py-ből (ez egyelőre csak a BOOK osztályt jelenti), majd hozzáadtuk az admin felülethez a BOOK-ot. És kész is van, felvehettek új könyveket! 

Forrás: https://docs.djangoproject.com/en/1.7/intro/tutorial02/

Az előző bejegyzésben (A Django konzol) a BOOK objektumok listázásakor az eredmény nem a legjobban nézett ki:

>>> BOOK.objects.all()
[<BOOK: BOOK object>]

Egészítsétek ki a models.py-t a def __unicode__(self) függvénnyel:

# coding=utf-8
from django.db import models #betölti a models csomagot a django.db-ből

class BOOK(models.Model):
    Title          = models.CharField(max_length = 256, verbose_name="Cím")
    PublishingDate = models.IntegerField(verbose_name="Kiadás dátuma")
    
    def __unicode__(self):
    	return self.Title

Indítsátok újra a konzolt és próbáljátok ki ismét a lekérdezést: 

>>> from books.models import *
>>> BOOK.objects.all()
[<BOOK: Egri csillagok>]

Magyarázat: def __unicode__(self): ez egy függvény, mely karakterlánccá alakítja a könyv objektumot. Minden függvény a def kulcsszóval kezdődik, majd a neve következik, utána pedig zárójelben a paraméterei. Mivel ez a függvény az osztályunkhoz tartozik, ezért az első és ebben az esetben egyetlen paramétere a self. Amikor a Django karakterlánccá szeretné alakítani az osztályunkból létrehozott objektumokat, akkor ezt a függvényt fogja meghívni. Bővebben: https://docs.djangoproject.com/en/dev/ref/models/instances/

Utána még egyel beljebb tabulálva jelezzük a pythonnak, hogy a return self.Title a függvényhez tartozik.

A return kulcsszóval adjuk vissza a függvény által kiszámított eredményt, ebben az esetben a könyv címét. 

A Python fejlesztések nagyon hasznos eszköze a konzol, hiszen sok mindent azonnal ki lehet próbálni benne. Terminál (cmd) ablakban indítsátok el a python-t. A >>> jelek után tetszőleges parancsot beírhattok és kipróbálhattok:

>>>range(5)
 [0, 1, 2, 3, 4]
 >>> import sys
 >>> sys.platform
 'win32'

A konzolt elindíthatjátok a PyCharmon belül is, a Tools/Run Python Console... menüpontban, ez kicsit könnyebben kezelhető (pl. lehet benne kattintani), mint a hagyományos konzol.

Django fejlesztés közben nagyon praktikus, ha bizonyos műveleteket, adatbázis lekérdezéseket ki tudunk próbálni a konzolban. A 

python manage.py shell

paranccsal indíthatjátok el terminál ablakban a Django konzolt. Utána importáljátok be a modelleket:

>>> from books.models import *
>>> b = BOOK()
>>> b.Title = "Egri csillagok"
>>> b.PublishingDate = 1901
>>> b.save()
>>> BOOK.objects.all()
[<BOOK: BOOK object>]

Az importálás után létrehoztam egy BOOK példányt, beállítottam a címét, majd a kiadás dátumát, majd elmentettem. Ekkor bekerült a MySQL adatbázisba is. Majd lekérdeztem az összes BOOK objektumot és az eredményt visszakaptam egy listában.

A Django konzolt is elindíthatjátok a PyCharmból. 

Arra figyeljetek, hogy miután beimportáltatok egy fájlt a konzolba, utána nem fogja észrevenni, ha átírtátok a  fájlt, tehát ebben az esetben újra kell indítanotok a konzolt! 

Most, hogy létrehoztunk egy appot, készítsük el az adatbázisát is!

Az adatokat a MySQL adatbázisunk fogja tartalmazni, melyet alapesetben az SQL nyelv segítségével használhatunk, ám a Django ezt elrejti előlünk és az SQL helyett egy könnyebben kezelhető, egyszerűbb módszert kínál, az ORM-et (Object Relation Mapper).

Nézzünk a példát, a models.py-t:

# coding=utf-8
from django.db import models #betölti a models csomagot a django.db-ből

class BOOK(models.Model):
    Title          = models.CharField(max_length = 256, verbose_name="Cím")
    PublishingDate = models.IntegerField(verbose_name="Kiadás dátuma")
      

Az első sorban megadjuk, hogy milyen kódolással értelmezze a Python a fájlt, utf-8 esetén írhatunk akár ékezetes karaktereket is.

A from valahonnan import valamit paranccsal tudunk betölteni más python modult, ebben az esetben a models-t a Django-ból. A # karakterrel jelöljük, hogy a sor többi része megjegyzés. 

A class kulcsszóval kezdődik az osztály létrehozása, melynek BOOK lesz a neve (tetszőleges nevet választhattam volna, és csak a kódolási stílusom miatt írtam csupa nagybetűvel). Utána zárójelben adjuk meg, hogy a models.Model osztályból származik, azaz meg fogja kapni ennek az összes tulajdonságát. A models.Model a models csomag Model osztályát jelenti, ezért kellett importálnunk a második sorban.

A kettőspont utáni új sort egy TAB-bal, vagy néhány (négy) space-szel beljebb kezdjük, így jelezzük, hogy amit oda írunk, az ehhez az osztályhoz fog tartozni. A python egyik különlegessége, hogy tabulálással jelzi a blokkokat, míg más nyelvek erre zárójeleket használnak: pl. a C++, C, Java a kapcsos zárójelet {}. A Python megoldásának az az előnye, hogy ettől kénytelenek vagyunk szebben formázott kódot írni. 

Utána felvesszük az osztály változóit, egyelőre csak a Title-t és a PublishingDate-et: a models.CharField jelzi, hogy ez egy karakterlánc lesz, legfeljebb 256 karakterből állhat, és amikor megjelenítjük akkor "Cím"-nek nevezzük. Ez alapján a Django létre tudja majd hozni az adatbázisban a megfelelő táblát. Bővebben: Adatbázis migrálása

Mi a különbség az osztály és az objektum között, illetve mik is ezek?

Az osztály írja le az adott objektum felépítését, működését. Az objektum vagy másképp példány az, amit az osztály alapján létrehozunk. Hasonlatként az osztály egy nagyon részletes tervrajz egy adott típusú autóról, az objektum pedig a tényleges autó, ami elvisz minket Á-ból Bé-be. A tervből következik, hogy az autónak van színe, sebessége, lehet benzin a tankjában, de ez legyártás (példányosítás) után mindegyik autónál különböző lesz. Bővebben az Objektum Orientált Programozásról: wiki.

Ha módosítottátok az adatbázist (azaz átírtátok a models.py-t), akkor a következő két sort kell lefuttatni a terminálban (command line):

python manage.py makemigrations books
python manage.py migrate books

Ezek létrehozzák az új táblázatokat, illetve, ha a meglévők változtak, akkor átalakítják a régieket.

Az első sor létrehozza a migrálást végző fájlt a books/migrations könyvtárban, a második pedig végrehajtja.

Forrás:

https://docs.djangoproject.com/en/1.7/topics/migrations/

Az előző pontban beállítottuk a settings.py-ben az adatbázis hozzáférést, ám a root felhasználót és jelszót adtuk meg, ami nem praktikus biztonsági okokból...

Tehát most létrehozunk egy új, limitált jogosultságú felhasználót:

indítsátok el a QueryBrowsert, lépjetek be a root felhasználóval, majd adjátok ki az alábbi parancsot:

CREATE USER 'djangosuli_user'@'localhost'; 

a 'localhost' adja meg, hogy milyen címekről kapcsolódhat a felhasználó. A következő paranccsal állítsátok be a jelszavát:

SET PASSWORD FOR 'djangosuli_user'@'localhost' = PASSWORD('djangosuli_passwd');

a fantáziadús és szuperbiztonságos djangosuli_passwd-re,

illetve adjatok neki jogokat a djangosuli adatbázisra:

GRANT ALL ON djangosuli.* TO 'djangosuli_user'@'localhost';

Források:

http://dev.mysql.com/doc/refman/5.0/en/create-user.html

http://dev.mysql.com/doc/refman/5.0/en/assigning-passwords.html

http://dev.mysql.com/doc/refman/5.0/en/grant.html

A fejlesztés megkezdéséhez hozzátok létre a projectet, abban pedig egy app-ot. A projectben kell megadni a beállításokat, többek között azt, miként kapcsolódjon az adatbázishoz, milyen időzónát használjon, honnan vegye a stílusfájlokat stb. Egy project több app-ot is tartalmazhat.  Projectnévnek a djangosuli-t választom.

Itt a blogban kezdetnek egy könyv nyilvántartó programot készítünk el, hiszen biztos mindenki szembesült már azzal a problémával, hogy túl sok könyve van otthon, meg a szüleinél stb. és ezeket jó lenne valahogy megjeleníteni egy weboldalon, hogy a barátaink azt böngésszék és ne a könyvespolcot túrják fel...

Terminál (cmd) ablakba írjátok be: 

python django-admin.py startproject djangosuli

Ezt a parancsot a c:\Python27\Lib\site-packages\django-1.7.1-py2.7.egg\django\bin könyvtárból adjátok ki, mert ott található a django-admin.py fájl. (Ez az elérési út függ a Django verziószámától, meg persze csak Windowson működik...) Project névnek kisbetűs, ékezet nélküli nevet válasszatok.

A parancs létrehozza a djangosuli könyvtárat, amiben rögtön lesz néhány fájl és egy könyvtár: 

projectnév/
   manage.py 
   djangosuli/ 
      __init__.py 
      settings.py 
      urls.py 
      wsgi.py

A manage.py segítségével tudjátok majd a projectre vonatkozó django parancsokat kiadni, melyek pl. létrehozzák az adatbázist, vagy elindítják a webszervert.
Az __init__.py jelzi a Pythonnak, hogy ez egy modul.
A settings.py-ben vannak a project szintű beállítások, többek között az adatbázis adatait is itt kell megadni.
Az urls.py-ben tudjátok megadni az oldalakhoz tartozó url-eket.
A wsgi.py pedig az oldal éles futtatásához kell, wsgi kompatibilis webszerverekhez, mint pl. az Apache.

A manage.py-be írjátok bele ezt a két sort:

import pymysql
pymysql.install_as_MySQLdb()

Ezzel állítjátok be, hogy a pymysql modullal kapcsolódjon az adatbázishoz. Léteznek más modulok is erre a feladatra, ennek az az előnye, hogy teljes egészében Pythonban írták, így teljesen platformfüggetlen.

A Terminál ablakban lépjetek be az újonnan létrehozott projectetek könyvtárába, majd futtassátok le a 

python manage.py startapp books

parancsot, mely létrehozza az alkalmazásotokat (jelen esetben a books appot) a hozzávaló fájlokkal együtt:

books/
    __init__.py
    admin.py
    migrations/
       __init__.py
    models.py
    tests.py
    views.py

Az admin.py-be kerülnek majd az admin felületet megjelenítő kódok, erről majd később...
A migrations könyvtárba kerülnek majd azok a fájlok, melyeket akkor hoz létre a Django, ha módosítjátok az adatbázis szerkezetét.
A models.py-ben lényegében az adatbázis szerkezetét írjuk le.
A tests.py-be a teszteket írhatjuk.
A views.py-be kerülnek majd azok a függvények, melyek egy-egy url megjelenítésért felelnek.

Indítsátok el a Query Browser-t, és a megjelenő kis ablakba írjátok be a MySQL szerveretek adatait (Server Host: localhost, a Username és Password az, amit telepítéskor megadtatok, a Default schema-t meg hagyjátok üresen).

Jobb oldalt a Shemadata felületen látjátok az adatbázisokat, legfelül a parancsbeviteli terület van, középen pedig a lekérdezések eredménye jelenik meg. A parancsbeviteli területen írjátok be a

create database djangosuli;

parancsot, majd Execute (CTRL+ENTER). Most létrehoztátok a "djangosuli" adatbázist, frissítsétek a Schemadata területet (jobb klikk, Refresh) és meg is jelenik rögtön.  A Django ebben az adatbázisban fogja létrehozni a táblákat.

A settings.py-ben a DATABASES-t írjátok át ilyenre:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', 
        'NAME': 'djangosuli',
        'USER': 'DB_USER',
        'PASSWORD': 'DB_PASSWORD',
        'HOST': 'localhost',   
        'PORT': '3306',
    }
}

ahol a DB_USER és a DB_PASSWORD az a felhasználónév és jelszó, amit a MySQL telepítésekor megadtatok, a NAME pedig az újonnan létrehozott adatbázisotok neve.

Az INSTALLED_APPS-ba pedig írjátok bele az appotok nevét. Később, ha szeretnétek modulokat telepíteni a projectetekbe, pl. AJAX használatához, akkor azt is ebbe a tuple-ba kell beírni. 

Adjátok ki a

python manage.py migrate 

parancsot, mely létrehozza a Djangohoz tartozó adatbázis táblákat, majd ha ez sikeres volt, akkor a 

python manage.py runserver

parancsot is. Ez utóbbi elindítja a beépített webszervert, melyet fejlesztésre lehet használni. Ha minden jól ment, akkor a http://127.0.0.1:8000 címen megnézhetitek az eredményt. 

További infókért olvassátok el ezt a tutorial-t (mely a bejegyzés forrása is).

Első lépésként telepítsétek fel a szükséges eszközöket a gépetekre.

Kezdjük a Pythonnal: kétféle verzió létezik belőle, a kettes és a hármas. Mivel elterjedtebb, én a kettest (a bejegyzés írásakor a 2.7.8-ast) javaslom használni. Innen tölthetitek le: https://www.python.org/downloads/ Ebből is kétféle verzió van, a 32 bites (x86) és a 64 bites (x86-64). Windows alatt praktikusabb a 32 bites verzió használata...

Miután ezzel kész vagytok, egy újonnan nyitott command line ablakban ellenőrizzétek le, hogy sikerült-e a telepítés:

Windowson: windows gomb, írjátok be, hogy cmd.exe, majd ENTER. (Más rendszerekben terminálnak hívják.) Ha túl kicsik a betűk a fekete ablakban, akkor állítsátok át nagyobbra, majd írjátok be, hogy python (majd ENTER). Ha megjelenik a Python prompt (>>>) , akkor minden rendben van, ha nem, akkor a Path környezeti változóba (Control Panel/System/Advanced System Settings/Environment Variables) írjátok be ezt: c:\Python27\;c:\Python27\Scripts\; 

easy_install telepítése: ez egy ügyes kis segédprogram Python modulok (mint pl. a Django) telepítéséhez. Töltsétek le ezt a fájlt: https://bootstrap.pypa.io/ez_setup.py majd cmd ablakban írjátok be ezt: python ez_setup.py (persze legyetek abban a könyvtárban, mint az ez_setup.py). A Path környezeti váltóba, ha még nem tettétek, írjátok bele ezt: c:\Python27\Scripts\;  

Más platformokra a telepítése szintén nagyon egyszerű: https://pypi.python.org/pypi/setuptools#unix-wget

Most már kiadhatjátok az

easy_install django parancsot, mely feltelepíti a Djangot. A Python modulok a Python27\Lib\site-packages\ könyvtárba kerülnek.

easy_install pymysql feltelepíti a MySQL modult, ennek a segítségével tud majd kapcsolódni a progitok az adatbázishoz. Egyébként itt egy lista a feltelepíthető modulokról: https://pypi.python.org/pypi?%3Aaction=index

Telepítsétek fel a MySQL-t is: http://dev.mysql.com/downloads/mysql/ itt a 64 bites verziót válasszátok. A felhasználónevet és a jelszót jegyezzétek meg! Egy egyszerű kis eszközt szoktam használni a MySQL-hez, a Query Browser-t, ezt is tegyétek fel: http://downloads.mysql.com/archives/query/

Végül, telepítsétek fel a PyCharmot: https://www.jetbrains.com/pycharm/download/ A Professional verziót javaslom, de használható az ingyenes Community Edition is.

Többször felmerült bennem, hogy megtanítom a barátaimat programozni, és ha egyszer már foglalkozom velük, akkor jobb leírni a dolgokat, hiszen különben elfelejtik mire hazaérnek... de ha leírom őket, akkor lehetne szépen is, mondjuk egy blog formájában.

Mindazoknak ajánlom ezt a blogot, akik szeretnének megtanulni Pythonban programozni, miközben webes-adatbázisos alkalmazásokat készítenek.

Különösebb előképzettségre nem lesz szükségetek, megpróbálok majd egyszerűen fogalmazni és érthető nyelvezetet használni. Sok gyakorlásra viszont szükségetek lesz, mert programozni csak úgy lehet megtanulni, ha az ember beleteszi az idejét.