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와 일치해야함

'컴퓨터 비전 > 웹 서비스' 카테고리의 다른 글

FastAPI  (0) 2023.12.16
Streamlit  (2) 2023.12.03
픽사베이  (1) 2023.12.03
인스타그램  (1) 2023.12.03
셀레니움  (0) 2023.12.02

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"}

'컴퓨터 비전 > 웹 서비스' 카테고리의 다른 글

Jinja 템플릿 엔진  (0) 2023.12.18
Streamlit  (2) 2023.12.03
픽사베이  (1) 2023.12.03
인스타그램  (1) 2023.12.03
셀레니움  (0) 2023.12.02

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>: 문서나 섹션의 꼬리말을 정의합니다.

'컴퓨터 비전 > HTML' 카테고리의 다른 글

<textarea>에서 첫 줄에 공백이 생길 때!  (0) 2024.02.11

1. 동기(Synchronous)

동기적인 작업은 순차적으로 실행되며, 한 작업이 끝나야 다음 작업이 시작됩니다.

간단한 비유로 설명하자면, 일을 처리하는데 한 가지 작업이 끝나기를 기다리면서 그때까지 다른 작업을 처리하지 않는 것과 비슷합니다. 대표적으로 함수를 호출하면 해당 함수의 실행이 끝날 때까지 제어가 반환되지 않습니다.

 

def func1():

    print('1')
    print('2')
    print('3')


def main():
    func1()


main()

# 동기는 스택처럼 쌓임
# 호출 호출 호출 >> 맨 끝 함수부터 스택구조로 순차적으로 실행

 

import time

def nagging():
  time.sleep(1)     # 동기함수
  print('🐼')


def main():
  nagging()
  nagging()


print(f"start : {time.strftime('%X')}")
main()
print(f"end : {time.strftime('%X')}")
더보기
start : 13:16:04
🐼
🐼
end : 13:16:06

 

 

2. 비동기(Asynchronous)

비동기적인 작업은 한 작업이 시작되면 바로 다음 작업으로 넘어가며, 작업이 완료되기를 기다리지 않습니다.
이는 주로 이벤트 핸들링, 네트워크 호출, 파일 읽기/쓰기 등의 상황에서 유용합니다.
대표적인 예로 비동기 함수 호출이 있습니다.

# sleep이 동기함수 이므로 asyncio.sleep 비동기용 슬립함수를 사용


import time

import asyncio

# asycn def : 코루틴
async def nagging():        
    await asyncio.sleep(1)  # 비동기 함수
    print('🐼')


async def main():
    await asyncio.gather(
        nagging(),
        nagging()
    )

    
print(f"start : {time.strftime('%X')}")
asyncio.run(main())
print(f"end : {time.strftime('%X')}")

 

await (동기처럼 멈춰주는 역할)

await는 Python에서 비동기 프로그래밍을 할 때 사용되는 키워드로, 주로 async 함수 내에서 다른 비동기 함수의 실행을 기다리는 데에 쓰입니다. await 키워드를 사용하면 현재 실행 중인 코루틴(coroutine)이 다른 코루틴의 완료를 기다리면서 실행을 일시 중단할 수 있습니다. 비동기 함수를 정의할 때는 함수 선언 앞에 async 키워드를 붙이고, 그 안에서 다른 비동기 함수를 호출할 때는 await를 사용합니다. await는 오직 async 함수 내에서만 사용됩니다. 일반적인 동기 함수나 스크립트에서는 사용할 수 없습니다.

 

run()

asyncio.run은 Python의 asyncio 모듈에서 제공하는 함수로, Python 3.7 이후 버전에서 도입되었습니다. 이 함수는 asyncio 이벤트 루프를 생성하고 실행하는 역할을 합니다. 주로 콘솔 스크립트나 간단한 애플리케이션에서 사용됩니다.

asyncio.run(main(), debug=False)
# main(): 실행하고자 하는 비동기 함수입니다. 이 함수는 asyncio 이벤트 루프에서 실행됩니다.
# debug: 선택적 매개변수로, 디버그 모드를 설정합니다. 기본값은 False입니다.

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

20. 변수 타입 어노테이션  (0) 2023.12.13
19. 파이썬 모듈  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12

1. 변수 타입 어노테이션

변수 타입 어노테이션은 파이썬 3.5부터 도입된 기능으로, 변수의 예상 타입을 명시하는데 사용됩니다. 이는 주로 코드의 가독성을 높이고, 정적 타입 검사 도구(예: mypy)를 사용하여 타입 오류를 사전에 잡아내기 위한 목적으로 사용됩니다.

타입 어노테이션은 실제로 변수의 타입을 강제하는 것이 아니라, 개발자가 변수가 어떤 타입을 가져야  것으로 예상하는지 명시하는 것입니다.

 

2. 기본 타입 어노테이션

name : str = '푸바오'
age : int = 3
height : float = 120.5
is_lover : bool = True


print(name)
print(type(name))
더보기
푸바오
<class 'str'>

 

 

3. 리스트, 튜플, 딕셔너리, 세트

컬렉션 타입에 대한 어노테이션은 조금  복잡합니다. 이를 위해 List, Tuple, Dict, Set 등의 제네릭 타입을 사용하게 됩니다. 이러한 타입들은 typing 모듈에서 가져올  있습니다.

from typing import List, Tuple, Dict, Set

names : List[str] = ['푸바오', '루이바오', '후이바오']
age : Tuple[int, int] = (25, 20)
scores : Dict[str, float] = {'푸바오' : 50, '아이바오' : 100}
numbers : Set[int] = {1, 2, 3, 3, 4}


print(names)
print(age)
print(scores)
print(numbers)
더보기
['푸바오', '루이바오', '후이바오']
(25, 20)
{'푸바오': 50, '아이바오': 100}
{1, 2, 3, 4}

 

 

4. 함수

함수의 매개변수와 반환 타입에 대한 어노테이션은 다음과 같이 합니다.

def add(a: int, b: int) -> int: # a는 int, b는 int, 결과(리턴값)는 int 자료형으로 처리
    return a + b
    
print(add(10, 5))
print(add('10','삼'))

print(add.__annotations__) # 타입 어노테이션을 확인
더보기
15
10삼
{'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

 

 

5. 클래스

클래스 또는 사용자 정의 타입에 대한 어노테이션도 가능합니다.

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    def __str__(self) -> str:
        return '이름:' + self.name + ', 나이:' + str(self.age)

def print_student(s: Student) -> None:
    print(f"이름:{s.name}, 나이:{s.age}")

student = Student('푸바오', 3)
print(student)
print_student(student)
더보기
이름:푸바오, 나이:3
이름:푸바오, 나이:3

 

 

6. 옵셔널

변수가 특정 타입이거나 None  있는 경우 Optional 사용합니다.

from typing import Optional

def find_score(name : str, scores : Dict[str, float]) -> Optional[float] :
    return scores.get(name)
    
print(find_score('푸바오', {'푸바오':80.5, '대나무':40.5, '아이바오':90.5}))
print(find_score('러바오', {'푸바오':80.5, '대나무':40.5, '아이바오':90.5}))
더보기
80.5
None

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

21. 파이썬 동기/비동기  (0) 2023.12.13
19. 파이썬 모듈  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12

1. 모듈

파이썬에서 모듈을 만들려면 간단히 .py 확장자를 가진 파일에 코드를 작성하면 됩니다. 모듈은 단순한 함수 뿐만 아니라 변수, 클래스 등도 포함할  있으며, 다른 스크립트에서 import 구문을 사용하여 가져올  있습니다.

 

 

 

 math_tools.py

# 변수

PI = 3.141592


# 함수

def add(a, b):
return a + b


def subtract(a, b):
return a - b


# 클래스
class Circle:
def __init__(self, radius):
self.radius = radius


def area(self):
return PI * self.radius * self.radius

.

 

구글 드라이브 마운트해서 사용하기

→ 구글드라이브에 math_tools.py 업로드 후 경로지정

path = '/content/drive/MyDrive/컴퓨터비전 시즌1/1.파이썬 기초/module/'

import sys
sys.path.append(path)
import math_tools
 

 

# 모듈 내의 변수
print(math_tools.PI)
더보기
3.141592653589793
# 모듈 내의 함수
print(math_tools.add(5,3))
print(math_tools.subtract(5,3))
# 모듈 내의 클래스
circle = math_tools.Circle(5)
print(circle.area())
더보기
78.53981633974483
# 필요한 속성, 클래스만 가져오기
from math_tools import PI, Circle

print(PI)
circle = Circle(5)
print(circle.area())
더보기
3.141592653589793
78.53981633974483
import math_tools as mt

# 모듈 내의 함수 사용
print(mt.add(5, 3))  # 8
print(mt.subtract(5, 3))  # 2

# 모듈 내의 클래스 사용
circle = mt.Circle(5)
print(circle.area())
더보기
8
2
78.53981633974483

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

21. 파이썬 동기/비동기  (0) 2023.12.13
20. 변수 타입 어노테이션  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12

1. 예외

예외(Exception) 프로그램 실행  발생할  있는 예상치 못한 문제 또는 오류 상황을 의미합니다. 예외가 발생하면 프로그램은 중단되기 때문에 이를 적절하게 처리하여 중단을 방지하거나 오류에 대한 정보를 사용자에게 제공해야 합니다.

 

2. 예외가 발생하는 경우

  • ValueError
    • 잘못된 값을 함수나 연산에 제공할 때 발생합니다.
    • 예) 숫자가 아닌 문자열을 int() 함수로 변환하려고 할 때 발생.
  • TypeError
    • 올바르지 않은 유형의 객체를 연산에 사용하려 할 때 발생합니다.
    • 예) 문자열과 숫자를 함께 더하려고 할 때 발생.
  • ZeroDivisionError
    • 숫자를 0으로 나누려고 할 때 발생합니다.
  • IndexError
    • 리스트, 튜플, 문자열 등의 시퀀스 유형에서 범위를 벗어난 인덱스에 접근하려 할 때 발생합니다.
    • 예) 길이가 3인 리스트에 대해 4번째 요소에 접근하려고 할 때 발생.
  • KeyError
    • 딕셔너리에서 존재하지 않는 키를 사용하여 값을 검색하려고 할 때 발생합니다.
  • AttributeError
    • 객체에 없는 속성이나 메서드에 접근하려고 할 때 발생합니다.
  • FileNotFoundError
    • 존재하지 않는 파일을 열려고 할 때 발생합니다.
  • ImportError
    • 존재하지 않는 모듈을 가져오려고 할 때 또는 모듈 내에 해당 속성/함수가 없을 때 발생합니다.
  • NameError
    • 정의되지 않은 변수나 함수를 사용하려고 할 때 발생합니다.
    • 예) 프로그램에서 정의되지 않은 변수 x를 사용하려고 할 때 발생.
  • OverflowError
    • 수치 연산 결과가 너무 커서 표현할 수 없을 때 발생합니다.
  • MemoryError
    • 프로그램이 사용 가능한 모든 메모리를 소진했을 때 발생합니다.

 

3. 예외 처리 기본 구조

try:
    # 예외가 발생할 가능성이 있는 코드
    
except ExceptionType1:  # 'ExceptionType1'에는 실제 예외 유형이 들어갑니다.
    # ExceptionType1 예외가 발생했을 때 실행될 코드
    
except ExceptionType2:  # 'ExceptionType2'에는 다른 예외 유형이 들어갑니다.
    # ExceptionType2 예외가 발생했을 때 실행될 코드
    
# 추가적인 except 블록을 계속 추가할 수 있습니다.

else:
    # try 블록에서 예외가 발생하지 않았을 때 실행될 코드
    
finally:
    # 예외 발생 여부와 관계없이 항상 실행될 코드

 

 

예시1)

# 에러코드 확인

print(10 / 3)
print(5 / 0)
print(4 / 2)



3.3333333333333335
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-1-9c5e3ff0ad94> in <cell line: 2>()
      1 print(10 / 3)
----> 2 print(5 / 0)
      3 print(4 / 2)

ZeroDivisionError: division by zero

 

 

# 특정 예외 처리

try:
    print(10 / 3)
    print(5 / 0)    #ZeroDivisionError: division by zero
    print(4 / 2)
except ZeroDivisionError :
    print('0으로 나눌 수 없습니다.')
print('프로그램 종료')
더보기
3.3333333333333335
0으로 나눌 수 없습니다.
프로그램 종료

 

# 모든 예외처리 

try:
    print(10 / 3)
    print(5 / 0)
    print(4 / 2)
except :
    print('0으로 나눌 수 없습니다.')
print('프로그램 종료')
더보기
3.3333333333333335
0으로 나눌 수 없습니다.
프로그램 종료

 

 

 

예시2)

# 에러 코드 확인

data = [10, 20, 30, 40, 50]
print(data[5])


---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-4-879de49a30d4> in <cell line: 2>()
      1 data = [10, 20, 30, 40, 50]
----> 2 print(data[5])

IndexError: list index out of range

 

# 모든 예외 처리

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except:
    print('인덱스 지정 잘못됨')
print('종료')
더보기
10
인덱스 지정 잘못됨
종료

# 특정 예외 처리

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except IndexError:
    print('인덱스 지정 잘못됨')
print('종료')
더보기
10
인덱스 지정 잘못됨
종료

 

 

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(int('일'))
    print(5/0)
    print(data[5])
    print()
    print(data[3]) #IndexError: list index out of range
except IndexError :
    print('인덱스 지정 잘못됨')
except ZeroDivisionError:
    print('0으로 나눌 수 없음')
except:                     # 전체예외처리는 마지막에 써야함
    print('오류처리')
print('종료')
더보기
10
오류처리
종료

 

  • except:만 사용: 하면 프로그램 종료나 키보드 중단과 같은 특수한 예외까지 처리할 수 있지만, 대부분의 상황에서 이렇게 예외 처리는 권장되지 않습니다.
  • except Exception as e:는 일반적인 예외만 처리하면서, 발생한 예외의 상세 정보에 접근할 수 있는 능력을 제공합니다. 이 형태를 사용하면 더 명시적이며 예외 처리가 더 예측 가능해집니다.

 

 

# 예외 에러 메세지 받기

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(5/0)
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except IndexError as e:
    print(e)
except ZeroDivisionError as e:
    print(e)
except Exception as e:                # 전체예외처리는 마지막에 써야함
    print(e)
print('종료')
더보기
output
10
division by zero
종료

# 예외가 발생하지 않았을 경우

try:
    data = [10, 20, 30, 40, 50]
    string = '오늘은 즐거운 예외처리 시간!'
    print(10 / 3)
    print(4 / 2)
except ZeroDivisionError as e:
    print('0으로 나눌 수 없습니다', e)
except IndexError as e:
    print('인덱스 지정이 올바르지 않습니다', e)
except TypeError as e:
    print('데이터 타입이 올바르지 않습니다', e)
else:
    print('정상적인 프로그램 진행')
print('프로그램을 종료합니다')
더보기
3.3333333333333335
2.0
정상적인 프로그램 진행
프로그램을 종료합니다

 

# 예외 발생 여부와 관계없이 실행하기

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(5/0)
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except IndexError as e:
    print(e)
except ZeroDivisionError as e:
    print(e)
except Exception as e:                # 전체예외처리는 마지막에 써야함
    print(e)
else:
    print('정상적인 프로그램 실행')
finally:
    print('오류에 관계없이 무조건 실행되는 문장')
print('종료')
더보기
10
division by zero
오류에 관계없이 무조건 실행되는 문장
종료

 

 

 

4. Exception 클래스

Exception 클래스는 파이썬의 내장 예외 계층 구조에서 거의 모든 내장 예외의 기본 클래스입니다. 이 클래스는 사용자 정의 예외를 만들거나 특정 예외 유형을 잡기 위한 기본적인 인터페이스를 제공합니다.

  1. 상속: 예외 유형은 Exception을 상속받아서 정의됩니다. 예를 들면 ValueError, TypeError, FileNotFoundError 등이 있습니다. 이 상속 구조 덕분에 except Exception 블록은 Exception을 상속받은 모든 예외를 캡처할 수 있습니다.
  2. 메시지: 예외가 생성될 때, 일반적으로 오류 메시지를 함께 전달할 수 있습니다. 이 메시지는 예외 객체의 args 속성을 통해 접근 가능하며, 예외를 문자열로 변환할 때(예: str(e)) 해당 메시지가 반환됩니다.

 

try:
    raise Exception('에러가 발생') # raise 에러를 내는 코드
except Exception as e:
    print(e)
def func1():
    n = int(input('짝수 입력 : '))
    if n % 2 != 0:
        raise Exception('짝수가 아닙니다.') # raise를 통해서 에러가 발생하게 만듬
    print(n)

try:
    func1()
except Exception as e:
    print('예외가 발생했습니다.')
더보기
짝수 입력 : 11
예외가 발생했습니다.
def func1():
    func2()

def func2():
    func3()

def func3():
    try:
        print('%d' % '문자열 출력')
    except TypeError:
        print('타입이 올바르지 않음')

func1()
# 리턴받기 전까지만 오류처리를 해주면됨
더보기
타입이 올바르지 않음

 

 

 

5. 사용자 정의 예외 클래스를 직접 만들고 활용하기

class AgeLimitError(Exception):
    def __init__(self, age, message ='원하는 나이 범위가 아님~'):
        self.age = age
        super().__init__(message) # 부모클래스 생성자에 메세지전달
        
def check_age(age):
    if age < 20:
        raise AgeLimitError(age, '어림')
    elif age > 40:
        raise AgeLimitError(age ,'늙음')
    else:
        return('적당')
        
ages = [17, 25, 43, 19]

for age in ages:
    try:
        print(check_age(age))
    except AgeLimitError as e:
        print(f"Error for age {e.age}: {e}")
더보기
Error for age 17: 어림
적당
Error for age 43: 늙음
Error for age 19: 어림

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

20. 변수 타입 어노테이션  (0) 2023.12.13
19. 파이썬 모듈  (0) 2023.12.13
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11

1. 스페셜 메서드

파이썬의 스페셜 메서드 (또는 매직 메서드라고도 불림)는 더블 언더스코어(__)로 시작하고 끝나는 메서드 이름을 갖습니다. 이 메서드들은 특정 구문이나 내장 함수를 사용할 때 파이썬 인터프리터에 의해 자동으로 호출됩니다.

예를 들어, 객체에 대해 + 연산자를 사용하면 해당 객체의 __add__ 메서드가 호출됩니다. 또는 len() 함수를 사용하면 __len__ 메서드가 호출됩니다.

 

 

1. __init__ : 객체 초기화 메서드

2. __str__ : 객체를 문자열로 표현하는 메서드. print() 함수나 str() 함수를 사용할  호출됩니다.

class Book:
    def __init__(self, title):
        self.title = title

book = Book('파이썬')
print(book)
print(str(book))
더보기
<__main__.Book object at 0x7b6b4b2ecc10>
<__main__.Book object at 0x7b6b4b2ecc10>

 

class Book:
    def __init__(self, title):
        self.title = title

    def __str__(self):
        return self.title
        
book = Book('파이썬')
print(book)
print(str(book))
더보기
파이썬
파이썬

 

 

3. __add__ : + 연산자를 사용할  호출되는 메서드

class Calc:
    def __init__(self, value):
        self.value = value

    def __add__(self, other): # other : 다른객체
        return self.value + other.value

num1 = Calc(5)
num2 = Calc(10)
result = num1 + num2
print(result)
# 덧셈 오버라이딩

 

4. __len__ : len() 함수를 사용할  호출되는 메서드

class Queue:
    def __init__(self):
        self.items = [1, 2, 3, 4, 5]

    def __len__(self):
        return len(self.items) #len()
        
        
queue = Queue()
print(len(queue))

 

 

5. __getitem__ : 인덱싱을 사용할  호출되는 메서드

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            return -1

p1 = Point(3, 4)
print(p1[0], p1[1], p1[100])
더보기
3 4 -1

 

6. __call__ : 객체를 함수처럼 호출할  사용되는 메서드

class CallableObject:
    def __call__(self, *args, **kwargs):
        print(f"Called with arguments: {args} and keyword arguments: {kwargs}")

callable_obj = CallableObject()
callable_obj(1, 2, 3, a="A", b="B")
더보기
Called with arguments: (1, 2, 3) and keyword arguments: {'a': 'A', 'b': 'B'}

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

19. 파이썬 모듈  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11
14. 콜백함수와 람다함수  (1) 2023.12.11

1. 상속

파이썬에서 상속은  클래스의 속성과 메서드를 다른 클래스에 전달하는 기능을 의미합니다. 상속을 사용하면 기존의 코드를 재사용하고 확장할  있습니다. 기본적으로 파이썬의 모든 클래스는 object라는 기본 클래스로부터 상속받습니다.

 

기본 클래스 (또는 부모 클래스): 상속의 출발점이 되는 클래스입니다.

파생 클래스 (또는 자식 클래스): 상속을 통해 속성과 메서드를 받는 클래스입니다.

 

 

class Parent:
    pass

class Child(Parent):
    pass

 

 

class Animal:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def eat(self, food):
            print(f'{self.name}는 {food}를 먹습니다.')

        def sleep(self, hour):
            print(f'{self.name}는 {hour}시간 동안 잠을 잡니다.')


animal = Animal('푸바오', 10) #객체 생성
animal.eat('대나무')
animal.sleep(10)
더보기
animal = Animal('푸바오', 10) #객체 생성
animal.eat('대나무')
animal.sleep(10)
class Bear(Animal): # Animal 클래스를 상속
    pass
    
    
    
# Animal 클래스를 상속 받았기 때문에
# Animal 클래스의 생성자 매개변수(name, age)를 전달해야 한다.
#hui = Bear()

hui = Bear('후이바오', 1)
hui.eat('분유')
hui.sleep(10)
더보기
후이바오는 분유를 먹습니다.
후이바오는 10시간 동안 잠을 잡니다.

 

 

2. 클래스 상속 시 생성자 호출 순서

1. 자식 클래스(child class)의 생성자가 호출됩니다.
2. 자식 클래스의 생성자에서 부모 클래스(parent class)의 생성자를 호출해야 합니다. 이를 위해 super() 함수를 사용합니다. super() 함수는 현재 클래스의 부모 클래스를 참조하며, 부모 클래스의 생성자를 호출할 수 있습니다.
3. 부모 클래스의 생성자가 호출됩니다.
4. 부모 클래스의 생성자가 실행을 마치면 자식 클래스의 생성자로 돌아가 자식 클래스의 생성자 코드가 실행됩니다.

 

class Parent:
    def __init__(self):
        print('부모 클래스의 생성자 호출')

class Child(Parent):
    def __init__(self):
        print('Child 클래스 생성자 호출')
        super().__init__()              # super<-부모 클래스/ 부모 클래스의 생성자를 호출
        print('자식 클래스 생성자 호출')
        
        
child = Child()
더보기
Child 클래스 생성자 호출
부모 클래스의 생성자 호출
자식 클래스 생성자 호출

 

3. ※ Object 클래스

object는 파이썬의 모든 클래스의 기본 클래스입니다. object 클래스는 파이썬에서 모든 객체의 기본적인 동작과 특성을 정의합니다.

class MyClass:
    pass
# 위 클래스는 아래 클래스와 동일
class MyClass(object):
    pass

 

 

4. 메서드 오버라이딩

메서드 오버라이딩(Method Overriding)은 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 서브 클래스(자식 클래스)에서 슈퍼 클래스(부모 클래스)의 메서드를 재정의하는 것을 의미합니다. 오버라이딩을 사용하면, 서브 클래스에서 상속받은 메서드의 동작을 변경하거나 확장할 수 있습니다.

 

#부모 클래스
class Animal:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def eat(self, food):
            print(f'{self.name}는 {food}를 먹습니다.')

        def sleep(self, hour):
            print(f'{self.name}는 {hour}시간 동안 잠을 잡니다.')
            
#자식 클래스
class Bear(Animal):
    def run(self):
        print(f'{self.name}은/는 달립니다.')

    def eat(self, food):
        print(f'{self.name}은/는 {food}를 많이 먹습니다.')

    def superEat(self, food):
        super().eat(food)            
        
        
        
Fubao = Animal('Fubao', 3) #부모 클래스
Fubao.eat('대나무')		#부모 클래스 eat
Fubao.sleep(10)        	   #부모 클래스 sleep

Lebao = Bear('러바오', 13)
Lebao.eat('대나무') # 자식클래스의 eat이 출력
Lebao.run()			
Lebao.sleep(10)		 
Lebao.superEat('당근') #부모것을 호출
더보기
Fubao는 대나무를 먹습니다.
Fubao는 10시간 동안 잠을 잡니다.


러바오은/는 대나무를 많이 먹습니다.
러바오은/는 달립니다.
러바오는 10시간 동안 잠을 잡니다.
러바오는 당근를 먹습니다.
animal = Animal('판다', 10)
# 부모 클래스는 자식 클래스를 알 수 없음.
# 자식 클래스의 객체 메서드를 사용하지 못함
animal.eat('사과')
#animal.run() 
#AttributeError: 'Animal' object has no attribute 'run'

 

 

5. ※ super() 메소드

super()는 파이썬의 내장 함수로서, 상속과 관련된 작업을 수행할 때 사용됩니다. 특히, 자식 클래스에서 부모 클래스의 메서드를 호출할 때 사용됩니다. super()의 주요 목적은 자식 클래스에서 부모 클래스의 메서드를 오버라이드(재정의)하면서도 그 오버라이드된 메서드 내에서 부모 클래스의 원본 메서드를 호출하는 것입니다.

 

5-1. 기본적인 사용

class Parent:
    def hello(self):
        print('부모클래스의 hello 메서드')
        
class Child(Parent):
    def hello(self):
        super().hello()
        print('자식클래스의 hello 메서드')
        
        
c = Child() #자식객체 생성
c.hello()
더보기
부모클래스의 hello 메서드
자식클래스의 hello 메서드

 

 

5-2. __init__메서드의 사용

class Parent:
    def __init__(self, value):
        self.value = value
        
class Child(Parent):
    def __init__(self, value, child_value):
        super().__init__(value)
        self.child_value = child_value        
        

c = Child(10, 20)
print(c.value)      #10
print(c.child_value)#20

 

5-3. 다중상속의 문제

class Base:
    def hello(self):
        print('Base 클래스의 hello 메서드 호출')

class A(Base):
    def hello(self):
        super().hello()
        print('A클래스의 hello 메서드 호출')

class B(Base):
    def hello(self):
        super().hello()
        print('B클래스의 hello 메서드 호출')

class Child(A,B):
    def hello(self):
        super().hello()
        print('Child 클래스의 hello 메서드 호출')
Child.mro()
#Base가 최상
#왼쪽 A
#오른쪽 B
#맨아래 Child
더보기
[__main__.Child, __main__.A, __main__.B, __main__.Base, object]
c = Child()
c.hello()
더보기
Base 클래스의 hello 메서드 호출
B클래스의 hello 메서드 호출
A클래스의 hello 메서드 호출
Child 클래스의 hello 메서드 호출

 

순서 : Base → B →  A → Child

 

6. 다중 상속

다중 상속은 클래스가 둘 이상의 부모 클래스로부터 상속을 받는 기능을 의미합니다. 파이썬은 다른 많은 객체 지향 언어와 달리 다중 상속을 지원합니다. 다중 상속을 사용하면 코드의 재사용성을 향상시킬 수 있지만, 동시에 복잡성이 높아지기 때문에 주의해야 합니다.

 

#부모 클래스
class Animal:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def eat(self, food):
            print(f'{self.name}는 {food}를 먹습니다.')

        def sleep(self, hour):
            print(f'{self.name}는 {hour}시간 동안 잠을 잡니다.')
            
class Human:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self, hour):
        print(f'{self.name}는 {hour}시간 동안 공부를 합니다.')
 
 
 
class Fubao(Animal, Human): # 두 클래스의 기능을 상속받아 두개의 기능을 사용가능
    pass 
    
    
Fu = Fubao('푸바오', 20)
Fu.eat('대나무')
Fu.study(2)

# 다이아몬드 문제 발생시 메서드가 실행되는 순서
Fubao.mro()

#[__main__.Fubao, > __main__.Animal,> __main__.Human,> object]
#Fubao가 다이아모양중 맨 아래
더보기
푸바오는 대나무를 먹습니다.
푸바오는 2시간 동안 공부를 합니다.
[__main__.Fubao, __main__.Animal, __main__.Human, object]

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11
14. 콜백함수와 람다함수  (1) 2023.12.11
13. 변수의 범위  (1) 2023.12.11