728x90
반응형

PyMySQL 설치

conda install -c conda-forge PyMySQL

mysqlapp 생성

python manage.py startapp mysqlapp

mysqlapp web 구현

mysqlapp
- 함수명 index 생성
- HttpResponse("index 페이지 입니다." ) 출력
- mysqlapp에 urls.py 생성
- url 패턴 : http ://127.0.0.1:8000/mysql/
  • mysqlapp > urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/mysql/
    path('', views.indexHtml ),
]
  • config > urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    ### mysqlapp의 urls.py 사용하기
    # http://127.0.0.1:8000/mysql/index
    path("mysql/", include("mysqlapp.urls")),

    path('admin/', admin.site.urls),
]
  • mysqlapp > views.py
from django.shortcuts import render
from django.http import HttpResponse

### http ://127.0.0.1:8000/mysql/
def index(request) :
    return HttpResponse("<u>index 페이지입니다.</u>")
  • config > settiings.py에서 INSTALLED_APPS에 'mysqlapp' 추가

데이터 여러건 조회하기

  • templates\mysqlapp\cart\cart_list.html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <h2>장바구니 전체 목록 조회하기🧺</h2>
    <h5>조회 건수 : {{cart_cnt}}</h5>
    <table border="1">
      <tr>
        <th>회원아이디</th>
        <th>주문번호</th>
      </tr>
      {% for data in cart_list %}
      <tr>
        <th>{{ data.cart_member }}</th>
        <th>{{ data.cart_no }}</th>
      </tr>
      {% endfor %}
    </table>
  </body>
</html>
  • mysqlapp > views.py
from django.shortcuts import render
from django.http import HttpResponse

from mysqlapp.model.cart_model import Cart

### http ://127.0.0.1:8000/mysql/
def index(request) :
    return HttpResponse("index 페이지입니다.")

### 데이터 여러건 조회하기
# - 장바구니 리스트 조회하기
# - /mysql/cart_list/
def cart_list(request) :
    ### model(DB) 처리
    # Cart class 생성
    cart = Cart()
    
    ### 장바구니 전체 정보 조회하기
    # - cart_cnt : 정수값을 반환받음
    # - cart_list : [{'컬럼명' : 값, '컬럼명' : 값, ...}, {}, {}]
    cart_cnt, cart_list = cart.getCartList()
    
    ### 반환
    return render(
        request,
        "mysqlapp/cart/cart_list.html",
        {"cart_cnt" : cart_cnt,
         "cart_list" : cart_list}
    )
  • mysqlapp > urls.py
from django.urls import path
from . import views

urlpatterns = [
     # http://127.0.0.1:8000/mysql/cart_list/
    path('cart_list/', views.cart_list ),
    # http://127.0.0.1:8000/mysql/
    path('', views.index ),
]

 

  • mysqlapp > model > model.py
    데이터와의 접속 정보를 담고, 커서 받아오기, 자원 종료 > 데이터베이스와 관련된 설정을 하는 곳
### 데이터베이스 처리 순서
# - DB 드라이버 연결 (PyMySQL이 연결 해줌)
# - DB 접속
# - DB로부터 cursor 받아오기
# - 조회/입력/수정/삭제 sql을 DB서버로 요청
# - DB 자원 반환

# - DB 드라이버 연결 (PyMySQL이 연결 해줌)
import pymysql

class Mysql_Model :
    ### 생성자
    def __init__(self) :
        # DB 접속 정보 정의
        self.initDBInfo()
        
        # DB 접속
        self.DBConnection()
        
        # DB로부터 cursor 받아오기
        self.DBCursor()
    
    ### DB 접속정보 확인
    def initDBInfo(self) :
        self.host = "localhost"
        self.user = "gjuser"
        self.password = "dbdb"
        self.db = "gjdb"
        # 문자 인코딩 타입
        self.charset = "utf8"
        # 조회 시 컬럼명을 동시에 보여줄지 여부 설정
        self.cursorclass = pymysql.cursors.DictCursor
        # 입력/수정/삭제 시 DB에 자동 반영 여부
        self.autocommit = True
        
    # - DB 접속
    def DBConnection(self) :
        try :
            self.conn = pymysql.connect(
                host = self.host,
                user = self.user,
                password = self.password,
                db = self.db,
                charset = self.charset,
                cursorclass = self.cursorclass,
                autocommit = self.autocommit
            )
            print("DB 접속 성공 -->", self.conn)
        except :
            print("DB 접속 정보 확인이 필요합니다.")
            
    # - DB로부터 cursor 받아오기
    def DBCursor(self) :
        self.cur = self.conn.cursor()
        
    # - 조회/입력/수정/삭제 sql을 DB서버로 요청
    # - cart_model.py에서 처리
    
    # - DB 자원 반환
    def DBClose(self) :
        try:
            self.cur.close()
            self.conn.close()
            print("DB 정보 반환 완료")
        except:
            print("이미 DB 정보가 반환되었습니다.")
  • mysqlapp > model > cart_model.py
    sql구문 작성
import pymysql
from mysqlapp.model.mysql import Mysql_Model

class Cart :
    ### 생성자
    def __init__(self) :
        self.db = Mysql_Model()
        
    ### 장바구니 전체 조회하기
    def getCartList(self) :
        sql = """
            Select cart_member, cart_no
            From cart
            Order By cart_member, cart_no        
        """
        
        ### DB에 요청하기 : cursor에 담기
        # 실행 결과의 건수
        rs_cnt = self.db.cur.execute(sql)
        
        # 실행 결과 데이터
        rows = self.db.cur.fetchall()
        
        # DB 정보 반환하기
        self.db.DBClose()
        
        return rs_cnt, rows

 

회원 상세정보 불러오기

  • templates\mysqlapp\cart\cart_list.html
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <h2>회원 상세 조회하기😊</h2>
    <table border="1">
      <tr>
        <th>회원아이디</th>
        <td>{{mem_view.mem_id}}</td>
      </tr>
      <tr>
        <th>회원이름</th>
        <td>{{mem_view.mem_name}}</td>
      </tr>
      <tr>
        <th>회원주소</th>
        <td>{{mem_view.mem_add1}} {{mem_view.mem_add2}}</td>
      </tr>
    </table>
  </body>
</html>
  • mysqlapp > urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/mysql/mem_view/
    path('mem_view/', views.mem_view ),
    
    # http://127.0.0.1:8000/mysql/cart_list/
    path('cart_list/', views.cart_list ),
    
    # http://127.0.0.1:8000/mysql/
    path('', views.index ),
]
  • mysqlapp > views.py
from django.shortcuts import render
from django.http import HttpResponse

from mysqlapp.model.member_model import Member

def mem_view(request) :
    ### 요청 파라메터 받기 : request가 가지고 있음
    if request.method == "POST" :
        mem_id = request.POST.get("mem_id", "none")
    elif request.method == "GET" :
        mem_id = request.GET.get("mem_id", "none")
        
        # DB 조회
        member = Member()
        rs_cnt, mem_view = member.getMemberView(mem_id)
        
    return render(
        request,
        "mysqlapp/member/mem_view.html",
        {"mem_view" : mem_view}
    )
  • mysqlapp > model > member_model.py
import pymysql
from mysqlapp.model.mysql import Mysql_Model

class Member :
    ### 생성자
    def __init__(self) :
        self.db = Mysql_Model()
        
    ### 회원 상세 조회하기
    def getMemberView(self, mem_id) :
        sql = f"""
            Select mem_id, mem_name, mem_add1, mem_add2
            From member   
            Where mem_id = '{mem_id}'  
        """
        
        ### DB에 요청하기 : cursor에 담기
        # 실행 결과의 건수
        rs_cnt = self.db.cur.execute(sql)
        
        # 실행 결과 데이터 
        # - {'컬럼명' : 값, '컬럼명' : 값, ...}
        # 한건 조회 이므로 fetchone
        row = self.db.cur.fetchone()
        
        # DB 정보 반환하기
        self.db.DBClose()
        
        return rs_cnt, row

728x90
반응형
728x90
반응형

Client - Server

client   server(WAS, Web Application Server) DB Server
브라우저
요청 url (http://127.0.0.1:8000/index)

요청(request)
web server

Container(Application)

    config라는 폴더의 djang App(ex. firstapp)
    Apache
넘어 온 주소 확인 후 index를 container로 넘김(즉, index 페이지 요청) →
Tomcat
index라는 이름의 pattern이 들어오면 특정 함수를 실행하라고 정의해 둠
이 함수는 java로 따지면 controller에 있는 함수. 
django로 따지면 views.py에 있는 함수
파싱(parsing)
html을 다시 읽어냄

응답(reponse)
html을 요청한 사람한테 넘김 함수가 실행되면서 html에 담긴 데이터를 web server로 다시 보내줌  

 

 

Django

  • Python 프레임워크 : Django, Flask 
  • 가상환경 새로 생성하여 진행
> conda create -n gj_django python=3.9
> conda activate gj_django
> pip install jupyter notebook
> python -m ipykernel install --user --name gj_django --display-name gj_django_kernel
> pip install ipython jupyter matplotlib pandas xlrd seaborn scikit-learn(python 버전 11이상이면 sklearn)
> pip install openpyxl
> conda install -c conda-forge django==4.0.1

Django 프로젝트 생성하기

  • Django 서버 생성
tutorial 파일로 이동
> django-admin startproject config . (config 한칸 띄우고 점. 찍기 > 현재 폴더에 config 폴더 생성 됨)

서버 테스트(웹은 생성시 마다 서버에 문제 없는지 확인 필요)
> python manage.py runserver

ctrl 누르고 아래 주소 클릭
> http://127.0.0.1:8000/

Django 페이지 등장🚀

Django VScode 설정 사항

  • vscode 실행 방법
    Prompt에서 가상환경 실행 후 totutorial 파일로 이동
(gj_django) C:\Users\user\gj_202311\11_Django\edu_django\tutorial>code .

 

  • config > settings.py 설
1. ALLOWED_HOSTS = [] 에 "127.0.0.1" 입력
결과 > ALLOWED_HOSTS = ["127.0.0.1"]

2. TEMPLATES에서 DIRS': []에 BASE_DIR/"templates" 입력
결과 > 'DIRS': [BASE_DIR/"templates"]

3. 언어 설정
> LANGUAGE_CODE = 'ko-kr'

4. 시간 설정
> TIME_ZONE = 'Asia/Seoul'

5. 파일 위치 설정
STATIC_URL = 'static/' 아래에
> STATICFILES_DIRS = [BASE_DIR/"static"] 추가

6. 나중에 사용할 부분

> INSTALLED_APPS
> DATABASES
 

  Web Site 만들기

  • firstapp 생성
Prompt tutoral 폴더 안에서 
> python manage.py startapp firstapp

영역을 app으로 나눠서 사용함 (ex. loginapp, joinapp)

  • firstapp 실행
INSTALLED_APPS 리스트에 'firstapp' 추가

  Web Site 만들기_함수

  • views.py
    앱의 시작점은 views.py (Spring으로 따지면 Controller에 해당)
from django.shortcuts import render

from django.http import HttpResponse

# Create your views here.
def index(request) :
    return HttpResponse("<u>firstapp의 index 페이지!!</u>")
  • urls.py
from django.contrib import admin
from django.urls import path
from firstapp import views as firstapp_view

urlpatterns = [
    ### http://127.0.0.1:8000/index
    path('index/', firstapp_view.index),

    path('admin/', admin.site.urls),
]

 

  Web Site 만들기_html

  • views.py
from django.shortcuts import render

from django.http import HttpResponse

# Create your views here.
def index(request) :
    return HttpResponse("<u>firstapp의 index 페이지!!</u>")

### http://127.0.0.1:8000/index_html
def indexHtml(request) :
    return render(
        request,
        "firstapp/index.html",
        {} # 어떤값을 줄건지 딕셔너리에 넣기
    )
  • templates\firstapp 파일 생성 후 index.html 작성
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>FirstApp - index.html</title>
  </head>
  <body>
    <h2>FirstApp-index.html</h2>
    <p>firstapp의 index.html 페이지 입니다.</p>
  </body>
</html>
  • urls.py
from django.contrib import admin
from django.urls import path
from firstapp import views as firstapp_view

urlpatterns = [
  
    ### http://127.0.0.1:8000/index
    path('index/', firstapp_view.index),
    
    ### http://127.0.0.1:8000/index_html
    path('index_html/', firstapp_view.indexHtml),

    path('admin/', admin.site.urls),
]

 

 

MainApp 생성

  •  mainapp 생성
Prompt tutoral 폴더 안에서 
> python manage.py startapp mainapp

INSTALLED_APPS 리스트에 'mainapp' 추가
  • view.py
from django.shortcuts import render

# Create your views here.

### http://127.0.0.1:8000/main_index
def index(requset) :
    return render(
        requset,
        "mainapp/index.html",
        {}
    )
  • templates\mainapp 파일 생성 후 index.html 작성
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>FirstApp - index.html</title>
  </head>
  <body>
    <h2>MainApp-index.html</h2>
    <p>mainapp의 index.html 페이지 입니다.</p>
  </body>
</html>
  • urls.py
from django.contrib import admin
from django.urls import path
from firstapp import views as firstapp_view
from mainapp import views as mainapp_view

urlpatterns = [
    ### http://127.0.0.1:8000/main_index
    path('', mainapp_view.index),
    
    ### http://127.0.0.1:8000/main_index
    path('main_index/', mainapp_view.index),
  
    ### http://127.0.0.1:8000/index
    path('index/', firstapp_view.index),
    
    ### http://127.0.0.1:8000/index_html
    path('index_html/', firstapp_view.indexHtml),

    path('admin/', admin.site.urls),
]

  • 설치 라이브러리
더보기

Python 관련

Python

Python Extension Pack

Python Extended

Python Indent

Python Debugger

Python snippetes

 

HTML, CSS, JS 관련

HTML CSS Support

HTML5 extension pack

html5-skelton

Extended Html5 Boilerplate

Html5 Reset Css

CSS Snippets

VS Code JavaScript (ES6) snippets

 

Django 관련

Django

Django Snippets

Django Templates

Django Snippets

 

url을 각 app에서 관리하게 하기 _firstapp

  • config에 있는 urls.py를 firstapp에 복사
  • config에 있는 urls.py
from django.contrib import admin
from django.urls import path, include
# from firstapp import views as firstapp_view
# from mainapp import views as mainapp_view

urlpatterns = [
    ### firstapp의 urls.py 사용하기
    # http://127.0.0.1:8000/first/index
    path("first/", include("firstapp.urls")),
    
    # ### http://127.0.0.1:8000/main_index
    # path('', mainapp_view.index),
    
    # ### http://127.0.0.1:8000/main_index
    # path('main_index/', mainapp_view.index),
  
    # ### http://127.0.0.1:8000/index
    # path('index/', firstapp_view.index),
    
    # ### http://127.0.0.1:8000/index_html
    # path('index_html/', firstapp_view.indexHtml),

    path('admin/', admin.site.urls),
]
  • firstapp에 있는 urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/first/index
    path('index/', views.indexHtml ),
    
    # http://127.0.0.1:8000/first/
    path('', views.indexHtml ),
]

 

url을 각 app에서 관리하게 하기 _mainapp

  • firstapp에 있는 urls.py를 firstapp에 복사
  • config에 있는 urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    ### firstapp의 urls.py 사용하기
    # http://127.0.0.1:8000/first/index
    path("first/", include("firstapp.urls")),
    
    ### mainapp의 urls.py 사용하기
    # http://127.0.0.1:8000/main/index
    path("main/", include("mainapp.urls")),

    path('admin/', admin.site.urls),
]
  • mainapp에 있는 urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/main/index
    path('index/', views.index ),
    
    # http://127.0.0.1:8000/main/
    path('', views.index ),
]

 

  • http://127.0.0.1:8000/ 만 입력 했을 때 main의 index가 뜨게 하는 방법
from django.contrib import admin
from django.urls import path, include
from mainapp import views as mainapp_view

urlpatterns = [
    ### firstapp의 urls.py 사용하기
    # http://127.0.0.1:8000/first/index
    path("first/", include("firstapp.urls")),
    
    ### mainapp의 urls.py 사용하기
    # http://127.0.0.1:8000/main/index
    path("main/", include("mainapp.urls")),
    
    # http://127.0.0.1:8000/
    path("", mainapp_view.index),
    path("index/", mainapp_view.index),
    
    path('admin/', admin.site.urls),
]

 

페이지 이동하기

  • mainapp > index.html (firstapp > index.html도 동일)
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>FirstApp - index.html</title>
  </head>
  <body>
    <h2>MainApp-index.html</h2>
    <p>mainapp의 index.html 페이지 입니다.</p>
    <p>
      <a href="/first/">firstapp/index 바로가기</a>
    </p>
  </body>
</html>

클릭 시 해당 페이지로 이동

 

이미지 삽입하기

  • firstapp > static\firstapp > images 생성
  • firstapp의 index.html
    {% load static %} > static 폴더를 사용하겠다는 의미
{% load static %}
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>FirstApp - index.html</title>
  </head>
  <body>
    <h2>FirstApp-index.html</h2>
    <p>firstapp의 index.html 페이지 입니다.</p>
    <p>
      <a href="/main/">Home 바로가기</a>
    </p>
    <p>
      <img
        src="{% static '/firstapp/images/fashion739.jpg' %}"
        width="300"
        height="300"
      />
    </p>
  </body>
</html>

  • 이미지 안불러와지면 settings.py에 가서 / 앞뒤로 띄어쓰기 한번 씩 하기 
STATICFILES_DIRS = [BASE_DIR / "static"]

 

jupyter 파일 웹에 적용하기_파일 생성해서 불러오기

  • 방법
    1. jupyter 에 있는 파일을 파이썬으로 저장
    2. firstapp에 ml_view 폴더 생성 후 안에 파이썬으로 저장한 파일 넣기
    3. 파이썬 내용 함수로 감싸기
  • firstapp > ml_view > ml_view.py 생성(여기 안에서는 항상 함수로 진행)
  • firstapp > ml_view.py
def getView() :
    ### 이미지 처리 수행 후
    ### 이미지를 static 위치에 저장까지만 하면 됨
    # - return은 안해도 됨. 테스트를 위해
    return "test"
  • firstapp > views.py
from firstapp.ml_view import ml_view

### http://127.0.0.1:8000/first/ml_view
def ml_View(request) :
    ### getView() 함수 호출하기
    rs_data = ml_view.getView()
    
    return render(
        request,
        "firstapp/ml_view/ml_view.html",
        {"rs_data" : rs_data}
    )
  • templates\firstapp > ml_view > ml_view.html 생성
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>FirstApp - index.html</title>
  </head>
  <body>
    <h2>ML-View 페이지</h2>
    <p>받아온 값 rs_data ={{rs_data}}</p>
  </body>
</html>
  • firstapp > urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/first/ml_view/
    path('ml_view/', views.ml_View ),
]

 

jupyter 파일 웹에 적용하기_기존 py 파일(Class) 사용하기

  • data_view.py 파일 사용
    그래프 저장 위치 변경하기

  • firstapp > views.py
from firstapp.data_view.data_view import Data_View

### http://127.0.0.1:8000/first/data_view/
def data_View(request) :
    ### Data_View 클래스 호출하기
    data_view = Data_View()
    
    return render(
        request,
        "firstapp/data_view/data_view.html",
        {}
    )
  • templates\firstapp > data_view > data_view.html 생성
{% load static %}
<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>FirstApp - index.html</title>
  </head>
  <body>
    <h2>Data-View 페이지</h2>
    <p>
      <img
        src="{% static '/firstapp/images/fig.png' %}"
        width="300"
        height="300"
      />
    </p>
  </body>
</html>
  • firstapp > views.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/first/data_view/
    path('data_view/', views.data_View ),
]

model 웹에 적용하기

  • model_view.py 파일 사용
    데이터 읽어들이기 / 훈련모델 저장시키기 / 훈련모델 불러오기 파일 경로 변경하기
  • firstapp > views.py
from firstapp.model_view.ml_view import ML_View

### http://127.0.0.1:8000/first/model_view/
def model_View(request) :
    ### ML_View 클래스 호출하기
    ml_view = ML_View()
    
    ### 정확도
    score = ml_view.getModelScore()
    
    ### 예측하기
    # 사용할 예측 데이터
    # - [[200.0, 23.0, 25.8, 10.34, 3.66]]
    x_input = [[200.0, 23.0, 25.8, 10.34, 3.66]]
    pred_data = ml_view.getModelPredict(x_input)
    
    return render(
        request,
        "firstapp/data_view/data_view.html",
        {"score" : score,
         "pred_data" : pred_data}
    )
  • templates\firstapp > model_view > model_view.html 생성
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <h2>Model-View 페이지</h2>
    <p>정확도 : {{score}}</p>
    <p>예측 : {{pred_data}}</p>
  </body>
</html>
  • firstapp > urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/first/model_view/
    path('model_view/', views.model_View ),
]

지도 웹에 적용하기

  • map_view.py 데이터 사용
    데이터 읽어들이기 파일 경로 변경하기
    folium 라이브러리 설치
  • firstapp > views.py
from firstapp.map_view.map_view import Map_View

### http://127.0.0.1:8000/first/map_view/
def map_View(request) :
    ### Map_View 클래스 호출하기
    map_view = Map_View()
    
    ### 지도 결과를 html로 받아오기
    map_html = map_view.getMapHtml() 
    
    ### 지도 시각화에 사용한 데이터 프레임 받아오기
    
    map_data = map_view.getDataFrame()
    
    return render(
        request,
        "firstapp/map_view/map_view.html",
        {
          "map_html" : map_html,
            "map_data" : map_data.to_html(),
         }
    )
  • templates\firstapp > map_view > map_view.html 생성
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <h2>Map-View 페이지</h2>
    <p>{{map_html | safe}}</p>
    <p>{{map_data | safe}}</p>
  </body>
</html>
  • firstapp > urls.py
from django.urls import path
from . import views

urlpatterns = [
    # http://127.0.0.1:8000/first/map_view/
    path('map_view/', views.map_View ),
]

728x90
반응형
728x90
반응형

컴파일러

    • 정의: 컴파일러는 전체 소스 코드를 컴파일하여 기계어 또는 중간 코드로 변환한다. 이 변환된 코드는 나중에 실행될 수 있다.
    • 동작 방식: 컴파일러는 소스 코드를 읽고 문법적 오류를 검사한 후, 중간 코드 또는 기계어로 변환한다. 이 변환된 코드는 실행 파일 형태로 저장되며, 이후에는 여러 번 실행될 수 있다.
    • 장점: 실행 시간에 빠르게 동작하고, 전체 프로그램을 미리 컴파일하기 때문에 반복적으로 실행할 때 효율적이다.
    • 단점: 컴파일이 필요하므로 초기 개발 단계에서는 추가 시간이 걸리며, 피드백이 느리다.
    • 사용예시: 
      JDK(Java Development Kit) : Java 컴파일러
      Java 환경에서 돌아가는 프로그램을 개발하는 데 필요한 툴들을 모아놓은 소프트웨어 패키지

인터프리터

  • 정의: 인터프리터는 소스 코드를 한 줄씩 읽어들여 즉시 실행한다. 전체 코드를 먼저 변환하지 않고 중간 단계 없이 직접 실행한다.
  • 동작 방식: 소스 코드를 읽고 해석하여 즉시 실행한다. 이는 코드를 미리 컴파일하지 않기 때문에 실행될 때마다 번역 작업이 필요하다.
  • 장점: 빠른 개발과 테스트를 가능하게 하며, 소스 코드 변경 시 바로 실행 결과를 확인할 수 있다.
  • 단점: 실행 시간에 오버헤드가 발생하며, 전체 프로그램의 최적화가 어려울 수 있다.
  • 사용예시:
  • Anaconda : Python 인터프리터
  • Anaconda에 python.exe 포함, 일반적인 시각화 라이브러리 포함.

가상환경을 아나콘다 기반으로 만들기

user/anaconda3/envs 에 가상환경 만들기

* 아나콘다 기준

 

※ 가상환경 만들기 전

1. C:\Users\user\gj_202311 폴더 생성

2. gj_202311에 00_가상환경만들기 폴더,  01_파이썬기초 폴더 생성

3. 00_가상환경만들기 폴더에 01_가상환경_기본생성.txt 생성

 

생성되어 있는 가상환경 확인하기

conda env list

(지금부터 진행하는 폴더 위치는 무관함)

가상환경 생성하기

- 생성 명령어
파이썬 버전 생략하면 가장 최신버전으로 생성 됨

 conda create -n 가상환경이름 python=파이썬버전
> conda create -n gj_env_01 python=3.9

 
- 설치 됐는지 확인


 가상환경 삭제하기

- 삭제 명령어
생성된 파일은 아나콘다 자체에서 관리하는 파일이여서 임의로 삭제하면 안됨
올바른 삭제 방법

conda remove -n gj_env_01 --all

가상환경으로 들어가기(활성화 시키기)

conda activate gj_env_01

 
가상환경으로 들어간 상태


가상환경에서 나오기(비활성화 시키기)

conda deactivate

설치되어 있는 패키지(라이브러리) 확인하기

conda list

pip list

 
conda list에서 python 버전 확인 가능
conda로 설치된 것이기 때문에 pip list에서는 python이 안보임
conda는 가장 최적화 된 것을 설치해줌
pip는 가장 최신 버전을 설치해줌


외부 에디터에서 가상환경을 연결(kernel)하기 위하여
jupyter 설치하기

pip install jupyter notebook

 
pip로 설치한다면? 
pip  y/n안물어보고 무조건 최신버전으로 설치


jupyter notebook 설치확인

 jupyter notebook

 
※ jupyter notebook 실행시 가끔 웹에 안뜨면 뒤에 토큰값 복사해서 넣기

 
서버 중지하고 싶으면? Ctrl + C


커널 생성 목록 확인하기

 jupyter kernelspec list

 
커널 생성하기 (base root 가상환경에서 진행)

 python -m ipykernel install --user --name gj_env_01 --display-name gj_env_01_kernel

 
커널 생성 후 목록 확인


주피터 노트북으로 작성한 파일 파이썬으로 변경하여 저장하기


 
기본 패키지 설치하기 (gj_env_01 가상환경에서 진행)

pip install ipython jupyter matplotlib pandas xlrd seaborn scikit-learn
pip install openpyxl

 
seaborn 데이터 시각
scikit-learn 머신러닝 라이브러리
 
도서 관리 프로그램 만들기 실습
https://mzero.tistory.com/38

 

[Python] 파이썬 도서 관리 프로그램 만들기 실습

주제 : 도서 입고/대출/반납 관리를 위한 키오스크 파이썬 프로그램 실습 1. 주요내용 - 도서 목록 : 새로운 책이 도서관에 [입고]되었을 때 프로그램 작성 - 도서 대출 : 도서 목록에서 임의 책을

mzero.tistory.com

 

728x90
반응형
728x90
반응형

작성한 클래스 코드 설명

# 1.
class Tv():  
    def __init__(self):
        self.__channel = 0
        self.__volume = 0
        self.__on = 'on'
        self._off = 'off'
    # 2.
    def show(self):
        print(self.__channel, self.__volume, self.__on)
    # 3.    
    def set_channel(self, channel):
        # 지문인식 등록 된 사람 지문 인지 검사
        if 2 < channel and 99 > channel:
            self.__channel = channel
    # 4.
    def get_channel(self, on):
        self.__on = on
    # 5.    
    def get_on(self, on):
        return self.__on

# 1 : Tv 클래스는 __init__ 생성자를 가지고 있으며, 이 생성자는 __channel, __volume, __on, _off의 기본값으로 TV 객체를 초기화힌다. __channel, __volume, __on 앞의 "__"은 접근제어자로 해당 속성들이 클래스 외부에서 직접 접근되지 않아야 함을 나타낸다. _off 앞의 한 번의 밑줄은 보호된 속성이지만, 두 번의 밑줄보다는 덜 제한적이라는 관습적인 표기이다.

# 2 : show 메서드는 현재 __channel, __volume, __on의 값을 출력하는 간단한 메서드다. 이 메서드는 TV의 현재 상태를 표시하는 데 사용될 수 있다.

# 3 : set_channel 메서드는 TV의 채널을 설정하는 데 사용된다. 채널이 2에서 99 사이인지 확인한 후에 __channel 속성을 업데이트 한다. (입력 유효성 검사 )

# 4 : get_channer 메서드는 on 값을 받아서 __on 속성에 할당한다.

# 5 : get_on 메서드는 __on 속성의 값을 반환한다. 이 메서드는 일반적인 "get" 메서드로서, 속성 값을 외부에서 가져오는 용도로 사용된다.

 

- 실행 결과

 

 

입출금 클래스 만들기 실습

https://mzero.tistory.com/33

 

[Python] 파이썬 클래스 실습

입출금 클래스 만들기 1. 요구사항 - 은행 계좌 - 잔액(balance) 상태 - 저금(deposit) 행동, 인출(witndraw) 행동 2. 내가 작성해 본 코드 class Bank(): def __init__(self): self.__balance = 0 self.__money = 0 def deposit(self,

mzero.tistory.com

 

MVC

- 사용자 인터페이스, 데이터 및 논리 제어를 구현하는데 널리 사용되는 소프트웨어 디자인 패턴

- Model, View, Controller

- 사용자가 view를 통해 controller를 조작하면 controller는 model을 통해 데이터를 가져오고, 그 정보를 통해 시각적인 담당을 하는 view를 다시 제어해서 사용자에게 전달

- 패턴을 사용하면 사용자 인터페이스로부터 비즈니스 로직을 분리하여 어플리케이션의 시각적인 요소나 그 이면에서 실행되는 비즈니스 로직을 서로 영향 없이 쉽게 고칠 수 있는 어플리케이션을 만들 수 있다.

- Model

     > 어플리케이션의 정보(데이터)를 나타냄

     > 데이터와 비즈니스 로직을 관리

     > 데이터베이스와의 상호작용, 데이터의 유효성 검사 등을 담당

 - controller

     > 모델과 뷰로 명령을 전달

     > 클라이언트의 요청을 받아 뷰와 모델 간의 조합을 구성하고, 어떤 뷰와 어떤 모델을 사용할지 결정.

- view

     > 레이아웃과 화면을 처리

     > 텍스트, 체크박스 등과 같은 사용자 인터페이스 요소를 나타냄

     > 클라이언트의 요청을 처리하고, 모델을 이용하여 데이터를 처리한 후, 클라이언트에게 결과를 전달하는 역할을 수행

 

MVC 패턴으로 고객 정보 관리 프로그램 만들기

https://mzero.tistory.com/35

 

[Python] 고객 정보 관리 프로그램 만들기 실습 4

주제 : 고객 정보 관리 시스템 1. 주요내용 기존의 로직을 MVC 패턴을 이용한 로직으로 변경하기 - Model class CustomerModel: def do_I(self, customers, customer): customers.append(customer) index = len(customers) - 1 return ind

mzero.tistory.com

 

728x90
반응형
728x90
반응형

문자열

- 문자열은 문자들의 시퀀스로 정의된다. 글자들이 실(String)로 묶여 있는 것이 문자열이라고 생각하면 된다.

- 인덱싱 : 문자열도 크게 보면 시퀀스(Sequence)라는 자료 구조에 속한다. 시퀀스는 리스트와 같이 항목들이 순서를 가지고 모인 자료구조이다.

 

원시 문자열

- 문자열의 시작 따옴표 앞에 r을 두면 원시 문자열(raw string)이 된다.

- 앞에 r이 붙어 있는 원시 문자열이기 때문에 파이썬은 백슬래시를 문자열의 일부로 간주한다. 즉, 백슬래시를 이스케이프 문자로 취급하지 않는다.

- 원시 문자열은 r'C:\\User\Kim\Document'와 같은 윈도우 파일 경로를 나타내는 문자열에 필요하다.

 

슬라이싱

- 슬라이싱이란 문자열의 일부를 잘라서 서브 문자열을 만드는 연산

 

문자열 관련 메소드

https://mzero.tistory.com/31

 

[Python] 파이썬 문자열 메소드, 정규식

문자열 메소드 - lower() : 소문자로 변환된 새 문자열을 반환한다. - upper() : 대문자로 변환된 새 문자열을 반환한다. >> lower() 및 upper() 메소드는 대소문자를 구분하지 않고 비교할 때 아주 유용하

mzero.tistory.com

 

파이썬 소스 파일 확인하기

- 사용자가 입력한 문자열이 파이썬 소스 파일 이름인지를 검사하려면 다음과 같이 입력

s = input('파이썬 소스 파일 이름을 입력하시오 : ')
if s.endswith('.py'):
    print('올바른 파일 이름입니다.')
else:
    print('올바른 파일 이름이 아닙니다.')

 

예외처리

- 사용자들은 잘못된 데이터를 입력할 수도 있고, 우리가 오픈하고자하는 파일이 컴퓨터에 존재하지 않을 수도 있으며 인터넷이 다운될 수도 있다.

- 오류가 발생했을때 오류를 사용자에게 알려주고 모든 데이터를 저장하게 한 후에 사용자가 우아하게(gracefully) 프로그램을 종료할 수 있도록 하는 것이 바람직히다.

 

오류의 종류

- 사용자 입력 오류 : 사용자가 정수를 입력하여야 하는데 실수를 입력 할 수 있다.

- 장치오류 : 네트워크가 안 된다거나 하드 디스크 작동이 실패할 수 있다.

- 코드오류 : 잘못된 인덱스를 사용하여서 배열에 접근할 수 있다.

- IOError : 파일을 열 수 없으면 발생한다.

- importError : 파이썬이 모듈을 찾을 수 없으면 발생한다.

- ValueError : 연산이나 내장 함수에서 인수가 적절치 않은 값을 가지고 있으면 발생한다.

- KeyboardInterrupt : 사용자가 인터럽트 키를 누르면 발생한다. (ctrl-c 나 delete)

- EOFError : 내장 함수가 파일의 끝을 만나면 발생한다.

 

예외처리

- Try-catch 구조

-오류를 처리 할 수 있게끔 지원한다.


- 예외처리 형식


- finally : 오류 유무에 상관 없이 무조건 실행


객체 지향 프로그래밍

객체 지향 프로그래밍(OOP: object-oriented programming)은 우리가 사는 실제 세계가 객체(object)들로 구성된 것과 비슷하게, 소프트웨어도 객체로 구성하는 방법이다. 실제 세계에서는 사람, 자동차, 텔레비전, 세탁기, 냉장고 등의 많은 객체가 존재한다. 객체들은 객체 나름 대로 고유한 기능을 수행하면서 다른 객체들과 메세지를 통하여 상호작용 한다.

 

절차 지향과 객체 지향

- 절차 지향 프로그래밍(procedural programming)은 프로시저를 기반으로 하는 프로그래밍 방법이다.

- 객체 지향 프로그래밍(object-oriented programming)은 데이터와 함수를 하나의 덩어리로 묶어서 생각하는 방법이다.

- 절차지향의 문제 : 가장 중요한 단점은, 서로 관련된 데이터와 함수를 묶을 수가 없다는 점이다. 따라서 절차 지향 방법에서는 데이터가 프로그램의 중요한 부분임에도 불구하고 프로그래머들은 함수 작성에만 신경을 쓰게 된다.

 

객체

- 객체(object)는 속성과 동작을 가진다

- 자동차는 메이커나 모델, 색상, 연식, 가격과 같은 속성(attribute)을 가지고 있다. 또 자동차는 주행할 수 있고, 방향을 전환하거나 정지할 수 있다. 이러한 것을 객체의 동작(action)이라고 한다.

- 파이썬에서는 모든 것이 객체이다.

 

클래스

- 객체에 대한 설계도를 클래스(class) 라고 한다. 클래스란 특정한 종류의 객체들을 찍어내는 형틀(template) 또는 청사진(blueprint)이라고도 할 수 있다.

- 클래스로부터 만들어지는 객체를 그 클래스의 인스턴스(instance)라고 한다.

- 형식

class 클래스 이름:
    def __init__(): # 생성자
    def 메소드 이름(...): # 메소드

- 모든 메소드에 사용 유무와 상관 없이 "self" 파라미터가 첫번째로 들어가야 한다.

class Counter:
    counter_a = 0
    def __init__(self): # 생성자
        print("__init__")
        self.count = 0 
    def increment(self): # 메소드
        self.count += 1 
    def print_count(self): # 메소드
        print(self.count)
 

캡슐화💊

- 개발자로서 클래스의 객체를 갖고 작업할 때는 객체가 어떻게 내부적으로 속성을 저장하고 어떻게 메소드들이 구현되는지 알 필요가 없다. 공용 인터페이스만 제공하고 구현 세부사항을 감추는 것을 캡슐화(encapsulation)라고 한다.

- 캡슐화는 데이터와 알고리즘을 하나로 묶는 것이다.

728x90
반응형
728x90
반응형

자료구조

자료들을 저장하는 여러 가지 구조들을 자료구조(Data Structure), 또는 데이터구조라 부른다.

시퀀스

- 요소(element)로 구성
- 요소 간에는 순서가 있다
- 시퀀스의 요소들은 번호가 붙여져 있다.
- 내장 시퀀스 (str, bytes, bytearrary, list, tuple, range)
- 동일한 연산을 지원
     > 인덱싱(indexing),  슬라이싱(slicing), 덧셈연산, 곱셈연산
- 내장함수 적용가능 : 시퀀스의 길이를 반환하는 len()함수, 최대값과 최소값을 찾는 max()와 min()함수
 

튜플 패킹과 언패킹

- 패킹
     t = ('apple', 'banana', 'grape')
- 언패킹
     (s1, s2, s3) = t
- 결과
      s1 = 'apple'     s2 = 'banana'     s3 = 'grape'
 

enumerate함수

- 순서가 있는 자료형(list, set, tuple, dictionary, string)을 입력으로 받았을 때, index와 값을 포함하여 리턴
- for문과 함께 자주 사용
- index와 값을 동시에 접근하면서 루프를 돌리고 싶을 때 사용

["apple", "banana", "grape"] enumerate( ) 사용(1, "apple")
(2, "banana")
(3, "grape")

 
Site Package  위치 확인하기

- Python에서 Site Packages가 설치되어 있는 경로를 출력하는 방법
- Terminal에서 다음 명령을 입력

python -m site --user-site

 
라이브러리

- 다른 사람들이 만들어 둔 함수들의 모음
- 자주 사용하는 기능을 쉽게 재사용할 수 있고 다른 사람과도 공유
- 표준 라이브러리 :  파이썬이 설치 될 때 같이 자동으로 설치 되는 라이브러리
- 외부 라이브러리 : 기본 외에 별도로 설치해서 사용하는 라이브러리
- 외부 라이브러리 설치 : pip install 라이브러리명, conda install 라이브러리명
- 사용법 : import 라이브러리명
- 현재 설치 되어있는 라이브러리 확인 : pip list
- Pandas : 파이썬의 데이터 분석 라이브러리
 
- 표준 라이브러리 날짜/ 시간 함수 정리 
https://mzero.tistory.com/28

[Python] 파이썬 표준 라이브러리 (날짜/시간) - datetime, timedelta, relativedelta

datetime() 현재 시간, 날짜를 가져온다. from datetime import datetime print(datetime.now()) timezone() timezone으로 설정한 기준의 시간과 날짜를 가져온다. from pytz import timezone print(datetime.now(timezone('UTC'))) datetime.no

mzero.tistory.com

 

728x90
반응형

+ Recent posts