IT공부

파이썬 프로그래밍 핵심! 클래스

• • class 가 필요한 이유?
    1. 어떠한 기능 사용(함수) + 값 저장(전역 변수) 를 하기 위해서!
    2. class 로 기능을 여러번 사용할 수 있다(인스턴스 생성으로!)
  • 클래스 개념 잡기
    • Ex) 클래스 [쿠키틀] - 인스턴스 [쿠키]
    • 클래스는 인스턴스를 만들기 위한 설계도 이다
      • 객체 - 클래스 (용어정리) ex) navi = cat()
        1. navi 는 객체
        2. navi는 cat의 인스턴스 이다
      • 즉 인스턴스는 관계위주 설명일 때 사용
  • 클래스 기초
    • self 맴버변수
      • this와 유사하며 해당 클래스에서 생성된 인스턴스를 지칭!
      • 클래스 내부 함수 선언시 첫 매개변수는 self!클래스

Ex) self

class Service:
         def setname(self, name): 
               self.name = name
                 print(name)

>>>pey.Service()
>>>pey.setname('ABC') // pey의 pey.name 은 'ABC' 이다
ABC 

• 
  
  • 
    
    • __init__ 함수
      • instance를 만들 때 상상 실행된다 ( 생성자와 비슷함 )

Ex) __init__

class Service:

    def __init__(self, name):

        self.name = name

        print name

>>>pey = Service("ABC") // 아까 예시의 setname이 같이 실행된것 처럼 보임

ABC

• 
  
  • 클래스 자세히 알기
    • 클래스의 구조

class [클래스명] [(상속 클래스 명)]:

    <클래스 변수1>

    <클래스 변수2>

    def [클래스 함수1] (self, [인수 ~ ])

        <문장1>

         ~ 형태

• 클래스의 상속
  • 상속이란 ? 다른 클래스의 기능을 물려받는 것
  • [ class 상속받을 클래스명 (상속할 class명) ]

ex)

class A:

    def sum(self, a, b)

        print(a+b)

class B(A):

>>> x = B()

>>> x.sum(2, 5)

7

• 메서드 오버라이딩
  • 상속받는 class에서 상속할 class와 같은 이름의 메서드를 만들어 재 정의하는 것
  • 이때 재정의한 기능으로 사용된다

ex)

class A:

    def cal(self, a, b)

        print(a+b)

class B(A):

    def cal(self, a, b) // 메서드 오버라이딩

        print(a-b)

>>> x = B()

>>> x.cal(5, 2)

3

• 연산자 오버로딩
  • 연산자(+, -, /, *등) 을 객체끼리 사용할 수 있게 함

ex)

class HousePark:

    last name = '박'

    def __init__ (self, name):

        self.fullname = self.lastname + name

    def __add__ (self, other):

        print(%s 과 %s %(self.fullname, other.fullname) 

>>> A = HousePark("땡땡")

>>> B = HousePark("아무개")

>>> A+B // A=self, B=other

박땡땡 과 아무개 

2. 모듈

    = 함수나 변수, 클래스들을 모아놓은 파일, 

    = 다른 파이썬 프로그램에서 불러와 사용할 수 있게 만듬

-1 모듈 만들고 불러오기

만들기 (mod1모듈)

#mod1.py

def sum(a, b):

    return a+b

불러오기(동일 dir 에서)

>>>import mod1 // 불러온 상태

>>>print(mod1.sum(5, 6)) // 불러와서 기능 사용

11

>>>from mod1 import sum // sum 함수 바로 사용하게 불러오기

>>> print(sum(5, 6)

11

-2 if__name__ == "__main__": 의 의미

mod1.py 에 if__name__ == "__main__": print(sum(1, 2)) 추가

--- mod1.py 실행시

3 출력 -> 메인이기 때문에 if문 참

--- 다른 곳에서 mod1모듈 호출시

출력 X

메인이 아니기 때문에 if문이 거짓 (아래내용 실행 X)

3. 패키지

    = 도트(.)를 이용하여 파이썬 모듈을 계층적(dir구조) 로 관리함

    = 공통 작업에서 유리, 유지보수 유리, 모듈 이름이 같아도 경로가 달라 사용 가능!

Ex) game 패키지

-> game, sound, graphic, play는 디렉터리, game이 루트 dir, 나머지 sub dir

- 사용법

>>> import game.sound.echo

>>> game.sound.echo.echo_test()

echo

>> from game.sound import echo

>> echo.echo_test()

echo

-> import만 사용하면 경로를 전체 적어서 모듈 안에 함수 사용

-> from a import b 로 하면 경로를 a까지는 생략 가능, a부터는 적어야 함

-> from 이 없을 때 import의 마지막 항목은 반드시 모듈이나 패키지 여야 한다!

- __init__.py의 용도

    = 해당 dir이 패키지의 일부임을 알려주는 역활

ex) sound/ 에 __init__.py가 없으면 

      game/

grapic/ play/

-----------------------> 사실 python3.3부터는 없어도 인식한다,,, 하지만 하위버전 호환을 위해 사용하자!

- __all__의 용도(__init__.py파일 안에 변수)

    = 특정 dir* 로 모듈을 사용할 때 __all__로 설정된 모듈은 모듈.함수 로 사용할 수 있다

ex)(sound에는 echo.py, wav.py가 존재)

#__init__.py

__all__ = ['echo']

>>> from game.sound import *

>>> echo.echo_test()

echo

>>> wav.wav_test()

오류 발생! // __all__ 변수에 선언 안되있기 때문

- relative 패키지

ex) graphic의 render.py에서 echo.py를 사용하려면

이때 sound의 부모 dir, graphic의 부모 dir은 game으로 동일하다 (깊이depth 가 같다)

..의 뜻은 자신의 부모 dir경로를 나타내므로

graphic에서의 .. = game = sound에서의 .. 이다
따라서 from game.sound.echo import echo_test = from ..sound.echo import echo_test

-> 이때 .. 은 모듈 내에서만 사용 가능한 경로이다

4. 예외처리

    = 프로그램 작성중 발생하는 오류를 예외적으로 처리할 수 있다

 - 오류 발생 상황

    1. 디렉터리에 없는 파일을 열려고 할 때 : FileNotFoundError

    >>> f = open('없는파일', r)

    2. 0으로 다른 숫자를 나눌 때 : ZeroDivisionError

    >>> 4/0

    3. 리스트 인덱스 오류 : IndexError

 - 오류 예외처리 기법

    1. try except 문

실행문1 실행중 오류가 발생하면 실행문2 실행

    2. try else 문

예외가 발생하지 않은 경우 실행, 반드시 except 절 바로 다음에 위치해야 함

오류발생 = 2 실행, 정상 실행 = 1, 3 실행

try:
    <실행문1>
except [발생오류[as 오류메시지 변수]]:
    <실행문2>

esle:

    <실행문3>

    3. try finally 문

예외가 발생하던 말던 수행해야 하는 것(대부분 리소스.close() 인 경우에 많이 쓰임)

 - 오류 회피하기

파일이 없는 경우 pass로 실행 안하고 지나감

try:

    f = open('없는파일', r)

except FileNotFoundError:

    pass

    - 오류 일부러 발생시키기

raise 내장오류 로 발생시킴

5. 내장함수

6. 외장함수

  = 파이썬 라이브러리 사용

- sys = sys 모듈은 파이썬 인터프리터가 제공한 변수 함수를 직접 제어할 수 있게 해줌

- pickle = 객체의 형태를 유지하면서 파일에 저장

- OS = 환경변수 dir, file등 os자원 제어 가능하게함

- shutil = 파일 복사 모듈

- glob = dir의 파일이름 읽기

- tempfile = 임시 파일 생성후 사용

- time = 시간관련

- calendar = 달력을 보여줌

- random = 난수 생성

- webbrowser = 기본 웹프라우저 자동 실행됨

=========================================================================

연습문제

#calculator.py
class Calculator :
    def __init__ (self, list) :
        self.list = list

    def sum(self) :
        tmp = 0
        for x in self.list :
           tmp += x
        return tmp

    def avg(self) :
        tmp = 0
        for x in self.list :
           tmp += x
        return tmp/len(self.list)

if __name__ == '__main__' :
    cal1 = Calculator([1, 2, 3, 4, 5])
    cal2 = Calculator([6, 7, 8, 9, 10])

    print(cal1.sum())
    print(cal1.avg())
    print(cal2.sum())
    print(cal2.avg())

프로그램의 구조를 쌓는다! 제어문

• IF문 
  • 조건을 판단하여 해당 조건에 맞는 상황을 수행하는데 쓰이는 것
  • if문의 기본구조
    • 들여쓰기는 언제나 같은 깊이로 해야한다! (Tap, SPACEBAR 둘다 사용 가능하다.)

• • 조건문이란?
    • 조건문 : 참, 거짓을 판단하는 문장
    • 비교 연산자 : <, >, ==, !=, >=, <= (비교연산의 값은 True, False 이다!)
    • 논리 접속사 : or, and, not, X in S(S안에 X가 있는가?), X not in S
  • + 수행문 중 아무것도 안하려면 pass 선언!, 한 줄로 작성 가능 ex) if 'a' in pocket : pass
• while 문
  • while문의 기본 구조

• • while 문 강제 탈출 = break
  • while 문의 맨 처음으로 돌아가기 = continue
  • 무한 루프(조건의 문제로 반복문이 끝나지 않는 상황) -> Ctrl + c 로 종료
• for 문
  • for문의 기본 구조

• • for 문에서도 contunue가 사용된다
  • for와 함께 쓰이는 range 함수
    • range() = 숫자 리스트를 자동으로 만들어 주는 함수
    • [range(first = 0, last)] - Ex) range(10) = 0~9, range(1,11) = 1~10
  • 리스트 안에 for문 포함시키기 (리스트 내포)
    • a 라는 리스트의 각 항목을 3을 곱한 결과를 result에 담는 예제 이때 짝수만 3을 곱하여 담음

프로그램의 입력과 출력

• 함수
  • 함수를 사용하는 이유 ?
    
    • 반복적으로 사용되는 '가치있는 부분'을 묶어서 사용
    • 어떤 입력값을 주었을 때, 어떤 결과값을 반환한다
    • 흐름을 읽기 편하다
  • 파이썬의 함수 구조

• • 입력값, 결과값에 따른 함수 형태
    1. 일반적 함수 (입력인수 O, 결과값 O) - 결과값 받을 인수 = 함수명(입력인수)
    2. 입력값이 없는 함수 (입력인수 X, 결과값 O) - 결과값 받을 인수 = 함수명()
    3. 결과값이 없는 함수 (입력인수 O, 결과값 X) - 함수명(입력인수)
    4. 입력값, 결과값이 없는 함수 (입력인수 X, 결과값 X) - 함수명()
  • 입력값이 몇개인지 모를 경우
    • 여러개의 입력 값을 받는 함수 - def 함수명 (*입력변수) :
      • 이때 입력변수는 값을 모아서 튜플의 형태로 사용된다
  • 함수의 결과값은 언제나 하나이다!
    1. return 문에 2가지가 있을 경우 - return a + b, a - b = 튜플로 반환(7, 1)
    2. return 문이 2개일 경우 - return문을 만나면 함수를 종료하므로 하나만 사용된다
  • 입력 인수에 초깃값 미리 설정
    • def my (name, old, man = True) :
    • 이때 my('abc', '3') 하면 man은 자동 True 상태가 된다, 별도로 지정도 가능 my("def", '4', False)
    • 초깃값 설정 시 주의사항
      • 초깃값은 뒤쪽(오른쪽) 부터 선언해야 한다, 사이나 앞쪽(왼쪽)에 쓰일 수 없다
  • 함수 안에서 선언된 변수의 효력 범위
    • 함수(들여쓰기) 안에서 사용된 지역변수는 그 안에서만 쓰이고, 끝나면 사라진다
    • 그 값 유지하는 방법
      1. return 문으로 반환한다
      2. global 명령어 사용 (global a) -> 외부에 종속적인 함수는 좋은 함수가 아니므로 사용 자제!

• 사용자 입력과 출력
  • 프로그램 작동 [사용자 입력] -> 처리(Program, 함수) -> [출력]
  • 사용자 입력
    • input() 함수 사용, 입력된 모든것을 문자열로 취급함
    • 이때 input() 안에 입력받는 질문을 작성하면 프롬프트로 띄울 수 있다 - input("질문 내용?")
      • ex) >>> number = inpub("숫자를 입력하세요 : ") / 숫자를 입력하세요 : (입력창)
  • print 자세히 알기
    • (큰)따옴표로 둘러싸인 문자열은 + 연산과 동일하다 - print("hello" "world") = print("hello" + "world") / helloworld
    • 문자열 띄어쓰기는 콤마로 사용한다 - >>>print("hello", "world) / hello world
    • 결과값을 한 줄에 출력하기 - for i in range(10) : print(i, end=' ') / 0 1 2 ~ 9 : 기본은 출력후 개행이지만 출력후 값을 end=으로 변경시킬 수 있다 / print(i, end=", ") / 0, 1, 2, ~ 9,
• 파일 입출력
  • 파일 생성하기 [파일 객체 = open("이름.txt", "열기 모드")], [파일객체.close()]
    • 열기 모드
      1. r = 읽기모드
      2. x = 쓰기모드(이미 존재하는 파일일 경우 삭제후 새로 쓰기)
      3. a = 추가모드(존재하는 파일의 마지막에 새로운 내용 추가)
  • 파일 쓰기모드로 출력값 적기
    • f = open("파일.txt", "w")
    • f.write(data) # data를 파일객체 f에 써라 // print() : 모니터에 출력, .write() 파일에 출력
  • 프로그램 외부에 저장된 파일 읽는 여러가지 방법
    1. readline() 함수 사용
       • str = f.readline() -> 파일의 첫 줄만 출력/ 모든 파일을 출력시키려면 if문으로 비교(빈 출력 = False)
    2. readlines() 함수 사용
       • 모든 파일을 읽어서 각각의 줄을 요소로 하눈 리스트 리턴 ["첫 줄~", "두번째 줄~" ~~, "마지막 줄"]
    3. read() 함수 사용
       • 파일 내용 전체를 문자열로 만들어 반환
  • 파일에 새로운 내용 추가시키기
    • f = open("파일.txt", 'a')
    • f.write(data) / 기존 파일의 뒤에 출력이 추가됨
  • with문과 함께 사용하기
    • with문으로 사용하면 블록을 벗어나는 순간 자동 .close를 해준다

기존

f.open("파일", "w")

f.write("~")

f.close()

with문 사용

with open("파일", "w") as f :

    f.write("~")

#이때 자동 f.close

파이썬 프로그래밍의 기초, 자료형

• 리스트 
  • 리스트 자료형(list)
    • 리스트 = 집합(배열과 유사)
    • 리스트는 어떤 자료형도, 리스트 자체도 요소값으로 가질 수 있다.
      • ex) a = [], a = [1, 2], a = ['hello', world'], a[1, 'hello'], a [ 1, 2, ['hello', 'world']
  • 리스트 인덱싱, 슬라이싱
    • 리스트 인덱싱
      • a = [1, 2, ['a', 'b']] / a[0] = 1, a[2][1] = 'b'
    • 리스트 슬라이싱
      • a = [1, 2, 3, ['a', 'b', 'c'], 4, 5] / a[2:5] = [3, ['a', 'b', 'c'], 4], a[3][:2] = ['a', 'b']
  • 리스트 연산자
    1. 리스트 더하기 +
       • a = [1, 2, 3], b = [4, 5, 6] / a + b = [1, 2, 3, 4, 5, 6]
    2. 리스트 반복하기 *
       • a = [1, 2] / a * 2 = [1, 2, 1, 2]
  • 리스트의 수정, 변경과 삭제
    • 리스트 수정
      1. 하나의 값 수정하기 : a = [1, 2, 3] / a[2] = 4 / [1, 2, 4]
      2. 연속된 범위의 값 수정하기 : a = [1, 2, 3, 4] / a[1 : 3] = ['a', 'b'], / [1, 'a', 'b', 4]
    • 리스트 요소 삭제하기
      1. [] 사용 : a = [1, 2, 3, 4] / a[1 : 3] = [] / [1, 4]
      2. del 함수 사용 : a = [1, 2, 3, 4] / del a[1] / [1, 3, 4]
  • 리스트 관련 함수들
    1. 리스트에 요소 추가 append() : a = [1, 2, 3] / a.append(4) / a = [1, 2, 3, 4] (마지막 요소에 추가)
    2. 리스트 정렬 sort() : a = [1, 3, 4, 2] / a.sort() / a = [1, 2, 3, 4]
    3. 리스트 뒤집기 reverse() : a = [1, 3, 4, 2] / a.reverse() / a = [2, 4, 3, 1]
    4. 위치 반환 index() : a = [1, 2, 3] / a.index(3) = 2 (= a[2] 따라서 .index(0) 사용 불가)
    5. 요소 삽입 insert() : a = [1, 2, 3] / a.insert(0, 4) / a = [4, 1, 2, 3]
    6. 요소 제거 remove() : a = [1, 2, 3, 1, 2 ,3] / a.remove(3) / a = [1, 2, 1, 2, 3] (맨 앞 3값만 제거)
    7. 리스트 요소 꺼내기 pop() : a = [1, 2, 3] / a.pop() / a = [1, 2]
    8. 리스트에 특정 요소 개수 세기 count() : a = [1, 2, 3, 1] / a.count(1) = 2
    9. 리스트 확장 extend() : a = [1, 2, 3], b = [6, 7] / a.extend([4, 5] / a = [1, 2, 3, 4, 5] / a.extend(b) / a = [1, 2, 3, 4, 5, 6, 7] // a.extend([4, 5]) == a+=[4, 5]
•  튜플
  • 튜플 자료형(tuple) : 리스트와 거의 유사하지만, ( ) 로 구분, 튜플의 요소 값은 변경 불가능
    • t1 = () / t2 = (1, ) / t3 = (1, 2, 3) / t4 = 1, 2 ,3 / t5 = ('a', 'b', ('c', 'd')) = 1개 요소도 , 붙임/괄호 생략 가능
  • 튜플의 인덱싱, 슬라이싱
    • 모두 리스트와 동일하게 연산 가능!!! but 값 변경 불가능!!
• 딕셔너리
  • 딕셔너리 자료형(dictonarly) : 대응 관계를 나타내는 자료형(=연관배열, 해쉬), key-value 가 쌍으로 존재한다, key로만 value를 얻는다 이때 딕셔너리는 순서가 없다!, 중복은 가능하긴하다
    • Ex) {key1:value1, key2:value2, ~~~ keyN:valueN}
  • 딕셔너리 쌍 추가, 삭제
    1. 추가 : a[2] = 'b' // 딕셔너리는 순서가 없으므로 2는 key, 'b'는 value를 뜻한다
    2. 삭제 : del a[2] // key가 2인 dic 삭제
  • 딕셔너리 사용법
    1. key값을 사용한 value에 접근
       • grade = {'pey':10, 'julliet':30} / grade['pey'] = 10
    2. 딕셔너리 생성시 주의사항
       • key값은 중복 허용되나 여러개중 1개만 인식(랜덤으로...) 웬만하면 중복없이 쓰자!
       • key값으로 list, dictionaly, set 사용 불가, tuple은 가능(key값이 바뀌면 안되기 때문)
  • 딕셔너리 관련 함수
    1. key 리스트 만들기 .keys() / a.keys() / dict_keys([~]) <- 리스트와 유사하지만 함수 사용 불가능!, list(dict_keys())로 함수 사용하기
    2. value 리스트 만들기 values() / a.values() / 앞과 동일
    3. key, value 쌍 얻기 .items() / a.items() / dict_items([(1,'a'),(2,'b')]) -> key,value를 튜플로 묶은 dict_items 앞과 동일
    4. key:value 쌍 모두 지우기 .clear() / a.clear() / a = {}
    5. key로 value 얻기 .get() / a.get('1') = a / a[1]은 1이 존재하지 않으면 오류 발생, get()은 None 리턴
    6. 해당 key 유무 조사 .in() / 'name' in a / True,False 반환
• 집합 
  • 집합 자료형(set) : 중복 X, 순서 X인 자료형
    • s1 = set([1, 2, 3]) / s1 -> {1, 3, 2}, s2 = set('Hello") / s2 -> {"o", "l", "H", "e"}
  • 집합 자료형의 활용 ( S1 = set([1,2,3,4,5,6]), S2 = set([4,5,6,7,8,9]) )
    1. 교집합 &, intersection() / S1 & S2, S1.intersection(S2) = {4, 5, 6}
    2. 합집합 :, union() / S1:S2, S1.union(S2) = {1,2,3,4,5,6,7,8,9}
    3. 차집합 -, difference / S1-S2, S1.difference(S2) = {1,2,3}
  • 집합 자료형 관련 함수들
    1. 값 1개 추가하기 .add() / s1.add(4)
    2. 값 여러개 추가하기 .update() / s1.update([4, 5, 6])
    3. 특정 값 제거 .remove() / s1.remove(2)

• 자료형의 참,거짓
  • 비어있으면 거짓, 채워져 있으면 참! 0,None이 이닌 숫자는 참
    • Ex) "hi" 참, (1, ) 참, 3 참 / "" 거짓, { } 거짓, 0 거짓, None 거짓
• 자료형의 값 저장공간 변수
  • 변수 : 객체를 가리키는 것, 객체 : 파이썬의 모든것!!, 파이썬은 별도로 자료형을 쓸 필요가 없다
    
    • ex) a = 3 / a->[3], b = a / a->[3]<-b
    • 튜플, 리스트 등도 변수가 될 수 있다 / [1, 2] = 3
    • a = b = 'python' 가능
    • a, b = b, a (= swap(a, b))
  • 참조
    • 변수는 객체를 가리킨다, 가리키는 것을 참조(reference)라 한다
    • 파이썬에서는 '3'은 상수가 아닌 정수형 객체이고, a = 3, b = 3 일때 둘다 같은 값을 가리킨다
    • 참조 개수 return 함수 / import sys, sys.getrefcount(3) / 3에 대한 참조 개수를 알려줌
  • 메모리에 생성된 변수 없애기
    • del(a) / python이 자동으로 없애주기 때문에 꼭 할 필요는 없다
  • 리스트를 변수에 넣고 복사할 때
    • a = [1,2,3] , b = a, a[1] = 4 / a[1,4,3] , b[1,4,3]
      • b = a 하는 순간 a->[1,2,3]<-b 상태가 된다, 따라서 [1,2,3] => [1,4,3] 이 되어도 b는 게속 참조하고 있다 (=pointer, call by reference와 같은 형태)
    • 이를 해결하기 위한 방법(call by value와 같은 형태로 만들기, 새 리스트를 만들어 참조시킴)
      1. [:] 이용, b = a[:]
      2. copy모듈 이용, b = copy(a)

cf) 파이썬의 기본은 call_by_reference, call_by_value 둘다 아닌 call_by_assignment 라고 한다. 파이썬의 객체는 크게 두가지로 나뉘는데 1.가변객체(mutable), 2.불변객체(immutable)이다 불변 타입의 객체 = call by value 가변 타입의 객체 = call by reference 즉 할당 되는 것에 따라 전달 방식이 달라지는 것이다.

파이썬 프로그래밍의 기초, 자료형

• 자료형
  1. 숫자형
     • 정수형 : a = 12 등
     • 실수형 : a = 1.2 ,a = 4.24E10(=4.24*10^10), a = 4.24e-8(=4.24*10^-8)
     • 8진수, 16진수 : 8진수 : a = 0o12, 0O12 / 16진수 : a = 0x8A
     • 복소수 : a = 1 + 2j, 1 + 2J (1 + 2i)
       • 숫자형 활용 연산자
         • 사칙연산 연산자 : +, -, *, / (/는 실수 자리까지 계산함)ㅇ
         • 제곱 연산자 : ** (X**Y = X^Y)
         • 소수점 아래는 버리는 나눗셈 연산자 // ex) 7/4 = 1.75, 7//4 = 1
  2. 문자열 자료형
     • 문자열 만드는 법
       1. 한줄 문자열 : ' 문자열 ' , " 문자열 " (' 와 " 를 문자열에 포함시키기 위해 2가지 \', \"로 쓸 수도 있음)
       2. 여러 줄 문자열 : '''문자열''', """문자열""" (개행문자와 같은 의미로 사용됨)
     • 문자열 연산
       1. +연산 : a = 'Hello', b = 'world', a+b = 'Helloworld'
       2. *연산 : a * 2 = 'HelloHello' 
          • ex) print('='*20) -> ============================
     • 문자열 인덱싱(가리키기) 와 슬라이싱(잘라내기)
       • 인덱싱 : a = 'Hi python' ( a[3] = 'p', a[-2] = 'o' ) 

• 
  
  1. 
     
     • 
       
       • 슬라이싱 : b = [0:6] (= a[0] + a[1] + a[2] + a[3] + a[4] + a[5]) 0 <= a < 6 / 생략 시 끝까지
         • ex) b = a[7:] = 7부터 끝까지, b = a[:6] = 0부터 5까지
     • 문자열 포메팅(서식문자)
       1. 숫자 대입 : "I eat %d apples. " %3
       2. 문자열 대입 : "I eat %s apples. " % "five"
       3. 변수로 대입 : number = 3 / "I eat %d apples. " %number
       4. 2개 이상 값 넣기 : " %d %s " %(number, "apples")
          • cf) 포매팅 연산자와 사용할 때 %를 같이 쓰려면 %%로 쓴다
     • 포맷 코드와 숫자 함께 사용하기
       1. 정렬과 공백
          • "%10s" %"hi" =>"        hi" (10개 자리에서 오른쪽 정렬)
          • "%-8s" %hi" => "hi      "(8개 자리에서 왼쪽 정렬)
       2. 소수점 표현
          • "%0.4f" %3.141592 => "3.1415" (소수점 4번째 자리)
          • "%-10.5f" %3.141592 => "3.14159    "(소수점 5번째 자리 10개 자리에서 왼쪽정렬(점도 1칸)
     • 문자열 관련 함수
       1. 문자 개수 세기 count() : a='hobby' / a.count('b') = 2 / b의 개수 세기
       2. 위치 알려주기 1 find() : a.find('y') / a.find('y') = 4 / 첫 위치 반환, 없으면 -1
       3. 위치 알려주기 2 index() : a.index('y') / find와 동일, 없으면 오류 발생
       4. 문자열 삽입 join() : a = ',' / a.join('abcd') / 'a,b,c,d' = 문자열 각 문자 사이에 a 삽입
          • 리스트, 튜플을 문자열로 만들기 Ex) "".join(a)
       5. 소문자->대문자 upper() : a = 'hi' / a.upper() / a = 'HI'
       6. 대문자 -> 소문자 lower() : a = 'HI' / a.lower() / a = 'hi'
       7. 왼쪽 공백 지우기 lstrip() : a = '   hi' / a.lstrip() / a = 'hi'
       8. 오른쪽 공백 지우기 rstrip() : a = 'hi   ' / a.rstrip() / a = 'hi'
       9. 양쪽 공백 지우기 strip() : a = '  hi  ' / a.strip() / a = 'hi'
       10. 문자열 바꾸기(치환) replace() : a = 'hello world' / a.replace('hello', 'hi') / a = 'hi world'
       11. 문자열 나누기(리스트로 반환) split() : a = 'hi world' / a.split() - 공백기준 / a = ['hi', 'world'] / a = 'a:b:c:d' / a.split(:) / a = ['a', 'b', 'c', 'd'] 

Chapter.6 상속 기본

• 상속이란?
  • 상속(Inheritance)
    • 객체 단위 코드를 '재사용'하는 방법, C++클래스가 C의 구조체와 구별되는 근거!
    • 두 클래스 사이의 '관계'를 고려해 프로그램 작성
  • 기본 문법
    • [class 파생클래스이름 : 접근제어지시자 부모클래스 이름]
      • ex) class MyData{ }; class MyDataEx : public CMyData { };
      • CMyDataEx 클래스는 CMyData 클래스를 상속받아 생성된 파생클래스가 된다, 
    • 파생 클래스 인스턴스가 생성될 때 기본 클래스(부모 클래스)의 생성자도 호출된다
      • 호출의 순서 1. 파생 클래스 생성자, 2. 부모 클래스 생성자
      • 실행의 순서 1. 부모 클래스 생성자, 2. 파생 클래스 생성자
    • 파생클래스는 기본클래스의 멤버에 접근 가능(private 제외)
    • 사용자 코드에서는 파생클래스의 인스턴스로 기본 클래스 메서드를 호출할 수 있다
  • 메서드 재정의
    • 오버라이드(override) 메서드를 재정의 하면 기존의 것이 무시된다(대체된다)
    • 기본 문법 및 특징
      • 재 정의시 기본형식의 메서드를 호출하려면 반드시 소속클래스를 정의해야 한다 (그렇지 않으면 재귀호출 발생함)
        • ex) CMyData::SetData(10);
      • 재정의 한 이유 : 제거 X, (기존 메서드 + 현재 메서드) 묶어 한꺼번에 작동 시키기 위함이다
      • 명시적 호출 : b.CMyData::SetData(15); // 메서드가 재 정의 되있어도 해당 클래스의 메서드가 실행된다
      • 묵시적 호출 : b.SetData(15);
        • 상위 클래스 참조자 형식으로 파생클래스에 대입했을 때 ( + 포인터도 )
        • ex) CMydata &rdata = a; // CMydata a;
        • rData.SetData(15); // CMyDataEx()의 SetData() 가 오버로드 됬으나 CMyData의 메서드가 실행됨
  • 상속에서의 생성자와 소멸자
    • 과정 
      1. 파생 클래스 생성자가 호출된다
      2. 파생 클래스 생성자가 실행되기 전에 부모 클래스의 생성자를 호출한다
      3. 부모 클래스 생성자가 실행되고 반환된다
      4. 파생 클래스의 생성자가 실행되고 반환된다
      5. 소멸은 생성의 역순(A -> B -> C | C -> B -> A)
         • 따라서 파생 클래스 에서 부모 클래스의 멤버변수에 쓰기, delet 연산을 하면 안된다!!!
         • 파생 클래스 생성자에서 부모 클래스 맴버 변수를 초기화 하지 않는다.
    • 생성자 선택
      • '생성자 상속'
        • 다중 정의된 상위 클래스의 생성자들을 그대로 가져오는 문법
          • ex)CMyDataEx(int nParam) : CMyData(nParam) { ~ } 
            • 파생 클래스 생성자 실행 전에 부모 클래스 생성자 호출함

Chapter.5 연산자 다중정의

• 연산자 함수린?
  • 연산자를 이용하듯 호출할 수 있는 '메서드' (결국 메서드 이다)
  • 장점
    1. 훨신 더 간결하게 코드를 작성 가능하다
    2. 코드의 확장성이 늘어난다
  • 단점
    1. 절대 오류가 발생해서는 안된다(결과를 확인하지 않기 때문에)
    2. 사용자 코드에서 문제점 파악이 매우 힘들다
  • 주의사항 : 절대 '논리 연산자'들은 다중정의 해서는 안된다(&&, || 등)
• 산술 연산자
  • +, -, /, % 의 산술 연산자의 의미를 재정의
  • ex) + 연산자 다중정의
    • '더한다'라는 의미를 어떻게 정의하는가 에 따라 결과가 달라짐 즉 '무엇이든 더할수 있다'
    • [ 클래스 이름 operator연산자( 인자 ) ]
      
      • ex) class + class = class(둘의 멤버 변수를 합한 값을 멤버변수로 가지고 있는 함수)
      • CMyData operator+(const CMyData &rhs) {
      •     CMyData result(0);
      •     result.m_nData = this->m_nData + rhs.m_nData;
      •     return result;
      • }
        • 이때 반환형식이 class 이므로 이름없는 객체가 생성됨 -> 필요에 따라 이동생성자 정의해서 사용(얕은복사)
• 대입 연산자
  • 일반 대입연산자 
    • = 연산자의 의미를 재 정의
    • 기존에 있던 멤버변수 헤제 후 새로 멤버변수 값 할당
    • 대입 연산자 발생시 발생할 수 있는 문제 2가지
      1. a = a 실행 시
         • 기존 멤버변후 헤제 후 할당할때 이미 헤제된 멤버변수를 가리키기 때문에 쓰레기값이 들어감
         • if(this == &rhs) 로 비교 해서 같을 시 헤제와 할당을 다시 하지 않고 바로 반환
      2. a = b = c 실행 시
         • 일반 a = b 시 반환값이 필요 없으나 2번 이상 수행시 반환값이 필요하게 됨
         • 클래스 이름& operator=(const 클래스이름 &rhs) 로 반환값을 지정해 줌
    • [ 클래스 이름& opeator=(const 클래스이름 &rhs) ]
      • ex)
      • CMyData& operator=(const CMyData &rhs) {
      •     if(this == &rhs)
      •         return *this;
      •     delet m_npData;
      •     m_npData = new int(*rhs.m_npData);
      •     return *this;
      • }
  • 복합 대입 연산자
    • +=, -=, /=, *= 같은 복합 대입 연산자를 대상으로 하는 연산자 다중정의
    • 처리 순서
      1. 현재 값 처리 // 새 객체 생성시 현재 값과 동일하게 선언
      2. 누적할 값 처리 // 새 객체의 멤버변수값에 += 처리
      3. 기존 데이터 delet 후 새 메모리 선언해서 대체 // 기존 대입 연산자와 같은 수행
  • 이동 대입 연산자
    • 일반 대입 연산 -> '깊은복사', 이동 대입 연산 -> '얕은 복사'
    • 이동 대입 연산 : 임시 객체를 r-value 로 대입 연산 실행시 수행 // 별도의 선언이 없으면 일반 대입 연산 진행
    • a = b + c 와 같은 계산 시 (b + c) 를 임시 객체로 이동 대입 연산을 실행한다
    • [ CMyData& operator=(CMyData &&rhs) { ~ } ]
• 배열 연산자
  • 포인터와 배열을 합쳐준다
    1. class 제작자 = 배열을 포인터로 만들어서 '메모리를 관리'할 수 있게 함
    2. main 사용자 = 포인터를 배열처럼 사용할 수 있게 함
  • 배열 연산자의 종류 2가지
    1. 일반 상황 (l-value, r-value 둘다 사용 가능) [int& operator[](int index) { };
    2. 상수형 참조인 경우(r-value 만 사용 가능) [int operator[](int index) const { };
       • class 가 함수의 매개변수 인 경우!
• 관계 연산자
  • ==, != 연산자를 다중정의(반환 형식은 int형 - 참:1, 거짓:0)
  • [ int operator==(const CMyString &rhs) { } ]
• 단항 증감 연산자
  • ++, -- (증가 연산자, 감소 연산자) 다
  • 단항 증감 연산자의 종류
    1. 전위식(++a) [ int operator++() {~ } ]
    2. 후위식(a++) [ int operator++(int) { ~ } ]
  • 전위식은 그냥 1을 더하면 된다
  • 후위식은 새로운 객체를 생성해서 원본은 +1 해주고, 새 객체를 반환한다
    • ex)
    • int operator++(int) {
    •     int nData = m_nData;
    •     m_nData++;
    •     return nData;
    • }

연습문제

1. 대입 연산자 오버로딩 시 주의해야 할 점 2가지, 그 이유?

= 1:본인인지 확인(a=a 일 경우 해결), 2:class& 클래스 참조자 형태로 반환(a=b=c일 경우 해결)

2. 각종 대입 연산자들의 적절한 반환 형식은 무엇인가?

= 산술 연산자:class, 대입 연산자:class참조자, 배열 연산자:int, int&(상수형 참조), 관계 연산자:int, 단항증감연산자:int

3. 후위식 단항 증가 연산자를 작성하려고 한다, 적절한 함수 원형을 예로 들어 보시오

= int operator++(int) { ~ }

#include <stdio.h>

#include <math.h>

int digit(int x) {

    int dcount=0;

    while(1) {

        x /= 10;

        dcount++;

        if(x == 0)

            return dcount;

    }

}

int main(int argc, const char * argv[]) {

    int num, count = 0;

    int value = 666;

    scanf("%d", &num);

    while(1) { // count 가 num이 되는 순간 그 value 반환

        int dig = digit(value); // dig는 자릿수

        int flag = 0; // 6이 나오면 flage += 1, 안나오면 flag = 0

        int tmp = value;

        for(int i=0; i<dig; i++) { // flag 가 3이 되면 count++, value의 1의 자리부터 666나오나 계산

           if(tmp % 10 == 6)

                flag++;

           else // 연속이 아닐 경우 flag 다시 0

               flag = 0; 

            tmp /= 10;

            if(flag == 3) {

                count++;

                break;

            }

        }

        if(num == count) {

            printf("%d\n", value);

            return 0;

        }

        value++;

    }

    return 0;

}

Chapter.4 복사 생성자와 임시 객체

(난이도 매우 높으니 여러번 복습할 것)

• 복사 생성자
  • 복사 생성자란? : 객체의 복사본을 생성할 때 호출되는 '생성자'
    • 생략하면 디폴트 생성자 처럼 컴파일러가 알아서 만들어 넣어줌
    • 클래스 내부에서 메모리를 동적할당 및 헤제, 멤버포인터 변수로 관리 한다면 문제가 생긴다
      • ex) 클래스 내부에 new 로 변수 사용
    • 사용법 [ 클래스 이름( const 클래스 이름 &rhs); ]
      • 이때 const는 생략 가능하지만, 원본 객체를 손상시키지 않기 위해 const를 꼭 선언해주자! 
  • 복사 생성자 정리 ( 모든 상황 )

1. 복사 생성자 (깊은 복사)
   1. 명시적 객체의 복사본 생성
   2. 함수의 형태로 호출
      1. 클래스가 함수의 매개변수로 사용 (무조건 참조 형태로 선언하기!)
      2. 클래스가 함수의 반환형태로 사용 (이름 없는 객체 생성됨!)
2. 이동 시멘틱 (얕은 복사)
   1. 이동생성자
   2. 이동 대입연산자

• 복사 생성자(게속)
  
  • 클래스가 함수의 매개변수로 사용되는 경우
    • 문제 : 의미없이 class 객체가 2번 사용됨
      1. 객체 선언시 1개 ( 함수의 인수로 넣기 위해 선언 )
      2. 함수의 매개변수로 클래스 객체를 받을때 다시 생성된 1개 ( 함수 내부에서 사용하기 위해 선언 )
    • Solution.1 : 복사 생성자 삭제(delete)
      • CTestData(const CTestData &rhs) = delete; 선언하기
      • 복사 생성이 아예 불가능하게 막아버림
    • Solution.2 : 참조자 사용 (&)
      • 매개변수로 클래스 객체를 받는 함수에서 매개변수로 클래스 객체의 참조자를 받는 함수로 변환시키기
      • ex) void TestFunc(CTest param) -> void TestFunc(const CTest &param) // 객체 생성은 1번만 됨
        • 이때도 const선언은 생략 가능하지만, 원본 객체를 손상시키지 않기 위해 const를 꼭 선언해주자! 
  • 깊은 복사와 얕은 복사
  • 얕은 복사는 메모리 관련 문제가 생긴다(둘다 delet 사용시 하나에 2번사용, 하나는 남아있는 상태가 되기 때문)

• 복사 생성자(게속)
  • 대입 연산자
    • 단순 대입 연산자(=) 가 구조체나 클래스에도 기본적으로 적용됨
    • 하지만 단순 대입 연산자는 '얕은 복사' 가 수행된다!
    • 따라서 이때 연산자 다중 정의를 사용하여 문제를 해결해 주면 된다(나중에 배울 것)
      • ex) CMyData& operator=(const CMyData &rhs) { *m_pnData = *rhs.m_pnData; return *this; }
      • a = b (a.operator=(b) 와 같은 형식으로 호출 가능)
• 묵시적 변환
  • 묵시적 변환이란?
    • 직접적인 언급은 없었으나 당연하게 변환 하는 것
  • 변환 생성자
    • 매개변수가 하나인 생성자를 '변환 생성자' 라고 한다!
    • ex) CTestData(int nParam) { ~ } // 변환 생성자
      • void TestFunc(CTestData param) { } / TestFunc(5); // 변환생성자 사용됨 
      • 원래 클래스를 맴버변수로 받지만, int 형으로 받음
    • 이는 실제로 임시 객체가 생성되어 전달된 것 즉 TestFunc(CTestData(5)) 와 동일한 의미를 가진다
    • 묵시적 변환 생성자는 편의성은 좋아지지만 효율성(성능)은 낮아진다
    • 이때 변환생성자 앞에 explicit 예약어를 사용하면 묵시적 변환이 불가능해진다(임시 객체 생성 X)
      • explicit CTestData(int nParam) { ~ }
  • 허용되는 변환
    • 변환 생성자가 있으면 int 자료형 -> CTestData 자료형 은 가능했다
    • 그러나 CTestData 자료형 -> int 자료형 은 불가능하다 이때 형변환 연산자를 사용하면 가능해진다
      1. operator int(void) { return m_nData; } / a 
      2. int(a) // 무조건 강제 변환 시킴 
      3. static_cast<int>(a) // 예외 상황을 제외하고는 변환 시켜줌
    • 웬만하면 static_cast<자료형>(이름) 으로 명시적 형변환을 사용하자!
  • 임시 객체와 이동 시멘틱
    • 함수의 반환 형식이 클래스인 경우
      • 함수의 반환형식이 클래스인 함수를 실행시키면 _tmain(메인함수)에 이름없는 객체가 생성, 소멸 된다
      • 함수를 반환(return) 하면서 생성, 대입 연산이 끝나면서 소멸 한다
        
        • 이때 '무조건' 이름없는 객체가 생성, 소멸 한다
      • '이름없는 임시 객체의 원본 = 임시 객체의 복사 생성이 끝난 후'
      • 이때 소멸 전에 연산이 가능하다 ex)TestFunc(10).GetData()
      • 이름없는 객체에 별칭을 부여해서 소멸 시점을 달라지게 할 수 있다
        • CTestData &rData = TestFunc(10) // 클래스 참조자 변수로 별칭을 부여! (소멸 시기를 인식하자)
    • r-value 참조
      • 3에4를 대입할 수 없듯 변수가 아닌 대상에 참조를 선언하는것은 허용되지 않는다
      • 그러나 C++11 표준 등장후 r-value 에 관한 참조자가 새로 제공됬다 ( int &&) 형식
      • 여기서 r-value : 연산자 따라 생성된 임시 객체!
      • 아래 표를 보고 어떤 상황에 무엇이 필요할지 선택해서 사용할 것

• 묵시적 변환 게속
  • 이동 시멘틱
    • 이동 생성자 + 이동 대입 연산자
    • 복사생성자와 대입 연산자에 r-value 참조를 조합하여 새로운 생성자가 만들어 졌다
    • 이동 생성자 [ CTestData(CTestData &&rhs) { ~ } ] 복사생성자에 & 하나더
    • 만들어진 이유 : 얕은 복사를 하기 위해 (복사 생성자는 깊은 복사가 된다)

연습문제

1. 함수의 매개변수가 기본 형식이 아니라 클래스라면 매개변수 형식은 어떻게 정하는 것이 바람직한가? 그 이유는?

- 클래스의 참조자 형식, 의미없이 객체를 2번 할당(선언) 하지 않기 위해

2. 복사 생성자 및 단순 대입 연산자를 반드시 정의해야 하는 클래스는 어떤 클래스인가?

- 클래스 내부에서 동적할당(new, delete) 를 사용하고, 이를 참조자로 관리하는 클래스

3. 만약 다음과 같은 코드에서 컴파일 오류가 없었다면 CTestData 클래스는 잠재적인 문제를 가진것, 그것이 무엇인가?

void TestFunc(const CTestData &param) { ~ }

int _tmain(int argc, _TCHAR* argv[]) {

    TestFunc(5);

    return 0;

}

- 변환 생성자가 활용된다 -> 성능에 대한 문제

4. 이동 시멘틱이 등장한 가장 큰 원인은 무엇인가?

- 얕은 복사를 사용해서 메모리 공간을 효율적으로 사용하기 위해