DjangoDjango के साथ शुरुआत करना


टिप्पणियों

Django खुद को "समय सीमा के साथ पूर्णतावादियों के लिए वेब फ्रेमवर्क" के रूप में विज्ञापित करता है और "Django बेहतर वेब एप्लिकेशन को अधिक तेज़ी से और कम कोड के साथ बनाना आसान बनाता है"। इसे एमवीसी वास्तुकला के रूप में देखा जा सकता है। इसके मूल में यह है:

  • विकास और परीक्षण के लिए एक हल्का और स्टैंडअलोन वेब सर्वर
  • एक फार्म क्रमांकन और सत्यापन प्रणाली जो डेटाबेस में भंडारण के लिए उपयुक्त HTML रूपों और मूल्यों के बीच अनुवाद कर सकती है
  • एक टेम्प्लेट सिस्टम जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग से उधार ली गई विरासत की अवधारणा का उपयोग करता है
  • एक कैशिंग ढांचा जो मिडलवेयर कक्षाओं के लिए कई कैश विधियों के समर्थन का उपयोग कर सकता है जो अनुरोध प्रसंस्करण के विभिन्न चरणों में हस्तक्षेप कर सकते हैं और अन्य कार्यों को पूरा कर सकते हैं
  • एक आंतरिक डिस्पैचर सिस्टम जो एक एप्लिकेशन के घटकों को पूर्व-परिभाषित संकेतों के माध्यम से घटनाओं को एक दूसरे से संवाद करने की अनुमति देता है
  • एक अंतर्राष्ट्रीयकरण प्रणाली, जिसमें विभिन्न भाषाओं में Django के अपने घटकों के अनुवाद शामिल हैं
  • एक क्रमांकन प्रणाली जो Django मॉडल के उदाहरणों का XML और / या JSON प्रतिनिधित्व प्रस्तुत कर सकती है और पढ़ सकती है
  • टेम्पलेट इंजन की क्षमताओं का विस्तार करने के लिए एक प्रणाली
  • पायथन द्वारा निर्मित यूनिट टेस्ट फ्रेमवर्क में एक इंटरफ़ेस

संस्करण

संस्करण रिलीज़ की तारीख
1.11 2017/04/04
1.10 2016/08/01
1.9 2015/12/01
1.8 2015/04/01
1.7 2014-09-02
1.6 2013-11-06
1.5 2013-02-26
1.4 2012-03-23
1.3 2011-03-23
1.2 2010-05-17
1.1 2009-07-29
1.0 2008-09-03

एक पूरी हैलो दुनिया का उदाहरण।

चरण 1 यदि आपके पास पहले से ही Django स्थापित है, तो आप इस चरण को छोड़ सकते हैं।

pip install Django
 

चरण 2 एक नया प्रोजेक्ट बनाएं

django-admin startproject hello
 

यह hello नामक एक फ़ोल्डर बनाएगा जिसमें निम्नलिखित फाइलें होंगी:

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py
 

चरण 3 अंदर hello मॉड्यूल (फ़ोल्डर युक्त __init.py__ ) नामक एक फ़ाइल बनाने views.py :

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── views.py  <- here
│   └── wsgi.py
└── manage.py
 

और निम्नलिखित सामग्री में डाल दिया:

from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello, World')
 

इसे व्यू फंक्शन कहा जाता है।

चरण 4 hello/urls.py को इस प्रकार संपादित करें:

from django.conf.urls import url
from django.contrib import admin
from hello import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', views.hello)
]
 

जो एक URL के लिए फ़ंक्शन फ़ंक्शन hello() को जोड़ता है।

चरण 5 सर्वर शुरू करें।

python manage.py runserver
 

चरण 6

ब्राउज़ करें http://localhost:8000/ एक ब्राउज़र में और आप देखेंगे:

नमस्ते दुनिया

डॉकटर समर्थन के साथ अनुकूल दोस्ताना परियोजना।

डिफ़ॉल्ट Django परियोजना टेम्पलेट ठीक है, लेकिन एक बार जब आप अपने कोड को तैनात करने के लिए मिलते हैं और उदाहरण के लिए devops परियोजना पर अपना हाथ डालते हैं तो चीजें गड़बड़ हो जाती हैं। आप जो कर सकते हैं वह आपके स्रोत कोड को शेष से अलग करता है जो आपके भंडार में होना आवश्यक है।

आप GitHub पर एक प्रयोग करने योग्य Django प्रोजेक्ट टेम्पलेट पा सकते हैं।

प्रोजेक्ट संरचना

PROJECT_ROOT
├── devel.dockerfile
├── docker-compose.yml
├── nginx
│   └── project_name.conf
├── README.md
├── setup.py
└── src
    ├── manage.py
    └── project_name
        ├── __init__.py
        └── service
            ├── __init__.py
            ├── settings
            │   ├── common.py
            │   ├── development.py
            │   ├── __init__.py
            │   └── staging.py
            ├── urls.py
            └── wsgi.py
 

मैं रखने के लिए service नामक निर्देशिका service है कि मैं एक ही उपयोग कर सकते हैं के लिए हर परियोजना के लिए धन्यवाद के लिए Dockerfile मेरे सभी परियोजनाओं के पार। आवश्यकताओं और सेटिंग्स का विभाजन पहले से ही यहाँ अच्छी तरह से प्रलेखित है:
कई आवश्यकताओं फ़ाइलों का उपयोग करना
कई सेटिंग्स का उपयोग करना

Dockerfile

इस धारणा के साथ कि केवल डेवलपर्स डॉकर का उपयोग करते हैं (हर देवता इन दिनों इस पर भरोसा नहीं करते हैं)। यह एक देव वातावरण हो सकता है devel.dockerfile :

FROM python:2.7
ENV PYTHONUNBUFFERED 1

RUN mkdir /run/service
ADD . /run/service
WORKDIR /run/service

RUN pip install -U pip
RUN pip install -I -e .[develop] --process-dependency-links

WORKDIR /run/service/src
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]
 

निर्माण के दौरान केवल आवश्यकताओं को जोड़ना डॉकटर कैश का लाभ उठाएगा - आपको केवल आवश्यकताओं में बदलाव पर पुनर्निर्माण करना होगा।

लिखें

डॉकर कंपोज़ काम में आता है - खासकर जब आपके पास स्थानीय रूप से चलाने के लिए कई सेवाएं हैं। docker-compose.yml :

version: '2'
services:
  web:
    build:
      context: .
      dockerfile: devel.dockerfile
    volumes:
      - "./src/{{ project_name }}:/run/service/src/{{ project_name }}"
      - "./media:/run/service/media"
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: mysql:5.6
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE={{ project_name }}
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - "./nginx:/etc/nginx/conf.d"
      - "./media:/var/media"
    depends_on:
      - web
 

nginx

आपका विकास पर्यावरण संभवत: ठेस वातावरण के करीब होना चाहिए इसलिए मुझे शुरू से ही नग्नेक्स का उपयोग करना पसंद है। यहाँ एक उदाहरण nginx विन्यास फाइल है:

server {
    listen   80;
    client_max_body_size 4G;
    keepalive_timeout 5;

    location /media/ {
        autoindex on;
        alias /var/media/;
    }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Ssl on;
        proxy_connect_timeout 600;
        proxy_read_timeout 600;
        proxy_pass http://web:8000/;
    }
}
 

प्रयोग

$ cd PROJECT_ROOT
$ docker-compose build web  # build the image - first-time and after requirements change
$ docker-compose up  # to run the project
$ docker-compose run --rm --service-ports --no-deps  # to run the project - and be able to use PDB
$ docker-compose run --rm --no-deps <management_command>  # to use other than runserver commands, like makemigrations
$ docker exec -ti web bash  # For accessing django container shell, using it you will be inside /run/service directory, where you can run ./manage shell, or other stuff
$ docker-compose start  # Starting docker containers
$ docker-compose stop  # Stopping docker containers
 

Django अवधारणाओं

django-admin एक कमांड लाइन उपकरण है जो Django के साथ जहाज करता है। यह एक Django परियोजना के प्रबंधन और प्रबंधन के लिए कई उपयोगी आदेशों के साथ आता है। आदेश वैसा ही है ./manage.py , इस अंतर के साथ कि आपको प्रोजेक्ट निर्देशिका में रहने की आवश्यकता नहीं है। DJANGO_SETTINGS_MODULE परिवेश चर सेट करने की आवश्यकता है।

एक Django परियोजना एक पायथन कोडबेस है जिसमें एक Django सेटिंग फ़ाइल है। Django व्यवस्थापक द्वारा django-admin startproject NAME माध्यम से एक प्रोजेक्ट बनाया जा सकता है। इस परियोजना में आमतौर पर शीर्ष स्तर पर manage.py नामक एक फाइल होती है और एक रूट URL फाइल होती है जिसे urls.py कहा जाता है। manage.py एक django-admin का प्रोजेक्ट विशिष्ट संस्करण है, और आपको उस प्रोजेक्ट पर प्रबंधन कमांड चलाने देता है। उदाहरण के लिए, अपने प्रोजेक्ट को स्थानीय रूप से चलाने के लिए, python manage.py runserver उपयोग करें। एक प्रोजेक्ट Django ऐप्स से बना है।

एक Django ऐप एक पायथन पैकेज है, जिसमें एक मॉडल फ़ाइल (डिफ़ॉल्ट रूप से models.py ) और ऐप-विशिष्ट यूआरएल और दृश्य जैसी अन्य फाइलें हैं। कमांड django-admin startapp NAME के माध्यम से एक ऐप बनाया जा सकता है (यह कमांड आपके प्रोजेक्ट डायरेक्टरी के अंदर से चलाया जाना चाहिए)। किसी परियोजना का हिस्सा बनने के लिए, इसे settings.py में INSTALLED_APPS सूची में शामिल किया जाना चाहिए। यदि आपने मानक कॉन्फ़िगरेशन का उपयोग किया है, तो Django के कई ऐप हैं जो स्वयं के ऐप इंस्टॉल किए गए हैं जो आपके लिए प्रमाणीकरण जैसी चीज़ों को संभालेंगे। ऐप्स का उपयोग कई Django परियोजनाओं में किया जा सकता है।

Django ORM उन सभी मॉडल मॉडल को मॉडल models.py में परिभाषित करता है और उन मॉडल वर्गों के आधार पर डेटाबेस टेबल बनाता है। ऐसा करने के लिए, पहले अपने डेटाबेस को settings.py में settings.py में DATABASES सेटिंग को संशोधित करके सेटअप करें। फिर, एक बार जब आप अपने डेटाबेस मॉडल को परिभाषित कर लेते हैं, तो python manage.py makemigrations । आपके मॉडल के आधार पर आपके डेटाबेस के स्कीमा को बनाने या अपडेट करने के लिए python manage.py migrate द्वारा अनुसरण किया जाता है।

एकल फ़ाइल हैलो वर्ल्ड उदाहरण

यह उदाहरण आपको Django में एक हैलो वर्ल्ड पेज बनाने के लिए एक न्यूनतम तरीका दिखाता है। यह आपको यह महसूस करने में मदद करेगा कि django-admin startproject example कमांड मूल रूप से फ़ोल्डर्स और फ़ाइलों का एक गुच्छा बनाता है और आपको अपनी परियोजना को चलाने के लिए उस संरचना की आवश्यकता नहीं है।

  1. एक फ़ाइल बनाएँ, जिसे file.py कहा जाता है।

  2. उस फ़ाइल में निम्न कोड को कॉपी और पेस्ट करें।

     import sys
     
     from django.conf import settings
     
     settings.configure(
         DEBUG=True,
         SECRET_KEY='thisisthesecretkey',
         ROOT_URLCONF=__name__,
         MIDDLEWARE_CLASSES=(
             'django.middleware.common.CommonMiddleware',
             'django.middleware.csrf.CsrfViewMiddleware',
             'django.middleware.clickjacking.XFrameOptionsMiddleware',
         ),
     )
     
     from django.conf.urls import url
     from django.http import HttpResponse
     
     # Your code goes below this line.
    
     def index(request):
         return HttpResponse('Hello, World!')
    
     urlpatterns = [
         url(r'^$', index),
     ]
    
     # Your code goes above this line
     
     if __name__ == "__main__":
         from django.core.management import execute_from_command_line
     
         execute_from_command_line(sys.argv)
     
  3. टर्मिनल पर जाएं और फ़ाइल को इस कमांड python file.py runserver साथ python file.py runserver

  4. अपना ब्राउज़र खोलें और 127.0.0.1:8000 पर जाएं

एक परियोजना शुरू करना

Django पायथन पर आधारित एक वेब डेवलपमेंट फ्रेमवर्क है। Django 1.11 (नवीनतम स्थिर रिलीज) को स्थापित करने के लिए पायथन 2.7 , 3.4 , 3.5 या 3.6 की आवश्यकता होती है। मान लें कि pip उपलब्ध है, स्थापना निम्न कमांड चलाने के समान सरल है। ध्यान रखें, जैसा कि नीचे दिखाया गया है संस्करण को छोड़ देना django के नवीनतम संस्करण को स्थापित करेगा:

$ pip install django
 

Django के विशिष्ट संस्करण को स्थापित करने के लिए, मान लें कि संस्करण django 1.10.5 है , निम्नलिखित कमांड चलाएँ:

$ pip install django==1.10.5
 

Django का उपयोग करके बनाए गए वेब एप्लिकेशन को Django परियोजना के भीतर रहना चाहिए। आप वर्तमान निर्देशिका में एक नई परियोजना शुरू करने के लिए django-admin कमांड का उपयोग कर सकते हैं:

$ django-admin startproject myproject
 

जहाँ myproject एक ऐसा नाम है जो विशिष्ट रूप से परियोजना की पहचान करता है और इसमें संख्याएँ , अक्षर और अंडरस्कोर शामिल हो सकते हैं

यह निम्नलिखित परियोजना संरचना का निर्माण करेगा:

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py
 

एप्लिकेशन को चलाने के लिए, विकास सर्वर शुरू करें

$ cd myproject
$ python manage.py runserver
 

अब जब सर्वर चल रहा है, तो अपने वेब ब्राउजर से http://127.0.0.1:8000/ जाएं। आप निम्न पृष्ठ देखेंगे:

यहाँ छवि विवरण दर्ज करें

डिफ़ॉल्ट रूप से, runserver कमांड पोर्ट 8000 पर आंतरिक आईपी पर विकास सर्वर शुरू करता है। जैसे ही आप अपने कोड में बदलाव करेंगे यह सर्वर अपने आप रीस्टार्ट हो जाएगा। लेकिन यदि आप नई फाइलें जोड़ते हैं, तो आपको सर्वर को मैन्युअल रूप से पुनरारंभ करना होगा।

यदि आप सर्वर के पोर्ट को बदलना चाहते हैं, तो इसे कमांड-लाइन तर्क के रूप में पास करें।

$ python manage.py runserver 8080
 

यदि आप सर्वर का आईपी बदलना चाहते हैं, तो इसे पोर्ट के साथ पास करें।

$ python manage.py runserver 0.0.0.0:8000
 

ध्यान दें कि runserver केवल डिबग बिल्ड और स्थानीय परीक्षण के लिए है। विशिष्ट सर्वर प्रोग्राम (जैसे अपाचे) का उपयोग हमेशा उत्पादन में किया जाना चाहिए।

एक Django ऐप जोड़ना

एक Django परियोजना में आमतौर पर कई apps होते apps । यह बस अपनी परियोजना को छोटे, बनाए रखने योग्य मॉड्यूल में संरचना करने का एक तरीका है। एक ऐप बनाने के लिए, अपने प्रोजेक्टफॉल्डर (जहां manage.py है) पर जाएं, और startapp कमांड को चलाएं (जो भी आप चाहते हैं उसे myapp बदलें):

python manage.py startapp myapp
 

यह myapp फोल्डर और आपके लिए कुछ आवश्यक फाइल्स जेनरेट करेगा, जैसे models.py और views.py

Django को myapp से अवगत कराने के लिए, इसे अपनी settings.py जोड़ें:

# myproject/settings.py

# Application definition
INSTALLED_APPS = [
    ...
    'myapp',
]
 

आपकी प्राथमिकता के अनुसार एक Django परियोजना की फ़ोल्डर-संरचना को बदला जा सकता है। फ़ोल्डर नामों को दोहराने से बचने के लिए कभी-कभी प्रोजेक्ट फ़ोल्डर का नाम बदलकर /src कर दिया जाता है। एक विशिष्ट फ़ोल्डर संरचना इस तरह दिखती है:

निर्देशिका संरचना

आभासी पर्यावरण

हालांकि कड़ाई की आवश्यकता नहीं है, यह "आभासी वातावरण" में अपनी परियोजना शुरू करने के लिए अत्यधिक अनुशंसित है। एक आभासी वातावरण एक कंटेनर (एक निर्देशिका) है जो पायथन का एक विशिष्ट संस्करण और मॉड्यूल (निर्भरता) का एक सेट रखता है, और जो ऑपरेटिंग सिस्टम के मूल पायथन या अन्य परियोजनाओं को एक ही कंप्यूटर पर हस्तक्षेप नहीं करता है।

आपके द्वारा काम करने वाले प्रत्येक प्रोजेक्ट के लिए एक अलग वर्चुअल वातावरण सेट करके, विभिन्न Django प्रोजेक्ट्स पायथन के विभिन्न संस्करणों पर चल सकते हैं, और संघर्ष के जोखिम के बिना निर्भरता के अपने स्वयं के सेट को बनाए रख सकते हैं।

अजगर 3.3+

पायथन 3.3+ में पहले से ही एक मानक venv मॉड्यूल शामिल है, जिसे आप आमतौर पर pyvenv कह सकते हैं। वातावरण में जहां pyvenv कमांड उपलब्ध नहीं है, आप मॉड्यूल को सीधे python3 -m venv रूप में लागू करके उसी कार्यक्षमता तक पहुंच सकते हैं।

वर्चुअल वातावरण बनाने के लिए:

$ pyvenv <env-folder>
# Or, if pyvenv is not available
$ python3 -m venv <env-folder>
 

अजगर २

यदि पायथन 2 का उपयोग कर रहे हैं, तो आप पहले इसे पाइप से एक अलग मॉड्यूल के रूप में स्थापित कर सकते हैं:

$ pip install virtualenv
 

और फिर इसके बजाय virtualenv कमांड का उपयोग करके वातावरण बनाएं:

$ virtualenv <env-folder>
 

सक्रिय करें (कोई भी संस्करण)

वर्चुअल वातावरण अब सेट किया गया है। इसका उपयोग करने के लिए, यह उस टर्मिनल में सक्रिय होना चाहिए जिसे आप इसका उपयोग करना चाहते हैं।

आभासी वातावरण को सक्रिय करने के लिए (कोई भी पायथन संस्करण)

लिनक्स की तरह:

$ source <env-folder>/bin/activate
 

विंडोज की तरह:

<env-folder>\Scripts\activate.bat
 

वर्चुअल वातावरण सक्रिय होने के संकेत के लिए यह आपके संकेत को बदल देता है। (<env-folder>) $

अब से, pip का उपयोग करके स्थापित सब कुछ आपके वर्चुअल एनवी फ़ोल्डर में स्थापित किया जाएगा, सिस्टम-वाइड नहीं।

वर्चुअल वातावरण का उपयोग करने के लिए deactivate :

(<env-folder>) $ deactivate
 

वैकल्पिक रूप से: virtualenvwrapper का उपयोग करें

आप virtualenvwrapper का उपयोग करने पर भी विचार कर सकते हैं जो virtualenv सृजन और सक्रियण को बहुत आसान बनाने के साथ-साथ इसे आपके कोड से अलग करता है:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate
 

वैकल्पिक रूप से: pyenv + pyenv-viritualenv का उपयोग करें

उन वातावरणों में जहाँ आपको कई पायथन संस्करणों को संभालने की आवश्यकता होती है, आप penenv-virtualenv के साथ virtualenv से लाभ उठा सकते हैं:

# Create a virtualenv for specific Python version
pyenv virtualenv 2.7.10 my-virtual-env-2.7.10

# Create a vritualenv for active python verion
pyenv virtualenv venv34

# Activate, deactivate virtualenv
pyenv activate <name>
pyenv deactivate
 

Virtualenvs का उपयोग करते समय, यह अक्सर अपने निर्धारित करने के लिए उपयोगी है PYTHONPATH और DJANGO_SETTINGS_MODULE में postactivate स्क्रिप्ट

#!/bin/sh
# This hook is sourced after this virtualenv is activated

# Set PYTHONPATH to isolate the virtualenv so that only modules installed
# in the virtualenv are available
export PYTHONPATH="/home/me/path/to/your/project_root:$VIRTUAL_ENV/lib/python3.4"

# Set DJANGO_SETTINGS_MODULE if you don't use the default `myproject.settings`
# or if you use `django-admin` rather than `manage.py`
export DJANGO_SETTINGS_MODULE="myproject.settings.dev"
 

अपना प्रोजेक्ट पथ सेट करें

यह अक्सर आपके प्रोजेक्ट पथ को आपके आधार में स्थित एक विशेष .project फ़ाइल के अंदर सेट करने के लिए भी उपयोगी होता है <env-folder> .project <env-folder> । ऐसा करते समय, हर बार जब आप अपने आभासी वातावरण को सक्रिय करते हैं, तो यह सक्रिय निर्देशिका को निर्दिष्ट पथ में बदल देगा।

<env-folder>/.project नामक एक नई फ़ाइल बनाएँ। फ़ाइल की सामग्री केवल प्रोजेक्ट डायरेक्टरी का पथ होनी चाहिए।

/path/to/project/directory
 

अब, अपने वर्चुअल वातावरण (या तो source <env-folder>/bin/activate या workon my_virtualenv ) का उपयोग करें और आपका टर्मिनल निर्देशिकाओं को /path/to/project/directory