이 게시글은 Fastcampus에서 제공하는 한 번에 끝내는 파이썬 웹 개발 초격차 패키지 Online. 강의를 듣고 작성하였습니다.

🚀 CH04_01. 클래스와 객체

🏳‍🌈 목차

1. 클래스와 객체
2. 여러가지 속성 (인스턴스 속성, 클래스 속성, 비공개 속성)
3. 여러가지 메서드 (인스턴스 메서드, 클래스 메서드, 정적 메서드, 매직 메서드)
4. 상속 (오버 라이딩, 추상클래스)
   

🏳‍🌈 절차 지향 vs 객체 지향

🚧 절차 지향 프로그래밍

기능들을 어떤 순서로 처리할 것인가에 초점을 맞춘다.

• 예를 들어, 아침에 일어나면

  1. 씻기
  2. 옷 갈아입기
  3. 밥 먹기

📌 이와 같이 순서가 중심이 되어 프로그래밍 하는 방식

🚧 객체 지향 프로그래밍

객체가 중심이 되고, 객체를 정의하고 객체간 상호작용에 초점을 맞춘다.

• 예를 들어,

  • A라는 사람이 있고 B라는 사람이 있음
  • A, B는 사람이자 객체
  • A가 B에게 돈을 빌려주는 행동을 하면
    • A는 -10 만큼 재산이 깎이고 B는 10이 재산이 늘어남

📌 이와 같이 객체간에 서로 어떤 행동에 의해 상호작용이 일어나는 것을 객체 지향 프로그래밍이라고 함

🚧 언제 쓰나?

프로그램의 규모에 따라 다름

• 프로그램의 규모가 작은 경우에는 절차 지향
• 대규모 프로젝트는 객체 지향 방식이 효율적
  

🏳‍🌈 클래스와 객체의 개념

🚧 클래스와 객체

클래스 📌 객체를 만들기 위한 설계도

객체 📌 설계도로부터 만들어낸 제품

🚧 클래스와 객체 만들기

클래스 만들기

class 클래스이름:
    # pass : 아직 구현하지 않고 넘어가고, 나중에 구현하겠다는 것을 의미
    pass 

객체 만들기

인스턴스 = 클래스이름()

🚧 속성과 메서드 추가하기

속성 추가하기

class Unit:
    # __init__ 메서드 : 생성자
    # 생성자의 첫 번째 변수로는 반드시 self가 반드시 들어감
    # self는 객체 자기 자신을 의미
    # 두번째 변수부터는 속성값으로 사용할 데이터를 입력받는 역할을 하게 됨.
    def __init__(self, name, hp, shield, demage):
        # 클래스의 속성 : self.속성명 형태로 작성하고, 위에서 입력받을 변수를 할당하는 형태로 작성
        self.name = name           # 이름
        self.hp = hp               # 체력
        self.shield = shield       # 방어막
        self.demage = demage       # 공격력

실제 객체 생성하기

probe = Unit("프로브", 20, 20, 5)
zealot = Unit("질럿", 100, 60, 16)
dragoon = Unit("드라군", 100, 80, 20)

메서드 추가하기

• Unit 클래스에 정보를 출력하는 메서드를 추가해 봅시다.

class Unit:
    def __init__(self, name, hp, shield, demage):
        self.name = name
        self.hp = hp
        self.shield = shield
        self.demage = demage
    # __str__ 메서드
    def __str__(self):
        return f"[{self.name}] 체력 : {self.hp} 실드 : {self.shield} 공격력 : {self.demage}"

객체 생성

probe = Unit("프로브", 20, 20, 5)
# print 실행 시, __str__ 메서드가 실행되게 됨.
print(probe)
# 프로브 체력 : 20 실드 : 20 공격력 : 5

🚀 CH04_02. 여러가지 속성

🏳‍🌈 인스턴스 속성 (instance attribute)

객체마다 다르게 가지는 속성

class Unit:
    def __init__(self, name, hp, shield, demage):
        self.name = name          # 인스턴스 속성
        self.hp = hp              # 인스턴스 속성
        self.shield = shield      # 인스턴스 속성
        self.demage = demage      # 인스턴스 속성

인스턴스 속성 사용 방법

• self.속성명 : 클래스 안에서 인스턴스를 사용할 때
• 객체명.속성명 : 클래스 밖에서 인스턴스를 사용할 때

🏳‍🌈 클래스 속성 (class attribute)

모든 객체가 공유하는 속성

class Unit:
    count = 0                    # 클래스 속성
    def __init__(self, name, hp, shield, demage):
        self.name = name
        self.hp = hp
        self.shield = shield
        self.demage = demage
        Unit.count += 1          # 클래스 속성

🏳‍🌈 비공개 속성 (private attribute)

클래스 안에서만 접근 가능한 속성

📌 클래스 밖에서 속성에 접근하려고 하면 접근 자체가 불가한 속성

class Unit:
    def __init__(self, name, hp, shield, demage):
        self.name = name
        self.__hp = hp                   # 비공개 속성
        self.shield = shield
        self.demage = demage

📌 실습 코드

클래스 생성

class Unit:
    count = 0
    def __init__(self, name, hp, shield, demage):
        self.name = name
        self.__hp = hp
        self.shield = shield
        self.demage = demage
        Unit.count += 1
        print(f"[{self.name} (이)가 생성 되었습니다.")

    def __str__(self):
        return f"[{self.name}] 체력 : {self.__hp} 실드 : {self.shield} 공격력 : {self.demage}"

객체 생성

# 객체 3개 생성
probe = Unit("프로브", 20, 20, 5)
zealot = Unit("질럿", 100, 60, 16)
dragoon = Unit("드라군", 100, 80, 20)

출력을 통한 확인

# 인스턴스 속성
print(probe.name)          # 프로브
print(zealot.hp)           # 9999
print(dragoon.damage)      # 20

# 클래스 속성
print(Unit.count)

# 비공개 속성 접근
prove.__hp = 9999
print(prove)            # [프로브] 체력 : 20 방어막 : 20 공격력 : 6
# 변경되지 않음.

📌 네임 맹글링 (name mangling)

• 이름을 뭉개서 해당 속성을 접근할 수 없게 만든다는 뜻
• 그러나 아래와 같이 접근하면 수정 가능

probe._Unit__hp = 9999
print(prove)            # [프로브] 체력 : 9999 방어막 : 20 공격력 : 6

🚀 CH04_03. 여러가지 메서드

🏳‍🌈 인스턴스 메서드 (instance method)

인스턴스 속성에 접근할 수 있는 메서드.

📌 항상 첫번째 파라미터로 self를 갖는다.

hit 메서드 구현하기

• 데미지를 받으면 체력과 방어막이 깎이는 **hit 메서드**를 구현해 보자.

1. 데미지가 방어막보다 작거나 같으면 방어막만 깎인다.

2. 데미지가 방어막보다 크고 체력보다 작으면 체력과 방어막이 깎인다.

3. 데미지가 체력보다 크면 체력을 0으로 만든다.

인스턴스 메서드

class Unit:
    count = 0
    def __init__(self, name, hp, shield, demage):
        self.name = name
        self.__hp = hp
        self.shield = shield
        self.demage = demage
        Unit.count += 1
        print(f"[{self.name} (이)가 생성 되었습니다.")

    def __str__(self):
        return f"[{self.name}] 체력 : {self.__hp} 실드 : {self.shield} 공격력 : {self.demage}"

    def hit(self, damage):
        # 방어막 변경
        if self.shield >= damage:
            self.shield -= damage
            damage = 0
        elif:
            damage -= shelf.shield
            self.shield = 0

        # 체력 변경
        if damage > 0:
            if self.hp > damage:
                self.hp -= damage
            else:
            self.hp -= 0

🏳‍🌈 클래스 메서드 (class method)

클래스 속성에 접근하기 위해서 사용한다.

📌 클래스를 의미하는 cls를 파라미터로 받는다.
📌 실습 코드

클래스 메서드

class Unit:
    count = 0
    ...
    @classmethod      # 데코레이터 형태로 사용
    def print_count(cls):
        print(f"전체 유닛 개수 : {cls.count}")

#클래스 메서드를 실행할 때는 객체를 거칠 필요 없이 바로 클래스에서 바로 호출 가능
Unit.print_count()         # 생성된 유닛 개수 : 3개

🏳‍🌈 정적 메서드 (static method)

인스턴스를 만들 필요가 없는 메서드

📌 self를 받지 않는다.

• 메서드가 인스턴스 유무와 관계없이 독립적으로 사용될 때
  

📌 실습 코드

정적 메서드

Math라는 클래스를 만들고 staticmethod 클래스를 math클래스 안에 구현

class Math:

    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def sub(x, y):
        return x - y

print(Math.add(3, 4))    # 7
print(Math.sub(3, 4))    # -1

🏳‍🌈 매직 메서드 (magic method)

클래스 안에서 정의가 가능한 스페셜 메서드

📌 특별한 상황에 호출된다.

• __이름__ 의 형태로 되어있다.
• __init__ 메서드 : 클래스에서 객체를 생성할 때 호출되는 메서드
• __str__ 메서드 : 클래스에서 객체를 출력할 때 호출되는 메서드

📌 dir : 객체가 가지고 있는 메서드와 속성을 확인할 수 있는 함수

• dir(prove) : prove 객체가 가지고 있는 메서드와 속성을 확인

🚀 CH04_04. 상속

🏳‍🌈 상속의 개념

📌 클래스들의 공통된 속성과 메서드를 뽑아내서 부모 클래스를 만든다.

이를 자식 클래스에서 상속받아서 사용한다.

🏳‍🌈 상속의 장점

📌 코드의 중복을 제거 가능

• 기존에는 여러가지 자식 클래스에서 각각 공통된, 중복된 코드를 일일히 만들어야 했지만, 부모 클래스에 공통된 코드를 만들어 놓으면 자식 클래스에서는 그대로 받아서 사용하면 됨.

📌 간편한 유지보수

• 부모클래스에 공통된 코드를 작성해놓으면 그 코드를 수정하면 되고, 자식클래스 각각에 구현한 상세 코드는 그 코드만 수정하면 되기 때문

🏳‍🌈 상속 구현하기

상속 실습 파트에서 코드 작성 예정

🏳‍🌈 추상 클래스

추상클래스는 추상메서드를 가질 수 있음

• 추상메서드 : 상속받는 자식 클래스에서 구현을 강제하도록 만드는 것
• 추상클래스 : 추상메서드를 하나라도 가지고 있는 클래스

📌 만약, 추상메서드를 만들었는데 자식클래스에서 해당 메서드를 구현하지 않으면 아래와 같은 오류 메세지 발생

🏳‍🌈 상속 실습

'Item' Class 생성

class Item:
    """
    속성 : 이름
    메서드 : 줍기, 버리기
    """
    def __init__(self, name):
        self.name = name

    def pick(self):
        print(f"[{self.name}] 을(를) 주웠습니다.")

    def discard(self):
        print(f"[{self.name}] 을(를) 버렸습니다.")

'Weapon' Class 생성

class Weapon(Item):
    """
    속성 : 공격력
    메서드 : 공격하기
    """
    def __init(self, name, damage):
        # super() : 부모 클래스를 호출
        # 거기에 생성자를 호출해서 이름을 넘겨주겠다!!
        super().__init__(name)
        self.damage = damage

    def attack(self):
        print(f"[{self.name}] 을(를) 이용해 {self.damage} 로(으로) 공격합니다.")

'HealingItem' Class 생성

class HealingItem(Item):
    """
    속성 : 회복량
    메서드 : 사용하기
    """
    def __init__(self, name, recovery_amount):
        super().__init(name)
        self.recovery_amount = recovery_amount

    def use(self):
        print(f"[{self.name}] 을(를) 사용합니다. {self.recovery_amount} 회복")

객체 생성

# 객체 생성
m16 = Weapon("m16", 110)
bungdae = HealingItem("붕대", 20)

m16.attack()
# m16 을(를) 이용해 110 로(으로) 공격합니다.
bungdae.use()
# bungdae 을(를) 사용합니다. 20 회복

추상클래스 실습

from abc import *

# 'ABCMeta' 라는 'metaclasss'를 상속받으면 Item 클래스가 추상클래스가 됨.
# 추상클래스로 만들고 나면 안에서 추상메서드를 사용할 수 있게 됨.
class Item(metaclass=ABCMeta):
    """
    속성 : 이름
    메서드 : 줍기, 버리기
    """
    def __init__(self, name):
        self.name = name

    def pick(self):
        print(f"[{self.name}] 을(를) 주웠습니다.")

    def discard(self):
        print(f"[{self.name}] 을(를) 버렸습니다.")

    # 추상메서드 만들때, abstractmethod 라는 메서드를 데코레이터로 사용
    # use 라는 메서드를 구현하지 않고 자식클래스로 넘김
    @abstracmethod
    def use(self):
        pass

class Weapon(Item):
    """
    속성 : 공격력
    메서드 : 공격하기
    """
    def __init(self, name, damage):
        # super() : 부모 클래스를 호출
        # 거기에 생성자를 호출해서 이름을 넘겨주겠다!!
        super().__init__(name)
        self.damage = damage

    def use(self):
        print(f"[{self.name}] 을(를) 이용해 {self.damage} 로(으로) 공격합니다.")


class HealingItem(Item):
    """
    속성 : 회복량
    메서드 : 사용하기
    """
    def __init__(self, name, recovery_amount):
        super().__init__(name)
        self.recovery_amount = recovery_amount

    def use(self):
        print(f"[{self.name}] 을(를) 사용합니다. {self.recovery_amount} 회복")


# 객체 생성
m16 = Weapon("m16", 110)
bungdae = HealingItem("붕대", 20)

m16.use()
# m16 을(를) 이용해 110 로(으로) 공격합니다.
bungdae.use()
# bungdae 을(를) 사용합니다. 20 회복

🚀 CH04_05 클래스 실습 문제

🏳‍🌈 상속 관계와 포함 관계

📌 is-a 관계: 서로 상속을 할 때 발생하는 관계

• *Weapon is-a Item *

  Weapon < Item

📌 has-a 관계: 어떤 특정 클래스가 다른 클래스의 객체를 가지고 있는 관계. 1:N 관계라고도 정리 가능.

• Player has-a Unit

  Player 하나의 객체가 여러개의 Unit 객체를 가지고 있음.

🏳‍🌈 Unit, Player 클래스 구현

1. 속성 : 닉네임, 미네랄, 가스, 유닛리스트

2. 메서드 : 생산하기 produce(이름, 미네랄, 가스, 체력, 방어막, 공격력)

   • Player의 미네랄과 가스가 충분한 경우 : 유닛 객체를 생성하고 유닛리스트에 추가한다.
   • Player의 미네랄이 부족한 경우 : "미네랄이 부족합니다"를 출력
   • Player의 가스가 부족한 경우 : "가스가 부족합니다"를 출력

# 유닛 정보
unit_info = {
    "probe" : {
        "name" : "프로브",
        "mineral" : 50,
        "gas" : 0,
        "hp" : 20,
        "shield" : 20,
        "demage" : 5
    },
    "zealot" : {
        "name" : "질럿",
        "mineral" : 100,
        "gas" : 0,
        "hp" : 100,
        "shield" : 60,
        "demage" : 16
    },
    "dragoon" : {
        "name" : "드라군",
        "mineral" : 125,
        "gas" : 50,
        "hp" : 100,
        "shield" : 80,
        "demage" : 20
    }
}

#  -----------

# 클래스 생성

class Unit(Player):
    """
    속성 : 이름, 체력, 방어막, 공격력
    """
    def __init(self. hp, shield, damage):
        self.hp = hp
        self.shield = shield
        self.damage = damage

class Player:
    """
    속성 : 닉네임, 미네랄, 가스, 유닛리스트
    메서드 : 유닛 생산하기
    """
    def __init__(self, nickname, mineral, gas, unit_list=[]):
        self.nickname = nickname
        self.mineral = mineral
        self.gas = gas
        self.unit_list = unit_list

    # 생산하기 메서드
    def produce(self, name, mineral, gas, hp, shield, damage):
        if self.mineral - mineral < 0:
            print("미네랄이 부족합니다.")
        elif self.gas - gas < 0:
            print("가스가 부족합니다.")
        else:
            self.mineral -= mineral
            self.gas -= gas
            unit = Unit(name, hp, shield, damage)
            self.unit_list.append(list)
            print(f"[{name}] 을(를) 생산합니다.")

객체 생성

# 플레이어 생성 1
# unit_list는 default 값으로 '[]'를 지정해두었기 때문에 인자로 넣지 않아도 빈 리스트로 지정됨.
player1 = Player("Bisu", 400, 10)

# 유닛 생성
player1.produce(unit_info['probe']['name'], unit_info['probe']['mineral'], unit_info['probe']['gas'], unit_info['probe']['hp'], unit_info['probe']['shield'], unit_info['probe']['damage']
# [프로브] 을(를) 생산합니다.
player2.produce(unit_info['zealot']['name'], unit_info['zealot']['mineral'], unit_info['zealot']['gas'], unit_info['zealot']['hp'], unit_info['zealot']['shield'], unit_info['zealot']['damage']
# [질럿] 을(를) 생산합니다.
player3.produce(unit_info['dragoon']['name'], unit_info['dragoon']['mineral'], unit_info['dragoon']['gas'], unit_info['dragoon']['hp'], unit_info['dragoon']['shield'], unit_info['dragoon']['damage']
# 가스가 부족합니다.

# 생성된 모든 유닛 확인
for unit in player1.unit_list:
    print(f"[{unit.name}] 체력 : {unit.hp} 방어막 : {unit.shield} 공격력 : {unit.damage}")

# [프로브] 체력 : 20 방어막 : 20 공격력 : 5
# [질럿] 체력 : 100 방어막 : 60 공격력 : 16



# 플레이어 생성 2
# unit_list는 default 값으로 '[]'를 지정해두었기 때문에 인자로 넣지 않아도 빈 리스트로 지정됨.
player1 = Player("Bisu", 500, 200)

# 유닛 생성
player1.produce(unit_info['probe']['name'], unit_info['probe']['mineral'], unit_info['probe']['gas'], unit_info['probe']['hp'], unit_info['probe']['shield'], unit_info['probe']['damage']
# [프로브] 을(를) 생산합니다.
player2.produce(unit_info['zealot']['name'], unit_info['zealot']['mineral'], unit_info['zealot']['gas'], unit_info['zealot']['hp'], unit_info['zealot']['shield'], unit_info['zealot']['damage']
# [질럿] 을(를) 생산합니다.
player3.produce(unit_info['dragoon']['name'], unit_info['dragoon']['mineral'], unit_info['dragoon']['gas'], unit_info['dragoon']['hp'], unit_info['dragoon']['shield'], unit_info['dragoon']['damage']
# [드라군] 을(를) 생산합니다.

# 생성된 모든 유닛 확인
for unit in player1.unit_list:
    print(f"[{unit.name}] 체력 : {unit.hp} 방어막 : {unit.shield} 공격력 : {unit.damage}")

# [프로브] 체력 : 20 방어막 : 20 공격력 : 5
# [질럿] 체력 : 100 방어막 : 60 공격력 : 16
# [드라군] 체력 : 100 방어막 : 80 공격력 : 20

이 게시글은 김준태 강사님의 DRF - Basic 강의를 듣고 작성하였습니다.

📢 수업 목표

1. DRF 로 간단한 블로그 만들기

✨ 카테고리 추가하기

🎨 Model, Serializers 설정

📌 글마다 카테고리를 할당할 수 있도록 카테고리 모델을 작성

• 글을 작성할 때, 존재하지 않는 카테고리를 지정하면 안되기 때문에, 이미 존재하는 카테고리 중에서만 카테고리를 선택할 수 있도록 해야함.
• 그래서 우선 카테고리를 저장해놓기 위한 모델/시리얼라이저를 작성.
• 그리고 글 모델에는 카테고리 필드를 하나 추가하고, 지금 만든 테고리 모델의 데이터만 받을 수 있도록 수정 (카테고리 모델에 없는 데이터는 절대 지정할 수 없도록)

blog/models.py

class Category(models.Model):
    name = models.CharField(max_length=50, unique=True)
    description = models.TextField(max_length=255)

    def __str__(self): # 이 코드는 admin 페이지에서 데이터를 object() 형태가 아니라 이름으로 표시할 수 있도록 바꿔주는 코드입니다.
        return f"{self.name}"

class Article(models.Model):
    category = models.ManyToManyField(Category, blank=True) # () 안의 Category 는 위 Category 모델을 명시한 것입니다!
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_time = models.DateTimeField(auto_now_add=True)
    updated_time = models.DateTimeField(auto_now=True)

• 하나의 글에 category 를 여러 개 지정할 수 있도록 하기 위해서, ManyToManyField 를 사용

  • Article 의 category 필드에는 카테고리 모델의 데이터 그 자체가 들어가는 것이 아니고, 카테고리 모델 중에서 어떤 데이터인지 구별하기 위한 pk 만 들어가게 된다고 생각하시면 됩니다!

📌 모델을 수정했다면 꼭 migration 이 필요

Terminal 창

$ poetry run python manage.py makemigrations

$ poetry run python manage.py migrate

📌 serializer 도 추가

blog/serializers.py

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ["name", "description"]

🎨 admin 페이지를 통한 카테고리 추가

📌 admin에 Category 모델 등록

blog.admin.py

from django.contrib import admin
from blog.models import Article, Category

# Register your models here.

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ["name", "get_description"]

    @admin.display(description="카테고리 안내")
    def get_description(self, obj):
        return obj.description[:30]

@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ["title", "get_content"]

    @admin.display(description="내용")
    def get_content(self, obj):
        return  obj.content[:30]

📌 서버 실행 > admin 페이지 접속 > 카테고리 추가

🎨 article 시리얼라이저의 수정

• 시리얼라이저는 어떤 내용을 사용자에게 보여줄지 (응답으로 전달할지) 결정하는 용도도 있음!!

  • 지금은 글을 표시할 때 제목, 내용, 글쓴시각, 수정시각 만 표시하게 됨.
  • 모델을 수정해서 카테고리가 추가된 만큼, 카테고리도 표시하도록 시리얼라이저를 수정!!

📌 serializers.py 수정

blog/serializers.py

from rest_framework import serializers
from .models import Article, Category

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ["name", "description"]

class ArticleSerializer(serializers.ModelSerializer):
    # article 을 표시할 때 카테고리 객체도 직렬화해서 보기 위한 설정 
    # 이게 없다면 카테고리 이름이 아니라, 그냥 id 숫자로만 표시되게 됨
    category = CategorySerializer(many=True, required=False, read_only=True)

    class Meta:
        model = Article
        fields = ["title", "content", "category"]

• serializer 안에서는 단순히 어떤 내용을 표시할지 뿐만 아니라, 해당 내용(필드)을 표시할 때 정확히 어떻게 표시할 건지도 명시 가능
• category 는 여러 개 지정 가능하기 때문에, 데이터가 여러개 들어올 수 있다는 것을 알려주기 위해서 many=True 옵션을 명시해야 함.

📌 create 함수 작성

• 그런데 위처럼만 작성하게 되면, 사용자로부터 카테고리를 입력받아서 글을 작성하는 과정이 조금 복잡해지게 됨.

  • 카테고리를 받아서 글이 저장되는 과정을 조금 더 간단히 만들기 위해서, create 함수를 추가

• create 함수의 역할

  • 지금 create 함수는 유저로부터 카테고리 번호를 받고, 글에 해당 번호의 카테고리를 지정해주기 위해서 작성!!
  • foreign key (ManyToMany) 가 포함된 모델의 데이터를 저장할 때면 보통 create 함수를 커스텀해서 사용!!

• article 시리얼라이저에 아래 내용을 추가할텐데, 이 함수는 views 에서 serializer.save() 시에 실행될 함수임.

  • 만약 create 함수가 없다면 자동으로 db에 저장하는 과정을 수행하지만, 있다면 해당 함수의 내용대로 db에 저장하는 과정이 수행됨.

    def create(self, validated_data): # is_valid 이후에 save 함수가 실행되므로, 현재 유저가 작성해서 들어온 데이터를 validated_data 라고 해서 받습니다. 
        get_categories = validated_data.pop("get_categories", []) # 유저가 "{title: 제목, content: 내용, get_categories: [카테고리번호들]}" 형태로 데이터를 보냈다면, 여기서 get_categories 부분만 추출합니다. 
        article = Article(**validated_data) # 해당 내용을 토대로 article 객체를 만듭니다.
        article.save() # 해당 객체를 db 에 저장합니다.
        article.category.add(*get_categories) # 저장된 그 글에 대해서 유저가 보낸 카테고리 번호에 맞는 category 를 지정합니다.
        return article

blog/serializers.py

• ArticleSerializer완성본

from rest_framework import serializers
from .models import Article, Category

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ["name", "description"]

class ArticleSerializer(serializers.ModelSerializer):
    category = CategorySerializer(many=True, required=False, read_only=True) # article 을 표시할 때 카테고리 객체도 직렬화해서 보기 위한 설정 (이게 없다면 카테고리 이름이 아니라, 그냥 id 숫자로만 표시되게 됨)
    get_categories = serializers.ListField(required=False) # 유저한테 리스트 형태로 카테고리를 입력받을 수 있도록, 추가한 필드

    class Meta:
        model = Article
        fields = ["title", "content", "category", "get_categories"]

    def create(self, validated_data): # views 에서 serializer.save() 실행 시 아래 코드가 실행됨 (이 create 함수가 없으면 자동으로 알아서 저장하고, 있으면 여기 있는 내용대로 저장과정을 수행함)
        get_categories = validated_data.pop("get_categories", [])
        article = Article(**validated_data)
        article.save()
        article.category.add(*get_categories)
        return article

🎨 요청 보내기

📌 Category 모델 생성 직후

• 게시글마다 등록된 카테고리가 없는 상황

📌 POST 요청

• get_categories 라는 키:밸류 쌍을 하나 더 추가해서 Post 요청

📌 GET 요청

• blog/ 로 접속하여 등록된 모든 글 조회

• blog/<int:pk> 로 접속하여 특정 글에 대해 조회
  • 1번, 3번에 해당하는 카테고리가 글에 잘 할당되어서, 표시되는 것을 확인 가능

✨ 댓글 추가하기

🎨 Model, Serializers 설정

📌 models.py 에 comment 모델을 추가

• 댓글은 무조건 특정한 글에 달리는 것이기 때문에, foreign key 형태로 Article 모델과 연결하는 article 필드를 추가

blog/models.py

class Comment(models.Model):
    content = models.CharField(max_length=100)
    article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='comments')
    created_time = models.DateTimeField(auto_now_add=True)
    updated_time = models.DateTimeField(auto_now=True)

• ManyToManyField vs ForeignKey

  • ManyToManyField 는 N:N 관계일 때, ForeignKey 는 1:N 관계일 때 사용하는 필드.

• related_name

  • related_name : Article 쪽에서 Comment 모델 객체에 접근할 때 쓰는 이름
  • 지금은 Comment 모델에 어떤 글에 달린 댓글인지 그 글 번호를 저장하고 있으나, 결국에 우리는 글을 보여줄 때 댓글도 함께 보여줘야 합니다.
  • 그러려면 글을 가져오는 과정 (Article 쪽) 에서 댓글까지 함께 가져와야 하는데, 그때 해당 이름이 사용되는 것

📌 serializer 작성

blog/serializers.py

class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = ["content", "article"]
        extra_kwargs = {'article': {'write_only': True}}

• 보통 블로그에서 댓글을 볼 때는 특정한 글 하단 부분에 내용만 표시 (content) 되고, 해당 댓글이 달린 글 번호 (article) 까지 함께 표시하지는 않기 때문에, 'article' 에 'write_only': True 옵션을 걸어서 글 번호는 표시하지 않도록 설정

🎨 article 시리얼라이저 수정

• article 데이터를 전달할 때, 해당 글이 가진 댓글 데이터도 함께 넘겨줄 수 있도록 article 시리얼라이저를 수정

  • comments = CommentSerializer(many=True, read_only=True) 부분과 함께 필드에 comments 가 추가된 것을 제외하고는 달라진 것이 없음.

blog/serializers.py

class ArticleSerializer(serializers.ModelSerializer):
    category = CategorySerializer(many=True, required=False, read_only=True)
    get_categories = serializers.ListField(required=False)
    comments = CommentSerializer(many=True, read_only=True) # comment 객체를 직렬화해서 보기 위한 설정

    class Meta:
        model = Article
        fields = ["id", "title", "content", "category", "get_categories", "comments"] # 필드에 comments 추가

    def create(self, validated_data):
        get_categories = validated_data.pop("get_categories", [])
        article = Article(**validated_data)
        article.save()
        article.category.add(*get_categories)
        return article

🎨 views 수정 (POST 요청 작성)

• views.py 내부의 BlogDetail 클래스에다가 댓글 작성을 위한 함수를 추가

  • 서버주소/blog/1/ 로 POST 요청을 보내면, 해당 1번 글에 댓글이 달리도록 작성하는 것!!

• 우선 1번 글이 진짜로 존재하는지 확인하고 → 댓글 내용을 직렬화한 후에 → 해당 1번 글과 댓글을 연결하면서 db 에 저장하도록 할 것임.

blog/views.py

    # comment api 를 따로 분리하기도 하는데, 이번에는 간단하게 여기서 post 를 보내도록 하겠습니다
    # 프로젝트의 규모가 커진다면 posts 라는 앱, comments 라는 앱으로 분리해서 각각 진행하시는게 좋습니다
    def post(self, request, pk):
        article = Article.objects.get(pk=pk) # 우선 실제로 존재하는 글에 대해서 댓글을 달고자 하는 것인지 확인
        comment_serializer = CommentSerializer(data=request.data, partial=True) # partial=True 라고 하면, 일부 데이터가 없어도 validation 을 통과합니다.
        if comment_serializer.is_valid():
            comment_serializer.save(article=article) # 유저가 작성한 댓글을 db 에 저장할 때, 앞서 db 에서 찾은 article 과 연결하면서 저장함
            return Response({"message": "정상"}, status=status.HTTP_200_OK)
        return Response(comment_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

→ 우선은 조금 더 간단한 방식으로 진행한 것이고, 실제로는 지금 같은 경우에 partial=True 를 쓰지는 않음.

• ** 예외처리도 조금 부족하게 되어있기 때문에, 더 정확한 방식에 대한 공부가 필요함.**

🎨 admin 수정

• admin 페이지에서 확인을 좀 더 편하게 하기 위해 설정 추가

blog/admin.py

from django.contrib import admin
from blog.models import Article, Category, Comment

# Register your models here.

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ["name", "get_description"]

    @admin.display(description="카테고리 안내")
    def get_description(self, obj):
        return obj.description[:30]

@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ["title", "get_content"]

    @admin.display(description="내용")
    def get_content(self, obj):
        return  obj.content[:30]

@admin.register(Comment)
class CommentAdmin(admin.ModelAdmin):
    list_display = [ "get_article", "get_content"]

    @admin.display(description="댓글")
    def get_content(self, obj):
        return  obj.content[:30]

    @admin.display(description="게시글 제목")
    def get_article(self, obj):
        return  obj.article.title

🎨 요청 보내기

• blogdetail view 에 작성했기 때문에, 아래처럼 blogdetail url 로 post 요청을 보내면 댓글이 등록됨

• POST 메서드로 댓글 등록

• GET 메서드로 정상 등록 여부 확인

이 게시글은 김준태 강사님의 DRF - Basic 강의를 듣고 작성하였습니다.

📢 수업 목표

1. DRF 로 간단한 블로그 만들기

✨ 간단한 Blog 만들기

🎨 poetry 로 django 프로젝트 만들기

Django Project 초기 셋팅 글을 참고하여 초기 셋팅 진행

🎨 rdb에 대해서

📌 블로그를 만들기 위해 필요한 것은?

• 이용자가 글을 쓸 수 있고, 이용자가 쓴 글이 계속해서 쌓이면서 이를 다른 사람이 볼 수 있어야 함.

📌 바로 데이터베이스가 필요

• 어떤 이용자 혹은 게시글이 있는지를 데이터베이스라는 정보 저장소를 통해서 확인하고, 사용자나 게시글을 해당 정보 저장소에 추가하는 형태로 작업이 이루어지게 됩니다.

📌 django 에서는 관계형 데이터베이스를 사용하는데, 이를 rdb (relational database) 라고 함.

• 즉, 데이터베이스는 데이터베이스인데, 안의 데이터들이 서로 관계를 맺으면서 이루어져있다는 뜻!

📌 db 내부에서 특정 정보에 대해서 정보를 담는 공간을 테이블이라고 함.

• 비유를 하자면, db 는 엑셀 파일이고, 테이블은 엑셀 파일 내부의 시트임.
• 엑셀에서 시트를 여러개 만들 수 있듯, db 에서 테이블도 여러개를 만들 수 있음.

📌 유저가 글을 쓰는 기능을 만든다고 생각하면, 우선 user 테이블과 post 테이블이 각각 존재해야 함.

• 각각 테이블에서 각각의 열 (id, title, body 등) 을 attribute 혹은 field 라고 말함.

📌 Post 테이블 내부의 userId 를 보고, User 테이블로 가서 해당 유저의 이름을 알 수 있음.

• id 가 1인 글의 경우, userId 가 1 이므로, User 테이블에서 id 가 1인 사람을 찾으면, ‘김xx' 이라는 사람이 글을 썼다는 것을 알 수 있음. → 이렇게 테이블을 서로 연결짓는 필드를 foreign key 라고 함. (예시에서 post 테이블의 userId 필드를 foreign key 라고 말함.)

• 그리고 이렇게 id로 특정한 유저를 구분짓기 위해서는, 해당 id 가 고유한 값 (unique) 이어야 함.
• 다른 유저랑 id 가 똑같다면 다른 유저와 구별을 할 수가 없게 됨.
• 그래서 이렇게 각 테이블마다 존재하는 unique 한 id 를 primary key 라고 함.

📌 보통은 아래와 같이 연결 구조를 표현하는 diagram 을 그려서 db 에 대한 초기 설계를 진행하게 됨.

🎨 model 설정

model : 글 저장 공간 만들기

📌 django 에서는 models.py 파일에 위와 같은 틀을 작성하고, 이후에 migration 이라는 행위를 통해서 실제 database 에 해당 테이블을 만들어주게 됨.

우선 틀을 만들기 위해, blog/models.py 에 모델 작성

blog.urls.py

from django.db import models

# Create your models here.
class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_time = models.DateTimeField(auto_now_add=True) # created_at 이라고도 합니다.
    updated_time = models.DateTimeField(auto_now=True)

📌 이렇게 하면 Article 이라는 이름으로 하나의 테이블을 만들 수 있게 됨.

• 모델을 만들 때는 필드마다 타입 (글자인지, 시간인지 등) 을 지정해줘야 하는데, 사용할 수 있는 Field 로는 CharField (단어 / 짧은 텍스트), TextField (긴 글), DateTimeField (시간) 등이 있음.

  • auto_now_add : 처음 추가될 때 자동으로 현재 시각을 받아오겠다는 뜻
  • auto_now : 수정될 때마다 자동으로 현재 시각을 받아오겠다는 뜻 → 이렇게 하면 사용자는 title, content 만 작성하면 되고, 작성 시각 등은 django 가 알아서 처리해줌.
  • id 를 굳이 직접 만들지 않은 이유는, primary key 로 쓸 필드는 굳이 직접 만들지 않아도 django 가 알아서 테이블 내에 id (혹은 pk) 라는 이름으로 필드를 만들어 주기 때문!

🎨 serializers 설정

serializers : 글에서 어떤 정보를 보여주거나 / 받을지를 지정

📌 request와 response

• request : www.naver.com 이라는 주소에 접근하는 것 자체가 하나의 요청.
• response : 그리고 접근하는 순간에 거기에 대한 응답으로 이미지, 로그인을 위한 js 코드라던지, 데이터 들이 응답으로 오게 됨

• 글을 작성할 때도, 하나의 요청으로 이러이러한 글을 써달라는 요청을 우리가 만든 서버 주소로 보내게 됨.
• 거기에 대한 응답으로 글 작성에 성공했다 라는 내용을 내려줌.

📌 Django RestFramework 에는 serializer 라는 것이 있음.

• 직렬화 (serialize) : db 에 저장되어있는 모델 객체를 프론트엔드로 전송 가능한 json 형태로 변형하는 것
• 역질렬화 : 직렬화의 반대로 프론트엔드에서 넘어온 데이터를 db 에 저장할 수 있도록 변환하는 과정

  정확히는 db 객체 (instance) → dict → ByteString 으로 변환하는 과정을 serialize 라고 말함.

• db 에 저장된 형태 그대로 웹사이트에 던져줄 수가 없으니, 이를 웹사이트에서 사용할 수 있는 형태로 가공하는 형태로 바꿔주는 과정임.

📌 drf 에서 serializer 를 작성할 때는 필요한 요소만 추출하도록 작성이 가능함.

• 그래서 회원 정보 (id, password 가 포함된) 를 프론트엔드 (웹사이트) 로 넘기는 과정에서도, id 만 넘기도록 설정 가능.
• 또한 serializer 를 통해서 현재 들어온 데이터가 유효한지 검사 (validation) 하는 과정 또한 진행하게 됨.
• 그래서 우리가 글을 쓰기 위해서는 title, content 가 각각 필요하다고 serializer 에 명시를 했는데, 이에 대한 데이터가 안오거나 혹은 부정확하게 오는 경우에 serializer 는 해당 데이터를 db 에 저장하는 과정을 수행하지 않게 됨.

위 내용을 조금 더 단순화해서 설명하자면,

📌 serializer : 특정한 모델에 대해서, ‘프론트엔드와 통신할 때, 주고 받을 데이터의 목록 을 작성’ 하는 과정

• 즉, 우선 글을 저장할 공간 (db) 에 글을 담기에 앞서서, 어떤 정보를 웹사이트 이용자로부터 받을지, 어떤 정보가 필요한지 등을 작성하는 과정. (또한 저장된 글을 이용자한테 보여줄 때 글의 어떤 정보를 보여줄 지 작성하는 과정이기도 함.)

더 단순하게 설명하자면, 프론트엔드와 통신할 때 주고 받을 데이터의 틀을 작성하는 과정!!

• model을 생성함으로써 글을 작성할 공간을 만들어 놓았는데, 그래서 유저로부터 어떤 데이터를 받아서 작성할 것인지는 아직 안정함.
• 유저로부터 어떤 데이터를 받고 어떤 정보를 유저한테 보여줄 것인지를 serializer.py에 작성

📌 serializer 는 기본적으로 아래와 같이 작성하는데, model 에 앞서 작성한 모델 (데이터를 가져오고 저장할 모델) 을 명시하고 fields 에는 웹사이트 이용자로부터 받을 + 이용자에게 표시해줄 데이터를 명시함.

blog/serializers.py

from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = "__all__"   # ["title", "content"]와 같은 형태로 작성하면 해당 필드만 표시

• created_time 등은 어차피 django 가 내용을 채우기 때문에, 그냥 fields 에는 사용자로부터 받을 title, content 만 작성해도 됨.
• 그 경우 글 데이터를 프론트엔드에 전달할 때에도 title, content 만 넘겨주게 됨.

🎴 cf) 만약 프론트엔드로부터 받을 수도 있고, 안받을 수도 있는 데이터는 아래처럼 추가로 옵션을 작성해서 명시 가능

blog/models.py

from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = ["title", "content"]
        extra_kwargs = {"title": {"required": False, "allow_null": True}}

• 지금 당장은 사용하지 않을 예정이지만, 위와 같은 방식으로 필요한 데이터 여부를 명시할 수 있음을 참고할 것
• models.py 에 모델을 작성할 때에도 이를 명시할 수 있는데, models.py 와 serializer 에 아무런 명시도 하지 않을 경우 작성한 필드 전부 필수적으로 필요한 데이터로 인식함.

🎨 views 설정 (GET 요청)

views : 주소로 들어왔을때 실행될 내부의 작업 (db에 저장, db에서 가져오기) 을 지정

📌 views : 이용자 (프론트엔드) 로부터 요청 (+ 데이터) 을 받았을 때, 작동할 함수를 작성하는 곳

• 실생활 비유

  • 실생활에 비유를 해보자면, 우리가 동사무소에 주민등록증을 발급하러 가면, 민증 발급 창구에 가서 공무원에게 발급 서류를 제출함.
  • 그러면 공무원은 그 서류를 토대로 일정한 작업을 한 뒤에, 주민등록증을 발급해주게 됨.

• 위의 예시를 웹사이트에 비유

  • "우리가 (웹사이트 이용자가) 동사무소에 주민등록증을 발급하러 가면, 민증 발급 창구에 가서 (웹사이트 URL로) 공무원에게 발급 서류를 제출 (요청, Request) 함.
  • 그러면 공무원 (django) 은 그 서류 (요청에 포함된 데이터, Request Data) 를 토대로 일정한 작업 (views.py 에 작성된 함수를 실행) 을 한 뒤에, 주민등록증을 발급해주게 됨. (응답, Response)"

📌 django 를 통해 글을 쓰는 과정 (POST 요청) 안내

• 이 과정을 풀어서 설명하자면,

• 웹사이트 이용자가 (글을 작성하려면), 글 작성 URL 로 글 데이터를 포함해서 요청을 보냄
• 그러면 django 는 해당 url 에 대응하는 views.py 내부의 함수를 실행
• 이 views.py 내부의 함수는 글 데이터를 serializer 를 통해서 역직렬화 + 해당 글을 db 에 저장
• 글 작성 성공 여부를 응답으로 전달해주게 됨.

📌 지금은 우선 글을 가져오는 것 (GET 요청) 부터 먼저 진행!

• 이 과정을 풀어서 설명하자면,

  1. 웹사이트 이용자가 글 가져오기 URL 로 요청을 보내면,
  2. django 는 해당 url 에 대응하는 views.py 내부의 함수를 실행하고,
  3. 이 함수는 db 에 저장된 글들을 serializer 를 통해서 직렬화해서 글 데이터를 응답으로 전달

• 그러면 지금 views.py 에

  1. db 에 저장된 글을 가져오고
  2. 글을 직렬화하고,
  3. 그렇게 직렬화한 글 데이터가 포함된 응답을 return 하는 함수를 작성

📌 CBV (Class Based View)

• 특정 url 에 해당하는 views 함수를 하나의 클래스를 통해서 전부 작성하는 방식

  • BlogList 라는 클래스 안에 요청 Method 별로 함수를 생성
  • 똑같은 url 이라도 GET 방식의 요청이면 글을 db 에서 가져와서 보여주는 작업을 수행하고,
  • POST 방식의 요청이면 사용자가 보낸 데이터를 db 에 저장하는 작업을 수행하도록 작성 가능
    • 예시 : blog.com/posts/ 로 Get 요청을 보내면 작성된 글들을 받아올 수 있고, Post 요청을 보내면 글을 작성할 수 있음

blog/models.py

from rest_framework.views import APIView
from rest_framework.permissions import AllowAny
from rest_framework.response import Response
from rest_framework import status
from .models import Article
from .serializers import ArticleSerializer

# Create your views here.
class BlogList(APIView):
    # permission_classes : (이 클래스와 연결된) Url 로 요청을 보내는 것에 대해 권한을 설정
    # allowany : 누구나 요청을 보낼 수 있도록 하는 것
    permission_classes = [AllowAny] 

    def get(self, request):
        article = Article.objects.all() # db 에서 글 가져오기
        serialized_article_data = ArticleSerializer(article, many=True).data # 가져온 글 직렬화하기
        return Response(serialized_article_data, status=status.HTTP_200_OK) # 직렬화한 데이터 응답으로 보내기

• 우선은 get 요청부터 작성하는 것이므로, def get(self, request): 이라고 작성하고, 그 아래에 글을 가져와서 응답으로 전달하는 과정을 작성.

  • 이렇게 하면 자동으로 get 요청에 대응해서 지금 작성한 함수가 실행됨.

📌 django orm

• db에서 글을 과져오는 과정으로는 다음과 같은 방식들이 있음.

  1. 전체 데이터 가져오기

• *(models.py 에 작성한 모델명).objects.all()**

  # Article.objects.all()
  # Article 테이블에서 모든 데이터를 다 가져옴.

  2. 일부 데이터 가져오기(데이터 여러개)

• *(models.py 에 작성한 모델명).objects.filter(필드명="값")**

  Article.objects.filter(title="안녕")
  # Article 테이블에서 제목에 '안녕' 이라고 되어있는 '데이터들'만 가져옴

  3. 특정 데이터 하나 가져오기 (데이터 딱 하나)

• *(models.py 에 작성한 모델명).objects.get(필드명="값")**

  Article.objects.get(pk=1)
  # Article 테이블에서 id 가 1 인 (첫번째로 작성된) 글을 가져옴

📌 데이터 직렬화

• serializer 의 경우, 아래와 같은 형태로 사용해서 지금 가져온 데이터를 직렬화해줄 수 있음.

  (serializers.py 에 작성한 시리얼라이저이름)(데이터, many=True).data

  ArticleSerializer(article, many=True).data

📌 마지막으로는 직렬화한 데이터를 포함해서, 200 이라는 HTTP CODE 와 함께 response 형태로 응답함.

• 이러면 프론트엔드에서는 해당 글 데이터를 받아볼 수 있게 됨.

  return Response(serialized_article_data, status=status.HTTP_200_OK)

🎨 urls 설정

urls : 어떤 주소로 들어와야 글이 작성되거나 / 글을 보여줄 지

• urls.py 는 앞서 보았던 views.py 에 작성한 함수를 특정한 url 과 연결하는 과정을 수행하는 곳

• www.naver.com 로 들어가면 네이버 화면이 보여지듯, (서버주소)/blog/ 로 들어가면 글을 볼 수 있게 작성할 예정.

• urls.py 는 앱마다 하나씩 작성하고, 그렇게 작성된 것들을 config (프로젝트 폴더) 내부의 urls.py 에다가 몰아넣는 식으로 작성.

blog/urls.py

from django.urls import path
from blog.views import BlogList # 방금 작성한 views.py 내부의 클래스 import

urlpatterns = [
    path("", BlogList.as_view()),
]

config/urls.py

• config/urls.py 는 아래처럼 작성해서, blog/urls.py 내부의 url 로 접근하려면 무조건 blog/ 를 붙여야하도록 작성.

  • 만약 위의 blog/urls.py 에 글을 보기 위한 url 을 asd/라고 작성해놓고, config/urls.py 에 path("blog/", include("blog.urls")) 라고 작성했다면, 글을 보려면 (우리 서버주소)/blog/asd/ 로 접속해야 함.

from django.urls import path
from blog.views import BlogList # 방금 작성한 views.py 내부의 클래스 import

urlpatterns = [
    path("", BlogList.as_view()),
]

🎨 admin 설정 후 서버 실행

admin : 관리자 페이지

• 이를 이용하면 현재 models 에 등록된 테이블에 데이터를 쉽게 채울 수 있음.

blog/admin.py

from django.contrib import admin
from .models import Article

# Register your models here.
admin.site.register(Article) # 괄호 안에는 admin 페이지에서 관리할 모델명이 들어가야함

📌 관리자 계정 생성

Terminal에 입력

$ poetry run python manage.py createsuperuser

📌 서버 실행

Terminal에 입력

$ poetry run python manage.py runserver

• 이제 127.0.0.1:8000/admin 로 들어가서, 방금 만든 관리자 계정으로 로그인
• 아래 메뉴에 들어가서 글을 하나 추가

• 이제 127.0.0.1:8000/blog/ 에 들어가면 아래처럼 표시되며 방금 작성한 글이 확인됨.
  • 127.0.0.1:8000/blog/ 로 GET 요청을 보내면 해당 응답이 온다는 뜻.
    • id 는 글이 작성된 순서대로 1번부터 부여됨.

🎨 게시글 쓰기 (POST 요청 작성)

• 이제 게시글을 작성하기 위한 코드를 작성할텐데, 지금 게시글을 저장할 공간과 필요한 내용 (model/serializers) 는 이미 작성되어 있으니 views.py 만 추가로 작성

• POST 요청과 관련해서 앞서 언급했던 내용을 한번 더 정리

  1. 웹사이트 이용자가 (글을 작성하려면),
  2. 글 작성 URL (현재는 글 작성 URL, 가져오기 URL 이 동일함) 로 글 데이터를 포함해서 요청 전송
  3. 그러면 django 는 해당 url 에 대응하는 views.py 내부의 함수를 실행
  4. 이 views.py 내부의 함수는 글 데이터를 serializer 를 통해서 역직렬화 + 해당 글을 db 에 저장
  5. 글 작성 성공 여부를 응답으로 전달

• 위의 과정도 아래와 같은 코드로 표현 가능

    def post(self, request):
        article_serializer = ArticleSerializer(data=request.data) # 시리얼라이저(data=request.data) 이라고 하면 request.data(사용자가 보낸 데이터)를 역직렬화하겠다는 뜻 / (data=) 이 없이 그냥 () 라면 직렬화
        if article_serializer.is_valid(): # 유효성 검사 (시리얼라이저가 자체적으로 가지고 있는 기능, 우리가 커스텀할 수 있음)
            article_serializer.save() # 유효하다면 db 에 저장 (시리얼라이저가 자체적으로 가지고 있는 기능, 저장하는 과정도 우리가 커스텀 가능 -> 다음 시간에 할 예정)
            return Response({"message": "정상"}, status=status.HTTP_200_OK)
        return Response(article_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

blog/views.py를 아래처럼 수정

• 위의 함수를 추가한 것

class BlogList(APIView):
    permission_classes = [AllowAny] 

    def get(self, request):
        article = Article.objects.all()
        serialized_article_data = ArticleSerializer(article, many=True).data
        return Response(serialized_article_data, status=status.HTTP_200_OK)

    def post(self, request):
        article_serializer = ArticleSerializer(data=request.data)
        if article_serializer.is_valid():
            article_serializer.save()
            return Response({"message": "정상"}, status=status.HTTP_200_OK)
        return Response(article_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

🎨 postman 사용해보기

📌 postman : 우리가 만든 서버로 직접 get, post 요청 등을 보내볼 수 있도록 도와주는 프로그램

https://www.postman.com/downloads/ 접속 후 다운로드 및 설치

• 설치 완료 후 앱을 실행

  • Create Workspace 혹은 Collections > 생성한 Workspace 혹은 Collections 접속 > + 클릭

  

📌 GET 요청 : 주소에 localhost:8000/blog/ 라고 입력하고 send 버튼을 누르면, 하단 부분에 응답이 표시됨!

📌 POST 요청 : 글을 적는 것도 가능

1. 주소창 왼쪽의 선택 버튼을 눌러서 GET → POST 로 변경
2. 그 아래에서 Body 를 선택하신 뒤에, raw 를 클릭
3. 그 후에 raw 의 오른쪽에 있는 선택 버튼 (text 라고 되어있는) 을 눌러서 json 으로 변경
4. 이제 빈칸에다가 {"title”: “제목", “content”: “내용”} (글을 쓰기 위해 필요한 값들) 이라고 작성 후, send 버튼 클릭 → 글쓰기 완료!

• 다시 GET 요청으로 조회하여 정상 등록 여부 확인

🎨 게시글 하나만 보기/수정/삭제 (PUT / DELETE 요청 작성)

📌 게시글 하나만 보는 과정은 또 다른 url 과 view 를 통해서 진행할 수 있도록 작성

• (서버주소)/blog/ 로 요청을 보낸다면 글 리스트를 보는 것 (혹은 글을 작성) 이고,

• (서버주소)/blog/(글 번호) 로 요청 보낸다면 해당 번호의 글 하나만 조회 (혹은 글을 수정/삭제)

  • 서버주소/blog/1 과 같은 형식, 여기서 1은 글의 id이자 pk
  • pk 이기 때문에 1 이라는 숫자만으로 글 하나를 특정할 수 있는 것이고, 해당 글을 보여주게 되는 것

• blog/urls.py 에는 path("<int:pk>", BlogDetail.as_view()), 를 추가

  • 여기서 int:pk 는 글자 그대로의 url 이 아니라, url 에 int(정수형)인 값을 받을 건데, 그 값의 이름을 pk 라고 해서 views.py 에서 변수로 쓸 수 있도록 하겠다는 뜻

    • 서버주소/blog/1 라는 주소로 요청이 온다면, 이 1이라는 값을 pk 라고 이름 붙여서 views 에서 사용할 수 있도록 하겠다는 뜻
    • 서버주소/blog/2 라는 주소로 요청이 온다면, 이 2이라는 값을 pk 라고 이름 붙여서 views 에서 사용할 수 있도록 하겠다는 뜻

blog/urls.py

from django.urls import path
from blog.views import BlogList, BlogDetail   # BlogDetail 함수 추가


urlpatterns = [
    path("", BlogList.as_view()),
    path("<int:pk>", BlogDetail.as_view()),   # 해당 경로 추가

]

• 이제 BlogDetail 함수 작성

blog/views.py

class BlogDetail(APIView):
    permission_classes = [AllowAny]

    def get(self, request, pk): # url 에 있는 숫자를 pk 라는 변수로 받아옴
        article = Article.objects.get(pk=pk) # pk가 1이라면 글 id가 1인 글을 찾아서 가져옴
        serialized_article_data = ArticleSerializer(article).data # 해당 글을 직렬화함
        return Response(serialized_article_data, status=status.HTTP_200_OK) # 직렬화한 글 데이터를 응답으로 보냄

    def put(self, request, pk): # put 은 수정을 요청할 때 쓰는 Method 입니다
        article = Article.objects.get(pk=pk) # 기존의 글 데이터를 db 에서 찾아옴
        # 원래라면 여기서 권한 체크
        article_serializer = ArticleSerializer(article, data=request.data) # 기존의 글과 함께, 현재 유저가 보낸 수정할 데이터 (request.data) 를 명시
        if article_serializer.is_valid(): # 유효성 검사
            article_serializer.save() # 유효하다면 수정작업 완료
            return Response(article_serializer.data) # 수정한 글 데이터를 응답으로 보냄
        return Response(article_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, pk):
        article = Article.objects.get(pk=pk) # 글을 db 에서 찾아옴
        # 원래라면 여기서 권한 체크
        article.delete() # 해당 글을 db 에서 삭제함
        return Response(status=status.HTTP_204_NO_CONTENT)

📌 Postman으로 확인

• 아래와 같이 /글id번호 를 붙여서 보내면, 해당 글번호에 해당하는 것만 GET 하게 됨.

  • GET : 게시글 하나만 보기

• method를 PUT으로 변경하여 BODY 내용을 수정 후 보내면, 해당 글번호의 내용이 수정됨.

  PUT : 게시글 수정

• method를 DELETE로 변경하여 보내면, 해당 글이 삭제됨.

  DELETE : 게시글 삭제 정상 삭제 여부 확인

🌞 K번째수

🚊 문제 설명

• 배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다. 2에서 나온 배열의 3번째 숫자는 5입니다.

📢 배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.

🚊 제한사항

• array의 길이는 1 이상 100 이하입니다.
• array의 각 원소는 1 이상 100 이하입니다.
• commands의 길이는 1 이상 50 이하입니다.
• commands의 각 원소는 길이가 3입니다.

🚊 입출력 예

입출력 예 #1, 2

• [1, 5, 2, 6, 3, 7, 4]를 2번째부터 5번째까지 자른 후 정렬합니다. [2, 3, 5, 6]의 세 번째 숫자는 5입니다.
• [1, 5, 2, 6, 3, 7, 4]를 4번째부터 4번째까지 자른 후 정렬합니다. [6]의 첫 번째 숫자는 6입니다.
• [1, 5, 2, 6, 3, 7, 4]를 1번째부터 7번째까지 자릅니다. [1, 2, 3, 4, 5, 6, 7]의 세 번째 숫자는 3입니다.

📑 Code : 내꺼

📌 Logic 설명

1. 반복문을 돌면서 commands의 각 요소 command를 꺼내옴
2. command 내의 각 요소는 기존 array를 슬라이싱할 start, end, 그리고 슬라이싱된 리스트를 정렬 후 우리가 찾을 요소의 순서를 의미
3. 단, start, end, index는 순번이 아닌 Index No.을 의미하므로 그에 맞게 조정해줘야 함.
4. list comprehension을 이용하여 간단하게 작성
5. 위의 로직을 순서대로 구현

> code
def solution(array, commands):
    return  [sorted(array[start-1:end])[index-1] for start,end,index in commands]

📑 Code : 다른 사람꺼

-

• 없음

> code

💡 새롭게 알게된 점

📌 -

> code

🌞 가장 큰 수

🚊 문제 설명

• 0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.
• 예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.

📢 0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

🚊 제한사항

• numbers의 길이는 1 이상 100,000 이하입니다.
• numbers의 원소는 0 이상 1,000 이하입니다.
• 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

🚊 입출력 예

📑 Code : 내꺼

📌 Logic 설명

1. 주어진 숫자들을 앞자리 수가 큰 것부터 앞에 배열해야 그것들을 이어 붙였을 때 가장 큰 수가 나옴.
2. 그것을 위해 주어진 리스트의 각 숫자들의 타입을 int 가 아닌 str 으로 변환
3. 그 다음에 리스트를 역순으로 정렬을 하게 되면, 앞자리 숫자가 큰 것부터 정렬하게 됨.
4. 그러나 위의 방식대로 하게 되면 3, 30, 34가 주어졌을 때 34, 30, 3 순서로 정렬하게 되고 이는 34, 3, 30 을 이어 붙인 숫자보다 작게됨. (34303 < 34330)
5. 이를 방지하기 위해 각 숫자를 3번 이어 붙여서 최소 3자리 이상의 숫자를 만들고, 그 값들의 크기를 비교하여 역순으로 정렬하면 됨.

   • 왜냐하면, 제한 사항에 numbers의 원소는 1000 이하의 숫자라는 내용이 있기 때문
   • ['3', '30', '34']의 경우, 각 요소를 3번씩 이어 붙이면 '333', '303030', '343434' 이 되고, 이를 문자열의 크기라는 기준으로 역순 정렬하면 '343434' > '333' > '303030' 순이 되기 때문에 리스트 정렬 결과가 ['34', '3', 30']이 됨.

• 즉, 1 > 2 > 5 순서대로 동작하게 코드를 작성하면 됨.

> code
def solution(numbers):
    # 주어진 리스트의 각 요소를 문자열로 변환
    numbers = list(map(str, numbers))
    # lambda 함수를 이용하여 주어진 리스트를 각 요소를 3번씩 이어붙인 결과의 역순으로 정렬하게 됨.
    numbers.sort(key=lambda x: x * 3, reverse=True)
    # 리스트 내의 문자열을 이어붙인 뒤 정수로 변환 후 다시 문자열로 변환
    return str(int(''.join(numbers)))

📑 Code : 다른 사람꺼

💡 두 수의 크기를 비교하여 1/0/-1을 반환하는 comparator 함수 생성

💡 functools 모듈의 cmp_to_key 함수를 이용하여 내가 만든 함수로 커스텀 정렬

• return 값은 항상 1/0/-1 이어야 함.

  • 1 : 정렬 기준대로 앞으로 가기 위해 True를 의미
  • -1 : 정렬 기준과 반대로 가서 뒤로 가기 위해 False를 의미
  • 0 : 0은 아예 정렬 기준에 해당되지 않아 그대로 있을 때를

💡 참고 :

[Python] 커스텀한 기준으로 sort()하기 : cmp_to_key()

> code
import functools

# 커스텀 정렬 함수 comparator 생성
def comparator(a,b):
    print(f"a:{a}")
    print(f"b:{b}")
    # t1 : 두 문자열의 수를 순서대로 이어 붙인 결과
    t1 = a+b
    # t2 : 두 문자열의 수를 반대로 이어 붙인 결과
    t2 = b+a

    print(f"int(t1) > int(t2) : {int(t1) > int(t2)}")
    print(f"int(t1) < int(t2) : {int(t1) < int(t2)}")
    print(f"비교 결과 : {result}")
    print("==============================================")

    # t1의 숫자값이 더 크다면 1 : 더 큰 값이 뒤로 이동
    # t2의 숫자값이 더 크다면 -1  : 더 큰놈이 앞으로 이동
    # 두 값이 동일하다면 0 : 순서는 기존과 동일
    return (int(t1) > int(t2)) - (int(t1) < int(t2)) 

def solution(numbers):
    n = [str(x) for x in numbers]
    n = sorted(n, key=functools.cmp_to_key(comparator),reverse=True)
    answer = str(int(''.join(n)))
    return answer

🔎 예시를 통한 확인

• 위의 코드에는 print 문이 모두 달려있는데, 예시 코드를 돌려보면 아래와 같은 결과가 나옴. 예시를 통한 출력 내용 확인

  numbers = [3, 30, 34, 5, 9]
  solution(numbers)
  
  

--- 출력 결과 ---

a:5 b:9 int(t1) > int(t2) : False int(t1) < int(t2) : True 비교 결과 : -1 ============================================== a:34 b:5 int(t1) > int(t2) : False int(t1) < int(t2) : True 비교 결과 : -1 ============================================== a:30 b:34 int(t1) > int(t2) : False int(t1) < int(t2) : True 비교 결과 : -1 ============================================== a:3 b:30 int(t1) > int(t2) : True int(t1) < int(t2) : False 비교 결과 : 1 ============================================== a:3 b:5 int(t1) > int(t2) : False int(t1) < int(t2) : True 비교 결과 : -1 ============================================== a:3 b:34 int(t1) > int(t2) : False int(t1) < int(t2) : True 비교 결과 : -1 ============================================== a:3 b:30 int(t1) > int(t2) : True int(t1) < int(t2) : False 비교 결과 : 1 ==============================================

--- return 값 --- '9534330'

<br>

---

<br>

## 🌞 [H-Index](https://school.programmers.co.kr/learn/courses/30/lessons/42747)


### 🚊 `문제 설명`
>- **[H-Index](https://en.wikipedia.org/wiki/H-index)**는 과학자의 생산성과 영향력을 나타내는 지표입니다.
>- 어느 과학자의 `H-Index`를 나타내는 값인 `h`를 구하려고 합니다. `위키백과1`에 따르면, `H-Index`는 다음과 같이 구합니다.
>- 어떤 과학자가 발표한 논문 `n`편 중, `h`번 이상 인용된 논문이 `h`편 이상이고 나머지 논문이 `h`번 이하 인용되었다면 `h`의 최댓값이 이 과학자의 `H-Index`입니다.

📢 어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 `citations`가 매개변수로 주어질 때, 이 과학자의 `H-Index`를 `return` 하도록 `solution` 함수를 작성해주세요.

### 🚊 `제한사항`
>- 과학자가 발표한 논문의 수는 `1편` 이상 `1,000편` 이하입니다.
>- 논문별 인용 횟수는 `0회` 이상 `10,000회` 이하입니다.

### 🚊 `입출력 예`

![](https://velog.velcdn.com/images/brown_eyed87/post/a8d45d8e-77ed-4e5f-867a-a1f332f04993/image.png)

`입출력 예`
>- 이 과학자가 발표한 논문의 수는 `5`편이고, 그중 `3`편의 논문은 `3`회 이상 인용되었습니다.
>- 그리고 나머지 `2`편의 논문은 `3`회 이하 인용되었기 때문에 이 과학자의 `H-Index`는 `3`입니다.

### 📑 `Code : 내꺼 `

<span style="color: #FA8072">**`Code 1`**</span>

📌 `Logic` 설명
> 코드에 직접 적음

```python
> code 1
def solution(citations):
    # 인용이 적게 된 논문들부터 서칭하기 위해 정렬
    citations.sort()
    # idx : 나보다 인용된 수가 적은 논문의 수
    # citation : 논문의 인용된 횟수
    for idx , citation in enumerate(citations):
        # 인용된 횟수가 남은 논문의 수(나를 포함한)보다 크거나 같으면
        if citation >= len(citations) - idx :
            # 인용된 논문의 숫자를 return
            return len(citations) - idx
    # 논문이 1편밖에 없는 경우
    return 0

Code 2

📌 Logic 설명

여기 사이트 내용 참고

> code 2
def solution(citations):
    # 인용이 많이 된 논문들부터 서칭하기 위해 역순으로 정렬
    citations.sort(reverse=True)
    print(f"citations : {citations}")
    print("=======~~=======")
    for idx, citation in enumerate(citations):
        print(f"idx : {idx}")
        print(f"citation : {citation}")
        print("========")
        # H-Index를 idx라고 가정
        # citation : 나머지 논문들이 인용된 횟수 중 최댓값
        # 나머지 논문들이 인용된 횟수 중 최댓값이 idx번 이하인 최초의 경우를 찾음.
        if idx >= citation:
            # idx를 반환
            return idx
    print(f"citations : {citations}")
    print("--------")
    # citations를 모두 서칭하였는데 H-Index 조건을 만족하는 값이 없다면
    # citations의 길이보다 작은 값으로 리스트를 2갈래로 구분지을 수 없다는 것이기 때문에
    # citations의 길이가 우리가 찾는 H-Index
    return len(citations)

🔎 예시를 통한 확인

• 위의 코드에는 print 문이 모두 달려있는데, 예시 코드를 돌려보면 아래와 같은 결과가 나옴. 예시를 통한 출력 내용 확인

  citations = [6, 5, 5, 5, 3, 2, 1, 0]
  solution(citations)
  
  

--- 출력 결과 ---

citations : [6, 5, 5, 5, 3, 2, 1, 0] =======~~======= idx : 0 citation : 6 ======== idx : 1 citation : 5 ======== idx : 2 citation : 5 ======== idx : 3 citation : 5 ======== idx : 4 citation : 3 ========

--- return 값 --- '9534330'

<br>


### 📑 `Code : 다른 사람꺼`

<span style="color: #FA8072">**`Code 1`**</span>

- 문제 조건을 제일 직관적으로 표현한 코드
- 그러나, 주어진 `citations` 배열을 모두 순회해야 하므로 좋은 코드는 아님.

```python
> code
    def solution(citations):
        # 최대값을 구하기 위해 max_라는 변수를 사용
        # 조건을 만족하는 값이 생길때마다 최대값으로 갱신하여 
        max_ = 0
        # 인용된 논문 수가 많은 것부터 탐색하기 위해 역순으로 정렬
        citations.sort(reverse=True)
        # index를 1부터 시작하는 이유는, 나를 포함한 값을 계산하기 위함
        for index, citation in enumerate(citations, start=1):
            # index : 지금 citation보다 인용된 횟수가 크거나 같은 논문의 수
            print(f"index : {index}")
            # citation : 논문의 인용된 횟수
            print(f"citation : {citation}")
            # (현재 논문의 인용 회수)가 (현재 논문의 인용된 횟수 이상으로 인용된 논문의 수)보다 더 크거나 같다면
            if citation >= index:
                # H_index가 될 수 있는 후보로 갱신
                # index는 1부터 점차 커지고, 최종적으로 만족하는 값이 max_에 저장되므로
                # 반복문 종료 후 결국 max_ 값은 H-Index를 만족하는 값이 됨.
                max_ = index
                print(f"answer : {answer}")
        return answer

Code 2

• 현재 논문보다 인용이 많이 된 논문의 횟수를 바로 체크하기 위해 주어진 배열을 역순으로 정렬
• enumerate의 시작을 1로 맞춤으로써, 배열의 idx 요소 값 각각이 바로 나보다 인용이 많이된 논문의 횟수를 뜻하게 됨.

> code
    def solution(citations):
        citations.sort(reverse=True)
        answer = max(map(min, enumerate(citations, start=1)))
        return answer

• 예시

  • citation = [1,6,2,4,0] 인 경우, 역순으로 정렬하면 [6,5,4,1,0]이 되고,
  • enumerate(citations, start=1) 함수 로 인해 (1,6), (2,5), (3,4), (4,1), (5,0) 와 같은 객체가 생성됨.
  • map(min, enumerate(citations, start=1))의 결과, (1,2,3,1,0)이라는 객체가 생성됨.
  • 결과적으로 3이 return됨.

• 해석

  • 위의 코드는 각각의 (idx, citation) 객체에 대해 x = 1부터 시작하여 y = index, y = citation 라고 하는 일차 함수를 그린 후, 각각의 x값에 대해 y값의 min 값들만 체크한 다음에 그 중에서 max 값을 찾은 결과임.
  • https://ssuamje.tistory.com/47 → 이 블로그에 관련된 내용이 더 자세히 적혀 있으니 참고할 것.

💡

📌

• API는 정의 및 프로토콜 집합을 사용하여 두 소프트웨어 구성 요소가 서로 통신할 수 있게 하는 메커니즘

예시 기상청의 소프트웨어 시스템에는 일일 기상 데이터가 들어 있을 때, 휴대폰의 날씨 앱은 API를 통해 이 시스템과 "대화"하고 휴대폰에 매일 최신 날씨 정보를 표시

✅ API의 의미

• API는 Application Programming Interface(애플리케이션 프로그램 인터페이스)의 줄임말
• API의 맥락에서 애플리케이션이라는 단어는 고유한 기능을 가진 모든 소프트웨어
• 인터페이스는 두 애플리케이션 간의 서비스 계약이라고 할 수 있습니다.
• 이 계약은 요청과 응답을 사용하여 두 애플리케이션이 서로 통신하는 방법을 정의함.
• API 문서에는 개발자가 이러한 요청과 응답을 구성하는 방법에 대한 정보가 포함되어 있음.

✅ API 작동 방식

• API 아키텍처는 일반적으로 클라이언트와 서버 측면에서 설명됨.
• 클라이언트 : 요청을 보내는 애플리케이션
• 서버 : 응답을 보내는 애플리케이션

  • 날씨 예에서 기상청의 날씨 데이터베이스는 서버이고 모바일 앱은 클라이언트에 해당.

API가 생성된 시기와 이유에 따라 API는 네 가지 방식으로 작동 가능.

📋 SOAP API

• 이 API는 단순 객체 접근 프로토콜을 사용
• 클라이언트와 서버는 XML을 사용하여 메시지를 교환

  • 과거에 더 많이 사용되었으며 유연성이 떨어지는 API

📋 RPC API

• 이 API를 원격 프로시저 호출이라고 함.
• 클라이언트가 서버에서 함수나 프로시저를 완료하면 서버가 출력을 클라이언트로 다시 전송

📋 Websocket API

• Websocket API는 JSON 객체를 사용하여 데이터를 전달하는 또 다른 최신 웹 API 개발
• WebSocket API는 클라이언트 앱과 서버 간의 양방향 통신을 지원
• 서버가 연결된 클라이언트에 콜백 메시지를 전송할 수 있어 REST API보다 효율적

📋 REST API

• 오늘날 웹에서 볼 수 있는 가장 많이 사용되고 유연한 API
  
• 클라이언트가 서버에 요청을 데이터로 전송
• 서버가 이 클라이언트 입력을 사용하여 내부 함수를 시작하고 출력 데이터를 다시 클라이언트에 반환

🌞 REST API

• REST는 Representational State Transfer의 줄임말

  • REST : 클라이언트가 서버 데이터에 액세스하는 데 사용할 수 있는 GET, PUT, UPDATE, DELETE 등의 함수 집합

• 클라이언트와 서버는 HTTP를 사용하여 데이터를 교환
  
• REST API의 주된 특징은 무상태

  • 무상태는 서버가 요청 간에 클라이언트 데이터를 저장하지 않음을 의미

• 서버에 대한 클라이언트 요청은 웹 사이트를 방문하기 위해 브라우저에 입력하는 URL과 유사함.
• 서버의 응답은 웹 페이지의 일반적인 그래픽 렌더링이 없는 일반 데이터

✅ REST API의 이점

REST API는 다음과 같은 네 가지 주요 이점을 제공

1. 통합

• API는 새로운 애플리케이션을 기존 소프트웨어 시스템과 통합하는 데 사용됨.
• 그러면 각 기능을 처음부터 작성할 필요가 없기 때문에 개발 속도가 향상됨.
• API를 사용하여 기존 코드를 활용 가능.

2. 혁신

• 새로운 앱의 등장으로 전체 산업이 바뀔 수 있음.
• 기업은 신속하게 대응하고 혁신적인 서비스의 신속한 배포를 지원해야 함.
• 전체 코드를 다시 작성할 필요 없이 API 수준에서 변경하여 이를 수행 가능.

3. 확장

• API는 기업이 다양한 플랫폼에서 고객의 요구 사항을 충족할 수 있는 고유한 기회를 제공

  • 예를 들어 지도 API를 사용하면 웹 사이트, Android, iOS 등을 통해 지도 정보를 통합 가능.

• 어느 기업이나 무료 또는 유료 API를 사용하여 내부 데이터베이스에 유사한 액세스 권한을 부여 가능

4. 유지 관리의 용이성

• API는 두 시스템 간의 게이트웨이 역할을 함.
• API가 영향을 받지 않도록 각 시스템은 내부적으로 변경해야 함.
• 이렇게 하면 한 시스템의 향후 코드 변경이 다른 시스템에 영향을 미치지 않음.

✅ REST API 보호 방안

모든 API는 적절한 인증 및 모니터링을 통해 보호되어야 함.

REST API를 보호하는 두 가지 주요 방법

*1. 인증 토큰 *

• 인증 토큰은 사용자에게 API 호출을 수행할 수 있는 권한을 부여하는 데 사용됨.
• 인증 토큰은 사용자가 자신이 누구인지 확인하고 해당 특정 API 호출에 대한 액세스 권한이 있는지 확인

  • 예를 들어, 이메일 서버에 로그인하면 이메일 클라이언트는 보안 액세스를 위해 인증 토큰을 사용

*2. API 키 *

• API 키는 API를 호출하는 프로그램 또는 애플리케이션을 확인

  • 즉, 애플리케이션을 식별하고 애플리케이션에 특정 API 호출을 수행하는 데 필요한 액세스 권한이 있는지 확인

• API 키는 토큰만큼 안전하지 않지만 사용량에 대한 데이터를 수집하기 위해 API 모니터링을 허용함.

  • 다른 웹 사이트를 방문할 때 브라우저 URL에서 긴 문자열과 숫자를 본 적이 있을 것임.
  • 이 문자열은 웹 사이트가 내부 API 호출을 수행하는 데 사용하는 API 키임.

🌞 Django REST Framework

Django vs Django REST Framework

• 기존의 DJango 프로젝트 : 기존 자체적인 웹 템플릿에게 바로 데이터를 전달
• Django REST Framework를 사용 시,JSON과 같은 양식으로 다양한 플랫폼의 클라이언트에게 데이터를 제공해줄 수 있는 API 서버 프로젝트가 만들어지게 되는 것

Django REST Framework

• Django를 기반으로 REST API 서버를 만들기 위한 라이브러리

• API는 웹 뿐만 아니라 앱과 같은 다양한 플랫폼의 백엔드 서비스를 위해 JSON 과 같은 규격화된 데이터를 제공.

• DJango REST Framework는 얻디까지나 Django를 기반으로 한 라이브러리이기 때문에 전반적으로 Django의 개발 흐름을 따라감.

  • REST API가 되기 위해 달라지는 부분들이 조금 있음. → DJango REST Framework 학습 시, 그 부분이 무엇인지에 초점을 두고 정리하고 숙지하는 과정을 반드시 거쳐야 함!!

🌞 REF

Site

AWS : RESTful API란 무엇입니까?

Book

백엔드를 위한 Django REST Framework with 파이썬

✅ 추가 학습 예정

REST API의 이해와 설계 #1-개념 소개 Django Rest Framework

🌞 같은 숫자는 싫어

🚊 문제 설명

• 배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다.
• 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다.
• 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다. 예를 들면,

  • arr = [1, 1, 3, 3, 0, 1, 1] 이면 [1, 3, 0, 1] 을 return 합니다.
  • arr = [4, 4, 4, 3, 3] 이면 [4, 3] 을 return 합니다.

📢 배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.

🚊 제한사항

• 배열 arr의 크기 : 1,000,000 이하의 자연수
• 배열 arr의 원소의 크기 : 0보다 크거나 같고 9보다 작거나 같은 정수

🚊 입출력 예

입출력 예 #1, 2

• 문제의 예시와 같습니다.

📑 Code : 내꺼

📌 Logic 설명

1. 중복을 제거한 요소를 담을 새로운 리스트 answer를 빈 리스트로 지정하고, 문제에서 주어진 array의 0 번째 요소를 담음
2. 주어진 array의 1 번째 요소부터 마지막 요소까지 반복문을 돌면서
3. answer의 마지막 요소와 현재 array의 요소를 비교하여 동일하지 않은 경우에만 array의 요소를 answer에 담음
4. 반복문 종료 후 answer를 return

> code
def solution(arr):
    answer = [arr[0]]
    length = len(arr)
    for i in range(1,length):
        if answer[-1] != arr[i]:
            answer.append(arr[i])
    return answer

📑 Code : 다른 사람꺼

정용님 코드

• 변수 지정도 깔끔하고, 초기 비교 대상을 -1로 지정함으로써 첫 번째 요소에 대해 예외적으로 코드를 작성해야 했던 내 코드보다 클-린한듯하여 좋았음.

> code
def solution(arr):
    # 중복을 제거한 요소를 담을 빈 리스트 생성
    answer = []

    # 기존 array의 요소와 비교할 대상을 front라는 변수로 지정 후 -1을 할당
    #   왜 -1인가?에 대해 반드시 기억해야 함!! 자주 쓰이는 기법
    #   문제의 '제한사항'에서 「 0 ≤ 배열 arr의 원소의 크기 ≤ 9 」라는 조건을 주었기 때문
    #    array의 어떤 요소와도 겹치지 않는 값이기 때문에 비교 대상으로 적절함
    front = -1

    # 반복문을 돌면서
    for item in arr:
        # 만약 array 내의 요소(item)가 비교 대상(front)와 다른 경우에만
        if front != item:
            # answer에 해당 요소를 추가
            answer.append(item)
            # 비교 대상을 answer의 마지막 요소인 item으로 갱신
            front  = item
        return answer

프로그래머스 코드

• 반복문을 돌면서 현재 요소와 그 뒷 요소를 비교하며 값이 다른 경우에만 새로운 리스트에 담는 방식으로 작성한 코드

> code
def solution(arr):
    return [arr[i] for i in range(len(arr)) if [arr[i]] != arr[i+1:i+2]]

💡 새롭게 알게된 점

📌 마지막 요소를 확인할 때, 리스트의 indexing이 아닌, slicing으로 코드를 작성함으로써 에러 발생을 방지하였다는 점에 대해 감탄했음.

• 리스트는 존재하지 않는 범위에 대해 slicing하는 경우, 빈 리스트[]를 반환
• 반면에, 존재하지 않는 범위의 index에 대해 indexing하는 경우, IndexError 발생

> code
    array = [1,2,3,4,5]
    print(array[6])       #   IndexError: list index out of range
    print(array[6:])      #   []

🌞 올바른 괄호

🚊 문제 설명

• 괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다.
• 예를 들어

  ()() 또는 (())() 는 올바른 괄호입니다. )()( 또는 (()( 는 올바르지 않은 괄호입니다.

📢 ( 또는 ) 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 True를 return 하고, 올바르지 않은 괄호이면 False를 return 하는 solution 함수를 완성해 주세요.

🚊 제한사항

• 문자열 s의 길이 : 100,000 이하의 자연수
• 문자열 s는 ( 또는 ) 로만 이루어져 있습니다.

🚊 입출력 예

입출력 예 #1, 2, 3, 4

• 문제의 예시와 같습니다.

📑 Code : 내꺼

Code 1

📌 Logic 설명

1. stack으로 활용할 빈 리스트 생성
2. 주어진 배열 s의 요소에 대해 반복문을 돌면서
3. 열린 괄호'('인 경우에는 stack에 담고
4. 그렇지 않는 경우(닫힌 괄호')')에는 stack의 상황을 보고 판단 4-1. stack이 비어 있는 경우에는 짝을 맞출 열린 괄호'('가 없는 것이기 때문에 False를 반환하고 종료 4-2. stack이 비어 있지 않은 경우에는 stack의 마지막 요소가 열린 괄호'('일 때 stack의 마지막 요소를 추출

   • 왜냐하면, stack의 마지막 요소인 열린 괄호'('와 주어진 배열에서 현재 요소인 닫힌 괄호')'가 짝을 맞춰 사라지기 때문

> code 1
def solution(s):
    stack = []
    for i in s:
        if i == "(":
            stack .append(i)
        else:
            if not stack:
                return False
            elif stack[-1] == "(":
                stack.pop()
    # stack이 비어 있지 않은지의 유무를 참/거짓으로 return
    #   stack이 비었다면 True, 비어있지 않다면 False를 반환
    return not stack 

Code 2

📌 Logic 설명

1. 열린 괄호 '('에는 +1, 닫힌 괄호 ')'에는 -1에 해당하는 점수를 부여
2. 열린 괄호와 닫힌 괄호가 순서대로 짝을 맞추면 점수는 +1 되었다가 -1되어서 결과적으로 0점으로 종료
3. 만약 점수가 음수로 가게 된다면, 열린 괄호 없이 닫힌 괄호가 나왔다는 말이기 때문에 무조건 짝을 맞추지 못하였다는 것을 의미하므로 False를 반환해야 함.

> code 1
def solution(s):
    score = 0
    for w in s:
        if score < 0:
            return 0
        else:
            if w == "(":
                score += 1 
            elif w == ")":
                score -= 1
    # score이 0점과 동일한지 유무를 참/거짓으로 반환
    #   score가 0점이면 참이므로 True를 반환
    return score == 0

📑 Code : 다른 사람꺼

• s 내의 요소가 닫힌 괄호')'인 경우, stack으로 사용하는 리스트 st의 마지막에 어떤 요소가 있는 지와 무관하게 pop 메서드를 실행 💡 단, pop 메서드를 실행하였는데 에러가 발생했다면, st가 빈 리스트라는 뜻이기 때문에 닫힌 괄호와 짝을 맞출 요소가 남아있지 않다는 뜻이 되어 False를 반환

> code
def is_pair(s):
    st = list()
    for c in s:
        if c == '(':
            st.append(c)

        if c == ')':
            try:
                st.pop()
            except IndexError:
                return False

    return len(st) == 

프로그래머스 코드

• 반복문을 돌면서 현재 요소와 그 뒷 요소를 비교하며 값이 다른 경우에만 새로운 리스트에 담는 방식으로 작성한 코드

> code
def solution(arr):
    return [arr[i] for i in range(len(arr)) if [arr[i]] != arr[i+1:i+2]]

🌞 기능개발

🚊 문제 설명

• 프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다.
• 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.
• 또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.

📢 먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

🚊 제한사항

• 작업의 개수(progresses, speeds 배열의 길이)는 100개 이하입니다.
• 작업 진도는 100 미만의 자연수입니다.
• 작업 속도는 100 이하의 자연수입니다.
• 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다.
• 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

🚊 입출력 예

입출력 예 #1

• 첫 번째 기능은 93% 완료되어 있고 하루에 1%씩 작업이 가능하므로 7일간 작업 후 배포가 가능합니다.
• 두 번째 기능은 30%가 완료되어 있고 하루에 30%씩 작업이 가능하므로 3일간 작업 후 배포가 가능합니다.
• 하지만 이전 첫 번째 기능이 아직 완성된 상태가 아니기 때문에 첫 번째 기능이 배포되는 7일째 배포됩니다.
• 세 번째 기능은 55%가 완료되어 있고 하루에 5%씩 작업이 가능하므로 9일간 작업 후 배포가 가능합니다.

• 따라서 7일째에 2개의 기능, 9일째에 1개의 기능이 배포됩니다.

입출력 예 #2

• 모든 기능이 하루에 1%씩 작업이 가능하므로, 작업이 끝나기까지 남은 일수는 각각 5일, 10일, 1일, 1일, 20일, 1일입니다.
• 어떤 기능이 먼저 완성되었더라도 앞에 있는 모든 기능이 완성되지 않으면 배포가 불가능합니다.

• 따라서 5일째에 1개의 기능, 10일째에 3개의 기능, 20일째에 2개의 기능이 배포됩니다.

📑 Code : 내꺼

📌 Logic 설명

코드에 직접 적음

> code
# 올림 함수 계산을 위해 math 모듈 사용
from math import ceil

def solution(progresses, speeds):
    # 작업 별 필요한 요일을 계산하여 그 수치를 담을 빈 리스트 생성
    day_required = []

    # 작업의 진척율, 개발 속도를 zip 함수로 묶어서 각각의 요소들에 대해 반복문을 실행
    for p, s in zip(progresses, speeds):
        # 잔여 작업 일수 : 남은 진척율을 개발 속도로 나누어 올림 계산한 결과
        # 그 결과를 day_required 리스트에 추가
        day_required.append(ceil((100-p)/s))
    # 마지막 요소까지 계산을 해야 하기 때문에, 해당 리스트의 최대값보다 하나 더 큰 값을 다시 day_required 리스트에 추가
    day_required.append(max(day_required)+1)

    # 아래 반복문을 통해 한꺼번에 배포가 되어야 하는 작업들을 담을 빈 리스트 temp 생성
    temp = []
    # 정답을 담을 빈 리스트 answer 생성
    answer = []

    # 위에서 day_required 리스트의 마지막 요소에 내가 지정한 값을 추가해두었기 때문에
    # 반복문을 실행할 범위를 day_required의 전체 요소의 개수에서 1만큼을 제외시킴.
    for i in range(len(day_required)-1):
        # day_required 리스트에서 0번째부터 i번째 요소까지의 최대값이 (i+1)요소보다 작을 때에만
        if max(day_required[:i+1]) < day_required[i+1]:
            # temp 리스트에 day_required의 현재 요소를 추가
            temp.append(day_required[i])
            # answer 리스트에는 temp 리스트의 개수(이번 배포 시 배포될 기능의 총 개수)를 추가
            answer.append(len(temp))
            # 다음 순서를 실행하기 위해, temp 리스트 초기화
            temp.clear()

        # day_required 리스트에서 0번째부터 i번째 요소까지의 최대값이 (i+1)요소보다 크거나 같다면
        else:
            # temp 리스트에 day_required의 현재 요소를 추가
            temp.append(day_required[i])

    return answer

📑 Code : 다른 사람꺼

상봉님 코드

• defaultdict 함수 사용이 아주 탁월했음.

  • key : value 형태의 요소를 담은 dictionary 자료형을 생성 시, 기존 key값이 없는 요소에 대해 자료형에 추가하는 경우 사용하면 좋음.
  • 일반적인 dict 자료형은 기존에 보유하고 있지 않은 key값에 대해 key:value를 넣어주려고 하면 error가 발생.

> code
from collections import defaultdict

def solution(progresses, speeds):

    # 역순으로 바꿔서 가장앞의 작업이 스택상 맨 위로 오도록 설정
    progresses = progresses[::-1]
    speeds = speeds[::-1]

    # [(55, 5), (30, 30), (93, 1)] 식으로 현재진행량과 작업속도를 묶어줌
    suc = list(zip(progresses,speeds))
    print(suc)

    # 키값이 없을때 해당 키값으로 value를 추가하면 오류가 발생하지않는 defaultdict() 함수 이용
    dic = defaultdict(int)
    print(dic)

    # 몇일이 경과했는지 저장할 day 선언
    day = 1

    # 모든 작업이 스택을 빠져나갈때까지 반복(작업완료)
    while len(suc) != 0:
        # 날짜 x 속도가 100프로를 넘는다면 맨위의 작업을 완료처리
        if suc[-1][0] + suc[-1][1]*day >= 100:
            print(suc[-1][0] + suc[-1][1]*day)
            print(day)
            suc.pop()
            print(suc)
            dic[day] += 1
        # 작업이 완료되지 않았다면 그냥 day만 1증가
        else:
            day += 1
        print(dic)

    return list(dic.values())

프로그래머스 코드

• 반복문을 돌면서 현재 요소와 그 뒷 요소를 비교하며 값이 다른 경우에만 새로운 리스트에 담는 방식으로 작성한 코드

> code
def solution(progresses, speeds):
    # [현재 작업, 누적 배포 예정 기능 수] 를 리스트 형태의 요소로 담을 빈 리스트 Q를 생성
    # Q는 결과적으로 2차원 리스트 형태가 됨.
    Q=[]
    # 작업의 진척율, 개발 속도를 zip 함수로 묶어서 각각의 요소들에 대해 반복문을 실행
    for p, s in zip(progresses, speeds):
        # Q가 비었거나, 가장 마지막 배포 예정 작업의 소요 일수가 이번 순서 작업의 소요 일수보다 작다면
        if len(Q)==0 or Q[-1][0] < -((p-100)//s):
            # Q에 이번 순서의 작업의 소요 일수를 누적 배포 예정 기능 수는 1개(본인꺼)로 지정하여 담음.
            Q.append([-((p-100)//s),1])
        # Q에 어떤 요소가 있고, 가장 마지막 배포 예정 작업의 소요 일수가 이번 순서 작업의 소요 일수보다 크거나 같다면
        else:
            # 가장 마지막 배포 예정의 작업 배포 시, 해당 기능을 함께 배포해야 하므로
            # 누적 배포 예정 기능 수에 +1 해줌.
            Q[-1][1]+=1
    # 배포 예정 작업은 Q의 각 요소 내의 1번째 요소에 해당하므로 아래와 같이 list Comprehension을 이용하여 리스트에 담아 반환
    return [q[1] for q in Q]

💡 새롭게 알게된 점

📌 올림 계산을 위해 math 모듈의 ceil 함수를 사용하지 않고, -((p-100)//s) 의 형태로 계산한 점.

• 파이썬에서 // 연산자의 의미 : 나누기 연산 후 소수점 버림

  • p-100은 음수가 됨.
  • (p-100)//s는 음수에서 내림을 한 결과이며, 이는 (100-p)/s 를 올림한 결과와 절대값이 동일함.
  • -(p-100)//s는 작업의 진척율을 개발 속도로 나눈 후 올림한 결과와 동일

🌞 프린터

🚊 문제 설명

• 일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다.
• 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다.
• 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다.
• 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.

   1. 인쇄 대기목록의 가장 앞에 있는 문서(J)를 대기목록에서 꺼냅니다.
   2. 나머지 인쇄 대기목록에서 J보다 중요도가 높은 문서가 한 개라도 존재하면 J를 대기목록의 가장 마지막에 넣습니다.
   3. 그렇지 않으면 J를 인쇄합니다.

• 예를 들어, 4개의 문서(A, B, C, D)가 순서대로 인쇄 대기목록에 있고 중요도가 2 1 3 2 라면 C D A B 순으로 인쇄하게 됩니다.
• 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 알고 싶습니다. 위의 예에서 C는 1번째로, A는 3번째로 인쇄됩니다.

📢 현재 대기목록에 있는 문서의 중요도가 순서대로 담긴 배열 priorities와 내가 인쇄를 요청한 문서가 현재 대기목록의 어떤 위치에 있는지를 알려주는 location이 매개변수로 주어질 때, 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 return 하도록 solution 함수를 작성해주세요.

🚊 제한사항

• 현재 대기목록에는 1개 이상 100개 이하의 문서가 있습니다.
• 인쇄 작업의 중요도는 1~9로 표현하며 숫자가 클수록 중요하다는 뜻입니다.
• location은 0 이상 (현재 대기목록에 있는 작업 수 - 1) 이하의 값을 가지며 대기목록의 가장 앞에 있으면 0, 두 번째에 있으면 1로 표현합니다.

🚊 입출력 예

입출력 예 #2

• 문제의 예시와 같습니다.

입출력 예 #1

• 6개의 문서(A, B, C, D, E, F)가 인쇄 대기목록에 있고 중요도가 1 1 9 1 1 1 이므로 C D E F A B 순으로 인쇄합니다.

📑 Code : 내꺼

사실 프로그래머스 다른 사람 풀이 보고 공부한 후, 숙지된 내용을 정리하였음.

📌 Logic 설명

1. 중복을 제거한 요소를 담을 새로운 리스트 answer를 빈 리스트로 지정하고, 문제에서 주어진 array의 0 번째 요소를 담음
2. 주어진 array의 1 번째 요소부터 마지막 요소까지 반복문을 돌면서
3. answer의 마지막 요소와 현재 array의 요소를 비교하여 동일하지 않은 경우에만 array의 요소를 answer에 담음
4. 반복문 종료 후 answer를 return

> code
from collections import deque

def solution(priorities, location):
    # 기존 배열에서 순서와 요소값을 tuple 형태의 요소로 갖는 새로운 리스트를 생성
    # deque 함수를 이용하여 리스트를 덱으로 변환
    # 명칭을 queue라고 지은 이유는, 선입선출의 방식으로 사용할 예정이기 때문
    # 아래 while문을 보면, 제일 앞에 있는 요소를 뽑은 후 조건 충족 시 다시 맨 뒤로 넣음.
    queue = deque([(idx, priority) for idx, priority in enumerate(priorities)])
    # 문제의 규칙대로 주어진 자료형을 정렬 후, 
    # 인쇄를 요청한 문서의 인쇄 순서를 확인할 변수를 answer로 지정하여 0을 할당.
    answer = 0
    # 조건을 만족할 때까지 반복

    while True:
        # queue의 제일 처음 요소를 뽑아서 target_data로 지정
        # popleft 함수를 사용했기 때문에, queue에서 해당 요소는 제거된 상태
        target_data = queue.popleft()

        # target_data의 중요도가 queue 내의 중요도보다 하나라도 작다면
        if any(target_data[1] < current_data[1] for current_data in queue):
            # 현재 데이터를 다시 queue 에 추가 
            queue.append(target_data)

        # target_data의 중요도가 나머지 모든 data의 중요도보다 높다면
        else:
            # 인쇄 순서를 하나 늘려줌.
            answer += 1
            # 「priorities에서 target_data의 중요도의 idx」가 「priorities에서 우리가 찾는 중요도의 idx」와 같다면
            if target_data[0] == location :
                # 인쇄 순서를 출력
                return answer

🔎 내가 못 푼 이유

1번째

> code
        priorities = [2,3,3,2,9,3,3]
        location = 3

위의 코드의 세부 작업 순서를 정리한 것이 다음과 같음.

priorities의 변화 및 인쇄 작업을 서술
(우리가 찾는 "location = 3"에 해당하는 2는 "2"로 표시)
    2,3,3,"2",9,3,3
    3,3,"2",9,3,3,2
    3,"2",9,3,3,2,3
    "2",9,3,3,2,3,3
    9,3,3,2,3,3,"2"
    9 인쇄     - 1번째 인쇄
    3 인쇄     - 2번째 인쇄
    3 인쇄     - 3번째 인쇄
    2,3,3,"2"
    3,3,"2",2
    3 인쇄     - 4번째 인쇄
    3 인쇄     - 5번째 인쇄
    "2" 인쇄   - 6번째 인쇄
    2 인쇄     - 7번째 인쇄

    따라서, return 값은 6이 됨.

그런데 나는 일단, 최대값이 맨 앞으로 오면 거기서 더이상의 정렬이 없을 것이라 생각하였음.

나의 잘못된 생각

priorities의 변화 및 인쇄 작업을 서술
(우리가 찾는 "location = 3"에 해당하는 2는 "2"로 표시)
    2,3,3,"2",9,3,3
    3,3,"2",9,3,3,2
    3,"2",9,3,3,2,3
    "2",9,3,3,2,3,3
    9,3,3,2,3,3,"2"
    9 인쇄     - 1번째 인쇄
    3 인쇄     - 2번째 인쇄
    3 인쇄     - 3번째 인쇄
    3 인쇄     - 4번째 인쇄
    3 인쇄     - 5번째 인쇄
    2 인쇄     - 6번째 인쇄
    "2" 인쇄   - 7번째 인쇄


    따라서, return 값은 7이 됨.

Logic 흐름 정리 1. 최대값이 맨 앞에 올때까지 rotate를 반복한 다음 그 값을 인쇄한 후에 2. 나머지 값들에 대해 또다시 최대값이 맨 앞에 올때까지 rotate를 반복 후 그 값을 인쇄. 3. 모든 요청이 인쇄된 후에 작업은 종료됨.

2번째

문제 조건 중, 아래 내용을 max 함수로 써서 작성하는 경우, 시간 초과의 문제와 ValueError가 발생.

2. 나머지 인쇄 대기목록에서 J보다 중요도가 높은 문서가 한 개라도 존재하면 J를 대기 목록의 가장 마지막에 넣습니다.

> 코드 구현
        (... 중간 생략 ...)
            while priorities:
                target = priorities.popleft()
                # 틀린 코드
                if target[1] < max(priority[1] for priority in priorities):
                # 바른 코드
                if any(target[1] < priority[1] for priority in priorities):
         (... 중간 생략 ...)

1. max 함수로 최대값을 구하는 경우에는 priorities의 모든 요소를 다 서칭해야 하기 때문에 시간이 오래 걸림.
2. popleft를 통해 priorities가 빈 리스트가 되게 되면, ValueError 발생

❗❗❗ any 함수에 대해 아래에 정리해두었으니 잊지 말고 다음에는 꼭 써먹자...

💡 새롭게 알게된 점

📌 all 함수와 any 함수

• 파이썬 공식 홈페이지에 가보면 all 함수와 any 함수에 대해 코드로 설명되어 있음.

all

• 인자로 반복 가능한 (iterable) 자료형을 받음.
• 인자로 받은 데이터의 모든 요소가 True인 경우, True를 반환
• 인자로 받은 요소 중 하나라도 False이면 False를 반환
• 인자로 받은 요소가 비어있으면 True

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any

• 인자로 반복 가능한 (iterable) 자료형을 받음.
• 인자로 받은 데이터의 요소 중 하나라도 True인 경우, True를 반환
• 인자로 받은 요소 중 모두 False이면 False를 반환
• 인자로 받은 요소가 비어있으면 False

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

📑 Code : 다른 사람꺼

강사님 코드

• queue 자료형을 활용하지 않고, while문과 for문을 활용한 풀이

> code
def solution(priorities, location):
    # answer는 인쇄 순서를 의미
    answer = 1
    # 대기 목록에 원래 순서를 포함시켜서 살펴보기 위해 enumerate 함수 사용
    queue = [[i,v] for i,v in enumerate(priorities)]
    # print(queue)

    while True:
        # 대기 목록에서 제일 앞에 있는 문서를 뽑음
        check = queue.pop(0)
        # 뽑은 문서가 중요도가 가장 높은지 확인
        # -> 나머지 인쇄 대기 목록에서 중요도가 높은 문서가 한 개라도 있는지 여부를 확인
        if check[1] == max(priorities):
            # 그 문서가 우리가 찾는 문서인지?
            if check[0] == location:
                맞으면 인쇄 순서를 반환
                return answer
            # 그 문서가 우리가 찾는 문서가 아니라면
            else:
                # 현재 중요도가 가장 높은 문서가 인쇄되고 없어지므로 대기 목록에서 제거
                priorities.remove(max(priorities))
                # 인쇄 순서가 하나 뒤로 밀리기 때문에 (+1)처리
                answer += 1
        # 뽑은 문서가 중요도가 가장 높지 않다면
        else:
            # 다시 대기 목록에 넣어줌.
            queue.append(check)

    return answer

📑 Code : 다른 사람꺼

정용님 코드

• queue 자료형을 활용하지 않고, while문과 for문을 활용한 풀이

> code
def solution(priorities, location):
    answer = 0

    while True:
        # 최대값
        max_num = max(priorities)
        print(f"max_num : {max_num}")

        for i in range(len(priorities)):
            # 최대값이 일치하면
            if max_num == priorities[i]:
                # 해당 답에 대한 순위 +1
                answer += 1
                # 최대값을 찾는 순위에서 제외
                priorities[i] = 0
                print(f"priorities : {priorities}")

                # 최대값을 다시 구함
                max_num = max(priorities)
                print(f"max_num : {max_num}")
                print(f"answer : {answer}")

                #  i의 위치와 일치하면 answer 반환
                if i == location:
                    return answer

🔎 예시를 통한 확인

예시를 통한 출력 내용 확인

priorities = [2,3,3,2,9,3,3]
location = 3

solution(priorities, location)

--- 출력 결과 ---

(while문 시작) max_num : 9

(for문 시작) priorities : [2, 3, 3, 2, 0, 3, 3] max_num : 3 answer : 1

priorities : [2, 3, 3, 2, 0, 0, 3] max_num : 3 answer : 2

priorities : [2, 3, 3, 2, 0, 0, 0] max_num : 3 answer : 3

(while문 다시 시작) max_num : 3

(for문 시작) priorities : [2, 0, 3, 2, 0, 0, 0] max_num : 3 answer : 4

priorities : [2, 0, 0, 2, 0, 0, 0] max_num : 2 answer : 5

priorities : [2, 0, 0, 0, 0, 0, 0] max_num : 2 answer : 6

--- return 값 --- 6

**`프로그래머스 코드`**
- 

```python
> code

🌞 다리를 지나는 트럭

🚊 문제 설명

• 트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다.
• 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다.
• 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다.
• 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.

• 예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

• 따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.

📢 solution 함수의 매개변수로 다리에 올라갈 수 있는 트럭 수 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭 별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.

🚊 제한사항

• bridge_length는 1 이상 10,000 이하입니다.
• weight는 1 이상 10,000 이하입니다.
• truck_weights의 길이는 1 이상 10,000 이하입니다.
• 모든 트럭의 무게는 1 이상 weight 이하입니다.

🚊 입출력 예

📑 Code : 내꺼

📌 Logic 설명

내가 직접 푼 것은 아니고, 다른 사람 풀이 보고 학습 후 해당 풀이를 보지 않고 풀었음.

• 기존 코드를 개선

> code
def solution(bridge_length, weight, truck_weights):
    # truck이 지나갈 bridge를 리스트로 생성.
    # bridge의 각 요소는 해당 위치의 무게를 의미함.
    bridge = [0] * bridge_length
    # bridge의 무게의 총 합을 미리 계산
    # 아래에서 계산이 필요할 경우에 sum(bridge)로 계산해도 되지만, 그렇게 할 경우에는 시간 초과가 발생.
    # sum 함수는 시간 복잡도가 O(N)이기 때문.
    bridge_weight_sum = 0
    # 총 소요 시간을 계산할 변수를 sec이라 지정하고 0을 할당.
    # second의 약자
    sec = 0

    # bridge가 남아 있으면 계속해서 반복
    while bridge:
        # 1초가 지나감.
        sec += 1
        # bridge의 제일 앞에 있는 무게는 다리를 빠져 나감.
        bridge_weight_sum -= bridge.pop(0)
        # print(f"1번째 bridge : {bridge}")

        # 만약 다리를 건너야 할 트럭이 아직 존재하는 경우에
        if truck_weights:
            # 현재 다리 위의 총 무게와 대기 중인 첫 번째 트럭의 무게의 합이 다리가 견딜 수 있는 무게보다 작거나 같다면
            if bridge_weight_sum + truck_weights[0] <= weight:
                # 다리의 마지막 위치에 대기 중인 첫 번째 트럭을 추가
                bridge_weight_sum += truck_weights[0]
                # 다리의 총 무게는 그 트럭의 무게만큼 늘려줌
                bridge.append(truck_weights.pop(0))
                # print(f"2번째 bridge : {bridge}")
            # 만약, 그 트럭이 다리에 올라오게 되었을 때 다리가 견디지 못한다면
            else:
                # 다리의 마지막 자리를 빈 무게로 채운다.
                bridge.append(0)
                # print(f"3번째 bridge : {bridge}")

    return sec

🔎 예시를 통한 확인

• 위의 코드에는 print 문이 모두 달려있는데, 예시 코드를 돌려보면 아래와 같은 결과가 나옴.

예시를 통한 출력 내용 확인

bridge_length = 5
weight = 5
truck_weights = [2,2,2,2,1,1,1,1]
solution(bridge_length, weight, truck_weights)


--- 출력 결과 ---

sec : 1 1번째 bridge : [0, 0, 0, 0] 2번째 bridge : [0, 0, 0, 0, 2]

sec : 2 1번째 bridge : [0, 0, 0, 2] 2번째 bridge : [0, 0, 0, 2, 2]

sec : 3 1번째 bridge : [0, 0, 2, 2] 3번째 bridge : [0, 0, 2, 2, 0]

sec : 4 1번째 bridge : [0, 2, 2, 0] 3번째 bridge : [0, 2, 2, 0, 0]

sec : 5 1번째 bridge : [2, 2, 0, 0] 3번째 bridge : [2, 2, 0, 0, 0]

sec : 6 1번째 bridge : [2, 0, 0, 0] 2번째 bridge : [2, 0, 0, 0, 2]

sec : 7 1번째 bridge : [0, 0, 0, 2] 2번째 bridge : [0, 0, 0, 2, 2]

sec : 8 1번째 bridge : [0, 0, 2, 2] 2번째 bridge : [0, 0, 2, 2, 1]

sec : 9 1번째 bridge : [0, 2, 2, 1] 3번째 bridge : [0, 2, 2, 1, 0]

sec : 10 1번째 bridge : [2, 2, 1, 0] 3번째 bridge : [2, 2, 1, 0, 0]

sec : 11 1번째 bridge : [2, 1, 0, 0] 2번째 bridge : [2, 1, 0, 0, 1]

sec : 12 1번째 bridge : [1, 0, 0, 1] 2번째 bridge : [1, 0, 0, 1, 1]

sec : 13 1번째 bridge : [0, 0, 1, 1] 2번째 bridge : [0, 0, 1, 1, 1]

sec : 14 1번째 bridge : [0, 1, 1, 1]

sec : 15 1번째 bridge : [1, 1, 1]

sec : 16 1번째 bridge : [1, 1]

sec : 17 1번째 bridge : [1]

sec : 18 1번째 bridge : []

--- return 값 --- 18

<br>


### 📑 `Code : 다른 사람꺼`

**`상봉님 코드`**
- ..

```python
> code
def solution(bridge_length, weight, truck_weights):
    count = 0            # 경과 시간
    weight_sum = 0       # 다리 위의 트럭들의 무게의 합
    bridge = []          # 다리 위에 있는 트럭들

    while truck_weights:
        count += 1

        # 트럭이 다리 위로 올라갈 수 있는 조건
        if ((weight_sum + truck_weight[0]) <= weight and len(bridge) <= bridge_length):
            # 트럭을 다리 위에 올리고
            bridge.append(truck_weights.pop())
            # 올린 트럭의 무게를 총 무게에 더한다.
            weight_sum += bridge[-1]
        else:
            # 다리 위로 올라갈 수 없다면 빈 공간으로 채운다.
            bridge.append(0)

        # 경과한 시간이 다리 길이보다 크면, 다리에서 나온 트럭들의 무게를 빼준다.
        if count >= bridge_length:
            weight_sum -= bridge.pop(0)

    # 총 경과 시간 + 다리 위에 있는 트럭들이 지나갈 시간
    return count + bridge_length

프로그래머스 코드

• 아직 이 코드는 정확히 이해를 하지 못함.

> code
def solution(bridge_length, weight, truck_weights):
    t = 0
    on = []  # (weight, stayed)
    while truck_weights or on:
        for i, e in enumerate(on):
            on[i] = (e[0], e[1] + 1)
            print(f"1번째 on : {on}")
        on = list(filter(lambda x: x[1] < bridge_length + 1, on))
        print(f"2번째 on : {on}")

        weight_sum = 0
        for e in on:
            weight_sum += e[0]
            print(weight_sum)

        if truck_weights:
            if weight_sum + truck_weights[0] <= weight:
                on.append((truck_weights.pop(0), 1))
                print(f"3번째 on : {on}")
        t += 1
        print(f"t : {t}")
        # print(str(t)+":"+str(on))
    return t

🔎 예시를 통한 확인

• 위의 코드에는 print 문이 모두 달려있는데, 예시 코드를 돌려보면 아래와 같은 결과가 나옴. 예시를 통한 출력 내용 확인

  bridge_length = 5
  weight = 5
  truck_weights = [2,2,2,2,1,1,1,1]
  solution(bridge_length, weight, truck_weights)
  
  

--- 출력 결과 ---

2번째 on : [] 3번째 on : [(2, 1)] t : 1 1번째 on : [(2, 2)] 2번째 on : [(2, 2)] weight_sum : 2 3번째 on : [(2, 2), (2, 1)] t : 2 1번째 on : [(2, 3), (2, 1)] 1번째 on : [(2, 3), (2, 2)] 2번째 on : [(2, 3), (2, 2)] weight_sum : 2 weight_sum : 4 t : 3 1번째 on : [(2, 4), (2, 2)] 1번째 on : [(2, 4), (2, 3)] 2번째 on : [(2, 4), (2, 3)] weight_sum : 2 weight_sum : 4 t : 4 1번째 on : [(2, 5), (2, 3)] 1번째 on : [(2, 5), (2, 4)] 2번째 on : [(2, 5), (2, 4)] weight_sum : 2 weight_sum : 4 t : 5 1번째 on : [(2, 6), (2, 4)] 1번째 on : [(2, 6), (2, 5)] 2번째 on : [(2, 5)] weight_sum : 2 3번째 on : [(2, 5), (2, 1)] t : 6 1번째 on : [(2, 6), (2, 1)] 1번째 on : [(2, 6), (2, 2)] 2번째 on : [(2, 2)] weight_sum : 2 3번째 on : [(2, 2), (2, 1)] t : 7 1번째 on : [(2, 3), (2, 1)] 1번째 on : [(2, 3), (2, 2)] 2번째 on : [(2, 3), (2, 2)] weight_sum : 2 weight_sum : 4 3번째 on : [(2, 3), (2, 2), (1, 1)] t : 8 1번째 on : [(2, 4), (2, 2), (1, 1)] 1번째 on : [(2, 4), (2, 3), (1, 1)] 1번째 on : [(2, 4), (2, 3), (1, 2)] 2번째 on : [(2, 4), (2, 3), (1, 2)] weight_sum : 2 weight_sum : 4 weight_sum : 5 t : 9 1번째 on : [(2, 5), (2, 3), (1, 2)] 1번째 on : [(2, 5), (2, 4), (1, 2)] 1번째 on : [(2, 5), (2, 4), (1, 3)] 2번째 on : [(2, 5), (2, 4), (1, 3)] weight_sum : 2 weight_sum : 4 weight_sum : 5 t : 10 1번째 on : [(2, 6), (2, 4), (1, 3)] 1번째 on : [(2, 6), (2, 5), (1, 3)] 1번째 on : [(2, 6), (2, 5), (1, 4)] 2번째 on : [(2, 5), (1, 4)] weight_sum : 2 weight_sum : 3 3번째 on : [(2, 5), (1, 4), (1, 1)] t : 11 1번째 on : [(2, 6), (1, 4), (1, 1)] 1번째 on : [(2, 6), (1, 5), (1, 1)] 1번째 on : [(2, 6), (1, 5), (1, 2)] 2번째 on : [(1, 5), (1, 2)] weight_sum : 1 weight_sum : 2 3번째 on : [(1, 5), (1, 2), (1, 1)] t : 12 1번째 on : [(1, 6), (1, 2), (1, 1)] 1번째 on : [(1, 6), (1, 3), (1, 1)] 1번째 on : [(1, 6), (1, 3), (1, 2)] 2번째 on : [(1, 3), (1, 2)] weight_sum : 1 weight_sum : 2 3번째 on : [(1, 3), (1, 2), (1, 1)] t : 13 1번째 on : [(1, 4), (1, 2), (1, 1)] 1번째 on : [(1, 4), (1, 3), (1, 1)] 1번째 on : [(1, 4), (1, 3), (1, 2)] 2번째 on : [(1, 4), (1, 3), (1, 2)] weight_sum : 1 weight_sum : 2 weight_sum : 3 t : 14 1번째 on : [(1, 5), (1, 3), (1, 2)] 1번째 on : [(1, 5), (1, 4), (1, 2)] 1번째 on : [(1, 5), (1, 4), (1, 3)] 2번째 on : [(1, 5), (1, 4), (1, 3)] weight_sum : 1 weight_sum : 2 weight_sum : 3 t : 15 1번째 on : [(1, 6), (1, 4), (1, 3)] 1번째 on : [(1, 6), (1, 5), (1, 3)] 1번째 on : [(1, 6), (1, 5), (1, 4)] 2번째 on : [(1, 5), (1, 4)] weight_sum : 1 weight_sum : 2 t : 16 1번째 on : [(1, 6), (1, 4)] 1번째 on : [(1, 6), (1, 5)] 2번째 on : [(1, 5)] weight_sum : 1 t : 17 1번째 on : [(1, 6)] 2번째 on : [] t : 18

--- return 값 --- 18

### 💡 새롭게 알게된 점


📌 

<br>

---

<br>

## 🌞 [주식가격](https://school.programmers.co.kr/learn/courses/30/lessons/42584)


### 🚊 `문제 설명`

📢 초 단위로 기록된 주식가격이 담긴 배열 `prices`가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 `return` 하도록 `solution` 함수를 완성하세요.


### 🚊 `제한사항`
>- prices의 각 가격은 1 이상 10,000 이하인 자연수입니다.
>- prices의 길이는 2 이상 100,000 이하입니다.

### 🚊 `입출력 예`

![](https://velog.velcdn.com/images/brown_eyed87/post/317acc77-c5fd-4d29-8aae-57f31ebd990e/image.png)


`입출력 예 설명`
>- 1초 시점의 ₩1은 끝까지 가격이 떨어지지 않았습니다.
>- 2초 시점의 ₩2은 끝까지 가격이 떨어지지 않았습니다.
>- 3초 시점의 ₩3은 1초뒤에 가격이 떨어집니다. 
따라서 1초간 가격이 떨어지지 않은 것으로 봅니다.
>- 4초 시점의 ₩2은 1초간 가격이 떨어지지 않았습니다.
>- 5초 시점의 ₩3은 0초간 가격이 떨어지지 않았습니다.


### 📑 `Code : 내꺼 `

📌 `Logic` 설명
> 코드에 직접 적음

```python
> code
from collections import deque

def solution(prices):
    length = len(prices)
    # 가격이 떨어지지 않은 기간은 몇 초인지를 기록할 리스트를 생성
    # 초기 값은 모두 0으로 셋팅
    answer = [0] * length

    # 리스트 전체를 반복하면서
    for i in range(length):
        # i번째 요소의 다음부터 끝에 있는 모든 요소들을 탐색
        for j in range(i+1, length):
            # 다음 요소로 넘어가서 조건을 만족하는 경우에 answer의 i번째 요소에 1초를 추가
            # 이 코드가 if문보다 위에 있는 이유는 본인보다 뒤에 어떤 비교대상이 있는 경우에
            # 그 대상이 나보다 크든 작든 간에 1초동안은 가격이 떨어지지 않은 것으로 간주할 것이기 때문임.
            answer[i] +=1
            # 만약 나보다 가격이 떨어진 요소를 발견하게 되면
            if prices[i] > prices[j]:
                # 반복문을 멈추고 빠져나감
                break
    return answer

📑 Code : 다른 사람꺼

강사님 코드

• '오큰수' 문제 풀이 방식 활용
• stack을 활용

  • 주어진 요소를 차례대로 하나씩 뽑아서 stack에 담았다가 조건을 만족하면 제거
  • 주식 가격이 떨어졌으면 그 떨어진 시간을 계산 후 stack에서 제거

> code
def solution(prices):
    # 각각의 주식가격마다 가격이 떨어지지 않은 기간을 담을 리스트를 생성
    # 기초 시간은 모두 0초로 셋팅
    answer = [0]*len(prices)
    # 비교의 기준이 될 요소의 index를 담을 빈 리스트를 stack으로 활용
    stack = [] 

    # 주식가격 리스트에 대해 반복문을 돌면서 아래 내용을 확인
    for i in range(len(prices)):
        # 비교 기준이 아직 남아 있고, 그런데 어딘가에서 주식 가격이 떨어졌다면
        while stack and prices[stack[-1]] > prices[i]:
            # stack에서 현재 비교 기준 주식가격의 위치를 뽑아옴
            # 주식이 떨어진 시각을 갱신하기 위함
            s = stack.pop()
            # 주식 가격이 떨어진 위치와 현재 비교 기준의 주식가격의 위치의 차이를 구함
            # 가격이 떨어지지 않은 기간을 담은 리스트에서 비교 기준의 위치의 시간을 갱신
            answer[s] = i-s
        # 비교 기준이 남아있지 않거나, 비교 기준이 있더라도 그 다음 요소보다 가격이 떨어지지 않았다면
        # 그 다음 요소를 비교 기준 리스트에 대기시킴
        stack.append(i)

    # 주식 가격이 떨어지지 않은 요소들만 stack에 남아있는 상황이므로
    # 각각의 요소들에 대해 주식 가격이 떨어지지 않은 시간을 계산하면 됨.
    while stack:
        # stack에서 제일 앞에 있는 요소(index 값임)들을 꺼내서
        s = stack.pop()
        # 그 위치의 주식가격이 떨어지지 않은 시간을 계산
        # 전체 리스트의 요소의 개수에서 나를 포함하여 나보다 왼쪽에 있는 요소의 개수만큼을 뺄셈
        # s는 index이고, index가 의미하는 바가 나보다 왼쪽에 있는 요소의 개수이므로
        # 자기 자신인 1개만큼을 포함시킨 (s+1)이 바로 '나를 포함하여 나보다 왼쪽에 있는 요소'의 개수를 의미
        answer[s] = len(prices)-(s+1)

    return answer

📑 Code : 다른 사람꺼

프로그래머스 코드

> code
def solution(prices):
    # stack으로 활용할 빈 리스트 생성
    # stack에 들어가는 요소: [본인의 index, 본인의 price]
    # 즉, stack은 2차원 리스트 형태로 구성될 예정
    stack = []
    # 가격이 떨어지지 않은 기간은 몇 초인지를 기록할 리스트를 생성
    # 초기 값은 모두 0으로 셋팅
    answer = [0] * len(prices)

    # 리스트 전체에 대해 반복문을 돌면서
    for i in range(len(prices)):
        # print(f"i : {i}")
        # stack에 어떤 요소가 있고, 
        # stack내의 마지막 요소(기준 요소)의 price가 현재 i번째 대상의 price보다 크다면
        #  └ 이말 인즉, 주식 가격이 떨어진 것을 의미함
        while stack and stack[-1][1] > prices[i]:
            # stack의 마지막 요소(기준 요소)를 추출
            # 기준 요소의 index를 past에 할당
            # 기준 요소의 price는 이미 바로 위의 while문에서 써먹었기 때문에 더이상 쓸일이 없어서 _ 에 할당
            past, _ = stack.pop()
            # print(f"past : {past}")
            # print(f"_ : {_}")
            # 기준 요소의 주식 가격이 떨어지지 않은 기간을 갱신
            # i - past의 의미 : i번째 대상의 위치(주식 가격이 떨어진 위치) - 기준 요소의 위치
            answer[past] = i - past
            # print(f"answer : {answer}")
        # stack에 빈 요소가 없거나 
        # stack의 마지막 요소의 price보다 i번째 대상의 price가 더 크거나 같다면
        # i번째 대상의 요소를 [요소의 index, 요소의 주식 가격] 의 형태로 stack에 추가
        stack.append([i, prices[i]])
        # print(f"stack : {stack}")

    # 위의 과정까지 거치면, 주식 가격이 떨어지지 않은 요소들은 stack에 남아 있음
    # 이제 stack에 남은 요소들에 대해 반복문을 돌면서
    for i, s in stack:
        # i번째 요소의 주식 가격이 떨어지지 않은 기간을 계산하여 갱신
        # 주식 가격이 떨어지지 않은 기간 = 배열의 전체 길이 - 본인의 index
        # `본인의 index` 가 '나보다 앞에 있는 요소의 개수'를 뜻한다는 점을 이용
        answer[i] = len(prices) - 1 - i
        # print(f"answer : {answer}")
    return answer

🔎 예시를 통한 확인

• 위의 코드에는 print 문이 모두 달려있는데, 예시 코드를 돌려보면 아래와 같은 결과가 나옴.

예시를 통한 출력 내용 확인

prices = [1,2,3,2,3]
solution(prices)


--- 출력 결과 ---

(for문 시작)
i : 0
stack : [[0, 1]]

i : 1 stack : [[0, 1], [1, 2]]

i : 2 stack : [[0, 1], [1, 2], [2, 3]]

i : 3 (while문 시작) past : 2 _ : 3 answer : [0, 0, 1, 0, 0] (while문 끝) stack : [[0, 1], [1, 2], [3, 2]]

i : 4 stack : [[0, 1], [1, 2], [3, 2], [4, 3]]

(2번째 for문 시작) answer : [4, 0, 1, 0, 0] answer : [4, 3, 1, 0, 0] answer : [4, 3, 1, 1, 0] answer : [4, 3, 1, 1, 0]

--- return 값 --- [4, 3, 1, 1, 0]

```

💡 새롭게 알게된 점

📌 리스트에서 해당 요소의 index가 의미하는 것이 리스트 내에서 본인보다 앞에 있는 요소의 개수 를 뜻하기도 한다는 점!!

🚀 003. HDD와 SSD의 차이

🏰 보조 기억 장치

• 보조 기억 장치는 전원이 꺼져 있을 때도 정보를 유지
• 주 기억 장치는 정보 저장 용량이 한정적인 데다 전원이 꺼지면 내용이 사라짐

🛴 보조 기억 장치의 종류

• 공통적인 특징

  • 메모리보다 많은 정보를 저장
  • 휘발성을 띠지 않아서 드라이브에 저장된 정보는 전력 공급이 없더라도 유지됨. ▶ 데이터, 명령어, 다른 모든 정보는 보조 기억 장치에 장기간 저장되고, 주 기억 장치로는 일시적으로만 옮겨짐.

• 용량의 크기

  • 1바이트는 대부분 일반적인 영어 텍스트 표현에서 알파벳 문자 1개를 저장

📌 하드 디스크(하드 드라이브)

• 자기 디스크는 회전하는 금속 표면에 있는 자성 물질의 미세한 영역이 자성을 띠는 방향을 설정하여 정보를 저장
• 데이터는 동심원을 따라 나 있는 트랙에 저장되며, 디스크는 트랙 간에 이동하는 센서를 이용하여 데이터를 읽고 씀

  • 오래된 컴퓨터가 작동할 때 들리는 윙윙거리고 딸각거리는 소리는 디스크가 센서를 금속 표면의 적절한 위치로 옮기면서 내는 소리
  • 디스크 표면은 고속으로(분당 5,400회 이상) 회전함
  • 디스크는 용량 면에서 RAM보다 바이트당 100배 정도 저렴하지만, 정보에 접근하는 속도는 더 느림
  • 디스크 드라이브가 금속 표면의 특정 트랙에 접근하는 데는 약 1/100초가 걸림.
  • 접근하고 나면 데이터는 초당 약 100MB의 속도로 전송됨

📌 SSD

• SSD는 회전하는 기계 장치 대신, 플래시 메모리를 사용함.
• 플래시 메모리는 비휘발성을 띔

  • 전원이 꺼져 있어도 개별 소자에 전하를 유지하는 회로에 정보가 전하 형태로 저장됨.
  • 저장된 전하를 읽어 값이 무엇인지 확인 가능하며, 삭제하고 새 값으로 덮어쓰기도 가능

• 플래시 메모리는 기존의 디스크 저장 장치보다 더 빠르고 가볍고 안정적임

  • 떨어뜨려도 고장이 덜 나고, 전략을 더 적게 사용하므로 휴대전화/카메라 등에 사용됨
  • 일반적인 노트북용 SSD는 250 ~ 500GB 정도를 저장

💡 디스크 드라이브는 컴퓨터의 논리적 구조와 물리적 구현 간의 차이를 보여주는 좋은 예

• 윈도우의 파일 탐색기나 맥OS의 파인더 같은 프로그램은 드라이브의 내용을 폴더와 파일의 계층 구조로 표시함.

• 데이터는 회전하는 기계 장치, 움직이는 부품이 없는 집적회로 또는 완전히 다른 형태의 장치에 저장됨.

• 드라이브라는 하드웨어와 파일시스템이라는 운영체제의 소프트웨어가 합작하여 조직화된 구조를 만들어 냄.

• 데이터를 저장하는 장치라면 완전히 다른 물리적 수단을 사용하더라도 이와 동일한 구조를 제공

  ex CD-ROM/DVD, USB, 카메라, 이동식 메모리 카드 → 이는 컴퓨팅 곳곳에 스며들어 있는 아이디어인 추상화의 좋은 예

  • 추상화는 물리적인 구현의 세부 사항을 숨김.

• 파일 시스템은 다양한 기술의 물리적 작동 방식과 관계없이 그 내용을 사용자에게 파일과 폴더의 계층 구조로 보혀줌

📌 다른 장치들

• 입력 장치

  ex 마우스, 키보드, 터치스크린, 마이크, 카메라, 스캐너

• 출력 장치

  ex 디스플레이, 프린터, 스피커

• 네트워킹 구성 요소

  ex 와이파이, 블루투스

• 시각, 청각, 또는 다른 면에서 접근성을 겪는 사용자를 위한 다양한 보조 장치도 있음

• 장치의 물리적인 속성은 대개 더 낮은 가격으로 더 작은 패키지에 더 많은 기능을 제공하는 방향으로 빠르게 변해 왔음

  • 이러한 장치들이 어떻게 단일 기기로 합쳐지고 있는 지에도 주목해야 함
  • 스마트폰은 노트북과 추상적인 아키텍처는 같지만, 크기와 소모 전력에 제약이 있어서 구현 방법은 크게 다름

🚀 004. 가로세로 1cm 프로세서 칩

• 하드웨어 장치들의 내부는 과거 와 비교했을 때 많은 발전된 모습을 발견할 수 있다.

  • 예를 들어, SD카드는 겉보기에 차이는 없으나 용량은 100배까지 늘어났으며, 컴퓨터 부품이 올라가 있는 회로 기판에서는 부품의 수가 더 적어졌다.
  • 왜냐하면 20년 전보다 많은 회로가 부품 내부에 들어가 있고, 배선이 더 미 세하며, 연결 핀의 수가 더 많고 훨씬 더 조밀하게 배치되어 있기 때문이다.

• 1990년대 말에 사용되던 데스크톱 PC의 회로 기판을 살펴보면, 프로세서와 메모리 같은 부품은 기판에 장착되거나 꽂혀있으며 회로 기판 반대쪽에 인쇄된 전선으로 연결된다.

• 컴퓨터의 전자 회로는 몇 가지 기본 소자가 매우 많이 모여 만들어진다.

🏰 논리게이트

• 컴퓨터의 전자 회로에서 가장 중요한 기본 소자
• 한 개나 두 개의 입력 값을 바탕으로 단일 출력 값을 계산
• 전압이나 전류 같은 입력 신호를 이용하여 전압이나 전류인 출력 신호를 제어
  • 이러한 게이트가 필요한 만큼 적절한 방식으로 연결되면 어떤 종류의 계산도 수행 가능

🏰 트랜지스터

• 회로 소자에서 가장 핵심적인 부분

• 1974년 벨 연구소에서 존 바딘, 월터 브래튼, 윌리엄 쇼클리가 발명

• 컴퓨터에서 기본적으로 스위치(전압의 제어를 받아 전류를 켜거나 끄는 장치) 역할을 함

  
  

• 한때는 논리 게이트가 개별 부품으로 만들어지기도 하였음

  • 에니악에서는 전구와 크기가 비슷한 진공관으로 만들어졌으며, 1960년대 컴퓨터에서는 지우개 정도 크기의 트랜지스터로 논리 게이트가 만들어졌음

• 아래 그림은 첫 번쨰 트랜지스터의 복제품, 진공관, 패키지에 들어 있는 프로세서를 보여줌.

• 프로세서에서 실제 회로 부분은 중앙에 있고 가로세로 1cm인 데 반해, 진공관은 길이가 약 4인치(10cm) 정도.

  • 최신 프로세서가 이 정도 크기라면 수십억개의 트랜지스터가 들어 있을 것임.

🏰 집적회로

• 논리게이트는 집적회로 상에서 만들어짐

• 집적회로는 흔히 칩 또는 마이크로칩이라고 함

• 집적회로는 모든 소자와 배선이 단일 평면(얇은 실리콘 판) 위에 들어가 있는데, 이는 개별 부품과 재래식 전선이 없는 회로를 만들기 위해 일련의 복잡한 광학적, 화학적 공정을 거쳐 제조된 것임.

  → 따라서 집적회로는 개별 부품으로 만들어진 회로보다 훨씬 작고 견고함

• 칩은 지름이 약 12인치(30cm)인 원형 웨이퍼 상에서 한꺼번에 제조됨.

  • 웨이퍼는 각 칩으로 나뉘고, 칩은 하나씩 패키징됨.
  • 일반적인 칩은 시스템의 나머지 부분과 칩을 연결해주는 수십~수백개의 핀이 있는 더 큰 패키지에 장착됨.
  • 실제 프로세서는 중앙에 있고, 가로세로 길이는 각각 1cm 정도

• 집적회로는 1958년경에 로버트 노이스와 잭 킬비가 독자적으로 발명

• 집적회로는 디지털 전자 장치의 핵심 요소이기는 하지만, 다른 기술과도 함께 사용됨

  • 디스크에는 자기 저장 기술, CD와 DVD에는 레이저, 네트워킹에는 광섬유가 사용됨.

🌉 점프 투 장고 사이트를 참고하여 일정 단위의 chapter에 대해 실습 후 새롭게 알게된 내용, 혹은 복습이 꼭 필요한 내용에 대해 정리!!

🌞 2-07. 스태틱

🌈 템플릿에 스타일 적용

• 작성한 스타일시트 파일을 질문 상세 템플릿에 적용하는 방법

  • html 문서 상단에 하단의 코드 추가
  • 템플릿에 스타일시트와 같은 스태틱 파일을 사용하기 위해서는 템플릿 최상단에 {% load static %}태그를 먼저 삽입해야 함.
  • 그래야만 {% static ... %}와 같은 템플릿 태그를 사용 가능.

{% load static %}
<link rel="stylesheet" type="text/css" href="{% static 'style.css' %}">

🌞 2-08. 부트스트랩

• 부트스트랩(Bootstrap)은 디자이너의 도움 없이도 개발자 혼자서 상당히 괜찮은 수준의 웹 페이지를 만들수 있게 도와주는 프레임워크.
• 부트스트랩은 트위터(Twitter)를 개발하면서 만들어졌고 현재 지속적으로 관리되고 있는 오픈소스 프로젝트

🌈 부트스트랩 설치

• 부트스트랩 다운로드 : https://getbootstrap.com/docs/5.1/getting-started/download/

🚦 부트스트랩 주의사항

• 부트스트랩은 3.x, 4.x, 5.x 등의 버전이 존재하고 메이저 번호(3, 4, 5)에 따라 그 사용방법이 다름.
• 이 책은 부트스트랩 버전 5 기준으로 실습을 진행.
• 다른 부트스트랩 버전을 사용하면 이 책의 예제가 정상 동작하지 않음.
• 압축파일 안에는 많은 파일들이 있는데 이 중에서 bootstrap.min.css 파일과 bootstrap.min.js 파일을 카피하여 static 디렉터리에 저장

🌈 부트스트랩 적용

• 먼저 질문 목록 template에 부트스트랩을 다음처럼 적용

📄 /templates/pybo/question_list.html

{% load static %}                                                                 # 추가
<link rel="stylesheet" type="text/css" href="{% static bootstrap.min.css' %}">    # 추가
{% if question_list %}
(... 생략 ...)

• 이제 부트스트랩 style을 적용 했으니 template도 부트스트랩을 사용하도록 다음과 같이 수정

  • 기존에는 <ul> 태그로 심플하게 작성했던 질문 목록을 테이블 구조로 변경.
  • 그리고 번호와 작성일시 항목도 추가함.
  • 번호는 for 문의 현재 순서를 의미하는 {{ forloop.counter }}를 이용.
  • 여기서 사용한 class="container my-3", class="table", class="table-dark" 등은 부트스트랩 스타일에 정의되어 있는 클래스들.

📄 /templates/pybo/question_list.html

{% load static %}
<link rel="stylesheet" type="text/css" href="{% static 'bootstrap.min.css' %}">
<div class="container my-3">
    <table class="table">
        <thead>
        <tr class="table-dark">
            <th>번호</th>
            <th>제목</th>
            <th>작성일시</th>
        </tr>
        </thead>
        <tbody>
        {% if question_list %}
        {% for question in question_list %}
        <tr>
            <td>{{ forloop.counter }}</td>
            <td>
                <a href="{% url 'pybo:detail' question.id %}">{{ question.subject }}</a>
            </td>
            <td>{{ question.create_date }}</td>
        </tr>
        {% endfor %}
        {% else %}
        <tr>
            <td colspan="3">질문이 없습니다.</td>
        </tr>
        {% endif %}
        </tbody>
    </table>
</div>

📌 부트스트랩에 대한 자세한 내용은 다음 URL을 참조!!!

• 앞으로 템플릿 작성시에 계속 부트스트랩 스타일들을 사용할 것

  https://getbootstrap.com/docs/5.1/getting-started/introduction/

• 이제 다음처럼 부트스트랩이 적용된 질문 목록을 볼 수 있을

• 이어서 질문 상세 template에도 다음처럼 부트스트랩을 적용

  • 이번에는 수정사항이 좀 많음.
  • 부트스트랩으로 화면을 구성하다 보면 가끔은 이렇게 많은 양의 HTML 코드를 작성해야 함.
  • 질문이나 답변은 하나의 뭉치에 해당하므로 부트스트랩의 card 컴포넌트를 사용.

📄 /templates/pybo/question_detail.html

{% load static %}
<link rel="stylesheet" type="text/css" href="{% static 'bootstrap.min.css' %}">
<div class="container my-3">
    <!-- 질문 -->
    <h2 class="border-bottom py-2">{{ question.subject }}</h2>
    <div class="card my-3">
        <div class="card-body">
            <div class="card-text" style="white-space: pre-line;">{{ question.content }}</div>
            <div class="d-flex justify-content-end">
                <div class="badge bg-light text-dark p-2">
                    {{ question.create_date }}
                </div>
            </div>
        </div>
    </div>
    <!-- 답변 -->
    <h5 class="border-bottom my-3 py-2">{{question.answer_set.count}}개의 답변이 있습니다.</h5>
    {% for answer in question.answer_set.all %}
    <div class="card my-3">
        <div class="card-body">
            <div class="card-text" style="white-space: pre-line;">{{ answer.content }}</div>
            <div class="d-flex justify-content-end">
                <div class="badge bg-light text-dark p-2">
                    {{ answer.create_date }}
                </div>
            </div>
        </div>
    </div>
    {% endfor %}
    <!-- 답변 등록 -->
    <form action="{% url 'pybo:answer_create' question.id %}" method="post" class="my-3">
        {% csrf_token %}
        <div class="mb-3">
            <label for="content" class="form-label">답변내용</label>
            <textarea name="content" id="content" class="form-control" rows="10"></textarea>
        </div>
        <input type="submit" value="답변등록" class="btn btn-primary">
    </form>
</div>

• 부트스트랩 card 컴포넌트 :

  https://getbootstrap.com/docs/5.1/components/card/

• 질문 상세 템플릿에 사용한 부트스트랩 클래스

  • 그리고 질문 내용과 답변 내용에는 style="white-space: pre-line;" 과 같은 스타일을 지정해 줌.
  • 글 내용의 줄 바꿈을 정상적으로 표시하기위해 적용한 스타일임.

• 부트스트랩을 적용한 질문 상세 화면

🌞 2-09. 템플릿 상속

🌈 표준 HTML 구조

• 표준 HTML 문서의 구조는 위의 예처럼 html, head, body 엘리먼트가 있어야 하며, CSS 파일 링크는 head 엘리먼트 안에 있어야 함. 또한 head 엘리먼트 안에는 meta, title 엘리먼트 등이 포함되어야 함.

📄 [표준 HTML 구조의 예]

<!doctype html>
<html lang="ko">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <link rel="stylesheet" type="text/css" href="/static/bootstrap.min.css">
    <title>Hello, pybo!</title>
</head>
<body>
(... 생략 ...)
</body>
</html>

🏳‍🌈 태그와 엘리먼트

<table> (... 생략 ...) </table>  <!-- table 엘리먼트 -->

위에서 <table>은 table 태그이고 <table> ~ </table> 처럼 table 태그로 시작해서 table 태그로 닫힌 구간(Block)은 table 엘리먼트이다.

🌈 템플릿 상속

• 앞에서 작성한 질문 목록, 질문 상세 템플릿을 표준 HTML 구조가 되도록 수정하는 방법은 무엇일까?

  • 그런데 템플릿 파일들을 모두 표준 HTML 구조로 변경하면 body 엘리먼트 바깥 부분(head 엘리먼트 등)은 모두 같은 내용으로 중복될 것임.
  • 그러면 CSS 파일 이름이 변경되거나 새로운 CSS 파일이 추가될 때마다 모든 템플릿 파일을 일일이 수정해야 함.

• 장고는 이런 중복과 불편함을 해소하기 위해 템플릿 상속(extend) 기능을 제공함.
• 템플릿 상속 : 기본 틀이 되는 템플릿을 먼저 작성하고 다른 템플릿에서 그 템플릿을 상속해 사용하는 방법

🚦 base.html 템플릿

• 모든 템플릿이 상속해야 하는 템플릿
• 표준 HTML 문서의 기본 틀
• body 엘리먼트 안의 {% block content %}와 {% endblock %} 템플릿 태그는 base.html을 상속한 템플릿에서 개별적으로 구현해야 하는 영역이 됨.

📄 /templates/base.html

{% load static %}
<!doctype html>
<html lang="ko">
<head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <!-- Bootstrap CSS -->
    <link rel="stylesheet" type="text/css" href="{% static 'bootstrap.min.css' %}">
    <!-- pybo CSS -->
    <link rel="stylesheet" type="text/css" href="{% static 'style.css' %}">
    <title>Hello, pybo!</title>
</head>
<body>
<!-- 기본 템플릿 안에 삽입될 내용 Start -->
{% block content %}
{% endblock %}
<!-- 기본 템플릿 안에 삽입될 내용 End -->
</body>
</html>

🚦 question_list 템플릿

• question_list.html 템플릿을 다음과 같이 변경

  • base.html 템플릿을 상속하기 위해 {% extends 'base.html' %} 처럼 extends 템플릿 문법을 사용.
  • 상단의 두 줄은 base.html에 이미 있는 내용이므로 삭제.
  • 그리고 {% block content %} 와 {% endblock %} 사이에 question_list.html에서만 쓰이는 내용을 작성.
  • 이렇게 하면 이제 question_list.html은 base.html 템플릿을 상속받아 표준 HTML문서로 바뀌게 됨.

📄 /templates/pybo/question_list.html

{% extends 'base.html' %}
{% block content %}
<div class="container my-3">
    <table class="table">

        (... 생략 ...)

    </table>
</div>
{% endblock %}

🚦 question_detail 템플릿

• question_detail.html 템플릿을 다음과 같이 변경

  • {% extends 'base.html' %} 템플릿 태그를 맨 위에 추가하고 기존 내용 위 아래로 {% block content %}와 {% endblock %}를 작성.
  • 템플릿 상속을 적용한 후 질문 목록, 질문 상세를 조회해보면 화면에 보여지는 것은 동일하지만 표준 HTML 구조로 변경된 것을 확인할 수 있음.

📄 /templates/pybo/question_list.html

{% extends 'base.html' %}
{% block content %}
<div class="container my-3">
    <h2 class="border-bottom py-2">{{ question.subject }}</h2>

    (... 생략 ...)

    </form>
</div>
{% endblock %}

🌞 2-10. 폼

🌈 질문 등록

• html 파일에 질문 등록하기 버튼 만들기

  • <a href="..."> 과 같은 링크이지만 부트스트랩의 btn btn-primary 클래스를 적용하면 버튼으로 보이게 됨.
  • 버튼을 클릭하면 pybo:question_create 별칭에 해당되는 URL이 호출될 것

📄 /templates/pybo/question_list.html

    (... 생략 ...)
    </table>
    <a href="{% url 'pybo:question_create' %}" class="btn btn-primary">질문 등록하기</a>     # 추가
</div>
{% endblock %}

🚦 URL 매핑

• pybo:question_create 별칭에 해당되는 URL 매핑 규칙을 추가

  • question_create 함수를 호출하도록 매핑

📄 /pybo/urls.py

from pybo.views import index, detail, question_create, answer_create     # 추가

(... 생략 ...)
urlpatterns = [
    (... 생략 ...)
    path('question/create/', question_create, name='question_create'),    # 추가
]

🚦 폼

• views.py에서 question_create 함수를 작성하기 전에 폼(Form)을 작성

  • 폼(Form)은 페이지 요청시 전달되는 파라미터들을 쉽게 관리하기 위해 사용하는 클래스
  • 폼은 필수 파라미터의 값이 누락되지 않았는지, 파라미터의 형식은 적절한지 등을 검증할 목적으로 사용
  • 이 외에도 HTML을 자동으로 생성하거나 폼에 연결된 모델을 이용하여 데이터를 저장하는 기능도 있음.
  • question_create 함수를 호출하도록 매핑

• 질문 등록시 사용할 QuestionForm을 forms.py 파일에 작성

  • QuestionForm은 모델 폼(forms.ModelForm)을 상속
  • 장고의 폼은 일반 폼(forms.Form)과 모델 폼(forms.ModelForm)이 있음.

    • 모델 폼(forms.ModelForm) : 모델(Model)과 연결된 폼으로 폼을 저장하면 연결된 모델의 데이터를 저장할수 있는 폼 👉 모델 폼은 이너 클래스인 Meta 클래스가 반드시 필요 👉 Meta 클래스에는 사용할 모델과 모델의 속성을 기재해야 함.

• 즉, QuestionForm은 Question 모델과 연결된 폼이고 속성으로 Question 모델의 subject와 content를 사용한다고 정의한 것

📄 /pybo/forms.py

from django import forms
from pybo.models import Question


class QuestionForm(forms.ModelForm):
    class Meta:
        model = Question  # 사용할 모델
        fields = ['subject', 'content']  # QuestionForm에서 사용할 Question 모델의 속성

🚦 view 함수

• views.py에서 question_create 함수를 작성

  • question_create 함수는 위에서 작성한 QuestionForm을 사용
  • render 함수에 전달한 {'form': form}은 템플릿에서 질문 등록시 사용할 폼 엘리먼트를 생성할 때 사용

📄 /pybo/forms.py

from .forms import QuestionForm

(... 생략 ...)

def question_create(request):
    form = QuestionForm()                                        
    return render(request, 'pybo/question_form.html', {'form': form})

🚦 template

• pybo/question_form.html 템플릿을 작성

  • 템플릿에서 사용한 {{ form.as_p }}의 form은 question_create 함수에서 전달한 QuestionForm의 객체
  • {{ form.as_p }}는 폼에 정의한 subject, content 속성에 해당하는 HTML 코드를 자동으로 생성

📄 /template/pybo/question_form.html

{% extends 'base.html' %}
{% block content %}
<div class="container">
    <h5 class="my-3 border-bottom pb-2">질문등록</h5>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit" class="btn btn-primary">저장하기</button>
    </form>
</div>
{% endblock %}

📌 action 속성

• 보통 form 태그에는 항상 action 속성을 지정하여 submit 실행시 action에 정의된 URL로 폼을 전송해야 함.

  • 하지만 여기서는 특별하게 action 속성을 지정하지 않았음.
  • form 태그에 action 속성을 지정하지 않으면 현재 페이지의 URL이 디폴트 action으로 설정됨.

• 물론 action 속성을 다음처럼 명확하게 지정해도 됨.

  <form method="post" action="{% url 'pybo:question_create' %}">

• 위와 같이 action 속성을 지정할 경우, question_form.html 템플릿은 질문 등록 에서만 사용 가능

  • 이후에 진행할 질문 수정 에서는 이 템플릿을 활용할 수가 없음.
  • 왜냐하면 질문 수정일 경우에는 action 값을 달리해야 하기 때문
  • 동일한 템플릿을 여러 기능에서 함께 사용할 경우에는 이처럼 form의 action 속성을 비워두는 트릭을 종종 사용
  • 우리는 이후에 질문 수정 기능을 구현할 때도 question_form.html 템플릿을 사용할 것이므로 action 속성은 비워둘 것!!

🚦 GET과 POST

서버 재시작 후 브라우저에서 정상 작동 여부 확인

• forms.py와 같은 신규 파일 작성시에는 로컬 서버 재시작이 필요

• 질문 목록 화면 하단에 "질문 등록하기" 버튼이 추가됨.

  • "질문 등록하기" 버튼을 클릭하면 다음과 같이 "질문 등록" 화면이 나타남.

• question_create 함수에 데이터를 저장하는 코드를 작성

📄 /pybo/views.py

def question_create(request):
    if request.method == 'POST':
        form = QuestionForm(request.POST)
        if form.is_valid():  # 폼이 유효하다면
            question = form.save(commit=False)  # 임시 저장하여 question 객체를 리턴받고
            question.create_date = timezone.now()  # 실제 저장을 위해 작성일시를 설정.
            question.save()  # 데이터를 실제로 저장.
            return redirect('pybo:index')
    else:
        form = QuestionForm()
    context = {'form': form}
    return render(request, 'pybo/question_form.html', context)

📌 POST, GET

• 동일한 URL 요청을 POST, GET 요청 방식에 따라 다르게 처리

  • 질문 목록 화면에서 "질문 등록하기" 버튼을 클릭한 경우에는 /pybo/question/create/ 페이지가 GET 방식으로 요청되어 question_create 함수가 실행됨.
    • 왜냐하면 <a href="{% url 'pybo:question_create' %}" class="btn btn-primary">질문 등록하기</a>와 같이 링크를 통해 페이지를 요청할 경우에는 무조건 GET 방식이 사용되기 때문. 따라서 이 경우에는 request.method 값이 GET이 되어 if .. else .. 구문에서 else 구문을 타게 되어 질문을 등록하는 화면을 렌더링
      
  • 그리고 질문 등록 화면에서 subject, content 항목에 값을 기입하고 저장하기 버튼을 누르면 이번에는 /pybo/question/create/ 페이지를 POST 방식으로 요청함.
    • 왜냐하면 앞서 설명했듯이 form 태그에 action 속성이 지정되지 않으면 현재 페이지가 디폴트 action으로 설정되기 때문.
    • 따라서 질문 등록 화면에서 저장하기 버튼을 클릭하면 question_create 함수가 실행되고 request.method 값은 POST가 되어 해당 코드 블럭이 실행됨.

• GET 방식에서는 form = QuestionForm() 처럼 QuestionForm을 인수 없이 생성.

• POST 방식에서는 form = QuestionForm(request.POST) 처럼 request.POST를 인수로 생성.

  • request.POST를 인수로 QuestionForm을 생성할 경우에는 request.POST에 담긴 subject, content 값이 QuestionForm의 subject, content 속성에 자동으로 저장되어 객체가 생성됨.
    • request.POST에는 화면에서 사용자가 입력한 내용들이 담겨있음.
  • 그리고 form.is_valid()는 form이 유효한지를 검사
    • 만약 form에 저장된 subject, content의 값이 올바르지 않다면 form에는 오류 메시지가 저장되고 form.is_valid()가 실패하여 다시 질문 등록 화면을 렌더링.
    • 이 때 form에는 오류 메시지가 저장되므로 화면에 오류를 표시할 수 있음.

• if form.is_valid(): form이 유효하다면 이후의 문장이 수행되어 질문 데이터가 생됨.

• question = form.save(commit=False) : form에 저장된 데이터로 Question 데이터를 저장하기 위한 코드

  • QuestionForm이 Question 모델과 연결된 모델 폼이기 때문에 이와 같이 사용 가능.
  • 여기서 commit=False는 임시 저장을 의미.
    • 즉, 실제 데이터는 아직 데이터베이스에 저장되지 않은 상태를 뜻함.
    • 여기서 form.save(commit=False) 대신 form.save()를 수행하면 Question 모델의 create_date에 값이 없다는 오류가 발생.
    • 왜냐하면 QuestionForm에는 현재 subject, content속성만 정의되어 있고 create_date 속성은 없기 때문.
    • 이러한 이유로 임시 저장을 하여 question 객체를 리턴받고 create_date에 값을 설정한 후 question.save()로 실제 데이터를 저장하는 것

      • create_date 속성은 데이터 저장 시점에 생성해야 하는 값이므로 QuestionForm에 등록하여 사용하지 않음.

• 이제 브라우저에서 질문 등록이 잘 되는지 확인

🚦 form widget

• {{ form.as_p }} 태그는 HTML 코드를 자동으로 생성하기 때문에 부트스트랩을 적용할 수가 없음.

  • 완벽하지는 않지만 다음처럼 QuestionForm을 조금 수정하면 어느정도 해결이 가능
  • widgets 속성을 지정하면 subject, content 입력 필드에 form-control과 같은 부트스트랩 클래스를 추가 가능

📄 /pybo/forms.py

from django import forms
from pybo.models import Question


class QuestionForm(forms.ModelForm):
    class Meta:
        model = Question
        fields = ['subject', 'content']
        widgets = {
            'subject': forms.TextInput(attrs={'class': 'form-control'}),
            'content': forms.Textarea(attrs={'class': 'form-control', 'rows': 10}),
        }

• 다시 질문 등록 화면을 요청해 보면 다음과 같이 부트스트랩이 적용된 것을 확인 가능

🚦 form label

• 질문 등록 화면에 표시되는 Subject, Content를 영문이 아니라 한글로 표시하고 싶다면 다음처럼 labels 속성을 지정

📄 /pybo/forms.py

from django import forms
from pybo.models import Question


class QuestionForm(forms.ModelForm):
    class Meta:
        model = Question
        fields = ['subject', 'content']
        widgets = {
            'subject': forms.TextInput(attrs={'class': 'form-control'}),
            'content': forms.Textarea(attrs={'class': 'form-control', 'rows': 10}),
        }
        labels = {                  # 추가
            'subject': '제목',       # 추가
            'content': '내용',       # 추가
        }                           # 추가

• 장고 폼(form)에 대한 보다 자세한 내용은 다음 URL을 참고

  https://docs.djangoproject.com/en/4.0/topics/forms/

🚦 수동 폼 작성

• {{ form.as_p }}

  • {{ form.as_p }}를 사용하면 빠르게 템플릿을 만들 수 있지만 HTML 코드가 자동으로 생성되므로 디자인 측면에서 많은 제한이 생김.
  • 예를 들어 폼 엘리먼트 내에 특정 태그를 추가하거나 필요한 클래스를 추가하는 작업에 제한이 생김.
  • 또 디자인 영역과 서버 프로그램 영역이 혼재되어 웹 디자이너와 개발자의 역할을 분리하기도 모호해짐.

• 이용하여 자동으로 HTML 코드를 생성하지 않고 직접 HTML 코드를 작성하는 방법을 사용하기 위해 수작업시 필요없는 widget 속성을 제거

📄 /pybo/forms.py

from django import forms
from pybo.models import Question


class QuestionForm(forms.ModelForm):
    class Meta:
        model = Question  # 사용할 모델
        fields = ['subject', 'content']  # QuestionForm에서 사용할 Question 모델의 속성
        widgets = {
            'subject': forms.TextInput(attrs={'class': 'form-control'}),
            'content': forms.Textarea(attrs={'class': 'form-control', 'rows': 10}),
        }

• 그리고 질문 등록 템플릿을 다음과 같이 수정

  • {{ form.as_p }}로 자동으로 생성되는 HTML 대신 제목과 내용에 해당되는 HTML코드를 직접 작성
  • 그리고 question_create 함수에서 form.is_valid() 가 실패할 경우 발생하는 오류의 내용을 표시하기 위해 오류를 표시하는 영역을 추가
    
  • 제목(subject) 항목의 value에는 {{ form.subject.value|default_if_none:'' }} 처럼 값을 대입해 주었는데 이것은 오류가 발생했을 경우 기존에 입력했던 값을 유지하기 위함.
  • |default_if_none:''의 의미 : 폼 데이터(form.subject.value)에 값이 없을 경우 None 이라는 문자열이 표시되는데 None 대신 공백으로 표시하라는 의미의 템플릿 필터

    • 장고의 템플릿 필터는 |default_if_none:'' 처럼 | 기호와 함께 사용됨.

📄 /templates/pybo/question_form.html

{% extends 'base.html' %}

{% block content %}
<div class="container">
    <h5 class="my-3 border-bottom pb-2">질문등록</h5>
    <form method="post">
        {% csrf_token %}
        <!-- 오류표시 Start -->                                               # 추가 시작
        {% if form.errors %}
        <div class="alert alert-danger" role="alert">
            {% for field in form %}
            {% if field.errors %}
            <div>
                <strong>{{ field.label }}</strong>
                {{ field.errors }}
            </div>
            {% endif %}
            {% endfor %}
        </div>
        {% endif %}
        <!-- 오류표시 End -->
        <div class="mb-3">
            <label for="subject" class="form-label">제목</label>
            <input type="text" class="form-control" name="subject" id="subject"
                   value="{{ form.subject.value|default_if_none:'' }}">
        </div>
        <div class="mb-3">
            <label for="content" class="form-label">내용</label>
            <textarea class="form-control" name="content"
                      id="content" rows="10">{{ form.content.value|default_if_none:'' }}</textarea>
        </div>                                                            # 추가 끝
        <button type="submit" class="btn btn-primary">저장하기</button>
    </form>
</div>
{% endblock %}

• "질문등록" 화면에서 제목에만 "TEST"라고 입력하고 "내용"은 비워둔 채 "저장하기" 버튼을 클릭해보면

  • "내용"에 아무런 값도 입력하지 않았기 때문에 "내용"을 입력하라는 오류메시지 확인 가능
  • 그리고 "제목"에 입력했던 "TEST"는 사라지지 않고 계속 유지되는 것도 확인 가능.

🌈 답변 등록

• 질문 등록에 장고 폼을 적용한 것처럼 답변 등록에도 장고 폼을 적용.

🚦 AnswerForm

• 답변을 등록할 때 사용할 AnswerForm을 pybo/forms.py 파일에 다음과 같이 작성

📄 /pybo/forms.py

from django import forms
from pybo.models import Question, Answer

(... 생략 ...)

class AnswerForm(forms.ModelForm):
    class Meta:
        model = Answer
        fields = ['content']
        labels = {
            'content': '답변내용',
        }

🚦 answer_create 함수

• answer_create 함수를 다음과 같이 수정

  • question_create와 같은 방법으로 AnswerForm을 이용하도록 변경.
  • 하지만 답변 등록은 POST 방식만 사용되기 때문에 GET 방식으로 요청할 경우에는 HttpResponseNotAllowed 오류가 발생하도록 설정.

📄 /pybo/views.py

(... 생략 ...)
from django.http import HttpResponseNotAllowed
from .forms import QuestionForm, AnswerForm
(... 생략 ...)

def answer_create(request, question_id):
    """
    pybo 답변등록
    """
    question = get_object_or_404(Question, pk=question_id)
    if request.method == "POST":
        form = AnswerForm(request.POST)
        if form.is_valid():
            answer = form.save(commit=False)
            answer.create_date = timezone.now()
            answer.question = question
            answer.save()
            return redirect('pybo:detail', question_id=question.id)
    else:
        return HttpResponseNotAllowed('Only POST is possible.')
    context = {'question': question, 'form': form}
    return render(request, 'pybo/question_detail.html', context)

🚦 question_detail.html

• 질문 상세 템플릿도 오류를 표시하기 위한 영역을 다음처럼 추가

📄 /templates/pybo/question_detail.html

{% extends 'base.html' %}
{% block content %}
<div class="container my-3">
    (... 생략 ...)
    <form action="{% url 'pybo:answer_create' question.id %}" method="post" class="my-3">
        {% csrf_token %}
        <!-- 오류표시 Start -->                     # 추가 시작
        {% if form.errors %}
        <div class="alert alert-danger" role="alert">
            {% for field in form %}
            {% if field.errors %}
            <div>
                <strong>{{ field.label }}</strong>
                {{ field.errors }}
            </div>
            {% endif %}
            {% endfor %}
        </div>
        {% endif %}
        <!-- 오류표시 End -->                       # 추가 끝
        <div class="form-group">
            <textarea name="content" id="content" class="form-control" rows="10"></textarea>
        </div>
        <input type="submit" value="답변등록" class="btn btn-primary">
    </form>
</div>
{% endblock %}

• 이렇게 수정하고 답변 내용 없이 답변을 등록하려고 하면 다음과 같은 오류 메시지가 표시됨.

🌉 점프 투 장고 사이트를 참고하여 일정 단위의 chapter에 대해 실습 후 새롭게 알게된 내용, 혹은 복습이 꼭 필요한 내용에 대해 정리!!

🌞 2-04. 조회와 템플릿

🌈 질문 목록 조회 구현

http://localhost:8000/pybo 위의 페이지를 요청하면

현재 : "안녕하세요 pybo에 오신 것을 환영합니다." 라는 문구가 출력됨. 변경 : 질문 목록이 출력되도록 프로젝트 파일들을 수정!

📄 /pybo/views.py

# from django.http import HttpResponse                               # 삭제
from django.shortcuts import render
from .models import Question


def index(request):
    # return HttpResponse("안녕하세요 pybo에 오신 것을 환영합니다.")     # 삭제
    question_list = Question.objects.order_by('-create_date')
    context = {'question_list': question_list}
    return render(request, 'pybo/question_list.html', context)

• 코드 풀이

  1. 질문 목록 데이터 : Question.objects.order_by('-create_date')
     • order_by : 조회 결과를 정렬하는 함수
     • order_by('-create_date') : 작성일시를 역순으로 정렬하라는 의미
     • - 기호 : 붙어 있으면 역방향, 없으면 순방향 정렬을 의미 → 게시물은 보통 최신순으로 보기 때문에 작성일시의 역순으로 정렬
       
  2. render 함수 :
     • 파이썬 데이터를 템플릿에 적용하여 HTML로 반환하는 함수
     • 즉, 위에서 사용한 render 함수는 질문 목록으로 조회한 question_list 데이터를 pybo/question_list.html 파일에 적용하여 HTML을 생성한후 리턴
     • 여기서 사용된 pybo/question_list.html과 같은 파일을 템플릿(Template)이라고 부름. → 템플릿 파일은 HTML 파일과 비슷하지만 파이썬 데이터를 읽어서 사용할수 있는 HTML 파일

📄 /pybo/question_list.html

{% if question_list %}
    <ul>
    {% for question in question_list %}
        <li><a href="/pybo/{{ question.id }}/">{{ question.subject }}</a></li>
    {% endfor %}
    </ul>
{% else %}
    <p>질문이 없습니다.</p>
{% endif %}

• 템플릿을 보면 {% if question_list %} 처럼 {% 와 %} 로 둘러싸인 문장들을 볼 수 있는데 이러한 것들을 템플릿 태그라고 함.
  • question_list.html에 사용된 템플릿 태그들은 다음과 같음.
  • 템플릿에서 사용한 question_list는 render 함수로 전달한 "질문 목록" 데이터 → views.py의 index 함수에서 2번째 줄에 있는 question_list임

http://localhost:8000/pybo 접속 시, 다음과 같이 변경된 화면을 확인 가능.

🌈 템플릿 태그

• 장고에서 사용하는 템플릿 태그는 다음 3가지 유형만 알면 됨.

🚦 1. 분기

• 분기문 태그의 사용법

  • 파이썬의 if 문과 유사하지만 항상 {% endif %} 태그로 닫아야 함.

  {% if 조건문1 %}
   <p>조건문1에 해당되는 경우</p>
  {% elif 조건문2 %}
   <p>조건문2에 해당되는 경우</p>
  {% else %}
   <p>조건문1, 2에 모두 해당되지 않는 경우</p>
  {% endif %}

🚦 2. 반복

• 반복문 태그의 사용법

  • 파이썬의 for 문과 유사하지만 항상 {% endfor %} 태그로 닫아야 함.

  {% for item in list %}
   <p>순서: {{ forloop.counter }} </p>
   <p>{{ item }}</p>
  {% endfor %}

  • 템플릿 for 문 안에서는 다음과 같은 forloop 객체를 사용

🚦 3. 객체 출력

• 객체를 출력하기 위한 태그의 사용법

  • 파이썬의 for 문과 유사하지만 항상 {% endfor %} 태그로 닫아야 함.

  {{ 객체 }}

  예) {{ item }}

• 객체에 속성이 있는 경우는 파이썬과 동일한 방법으로 도트(.) 문자를 이용하여 표시

예) {{question.id}}, {{question.subject}}

• 이 책에서는 파이보에 필요한 템플릿 문법이 나올 때마다 자세하게 알아볼 예정.
• 템플릿에 대한 보다 자세한 내용은 다음 URL을 참고. https://docs.djangoproject.com/en/4.0/topics/templates/

🌈 질문 상세 조회 구현

http://localhost:8000/pybo/2/

• 이 URL의 의도 : id 값이 2인 Question을 상세 조회

동작을 위해 파일들을 아래와 같이 수정

📄 /pybo/urls.py

from django.urls import path

from pybo.views import index, detail

urlpatterns = [
    path('', index),
    path('<int:question_id>/', detail),    # 추가
]

• path('<int:question_id>/', detail) 라는 URL 매핑을 추가.
• 이제 http://localhost:8000/pybo/2/ 페이지가 요청되면 여기에 등록한 매핑 룰에 의해 http://localhost:8000/pybo/<int:question_id>/ 가 적용되어 question_id 에 2가 저장되고 detail 함수도 실행될 것
• <int:question_id> 에서 int는 숫자가 매핑됨을 의미

📄 /pybo/views.py

• detail 함수 추가

def detail(request, question_id):
    question = Question.objects.get(id=question_id)
    context = {'question': question}
    return render(request, 'pybo/question_detail.html', context)

• detail 함수 호출시 전달되는 매개변수가 request 외에 question_id가 추가됨.
• 매개변수 question_id에는 URL 매핑시 저장된 question_id가 전달
• http://localhost:8000/pybo/2/ 페이지가 요청되면 매개변수 question_id에 2가 세팅되어 detail 함수가 실행

📄 `/templates/pybo/question_detail.html`

• detail 함수에서 사용할 pybo/question_detail.html 템플릿

<h1>{{ question.subject }}</h1>
<div>
    {{ question.content }}
</div>

• {{ question.subject }}과 {{ question.content }}의 question은 detail 함수에서 템플릿에 context 변수로 전달한 Question 모델 객체

http://localhost:8000/pybo/2/ 접속

❗❗ 오류 페이지 http://localhost:8000/pybo/30/ 페이지를 요청

• 그러면 DoesNotExist 오류가 발생.
• 이 오류는 전달된 question_id가 30이기 때문에 Question.object.get(id=30)이 호출되어 발생한 오류임.
• 이 때 브라우저에 전달되는 오류코드는 500

  이렇게 없는 데이터를 요청할 경우 500 오류 페이지 보다는 Not Found (404) 페이지를 리턴하는 것이 바람직

[HTTP 주요 응답코드의 종류]

http://localhost:8000/pybo/30/ 처럼 없는 데이터를 요청할 경우 500 페이지 대신 404 페이지를 출력하도록 detail 함수를 수정

📄 /pybo/views.py

• Question.objects.get(id=question_id)에서 get 함수를get_object_or_404(Question, pk=question_id)로 변경.
  • 여기서 사용한 pk는 Question 모델의 기본키(Primary Key)에 해당하는 값을 의미

from django.shortcuts import render, get_object_or_404            #  get_object_or_404 추가
from .models import Question

(... 생략 ...)

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)        # 수정
    context = {'question': question}
    return render(request, 'pybo/question_detail.html', context)

🏳‍🌈 Generic View 알아두기

• 이 책은 제네릭뷰를 사용하지 않음.
• 왜냐하면 제네릭뷰는 매우 편리하지만 내부적으로 어떻게 동작하는지 이해하기 쉽지 않아 장고를 배우는 지금 이 시점에서는 오히려 혼란을 초래할 수 있기 때문
• 간단한 내용만 살펴볼 것

• 장고에는 제네릭뷰(Generic View)라는 것이 있음.

  • 목록 조회나 상세 조회 같은 특정한 패턴이 있는 뷰를 작성할 때 늘 비슷한 내용을 입력하기 때문에 이것을 패턴화하여 간략하게 만든것이 바로 제네릭 뷰

  • 만약 우리가 views.py에 작성한 index나 detail 함수를 제네릭 뷰로 변경하면 다음처럼 간략하게 작성 가능

📄 /pybo/views.py

class IndexView(generic.ListView):
    def get_queryset(self):
        return Question.objects.order_by('-create_date')

class DetailView(generic.DetailView):
    model = Question

• IndexView 클래스가 index 함수를 대체하고 DetailView 클래스가 detail 함수를 대체함.
• IndexView는 템플릿 명이 명시적으로 지정되지 않은 경우에는 디폴트로 모델명_list.html 을 템플릿명으로 사용.
• 마찬가지로 DetailView는 모델명_detail.html을 디폴트 템플릿명으로 사용.

• 그리고 제네릭 뷰 사용을 위해 pybo/urls.py 파일은 다음과 같이 변경되어야 함.

📄 /pybo/urls.py

from django.urls import path

from . import views

app_name = 'pybo'
urlpatterns = [
    path('', views.IndexView.as_view()),
    path('<int:pk>/', views.DetailView.as_view()),
]

• 이렇듯 모델의 목록 조회나 상세 조회는 제네릭뷰를 사용하는것이 매우 간편함.
• 단, 제네릭 뷰를 사용할 경우에는 복잡한 케이스에서 더 어렵게 작성되는 경우가 종종 있으니 주의하여 사용

🌞 2-05. URL 별칭

🌈 URL 하드코딩

question_list.html 템플릿에 사용된 링크

<li><a href="/pybo/{{ question.id }}/">{{ question.subject }}</a></li>

• 위의 링크는 질문 상세를 위한 URL 링크임.

  • 하지만 이러한 URL 링크는 수정될 가능성이 있음.
  • 예를 들어, http://localhost:8000/pybo/question/2 또는 http://localhost:8000/pybo/2/question 처럼 변경될 가능성이 존재.
  • 실제 프로젝트에서 URL 리팩토링은 빈번하게 발생

• URL 링크의 구조가 자주 변경된다면 템플릿에서 사용한 모든 URL들을 일일이 찾아가며 수정해야 하는 리스크가 발생.

• 이러한 문제점을 해결하기 위해서는 해당 URL에 대한 실제 링크 대신 링크의 주소가 1:1 매핑되어 있는 별칭을 사용

🌈 URL 별칭

• 링크의 주소 대신 별칭을 사용하려면 URL 매핑에 name 속성을 부여하면 됨.
• /pybo.urls.py 파일을 다음과 같이 수정

  • http://localhost:8000/pybo/ URL은 index,
  • http://localhost:8000/pybo/2와 같은 URL에는 detail라는 별칭을 부여한 것

📄 /pybo/urls.py

from django.urls import path

from pybo.views import index, detail

urlpatterns = [
    path('', index, name='index'),
    path('<int:question_id>/', detail, name='detail'),
]

🌈 템플릿에서 URL 별칭 사용하기

• 이렇게 pybo/urls.py 파일에 별칭을 추가하면 템플릿에서 다음처럼 사용

  • 하드코딩 되어 있던 /pybo/{{ question.id }} 링크를 {% url 'detail' question.id %}로 변경
  • 여기서 question.id는 URL 매핑에 정의된 <int:question_id>에 전달해야 하는 값을 의미

📄 /templates/pybo/question_list.html

{% if question_list %}
    <ul>
    {% for question in question_list %}
        <li><a href="{% url 'detail' question.id %}">{{ question.subject }}</a></li>
    {% endfor %}
    </ul>
{% else %}
    <p>질문이 없습니다.</p>
{% endif %}

📌 파라미터명 전달

1. 한 개의 파라미터를 전달할 경우에는 다음과 같이 사용

   {% url 'detail' question.id %}

2. 이 때 다음처럼 파라미터 명을 함께 사용 가능

   {% url 'detail' question_id=question.id %}

3. 만약 2개 이상의 파라미터를 사용해야 한다면 다음과 같이 공백 문자 이후에 덧 붙여주면 됨.

   {% url 'detail' question_id=question.id page=2 %}

🌈 URL 네임스페이스

• 현재는 pybo 앱 하나만 사용중이지만 pybo 앱 이외의 다른 앱이 프로젝트에 추가 될 수도 있을 것임.
• 이런 경우 서로 다른 앱에서 동일한 URL 별칭을 사용하면 중복이 발생할 것

❗❗ 이 문제를 해결하려면 pybo/urls.py 파일에 네임스페이스를 의미하는 app_name 변수를 지정해야 함.

• app_name을 pybo로 설정

📄 /pybo/urls.py

from django.urls import path
from pybo.views import index, detail

app_name = 'pybo'         # 추가

urlpatterns = [
    path('', index, name='index'),
    path('<int:question_id>/', detail, name='detail'),
]

• 위와 같이 수정 후, 템플릿에서 사용한 URL 별칭에 네임스페이스를 다음과 같이 지정해야 함.

  • detail 앞에 pybo 라는 네임스페이스를 붙여준 것

📄 /templates/pybo/question_list.html

{% if question_list %}
    <ul>
    {% for question in question_list %}
        <li><a href="{% url 'pybo:detail' question.id %}">{{ question.subject }}</a></li>      # 수정
    {% endfor %}
    </ul>
{% else %}
    <p>질문이 없습니다.</p>
{% endif %}

📌 redirect 함수와 URL 별칭

• URL 별칭은 템플릿 외에 redirect 함수에서도 사용됨.
• redirect는 특정 페이지로 이동시키는 함수.

  redirect('pybo:detail', question_id=question.id)

🌞 2-06. 데이터 저장

• 이번 장에서는 답변을 등록하는 기능을 생성 예정

🌈 답변 등록 폼 추가

• 질문 상세 템플릿에 다음처럼 답변을 저장할 수 있는 폼(form)을 추가

  • 답변의 내용을 입력할 수 있는 텍스트창(textarea)과 답변을 저장 할 수 있는 "답변등록" 버튼을 추가.
  • 답변 저장을 위한 URL은 form 태그의 action 속성에 {% url 'pybo:answer_create' question.id %}로 지정

📄 /templates/pybo/question_list.html

<h1>{{ question.subject }}</h1>
<div>
    {{ question.content }}
</div>
<form action="{% url 'pybo:answer_create' question.id %}" method="post">      # 추가
{% csrf_token %}                                                              # 추가
<textarea name="content" id="content" rows="15"></textarea>                   # 추가
<input type="submit" value="답변등록">                                         # 추가
</form>                                                                       # 추가

• form 태그 바로 밑에 보이는 {% csrf_token %}은 보안에 관련된 항목으로 form으로 전송한 데이터가 실제 웹 페이지에서 작성한 데이터인지를 판단하는 가늠자 역할을 함.

  • 만약 어떤 해커가 이상한 방법으로 데이터를 전송할 경우에는 서버에서 발행한 csrf_token 값과 해커가 일방적으로 보낸 csrf_token 값이 일치하지 않기 때문에 블록킹될 것

• 따라서 form 태그 바로 밑에 {% csrf_token %} 태그를 항상 위치시켜야 함.

  • POST 요청시 form 태그에 csrf_token이 없으면 장고는 오류를 냄.

🏳‍🌈 CSRF란?

CSRF(cross site request forgery)

• 웹 사이트 취약점 공격을 방지를 위해 사용하는 기술
• 장고가 CSRF 토큰 값을 세션을 통해 발행하고 웹 페이지에서는 폼 전송시에 해당 토큰을 함께 전송하여 실제 웹 페이지에서 작성된 데이터가 전달되는지를 검증하는 기술
• csrf_token 사용을 위해서는 CsrfViewMiddleware 미들웨어가 필요한데 이 미들웨어는 settings.py의 MIDDLEWARE 항목에 디폴트로 추가되어 있으므로 별도의 설정은 필요 없음.

📄 /templates/pybo/question_list.html

(... 생략 ...)

MIDDLEWARE = [
    (... 생략 ...)
    'django.middleware.csrf.CsrfViewMiddleware',
    (... 생략 ...)
]
(... 생략 ...)

• 만약 csrf_token 기능을 사용하고 싶지 않다면 저 코드 한 줄을 주석처리하면 됨.

🌈 URL 매핑

• 질문 상세 템플릿을 위와 같이 고친 후 질문 상세 페이지를 요청하기 위해 pybo/urls.py에 다음과 같은 URL 매핑을 등록

  • answer_create 별칭에 해당하는 URL 매핑 규칙을 등록.
  • 이제 http://locahost:8000/pybo/answer/create/2/ 와 같은 페이지를 요청하면 URL 매핑 규칙에 의해 answer_create 함수가 호출될 것

📄 /pybo/urls.py

from django.urls import path

from pybo.views import index, detail, answer_create    # 추가


app_name = "pybo"

urlpatterns = [
    path("", index),
    path("<int:question_id>/", detail, name="detail"),
    path("answer/create/<int:question_id>/", answer_create, name="answer_create"),   # 추가
]

• 그리고 URL 매핑 규칙에 정의된 answer_create 함수를 pybo/views.py 파일에 다음처럼 추가

  • answer_create 함수의 매개변수 question_id는 URL 매핑에 의해 그 값이 전달됨.
  • 만약 http://locahost:8000/pybo/answer/create/2/ 라는 페이지를 요청하면 매개변수 question_id에는 2라는 값이 전달될 것

📄 /pybo/views.py

from django.shortcuts import render, get_object_or_404, redirect   # 추가
from django.utils import timezone   # 추가
from .models import Question

(... 생략 ...)

def answer_create(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    question.answer_set.create(content=request.POST.get('content'), create_date=timezone.now())
    return redirect('pybo:detail', question_id=question.id)

• 답변 등록시 텍스트창에 입력한 내용은 answer_create 함수의 첫번째 매개변수인 request 객체를 통해 읽을 수 있음.

  • 즉, request.POST.get('content')로 텍스트창에 입력한 내용을 읽을 수 있음.
  • request.POST.get('content') : POST로 전송된 폼(form) 데이터 항목 중 content 값을 의미

• 그리고 답변을 생성하기 위해 question.asnswer_set.create 를 사용.

  • question.answer_set : 질문의 답변을 의미.
  • Question과 Answer 모델은 서로 ForeignKey 로 연결되어 있기 때문에 이처럼 사용 가능.

📌 답변을 저장하는 또 다른 방법은 Answer 모델을 직접 사용하는 방법

• 어떤것을 사용해도 결과는 동일

📄 /pybo/views.py

(... 생략 ...)
from .models import Question, Answer

(... 생략 ...)

def answer_create(request, question_id):
    """
    pybo 답변등록
    """
    question = get_object_or_404(Question, pk=question_id)
    answer = Answer(question=question, content=request.POST.get('content'), create_date=timezone.now())     # 변경 및 추가된 부분
    answer.save()                                                                                           # 변경 및 추가된 부분
    return redirect('pybo:detail', question_id=question.id)

• 답변을 생성한 후 질문 상세 화면을 다시 보여주기 위해 redirect 함수를 사용

  • redirect 함수 : 페이지 이동을 위한 함수.
  • pybo:detail 별칭에 해당하는 페이지로 이동하기 위해 redirect 함수를 사용.
  • 그리고 pybo:detail 별칭에 해당하는 URL은 question_id가 필요하므로 question.id를 인수로 전달

🌈 답변 저장

• 이렇게 수정한 후, 질문 상세 화면 호출

  • 텍스트 창에 아무 값이나 입력하고 답변을 등록해보면 화면에는 아무런 변화가 없음.
  • 왜냐하면 아직 등록된 답변을 표시하는 기능을 템플릿에 추가하지 않았기 때문

🌈 답변 조회

• 등록된 답변을 질문 상세 화면에 표시하려면 다음과 같이 질문 상세 템플릿을 수정해야 함.

  • 중간 부분에 질문에 등록된 답변을 확인할 수 있는 영역을 추가.
  • question.answer_set.count : 답변의 총 갯수를 의미
    • question.answer_set : 질문과 연결된 답변들을 의미

📄 /templates/pybo/question_detail.html

<h1>{{ question.subject }}</h1>
<div>
    {{ question.content }}
</div>
<h5>{{ question.answer_set.count }}개의 답변이 있습니다.</h5>    # 추가
<div>                                                          # 추가
    <ul>                                                       # 추가
    {% for answer in question.answer_set.all %}                # 추가
        <li>{{ answer.content }}</li>                          # 추가
    {% endfor %}                                               # 추가
    </ul>                                                      # 추가
</div>                                                         # 추가
<form action="{% url 'pybo:answer_create' question.id %}" method="post">
{% csrf_token %}
<textarea name="content" id="content" rows="15"></textarea>
<input type="submit" value="답변등록">
</form>

• 이렇게 수정 후, 다시 질문 상세 화면을 호출

🌉 점프 투 장고 사이트를 참고하여 일정 단위의 chapter에 대해 실습 후 새롭게 알게된 내용, 혹은 복습이 꼭 필요한 내용에 대해 정리!!

🌞 2-01. URL과 View

🌈 장고 개발 흐름 정리하기

[1] 브라우저에서 로컬 서버로 http://localhost:8000/pybo 페이지를 요청 [2] urls.py 파일에서 /pybo URL 매핑을 확인하여 views.py 파일의 index 함수를 호출 [3] 호출한 결과를 브라우저에 반영

🌈 URL 분리

✨ pybo 앱에 관련한 것들은 pybo 앱 디렉터리 하위에 위치해야 함.

• config의 urls.py 파일은 앱이 아닌 프로젝트 성격의 파일이므로, 이곳에는 프로젝트 성격의 URL 매핑만 추가되어야 함.
• 따라서 pybo 앱에서만 사용하는 URL 매핑을 pybo/urls.py 파일로 분리하여 관리할 것!

📄 /config/urls.py

from django.contrib import admin
from django.urls import path, include
# from pybo import views  → 더 이상 필요하지 않으므로 삭제

urlpatterns = [
    path('admin/', admin.site.urls),
    path('pybo/', include('pybo.urls')),  # ← 추가한 코드
]

path('pybo/', include('pybo.urls'))

• pybo/로 시작하는 페이지를 요청하면 이제 pybo/urls.py 파일의 매핑 정보를 읽어서 처리하라는 의미
• 따라서 이제 pybo/로 시작하는 URL (예시 : pybo/question/create, pybo/answer/create)을 추가해야 할 때 config/urls.py 파일을 수정할 필요없이 pybo/urls.py 파일만 수정하면 됨.
  

📄 /pybo/urls.py

from django.urls import path

from pybo.views import index

urlpatterns = [
    path('', index),
]

• 기존 /config/urls.py 파일에 설정했던 내용과 별반 차이가 없음.
• 다만 path('', index) 처럼 pybo/ 가 생략된 '' 이 사용됨.
  • 이렇게 되는 이유는 config/urls.py 파일에서 이미 pybo/로 시작하는 URL이 pybo/urls.py 파일과 먼저 매핑되었기 때문.
• 즉, pybo/ URL은 다음처럼 config/urls.py 파일에 매핑된 pybo/ 와 pybo/urls.py 파일에 매핑된 '' 이 더해져 pybo/가 됨.

🌞 2-02. Model

🌈 ORM

🚦 쿼리문

데이터베이스의 데이터를 생성, 조회, 수정, 삭제하기 위해 사용하는 질의문(문법)

🚦 ORM

1. 전통적으로 데이터베이스를 사용하는 프로그램들은 데이터베이스의 데이터를 조회하거나 저장하기 위해 쿼리문을 사용해야 했다.
2. 이 방식은 여전히 많이 사용되고 있는 방식이지만 몇 가지 단점이 있다.
   • 개발자마다 다양한 쿼리문이 만들어지고, 또 잘못 작성된 쿼리는 시스템의 성능을 저하 시킬수 있기 때문이다.
   • 그리고 데이터베이스를 MySQL에서 오라클로 변경하면 프로그램에서 사용한 쿼리문을 모두 해당 데이터베이스의 규칙에 맞게 수정해야 하는 어려움도 생긴다.

• ORM(Object Relational Mapping)을 사용하면 데이터베이스의 테이블을 모델화하여 사용하기 때문에 위에서 열거한 SQL방식의 단점이 모두 없어짐.
• ORM을 사용하면 개발자별로 독특한 쿼리문이 만들어질 수가 없고 또 쿼리를 잘못 작성할 가능성도 낮아짐.
• 그리고 데이터베이스 종류가 변경되더라도 쿼리문이 아닌 모델을 사용하기 때문에 프로그램을 수정할 필요가 없음.
  

🌈 CASCADE 옵션

🚦 ForeignKey

• Answer 모델은 질문에 대한 답변에 해당되므로 Question 모델을 속성으로 가져가야함.

• 기존 모델을 속성으로 연결하려면 ForeignKey를 사용해야 함.

• ForeignKey는 다른 모델과 연결하기 위해 사용.

  🚦 on_delete=models.CASCADE

  • 이 답변(Answer)과 연결된 질문(Question)이 삭제될 경우 답변(Answer)도 함께 삭제된다는 의미
  • 질문 하나에는 무수히 많은 답변이 등록될 수 있음.
  • CASCADE 옵션은 질문을 삭제하면 그에 달린 답변들도 모두 함께 삭제
    

• 장고에서 사용하는 속성(Field)의 타입은 이것 외에도 많음.

  • 다음 URL에서 어떤것들이 있는지 참고할 것 https://docs.djangoproject.com/en/4.0/ref/models/fields/#field-types

🌈 sqlmigrate

• makemigrations로 데이터베이스 작업 파일을 생성하고 migrate 명령을 실행하기 전에 실제 어떤 쿼리문이 실행되는지 sqlmigrate 명령으로 확인해 볼 수 있음.
• sqlmigrate 명령은 단지 실행되는 쿼리만 조회할 뿐이며, 실제 쿼리가 수행되지는 않음.
  

📌 다음의 명령어를 Terminal 창에서 실행

python manage.py sqlmigrate '앱이름' 'makemigrations으로 생성된 파일 이름'

• 예시 ```python (mysite) c:\projects\mysite> python manage.py sqlmigrate pybo 0001 BEGIN;
• -
• • Create model Question
• - CREATE TABLE "pybo_question" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "subject" varchar(200) NOT NULL, "content" text NOT NULL, "create_date" datetime NOT NULL);
• -
• • Create model Answer
• - CREATE TABLE "pybo_answer" ("id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "content" text NOT NULL, "create_date" datetime NOT NULL, "question_id" bigint NOT NULL REFERENCES "pybo_question" ("id") DEFERRABLE INITIALLY DEFERRED); CREATE INDEX "pybo_answer_question_id_e174c39f" ON "pybo_answer" ("question_id"); COMMIT;

(mysite) c:\projects\mysite>

>- <span style="color: #EB5757">`python manage.py sqlmigrate pybo 0001`</span>명령에서 `pybo`는 앱 이름을 의미하고 `0001`은 생성된 작업파일(예: `0001_initial.py`)의 일련번호를 의미.
>- `SQL` 문에 익숙한 독자라면 데이터베이스에 어떤 일들이 벌어질지 유추할 수 있을 것이지만, 여기에 출력되는 `SQL` 문들이 무엇인지 몰라도 상관없음.
>- 장고는 이러한 `SQL` 대신 `Model`을 사용하기 때문

<br>

## 🌈 <span style='background-color: #ffffe8'>`Django shell`</span>

> 장고 셸을 실행하여 모델을 사용하는 방법
> 장고 셸은 장고에 필요한 환경들이 자동으로 설정되어 실행됨.

📌 다음의 명령어를 `Terminal` 창에서 실행

<span style="color: #EB5757">**`python manage.py shell`**</span>
<br>

### 🚦 <span style='background-color: #f0fcfc'>Question 생성</span>

- Question과 Answer 모델은 장고 셸에서 다음처럼 import하여 사용할 수 있음.
```python
>>> from pybo.models import Question, Answer

• Question 모델을 이용하여 질문 데이터를 만들기

  • Question 모델의 create_date 속성은 DateTimeField 타입이므로 timezone.now()로 현재일시를 대입.

• 아래처럼 Question 모델의 객체 q를 생성한 후 save함수를 실행하면 질문 데이터가 1건 생성됨.

  >>> from django.utils import timezone
  >>> q = Question(subject='pybo가 무엇인가요?', content='pybo에 대해서 알고 싶습니다.', create_date=timezone.now())
  >>> q.save()

• 데이터가 1건 생성되면 반드시 다음처럼 id 값이 생성됨.

  >>> q.id
  1

• id는 모델 데이터의 유일한 값으로 프라이머리 키(PK:Primary Key)라고도 함.
• 이 id 값은 데이터를 생성할 때마다 1씩 증가됨.

  >>> q = Question(subject='장고 모델 질문입니다.', content='id는 자동으로 생성되나요?', create_date=timezone.now())
  >>> q.save()
  >>> q.id
  2
  1

  
  

🚦 Question 조회 : 전체 데이터 조회

• 저장한 데이터를 조회

  >>> Question.objects.all()
  <QuerySet [<Question: Question object (1)>, <Question: Question object (2)>]>

• 저장한 Question 모델의 데이터는 Question.objects 를 통해서 조회할 수 있음.

  • Question.objects.all()은 모든 Question 데이터를 조회하는 함수임.
  • 결과값으로는 QuerySet 객체가 리턴되는데 위처럼 Question 객체를 포함하고 있음.
  • Question object (1), Question object (2) 에서 1과 2는 Question 데이터의 id 값을 의미.

• 다음처럼 Question 모델에 str 메서드를 추가하면 id 값 대신 제목을 표시할 수 있음.

📄 /pybo/urls.py

(... 생략 ...)

class Question(models.Model):
    subject = models.CharField(max_length=200)
    content = models.TextField()
    create_date = models.DateTimeField()

    def __str__(self):          # 추가한 코드
        return self.subject     # 추가한 코드

(... 생략 ...)

• 모델이 변경되었으므로 장고 셸을 재시작해야 변경된 결과를 확인할 수 있음.

  장고 셸을 종료하기 위해서는 장고 셸에서 Ctrl+Z 또는 quit()을 입력.

• 이렇게 수정하고 Question.objects.all() 함수를 다시 실행

  (mysite) c:\projects\mysite>python manage.py shell
  >>> from pybo.models import Question, Answer
  >>> Question.objects.all()
  <QuerySet [<Question: pybo가 무엇인가요?>, <Question: 장고 모델 질문입니다.>]>
  >>>

• 1과 2라는 id 값 대신 이제 제목이 표시되는 것을 확인 가능.
  

❗❗ 모델에 메서드가 추가될 경우에는 makemigrations와 migrate를 수행할 필요가 없음.

• makemigrations, migrate 명령이 필요한 경우는 모델의 속성이 변경되었을때 뿐이다.
  

🚦 특정 데이터 조회 : filter와 get

• 이번에는 filter를 사용하여 id 값이 1인 Quesiton 데이터를 조회.

  • filter는 조건에 해당되는 데이터를 모두 리턴해 주기 때문에 다건을 의미하는 QuerySet이 리턴됨.

  >>> Question.objects.filter(id=1)
  <QuerySet [<Question: pybo가 무엇인가요?>]>

• id는 유일한 값이므로 filter 대신 get을 이용하여 조회할 수도 있다.

  • get으로 조회할 경우 QuerySet이 아닌 Question 모델 객체가 리턴됨.
  • filter는 다건을 리턴하지만 get은 한 건만 리턴하기 때문.
  • 하지만 get으로 조회시 조건에 맞는 데이터가 없으면 오류가 발생
    • get은 반드시 1건의 데이터를 조회할 때 사용함.
    • 보통 get은 id와 같은 유일한 값으로 조회할 경우에만 사용.

  Code>
  >>> Question.objects.get(id=1)
  <Question: pybo가 무엇인가요?>

🚦 특정 문자열을 포함한 조회 : __contains

• 이번에는 subject에 "장고"라는 문자열이 포함된 데이터만 조회

  • subject__contains='장고'의 의미는 "subject에 '장고'라는 문자열이 포함되어 있는가?" 라고 해석할 수 있다. subject__contains 에서 언더바(_)가 1개가 아닌 2개임에 주의하자.

  >>> Question.objects.filter(subject__contains='장고')
  <QuerySet [<Question: 장고 모델 질문입니다.>]>

  
  

📌 데이터를 조회하는 filter의 사용법은 위에서 알아본 것 외에도 아주 많음.

• filter에 대한 자세한 사용법은 장고 공식 문서를 참조할 것.
• 장고 공식 문서는 장고 개발시 필수적으로 참조해야 하는 문서임.
  • https://docs.djangoproject.com/en/4.0/topics/db/queries/

🚦 Question 수정

• id 값이 2인 Question 데이터를 조회

  >>> q = Question.objects.get(id=2)
  >>> q
  <Question: 장고 모델 질문입니다.>

• subject 속성을 다음과 같이 수정

  >>> q.subject = 'Django Model Question'
  >>>

• 여기까지만 해서는 수정이 되지 않음.

  • 다음처럼 save를 수행해 주어야 변경된 데이터가 반영된다는 점을 꼭 기억할 것!!

  >>> q.save()
  >>> q
  <Question: Django Model Question>

🚦 Question 삭제

• id 값이 1인 Question 데이터를 삭제

  >>> q = Question.objects.get(id=1)
  >>> q.delete()
  (1, {'pybo.Question': 1})

• 실제로 삭제되었는지 다음처럼 Question.objects.all() 로 확인

  >>> Question.objects.all()
  <QuerySet [<Question: Django Model Question>]>

🚦 Answer 작성

• 답변 데이터를 생성

  >>> q = Question.objects.get(id=2)
  >>> q
  <Question: Django Model Question>
  >>> from django.utils import timezone
  >>> a = Answer(question=q, content='네 자동으로 생성됩니다.', create_date=timezone.now())
  >>> a.save()

• 답변 데이터를 만들기 위해서는 질문이 필요하므로 id가 2인 질문을 먼저 조회한 후 question 속성에 대입.
• Answer 모델도 Question 모델과 마찬가지로 유일한 값을 의미하는 id가 자동으로 생성됨.

  >>> a.id
  1

🚦 Answer 조회

• 답변을 조회하는 방법은 질문과 마찬가지로 Answer의 id 값을 사용

  >>> a = Answer.objects.get(id=1)
  >>> a
  <Answer: Answer object (1)>

• Answer 객체인 a를 사용하면 답변에 연결된 질문도 조회 가능

  >>> a.question
  <Question: Django Model Question>

❗❗ Answer 모델 객체인 a를 통해서 질문을 찾는것은 Answer 모델에 question 속성이 연결되어 있기 때문에 매우 쉬움.

• 그렇다면 질문을 이용하여 답변을 찾는 것은 가능?

  Yes

  • q.answer_set을 사용하면 질문에 연결된 답변을 가져올 수 있음.
  • Question 모델에는 answer_set 이라는 속성이 없지만 Answer 모델에 Question 모델이 ForignKey로 연결되어 있기 때문에 q.answer_set 과 같은 역방향 접근이 가능

  >>> q.answer_set.all()
  <QuerySet [<Answer: Answer object (1)>]>

📌 연결모델명_set 방법

• 연결모델명_set(예:answer_set)은 상식적으로 생각하면 더 쉬움.

  • 질문 하나에는 여러개의 답변이 가능하므로 q.answer_set이 가능하지만 답변 하나에는 여러개의 질문이 있을 수 없으므로 a.question_set은 불가능.
  • 답변 하나에는 질문 하나만 가능하기 때문에 a.question만 가능.

🌞 2-03. Django Admin

🌈 모델 관리

• 이미 생성한 Question 모델을 Admin에 등록하는 방법

📄 /pybo/admin.py

from django.contrib import admin
from .models import Question         # 추가한 코드

admin.site.register(Question)        # 추가한 코드

🌈 모델 검색

• 관리자 화면에서 제목(subject)으로 질문 데이터를 검색하기 위해 Search 기능 추가

  • 다음처럼 pybo/admin.py 파일을 수정
    • Question 모델에 세부 기능을 추가할 수 있는 QuestionAdmin 클래스를 생성
    • 제목 검색을 위해 search_fields 속성에 'subject'를 추가

📄 /pybo/admin.py

from django.contrib import admin
from .models import Question


class QuestionAdmin(admin.ModelAdmin):          # 추가한 코드 
    search_fields = ['subject']                 # 추가한 코드 


admin.site.register(Question, QuestionAdmin)    # 추가한 코드 

• 이렇게 수정하면 다음처럼 검색기능이 추가된 화면 확인 가능.

• 아래 두 가지 방식은 동일

  • 2번째 방식은 김형종 강사님 수업 시간에 배운 방식

❗❗ 장고 관리자에는 이 외에도 무수히 많은 기능들이 있음.

• 자세한 내용은 다음 URL을 참고.
• https://docs.djangoproject.com/en/4.0/ref/contrib/admin/

VS Code를 이용해보자!!!!!!!

🥡 확장 플러그인 설치

🥡 마크다운 파일 생성

🥡 mermaid 를 이용한 diagram 작성

• 작성 방법은 아래와 같다.

작성 예시 참고 : Mermaid github

🥡 mermaid 사용법

다이어그램 종류

🥗 순서도(Flowchart) : flowchart

• 모든 순서도는 노드, 기하학적 모양 및 가장자리, 화살표 또는 선으로 구성됨.
• mermaid 코드는 이러한 node와 edge가 만들어지고 상호 작용하는 방식을 정의함.

🥗 시퀀스 다이어그램(Sequence Diagram) : sequenceDiagram

• 공정이 서로 어떻게 그리고 어떤 순서로 작동하는지 보여주는 상호 작용 다이어그램

🥗 클래스 다이어그램(Class Diagram) : classDiagram

• 소프트웨어 공학에서 통합 모델링 언어(UML)의 클래스 다이어그램(class diagram)은 시스템의 클래스, 속성, 작업(또는 방법) 및 객체 간의 관계를 보여줌으로써 시스템의 구조를 설명하는 정적 구조 다이어그램의 한 유형

🥗 상태 다이어그램(State Diagram) : stateDiagram

• 컴퓨터 과학 및 관련 분야에서 시스템의 동작을 설명하기 위해 사용되는 다이어그램의 한 유형.
• 상태 다이어그램은 기술된 시스템이 유한한 수의 상태로 구성되어 있어야 함.

🥗 엔티티 관계도(Entity relationship diagram) : erDiagram

• 특정 지식의 영역에서 상호 연관된 관심사를 설명.
• 기본 ER 모형은 (관심 있는 것들을 분류하는) 엔티티 유형으로 구성됨.
• 엔티티 간에 존재할 수 있는 관계(그 엔티티 유형의 인스턴스)를 명시함.

🥗 사용자 이동 경로 다이어그램(User Journey Diagram) : journey

• 시스템, 애플리케이션 또는 웹 사이트 내에서 다양한 사용자가 특정 작업을 완료하기 위해 어떤 단계를 밟는지 자세히 설명.
• 이 기법은 현재(있는 그대로) 사용자 워크플로우를 보여주고, 향후 워크플로우에 대한 개선 영역을 나타냄.

🥗 간트 차트(Gantt) : gantt

• 막대 차트의 일종으로, 프로젝트 일정과 하나의 프로젝트가 완료되는 데 걸리는 시간을 보여줌.
• 간트 차트는 프로젝트의 터미널 요소와 요약 요소의 시작 날짜와 종료 날짜 사이의 일 수를 보여줌.

🥗 원형 차트(Pie Chart) : pie

• 숫자 비율을 나타내기 위해 조각으로 나누어 표현.

🥗 요구사항 다이어그램(Requirement Diagram) : requirementDiagram

• 요구사항과 요구사항의 상호 연결 및 기타 문서화된 요소에 대한 시각화를 제공.
• 모델링 사양은 SysML v1.6에 정의된 사양을 따름.

🥗 깃 다이어그램(Gitgraph Diagram) : gitDiagram

• 다양한 분기에 대한 git 커밋 및 git 액션(명령)을 그림으로 표현한 것

🥗 C4 다이어그램 (C4 Diagram) : C4Content

• 공식문서 기준으로 그릴 수는 있으나 아직 실험 중인 다이어그램

🥰 REF

🍷 Mermaid https://sabarada.tistory.com/209 https://richwind.co.kr/147 https://velog.io/@skyfishbae/마크다운-Markdown-사용법-및-Velog-용-편집기-Editor-리뷰-2

🍗 PlantUML : 추후 시간될 때 공부해보기 https://choboit.tistory.com/96?category=1066529 https://ttottoro.tistory.com/735

이 게시글은 김형종 강사님의 Django 웹개발 강의를 듣고 작성하였습니다.

🍻 DJango ORM

Django QuerySet API reference 사이트 참고

🍸 ORM과 QuerySets

🍹 ORM

• ORM이란 Object-Relational Mapping의 약자로 객체(Object)와 관계형 데이터베이스(Relational Database)의 데이터를 매핑(Mapping)해주는 것을 의미.

  • 객체 간의 관계를 바탕으로 SQL을 자동 생성하여 sql쿼리문 없이도 데이터베이스의 데이터를 다룰 수 있게 해줌.
  • 데이터베이스의 테이블을 객체지향 프로그래밍에서 흔히 사용하는 객체(Class)처럼 사용할 수 있도록 해주는 기술.
  • 기존 쿼리문을 작성하여 데이터베이스를 조작하는 것을 넘어서서 더 효율적이고 가독성 및 유지 보수에 적합한 코드를 만들기 위해 나온 기술.

🍹 QuerySets

• QuerySet 이란 데이터베이스에서 전달 받은 객체의 목록이다.

  • Django ORM에서 발생한 자료형
  • 리스트와 구조는 같지만 파이썬 기본 자료구조가 아니기 때문에 파이썬에서 읽고 쓰기 위해 자료형 변환(Casting)

🍸 ORM 실습

🍹 실습 사전 준비

1. 현재 프로젝트 폴더 내에 orm 앱 설치 후 기본 셋팅
2. model 설정 및 db 테이블 추가

models.py 코드

from django.db import models


class Member(models.Model):
    name = models.CharField(verbose_name="이름", max_length=10)
    birth = models.DateField(verbose_name="생년월일", null=True)
    email = models.EmailField(verbose_name="이메일")
    phone = models.CharField(verbose_name="전화번호", max_length=11)

    created_at = models.DateTimeField(verbose_name="생성일", auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name="갱신일", auto_now=True)

    def __str__(self):
        return f"{self.name} ({self.email})"

    class Meta:
        verbose_name = "회원"
        verbose_name_plural = "회원 목록"


class Product(models.Model):
    NEW = "new"
    OLD = "old"
    STATUS_TYPE = (
        (NEW, "신상품"),
        (OLD, "재고상품"),
    )

    code = models.CharField(verbose_name="상품코드", max_length=8)
    status = models.CharField(verbose_name="상품구분", max_length=3, choices=STATUS_TYPE)
    name = models.CharField(verbose_name="상품명", max_length=30)
    price = models.PositiveSmallIntegerField(verbose_name="가격(원)", default=0)

    created_at = models.DateTimeField(verbose_name="생성일", auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name="갱신일", auto_now=True)

    def __str__(self):
        return f"{self.name} ({self.code})"

    class Meta:
        verbose_name = "상품"
        verbose_name_plural = "상품 목록"


class PaymentOrderRecord(models.Model):
    NOT_YET = 0
    PAID = 1
    REFUND = 2
    STATUS_TYPE = (
        (NOT_YET, "결제전"),
        (PAID, "결제완료"),
        (REFUND, "환불완료"),
    )

    code = models.CharField(verbose_name="결제코드", max_length=15)
    status = models.IntegerField(verbose_name="결제구분", default=0, choices=STATUS_TYPE)
    member = models.ForeignKey(
        Member,
        verbose_name="회원",
        on_delete=models.CASCADE,
        null=True,
        related_name="member_paymentorderrecord",
    )
    product = models.ManyToManyField(
        Product, verbose_name="상품", related_name="product_paymentorderrecord"
    )

    created_at = models.DateTimeField(verbose_name="생성일", auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name="갱신일", auto_now=True)

    def __str__(self):
        return f"{self.code} ({self.product.count()}개)"

    class Meta:
        verbose_name = "결제 주문서"
        verbose_name_plural = "결제 주문서 목록"

3. orm 실습을 위한 db 생성

• 실행 파일 준비

  • 아래와 같이 management폴더 구조 만들기
    • management 폴더와 commands 폴더 내에 아무 내용도 들어 있지 않은 __init__.py 파일 필수 생성
    • commands 폴더 내에 실행 파일 생성
      • push_orm_data.py : test db 생성 시 사용
      • control_orm_data.py : orm 실습 시 사용

push_orm_data.py 코드

• 아래 코드를 해당 파일에 붙여넣고 저장
• terminal 창에서 명령어 실행
  • poetry run python manage.py push_orm_data

import datetime

from django.core.management.base import BaseCommand

from orm.models import Member, PaymentOrderRecord, Product

# TODO: 커맨드 활용
# https://docs.djangoproject.com/en/3.2/howto/custom-management-commands/#testing
    class Command(BaseCommand):
        help = "PUSH TEST DB"

        def handle(self, *args, **options):
            member_list = [
                ("이병헌", "lbh@test.com", "01017472748", datetime.date(1970, 7, 12)),
                ("박해수", "phs@test.com", "01039584378", datetime.date(1981, 11, 21)),
                ("황정민", "hjm@test.com", "01012344624", datetime.date(1970, 9, 1)),
                ("강동원", "kdw@dummy.com", "01048572738", datetime.date(1981, 1, 18)),
                ("장동건", "jdk@dummy.com", "01020302949", datetime.date(1972, 3, 7)),
                ("송강호", "skh@movie.com", "01020584737", datetime.date(1967, 1, 17)),
            ]

            product_list = [
                ("po3nuw01", "new", "휴지", 1500),
                ("92oif0rj", "new", "화장품", 30000),
                ("9oiuh67y", "old", "네스프레소", 300000),
                ("8ai2k8ww", "new", "수저", 1000),
                ("9oi8ujhy", "new", "젓가락", 500),
                ("8uhyjtd6", "old", "압력밥솥", 250000),
                ("9if56yhg", "new", "머그컵", 5000),
                ("23tyfuen", "old", "스마트폰", 1000000),
            ]

            payment_list = [
                ("20220101-9oi8u7", 0, "이병헌", 2),
                ("20220101-8ujhbg", 0, "이병헌", 3),
                ("20220101-5tgvfr", 1, "박해수", 4),
                ("20220101-4rfcdE", 2, "박해수", 1),
                ("20220101-3edcxs", 1, "송강호", 2),
                ("20220101-2wsxdd", 0, "강동원", 1),
                ("20220101-9iuj78", 1, "강동원", 3),
                ("20220101-7ujhy6", 2, "장동건", 3),
            ]

            for item in member_list:
                member, is_created = Member.objects.get_or_create(
                    name=item[0], email=item[1], phone=item[2]
                )
                member.birth = item[3]
                member.save()

            for item in product_list:
                Product.objects.get_or_create(code=item[0], status=item[1], name=item[2], price=item[3])

            for item in product_list:
                Product.objects.get_or_create(code=item[0], status=item[1], name=item[2], price=item[3])

            for item in payment_list:
                payment_order_record, is_created = PaymentOrderRecord.objects.get_or_create(
                    code=item[0]
                )

                payment_order_record.status = item[1]
                payment_order_record.member = Member.objects.get(name=item[2])

                for product in Product.objects.order_by("?")[: item[3]]:
                    payment_order_record.product.add(product)

                payment_order_record.save()

control_orm_data.py 기초 코드 작성

import datetime

from django.core.management.base import BaseCommand

from orm.models import Member, PaymentOrderRecord, Product

# TODO: 커맨드 활용
# https://docs.djangoproject.com/en/3.2/howto/custom-management-commands/#testing
class Command(BaseCommand):
    help = "CONTROL TEST DB"

    def handle(self, *args, **options):

이제 이 다음부터 아래의 실습을 이어가게 될 것이며, 코드 작성 후, terminal 창에서 파일 실행 명령을 하면 됨.

• 실행 명령어 : poetry run python manage.py control_orm_data
• 아래의 코드들은 control_orm_data.py 파일에서 handle 함수 부분의 코드에 해당.

🍹 전체 데이터 조회 : all

control_orm_data.py

    def handle(self, *args, **options):
        all_member = Member.objects.all()
        all_product = Product.objects.all()
        all_payment = PaymentOrderRecord.objects.all()

        # Member 전체 쿼리 조회
        print(all_member)
        # Product 전체 쿼리 조회
        print(all_product)
        # Payment 전체 쿼리 조회
        print(all_payment)

terminal 실행 결과

    # Member
    <QuerySet [<Member: 이병헌 (lbh@test.com)>, <Member: 박해수 (phs@test.com)>, <Member: 황정민 (hjm@test.com)>, <Member: 강동원 (kdw@dummy.com)>, <Member: 장동건 (jdk@dummy.com)>, <Member: 송강호 (skh@movie.com)>]>
    # Product
    <QuerySet [<Product: 휴지 (po3nuw01)>, <Product: 화장품 (92oif0rj)>, <Product: 네스프레소 (9oiuh67y)>, <Product: 수저 (8ai2k8ww)>, <Product: 젓가락 (9oi8ujhy)>, <Product: 압력밥솥 (8uhyjtd6)>, <Product: 머그컵 (9if56yhg)>, <Product: 스마트폰 (23tyfuen)>]>   
    # Payment
    <QuerySet [<PaymentOrderRecord: 20220101-9oi8u7 (2개)>, <PaymentOrderRecord: 20220101-8ujhbg (3개)>, <PaymentOrderRecord: 20220101-5tgvfr (4개)>, <PaymentOrderRecord: 20220101-4rfcdE (1개)>, <PaymentOrderRecord: 20220101-3edcxs (2개)>, <PaymentOrderRecord: 20220101-2wsxdd (1개)>, <PaymentOrderRecord: 20220101-9iuj78 (3개)>, <PaymentOrderRecord: 20220101-7ujhy6 (3개)>]>

🍹 데이터 검색 (filter) : 데이터 포함 'contains' 외

🍾 Case 1. 전체 일치

control_orm_data.py

    def handle(self, *args, **options):
        # Filter : 
        filter_member = Member.objects.filter(name="강동원")
        print(filter_member)

terminal 실행 결과

    <QuerySet [<Member: 강동원 (kdw@dummy.com)>]>

🍾 Case 2. 일부 포함 : '__contains='

control_orm_data.py

    def handle(self, *args, **options):
        filter_member = Member.objects.filter(name__contains="강")
        print(filter_member)

    # 대소문자 구분
    filter_payment = PaymentOrderRecord.objects.filter(code__contains="E")
    print(filter_payment)
    filter_payment = PaymentOrderRecord.objects.filter(code__contains="e")
    print(filter_payment)

terminal 실행 결과

    <QuerySet [<Member: 강동원 (kdw@dummy.com)>, <Member: 송강호 (skh@movie.com)>]>

# 대문자와 소문자를 다르게 결과가 같다?!!
<QuerySet [<PaymentOrderRecord: 20220101-4rfcdE (1개)>, <PaymentOrderRecord: 20220101-3edcxs (2개)>]>
<QuerySet [<PaymentOrderRecord: 20220101-4rfcdE (1개)>, <PaymentOrderRecord: 20220101-3edcxs (2개)>]>

🍗 contains vs icontains 차이

• contains : 대문자와 소문자를 구분
• icontains : 대문자와 소문자를 동일한 데이터로 취급

• 단, sqlite에서는 contains를 사용하더라도 대소문자 구분 없이 동일한 값을 조회.
• Django를 이용한 Search 기능 구현 시, icontains를 많이 사용
• 이것보다 한 단게 더 진화한게 ES (Elastic Search)

🍗 ES (Elastic Search) : 추후 학습 시 내용 보충 예정

• 형태소 단위로 나눠서 db화 시켜서 search를 진행

🍾 Case 3. 시작 부분에 포함 : 'startswith`

추후 __startswith=, __endswith= 내용 보충 예정 자매품 __istartswith=, __iendswith=도 있음.

🍹 데이터 검색 (filter) : 크기 비교 '__lt=' 외

• __gt= : greater than
• __gte= : greater than or equal to
• __lt= : less than
• __lte= : less than or equal to

control_orm_data.py

    def handle(self, *args, **options):
        filter_product = Product.objects.filter(price__lte=1000)

    print(filter_product)

    for item in filter_product:
        print(item.price)

terminal 실행 결과

    <QuerySet [<Product: 수저 (8ai2k8ww)>, <Product: 젓가락 (9oi8ujhy)>]>

1000
500

🍹 데이터 검색 (filter) : ChoiceField 관련 조회

• ChoiceField 데이터 관련 filter의 경우에는 status값에 모델명.상태값으로 지정해야 함.

models.py 에서 Product 모델 클래스 내용

    class Product(models.Model):
        NEW = "new"
        OLD = "old"
        STATUS_TYPE = (
            (NEW, "신상품"),
            (OLD, "재고상품"),
        )

    code = models.CharField(verbose_name="상품코드", max_length=8)
    status = models.CharField(verbose_name="상품구분", max_length=3, choices=STATUS_TYPE)
    name = models.CharField(verbose_name="상품명", max_length=30)
    price = models.PositiveSmallIntegerField(verbose_name="가격(원)", default=0)

    created_at = models.DateTimeField(verbose_name="생성일", auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name="갱신일", auto_now=True)

    def __str__(self):
        return f"{self.name} ({self.code})"

    class Meta:
        verbose_name = "상품"
        verbose_name_plural = "상품 목록"

control_orm_data.py

    def handle(self, *args, **options):
        filter_product = Product.objects.filter(price__lte=1000, status=Product.NEW)
        print(filter_product)

terminal 실행 결과

    <QuerySet [<Product: 수저 (8ai2k8ww)>]>

🍓 filter는 2개 이상 적용 가능

🍹 데이터 개수 세기 (Count)

control_orm_data.py

    def handle(self, *args, **options):
       all_member_count = len(all_member)
        print(all_member_count)

    all_member_count = all_member.count()
    print(all_member_count)

terminal 실행 결과

    6
    6

🍓 단, len보다 count를 사용할 것!!

• len도 결국 QuerySets 내부에 메서드로 구현이 되어 있으나
• len 함수는 결국 내부에서 count 메서드를 다시 호출하는 구조로 되어있기 때문에 미세하지만 속도가 조금 더 느림.

🍹 데이터 연산 (aggregate) - Sum, Avg / Max, Min

control_orm_data.py

# 아래 코드에서 'data'는 변수명이며, 임의로 지정 가능
from django.db.models import Sum, Avg, Max, Min

def handle(self, *args, **options):
    # Sum
    all_product_total = all_product.aggregate(data=Sum("price"))
    print(all_product_total)
    # Avg
    all_product_average = all_product.aggregate(data=Avg("price"))
    print(all_product_average)
    # Max
    all_product_max = all_product.aggregate(data=Max("price"))
    print(all_product_max)
    # Min
    all_product_min = all_product.aggregate(data=Min("price"))
    print(all_product_min)

terminal 실행 결과

   # Sum
    {'data': 1588000}
   # Avg
    {'data': 198500.0}
   # Max
    {'data': 1000000}
   # Min
    {'data': 500}

🍹 원하는 필드(컬럼)만 추출 (values)

control_orm_data.py

    def handle(self, *args, **options):
        all_product_status = all_product.values("status")
        print(all_product_status)
        print(type(all_product_status))

        all_product_status_list = all_product.values_list("status")
        print(all_product_status_list)
        print(type(all_product_status_list))

        all_product_status_list = all_product.values_list("status", flat=True)
        print(all_product_status_list)
        print(type(all_product_status_list))

    all_product_status_real_list = list(all_product_status_list)
    print(all_product_status_real_list)
    all_product_status_distinct_list = list(set(lall_product_status_list))
    print(all_product_status_distinct_list)

terminal 실행 결과

    <QuerySet [{'status': 'new'}, {'status': 'new'}, {'status': 'old'}, {'status': 'new'}, {'status': 'old'}, {'status': 'old'}, {'status': 'new'}, {'status': 'old'}]>
    <class 'django.db.models.query.QuerySet'>

<QuerySet [('new',), ('new',), ('old',), ('new',), ('old',), ('old',), ('new',), ('old',)]>
<class 'django.db.models.query.QuerySet'>

<QuerySet ['new', 'new', 'old', 'new', 'old', 'old', 'new', 'old']>
<class 'django.db.models.query.QuerySet'>

['new', 'new', 'old', 'new', 'old', 'old', 'new', 'old']
['new', 'old']

🍹 데이터 정렬 (order by)

control_orm_data.py

    def handle(self, *args, **options):
        # 오름차순
        all_product_asc = all_product.order_by("price")
        print(all_product_asc)
        # 내림차순
        all_product_dsc = all_product.order_by("-price")
        print(all_product_dsc)

    # 내림차순 정렬 후 가격만 확인
    for item in all_product_dsc:
        print(item.price)

    # random으로 정렬
    all_product_random = all_product.order_by("?")
    print(all_product_random)
    # 렌덤으로 하나의 결과만 추출
    #   방법 1
    choice_product_random = all_product.order_by("?")[0]
    print(choice_product_random)    
    #   방법 2
    index = randint(0, Product.objects.count() - 1)
    product = Product.objects.all()[index]
    print(product)

terminal 실행 결과

        # 오름차순
        <QuerySet [<Product: 젓가락 (9oi8ujhy)>, <Product: 수저 (8ai2k8ww)>, <Product: 휴지 (po3nuw01)>, <Product: 머그컵 (9if56yhg)>, <Product: 화장품 (92oif0rj)>, <Product: 압력밥솥 (8uhyjtd6)>, <Product: 네스프레소 (9oiuh67y)>, <Product: 스마트폰 (23tyfuen)>]>
        # 내림차순
        <QuerySet [<Product: 스마트폰 (23tyfuen)>, <Product: 네스프레소 (9oiuh67y)>, <Product: 압력밥솥 (8uhyjtd6)>, <Product: 화장품 (92oif0rj)>, <Product: 머그컵 (9if56yhg)>, <Product: 휴지 (po3nuw01)>, <Product: 수저 (8ai2k8ww)>, <Product: 젓가락 (9oi8ujhy)>]> 

    # 내림차순 정렬 후 가격만 확인
    1000000
    300000
    250000
    30000
    5000
    1500
    1000
    500

    # random으로 정렬
    <QuerySet [<Product: 휴지 (po3nuw01)>, <Product: 네스프레소 (9oiuh67y)>, <Product: 머그컵 (9if56yhg)>, <Product: 압력밥솥 (8uhyjtd6)>, <Product: 젓가락 (9oi8ujhy)>, <Product: 화장품 (92oif0rj)>, <Product: 수저 (8ai2k8ww)>, <Product: 스마트폰 (23tyfuen)>]>  
    # random 정렬 후 하나만 뽑아오기
    #   방법 1
    화장품 (92oif0rj)
    #   방법 2
    압력밥솥 (8uhyjtd6)

🍹 데이터 검색 (filter) : 외래키(Foreign Key) 참조

🥡 먼저, 각 모델에 대해 살펴보자.

PaymentOrderRecord 모델

• 아래와 같이 member라는 filed를 가지고 있는데, 이것은 Member라는Field를 외래키로 가지고 있음.

        member = models.ForeignKey(
                Member,
                verbose_name="회원",
                on_delete=models.CASCADE,
                null=True,
                related_name="member_paymentorderrecord",
            )

Member 모델

• 아래와 같이 name이라는 Field를 가지고 있음.

    class Member(models.Model):
        name = models.CharField(verbose_name="이름", max_length=10)
        birth = models.DateField(verbose_name="생년월일", null=True)
        email = models.EmailField(verbose_name="이메일")
        phone = models.CharField(verbose_name="전화번호", max_length=11)
  

    created_at = models.DateTimeField(verbose_name="생성일", auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name="갱신일", auto_now=True)

🥡 이것을 이용한 데이터 조회

control_orm_data.py

    def handle(self, *args, **options):
        # 송강호라는 사람이 구매한 주문서 출력
        payment_by_name = all_payment.filter(member__name="송강호")
        print(payment_by_name)
        # 머그컵을 구매한 주문서 출력
        payment_by_product = all_payment.filter(product__name="머그컵")
        print(payment_by_product)

terminal 실행 결과

    <QuerySet [<PaymentOrderRecord: 20220101-3edcxs (2개)>]>

<QuerySet [<PaymentOrderRecord: 20220101-9oi8u7 (2개)>]>

🍹 데이터 검색 (filter) : 가상의 필드(annotate) 이용

🥡 PaymentOrderRecord라는 모델에 member라는 필드는 있지만, member_name이라는 필드는 없음.

• 이럴 때, 해당 필드를 생성해서 붙여주는 작업을 하는 것이 바로 annotate의 역할

  • 주의할 것!!
    • 어떤 필드에 접근하려면 하나의 객체여야만 함.
    • 쿼리셋에 대한 리스트이면 특정 필드에 접근할 수 없음.
    • 그래서 last() 메서드를 붙여서 하나의 객체를 추출한 것임.

control_orm_data.py

    def handle(self, *args, **options):
        all_payment_annotate = all_payment.annotate(member_name=F("member__name"))

    print(type(all_payment_annotate))
    print(type(all_payment_annotate.last()))

    # print(all_payment_annotate.member_name)
    print(all_payment_annotate.last().member_name)

    for item in all_payment_annotate:
        print(item.member_name)

terminal 실행 결과

    <class 'django.db.models.query.QuerySet'>  # 쿼리셋
    <class 'orm.models.PaymentOrderRecord'>    # 하나의 row

장동건

이병헌
이병헌
박해수
박해수
송강호
강동원
강동원
장동건

🍹 데이터 검색 (filter) : 특정 범위 내에서 찾기(in)

🥡 내가 찾고싶은 리스트 목록을 미리 지정하고, 내가 가진 데이터 값들 중 해당 리스트 내에 있는 것들만 조회할 때 사용

control_orm_data.py

    def handle(self, *args, **options):
        price_list = [500, 1000]
        product_in_the_list = all_product.filter(price__in=price_list)

    print(product_in_the_list)

terminal 실행 결과

    <QuerySet [<Product: 수저 (8ai2k8ww)>, <Product: 젓가락 (9oi8ujhy)>]>

🍹 개별 실습

🍾 Q1. 결제 전 상태의 고객의 이름을 출력

control_orm_data.py

    def handle(self, *args, **options):
        find_customer_name = all_payment.filter(status=PaymentOrderRecord.NOT_YET).values_list(
            "member__name", flat=True
        )

    print(find_customer_name)
    print(list(set(find_customer_name)))

terminal 실행 결과

    <QuerySet ['이병헌', '이병헌', '강동원']>
    ['이병헌', '강동원']

🍾 Q2. 화장품을 주문하고, 환불한 고객의 이름 출력

control_orm_data.py

    def handle(self, *args, **options):
        find_customer_name = all_payment.filter(product__name="화장품", status=PaymentOrderRecord.REFUND).values_list("member__name", flat=True)

    print(find_customer_name)

terminal 실행 결과

    <QuerySet []>

🏁 ref

Django 공식 문서 > QuerySet API reference ORM 쿼리 최적화 Django > 반드시 알아야 할 5가지 ORM 쿼리 (엑셀만큼 쉬운) Django Annotation/Aggregation

🚦 2장. 의미있는 이름

🚀 소프트웨어에서 이름은 어디나 쓰임

• 변수, 함수, 인자, 클래스, 패키지, 소스파일, 심지어 소스파일이 담긴 디렉토리 등등   → 이렇게나 많이 사용하므로 이름을 잘 지으면 여러모로 편리함.

• 이름을 잘 짓는 간단한 규칙에 대한 학습을 시-작!!

  
  ## 🚀 `의도를 분명히 밝혀라`

• 좋은 이름을 지으려면 시간이 걸리지만 좋은 이름으로 절약하는 시간이 훨씬 더 많음.

• 이름을 주의 깊게 살펴 더 나은 이름이 떠오르면 개선할 것.

• 이름을 잘 지으면 코드를 읽는 사람이 좀 더 행복해 질 수 있음.

• 변수/함수/클래스의 이름은 존재 이유/수행 기능/사용 방법과 같은 질문에 답할 수 있어야 함.

  
  

🚀 그릇된 정보를 피하라

• 프로그래머는 코드에 그릇된 단서를 남겨서는 안됨   → 그릇된 단서는 코드 의미를 흐림.
• 나름대로 널리 쓰이는 의미가 있는 단어를 다른 의미로 사용해도 안됨. (e.g. list)
• 서로 흡사한 이름을 사용하지 않도록 주의할 것
• 유사한 개념은 유사한 표기법을 사용하고 이것도 정보에 해당됨.
• 일관성이 떨어지는 표기법은 그릇된 정보임.
  

🚀 의미 있게 구분하라

• 컴파일러나 인터프리터만 통과하려는 생각으로 코드를 구현하는 프로그래머는 스스로 문제를 일으킴.
• 동일한 범위 안에서 다른 두 개념에 같은 이름을 사용하지 못하기 때문에 한쪽 이름을 고치려다가 잘못 고치는 순간 컴파일이 불가능한 상황에 빠짐.
• 연속적인 숫자를 덧붙인 이름(a1, a2, …, aN)은 그릇된 정보를 제공하는 이름도 아니고, 아무런 정보를 제공하지 못하는 이름일 뿐, 저자 의도가 전혀 드러나지 않음.
  불용어를 추가한 이름 역시 아무런 정보도 제공하지 못함.
    → a나 the같은 접두사이더라도 의미가 분명히 다르다면 사용해도 무방.
• 읽는 사람이 차이를 알도록 이름을 붙여라   → 나쁜 예시 : getctiveAcount(), getctiveAcounts(), getctiveAcountInfo()
  

🚀 발음하기 쉬운 이름을 사용하라

• 두뇌에서 상당한 부분은 단어라는 개념만 전적으로 처리하고, 정의상으로 단어는 발음이 가능하므로, 발음하기 쉬운 이름을 선택하는 것이 좋음.
  

🚀 검색하기 쉬운 이름을 사용하라

• 문자 하나를 사용하는 이름과 상수는 텍스트 코드에서 쉽게 눈에 띄지 않는다는 문제점이 있음
• 짧은 숫자나 문자는 여러 군데에서 등장하므로 긴 이름이 짧은 이름보다 좋고, 검색하기 쉬운 이름이 상수보다 좋음.
• 한 문자만 사용하고 싶다면, 간단한 메서드에서 로컬 변수를 지정할 때 사용할 것.
• 이름 길이는 범위 크기에 비례해야 하며, 변수나 상수를 코드 여러 곳에서 사용한다면 검색하기 쉬운 이름이 바람직함.
  

🚀 인코딩을 피하라

• 이름에 인코딩할 정보는 매우 많으며, 유형이나 범위까지 인코딩에 넣으면 그만큼 해독이 어려워짐.
• 때로는 인코딩이 필요한 경우도 있음.
    → 인터페이스 클래스와 구현 클래스
  

🚀 자신의 기억력을 자랑하지 마라

• 변수 이름을 자신이 아는 이름으로 변환해야 한다면 그 변수 이름은 바람직하지 않음.
• 일반적으로 문제 영역이나 해법 영역에서 사용하지 않는 이름을 선택했기 때문에 생기는 문제.
• 루프에서 반복 횟수를 세는 변수는 문자 하나만 사용해도 괜찮음.
    → 소문자 L은 제외하며, 루프 범위가 아주 작고 다른 이름과 충돌하지 않을 경우에 한정.
• 똑똑한 프로그래머와 전문가 프로그래머 사이에서 나타나는 차이점 하나만 들자면, 전문가 프로그래머는 명료함이 최고라는 사실을 이해함.
    → 전문가 프로그래머는 자신의 능력을 좋은 방향으로 사용해 남들이 이해하는 코드를 내놓음.
  

🚀 클래스 이름

• 클래스 이름과 객체 이름은 명사나 명사구가 적합함.
• 좋은 예 : Customer, WikiPage, Account, AddressParser
• 나쁜 예 : Manager, Processor, Data, Info 등과 같은 단어.               → 동사는 아예 사용하지 않음.
  

🚀 메서드 이름

• 메서드 이름은 동사나 동사구가 적합.

  • 좋은 예 : postPayment, deletePage, save 등
  • 접근자(Accessor), 변경자(Mutator), 조건자(Predicate)는 javabean 표준에 따라 값 앞에 get, set, is를 붙임.

• 생성자(Constructor)를 중복정의(overload)할 때는 정적 팩토리 메서드를 사용함.   → 메서드는 인수를 설명하는 이름을 사용함.

  
  

🚀 기발한 이름은 피하라

• 이름이 너무 기발하면 기억할 사람만 그 이름을 기억함.
• 재미난 이름보다 명료한 이름을 선택하라.
• 의도를 분명하고 솔직하게 표현하라
  

🚀 한 개념에 한 단어를 사용하라

• 추상적인 개념 하나에 단어 하나를 선택해 이를 고수하게 되면 어느 클래스에서 어느 이름을 썼는지 기억하기 어려움.   → 예를 들어, 클래스마다 같은 메서드 이름을 사용하는 것.
• 이클립스, 인텔리제이 등과 같은 최신 IDE는 문맥에 맞는 단어를 제공함.

  • 예를 들어, 객체를 사용하면 그 객체가 제공하는 메서드 목록을 보여줌.
  • 하지만 목록은 보통 함수 이름과 매개변수만 보여줄 뿐 주석은 보여주지 않음.

• 따라서 메서드 이름은 독자적이고 일관적이어야 함.
• 일관성 있는 어휘는 코드를 사용할 프로그래머가 반갑게 여길 선물임.
  

🚀 말장난을 하지 마라

• 한 단어를 두 가지 목적으로 사용하지 말 것
• 여러 클래스에서 한 단어를 동일한 기능의 메서드에 사용하게 되더라도 그 메서드의 매개변수와 반환 값이 의미적으로 똑같다면 문제가 없음.
• 프로그래머는 코드를 최대한 이해하기 쉽게 짜야 함.
• 집중적인 탐구가 필요한 코드가 아니라 대충 훑어봐도 이해할 코드 작성이 목표임.
  

🚀 해법 영역에서 가져온 이름을 사용하라

• 코드를 읽을 사람도 프로그래머이기 때문에 전산 용어, 알고리즘 이름, 패턴 이름, 수학 용어 등은 사용해도 괜찮음.
  

🚀 문제 영역에서 가져온 이름을 사용하라

• 적절한 '프로그래머 용어'가 없다면 문제 영역에서 이름을 가져올 것.
• 그러면 코드를 보수하는 프로그래머가 분야 전문가에게 의미를 물어 파악할 수 있음.
• 우수한 프로그래머와 설계자라면 해법 영역과 문제 영역을 구분할 줄 알아야 함.
• 문제 영역 개념과 관련이 깊은 코드라면 문제 영역에서 이름을 가져와야 함
  

🚀 의미 있는 맥락을 추가하라

• 스스로 의미가 분명한 이름이 없지는 않지만 대다수의 이름은 그렇지 못함.
• 그래서 클래스, 함수, 이름 공간에 넣어 맥락을 부여함.
• 모든 방법이 실패하면 마지막 수단으로 접두어를 붙임.
  

🚀 불필요한 맥락을 없애라

• 고급 휘발유 충전소(Gas Station Deluxe) 라는 애플리케이션을 짠다고 가정.
• 모든 클래스 이름을 GSD로 시작하게 된다면 IDE에서 G를 입력하고 자동완성 키를 누르는 순간 모든 클래스를 열거하기 때문에 현명하지 못함.
• 일반적으로는 의미가 분명한 경우에 한해 짧은 이름이 긴 이름보다 좋음.
• accountAddress와 customerAddress는 Address 클래스의 인스턴스로는 좋은 이름이나, 클래스 이름으로 적합하지 못함.
  

🚀 마치면서

• 좋은 이름을 선택하려면 설명 능력이 뛰어나야 하고 문화적 배경이 같아야 함
• 좋은 이름을 선택하는 능력은 기술, 비즈니스, 관리 문제가 아닌 교육 문제임
• 사람들이 이름을 바꾸지 않으려는 이유 하나가 다른 개발자가 반대할까 두려워서임.
• 그러나 오히려 좋은 이름으로 바꿈으로써 코드 가독성이 높아짐.
• 다른 사람이 짠 코드를 손본다면 리팩터링 도구를 사용해 문제 해결 목적으로 이름을 개선하는 것이 좋음.
• 이것은 단기적인 효과는 물론 장기적인 이익도 보장함.

🚦 1장. 깨끗한 코드

🚀 Code

✔ 기계가 실행할 정도로 상세하게 요구사항을 명시하는 작업(프로그래밍)의 결과 ✔ 요구사항을 표현하는 언어

• 앞으로 프로그래밍 언어에서 추상화 수준은 점차 높아질 것이며 특정 응용 분야에 적합한 프로그래밍 언어 수도 점차 많아질 것임.
• 고도로 추상화된 언어나 특정 응용 분야 언어로 기술하는 명세 역시 코드이며 어떤 언어를 사용하든 코드는 기계가 이해하고 실행할 정도로 엄밀하고 정확하고 상세하고 정형화되어야 하기 때문에 코드는 사라지지 않을 것임.

🚀 나쁜 코드

✔ 나쁜 코드는 개발 속도를 크게 떨어뜨림. ✔ 코드를 고칠 때마다 엉뚱한 곳에서 문제가 생기고, 매번 얽히고 설킨 코드를 '해독'해서 얽히고 설킨 코드를 더함. ✔ 시간이 지나면서 쓰레기 더미는 점점 높아지고 깊어지고 커지기 때문에 청소할 방법이 없는 불가항력의 존재임.

• 나쁜 코드가 쌓일수록 팀 생산성은 떨어지기 시작해 0으로 근접함.
• 생산성을 증가시키려고 프로젝트에 새 인력을 투입하지만 시스템 설계에 대한 조예가 깊지 않기 때문에 결국은 나쁜 코드를 더 많이 양산하게 되어 생산성은 더더욱 0에 수렴.
• 이로 인해 원대한 재설계의 꿈을 가지고 새로운 타이거 팀이 구성됨.
• 가장 유능하고 똑똑한 사람들만 타이거 팀으로 차출되며 나머지는 계속해서 현재 시스템을 유지보수.
• 그러나 때때로 경주는 아주 오랫동안 이어져 새 시템이 기존 시스템을 따라잡을 즈음이면 초창기 타이거 팀원들은 모두 떠나고 새로운 팀원들이 새 시스템을 설계하고자 나섬. ( ∵ 현재 시스템이 너무 엉망이어서 )

🚀 좋은 코드가 나쁜 코드로 전락하게 되는 이유

• 원래 설계를 뒤집는 방향으로 요구사항이 변했기 때문
• 일정이 촉박해 제대로 할 시간이 없었기 때문
• 멍청한 관리자와 조급한 고객, 쓸모없는 마케팅 부서 때문

🚩 그러나 결국 잘못은 전적으로 프로그래머에게 있는 것!!!

✔ 프로그래머라면 누구나 나쁜 코드가 업무 속도를 늦춘다는 사실을 익히 알지만, 기한을 맞추기 위해 나쁜 코드를 양산할 수밖에 없다고 느낌. ✔ 그러나 나쁜 코드를 양산하면 엉망진창인 상태로 인해 속도가 늦어져 결국 기한을 맞추지 못함.

🚩 기한을 맞추며 빨리 갈 수 있는 유일한 방법은 언제나 코드를 최대한 깨끗하게 유지하는 습관임.

🚀 깨끗한 코드는 어떻게 작성하나?

• 누구나 깨끗한 코드와 나쁜 코드를 구분할 줄 알더라도, 깨끗한 코드를 작성할 줄 알지는 않음.

• 깨끗한 코드를 작성하려면 '청결'이라는 힘겹게 습득한 감각을 활용해 자잘한 기법들을 적용하는 절제와 규율이 필요함. ✔ 여기서 키 포인트는 '코드 감각'임. ✔ 누군가는 그것을 타고나지만, 또 누군가는 투쟁해서 얻어야 함. ✔ 거기에 절제와 규율을 적용해 나쁜 코드를 좋은 코드로 바꾸는 전략도 필요함

• '코드 감각'이 없는 프로그래머도 때로는 나쁜 모듈을 알아보지만, '코드 감각' 이 있는 프로그래머는 나쁜 모듈을 보면 좋은 모듈로 개선할 방안을 떠올리고, 최고의 방안을 선택하여 계획을 세움.

🚀 깨끗한 코드란?

🚢 비야네 스트롭스트룹

C++ 창시자이자 『The C++ Programming Language』 저자

• 나는 우아하고 효율적인 코드를 좋아한다.
• 논리가 간단해야 버그가 숨어들지 못한다.
• 의존성을 최대한 줄여야 유지보수가 쉬워진다.
• 오류는 명백한 전략에 의거해 철저히 처리한다.
• 성능을 최적으로 유지해야 사람들이 원칙 없는 최적화로 코드를 망치려는 유혹에 빠지지 않는다.
• 깨끗한 코드는 한 가지를 제대로 한다.

🌞 그에게 깨끗한 코드란! ✔ 보는 사람에게 즐거움을 선사해야 함. ✔ 세세한 사항까지 꼼꼼하게 처리하는 코드 ✔ 각 함수와 클래스와 모듈은 주변 상황에 현혹되거나 오염되지 않고 한 가지 길을 걷는 코드여야 함.

🌑 나쁜 코드는 속도도 느리고 CPU 자원도 낭비하며, 보기에도 즐겁지 않으며, 또 다른 나쁜 코드를 유혹함.

🚢 데이브 토마스와 앤디 헌트

실용주의 프로그래머 ✔ 나쁜 코드는 깨진 창문과도 같음. ✔ 창문이 깨진 건물은 누구도 상관하지 않는다는 인상을 풍기며 사람들도 관심을 끊음.

🚢 그래디 부치

『Object Oriented Analysis and Design with Application』 저자

• 깨끗한 코드는 단순하고 직접적임.
• 깨끗한 코드는 잘 쓴 문장처럼 읽힘
• 깨끗한 코드는 결코 설계자의 의도를 숨기지 않음.
• 오히려 명쾌한 추상화와 단순한 제어문으로 가득함.

✔ 가독성을 강조하여 깨끗한 코드가 잘 쓴 문장처럼 읽혀야 함. ✔ 코드는 추측이 아니라 사실에 기반해야 하며 반드시 필요한 내용만 담겨야 함. ✔ 코드를 읽는 사람에게 프로그래머가 단호하다는 인상을 줘야 함.

🚢 '큰' 데이브 토마스

PTO 창립자이자 이클립스 전략의 대부

• 깨끗한 코드는 작성자가 아닌 사람도 읽기 쉽고 고치기 쉽다.
• 단위 테스트 케이스와 인스 테스트 케이스가 존재한다.
• 깨끗한 코드에는 의미 있는 이름이 붙는다.
• 특정한 목적을 달성하는 방법은 (여러 가지가 아니라) 하나만 제공한다.
• 의존성은 최소이며 각 의존성을 명확히 정의한다.
• API는 명확하여 최소로 줄였다.
• 언어에 따라 필요한 모든 정보를 코드만으로 명확히 표현할 수 없기에 코드는 문학적으로 표현해야 마땅하다.

✔ 깨끗한 코드란 다른 사람이 고치기 쉬워야 함. ✔ 테스트 케이스가 없는 코드는 깨끗한 코드가 아님. ✔ 깨끗한 코드를 만들기 위해서는 인간이 읽기 좋은 코드를 작성하면 됨.

🚢 마이클 페더스

『Working Effectively with Legacy Code』 저자

• 깨끗한 코드의 특징은 많지만 그 중에서도 모두를 아우르는 특징이 하나 있다.
• 깨끗한 코드는 언제나 누군가 주의 깊게 짰다는 느낌을 준다.
• 고치려고 살펴봐도 딱히 손 댈 곳이 없다.
• 작성자가 이미 모든 사항을 고려했으므로, 고칠 궁리를 하다보면 언제나 제자리로 돌아온다.
• 그리고는 누군가 남겨준 코드, 누군가 주의 깊게 짜놓은 작품에 감사를 느낀다.

✔ 깨끗한 코드는 주의 깊게 작성한 코드. ✔ 즉, 누군가 시간을 들여 깔끔하고 단정하게 세세한 사항까지 꼼꼼하게 신경쓴 코드.

🚢 론 제프리스

『Extreme Programming Installed』와 『Extreme Programming Adventure in C#』 저자

• 최근들어 나는 켄트 백이 제안한 단순한 코드 규칙으로 구현을 시작한다.
  (그리고 같은 규칙으로 구현을 거의 끝낸다.)
• 중요한 순으로 나열하자면 간단한 코드는

  • 모든 테스트를 통과한다.
  • 중복이 없다.
  • 시스템 내 모든 설계 아이디어를 표현한다.
  • 클래스, 메서드, 함수 등을 최대한 줄인다.

✔ 중복이 있다는 것은 코드가 아이디어를 제대로 표현하지 못한다는 증거임.
✔ 표현력은 의미 있는 이름을 포함함.
✔ 여러 기능을 수행하는 객체나 메서드를 찾아서,

    1. 객체가 여러 기능을 수행한다면 여러 객체로 나눈다.
    2. 메서드가 여러 기능을 수행한다면 메서드  추출 리팩터링 기법을 적용해
    3. 기능을 명확히 기술하는 메서드 하나와 기능을 실제로 수행하는 메서드 여러 개로 나눈다.

🌝 결론적으로 깨끗한 코드를 만드는 비결이란 중복 줄이기, 표현력 높이기, 초반부터 간단한 추상화 고려하기!!

🚢 워드 커닝햄

위키 창시자. 피트 창시자. 익스트림 프로그래밍 공동 창시자

• 코드를 읽으면서 짐작했던 기능을 각 루틴이 그대로 수행한다면 깨끗한 코드라 불러도 되겠다.
• 코드가 그 문제를 풀기 위한 언어처럼 보인다면 아름다운 코드라 불러도 되겠다.

✔ 깨끗한 코드는 코드를 독해하느라 머리를 쥐어짤 필요가 없어야 함. ✔ 읽으면서 짐작한 대로 돌아가는 코드가 깨끗한 코드임. ✔ 코드가 그 문제를 풀기 위한 언어처럼 보인다는 것은 언어를 단순하게 보이도록 만든다는 것을 뜻하며 그것은 프로그래머에게 달려있음.

🚢 저자 생각

🌞 코드를 잘 짜려면 새 코드를 짜면서 끊임없이 기존 코드를 읽어야 함.

• 주변 코드를 읽지 않으면 새 코드를 짤 수 없음.
• 주변 코드가 읽기 쉬우면 새 코드를 짜기도 쉬움.
• 코드를 빠르게 짜기 위해서는 코드를 읽기 쉽게 만들면 됨.
  

🌞 보이스카우트 규칙

• 체크아웃할 때보다 좀 더 깨끗한 코드를 체크인한다면 코드는 절대 나빠지지 않음.
• 변수 이름 하나를 개선하고, 조금 긴 함수 하나를 분할하고, 약간의 중복을 제거하고, 복잡한 if문 하나를 정리하면 충분함.

• 내장 템플릿 태그 및 필터
  

🛴 템플릿(template) 언어

• Django의 템플릿 언어(template language)는 강력함과 편리함 사이의 균형을 잡고자 설계됨.
• 템플릿 언어를 사용하면 HTML 작업을 훨씬 수월하게 할 수 있음.
• python 변수 및 문법을 html 안에서 쓸 수 있도록 Django에서 제공해주는 언어이기 때문에 html과도 python과도 조금 다름.
• 하지만 직관적이고 사용하는데 있어서 고도의 학습량을 요구하지 않음.
  

🛴 템플릿 변수

• 템플릿 변수를 사용하면 뷰에서 템플릿으로 객체를 전달 가능.
• 사용 방법 : {{ 변수 }}
• 점(.) 은 변수의 속성에 접근할 때 사용.
  
• Django의 view에서 template으로 context를 전달할 수 있음.
• 즉, 함수(CBV 혹은 FBV)에서 html 문서로 어떠한 객체를 보낼 수 있다는 것.

  {{ section.title}}

  • view에서 section이라는 객체를 html 문서로 보냈을 것이고,
  • 그 section이라는 객체 안에는 title이라는 속성을 가지고 있을 것임.

🔥 Django에서는 장고 템플릿 변수를 사용하여 html 문서 상에서도 어떠한 객체의 속성들에 접근할 수 있고, 이를 출력할 수 있도록 지원.

🛴 템플릿 필터

• 사용 방법 : {{ 변수.속성 | 필터 }}
• 템플릿 변수의 값을 특정 형식으로 변환할 때 사용하고, 형식은 템플릿 변수 다음에 바(|)를 그은 다음 적용하고자 하는 필터를 명시.

  {{ story.headline | upper }}

  • 여기서, upper와 같은 것들이 바로 템플릿 필터
  • upper라고 명시하였으므로, story.headline의 값을 대문자 형식으로 변환

🔥 위의 링크에서 30개 정도의 필터 내용 확인 가능.

🛴 템플릿 태그

• 사용 방법 : {% %}
• {% load static %}와 같이 사용할 수도 있고, 위의 예제에서 볼 수 있듯이 if문 또는 for문과 같이 흐름을 제어할 수 있도록 작성도 가능.
  
• HTML 문서는 프로그래밍 언어가 아니고 마크업 언어이기 때문에 단지 문서를 웹에서 띄워주는 역할을 하게 됨.
• 그렇기 때문에 HTML 자체는 프로그래밍적 로직을 구현 불가
  • 그러나, if문, for문와 같은 템플릿 태그를 사용한다면 프로그래밍적 로직을 구현 가능.
• 따라서 앞에서 배웠던 템플릿 변수와 템플릿 태그를 활용한다면 간단한 처리도 가능하게 됨.
  
• {% extends %}와 같이 단독으로 사용할 수 있는 템플릿 태그들도 있지만, {% if %} 처럼 뒤에 {% endif %} 템플릿 태그를 반드시 닫아주어야 하는 것들도 있음.

🔥 위의 링크에서 상세 내용 확인 가능.

🛴 템플릿 코멘트

• 말 그대로 HTML 문서 상에서 코멘트가 필요할 때 사용
• 이는 주석과 비슷한 역할을 하고, 이는 Django로 개발할 시 웹 브라우저에 의해 해석되어 출력되지 않음.
  
• Django에서는 두 가지의 코멘트 형식을 제공.
  • 1번 형식은 한 줄을 코멘트할 때 사용
  • 2번은 여러 줄을 코멘트할 때 코멘트 태그 사이에 코멘트를 작성.

    1. {# #}
    2. {% comment %} {% endcomment %}

🛴 템플릿 상속

• 말 그대로 html 문서 중 기본 뼈대가 되는 문서를 기본 템플릿으로 정하고, 이는 공통의 코드이므로 다른 문서에서 기본 템플릿의 코드가 필요하면 상속하여 가져다 쓰는 것
• 기본이 되는 템플릿을 base.html로 지정.
• extends를 통해서 어떤 html을 상속받을지를 결정해줌.
• 다음으로 부모 html에 있는 block``들과 대응시켜 그 안에 내용을 써주면 작성한 내용이 부모html의block` 안으로 들어가서 화면에 출력됨.

  base.html list.html

  • base.html 의 내용을 상속받아 가져다 씀.
  • block content과 endblock content 사이의 내용을 base.html에 지정한 해당 영역에 넣어서 화면에 출력됨.

  

🏁 ref

Django 공식 문서 Opentutorials.org lks의 코딩일기

Django Template Language 실습

🛴 Model 설정

app/models.py

from django.db import models

class Attendance(models.Model):
    # ChoiceField 사용법 알아두기
    NONE = "NO"
    ATTENDANCE = "AT"
    ABSENT = "AB"
    PART = "PT"

    STATUS_CHOICES = [
        (NONE, "미지정"),
        (ATTENDANCE, "출석"),
        (ABSENT, "결석"),
        (PART, "일부참여"),
    ]

    name = models.CharField(verbose_name="이름", max_length=10)
    date = models.DateField(verbose_name="날짜")
    status = models.CharField(
        verbose_name="출석 여부", max_length=2, choices=STATUS_CHOICES, default=NONE
    )
    description = models.TextField(verbose_name="비고")

    def __str__(self):
        return f"출석부 : {self.name} ({self.date})"

    class Meta:
        verbose_name = "출석부"
        verbose_name_plural = "출석부 목록"

🛴 View 설정

app/views.py

from django.shortcuts import redirect
from django.views.generic import TemplateView
from .models import Attendance, Question

# 전체 조회
class AttendanceView(TemplateView):
    template_name = "attendance/list.html"

    def get_context_data(self, *args, **kwargs):
        attendance_qs = Attendance.objects.all().order_by("-date")

        context = {}
        context["attendance_qs"] = attendance_qs
        return context

# 특정 페이지 조회
class AttendanceCreateView(TemplateView):
    template_name = "attendance/enrolled.html"

    def get(self, request, **kwargs):
        response = super(AttendanceCreateView, self).get(self, request)
        return response

    def post(self, request):
        name = request.POST.get("name", None)
        date = request.POST.get("date", None)
        status = request.POST.get("status", None)
        description = request.POST.get("description", None)

        Attendance.objects.create(name=name, date=date, status=status, description=description)

        return redirect("attendance_list")

🛴 URL 설정

config/urls.py

이번 실습에서는 app 폴더 내에 urls.py 파일을 생성해서 분리하지 않았음.

from django.contrib import admin
from django.urls import path
from app.views import index, AttendanceView, AttendanceCreateView
from django.conf.urls.static import static
from django.conf import settings

urlpatterns = [
    path("admin/", admin.site.urls),
    path("attendance/", AttendanceView.as_view(), name="attendance_list"),
    path("attendance/create/", AttendanceCreateView.as_view(), name="attendance_create"),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

🛴 HTML 설정

Django Template Language 사용

📄 list.html

{% extends "base.html" %}

{% block content %}
<div class="warning hidden">
    <h3>** 지난 일정은 출석 여부를 변경할 수 없습니다.</h3>
</div>
<div>
    <table class="attendance-table">
        <thead>
            <tr>
                <td>이름</td>
                <td>날짜</td>
                <td>출석여부</td>
                <td>비고</td>
            </tr>
        </thead>
        <tbody>
            {% for attendance in attendance_qs%}
            <tr>
                <td class="name">{{attendance.name}}</td>
                <td class="date">{{attendance.date|date:"Y.m.d"}}</td>
                <td class="status">{{attendance.get_status_display}}</td>
                <td class="description">{{attendance.description}}</td>
            </tr>
            {% endfor %}
        </tbody>
    </table>
</div>
<div>
    <button type="button" class="button-bg-full" onclick="location.href='{% url 'attendance_create' %}'">출석체크하기</button>
</div>
{% endblock content %}

{% for attendance in attendance_qs%} 관련

• attendance-qs
  • app/views.py 파일 내의 AttendanceView 함수에서 get_context_data 함수를 통해 Attendance 모델 규격에 맞춰 db에 저장된 데이터들로 만든 QuerySet -QuerySet : Database에서 전달받은 객체들의 모음(list)
• attendance
  • attendance-qs이라고 하는 QuerySet 내에 있는 요소 객체
    • Attendance 모델에서 정의한 field를 본인 객체의 속성 데이터으로 가지고 있음.

{{attendance.name}} 관련

# list.html
      <td class="name">{{attendance.name}}</td>
      <td class="date">{{attendance.date|date:"Y.m.d"}}</td>
      <td class="status">{{attendance.get_status_display}}</td>
      <td class="description">{{attendance.description}}</td>

• attendance는 위에서 설명한 QuerySet 내의 요소 객체 각각을 의미.

• attendance.name은 그 객체 내의 속성을 의미하며, 이는 views.py에서 생성한 각각의 변수를 뜻함.

  # views.py
      def post(self, request):
         name = request.POST.get("name", None)
         date = request.POST.get("date", None)
         status = request.POST.get("status", None)
         description = request.POST.get("description", None)
  
         Attendance.objects.create(name=name, date=date, status=status, description=description)
  
         return redirect("attendance_list")

• post 함수 내에서 name으로 선언한 변수가 바로 위의 html 파일 내에서 사용한 템플릿 변수 attendance.name의 name을 의미.

• 그리고 post 함수 내에서 name 변수에게 request 함수를 통해 생성한 값을 할당해주었는데, 이 함수 내의 변수 "name"은 models.py에서 정의한 Attendance 모델의 field 이름을 뜻함.

  # models.py
      class Attendance(models.Model):
          NONE = "NO"
          ATTENDANCE = "AT"
          ABSENT = "AB"
          PART = "PT"
  
          STATUS_CHOICES = [
              (NONE, "미지정"),
              (ATTENDANCE, "출석"),
              (ABSENT, "결석"),
              (PART, "일부참여"),
          ]
  
          name = models.CharField(verbose_name="이름", max_length=10)
          date = models.DateField(verbose_name="날짜")
          status = models.CharField(
              verbose_name="출석 여부", max_length=2, choices=STATUS_CHOICES, default=NONE
          )
          description = models.TextField(verbose_name="비고", blank=True)
  
          def __str__(self):
              return f"출석부 : {self.name} ({self.date})"
  
          class Meta:
              verbose_name = "출석부"
              verbose_name_plural = "출석부 목록"

• 현재 Attendance 모델은 ChoiceField를 사용하였는데, 이는 enrolled.html에서 form을 이용하여 자료를 입력받을 때 사용.

• 예를 들어, ATTENDANCE = "AT"라는 부분을 보게 되면, ATTENDANCE라는 변수에 "AT"라는 값을 할당해주게 되는 것이고,

• STATUS_CHOICE 리스트에서 그 "AT"라는 값과 "출석"이라는 값을 tuple 형태로 매칭.

• 또한 사용자가 화면을 통해 form을 작성하여 선택하여 POST 요청을 할 경우, "AT"라는 값이 서버로 넘어오게 됨.

  # enrolled.html
      <div class="form-item">
          <div class="title">출석여부</div>
  
          <div class="radio-wrap">
              <input type="radio" name="status" value="AT">
              <label for="attendance">출석</label>
          </div>
          <div class="radio-wrap">
              <input type="radio" name="status" value="AB">
              <label for="absent">결석 (사유 필히 작성)</label>
          </div>
          <div class="radio-wrap">
              <input type="radio" name="status" value="part">
              <label for="complete">일부 일정 불참 (사유 필히 작성)</label>
      </div>
    </div>

• 위에서 보시다 시피, input 태그 내의 value 값으로 해당 변수의 데이터가 동일하게 기재가 되어 있어야함.

📄 enrolled.html

{% extends 'base.html' %}

{% block content %}
<div>
    <form method="post" action="">
        {% csrf_token %}
        <div class="form-item">
            <div class="title">이름</div>
            <input class="input-box" type="text" name="name" value="">
        </div>
        <div class="form-item">
            <div class="title">날짜</div>
            <input class=""input-box" type="date" name="date" value="">
        </div>
        <div class="form-item">
            <div class="title">출석여부</div>
            <div class="radio-wrap">
                <input type="radio" name="status" value="AT">
                <label for="attendance">출석</label>
            </div>
            <div class="radio-wrap">
                <input type="radio" name="status" value="AB">
                <label for="absent">결석 (사유 필히 작성)</label>
            </div>
            <div class="radio-wrap">
                <input type="radio" name="status" value="PT">
                <label for="part">일부 일정 불참 (사유 필히 작성)</label>
            </div>
        </div>
        <div class="form-item">
            <div class="title">사유</div>
            <div class="textarea-wrap">
                <textarea name="description" form-items="8" cols="50"></textarea>
            </div>
        </div>

        <div class="form-item">
            <button class="button-bg-full" type="submit">제출하기</button>
            <button class="button-bg-empty" type="button" onclick="location.href='{% url 'attendance_list' %}'">목록보기</button>
        </div>
    </form>
</div>
{% endblock content %}

URL Template Tag 작성 관련

{% url 'attendance_list' %}

• urls.py 파일에서 url name이 attendance_list로 되어 있는 url로 연결해주는 경로임을 의미.

  # urls.py
  urlpatterns = [
    path("admin/", admin.site.urls),
    path("attendance/", AttendanceView.as_view(), name="attendance_list"),
    path("attendance/create/", AttendanceCreateView.as_view(), name="attendance_create"),
  ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

• 현재 이 경우에는 웹브라우저를 통해 기본 주소/attendance/로 접속 시, 우리가 미리 지정한 html 화면을 보여주겠다는 것을 의미.

• 지정한 html 파일이 무엇인지 확인하기 위해서는 위의 경로에서 사용한 View 함수로 가서 확인해보면 됨.

  # views.py
    class AttendanceView(TemplateView):
        template_name = "attendance/list.html"
  
        def get_context_data(self, *args, **kwargs):
        attendance_qs = Attendance.objects.all().order_by("-date")
  
        context = {}
        context["attendance_qs"] = attendance_qs
        return context

• 위의 함수 내에서 template_name = "attendance/list.html 부분을 통해, 이 함수가 template/attencance/list.html의 위치에 해당하는 html 파일을 url에 연결해준다는 것을 알 수 있음.

이 게시글은 김형종 강사님의 Django 웹개발 강의를 듣고 작성하였습니다.

> Django 프로젝트 관련 정보
       - 프로젝트 관리 폴더 이름 : `config`
       - 프로젝트 내에서 실습 시 생성한 앱의 이름 : `board`

View를 생성하는 2가지 방법

🛴 FBV (Function Based View)

board/views.py

        def index_function(request):

            # GET
            if request.method == "GET":
                return HttpResponse("index by GET function called")

            # POST
            if request.method == "POST":
                return HttpResponse("index by POST function called")

• view : request를 받아서 response를 보내는 함수
• url : Browser에서 화면을 출력하는 기준
• views.py에서 view function을 생성 후, urls.py에 해당 view를 통해 response를 화면에 출력할 url을 연결해줘야 함.
  

config/urls.py

        from django.contrib import admin
        from board.views import index_function

        urlpatterns = [
            # 127.0.0.1:8000/admin/ 으로 접속 시, admin page 나옴
            path("admin/", admin.site.urls),
            # 기본 주소 접속 시 페이지 설정
            path("", index, name="index"),
            # 'board' App 관련 urls
            # 127.0.0.1:8000/fbv/ 로 접속 시, views.py에서 생성한 index_function 을 통해 처리한 방법대로 화면이 나옴
            path("fbv/", index_function, name="index_function"),   ◀◀◀ view에서 생성한 FBV 함수를 url로 연결해주는 코드
        ]

browser

🔥 path 내에서 지정한 name은 template 폴더 내 html 파일에서 django 템플릿 언어를 사용하여 링크 연결 시 사용하게 되는 점을 꼭 기억할 것!!!

• 위와 같이 코드 작성 후, 서버를 실행한 다음 해당 url로 접속하면 아래와 같이 나옴.

🛴 CBV (Class Based View)

board/views.py

        class IndexClass(View):

            # GET
            def get(self, request):
                return HttpResponse("index by GET class called")

            # POST
            def post(self, request):
                return HttpResponse("index by POST class called")

• 대표적인 HTTP Methods : GET & post
• CBV의 경우, 요청받은 method에 따라 분기문으로 나누는 FBV와 비교하였을 때 직관적이고 코드가 깔끔하기 때문에 관리하기에 더 용이함.
• Django는 우리가 원하는 서비스의 logic을 views.py에 모두 작성해야 하는 구조로 되어 있음.
• 그렇기 때문에 일반적으로 렌더링해야 하는 화면이 많고 logic이 많은 상황에서는 FBV보다는 CBV를 더 선호함.
  

config/urls.py

        from django.contrib import admin
        from board.views import IndexClass

        urlpatterns = [
            # 127.0.0.1:8000/cbv/ 로 접속 시, views.py에서 생성한 index_function 을 통해 처리한 방법대로 화면이 나옴
            path("cbv/", IndexClass.as_view(), name="index_class"),   ◀◀◀ view에서 생성한 CBV 함수를 url로 연결해주는 코드
        ]

browser

• 위와 같이 코드 작성 후, 서버를 실행한 다음 해당 url로 접속하면 아래와 같이 나옴.

HTML 연결하기

여러 종류의 데이터를 화면에 보여주기

🛴 FBV - html을 url과 연결

board/views.py

      from django.shortcuts import HttpResponse, render

      # 단순 텍스트가 아닌 html을 url과 연결하여 화면에 보여줄 때 사용
      def index_function2(request):

          # GET
          if request.method == "GET":
              return render(request, "practice/index_f2.html", {})

          # POST
          if request.method == "POST":
              return HttpResponse("index by POST function2 called")

🔥 render는 결국 HttpResponse를 return 하는 것임

• render 클래스 구성

config/urls.py

        from django.contrib import admin
        from board.views import index_function2

        urlpatterns = [
            path("fbv2/", index_function2, name="index_function2"),
        ]

templates/practice/index_f2.html

        <h1>Hard Practice</h1>
        <h3>test - 'index_function2'</h3>

browser

• 위와 같이 코드 작성 후, 서버를 실행한 다음 해당 url로 접속하면 아래와 같이 나옴.

🛴 FBV - html을 url과 연결 - context 활용

• context를 이용하면 context 내에 지정한 data를 우리가 연결하고자 하는 html 내에 삽입하여 화면에 보여줄 수 있음.
• context는 key : value 형태의 dictionary 자료구조
• context 내의 key를 그 이름 그대로 html에 템플릿 변수로 넣어주면 됨.

board/views.py

      from django.shortcuts import HttpResponse, render

      def index_function3(request):

          # GET
          if request.method == "GET":
              # context는 dictionary 형태(key : value)로 되어 있는 우리의 data를 전달함.
              #   웹페이지라는 것은 결국은 어떠한 정보를 전달하기 위한 페이지이고,
              #   그런 데이터를 우리는 context를 이용하여 전달함.
              context = {
                  "method": request.method,
                  "user": request.user,
                  "temp": "welcome to my site!!",
              }
              return render(request, "practice/index_f3.html", context)

          # POST
          if request.method == "POST":
              return HttpResponse("index by POST function3 called")

config/urls.py

        from django.contrib import admin
        from board.views import index_function3

        urlpatterns = [
            path("fbv3/", index_function3, name="index_function3"),
        ]

templates/practice/index_f3.html

        <h1>Hard Practice</h1>
        <h3>test - 'index_function3'</h3>
        <br>
        <br>
        <h4>{{method}}</h4>
        <h4>{{user}}</h4>
        <h4>{{temp}}</h4>

browser

• 위와 같이 코드 작성 후, 서버를 실행한 다음 해당 url로 접속하면 아래와 같이 나옴.

🛴 FBV - url path 지정

• context 내의 key, value를 이용하여 url의 path 지정 가능

board/views.py

      from django.shortcuts import HttpResponse, render

      def index_function4(request, name, code):

          # GET
          if request.method == "GET":
              context = {
                  "method": request.method,
                  "user": request.user,
                  "temp": "welcome to my site!!",
                  "name": name,
                  "code": code,
              }
              return render(request, "practice/index_f4.html", context)

          # POST
          if request.method == "POST":
              return HttpResponse("index by POST function4 called")

config/urls.py

        from django.contrib import admin
        from board.views import index_function4

        urlpatterns = [
            # main path와 sub path 지정 시, <str:변수명> 으로 코드 작성
            path("fbv4/<str:name>/<str:code>/", index_function4, name="index_function4"),
        ]

templates/practice/index_f4.html

        <h1>Hard Practice</h1>
        <h3>test - 'index_function4'</h3>
        <br>
        <br>
        <h4>{{method}}</h4>
        <h4>{{user}}</h4>
        <h4>{{temp}}</h4>
        <h4>{{name}}</h4>
        <h4>{{code}}</h4>

browser

• 위와 같이 코드 작성 후, 서버를 실행한 다음 해당 url로 접속하면 아래와 같이 나옴.

🛴 CBV - html을 url과 연결

board/views.py

      from django.shortcuts import HttpResponse, render
      from django.views.generic import TemplateView

      # CBV로 html을 url과 연결시키고자 할 경우에는 TemplateView를 상속받아 class를 선언
      class IndexClass2(TemplateView):
          # 명시적으로 template_name을 선언
          template_name = "practice/index_c2.html"

          # GET
          def get(self, request):
              response = super(IndexClass2, self).get(self, request)
              return response

          # POST
          def post(self, request):
              return HttpResponse("index by POST class2 called")

config/urls.py

        from django.contrib import admin
        from board.views import IndexClass2

        urlpatterns = [
            path("cbv2/", IndexClass2.as_view(), name="index_class2"),
        ]

templates/practice/index_f2.html

        <h1>Hard Practice</h1>
        <h3>test - 'index_class2'</h3>
        <br>
        <br>
        <h4>{{method}}</h4>
        <h4>{{user}}</h4>
        <h4>{{temp}}</h4>
        <h4>{{name}}</h4>
        <h4>{{code}}</h4>

browser

• 위와 같이 코드 작성 후, 서버를 실행한 다음 해당 url로 접속하면 아래와 같이 나옴.

🛴 FBV - query string 사용

• 주소 뒤에 ?query=검색어를 붙여 접속
• 해당 query는 `request.GET.get('query', default) 형태로 작성

board/views.py

      from django.shortcuts import HttpResponse, render

      # context 내의 일부 인자는 query string으로 사용하는 방법
      def index_function5(request, name):

          # GET
          if request.method == "GET":
              return render(
                  request,
                  "practice/index_f5.html",
                  {
                      "method": request.method,
                      "user": request.user,
                      "temp": "welcome to my site!!",
                      "name": name,
                      # query로 code를 사용
                      "code": request.GET.get("code"),
                  },
              )

          # POST
          if request.method == "POST":
              return HttpResponse("index by POST function5 called")

config/urls.py

        from django.contrib import admin
        from board.views import index_function5

        urlpatterns = [
            path("fbv5/<str:name>/", index_function5, name="index_function5"),
        ]

templates/practice/index_f5.html

        <h1>Hard Practice</h1>
        <h3>test - 'index_function5'</h3>
        <br>
        <br>
        <h4>{{method}}</h4>
        <h4>{{user}}</h4>
        <h4>{{temp}}</h4>
        <h4>{{name}}</h4>
        <h4>{{code}}</h4>

browser

• 위와 같이 코드 작성 후, 서버를 실행한 다음과 같이 url을 입력하여 접속하면 아래와 같이 나옴.

CSRF TOKEN

🛴 CSRF(Cross Site Request Forgery)

• 정상적인 사용자의 의도와는 무관하게, 공격자가 의도한 행위(수정, 삭제, 등록 등)로 웹사이트에 요청하는 것

🚧 Django CSRF

1. 클라이언트 요청이 발생시, Django는 자동으로 csrf_token을 클라이언트에게 전송
2. 클라이언트는 form data를 csrf_token과 함께 POST로 전송
3. 전송받은 csrf_token의 유효성을 검증하여 유효한 경우 요청을 처리.
4. 검증 오류(유효하지 않거나, 존재하지 않음)시, 403 Forbidden Response반환

🔥 Django는 POST 동작에서 csrf_token을 제공

CSRF를 예외로 처리하기보다, 로직을 점검 및 구현하는 것이 좋습니다.

🌍 CSRF 예외처리

csrf_exempt 함수를 decorator로 사용하면 됨.

board/views.py

      from django.shortcuts import HttpResponse, render
      from django.views.decorators.csrf import csrf_exempt

      # FBV 위에  csrf_exempt를 decorator로 사용
      @csrf_exempt
      def index_function2(request):

          # GET
          if request.method == "GET":
              return render(request, "practice/index_f2.html", {})

          # POST
          if request.method == "POST":
              return HttpResponse("index by POST function2 called")

config/urls.py

        from django.contrib import admin
        from board.views import index_function2

        urlpatterns = [
            path("fbv2/", index_function2, name="index_function2"),
        ]

templates/practice/index_f2.html

        <h1>Hard Practice</h1>
        <h3>test - 'index_function2'</h3>

Postman

• Postman 프로그램을 사용하여 해당 링크로 post 요청을 보내면 아래와 같이 정상적인 결과를 return받게 됨을 확인 가능.

• 만약, 위의 csrf_exempt 데코레이터를 제거하게 되면 아래와 같이 에러 메세지가 출력됨.

🌞 폰켓몬

🚊 문제 설명

• 당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다.
• 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다.
• 홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다.
• 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다.
• 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다.
• 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

  • 첫 번째(3번), 두 번째(1번) 폰켓몬을 선택
  • 첫 번째(3번), 세 번째(2번) 폰켓몬을 선택
  • 첫 번째(3번), 네 번째(3번) 폰켓몬을 선택
  • 두 번째(1번), 세 번째(2번) 폰켓몬을 선택
  • 두 번째(1번), 네 번째(3번) 폰켓몬을 선택
  • 세 번째(2번), 네 번째(3번) 폰켓몬을 선택

• 이때, 첫 번째(3번) 폰켓몬과 네 번째(3번) 폰켓몬을 선택하는 방법은 한 종류(3번 폰켓몬 두 마리)의 폰켓몬만 가질 수 있지만, 다른 방법들은 모두 두 종류의 폰켓몬을 가질 수 있습니다.
• 따라서 위 예시에서 가질 수 있는 폰켓몬 종류 수의 최댓값은 2가 됩니다.

• 당신은 최대한 다양한 종류의 폰켓몬을 가지길 원하기 때문에, 최대한 많은 종류의 폰켓몬을 포함해서 N/2마리를 선택하려 합니다.
• N마리 폰켓몬의 종류 번호가 담긴 배열 nums가 매개변수로 주어질 때, N/2마리의 폰켓몬을 선택하는 방법 중, 가장 많은 종류의 폰켓몬을 선택하는 방법을 찾아, 그때의 폰켓몬 종류 번호의 개수를 return 하도록 solution 함수를 완성해주세요.

🚊 입출력 예

입출력 예 #1

• 문제의 예시와 같습니다.

입출력 예 #2

• 6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
• 가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리, 2번 폰켓몬 한 마리, 4번 폰켓몬 한 마리를 고르면 되며, 따라서 3을 return 합니다.

입출력 예 #3

• 6마리의 폰켓몬이 있으므로, 3마리의 폰켓몬을 골라야 합니다.
• 가장 많은 종류의 폰켓몬을 고르기 위해서는 3번 폰켓몬 한 마리와 2번 폰켓몬 두 마리를 고르거나, 혹은 3번 폰켓몬 두 마리와 2번 폰켓몬 한 마리를 고르면 됩니다.
• 따라서 최대 고를 수 있는 폰켓몬 종류의 수는 2입니다.

📑 Code : 내꺼

📌 Logic 설명

1. 내가 가져갈 수 있는 마리 수 : N/2 계산
2. 현재 폰켓몬의 종류의 수 X 계산
3. X와 N/2의 크기를 비교하여 결과값 계산

> code

    def solution(ls):
        return min(len(ls)//2, len(set(ls)))

📑 Code : 다른 사람꺼

> code

    없음

🌞 완주하지 못한 선수

🚊 문제 설명

• 수많은 마라톤 선수들이 마라톤에 참여하였습니다.
• 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.
  
• 마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

🚊 제한 사항

• 마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.
• completion의 길이는 participant의 길이보다 1 작습니다.
• 참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.
• 참가자 중에는 동명이인이 있을 수 있습니다.

🚊 입출력 예

입출력 예 #1

• leo는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

입출력 예 #2

• vinko는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

입출력 예 #3

• mislav는 참여자 명단에는 두 명이 있지만, 완주자 명단에는 한 명밖에 없기 때문에 한명은 완주하지 못했습니다.

📑 Code : 내꺼

> code 1

    def solution(participant, completion):
        # 동명이인을 고려하여 참가자와 완주자 list를 각각 정렬
        participant.sort()
        completion.sort()

        # 반복문을 통해
        for i in range(len(completion)):
            # 앞에서부터 순서대로 각 list 요소를 비교
            #   일치하지 않는 경우가 바로 완주하지 못한 선수
            if participant[i] != completion[i]:
                return participant[i]

        # 이 코드는 완주하지 못한 선수가 여러 명일 때에는 `error` 발생할 것임.
        # 이 문제에서는 상관 없음.

> code 2

    def solution(participant, completion):
        # `참가자 이름 : 해당 이름의 참가자 수`의 형태로 사용할 빈 dict 생성
        dic = {}
        # 참가자 리스트를 순회하면서 dic에서 참가자 이름별 참가자 수를 하나씩 카운트
        for i in participant:
            dic[i] = dic.get(i, 0) + 1
        # 완주자 리스트를 순회하면서 dic에서 완주자 이름에 해당하는 참가자 수를 하나씩 제거
        for j in completion:
            dic[j] -= 1
        # 참가자 리스트를 순회하면서 dic에서 참가자 수가 남아 있는 참가자 이름을 추출
        #   완주하지 못한 사람만이 참가자 수가 남아있기 때문
        for k in participant:
            if dic[k] != 0:
                return k

📑 Code : 다른 사람꺼

> code

    from collections import Counter


    def solution(participant, completion):
        answer = Counter(participant) - Counter(completion)
        return list(answer.keys())[0]

🌞 전화번호 목록

🚊 문제 설명

• 전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
• 전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

  • 구조대 : 119
  • 박준영 : 97 674 223
  • 지영석 : 11 9552 4421

• 전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

🚊 제한 사항

• phone_book의 길이는 1 이상 1,000,000 이하입니다.
  • 각 전화번호의 길이는 1 이상 20 이하입니다.
  • 같은 전화번호가 중복해서 들어있지 않습니다.

🚊 입출력 예

입출력 예 #1

• 앞에서 설명한 예와 같습니다.

입출력 예 #2

• 한 번호가 다른 번호의 접두사인 경우가 없으므로, 답은 true입니다.

입출력 예 #3

• 첫 번째 전화번호, “12”가 두 번째 전화번호 “123”의 접두사입니다. 따라서 답은 false입니다.

📑 Code : 내꺼

📌 Logic 설명

• 전화번호부를 정렬하게 되면, 인접한 2개씩만 비교하면 한 번호가 다른 번호의 접두어인지 바로 확인 가능

> code

    def solution(phone_book):
        phone_book.sort()
        length = len(phone_book)
        for i in range(length-1):
            if phone_book[i] == phone_book[i+1][:len(phone_book[i])]:
                return False
        return True

📑 Code : 다른 사람꺼

> code

    def solution(phoneBook):
    phoneBook = sorted(phoneBook)

    for p1, p2 in zip(phoneBook, phoneBook[1:]):
        if p2.startswith(p1):
            return False
    return True

🌞 위장

🚊 문제 설명

• 스파이들은 매일 다른 옷을 조합하여 입어 자신을 위장합니다.
• 예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다.
• 스파이가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.

🚊 제한 사항

• clothes의 각 행은 [의상의 이름, 의상의 종류]로 이루어져 있습니다.
• 스파이가 가진 의상의 수는 1개 이상 30개 이하입니다.
• 같은 이름을 가진 의상은 존재하지 않습니다.
• clothes의 모든 원소는 문자열로 이루어져 있습니다.
• 모든 문자열의 길이는 1 이상 20 이하인 자연수이고 알파벳 소문자 또는 '_' 로만 이루어져 있습니다.
• 스파이는 하루에 최소 한 개의 의상은 입습니다.

🚊 입출력 예

입출력 예 #1

• headgear에 해당하는 의상이 yellow_hat, green_turban이고 eyewear에 해당하는 의상이 blue_sunglasses이므로 아래와 같이 5개의 조합이 가능합니다.

입출력 예 #2

• face에 해당하는 의상이 crow_mask, blue_sunglasses, smoky_makeup이므로 아래와 같이 3개의 조합이 가능합니다.

📑 Code : 내꺼

📌 Logic 설명

1. 옷의 종류별 개수를 dict로 표현
2. 각각의 종류의 옷에 대해 입을 수 있는 경우의 수는 총 (해당 종류의 옷의 개수 + 1) → 입지 않는 경우 1가지까지 포함시켜야 하므로
3. 옷을 조합할 수 있는 전체 경우의 수는 위에서 구한 각 종류의 옷들에 대한 경우의 수를 모두 곱한 값에서 전부 입지 않는 경우 1가지를 제외하면 됨.

> code

    import math

    def solution(clothes):
        answer = {}
        for p in clothes:
            answer[p[1]] = answer.get(p[1], 0) + 1
        array = answer.values()
        array = [i+1 for i in array]
        return math.prod(array) -1

📑 Code : 다른 사람꺼

> code

    없음

🌞 베스트앨범

🚊 문제 설명

• 스트리밍 사이트에서 장르 별로 가장 많이 재생된 노래를 두 개씩 모아 베스트 앨범을 출시하려 합니다.
• 노래는 고유 번호로 구분하며, 노래를 수록하는 기준은 다음과 같습니다.

  1. 속한 노래가 많이 재생된 장르를 먼저 수록합니다.
  2. 장르 내에서 많이 재생된 노래를 먼저 수록합니다.
  3. 장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.

• 노래의 장르를 나타내는 문자열 배열 genres와 노래별 재생 횟수를 나타내는 정수 배열 plays가 주어질 때, 베스트 앨범에 들어갈 노래의 고유 번호를 순서대로 return 하도록 solution 함수를 완성하세요.

🚊 제한 사항

• genres[i]는 고유번호가 i인 노래의 장르입니다.
• plays[i]는 고유번호가 i인 노래가 재생된 횟수입니다.
• genres와 plays의 길이는 같으며, 이는 1 이상 10,000 이하입니다.
• 장르 종류는 100개 미만입니다.
• 장르에 속한 곡이 하나라면, 하나의 곡만 선택합니다.
• 모든 장르는 재생된 횟수가 다릅니다.

🚊 입출력 예

1. classic 장르는 1,450회 재생되었으며, classic 노래는 다음과 같습니다.

   • 고유 번호 3: 800회 재생
   • 고유 번호 0: 500회 재생
   • 고유 번호 2: 150회 재생

2. pop 장르는 3,100회 재생되었으며, pop 노래는 다음과 같습니다.

   • 고유 번호 4: 2,500회 재생
   • 고유 번호 1: 600회 재생

3. 따라서 pop 장르의 [4, 1]번 노래를 먼저, classic 장르의 [3, 0]번 노래를 그다음에 수록합니다.

   • 장르 별로 가장 많이 재생된 노래를 최대 두 개까지 모아 베스트 앨범을 출시하므로 2번 노래는 수록되지 않습니다.

📑 Code : 내꺼

📌 Logic 설명

1. 내가 가져갈 수 있는 마리 수 : N/2 계산
2. 현재 폰켓몬의 종류의 수 X 계산
3. X와 N/2의 크기를 비교하여 결과값 계산

> code

    def solution(genres, plays):

        # dic1 → '장르 : 재생곡 합계" 를 담은 dict 형식으로 만듦
        length = len(genres)
        dic1 = {}
        for i in range(length):
            dic1[genres[i]] = dic1.get(genres[i], 0) + plays[i]
        print(dic1)

        # dic2 → '장르 : (재생곡, 재생곡의 idx)' 형태의 tuple을 담은 dict로 만듦.
        dic2 = {j:[] for j in genres}
        for k in range(length):
            dic2[genres[k]].append([plays[k],k])
        print(dic2)

        # dic3 → '장르별 재생곡 합계 : (재생곡, 재생곡의 idx)' 형태의 tuple을 담은 dict로 만듦
        length2 = len(dic2)
        dic3 = {l:[] for l in dic1.values()}
        for i in range(length2):
            dic3[list(dic1.values())[i]] = dic3.get(list(dic1.values())[i], 0) + list(dic2.values())[i]
        print(dic3)
        # dic3 → 위에서 만든 dict를 '장르별 재생곡 합계'를 기준으로 역순 정렬
        dic3 = sorted(dic3.items(), key=lambda x: x[0], reverse=True)
        print(dic3)


        result = []
        for i in dic3:
            # 한 장르 내에서 재생횟수는 역순으로, 동일 재생횟수에 대해서는 idx를 순서대로 정렬
            arr = sorted(i[1], key=lambda x: (-x[0],x[1]))
            print(arr)
            # 한 장르 내에 곡이 하나라면 그것만 추가
            if len(arr) == 1:
                result.append(arr[0][1])
            # 한 장르 내에 곡이 2개 이상이라면 2개까지만 추가
            else:
                for j in range(2):
                    result.append(arr[j][1])
        return result

📑 Code : 다른 사람꺼

> code

    def solution(genres, plays):
        answer = []
        d = {e:[] for e in set(genres)}
        for e in zip(genres, plays, range(len(plays))):
            d[e[0]].append([e[1] , e[2]])
        genreSort =sorted(list(d.keys()), key= lambda x: sum( map(lambda y: y[0],d[x])), reverse = True)
        for g in genreSort:
            temp = [e[1] for e in sorted(d[g],key= lambda x: (x[0], -x[1]), reverse = True)]
            answer += temp[:min(len(temp),2)]
        return answer

🚊 문제 설명

• binary tree의 root node에 대한 포인터가 주어지면 binary tree의 top view를 print할 것.
• top view란, node의 위에서 본 tree를 뜻함.

  예시 1. input : 1 2 5 3 4 6

   1
    \
     2
      \
       5
      /  \
     3    6
      \
       4

  > `Top View` : `1` → `2` → `5` → `6`
  > <br>
  >
  > `예시 2.`
  > `input : 1 10 4 3 2 7 5 6 11 15 13 17`
  >```python
        1
          \
           10
          /  \
        4      11
       / \      \
     3    7       15
    /    /  \    /  \  
   2    5    6  13   17

  Top View : 2 → 3 → 1 → 10 → 11 → 15 → 17

입력 예시

             1 2 5 3 4 6

   1
    \
     2
      \
       5
      /  \
     3    6
      \
       4

출력 예시

1 2 5 6

설명

From the top, only nodes 1, 2, 5, 6 are visible.

🚢 기본 제공 Code

class Node:
    def __init__(self, info): 
        self.info = info  
        self.left = None  
        self.right = None 
        self.level = None 

    def __str__(self):
        return str(self.info) 

class BinarySearchTree:
    def __init__(self): 
        self.root = None

    def create(self, val):  
        if self.root == None:
            self.root = Node(val)
        else:
            current = self.root

            while True:
                if val < current.info:
                    if current.left:
                        current = current.left
                    else:
                        current.left = Node(val)
                        break
                elif val > current.info:
                    if current.right:
                        current = current.right
                    else:
                        current.right = Node(val)
                        break
                else:
                    break

🚢 Input & Output

tree = BinarySearchTree()
t = int(input())

arr = list(map(int, input().split()))

for i in range(t):
    tree.create(arr[i])

topView(tree.root)

📑 Code 1 : BFS

📌 Logic 설명

• 위에서 바라봤을 때 최초로 보이는 Node만 담아야 하는 조건을 고려하여 tree에서의 상하 level 개념을 빗대어 좌우 level 개념을 depth라는 값으로 활용
• 전체 Node를 탐색하면서 조건에 맞는 Node만 찾아야 하므로 BFS 개념 사용

from collections import deque

def topView(root):
    # 결과를 담을 dict 생성
    #   depth(해당 노드의 좌우 폭의 단계)와 node.info(해당 노드의 value)를 dict 형태로 담을 예정
    result = {}
    # queue 자료구조 이용을 위해 deque 함수 사용
    queue = deque([])
    # root node부터 진행하기 위해 queue에 추가
    #   좌우 폭의 단계(depth)를 숫자로 표현하기 위해 각 노드를 [node, depth] 로 표현
    #   root node는 [root, 0]으로 표현
    queue.append(([root,0]))
    # queue가 빌 때까지 진행
    while(queue):
        # 현재 level에서 가장 앞에 있는(depth가 가장 낮은) node를 선택
        current_node = queue.popleft()
        # 만약, 해당 depth의 node에 대한 데이터가 result에 없다면
        if not current_node[1] in result:
            # 현재 노드의 depth:info 를 result에 추가
            result[current_node[1]] = current_node[0].info
        # 만약, 현재 노드의 왼쪽 자식 노드가 있다면
        if current_node[0].left:
            # 그 노드를 [node, depth] 형태의 자료형으로 queue에 추가
            #   그 노드의 depth는 현재 노드의 depth보다 1이 작음 (왼쪽으로 이동하니까)
            queue.append([current_node[0].left, current_node[1]-1])
        # 만약, 현재 노드의 오른쪽 자식 노드가 있다면
        if current_node[0].right:
            # 그 노드를 [node, depth] 형태의 자료형으로 queue에 추가
            #   그 노드의 depth는 현재 노드의 depth보다 1이 큼 (오른쪽으로 이동하니까)
            queue.append([current_node[0].right, current_node[1]+1])
    # depth 기준으로 dict를 정렬하기 위해 items() 메서드를 사용
    #   depth 기준으로 정렬 시, top view 기준으로 왼쪽부터 순서대로 정렬됨.
    for depth, value in sorted(result.items()):
        print(str(value), end=" ")

📑 Code 2 : DFS

📌 Logic 설명

• 위에서 바라봤을 때 최초로 보이는 Node만 담아야 하는 조건을 고려하여 tree에서의 상하 level 개념을 빗대어 좌우 level 개념을 depth라는 값으로 활용
• root Node부터 시작하여 연결된 자식 Node들에 대해 level을 낮춰가며 depth와 count(root node로부터의 이동 횟수)를 계산 → DFS 개념을 사용하는 이유
• depth가 동일한 Node들에 대해서는 count가 적은 Node가 top view에서 발견되는 Node라는 점을 코드로 구현

# binary tree의 모든 Node에 대해 depth(좌/우 level)와 count(이동 횟수)를 계산하여 위에서 언급한 조건에 맞는 Node만 추출하는 함수를 생성
def traversal(root, depth, count, temp):
    # root Node가 없으면 종료시킴
    if root is None:
        return
    # 현재 노드의 depth가 temp에 없다면
    if depth not in temp:
        # 현재 노드의 depth와 [value, count]를 dictionary 형태로 temp에 담음
        temp[depth] = [root.info, count]
    # 현재 노드와 동일한 depth를 갖는 노드가 temp에 있는 경우,
    #   해당 노드의 count보다 현재 노드의 count가 더 작다면
    if count < temp[depth][1]:
        # 그 depth를 갖는 노드의 정보를 현재 노드의 정보로 갱신
        #  한마디로 지금 노드의 depth, info, count로 바꿔준다 이말임
        #    왜냐면, count가 작다는 것은 이동을 적게했다는 것이고 그 말인즉 
        #    상위 level에 위치한 Node이기 때문에 top view에서 먼저 보인다는 것이기 때문
        temp[depth] = [root.info, count]
    # 재귀를 호출하여 우측/좌측 모두 전부 계산
    #   이동해서 찾는 것인데, 이동은 무조건 count가 (+1)되고, 
    #   좌/우 여부에 따라 depth는 (-1) 혹은 (+1)됨.
    traversal(root.right, depth + 1, count + 1, temp)
    traversal(root.left, depth - 1, count + 1, temp)

def topView(root):
    # top view로 바라보았을 때의 결과를 담을 dict 선언
    temp = dict()
    # root Node부터 전부 탐색하여 결과를 dict에 담음
    traversal(root, 0, 0, temp)
    # depth 기준으로 dict를 정렬하기 위해 items() 메서드를 사용
    #   depth 기준으로 정렬 시, top view 기준으로 왼쪽부터 순서대로 정렬됨.
    for i in sorted(temp.items()):
        print(i[1][0], end = ' ')

🚊 문제 설명

• Huffman coding 은 주파수에 따라 가변 길이의 부호어들을 고정 길이 입력 문자에 할당한다.

• 빈도가 높은 문자일수록 짧은 부호어들이 할당되고 빈도가 낮은 문자일수록 긴 부호어들이 할당됩니다.
• 문자의 경로를 따라 있는 모든 가장자리에는 코드 번호가 포함되어 있습니다.
• 트리의 왼쪽에 있으면 0이 됩니다. 오른쪽에 있으면 1이 됩니다.
• 오직 leaf node만이 글자와 그 빈도수를 포함할 것이다. 다른 모든 node는 문자 대신 null을 포함하며, 모든 노드와 그 하위 문자의 빈도 수를 포함한다.

• 예를 들어 문자열 ABRACADABRA를 생각해 보자.

• 문자열에는 총 11개의 문자가 있고, 이 숫자는 최종적으로 결정된 트리의 루트에 있는 수와 일치해야 한다.
• 우리의 주파수는 A=5, B=2, R=2, C=1, B=1 이다.
• 가장 작은 두 개의 주파수는 C와 D에 해당하므로 둘 다 1로 값이 같으므로 이 두 주파수로 트리를 만든다.
• 루트 노드는 하위 노드 카운트의 합계(이 경우에는 1+1 =2)를 포함한다.
• 왼쪽 노드는 처음 접하는 문자 C를, 오른쪽 노드는 D를 포함합니다.
• 다음으로 우리는 방금 만든 트리, 문자 B, 문자 R의 3가지 항목을 가지고 있다.
• 트리가 먼저 왔기 때문에 새 루트 노드의 왼쪽에 있고, B는 오른쪽으로 가게 된다.
• 트리가 완료될 때까지 반복한 다음, 가장자리에 1과 0을 입력.
• 완성된 그래프는 다음과 같다.

• 입력된 문자는 오직 leaf node에만 있다.

• 내부 노드의 문자 값은 Null을 의미한다.
• 우리는 캐릭터에 대한 우리의 값이 다음과 같은 것을 확인할 수 있다.

      A - 0
      B - 111
      C - 1100
      D - 1101
      R - 10

• Huffman encoding된 문자열은 다음과 같다.

      A B    R  A C     A D     A B    R  A
      0 111 10 0 1100 0 1101 0 111 10 0
      or
      01111001100011010111100

• 모호성을 피하기 위해 Huffman encoding은 접두사 없는 인코딩 기법이다. 부호어는 다른 부호어의 접두사로 나타나지 않는다
• 인코딩된 문자열을 디코딩하려면 0과 1을 따라 leaf node까지 이동한 후 문자를 반환한다.
• Huffman tree의 루트에 대한 포인터와 디코딩할 이진 코드화된 문자열이 제공되며, 디코딩된 문자열을 출력해야 한다.

입력 예시

s="1001011"

출력 예시

ABACA

설명

S="1001011"
Processing the string from left to right.
S[0]='1' : we move to the right child of the root. We encounter a leaf node with value 'A'. We add 'A' to the decoded string.
We move back to the root.

S[1]='0' : we move to the left child. 
S[2]='0' : we move to the left child. We encounter a leaf node with value 'B'. We add 'B' to the decoded string.
We move back to the root.

S[3] = '1' : we move to the right child of the root. We encounter a leaf node with value 'A'. We add 'A' to the decoded string.
We move back to the root.

S[4]='0' : we move to the left child. 
S[5]='1' : we move to the right child. We encounter a leaf node with value C'. We add 'C' to the decoded string.
We move back to the root.

 S[6] = '1' : we move to the right child of the root. We encounter a leaf node with value 'A'. We add 'A' to the decoded string.
We move back to the root.

Decoded String = "ABACA"

🚢 기본 제공 Code

import queue as Queue

cntr = 0

class Node:
    def __init__(self, freq, data):
        self.freq = freq
        self.data = data
        self.left = None
        self.right = None
        global cntr
        self._count = cntr
        cntr = cntr + 1

    # lt (less than) : 두 객체의 값의 크기를 비교할 때 사용되는 함수
    def __lt__(self, other):
        if self.freq != other.freq:
            return self.freq < other.freq
        return self._count < other._count

def huffman_hidden():#builds the tree and returns root
    q = Queue.PriorityQueue()


    for key in freq:
        q.put((freq[key], key, Node(freq[key], key) ))

    while q.qsize() != 1:
        a = q.get()
        b = q.get()
        obj = Node(a[0] + b[0], '\0' )
        obj.left = a[2]
        obj.right = b[2]
        q.put((obj.freq, obj.data, obj ))

    root = q.get()
    root = root[2]#contains root object
    return root

def dfs_hidden(obj, already):
    if(obj == None):
        return
    elif(obj.data != '\0'):
        code_hidden[obj.data] = already

    dfs_hidden(obj.right, already + "1")
    dfs_hidden(obj.left, already + "0")

🚢 Input & Output

ip = input()
freq = {}#maps each character to its frequency

cntr = 0

for ch in ip:
    if(freq.get(ch) == None):
        freq[ch] = 1
    else:
        freq[ch]+=1

root = huffman_hidden()#contains root of huffman tree

code_hidden = {}#contains code for each object

dfs_hidden(root, "")

if len(code_hidden) == 1:#if there is only one character in the i/p
    for key in code_hidden:
        code_hidden[key] = "0"

toBeDecoded = ""

for ch in ip:
   toBeDecoded += code_hidden[ch]

decodeHuff(root, toBeDecoded) # 우리가 구현할 함수를 여기서 실행

📑 Code

def decodeHuff(root, s):
    # 현재 노드를 root로 지정
    current_node = root
    # 노드의 데이터를 쌓을 빈 문자열을 선언
    result = ''
    # s의 숫자들을 앞에서부터 확인하는 작업을 반복
    for num in s:
        # 해당 숫자값이 0이라면
        if int(num) == 0:
            # 탐색할 노드의 위치를 현재 노드의 왼쪽 노드로 변경
            current_node = current_node.left
        # 해당 숫자값이 1이라면
        else:
            # 탐색할 노드의 위치를 현재 노드의 오른쪽 노드로 변경
            current_node = current_node.right
        # 만약 현재 노드의 왼쪽 노와 오른쪽 노드가 모두 없다면
        if current_node.left == None and current_node.right == None:
            # 현재 노드의 데이터를 result에 추가
            result += current_node.data
            # 현재 노드를 다시 root로 지정
            # 반복문을 돌 때, 항상 root 노드부터 탐색을 시작하기 위함.
            current = root

    print(result)

Tree: Preorder Traversal Tree: Inorder Traversal Tree: Postorder Traversal Tree: Levelorder Traversal

🚊 문제 공통 사항

🚢 이진탐색트리 클래스

# 1. Node 클래스 선언
class Node:
    def __init__(self, info): 
        # Node의 데이터 = info
        self.info = info
        # Node의 왼쪽 = None
        self.left = None  
        # Node의 오른쪽 = None
        self.right = None 
        # Node의 level = None
        self.level = None 

    # init에서 규정한 클래스 자체 내용을 출력
    def __str__(self):
        return str(self.info) 

# 이진탐색트리 클래스 선언
class BinarySearchTree:
    def __init__(self):
        # root 노드를 None으로 선언
        self.root = None

    # 이진탐색트리에 데이터 삽입

    def create(self, val):  
        # root 노드가 없으면
        if self.root == None:
            # val 값을 갖는 노드를 생성하여 root 노드에 할당하고 끝냄.
            self.root = Node(val)
        #  root 노드가 있으면
        else:
            # 현재 노드를 root 노드로 지정
            current = self.root
             # 계속 반복
            #   삽입할 위치를 먼저 찾고, 완료되면 해당 노드의 데이터를 val로 지정하는 방식
            while True:
                # 삽입하려는 데이터 값이 현재 노드의 데이터 값보다 작다면 → 왼쪽으로 내려가서 삽입할 위치를 찾음.
                if val < current.info:
                    # 현재 노드의 왼쪽 노드가 있으면
                    if current.left:
                        # 삽입할 탐색 위치를 현재 노드의 왼쪽 노드로 변경
                        current = current.left
                    # 현재 노드의 왼쪽 노드가 없다면
                    else:
                        # val 값을 갖는 노드를 생성하여 현재 노드의 왼쪽 노드에 할당.
                        current.left = Node(val)
                        # 데이터 삽입을 끝냈으니 반복문 종료시키고 끝냄.
                        break
                # 삽입하려는 데이터 값이 현재 노드의 데이터 값보다 크다면
                elif val > current.info:
                    # 현재 노드의 오른쪽 노드가 있다면
                    if current.right:
                        # 삽입할 탐색 위치를 현재 노드의 오른쪽 노드로 변경
                        current = current.right
                    # 현재 노드의 오른쪽 노드가 없다면
                    else:
                        # val 값을 갖는 노드를 생성하여 현재 노드의 오른쪽 노드에 할당
                        current.right = Node(val)
                        # 데이터 삽입을 끝냈으니 반복문 종료시키고 끝냄.
                        break
                # 삽입하려는 데이터 값이 현재 노드의 데이터 값과 동일하다면
                else:
                    # 삽입할 필요가 없으니 그냥 끝냄.
                    break

🚢 Input & Output

# 이진 탐색 트리 선언
tree = BinarySearchTree()
# 생성할 노드 개수 입력받기
t = int(input())
# n × 1 사이즈의 리스트 형태의 array 생성
arr = list(map(int, input().split()))
# for문을 돌면서 노드 생성
for i in range(t):
    tree.create(arr[i])

##### 여기에 문제에서 원하는 함수를 입력받아 코드 실행하게 됨 ####

🚊 Tree 순회 구현

제약조건

Nodes in the tree

출력 형식

Print the tree's preorder traversal as a single line of space-separated values.

입력 예시

     1
      \
       2
        \
         5
        /  \
       3    6
        \
         4  

출력 예시

# Preorder
    1 2 5 3 4 6 
# Inorder
    1 2 3 4 5 6 
# Postorder
    4 3 6 5 2 1 
# Levelorder
    1 2 5 3 6 4

🚊 순회 방식별 살펴보기

🚢 Preorder

🚥 Root Node → left Node → right Node

📑 Code

def PreOrder(root):
    # root 노드가 있다면
    if root:
        # 현재 노드의 데이터를 출력하고
        print(root.info, end=" ")
        # 현재 노드의 왼쪽에서 PreOrder를 다시 진행
        # → 왼쪽으로 한 단계 들어가는 것을 의미
        PreOrder(root.left)
        # 현재 노드의 왼쪽에서 Preorder가 끝났다면, 오른쪽에서 PreOrder를 다시 진행
        # → 오른쪽으로 한 단계 들어가는 것을 의미
        PreOrder(root.right)

• root 노드에서 현재 노드의 데이터를 출력하고
• 그 다음에 왼쪽 노드로 내려가서 해당 노드의 데이터를 출력
• 위의 과정을 반복
• 더이상 파고들 왼쪽 노드가 없으면 바로 이전 노드로 돌아가 해당 노드의 오른쪽 노드로 내려감.
• 이 과정을 끝까지 반복

🚢 Inorder

🚥 left Node → Root Node → right Node

📑 Code

def inOrder(root):
    # root 노드가 있다면
    if root:
        # 현재 노드의 왼쪽에서 inOrder를 다시 진행
        inOrder(root.left)
        # 현재 노드의 데이터를 출력
        print(root.info, end=" ")
        # 현재 노드의 오른쪽에서 inOrder를 다시 진행
        inOrder(root.right)

• root 노드부터 현재 노드의 왼쪽 노드로 내려가는 과정을 반복
• 현재 노드 기준, 더이상 파고들 왼쪽 노드가 없으면 현재 노드의 데이터를 출력
• 바로 이전 노드로 돌아가 해당 노드의 데이터를 출력
• 그 노드의 오른쪽 노드로 내려가서 해당 노드의 데이터를 출력
• 이 과정을 끝까지 반복

🚢 Postorder

🚥 Root Node → left Node → right Node

📑 Code

def postOrder(root):
    # root 노드가 있다면
    if root:
        # 현재 노드의 왼쪽에서 postOrder를 다시 진행
        postOrder(root.left)
        # 현재 노드의 오른쪽에서 postOrder를 다시 진행
        postOrder(root.right)
        # 현재 노드의 데이터를 출력
        print(root.info, end=" ")

• root 노드부터 현재 노드의 왼쪽 노드로 내려가는 과정을 반복
• 더이상 파고들 노드가 없으면 현재 노드의 오른쪽 노드로 내려감
• 현재 노드의 데이터를 출력
• 이 과정을 끝까지 반복

🚢 Levelorder

🚥 Root Node → left Node → right Node

• 각 Level의 노드를 왼쪽부터 출력 후, 그 다음 Level로 넘어가 이 과정을 반복

📑 Code

from collections import deque

def levelOrder(root):
    if not root:
        return 

    # deque 생성
    queue = deque()
    # root 노드를 추가
    queue.append(root)
    # queue에 아무 것도 없을 때까지 반복
    while queue:
        # queue의 첫 번째 객체를 추출하여 현재 노드에 할당
        current_node = queue.popleft()
        # 현재 노드의 데이터를 출력
        print(current_node.info, end = ' ')
        # 현재 노드의 왼쪽 노드가 있다면?
        if current_node.left: 
            # queue에 해당 노드를 추가
            queue.append(current_node.left)
        # 현재 노드의 오른쪽 노드가 있다면?
        if current_node.right: 
            # queue에 해당 노드를 추가
            queue.append(current_node.right)

• FIFO(First In First Out) 방식의 Queue 자료구조를 사용하기 위해 collections 모듈의 deque을 import
• 상위 Level부터 노드들을 순서대로 담을 queue를 deque 자료구조로 선언
• root 노드부터 시작하여 해당 노드의 왼쪽 노드와 오른쪽 노드가 순서대로 queue에 쌓이게 됨.
• 노드 데이터의 출력은 queue에서 왼쪽부터 뽑혀 나와 진행되기 때문에 상위 Level부터 시작해서 현재 노드의 왼쪽부터 오른쪽으로 순서대로 출력되고 그 다음 Level로 넘어가서 반복되는 형태로 진행됨.