Django 잠금 해제: 초보자&# 생성 지점

소개

Django는 강력하고 확장 가능한 웹 애플리케이션을 빠르고 효율적으로 구축할 수 있는 강력한 웹 프레임워크입니다. Python으로 작성되었으며 "배터리 포함" 철학을 따릅니다. 즉, 개발을 더 빠르고 쉽게 만들어 주는 많은 기능이 내장되어 있어 프로토타입 제작에 적합합니다. 소규모 개인 프로젝트를 만들든 대규모 기업 애플리케이션을 만들든 Django에는 필요한 도구가 있습니다.

이 가이드에서는 Django의 MVT 디자인 패턴(모델, 뷰 및 템플릿)을 안내하여 자신만의 웹 애플리케이션을 구축하기 위한 견고한 기반을 제공합니다. 마지막에는 Django의 작동 방식과 해당 구성 요소를 효과적으로 사용하는 방법을 명확하게 이해하게 될 것입니다.

가상 환경으로 Django 프로젝트 설정

Django 공식 문서 참고: Django Documentation

핵심 구성요소를 살펴보기 전에 프로젝트의 종속성을 관리하기 위한 가상 환경을 설정해 보겠습니다. 이렇게 하면 프로젝트를 격리된 상태로 유지하고 다른 Python 프로젝트와의 충돌을 방지할 수 있습니다.

참고: Linux 사용을 적극 권장합니다. Windows를 사용하는 경우 WSL을 설치하여 Linux 환경에 접속하세요.

1. venv 모듈을 설치합니다:

sudo apt install python3-venv

2. 가상 환경 생성:

python -m venv .venv

3. 가상 환경을 활성화합니다:

source .venv/bin/activate

4. 장고를 설치합니다:

가상 환경이 활성화된 상태에서 Django를 설치하세요.

python -m pip install django

5. Django 프로젝트 생성:

django-admin startproject myproj

myproj를 원하는 프로젝트 이름으로 바꾸세요.

6. 앱 만들기:

프로젝트 디렉토리 안에 앱을 생성하세요.

python manage.py startapp myapp

7. 새로 생성된 앱을 다음 위치에 있는 settings.py에 추가합니다.

당신의 프로젝트 이름/당신의 프로젝트 이름/settings.py

INSTALLED_APPS = [
    'myapp',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

이제 프로젝트가 Manage.py 파일, 프로젝트 설정, 첫 번째 앱을 포함한 기본 구조로 설정되었습니다

모델

모델은 Python 클래스를 사용하여 데이터베이스 테이블의 구조와 테이블 간의 관계를 정의합니다. 각 모델 클래스는 단일 데이터베이스 테이블에 매핑되고 모델의 각 속성은 데이터베이스 필드에 해당합니다. Django는 django.db.models.Model에서 상속된 클래스를 사용하여 데이터베이스 스키마를 정의할 수 있도록 하여 이 프로세스를 단순화합니다.

ORM은 객체 관계형 매핑을 의미합니다. Django에서 ORM은 개발자가 SQL 쿼리를 작성하는 대신 Python 코드를 사용하여 데이터베이스와 상호 작용할 수 있도록 하는 강력한 기능입니다. 이 추상화 계층은 Python 클래스(모델)를 데이터베이스 테이블에 매핑하고 해당 클래스의 인스턴스를 테이블의 행에 매핑합니다.

SQLite 소개

Django는 설정이 매우 쉽기 때문에 SQLite를 기본 데이터베이스로 사용합니다. SQLite는 모든 데이터를 하나의 간단한 파일에 보관하는 경량 데이터베이스이므로 웹 사이트 데이터를 저장하고 관리하기 위해 추가로 설치할 필요가 없습니다. 복잡한 데이터베이스 설정에 대한 걱정 없이 애플리케이션 구축에 집중할 수 있으므로 개발 및 테스트에 탁월한 선택입니다.

Django에서는 'code', 'city'와 같은 속성을 가진 Airport라는 테이블이 Python 클래스로 표현되며, 각 속성은 클래스 변수로 정의됩니다.

class Airport(models.Model):
    code = models.CharField(max_length=3)
    city = models.CharField(max_length=64)

1. 모델 정의:

앱의 models.py에서 Django의 ORM을 사용하여 모델을 정의하세요.

from django.db import models

class Flight(models.Model):
    # Diri, kada flight naa tay origin kung asa gikan, destination, ug duration
    # Nakabutang sa parameters ilang properties, such as length of the characters

    origin = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name='departures')
    destination = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name='arrivals')
    duration = models.IntegerField()

    def __str__(self):
        return f'{self.id}: {self.origin} to {self.destination} | {self.duration} minutes.'

2. 마이그레이션:

모델을 정의한 후 마이그레이션을 생성하고 적용하여 데이터베이스 스키마를 업데이트하세요.

간단히 말하면:

• makemigrations는 데이터베이스에 대한 변경을 계획하는 것과 같습니다.
• 마이그레이션은 실제로 데이터베이스에서 이러한 변경 사항을 수행합니다. 따라서 makemigration을 계획한 후 변경 사항을 실행하고 적용하는 것이 마이그레이션입니다.

python manage.py makemigrations
python manage.py migrate

3. 모델과의 상호작용:

Django의 셸을 사용하여 모델과 상호작용하세요: python prepare.py 셸

예:

>> from flights.models import Flight

>> flight1 = Flight(origin="Davao", destination="Manila", duration=569)
>> fligh1.save()

Flights 모델의 인스턴스를 만들었습니다. 이 인스턴스 flight1은 내 데이터베이스의 Flight 테이블에 있는 단일 행을 나타냅니다. Flight 모델에는 출발지, 목적지 및 기간이 정의되어 있습니다.
인스턴스를 생성할 때. 다음 필드를 특정 값으로 설정합니다:

• origin : "Davao"
• destination : "Manila"
• duration : 569 (representing the flight duration in minutes)

Views

Views are a crucial part of the framework that handles the logic behind what a user sees and interacts with in a web application. Views are responsible for processing user requests, retrieving necessary data from the database, and returning the appropriate response (typically an HTML page, JSON data, or a redirect).

In simple terms, Views in Django act as the middleman between the web pages and the data. They take requests from users, process any necessary data, and then send back the appropriate response, like a webpage or a file. Essentially, views decide what content should be shown to the user and how it should be presented.

In this read, we will only be using Function-Based Views

1. Function-Based Views:

These are Python functions that take a web request and return a web response. The most basic view in Django is a function that receives a request object and returns a response object.

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, World!")

2. Class-Based Views:

These are Python classes that provide more structure and allow for more complex functionality compared to Function-Based Views.

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        return HttpResponse("Hello, World!")

Templates

Templates are used to render HTML and display data to users. They allow you to separate your HTML from Python code. Django templates are a powerful tool for generating dynamic HTML content in your web application. By separating the presentation (HTML) from the backend logic (Python code), templates help keep your code clean, maintainable, and reusable.

In simple terms, Templates in Django are like blueprints that define how data should be displayed on a webpage. They allow you to combine static content (like HTML) with dynamic content (like data from a database) to create a fully rendered page. Instead of hardcoding every detail, you use templates to keep the design and data separate, making it easier to update and manage your website.

1. Creating a Template

Start with creating a directory for your templates inside your app and name the directory as templates. Create another directory inside the templates named myapp.

django-proj/myapp/templates/myapp

Now, you can finally place all your templates inside the inner directory you created:

django-proj/myapp/templates/myapp/base.html

Creating the base.html allows you to define a base template or layout with common structure (headers, navbar, and footer) that other templates can inherit. This feature is useful for maintaining consistency across different pages.

Example:

<!DOCTYPE html>
<html>
<head>
    <title> {% block title %} myApp {% endblock %} </title>
</head>
<body>
    <header>
        <h1>My Site</h1>
    </header>
    <div class="content">
        {% block content %}{% endblock %}
    </div>
    <footer>
        <p>Footer content here</p>
    </footer>
</body>
</html>

Let's create another template called index.html and place it in the same directory of base.html.

Example of extending template index.html:

{% extends "myapp/base.html" %}
{% block content %}
    <h1>Flights</h1>
    <ul>
        {% for flight in flights %}
            <li>Flight: {{ flight.id }} {{ flight.origin }} to {{ flight.destination }}</li>
        {% endfor %}
    </ul>
{% endblock %}

The {% extends "myapp/base.html" %} tells Django to use the base.html as the base layout template. The {% block content %} defines a block of content that will be filled with content from index.html. The content block in base.html will be replaced with the content provided in index.html.

2. Rendering Templates

In a Django view, you typically render a template using the render() function, which combines the template with the context data to produce the final HTML output.

from django.shortcuts import render

def index(request):
    return render(request, 'myapp/index.html')

When Django renders index.html, it will include the structure from base.html, replacing the content block with the content specified in index.html. This allows for consistent design across pages and makes it easy to update the overall layout without changing every individual template.

URLs and Routing

Django uses URL patterns to map URLs to views. These patterns are defined in a file called urls.py within each Django app.

URL patterns are defined with the path() function, mapping specific URL paths to view functions or classes. Dynamic URL segments, such as , allow for capturing variables from the URL to be used in views. The include() function enables modular URL management by including patterns from other apps.

In simple terms, URLs are like street addresses for different pages on your website. Routing is the system that makes sure when someone types in a specific address (URL), they get directed to the right page. You set up these "addresses" in a special file so Django knows where to send people when they visit your site.

1. Configuring URLs:
Define URL patterns in urls.py of your app:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
]

Inlcude your app's URLs in the project's urls.py:

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls'))
]

Wrapping up

Congratulations! You've taken the first steps in learning Django. I’ve covered the basics of Models, Views, Templates, and URL routing. With these fundamentals, you’re on your way to building your own Django applications. Keep experimenting, keep coding, and don't hesitate to dive deeper into the Django documentation and community resources.

I hope this guide has made these concepts clearer and that you’ve learned something valuable along the way.

• 0xshr00msz

위 내용은 Django 잠금 해제: 초보자&# 생성 지점의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!