솔의 다락

객체지향 프로그래밍 OOP, Object Oriented programming

# 객체지향 프로그래밍

   * 객체지향 프로그래밍

     : 자바, c++은 객체지향 프로그래밍 언어 / 파이썬은 내부적으로 객체지향이며 객체지향 문법 지원

   * 객체의 개념

     (1) 사물을 나타낼 수 있는 설계도를 만든다. = class

     (2) 설계도를 기반으로 객체들을 만든다. = object, 인스턴스

     (3) 각 객체에 속성값을 부여하고 기능을 호출한다. = attribute, 필드 / method

# 1. class 

   * 클래스란

     : 현실 세계의 사물을 컴퓨터 안에서 구현하려고 고안된 설계도와 같은 개념으로,

       사물과 사물의 속성, 기능을 구현

       ⇒ 사물(객체, 인스턴스)  /  속성(attribute, 필드)  /  기능(method 메서드)

                 자동차                                      색상, 종류, 속도                      엑셀 밟기, 브레이크 밟기

   * class 선언하기 )  class 클래스명 :

                                     속성(필드) 선언     _     속성명 = ~~~

                                     메서드 선언           _     def 메서드명 (self, 인자1, 인자2, ...)

                                                                              인자 포함 실행문

                                                                              return self.속성명

                                  ↳ 메서드에 self를 쓰는 것은 메서드 안에서 속성에 접근하기 위해!

                                     메서드 안에서 속성에 접근하지 않는다면 쓰지 않아도 됨

                                           ex.  def print_message() :

                                                      print("메세지 출력")

class Car :
    speed = 0
    color = ''
    def upSpeed(self, value) :
    	self.speed = self.speed + value

# 2. 객체(인스턴스)

   * 객체란

     : 자동차 설계도에 따라 여러 대를 생산하는 것처럼

       설계도인 class를 기반으로 여러 객체가 존재하며, 각 객체가 별도로 속성(필드), 메서드를 가짐

   * 객체 생성하기 )  객체명1 = class명()

                                객체명2 = class명()

mycar1 = Car()
mycar2 = Car()

# 3. 속성(필드)값

   * 속성(필드)값

     : 각 객체(인스턴스)마다 별도의 필드가 있으니, 별도의 값 부여해주기

   * 속성값 부여하기 )  객체명1.속성명 = ~~~

                                    객체명2.속성명 = ~~~

mycar1.speed = 10
mycar1.color = 'blue'

mycar2.speed = 20
mycar2.color = 'black'

# 4. 메서드

   * 메서드 호출하기 )  객체명1.메서드명()   or   객체명1.메서드명(인자)

mycar1.upSpeed(30)
print(mycar1.color , mycar1.speed)

mycar2.upSpeed(50)
print(mycar2.color , mycar2.speed)

blue 40
black 70

파이썬 라이브러리

# 라이브러리

   * 라이브러리란 : 미리 만들어놓은 함수 집합

   * 다양한 라이브러리 : https://docs.python.org/3/library/

# 사용법

   1. 라이브러리 호출 후 내부 함수 쓰기 )  import 라이브러리명

                                                                  라이브러리명.함수명(인자)

   2. 라이브러리의 함수 호출하기 )  from 라이브러리명 import 함수명

                                                         함수명(인자)                                   _ 라이브러리명 안 써도 된다는 장점

   3. 라이브러리의 모든 함수를 호출 )  from 라이브러리명 import *

                                                              함수명(인자)

   4.  라이브러리나 함수에 별칭 부여 )  import 라이브러리명 as 별칭

                                                              or   from 라이브러리명 import 함수명 as 별칭

튜플

# 생성  : 튜플명 = ( 값1, 값2, ... )     _ 튜플은 괄호

# 읽기  : 튜플명[인덱스번호]

# 사용  - 튜플의 개별값 추가, 삭제, 수정 불가능      _ 튜플 전체 삭제는 del(튜플명)

            - 튜플 이어 붙이기 : 튜플명1 + 튜플명2

            - 튜플값 반복 : 튜플명 * n

tuple1 = (1,2,3)
tuple2 = (4,5,6)

tuple1 + tuple2
(1,2,3,4,5,6)

tuple1 * 2
(1,2,3,1,2,3)

# 변환   -  list(튜플명) : 튜플을 리스트로 변환

             -  tuple(리스트명) : 리스트를 튜플로 변환

             - 변수 변환 

■ x와 y의 값 바꾸기 ■
x = 1, y = 2

temp = x
x = y
y = temp

■ 튜플 사용 ■
(x,y) = (y,x)

             - 반환값이 여러 개인 함수

딕셔너리

# 역할 :  키로 값 찾기

# 선언 : 딕셔너리명 = dict()     or     딕셔너리명 = { 키1 : 값1 , 키2 : 값2 , ... }

                                                                                ↳ 값에 리스트, 딕셔너리 들어갈 수 있음

# 읽기 :  딕셔너리명 [키]     → 값을 출력  /  딕셔너리의 [ ] 안에는 인덱스 번호가 아닌 키!

                                           ↳ 값이 리스트인 경우 )  딕셔너리명 [키] [인덱스번호]

                                           ↳ 값이 딕셔너리인 경우 )  딕셔너리명 [키] [키]

통화별 환율을 딕셔너리로 만들고 사용자로부터 금액과 통화명 사이에 공백을 넣어 입력받은 후
이를 원으로 바꿔서 계산하시오

exchange = {'달러':1112 , '위안':171 , '엔':1010}

price = input("금액을 입력하세요 ")

for i in exchange.keys() :
	if price[4:] == i :
    	print( int(price[0:3]) * exchance[i] , '원')

집합

# 선언  - 빈 집합 )  집합명 = set()

            - 값이 여러 개 )  집합명 = {값1, 값2, ...}   or   집합명 = set( {값1, 값2, ..} )

            - 값이 하나 )  집합명 = set( 값 )

# 읽기  - 집합은 인덱스번호 지원 X

            - 반복문에서는 print로 출력 O

            - 값 in 집합명  으로 T/F 판단

# 연산  - 집합명A & 집합명B : 교집합 출력

            - 집합명A \ 집합명B : 합집합 출력

            - 집합명A - 집합명B : 차집합 출력

            - 집합명A ^ 집합명B : 합집합 - 교집합

# 특징 :  값의 순서 없음, 중복 없음

               so 리스트에 중복값이 있을 경우 set(리스트명)으로 집합 변환하면 중복값 제거

               다시 list(리스트명)으로 리스트 변환하면 중복값 제거한 리스트 생성

# 수정  - 값 하나 추가 )  집합명.add(값)

            - 여러 값은 리스트 형태로 추가 )  집합명.update( [값4, 값5, ...] )

            - 제거 )  집합명.remove(값)

함수

# 개념과 필요성

   y = f(x) 처럼 입력값을 처리해 특정 결과를 반환해주는 상자

   - y : 결과값 output

   - x : 대입값 input , 인수 argument, 매개변수 parameter

# 함수 선언

  ## 함수 선언

   def  함수명(매개변수명) :

       실행문                                          _ 실행문 없이 일단 함수 이름만 선언하고 싶을 경우 실행문 자리에 pass 쓰기

  ## 전역 변수 선언

  ## 메인 코드

# 지역변수와 전역변수

   - 지역변수 local variable : 함수 선언 부분 안에서만 사용되는 변수

   - 전역변수 global variable : 프로그램 전체에서 사용되는 변수

  ⇒  지역변수명과 전역변수명이 같을 경우,

        함수 선언 부분 안에서는 지역변수명이 우선

        함수 선언 부분 밖에서는 전역변수명만 취급

# return

   - 반환값이 있는 함수 )  def 함수명() :

                                             실행문

                                              return 반환값      _ 해당 블럭에서 return 이후는 더이상 진행되지 않고 종료

def func1(a, b) :
	result = a + b
    return result
    
print(func1(5, 8))
13

def check(id) :
	if id == "kds" :
    	print("valid id")
        return
    print("invalid id : ", id)
    
# id가 kds이면 print 실행하고 return에서 종료
# id가 kds가 아니면 if 블럭 밖의 print 실행

   - 반환값이 없는 함수 )  def 함수명 () :    or    def 함수명 () :

                                             실행문                      실행문

                                                                              return

def func2(a, b) :
	print("a + b = ", a+b)
    
func2(5,8)
a + b = 13

   - 반환값이 여러 개인 함수 )  반환할 값을 리스트에 넣고 리스트를 반환   

                                                 def func3(a, b) :

                                                     반환리스트명 = []

                                                     return 반환리스트명

for문

# 기본 for문

   * 숫자 범위 형식 )  

       for 변수 in range(시작값, 끝값+1, 증가값) :

           실행문

       ↳ 변수에 시작값부터 끝값까지 변수에 대입하며 반복 실행

   * 리스트 범위 형식 )  

        for 변수 in 리스트명 :       or       for 변수 in [ 리스트 나열 ] :

            실행문                                        실행문

        ↳  for문 첫째줄에서 list 값을 변수에 대입하며 반복 실행

        ↳  list의 값을 인덱스 번호로 인식하고, list 개수에 맞춰 해당 번호의 값을 실행

             ex.  리스트에 값이 3개 있으면 인덱스 0번 실행 , 1번 실행 , 2번 실행 후 종료

        ↳  (주의) for loop 안에서 list값이 추가/삭제되는 경우,

                       수정된 list의 항목에 원래대로의 인덱스 번호를 부여하고 반복하기 때문에 띄엄띄엄 실행됨

              ex.  원래 리스트에 값이 [1,2,3,4]로 4개 있으면 인덱스 0번~3번까지 4번 실행

                     0번 실행 후 리스트에서 원래 0번 자리에 있던 값 [1]이 삭제되면

                     다음 1번 실행할 때에는 새로 구성된 [2,3,4]의 1번인 [3]을 실행

# 중첩 for문

      for i in range(시작값, 끝값+1, 증가값) :

          for k in list :

              실행문

          for i in range (시작값, 끝값+1) :

              실행문

      ↳  중첩문에서는 반드시 다른 변수 사용 (i , k)

           for loop 끝나면 같은 변수 사용 가능

while문

# while문

   * 기본 형식 )   while 조건식 :

                             조건식이 참일 때 실행할 실행문

                          조건식이 거짓일 때 실행할 실행문

   * 활용 형식 )  for i in range (시작값, 끝값+1) :        =        변수 = 시작값

                            실행문                                                       while 변수 < 끝값 :

                                                                                                  실행문

                                                                                                  변수 += 증가값

# 무한루프

   조건식에 True(1)을 지정하면 무한 반복

    while True :      or     while 1 :

        실행문                      실행문

break문 & continue문

# break문

# continue문

조건문

# 기본 if문

   * 형식 )  if 조건식A :

                    실행문1

                    실행문2

                 elif 조건식B :

                    실행문3

                 else :

                    실행문4

   * 실행 )  if의 조건식이 참일 때, if문 블럭 전체를 실행  _ 블럭 단위로 실행하기 때문에 들여쓰기 간격 주의!

                                      거짓일 때, elif와 else의 실행문을 실행

# 중첩 if문

   * 형식 )  if 조건식A :

                    if 조건식a :

                        실행문1

                    else :

                        실행문2

                 else :

                    실행문3

# if문 응용

   * 리스트 항목 확인

       -  if 값 in 리스트명  : 값이 있으면 if 실행문 실행

       -  if 값 not in 리스트명  : 값이 없으면 if 실행문 실행

리스트

# 활용

생성 )  리스트명 = [값1, 값2, 값3, ...] 

           : 보통 리스트명=[] or 리스트명=list() 로 빈 리스트 생성 후 작업

           : 리스트에는 모든 데이터 형식이 들어갈 수 O

추출 )  리스트명[인덱스번호]  : 맨 첫자리가 0, 맨 마지막이 -1

                                                [1:3]은 두번째부터 세번째

추가 )  리스트명.append(값)  : 맨 뒤에, 하나씩만 추가 가능

           리스트명.insert(인덱스번호, 값)  : 해당 인덱스번호에 값 끼워넣기

           리스트명.extend([추가할 리스트])  : 리스트를 추가

삭제 )  리스트명.remove(값)  : 특정 데이터값이 여러개이면 맨 첫번째 값만 삭제

           del(리스트명[인덱스번호])

           리스트명.pop()  : 맨 뒤 값을 삭제

           리스트명.clear()  : 리스트 내용 모두 삭제

수정 )  리스트명[인덱스번호] = 수정할값

# 리스트 함수

  - 리스트명.sort()  : 리스트 데이터 순서대로 정렬  _ 아예 데이터 정렬이 바뀜

  - sorted(리스트명)  : 리스트를 순서대로 정렬해서 출력  _ 기존 데이터 정렬 유지, 출력값만 정렬

  - 리스트명.reverse()  : 역순 정렬  _ 아예 데이터 정렬이 바뀜

리스트를 역순으로 출력하세요

list = [1,2,3,4,5]
list.reverse()
print(list)   _ print(list.reverse()) 아님!
5,4,3,2,1

  - 문자열변수명.split()  : 문자열을  띄어쓰기로 구분해 리스트로 정렬  _ 본래 변수가 리스트로 바뀌는 것은 X

    문자열변수명.split("-")  : - 을 기준으로 구분해 리스트로 정렬

  - len(리스트명)  : 리스트 개수 확인   _ count 아님!

  - 리스트명.count(값)  : 특정 값의 개수 세기

  - 리스트명.index(찾을값)  : 해당 값 위치의 인덱스번호 확인

  - new리스트명 = 리스트명.copy()  : 새로운 리스트에 기존 리스트 내용 복사

RRN = 900001-1231231
RRN.split("-")
["900001", "1231231"]

Q ) filename = 'exercise01.docx' 에서 확장자를 제거한 파일 이름만 출력하세요.

filename = 'exercise01.docx'
filelist = filename.split(".")

print(filelist[0])

# 2차원 리스트

  aa = [[1,2] , [3,4]] 이면

  1 = aa[0][0] , 2 = aa[0][1] , 3 = aa[1][0] , 4 = aa[1][1]