국비 교육 99일차 - python class, 상속, 파일 입출력

아직 기본문법을 배우고 있기 때문에 심화된 과정이 나오진 않았다. 바로 시작하겠다. 

 

아침에는 전에 배운 db연결을 다시 복습했다

'''
    DB정리
    1. function
        def 함수명(매개변수...):
            처리
            #결과값이 있는 경우
            return 값
            
    2. class => 자바와 비슷하다
        class 클래스명:
        생성자
        멤버변수
        멤버변수
    DB 연습
    =sqlite
    =oracle
    SELECT
        => 조건
        empno=7788
        => param=(7788,), 프로그램(record), row
        execute("SELECT * FROM emp WHERE empno=?,param)
        param=7788
        execute("SELECT * FROM emp WHERE empno=%d %param)
        execute("SELECT * FROM emp WHERE empno=:empno",{"empno":7788})
        두개 이상
         execute("SELECT * FROM emp WHERE IN('%d', '%d')" %(7788,7794))
         execute("SELECT * FROM emp WHERE ename=:ename, empno=:empno", {"ename":'값', "empno":값})
    INSERT
        emp=(값, 값...)
        <input type=text name=name size=15>
        name=request.TextField('name')
        <textarea name=content>
        content=request.CharacterField('content')
        execute("INSERT INTO emp VALUES(?,?,?,?,?...)" emp)
    UPDATE
        execute("UPDATE table1 SET name=? WHERE id=?", ('홍길동','hong'))
        execute("UPDATE table1 SET name=:name WHERE id=:id", {'name':값,'id':값})
        execute("UPDATE table1 SET name=%s WHERE id=%s", %('값','값'))
    DELETE
         execute("DELETE FROM table WHERE name=:name WHERE id=:id", {'name':값,'id':값})
         execute("DELETE FROM table WHERE name=%s WHERE id=%s", %('값','값'))
'''
import sqlite3

conn=sqlite3.connect("member.db")
cur=conn.cursor()
sql="CREATE TABLE member1(id text, name text, sex text, addr text, tel text)"
#cur.execute(sql)
#print("테이블 생성 완료")
#1. insert
def insert():
    #getConnection
    conn=sqlite3.connect("member.db")
    cur=conn.cursor()
    id=(input("input ID:"))
    name=input("input NAME:")
    sex=input("input sex:")
    addr=input("input addr:")
    tel=input("input tel")
    data=(id,name,sex,addr,tel)
    sql="INSERT INTO member VALUES(?,?,?,?,?)"
    #실행
    cur.execute(sql,data)
    print("데이터 추가 완료")
    #disConnection
    cur.close()
    conn.close()

#데이터 읽기
def selectList():
    conn=sqlite3.connect("member.db")
    cur=conn.cursor()
    sql="SELECT * FROM member"
    cur.execute(sql)
    
    #출력
    for row in cur:
        print(row)
    cur.close()
    conn.close()
# 찾기
def selectOne():
    conn=sqlite3.connect("member.db")
    cur=conn.cursor()
    id=input("ID를 입력:")
    sql="SELECT * FROM member WHERE id=:id"
    cur.close(sql,{"id":id})
    data=cur.fetchone()
    print(data)
    conn.close()
#데이터 추가
#insert()
#selectList()
#selectOne()
def update():
    conn=sqlite3.connect("member.db")
    cur=conn.cursor()
    id=(input("input ID:"))
    name=input("input NAME:")
    sex=input("input sex:")
    addr=input("input addr:")
    tel=input("input tel")
    data=(id,name,sex,addr,tel)
    sql="""
        UPDATE member SET
        name=?, sex=?, addr=?, tel=?
        WHERE id=?
    """
    cur.execute(sql,data)
    conn.commit()
    print("수정 완료!!")
    cur.close()
    conn.close()
#삭제하기
def delete():
    conn=sqlite3.connect("member.db")
    cur=conn.cursor()
    id=(input("input ID:"))
    sql=f"""
        DELETE FROM member
        WHERE id='{id}'
    """
    cur.execute(sql)
    conn.commit()
    cur.close()
    conn.close()    
#수정 함수 호출
#update()
#selectList()

#삭제 함수 호출
delete()
selectList()

data를 입력하고, 불러오고, 수정하고 삭제하는 것까지 전부 함수화 해서 불러보는 연습을 해봤다. id로 검색하는 기능까지 만들었는데, 이정도까지 하면 웹 사이트의 기본 개발은 완성을 한 것이다. 

 

 

파이썬의 객체지향 프로그래밍

'''
    클래스 : 객체지향 프로그램
            면접) OOP
    1) 클래스 구성
        1. 멤버변수 : 상태 (state)
        Back-end, Front-end => 프로그램은 데이터(상태) 관리
        2. 멤버함수(멤버메소드) : 행위(동작) => 요청 => 메세지 (통신할 수 있는 상태)
            면접 함수 VS 메소드
                Function VS Procedure
            예)
                A <==========> B
                     message (주고 받기)
                     사용 => 메소드
        3. 생성자 : 멤버변수를 초기화
    2) 클래스 선언
        = 클래스명 식별
         = 알파벳으로 시작, _, 한글사용 (_는 임시 클래스)
         = 숫자는 사용 가능 (앞에 사용금지)
        class 클래스명
'''
class Member:
    id=''
    name=''
    sex=''
    addr=''
    tel=''
    
#메모리 할당
mem=Member()
mem.id='jeno'
mem.name='이제노'
mem.sex='m'
mem.addr='ilsan'
mem.tel='010-1111-1111'

mem1=Member()
mem1.id='renjun'
mem1.name='런쥔'
mem1.sex='m'
mem1.addr='jirin'
mem1.tel='010-2222-2222'

#print
print(f"ID:{mem.id}")
print(f"NAME:{mem.name}")
print(f"SEX:{mem.sex}")
print(f"ADDR:{mem.addr}")
print(f"TEL:{mem.tel}")
print("===============")
print(f"ID:{mem1.id}")
print(f"NAME:{mem1.name}")
print(f"SEX:{mem1.sex}")
print(f"ADDR:{mem1.addr}")
print(f"TEL:{mem1.tel}")

클래스를 만들어 주고, 안의 멤버변수를 초기화시켜준다. 그리고 메모리 할당을 한 뒤 값을 채워주고 다시 호출해보는 연습을 했다. 이렇게 클래스화 하면, 메모리만 각각 다른 변수에 할당해서 각각 다른 값을 저장할 수 있다. 

 

 

생성자, 소멸자 함수 사용법 

이렇게 class에 생성자와 소멸자 함수까지 전부 만들어주고, 객체 메모리 할당을 할때 값을 넣어주면 값이 정상적으로 채워진다. 

 

'''
    class Member
    {
        public void display(this)
        {
        }
        public void init(this)
        {
        }
        public static void disp()
        {
        }
    }
'''
#멤버메소드
class Sawon:
    #멤버변수 선언
    sabun=1
    name=''
    dept=''
    job=''
    sal=0
    #초기화 (생성자)
    def __init__(self): #default 생성자 (만들지 않을 경우에 자동으로 생성)
        print("생성자 함수 호출!!")
    #소멸자
    def __del__(self):
        print("소멸자 함수 호출!!")
    #기능 설정 : 멤버메소드
    def setSabun(self,sabun):
        self.sabun=sabun
    def getSabun(self):
        return self.sabun
    def sawonPrint(self):
        print(f"사번:{self.sabun}")
        print("이름:"+self.name)
        print("부서:"+self.dept)
        print("직위:"+self.job)
        print(f"급여:{self.sal}")
        
hong=Sawon()
#hong=setSabun(1)
hong.name="홍길동"

Sawon 클래스에 멤버변수를 선언하고 생성자, 소멸자 함수까지 같이 선언한다. 그리고 getter, setter에 해당하는 함수를 선언하고 사원의 목록을 출력하는 print 함수까지 작성해준다. 

 

이렇게 쓰면 Sawon 클래스를 통해 저장된 변수 값을 사용할 수 있다. 

 

 

 

전역변수, 멤버변수, 지역변수 확인

클래스 안에서 선언된건 멤버변수이고 사용을 위해서는 반드시 self 지시어를 써줘야 한다. (java의 this와 같다)

 

 

상속

'''
  객체 지향 프로그램 
  = is-a : 상속
  = has-a : 포함 
'''
from _overlapped import NULL
'''
  class Emp
  {
     private Dept dvo=new Dept();
  }
  class Dept
  {
  }
'''
# has-a : Join 
class Dept:
    deptno=0
    dname=''
    loc=''
    def setDeptno(self,deptno):
        self.deptno=deptno
    def getDeptno(self):
        return self.deptno
    def setDname(self,dname):
        self.dname=dname
    def getDname(self):
        return self.dname
    def setLoc(self,loc):
        self.loc=loc
    def getLoc(self):
        return self.loc
    def showDept(self,deptno,dname,loc):
        self.setDeptno(deptno)
        self.setDname(dname)
        self.setLoc(loc)
    
class Emp:
    empno=0
    ename=''
    handler=NULL
    def __init__(self,empno,ename):
        self.empno=empno
        self.ename=ename
        self.handler=Dept()
        self.handler.showDept(10, '개발부', '서울')
    def show(self):
        print(f"사원번호:{self.empno}") # + (숫자+숫자) (문자열+문자열) , (숫자+문자열)(X)
        print("사원이름:"+self.ename)
        print(f"부서번호:{self.handler.getDeptno()}")
        print("부서명:"+self.handler.getDname())
        print("근무지:"+self.handler.getLoc())
        
emp=Emp(7788,'홍길동')
emp.show()   

handler를 통해서 상속을 받아 사용하고 있다. 

 

 

파이썬 예외처리

'''
    예외처리 : 에러를 방지하는 프로그램
    ====== 강제종료를 방지하고 정상 종료를 할 수 있게 만드는 프로그램
    형식)
        try:
            정상수행 문장이 들어간다
        except: ====> 여러개를 사용할 수 있다 (수정이 가능한 에러만 처리)
            에러가 발생기에 처리
        finally:
            try, except와 관련없이 무조건 수행되는 문장 (서버 종료, 데이터베이스 종료)
            
        1. python에서 제공하는 예외처리 클래스
            BaseException (Throwable)
                |
            -----------------------------------------
            |        |                            |
        SystemExit  KeyboardInterrupt           Exception(수정가능) 
        =============================            |
            Error(수정이 불가능)                    ArithemticError
                                                    = FloatingPointError
                                                    = OverflowError            
                                                    = ZeroDivisionError
'''        
'''                                               
def div(a,b):
    return a/b

try:
    c=div(5,2)
    print(c)
    d=div(5, 0) #오류가 발생하면 except를 찾는다 / 밑에 있는 문장을 수행하지 않는다
    print(d)
except ZeroDivisionError:
    print("can't divided by 0")
finally:
    print("normally finished")
'''

def div(a,b):
    return a/b
try:
    c=div(10,3)
    print(c)
    d=div(10,0)
    print(d) #출력이 안된다
    
    e=[2,3]
    print(e[0])
    print(e[1])
    print(2[3])
    
    f=open('c:/pythonDev/upload.txt') #Exception
#except ZeroDivisionError:
    #print("can't divided by 0")
#except IndexError as e:
    #print("에러메세지:",e) #ex.getMessage()
except Exception as e:
    print('에러메세지:',e)
finally:
    print("여기는 무조건 수행 문장")
print("작업 완료")

 자바에서는 try~catch절 이었는데 파이썬에서는 try~except로 사용한다. 

 

 

파일 입출력

'''
    파일 입출력(업로드, 다운로드)
    파이썬 특화언어 (데이터 수집) => 데이터베이스에 첨부하는 것은 아님
    Jsoup : 이미 데이터베이스에 존재하는 내용
    => 채팅문자열, 트위터 .... => 분석, 통계 (통계낸 데이터를 DB에 설정)
    파일 입출력
    형식)
        1. 파일 열기
        2. 조작 (읽기, 쓰기, 첨부)
                모드 : r(읽기모드), w(쓰기모드), a(추가모드)
        3. 파일 닫기
            f.close()
'''
#쓰기
#readline
def writedata():
    try:
        f=open('c:/pythonDev/student.txt','a')  #w => create모드 (파일을 생성하고 내용을 저장)
        for i in range(1, 11):
            data="이제노 %d\n" %i
            f.write(data)
        f.close()
        print("success")
    except Exception as e:
        print("파일 에러:",e)
        
def readdata():
    try:
        f=open('c:/pythonDev/student.txt','r') #r => 읽기 => create(X) : 파일이 존재해야 된다 
        while True: #0이 아닌 모든 수는 True (0,0.0=>False)
        #값을 읽어오기
            line=f.readline()
            if not line:
                break
            print(line,end='')
        f.close()
    except Exception as e:
        print("파일 에러:",e)       

#readlines
def readdatas():
    try:
        f=open('c:/pythonDev/student.txt','r')
        lines=f.readlines() #전체를 읽어온다 => [] list형식으로 읽는다
        '''
            데이터가 여러개를 가지고 올때
            = 데이터베이스 => () : 튜플
            = 파일 (일반파일) => [] : 리스트
            = 파일(JSON) => {"key":"값"} : 딕트
        '''
        for line in lines:
            print(line,end='')
        f.close()
    except Exception as e:
        print('에러:',e)

def readdata2():
    try:
        f=open('c:/pythonDev/student.txt','r')
        data=f.read()
        print(data)
        f.close()
    except Exception as e:
        print('에러:',e)

#with => 자동으로 파일을 닫아준다         
def readWithdata():
    try:
        with open('c:/pythonDev/student.txt','r') as f:
            line=f.readlines()
            print(line)
        #f.close()
    except Exception as e:
        print('에러:',e)
#함수 호출
#writedata()
#readdata()
#readdatas()
#readdata2()
readWithdata()

 파일을 읽어오고, 수정하고 만드는 모드 전부 가능하다. data로 하나씩 읽어오는 방법, line으로 한줄씩 읽어오는 방법, list형식으로 전체를 읽어오는 방법이 존재한다. 

 

with를 사용하면 자동으로 파일을 닫아줘서 사용하기가 편리하다

class StudentVO:
    name=''
    kor=0
    eng=0
    math=0
    
class StudentManager:
    #f=None
    
    def fileWrite(self,vo):
        try:
            with open('c:/pythonDev/student.txt','a') as f:
                data="{},{},{},{},{},{}\n".format(vo.name,vo.kor,vo.eng,vo.math,(vo.kor+vo.eng+vo.math),(vo.kor+vo.eng+vo.math)/3.0)
                f.write(data)
        except Exception as e:
            print("입력 에러:",e)

sm=StudentManager()
vo=StudentVO()
vo.name=input('이름 입력:')
vo.kor=int(input('국어 입력:'))
vo.eng=int(input('영어 입력:'))
vo.math=int(input('수학 입력:'))
sm.fileWrite(vo)

 VO클래스를 작성하고, 값을 입력을 받아 그 내용을 텍스트파일에 쓰는 코드를 완성했다. 

 

텍스트 파일에 위와 같이 내용이 추가가 되어 들어오게 된다.