DataBase 

DB(Database)
데이터가 모여있는 기지

DBMS(Database Management System)
DB를 관리할 수 있는 구체적인 시스템
오라클, MySQL, MariaDB, MS-SQL, MongoDB, ...

MySQL
웹 사이트와 다양한 애플리케이션에서 사용되는 DBMS이다.
오라클은 관리 비용이 고가이지만 MySQL은 저가형 데이터베이스이다.
문법이 간결하고 쉬우며, 메모리 사용량이 현저히 낮아서 부담없이 사용 가능하다.

DBMS 소통 방식
-----------------------------------------------------
          사용자
-----------------------------------------------------
    ↕               ↕
고객 관리 응용프로그램      ↕   주문 관리 응용프로그램
    ↕               ↕
-----------------------------------------------------
          DBMS
-----------------------------------------------------

RDBMS(관계형 데이터베이스 관리 시스템)
테이블끼리 서로 관계를 맺는다.

Table A(TBL_USER)                Table B(TBL_ORDER)
번호(PK)    이름    나이    아이디(UK)       주문번호(PK)       번호(FK)    날짜       상품수량
1    이기영    20    lky1234       20240114001    2    20240114    5
2    장상화    21    jsh5555       20240114002    2    20240114    20
3    조은종    22    jej9999       20240114003    1    20240114    100
4    서경덕    45    sgd7777       20240115001    4    20240115    1
5    문우람    78    mor4444       20240115002    3    20240115    45

이러한 구조를 가지는 것을 Table이라고 부른다.

COLUMN(열, 속성, 필드)
공통된 값들의 주제(집합)

ROW(행, 레코드, 튜플)
하나의 정보

PRIMARY KEY(PK)
고유한 값, 테이블 당 1개씩만 존재한다.
각 정보의 구분점으로 사용된다.
중복이 없고 NULL값을 허용하지 않는다.

FOREIGN KEY(FK)
다른 테이블의 PK를 의미한다.
보통 테이블끼리 관계를 맺을 떄 사용한다.
중복이 가능하고, NULL도 허용한다.

UNIQUE KEY(UNIQUE)
NULL은 허용하지만 중복은 허용하지 않는다.

SQL문(쿼리문) - DDL, DML, DCL, TCL
스크립트 언어(인터프리터 언어)
DMBS와 소통하는 언어

MySQL 설치

1) 로그인
> mysql -u root -p
> 비밀번호

2) 기본 데이터베이스 선택
> use mysql;

3) 로컬에서만 접속 가능한 계정 생성
> create user 'userid'@localhost identified by '비밀번호';

4) 원격으로도 접속 가능한 계정 생성
> create user 'userid'@'@'%' identified by '비밀번호';

5) 데이터베이스 생성
> create database [데이터베이스 이름];

6) 데이터베이스 사용
> user [데이터베이스 이름];

7) 데이터베이스 삭제
> drop database [데이터베이스 이름];

8) 사용자 비밀번호 변경
> set password for 'userid'@'%' = '신규 비밀번호';

9) 사용자 삭제
> drop user 'userid'@'%';

10) 연결 권한
> grant asll privileges on *.* to 'userid'@'%' with grant option;

11) 권한 관련 명령어 확정
> flush privileges;

SQL문(쿼리문)

- DDL (데이터 정의어)

DDL(DATA Definition Language): 데이터 정의어
- 테이블을 조작하거나 제어할 수 있는 쿼리문

Table

데이터 무결성

무결성 : 데이터의 정확성, 일관성, 유효성이 유지되는 것

● 정확성 : 데이터는 애매하지 않아야 한다.

● 일관성 : 각 사용자가 일관된 데이터를 볼 수 있도록 해야한다.
● 유효성 : 데이터가 실제 존재하는 데이터여야 한다.

1. 개체 무결성
모든 테이블이 PK로 선택된 컬럼을 가져야 한다.

2. 참조 무결성
두 테이블의 데이터가 항상 일관된 값을 가지도록 유지한다.

3. 도메인 무결성
컬럼의 타입, NULL값의 허용 등에 대한 사항을 정의하고
올바른 데이터가 입력되었는 지를 확인한다.

모델링(기획) : 추상적인 주제를 DB에 맞게 설계하는 것

1. 요구사항분석
회원, 주문, 상품: 3가지를 관리하고자 한다.

2. 개념적 설계(개념 모델링)

회원 주문 상품
---------------------------------
번호 번호 번호
---------------------------------
아이디 날짜 이름
비밀번호 회원번호 가격
이름 상품번호 재고

3. 논리적 설계(논리 모델링)

회원 주문 상품
--------------------------------------------------------
번호PK 번호PK 번호PK
--------------------------------------------------------
아이디 U, NN 날짜 NN 이름 NN
비밀번호 NN 회원번호 FK 가격 D=0
이름 NN 상품번호 FK 재고 D=0

4. 물리적 설계(물리 모델링)

tbl_user
------------------------------------------
id: bigint primary key
------------------------------------------
user_id: varchar(255) unique not null
password: varchar(255) not null
name: varchar(255) not null

5. 구현

정규화

정규화

 :  삽입/수정/삭제의 이상현상을 제거하기 위한 작업.
    데이터의 중복을 최소화하는 데에 목적이 있다.
    5차 정규화까지 있으나 3차 정규화까지만 진행한다.

1차 정규화

2차 정규화

3차 정규화

★ 데이터베이스에서 정규화가 필요한 이유
   데이터베이스를 잘못 설계하면 불필요한 데이터 중복으로 인해 공간이 낭비된다.
   이런 현상을 이상(Anomaly)현상이라고 한다.


   회원번호와 프로젝트코드 두 컬럼의 조합키로 설정되어 있는 테이블이고
   한 사람은 하나의 부서만 가질 수 있다.

   회원번호      이름   부서   프로젝트코드   급여   부서별 명수
   22080101   한라봉   개발팀   ABC0001      3000   4
   22080101   한라봉   개발팀   DEF1112      2000   4
   22080101   한라봉   개발팀   CBA9474      4000   4
   22080104   홍길동   기획팀   EFG0881      5000   2
   22081106   이순신   디자인팀   GHI9991      6000   3

★정규화가 필요한 이유 3가지 ★

   ▶ 2차 정규화

      회원번호      프로젝트코드   급여
      22080101   ABC0001      3000
      22080101   DEF1112      2000
      22080101   CBA9474      4000
      22080104   EFG0881      5000
      22081106   GHI9991      6000


      회원번호      이름   부서   부서별 명수
      22080101   한라봉   개발팀   4
      22080104   홍길동   기획팀   2
      22081106   이순신   디자인팀   3


   ▶ 3차 정규화 진행

      회원번호      이름   부서   
      22080101   한라봉   개발팀   
      22080104   홍길동   기획팀   
      22081106   이순신   디자인팀   
      22080103   장보고   개발팀

      부서   부서별 명수
      개발팀   4
      기획팀   2
      디자인팀   3

SQL문(쿼리문)

- DML(Data Manipulation Language) : 데이터 조작어

join

: 여러 테이블에 흩어져 있는 정보 중
사용자가 필요한 정보만 가져와서 가상의 테이블처럼 만들고 결과를 보여주는 것.
정규화를 통해 조회 테이블이 너무 많이 쪼개져 있으면,
작업이 불편하기 떄문에 조회의 성능을 향상시키고자 join을 사용한다.

- 등가 조인
: on절에 등호가 있을 때, 서로 관계를 맺고 있는 테이블끼리 JOIN할 때 주로 사용된다.

- 비등가 조인
: on절에 등호가 없을 때, 서로 관계를 맺지 않고 있는 테이블끼리 JOIN할 때 주로 사용된다.

옵티마이저(Optimizer)

SQL을 가장 빠르고 효율적으로 수행할 최적의 처리경로(최적비용)을 생성해주는 DBMS 내부의 핵심 엔진
사용자가 쿼리문(SQL)으로 결과를 요청하면, 이를 생성하는 데 필요한 처리경로는 DBMS에 내장된
옵티마이저가 자동으로 생성한다. 옵티마이저가 생성한 SQL 처리경로를 실행 계획(Execution Plan)이라고 한다.
COST: 예상 수행 시간, 쿼리를 수행하는 데 소요되는 일량 또는 시간
CARDINALiTY: 실행 결과의 건수

옵티마이저의 SQL 최적화 과정
사용자가 작성한 쿼리를 수행하기 위해, 실행 계획을 찾는다.
데이터 딕셔너리에 미리 수집해 놓은 오브젝트 통계 및 시스템 통계 정보를 이용해서
각 실행계획의 예상 비용을 산정한다.
각 실행계획을 비교해서 최저 비용을 갖는 하나를 선택하여 실행한다.

옵티마이저의 종류

1. 규칙기반 옵티마이저(RBO)
미리 정해진 규칙에 따라 실행

2. 비용기반 옵티마이저(CBO)
비용이 가장 낮은 실행계획을 선택

SQL문(쿼리문)

- TCL(Transaction Control Language) : 트랙잭션 제어어

트랜잭션 : 하나의 작업(서비스)에 필요한 쿼리를 묶은 단위

commit
: 모든 작업을 확정하는 명령어

rollback
: 이전 커밋 시점으로 이동


   > show variables like '%autocommit%';

   > set autocommit = true;
   > set autocommit = false;

VIEW

기존의 테이블은 그대로 놔둔 채 필요한 컬럼들 새로운 컬럼을 만든 가상 테이블.
실제 데이터가 저장되는 것은 아니지만 VIEW를 통해서 충분히 데이터를 관리할 수 있다.

- 독립성: 다른 곳에서 접근하지 못하도록 하는 성질
- 편리성: 긴 쿼리문을 짧게 만드는 성질
- 보안성: 기존의 쿼리문이 모이지 않는다.

VIEW 문법
create view [뷰 이름] as (select 쿼리문)

# email을 입력받고 아이디와 도메인을 각각 분리하여 출력한다.

'''
    첫 번째 값으로 야드를 입력받고, 두 번째 값으로 인치를 입력받아서
    각각 cm로 변환하여 다음 형식에 맞추어 소수점 둘 째자리까지 출력한다.

    1yd: 91.44cm
    1in: 2.54cm

    예)
        yard 입력: 10
        inch 입력: 10

        10 yard는 914.4cm
        10 inch는 25.4cm
'''
# round(값, 원하는 자리수) : 소수점이 맞춰진 결과값
#%%
# email을 입력받고 아이디와 도메인을 각각 분리하여 출력한다.
id, domain = input('이메일 입력 : ').split('@')
print(f'아이디 : {id}\n 도메인 : {domain}입니다.')


#%%
yard_message = 'yard 입력: '
inch_message = 'inch 입력: '

yard = float(input(yard_message))
inch = float(input(inch_message))

yard_to_cm = round(yard * 91.44, 2)
inch_to_cm = round(inch * 2.54, 2)

yard_formatting = f'{yard} yard는 {yard_to_cm}cm'
inch_formatting = f'{inch} yard는 {inch_to_cm}cm'

print(yard_formatting, inch_formatting, sep='\n')

ChatGPT
- OpenAI에서 공개한 GPT모델(자연어처리 모델)을 기반으로 만든 ChatGPT
- 인공지능 채팅 서비스
- 2021년까지의 지식까지만 학습됨
- 정보를 빠른시간에 정제된 텍스트로 표현

ChatGPT 프롬프트 엔지니어링
1. 영어로 질문
    - 기본적으로 영어로 세팅
    - 다국어를 이용시 영어에 비해 느리고 정보량이 부족
2. 상황을 구체적으로 기술
    - streamlit에 대해 설명해줘 => 나는 AI개발자야. 직원을 교육하고 있는데 streamlit에 대해 개념을 설명하는 자료를 만들어줘
3. GPT에게 역할을 부여
    - 너는 스타트업에 개발 팀장이야. 팀장처럼 행동해줘 네가 질문을 하면 내가 대답을 할게. 첫번째 질문을 생성해줘

https://wrtn.ai/

GPTAPI키 받는 순서

https://openai.com/blog/openai-api 에서 로그인 ▶ 왼쪽 메뉴에서 API key에서 키 생성

# 번역서비스

1_app.py

# 번역 서비스
import streamlit as st
import openai
openai.api_key = '' # 자신의 api키 작성
example = {
    "한국어": ['오늘 날씨가 어때?', '최근 딥러닝 기반의 AI기술이 인기를 끌고 있다'],
    "영어":['How is the weather today?', 'Recently, AI technology based on deep learning is gaining popularity'],
    "일본어":['今日の天気はどう？','最近ディープラーニング基盤のAI技術が人気を集めている']
}
# 함수 생성
def translate_text(text, src_lang, trg_lang):
    def build_fewshot(src_lang, trg_lang):
        src_examples = example[src_lang]
        trg_examples = example[trg_lang]
        fewshot_messages = []

        for src_text, trg_text in zip(src_examples, trg_examples):
            fewshot_messages.append({'role':'user','content':src_text})
            fewshot_messages.append({'role':'assistant','content':trg_text})
        return fewshot_messages


    system_instrunction = f'assistant는 번역앱으로서 동작한다. {src_lang}을 {trg_lang}으로 적절하게 번역하고 번역된 텍스트만 출력한다.'
    
    fewshot_messages = build_fewshot(src_lang=src_lang, trg_lang=trg_lang)
    
    messages = [{'role':'system', 'content':system_instrunction}, *fewshot_messages, {'role':'user', 'content':text}] # 시스템으로 명령/ 예를 두개 정도 보냄
    #print(fewshot_messages)
    
    response = openai.chat.completions.create(
        model='gpt-3.5-turbo',
        messages=messages
    )
    print(response.choices[0].message.content)
    return response.choices[0].message.content



st.title('간단한 번역 서비스')
text = st.text_area('번역할 내용을 입력하세요', '')
src_lang = st.selectbox('번역할 언어', ['한국어','영어','일본어'])
trg_lang = st.selectbox('번역된 언어', ['영어','한국어','일본어'])
if st.button('번역하기'):
    translated_text = translate_text(text, src_lang, trg_lang)
    st.success(translated_text)

# 광고문구 만들기

main.py

import openai
from fastapi import FastAPI
from pydantic import BaseModel
openai.api_key = ''

class AdGenerator:
    def __init__(self, engine='gpt-3.5-turbo'):
        self.engine = engine    # gpt-3.5-turbo
        self.type = self.get_type_engine(engine) # chat
    def get_type_engine(self, engine):
        if engine.startswith('gpt-3.5'):
            return 'chat'
        elif engine.startswith('text-'):
            return 'text'
        raise Exception(f'알려지지 않은 모델: {engine}')
    def using_chatgpt(self, prompt):
        system_instruction = 'assistant는 마케팅 문구 작성 도우미로 동작한다. user의 내용을 참고하여 마케팅 문구를 작성해줘'
        messages = [{'role':'system', 'content':system_instruction}, {'role':'user', 'content':prompt}]
        response = openai.chat.completions.create(
            model=self.engine, messages=messages
        )
        result = response.choices[0].message.content.strip()
        return result
    def generate(self, product_name, details, option):
        prompt = f'제품 이름: {product_name}\n주요 내용: {details}\n광고 문구의 스타일: {option}\n위 내용을 참고하여 마케팅 문구를 작성해줘'
        if self.type == 'chat':
            result = self.using_chatgpt(prompt=prompt)
        return result

app = FastAPI()
class Product(BaseModel):
    product_name: str
    details: str
    option: str
@app.post('/create_ad')
def create_ad(product: Product):
    adGenerator = AdGenerator()
    ad = adGenerator.generate(product_name=product.product_name,
                              details=product.details,
                              option=product.option)
    return {'ad': ad}

streamlit으로 웹 생성

2_app.py

import streamlit as st
import requests

st.title('광고문구 서비스')
generate_ad_url = 'http://127.0.0.1:8000/create_ad'

product_name = st.text_input('제품 이름')
details = st.text_input('주요 내용')
options = st.multiselect('광고 문구의 느낌', options=['기본','재밌게', '차분하게', '과장스럽게', '참신하게', '고급스럽게'], default=['기본'])

if st.button('광고 문구 생성'):
    try:
        response = requests.post(
            generate_ad_url,
            json = {"product_name": product_name,
                    "details": details,
                    "option": ", ".join(options)} #이렇게 해야 여러개 선택한 것을 다같이 보냄
        )
        ad = response.json()['ad']
        st.success(ad)

    except:
        st.error('오류')

1. Jinja

Jinja는 Python에서 사용되는 템플릿 엔진 중 하나로, 템플릿과 데이터를 결합하여 동적인 콘텐츠를 생성하는 데 사용됩니다. 주로 웹 프레임워크에서 HTML 페이지를 동적으로 렌더링하는 데 활용됩니다.

https://jinja.palletsprojects.com/en/3.1.x/

2. 설치

Jinja2를 설치합니다.

# Window
pip install jinja2

# macOS
pip3 install jinja2

3. 간단한 예제

templates라는 디렉토리를 프로젝트 루트에 만들고 그 안에 index.html 파일을 추가합니다.

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ data. title }}</title>
    <link rel="stylesheet" href="/css/style.css">
</head>
<body>
    <h2>안녕! {{ data.name}}</h2>
    <p>{{ request.url }}</p>
</body>
</html>

main.py 생성 후 작성

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
# Jinja2Templates는 html과 연결시켜주는 역할
# 정적파일을 저장해주는 공간을 생성 StaticFiles -> 가상화시켜서 경로를 만들어줌

# http:// http://127.0.0.1:8000/
app = FastAPI()
templates = Jinja2Templates(directory="templates")

app.mount("/css", StaticFiles(directory="static"), name ="css") # 연결 #/css는 가상의 경로가 됨

@app.get("/")
async def read_root(request: Request):
   # 템플릿에 전달할 데이터
    data = {"name": "뚠빵이", "title": "푸바오 당근뺏기"}
    
    # 템플릿 렌더
    return templates.TemplateResponse("index.html", {"request": request, "data": data})

http://127.0.0.1:8000/에 액세스하면 FastAPI가 Jinja를 사용하여 동적으로 렌더링한 HTML 페이지를 볼 수 있습니다. 위의 예제에서는 index.html 파일에 정의된 변수 {{ name }}과 {{ title }}에 데이터를 전달하여 동적으로 내용을 생성합니다.

uvicorn main:app --reload

4. 로그인 예제

templates라는 디렉토리를 프로젝트 루트에 만들고 그 안에 login.html 파일과 info.html파일을 추가합니다.

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>로그인</title>
</head>
<body>
    <h2>로그인</h2>
    <form action="/login" method="post">
        <p>아이디: <input type="text" name="userid"></p>
        <p>비밀번호: <input type="password" name="userpw"></p>
        <p><button type="submit">로그인</button></p>
    </form>
</body>
</html>

info.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>회원정보</title>
</head>
<body>
    <h2>회원정보</h2>
    <p>입력한 아이디는 {{ userid }} 이고, 비밀번호는 {{ userpw }} 입니다!</p>
</body>
</html>

main.py 파일 생성

main.py

from fastapi import FastAPI, Request, Form
from fastapi.templating import Jinja2Templates

app = FastAPI()

templates = Jinja2Templates(directory="templates")

@app.get("/login")
async def login_form(request: Request):
    return templates.TemplateResponse("login.html", {"request": request})

@app.post("/login")
async def login(request: Request, userid: str = Form(...), userpw: str = Form(...)):
    return templates.TemplateResponse("info.html", {"request": request, "userid": userid, "userpw": userpw})
#(...)은 무조건 입력해야 하는것 html의 name = useri와 일치해야함

1. Fast API

FastAPI는 Python 기반의 웹 프레임워크로, 주로 API를 빠르게 개발하기 위해 설계되었습니다. FastAPI는 강력한 타입 힌팅(Type Hints)을 활용하여 개발자에게 코드 작성의 안정성과 가독성을 제공합니다.

https://fastapi.tiangolo.com/ko/

※  타입 힌팅(Type Hints)

타입 힌팅(Type Hints)은 프로그래밍 언어에서 변수, 함수 매개변수, 함수 반환값 등에 대한 데이터 타입 정보를 코드에 명시적으로 제공하는 기술입니다. Python 3.5 이상에서 도입된 기능으로, 코드의 가독성을 높이고 프로그램의 안정성을 강화하는 데 도움이 됩니다.

2. Fast API vs Flask vs Django

FastApi

장점

FastAPI는 최신 Python 기반 프레임워크로 빠른 성능과 사용하기 쉬운 API로 유명합니다. 비동기 프로그래밍을 지원하므로 실시간 애플리케이션 구축에 적합합니다. 또한 자동 API 문서화 및 유효성 검사를 제공하여 개발자의 시간과 노력을 절약합니다.

단점

FastAPI는 비교적 새로운 프레임워크이며 기존 프레임워크에 비해 커뮤니티 지원 및 리소스가 많지 않을 수 있습니다. 또한 비동기 프로그래밍을 처음 접하는 개발자를 위한 학습 곡선도 있습니다.

활용도

FastAPI는 특히 데이터 집약적인 애플리케이션을 위한 실시간 및 고성능 API 구축에 적합합니다.

Django

장점

Django는 웹 애플리케이션 개발에 널리 사용되는 성숙한 Python 기반 프레임워크입니다. 인증, 관리자 패널 및 ORM과 같은 많은 기본 기능을 제공합니다. 또한 지원 및 리소스를 제공하는 크고 활동적인 커뮤니티가 있습니다.

단점

Django는 복잡할 수 있으며 설정하려면 상당한 구성이 필요합니다. 소규모 프로젝트나 경량 API
축에는 적합하지 않을 수도 있습니다.

활용

Django는 웹 애플리케이션, 특히 콘텐츠 기반 웹사이트, 전자상거래 플랫폼 및 소셜 미디어 플랫폼을 구축하는 데 널리 사용됩니다.

Flask

장점

Flask는 배우고 사용하기 쉬운 경량 Python 기반 프레임워크입니다. 유연성을 제공하고 개발자가 모듈식 및 확장 가능한 방식으로 웹 애플리케이션을 구축할 수 있도록 합니다. 또한 사용자 정의가 가능하고 소규모 프로젝트를 구축하는 데 적합합니다.

단점

Flask는 다른 프레임워크에 비해 기본 제공 기능이 적기 때문에 개발자가 구현하는 데 더 많은 노력과 시간이 필요할 수 있습니다. 또한 대규모 웹 애플리케이션을 구축하는 데 적합하지 않을 수도 있습니다.

활용

Flask는 개인 웹 사이트, 간단한 API 및 내부 대시보드와 같은 소규모 웹 애플리케이션 및 프로토타입을 구축하는 데 적합합니다.

요약

FastAPI는 실시간 및 고성능 API를 구축하는 데 적합한 현대적이고 빠른 프레임워크이고, Django는 복잡한 웹 애플리케이션을 구축하는 데 적합한 성숙한 프레임워크이며, Flask는 소규모 웹 애플리케이션 및 프로토타입을 구축하는 데 적합한 가볍고 유연한 프레임워크입니다. . 그들 사이의 선택은 개발 팀의 기술과 경험뿐만 아니라 프로젝트의 특정 요구 사항과 요구 사항에 따라 다릅니다.

3. 설치

FastAPI를 설치하기 전에 Python 가상환경을 만들어줍니다. 가상환경을 사용하면 프로젝트 간에 의존성 충돌을 방지하고 프로젝트 별로 필요한 패키지를 독립적으로 관리할 수 있습니다.

# Windows
python -m venv venv

# macOS/Linux
python3 -m venv venv

가상환경이 생성되면 해당 가상환경을 활성화합니다.

# Windows
venv\Scripts\activate

# macOS/Linux
source venv/bin/activate

FastAPI를 사용하려면 먼저 FastAPI 패키지를 설치해야 합니다.

pip install fastapi

FastAPI 애플리케이션을 실행하기 위해 uvicorn이라는 ASGI 서버가 필요합니다.

pip install "uvicorn[standard]"

uvicorn[standard]

1. 이 패키지는 uvicorn에 기본적으로 포함된 기능 외에도 추가적인 표준 미들웨어를 포함합니다.

2. 표준 미들웨어는 보안, 로깅 및 기타 서버 관련 기능을 추가하는 데 도움이 됩니다.

3. 예를 들어, Gzip 압축, CORS(Cross-Origin Resource Sharing) 지원 등이 기본적으로 포함되어 있습니다.

uvicorn

1. 기본적으로 필요한 최소한의 기능만을 제공하는 패키지입니다.

2. uvicorn[standard]에 비해 미들웨어가 적고, 기본적인 서버 기능만을 제공합니다.

※ ASGI 서버

ASGI는 Asynchronous Server Gateway Interface의 약자로, 비동기 웹 애플리케이션과 서버 간의 표준 인터페이스를 제공하는 프로토콜입니다. ASGI는 Python 웹 애플리케이션을 구축할 때 비동기 처리를 지원하고, 실시간 기능을 구현할 수 있도록 하는 중간 계층 역할을 합니다.

기존의 WSGI(웹 서버 게이트웨이 인터페이스)는 동기적인 요청과 응답을 다루는 데에 효과적이었습니다. 하지만 현대의 웹 애플리케이션에서는 동시성(concurrency)이나 비동기(asynchronous) 처리가 중요한 역할을 하게 되면서 WSGI의 한계가 드러나게 되었습니다.

4. 기본 예제

main.py

from fastapi import FastAPI

users = {
    0: {"userid": "apple", "name": "푸바오"},
    1: {"userid": "banana", "name": "아이바오"},
    2: {"userid": "orange", "name": "러바오"}
}

app = FastAPI()

# http://127.0.0.1:8000/users/0
# uvicorn main:app --reload
@app.get("/users/{id}")
def find_user(id: int):
    user = users[id]
    return user

# http://127.0.0.1:8000/users/0/userid
# http://127.0.0.1:8000/docs
@app.get("/users/{id}/{key}")
def find_user_by_key(id: int, key: str):
    user = users[id][key]
    return user

5. 실행

작성한 FastAPI 애플리케이션을 실행합니다. 다음 명령을 사용하여 uvicorn을 통해 실행할 수 있습니다.

uvicorn main:app --reload

FastAPI는 자동으로 생성된 Swagger UI를 통해 API 문서를 제공합니다. 기본적으로 http://127.0.0.1:8000/docs 또는 http://127.0.0.1:8000/redoc에서 확인할 수 있습니다. Swagger UI를 통해 API의 엔드포인트, 매개변수, 응답 형식 등을 살펴볼 수 있습니다.

6. REST와 RESTful API

REST: "Representational State Transfer"의 약자로, 웹 상에서 자원을 표현하고 상태를 전송하기 위한 아키텍처적인 스타일입니다. REST는 네트워크 아키텍처의 한 형식으로, 리소스(자원)를 정의하고 이를 고유하게 식별하는 데 중점을 두며, HTTP 프로토콜을 기반으로 하고 있습니다. REST는 간결하고 확장 가능한 디자인을 지향하여 웹 서비스를 위한 표준 아키텍처로 널리 사용되고 있습니다.

RESTful API(REST API): REST 아키텍처를 따르는 웹 서비스의 인터페이스를 말합니다. 이 API는 클라이언트와 서버 간의 통신을 위한 규칙을 제공하며, 자원의 생성, 조회, 수정, 삭제(CRUD)와 같은 기본적인 데이터 조작을 위한 메서드를 제공합니다. RESTful API는 HTTP를 기반으로 하기 때문에 웹에서 쉽게 사용할 수 있습니다. 클라이언트와 서버 간의 통신은 자원의 표현을 통해 이루어지며 표현은 일반적으로 JSON 또는 XML 형식으로 이루어집니다.

예를 들어, 다음은 간단한 RESTful API의 예시입니다:

자원(리소스): /users

HTTP 메서드: GET (모든 사용자 조회), POST (새로운 사용자 생성), PUT 또는 PATCH (사용자 정보 업데이트), DELETE (사용자 삭제)

7. JSON

JSON은 "JavaScript Object Notation"의 약어로, 데이터를 표현하고 교환하기 위한 경량의 데이터 형식입니다. 주로 서버와 클라이언트 간에 데이터를 주고 받을 때 사용되며, 텍스트 형태로 이루어져 있습니다. JSON은 간결하면서도 읽기 쉽고 파싱하기 쉬운 구조를 가지고 있어 많은 프로그래밍 언어에서 지원하고 있습니다.

{
  "키1": "값1",
  "키2": "값2",
  "키3": {
    "키4": "값4",
    "키5": "값5"
  },
  "배열키": [
    "배열값1",
    "배열값2",
    "배열값3"
  ]
}

8. HTTP Method

FastAPI에서는 각 메서드에 대응하는 데코레이터를 제공하여 해당 엔드포인트에 대한 핸들러 함수를 등록할 수 있습니다. 이러한 데코레이터를 사용하여 각각의 HTTP 메서드에 대한 동작을 정의할 수 있습니다.

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional

users = {
    0: {"userid": "apple", "name": "푸바오"},
    1: {"userid": "banana", "name": "아이바오"},
    2: {"userid": "orange", "name": "러바오"}
}

app = FastAPI()
# http://127.0.0.1:8000/user/?
@app.get("/users/{id}")
def find_user(id: int):
    item = users[id]
    return item

# http://127.0.0.1:8000/users/0/userid
@app.get("/users/{id}/{key}")
def find_user_by_key(id:int, key:str):
    user = users[id][key]
    return user

# http://127.0.0.1:8000/id-by-name?name=푸바오
@app.get("/id-by-name")
def find_user_by_name(name:str):
    for userid, user in users.items():
        if user['name'] == name:
            return user
    return {"error : 데이터를 찾지 못함"}

class User(BaseModel):
    userid : str
    name : str

@app.post("/{id}")
def create_user(id: int, user: User):
    if id in users:
        return {"error" : "이미 존재하는 키"}
    users[id] = user.__dict__       # user객체를 딕셔너리로 만듬
    return {"success" : "ok"}


class UserForUpdate(BaseModel):
    userid: Optional[str]
    name: Optional[str]

@app.put("/{id}")
def update_user(id:int, user: UserForUpdate):
    if id not in users:
        return {"error" : "id가 존재하지 않음"}
    if user.userid : 
        users[id]['userid'] = user.userid
    if user.name:
        users[id]['name'] = user.name
    return {"success" : "ok"}

@app.delete("/users/{id}")
def delete_item(id:int):
    users.pop(id)
    return {"success": "ok"}

1. CSS

CSS(Cascading Style Sheets)는 HTML이나 XML과 같은 마크업 언어로 작성된 문서의 스타일을 정의하기 위한 스타일 시트 언어입니다. CSS는 웹 페이지의 레이아웃, 색상, 폰트 및 다양한 시각적 요소를 디자인하는 데 사용됩니다. HTML이 웹 페이지의 구조를 정의하는 데 중점을 두는 반면, CSS는 웹 페이지의 디자인과 스타일을 담당합니다. 

2. CSS 문법

CSS는 선택자(selector)와 선언 블록(declaration block)으로 이루어져 있습니다. 선택자는 스타일을 적용할 HTML 요소를 선택하고, 선언 블록은 해당 요소에 적용할 스타일 규칙을 정의합니다.

- 인라인 스타일

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>인라인 스타일</title>
</head>
<body>
    <h2 style="text-align: center; font-size: 50px;">인라인 스타일</h2>
    <p style="text-align: center; font-size: 20px; color: deepskyblue;">HTML 요소 내부에 style 속성을 사용하여 적용하는 방법</p>
</body>
</html>

- 내부 스타일

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>내부 스타일</title>
    <style>
        h2 { font-size: 50px; }
        ul { list-style: none; }
        li { display: inline-block; margin-right: 50px; font-weight: bold; color: deeppink;}
    </style>
</head>
<body>
    <h2>CSS를 적용하는 방법</h2>
    <ul>
        <li>인라인 스타일</li>
        <li>내부 스타일</li>
        <li>외부 스타일</li>
    </ul>
</body>
</html>

- 외부 스타일

/*
    style.css
    작성자: 류정원
    내용: 외부 스타일 적용 방법
*/
h2 { font-size: 50px; } /* h2 요소의 사이트를 50px로 설정 */
ul { list-style: none; }
li { display: inline-block; margin-right: 50px; font-weight: bold; color: deeppink;}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>외부 스타일</title>
    <link rel="stylesheet" href="./css/style.css">
</head>
<body>
    <h2>CSS를 적용하는 방법</h2>
    <ul>
        <li>인라인 스타일</li>
        <li>내부 스타일</li>
        <li>외부 스타일</li>
    </ul>
</body>
</html>

3. 선택자

CSS 선택자는 HTML 문서 내에서 스타일을 적용할 대상을 선택하는데 사용되는 패턴이나 규칙입니다. 선택자는 특정 HTML 요소 또는 요소 그룹을 가리키며, 해당 요소에 스타일을 적용하도록 CSS 규칙을 설정하는 데 사용됩니다.

- 전체 선택자

전체 선택자(*)는 HTML 문서 내의 모든 요소를 선택하는 CSS 선택자입니다. 이 선택자를 사용하면 모든 HTML 요소에 동일한 스타일을 적용할 수 있습니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>전체 선택자</title>
    <style>
        h2 { color: deeppink; font-size: 50px; }
        * { color: deepskyblue; }

    </style>
</head>
<body>
    <h2>전체 선택자</h2>
    <ol>
        <li>스타일을 모든 요소에 적용</li>
        <li>* 기호를 사용해서 표현</li>
        <li>너무 많은 요소가 있는 HTML 문서에 사용할 경우 클라이언트에 부하를 줄 수 있음</li>
    </ol>
</body>
</html>

- 요소 선택자

요소 선택자(Element Selector)는 CSS에서 가장 기본적인 선택자 중 하나로, 특정 HTML 요소를 선택하여 해당 요소에 스타일을 적용하는 데 사용됩니다. 요소 선택자는 해당 요소의 이름을 직접 사용하여 선택합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>요소 선택자</title>
    <style>
        h2 { font-size: 50px; }
        p { color: deepskyblue; }
    </style>
</head>
<body>
    <h2>요소 선택자</h2>
    <p>특정 요소가 쓰인 모든 요소에 스타일을 적용</p>
    <p><span>span 요소</span></p>
    <p><strong>strong 요소</strong></p>
    <p><ins>ins 요소</ins></p>
</body>
</html>

※ 상속

CSS 상속은 부모 요소로부터 자식 요소로 스타일 속성이 전달되는 메커니즘입니다. 특정 스타일 속성이 부모 요소에 정의되고 자식 요소에는 정의되어 있지 않을 때, 자식 요소는 부모 요소로부터 해당 속성을 상속받습니다.

https://www.w3.org/TR/CSS22/propidx.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>상속</title>
    <style>
        div { 
            color: deeppink;    /* 상속 됨 */
            border: 3px dotted red; /* 상속 안됨 */
            padding: 30px; /* 상속 안됨 */
        }
        /* h3 { border: 3px dotted red; } */
    </style>
</head>
<body>
    <h2>상속</h2>
    <div>
        div 영역
        <h3>상속이란</h3>
        <p>부모 요소의 속성값이 자식 요소에게 전달되는 것</p>
    </div>
</body>
</html>

- id 선택자

ID 선택자는 CSS에서 특정 HTML 요소를 선택하여 해당 요소에 스타일을 적용하는 데 사용되는 선택자입니다. ID는 HTML 요소에 고유한 식별자를 부여하며, 이 식별자는 CSS에서 # 기호를 사용하여 선택자로 지정됩니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>id 선택자</title>
    <style>
        #container {
            background-color: gold;
            padding: 20px;
            width: 500px;
            height: 300px;
            text-align: center;

        }
        #header {
            background-color: deepskyblue;
            width: 200px;
            height: 300px;
            text-align: center;
            /* margin: 100px auto; */
            line-height: 300px;
        }
    </style>
</head>
<body>
    <h2>id 선택자</h2>
    <div id="container">div 첫번째 영역</div>
    <div id="header">div 두번째 영역</div>
</body>
</html>

- class 선택자

CSS 클래스 선택자는 특정한 클래스를 가진 HTML 요소를 선택하여 해당 요소에 스타일을 적용하는 데 사용됩니다. 클래스는 여러 요소에 동시에 적용할 수 있으며, 동일한 클래스를 여러 요소에 사용할 수 있습니다. 클래스 선택자는 마침표(.)로 시작하며, 클래스 이름은 마침표 이후에 나옵니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>class 선택자</title>
    <style>
        .bigText { font-size: 50px; }
        .smallText { font-size: 14px; }
        .redText { color: red; }
    </style>
</head>
<body>
    <h2 class="bigText">class 선택자</h2>
    <p><span class="smallText redText">클래스 선택자는 특정 집단의 요소를 한번에 스타일을 적용</span></p>
    <p><span class="smallText">. 기호를 사용하여 같은 class 이름을 가진 요소에 스타일을 적용</span></p>
</body>
</html>

- 그룹 선택자

그룹 선택자는 동일한 스타일을 여러 선택자에 적용하기 위해 사용됩니다. 여러 선택자를 쉼표로 구분하여 그룹을 형성하고, 해당 그룹에 동일한 스타일을 적용할 수 있습니다. 이는 코드를 간결하게 유지하고 일관된 스타일을 적용하는 데 유용합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>그룹 선택자</title>
    <style>
        * { text-align: center; }
        h2 { font-size: 50px; }
        h3 { font-size: 30px; }
        p, li { font-size: 20px; }
        li { display: inline-block; margin-right: 40px; font-weight: bold; color: deeppink; }
    </style>
</head>
<body>
    <h2>그룹 선택자</h2>
    <p>여러개의 요소를 나열하고 ,(콤마)로 구분하여 스타일을 적용</p>
    <h3>선택자의 종류</h3>
    <li>전체 선택자</li>
    <li>요소 선택자</li>
    <li>아이디 선택자</li>
    <li>클래스 선택자</li>
    <li>그룹 선택자</li>
</body>
</html>

- 자식 자손 선택자

자식 선택자(Child Selector)는 CSS에서 특정 부모 요소의 직계 자식 요소를 선택하는 선택자입니다. 자식 선택자를 사용하면 부모 요소의 직계 자식에만 스타일을 적용할 수 있습니다.

자손 선택자(Descendant Selector)는 CSS에서 특정 조상 요소 내에 있는 모든 하위 요소를 선택하는 선택자입니다. 자손 선택자를 사용하면 모든 하위 요소에 스타일을 적용할 수 있습니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>자식 자손 선택자</title>
    <style>
        ul > a { font-size: 30px; }
        ul a { color: deeppink; }
    </style>
</head>
<body>
    <h2>자식 자손 선택자</h2>
    <ul>
        <a href="https://www.naver.com">네이버</a>
        <li><a href="https://www.google.com">구글</a></li>
        <li>다음</li>
        <li><a href="https://www.nate.com">네이트</a></li>
    </ul>
</body>
</html>

- 일반 인접 형제 선택자

일반 형제 선택자(General Sibling Selector)는 CSS에서 특정 요소의 모든 형제 요소를 선택하는 선택자입니다. 선택자를 사용하여 특정 요소의 형제 요소 중에서 특정한 형제에 스타일을 적용할 수 있습니다.

인접 형제 선택자(Adjacent Sibling Selector)는 CSS에서 특정 요소의 바로 뒤에 나오는 형제 요소를 선택하는 선택자입니다. 선택자를 사용하여 특정 요소의 바로 뒤에 나오는 형제에 대해 스타일을 적용할 수 있습니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>일반 형제 선택자</title>
    <style>
        p + span { color: gold; background-color: deepskyblue;}
        h3 + p { background-color: deeppink; }
        h3 ~ p { color: green; }
    </style>
</head>
<body>
    <h2>일반 형제 선택자</h2>
    <div>
        <h3>첫째</h3>
        <p>둘째</p>
        <a href="#">셋째</a>
        <h4>넷째</h4>
        <p>다섯째</p>
        <span>여섯째</span>
    </div>
</body>
</html>

- 속성 선택자

속성 선택자(Attribute Selector)는 특정 HTML 요소가 특정 속성을 가지고 있는지 여부에 따라 해당 요소를 선택하는 CSS 선택자입니다. 속성 선택자는 대괄호 [] 안에 속성 이름과 속성 값 또는 일치하는 부분을 지정하여 사용됩니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>속성 선택자</title>
    <style>
        [href] { text-decoration: none; color: deeppink; }
        .attr { background-color: gold; }
        [class='attr'] { font-size: 30px; }
        [title] { text-align: center; font-size: 50px;}
    </style>
</head>
<body>
    <h2 title="h2 요소의 title 속성">속성 선택자</h2>
    <p><a href="https://www.naver.com" target="_blank">네이버</a></p>
    <p class="attr">속성명과 속성값이 모두 일치하는 요소를 선택자로 지정</p>
</body>
</html>

- 가상 선택자

가상 선택자(Virtual Selector)는 문서의 특정 상태나 위치에 따라 요소를 선택하기 위한 CSS 선택자입니다. 이러한 선택자들은 사용자 인터랙션, 요소의 상태, 위치 등에 따라 스타일을 동적으로 적용할 수 있도록 합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>가상 선택자</title>
    <style>
        .list > li:first-child { color: deeppink; }
        .list > li:nth-child(2) { color: gold; }
        .list > li:nth-child(odd) { background-color: greenyellow; }
        .list > li:nth-child(even) { background-color: black; }
        .list > li:last-child { color: white; }
    </style>
</head>
<body>
    <h2>가상 선택자</h2>
    <ul class="list">
        <li>첫번째</li>
        <li>두번째</li>
        <li>세번째</li>
        <li>네번째</li>
    </ul>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>가상 선택자</title>
    <style>
        a:link { text-decoration: none; color: greenyellow; }
        a:visited { text-decoration: none; color: deepskyblue; }
        a:hover { text-decoration: underline; }
        a:active { text-decoration: underline; color: red; }

    </style>
</head>
<body>
    <p><a href="https://python.org">파이썬 공식 페이지</a></p>
</body>
</html>

1. HTML

HTML은 HyperText Markup Language(하이퍼텍스트 마크업 언어)의 약자로, 웹 페이지의 구조를 정의하는 마크업 언어입니다. HTML은 웹 브라우저가 웹 페이지를 해석하고 표시하는 데 사용되며, 텍스트, 이미지, 링크, 표, 목록 등의 다양한 요소를 포함할 수 있습니다.

HTML 문서는 태그(tag)라 불리는 특별한 코드로 구성되어 있습니다. 각 태그는 각자의 의미를 가지며, 웹 브라우저에게 문서의 구조를 알려줍니다. 각 태그는 일반적으로 다음과 같은 형식을 가집니다.

2. HTML 기본 구조

<!DOCTYPE html>
<html>
<head>
    <title>문서 제목</title>
</head>
<body>

    <h1>이것은 제목입니다</h1>
    <p>이것은 단락입니다.</p>

</body>
</html>

<!DOCTYPE html>: HTML5 문서 유형을 정의합니다.
<html>: HTML 문서의 시작과 끝을 나타냅니다.
<head>: 문서의 메타데이터와 관련된 정보를 포함하는 부분입니다.
<title>: 문서의 제목을 정의합니다. 이는 브라우저 탭이나 창의 제목에 표시됩니다.
<body>: 실제로 웹 페이지에 표시되는 내용을 담고 있는 부분입니다.
<h1>, <p>: 각각 제목과 단락을 나타내는 태그입니다.

3. 문단 태그

문단(paragraph) 태그는 텍스트를 문단으로 묶는 데 사용되는 HTML 태그입니다. 주로 글의 내용을 구조화하고 가독성을 높이기 위해 활용됩니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>문단 태그</title>
</head>
<body>
    <p>1. 문단 태그</p>
    <p>문단을 만드는 태그</p>
    블록 태그
    블록 태그
</body>
</html>

4. 제목 태그

HTML에서 제목을 나타내는 데 사용되는 태그는 <h1>에서 <h6>까지입니다. 이는 Heading(헤딩) 태그로 불리며, 숫자가 커질수록 제목의 수준이 낮아집니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>제목 태그</title>
</head>
<body>
    <h1>안녕하세요. 제목태그 h1</h1>
    <h2>안녕하세요. 제목태그 h2</h2>
    <h3>안녕하세요. 제목태그 h3</h3>
    <h4>안녕하세요. 제목태그 h4</h4>
    <h5>안녕하세요. 제목태그 h5</h5>
    <h6>안녕하세요. 제목태그 h6</h6>
</body>
</html>

5. 서식 태그

"서식 태그"는 HTML 문서에서 텍스트의 서식을 지정하는 태그들을 가리킵니다. 여러 서식 태그들이 텍스트의 스타일, 강조, 목록, 링크 등을 정의하는 데 사용됩니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>서식태그</title>
</head>
<body>
    <h2>서식 태그</h2>
    <p>b 태그는 글자를 <b>굵게</b> 표현합니다</p>
    <p>strong 태그는 글자를 <strong>굵게</strong> 표현합니다</p>
    <p>i 태그는 글자를 <i>이탤릭체</i>로 표현합니다</p>
    <p>em 태그는 글자를 <em>이탤릭체</em>로 표현합니다</p>
    <p>ins 태그를 사용하면 <ins>중요한 글자</ins>를 표현할 수 있습니다</p>
    <p>del 태그를 사용하면 <del>글자를 지운 것</del>처럼 표현합니다</p>
    <p>sup 태그를 사용해서 수식을 표현: x<sup>2</sup> + y<sup>3</sup> = z</p>
    <p>sub 태그를 사용해서 화학식을 표현: H<sub>2</sub>O</p>
</body>
</html>

6. 목록 태그

HTML에서 목록을 만들기 위해 사용되는 주요 목록 태그에는 <ul>, <ol>, <li>가 있습니다. 이러한 태그들은 웹 페이지에서 항목을 순서 있는 목록(ordered list)이나 순서 없는 목록(unordered list)으로 구성하는 데 사용됩니다.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>목록 태그</title>
</head>

<body>
    <h2>목록 태그</h2>
    <ul>
        <li>러바오</li>
        <li>아이바오</li>
        <li>푸바오</li>
    </ul>

    <hr>
    <ol>
        <li>러바오</li>
        <li>아이바오</li>
        <li>푸바오</li>
    </ol>

    <hr>
    <dl>
        <dt>러바오</dt>
        <dd>아이바오</dd>
        <dd>푸바오</dd>
        <dd>대나무</dd>
    </dl>
</body>
</html>

7. 이미지 태그

이미지를 웹 페이지에 삽입하기 위해 사용되는 HTML 태그는 <img>입니다. <img> 태그는 이미지의 소스(src) 및 대체 텍스트(alt)와 같은 속성을 사용하여 이미지를 정의합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>이미지 태그</title>
</head>
<body>
    <h2>이미지 태그</h2>
    <img src="https://img.png" alt="로고">
    <img src="./rain1.png" alt="비 이미지">
    <img src="./images/rain2.png" alt="비 이미지">
</body>
</html>

8. 하이퍼 링크

하이퍼링크(하이퍼텍스트 링크)를 생성하기 위해 사용되는 HTML 태그는 <a>(앵커) 태그입니다. <a> 태그는 사용자를 다른 웹 페이지로 이동하거나 같은 페이지 내에서 다른 부분으로 이동하게 하는 링크를 생성하는 데 사용됩니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>하이퍼링크</title>
</head>
<body>
    <h2>하이퍼링크</h2>
    <!-- 절대 경로 -->
    <a href="http://koreaisacademy.co.kr">코리아IT아카데미</a>
    <a href="https://www.daum.net"><img src="https://t1.daumcdn.net/daumtop_chanel/op/20200723055344399.png" alt="다음 로고"></a>

    <!-- 상대 경로 -->
    <a href="./subpage/1-1. 이미지태그.html">서브페이지로 이동</a>
    <a href="./subpage/1-1. 이미지태그.html"><img src="./rain5.png" alt="비 이미지"></a>
</body>
</html>

9. 테이블

HTML에서 테이블을 만들기 위해 사용되는 태그는 <table>입니다. 테이블은 행과 열로 구성되며, 각 셀에 데이터를 담을 수 있습니다. 테이블을 만들 때는 <table>을 시작 태그로 사용하고, 각 행은 <tr>(table row) 태그로, 각 셀은 <td>(table data) 태그로 정의합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>테이블 1</title>
</head>
<body>
    <h2>테이블 1</h2>
    <table>
        <tr>
            <td>첫번째 셀</td>
        </tr>
    </table>
    <hr>
    <table border="1" width="300">
        <tr>
            <td>첫번째 셀</td>
        </tr>
    </table>
    <hr>
    <table border="1">
        <tr>
            <td>첫번째 셀</td><td>두번째 셀</td>
        </tr>
        <tr>
            <td>세번째 셀</td><td>네번째 셀</td>
        </tr>
        <tr>
            <td>다섯번째 셀</td><td>여섯번째 셀</td>
        </tr>
    </table>
    <hr>
    <table border="1">
        <tr>
            <td colspan="2">첫번째 셀</td>
        </tr>
        <tr>
            <td>세번째 셀</td><td>네번째 셀</td>
        </tr>
        <tr>
            <td>다섯번째 셀</td><td>여섯번째 셀</td>
        </tr>
    </table>
    <hr>
    <table border="1">
        <tr>
            <td>첫번째 셀</td><td>두번째 셀</td>
        </tr>
        <tr>
            <td rowspan="2">세번째 셀</td><td>네번째 셀</td>
        </tr>
        <tr>
            <td>여섯번째 셀</td>
        </tr>
    </table>
</body>
</html>

10. 아이프레임

아이프레임(<iframe>) 태그는 다른 HTML 문서를 현재 문서에 삽입하는 데 사용됩니다. 이를 통해 외부 웹 페이지, 동영상, 지도 등을 현재 페이지에 내장할 수 있습니다. <iframe> 태그는 웹페이지의 일부분을 다른 웹페이지로 대체하거나, 다른 소스의 콘텐츠를 보여주는 데에 유용합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>아이프레임</title>
</head>
<body>
    <h2>아이프레임</h2>
    <p><a href="./테이블.html">테이블 연습 페이지(현재창)</a></p>
    <p><a href="./테이블.html" target="_blank">테이블 연습 페이지(새탭)</a></p>
    <p><a href="./테이블.html" target="korea">테이블 연습 페이지(아이프레임)</a></p>
    <p><a href="http://www.koreaisacademy.com" target="korea">코리아IT아카데미(아이프레임)</a></p>
    <p><iframe src="http://www.koreaisacademy.com" style="width:100%; height:600px; border: 3px dashed red;" name="korea"></iframe></p>
</body>
</html>

11. 폼

HTML에서 폼(form)은 사용자로부터 정보를 입력 받을 수 있는 구조를 제공하는 데 사용됩니다. 폼을 생성하기 위해 사용되는 주요 태그는 <form>입니다. 폼은 텍스트 입력, 비밀번호 입력, 라디오 버튼, 체크박스, 드롭다운 메뉴 등 다양한 입력 요소를 포함할 수 있습니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>폼태그</title>
</head>
<body>
    <h2>폼태그</h2>
    <form action="./regist" method="post">
        <input type="hidden" name="hdd" value="서버로 전달될 값">

        <p>아이디: <input type="text" maxlength="20" placeholder="아이디를 입력하세요" name="userid" id="userid" required></p>
        <p>비밀번호: <input type="password" maxlength="20" placeholder="비밀번호를 입력하세요" name="userpw" id="userpw" required></p>
        <p>성별: <label for="male">남자</label><input type="radio" name="gender" value="남자" id='male' checked> <label for="female">여자</label><input type="radio" name="gender" value="여자" id="female"></p>
        <p>취미: <label for="hobby1">게임</label><input type="checkbox" name="hobby" id="hobby1" value="게임" checked>  <label for="hobby2">술</label><input type="checkbox" name="hobby" id="hobby2" value="술"> <label for="hobby3">다꾸</label><input type="checkbox" name="hobby" id="hobby3" value="다꾸"> <label for="hobby4">배드민턴</label><input type="checkbox" name="hobby" id="hobby4" value="배드민턴"> <label for="hobby5">드라마시청</label><input type="checkbox" name="hobby" id="hobby5" value="드라마시청"></p>
        <p>첨부파일: <input type="file" name="file"></p>
        <p>이메일: <input type="email" name="email"></p>
        <p>웹사이트: <input type="url" name="url" value='http://www.naver.com' readonly></p>
        <p>전화번호: <input type="tel" name="tel" disabled></p>
        <p>생년월일: <input type="date" name="birthday"></p>
        <p>좋아하는 숫자: <input type="number" min="1" max="10" step="1"></p>
        <p>쿠폰번호: <input type="search" name="search"></p>
        <p>좋아하는 색상: <input type="color" name="color"></p>
        <p>프로그래밍 능력: <input type="range" min="0" max="10" value="3"></p>
        <p>직업: 
            <select name="job" id="job">
                <option value="프로그래머">프로그래머</option>
                <option value="공무원">공무원</option>
                <option value="의사">의사</option>
                <option value="법조인">법조인</option>
                <option value="취준생">취준생</option>
            </select>
        </p>
        <p>자기소개</p>
        <p><textarea name="content" id="content" cols="50" rows="5"></textarea></p>
        <p><input type="button" value="클릭하세요" onclick="alert('안녕?')"> <input type="reset" value="다시입력"> <input type="submit" value="회원가입"></p>
    </form>
</body>
</html>

12. 디스플레이

디스플레이 관련 태그는 웹 페이지에서 콘텐츠의 표시 방법과 레이아웃을 제어하는 데 사용됩니다. 주로 CSS (Cascading Style Sheets)와 함께 사용되며, 웹 페이지의 디자인 및 레이아웃을 조정하는 데에 큰 역할을 합니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>디스플레이</title>
</head>
<body>
    <h2>디스플레이</h2>
    1. <span style="font-size: 30px; color: deeppink">span 태그 영역</span>입니다.
    <div style="width: 600px; height: 300px; background-color: gold;">2. div 태그 영역</div>
</body>
</html>

13. 시맨틱 태그

시맨틱 태그(semantic tags)는 HTML5에서 도입된 태그로, 문서의 구조와 의미를 더 명확하게 전달하기 위해 사용됩니다. 이러한 태그들은 웹 페이지의 콘텐츠를 구조화하고 의미를 부여하여 검색 엔진 및 개발자에게 페이지의 내용을 이해하기 쉽게 만듭니다.

<header>: 문서나 섹션의 머리말을 정의합니다.
<nav>: 내비게이션 링크를 정의합니다.
<article>: 독립적으로 구분되거나 재사용 가능한 컨텐츠 영역을 정의합니다.
<section>: 문서의 섹션을 정의합니다.
<aside>: 주변 내용과는 관련이 적은 부가 정보를 포함하는 콘텐츠를 정의합니다.
<footer>: 문서나 섹션의 꼬리말을 정의합니다.