[Python] 32. 함수와 람다, 변수, 예외처리, 클래스

1. 함수와 람다

2. 변수

3. 예외처리

4. 클래스

# -*- coding: utf-8 -*-
"""
Created on Wed Jun 15 09:30:05 2022

@author: p011v
"""

'''
    Collection : 데이터의 모임.
        리스트(list) : 배열. 순서유지. 첨자(인덱스)사용 가능. []
        튜플(tuple) : 배열. 순서유지. 첨자(인덱스) 사용 가능. 상수화된 리스트.
                     변경 (수정, 추가) 불가 리스트. ()
        딕셔너리(dictionary) : (key, value) 쌍 인 객체. JAVA의 Map. {}
                    item() : (key, value) 쌍 인 객체를 리스트 형태로 리턴
                    keys() : key들만 리스트 형태로 리턴
                    values() : value들만 리스트 형태로 리턴
        셋(set) : 중복불가. 순서모름. 첨자(인덱스) 사용 불가. 집합표현 객체.{}
            &, intersection() : 교집합
            |, union() : 합집합
            
    컴프리헨션(comprehension) : 패턴(규칙)이 있는 데이터를 생성하는 방법
'''

# conprehention 방식으로 set 객체 생성하기
# 1 ~ 10사이의 짝수의 제곱값을 가진 set 객체 생성하기
#1
set1 = {x*x for x in range(2,11,2)}
print(set1)
#2
set1 = {x**2 for x in range(1,11) if x%2 == 0}
print(set1)

# dictionary 데이터 생성하기
products = {"냉장고":220, "건조기":140, "TV":130, "세탁기":150, "컴퓨터":200}
# 200미만의 제품만 product1 객체 저장하기
#1
product1 = {}
for k in products :
    if products[k] < 200 :
        product1[k] = products[k]
print(product1)
#2
product1 = {}
for k in products.keys() :
    if products[k] < 200 :
        product1[k] = products[k]
print(product1)
#3
product1 = {}
for k,v in products.items() :
    if v < 200 :
        product1[k] = v
print(product1)
# conprehention 방식
product2 = {k:v for k,v in products.items() if v < 200}
print(product2)


########## 1. 함수와 람다
# 함수의 정의 : def 예약어 이용
def func1() :
    print("finc1() 함수 호출")
    return 10 #함수 종료. 값을 전달.

def func2(num) :
    print("finc2() 함수 호출", num)

a=func1() # 함수호출. 함수실행
print(a)

func2(100)

########## 2. 변수
#전역변수 : 모든 함수에 접근이 가능한 변수. 함수외부에서 사용됨.
#지역변수 : 변수가 사용된 함수에서만 접근이 가능한 변수. 함수내부에서 사용됨.
# 변수명이 같이 선언되어있을 때 지역변수를 우선으로 취급함.

def func3() :
    global gval #global 변수명 : 전역변수의 변수를 사용 선언
    gval=300
    a=100 #지역변수. 전역변수 a와 상관없음.
    b=20 #지역변수
    print("func3() 함수 a=", a, ",b=", b, "gval=", gval)
    
def func4() :
    b=30 #지역변수
    print("func4() 함수 a=", a, ",b=", b, "gval=", gval)
    
a=10    #전역변수
gval=200 #전역변수
func3()
func4()
print("a=", a, "gval=", gval)

# 매개변수
def add1(v1, v2):
    return v1+v2

def sub1(v1, v2):
    return v1-v2

hap = add1(10,20) 
sub = sub1(10,20) 
print(hap) #30
print(sub) #-10
hap = add1(10.5, 20.3)
sub = sub1(30.59, 21.3)
print(hap) #30.8
print(sub) #9.29
hap = add1("python","3.9")
print(hap) #python3.9

#가변매개변수 : 매개변수의 갯수 정해지지 않은 경우
def multiparam(* p) :   # 매개변수 0개 이상
    result = 0
    for i in p :    # i : 하나의 매개변수
        result += i
    return result

print("multiparam()=", multiparam())                      #0
print("multiparam(10)=", multiparam(10))                  #10
print("multiparam(10, 20)=", multiparam(10, 20))          #30
print("multiparam(10, 20, 30)=", multiparam(10, 20, 30))  #60

print("multiparam(1.5, 2.3, 3.9)=", multiparam(1.5, 2.3, 3.9))  #7.7

#매개변수에 기본값 설정하기
def hap1(num1=0, num2=1) :
    return num1 + num2

print("hap1()=", hap1()) #1 매개변수가 없음 : num1=0, num2=1
print("hap1(10)=", hap1(10)) #11 num1=10, num2=1
print("hap1(0, 10)=", hap1(0, 10)) #10 num1=0, num2=10
print("hap1(10, 20)=", hap1(10, 20)) #30 num1=10, num2=20
print("hap1(10, 20, 30)=", hap1(10, 20, 30)) #오류발생. 선언된 매개변수 갯수와 입력된 인자값의 갯수가 다름.

#리턴값이 두개인 경우 : 리스트로 리턴
def multi(v1, v2) :
    list1 = []
    list1.append(v1+v2)
    list1.append(v1-v2)
    return list1

list1 = multi(200,100)
print(list1)

# 문제 : list1 리스트의 평균을 구해주는 함수 getMean를 구현하기
#1
def getMean(numlist) :
    if len(numlist) > 0 :
        return sum(numlist)/len(numlist)
    else :
        return 0
#2
def getMean (numlist) :
    return sum(numlist)/len(numlist) if len(numlist) > 0 else 0

list1=[2,3,3,4,4,5,5,6,6,8,8]
print("list1의 합: ", sum(list1))
print("list1의 평균: ", getMean(list1))

list2=[]
print("list2의 합: ", sum(list2))
print("list2의 평균: ", getMean(list2))

# 람다식을 이용한 함수
def hap1(num1,num2) :
    return num1+num2
print(hap1(10)) #오류발생. 매개변수 갯수 오류
print(hap1(10,20))
print(hap1(10.5,20.3))

hap2 = lambda num1,num2:num1+num2
print(hap2(10)) #오류발생. 매개변수 갯수 오류
print(hap2(10,20))
print(hap2(10.5,20.3))

# 매개변수에 기본값 설정하기
hap3 = lambda num1=0,num2=1:num1+num2
print(hap3(10)) #오류발생. 매개변수 갯수 오류
print(hap3(10,20))
print(hap3(10.5,20.3))

#mylist1 객체의 요소에 10을 더한 값을 가진 mylist2 객체 생성하기
mylist1 = [1,2,3,4,5]
mylist2 = []

#1
for n in mylist1 :
    mylist2.append(n+10)
print(mylist2)
#2 : conprehention 방식
mylist2 = [n+10 for n in mylist1]
print(mylist2)
#3 : map 함수 이용
# map(함수,리스트) : 리스트의 요소들마다 함수 설정
mylist2 = list(map(lambda n:n+10,mylist1))
print(mylist2)

########## 3. 예외처리 : 예측가능한 오류를 정상적으로 처리해주는 기능
# try except 예약어 사용

idx = "파이썬".index("일") #오류발생
idx = "파이썬".find("일") # -1
print(idx)

#예외처리하기
try :
    idx = "파이썬".index("일")
    print(idx)
except :
    print("파이썬 문자열에는 '일'자가 존재하지 않습니다.")

#mystr 문자열에 파이썬 문자의 위치를 strpos 리스트에 저장하기
mystr = "파이썬 공부 중입니다. 파이썬을 열심히 공부합시다."
#1
strpos = []
index = 0
while True :
    index = mystr.find("파이썬",index)
    if index < 0 :
        break;
    strpos.append(index)
    index += 1
print(strpos)
#2
strpos = []
index = 0
while True :
    try :
        index = mystr.index("파이썬",index)
        strpos.append(index)
        index += 1
    except :
        break;
print(strpos)

# 다중예외처리 : 하나의 try 구문에 여러개의 except 구문이 존재
#               예외별로 다른 처리 가능
num1 = input("숫자형 데이터1 입력: ") #10
num2 = input("숫자형 데이터2 입력: ") #0

try : 
    a = [0]
    print(a[0]) #IndexError
    n1 = int(num1)
    n2 = int(num2)
    print(n1+n2)
    print(n1/n2) #ZeroDivisionError
except ValueError as e :
    print("숫자로 변환 할 수 없습니다.")
    print(e)
except ZeroDivisionError as e :
    print("두번째 숫자는 0 입력이 불가능 합니다.")
    print(e)
finally : #정상, 예외 발생 모두 실행되는 구문
    print("프로그램 종료")

# 다중예외처리를 하나의 변수로 묶기
num1 = input("숫자형 데이터1 입력: ") #10
num2 = input("숫자형 데이터2 입력: ") #0

try :
    n1 = int(num1) #ValueError
    n2 = int(num2)
    print(n1+n2)
    print(n1/n2) #ZeroDivisionError
except (ValueError, ZeroDivisionError) as e :
    print("숫자 입력 오류 입니다.")
    print(e)
finally : #정상, 예외 발생 모두 실행되는 구문
    print("프로그램 종료")

# 나이를 입력받아 19세미만이면 미성년, 19세이상이면 성인 출력하기
# 입력된 데이터가 숫자가 아닌 경우 '숫자만 입력하세요.' 메세지 출력하기

#1
try :
    age = int(input("나이를 입력하세요: "))
    if age < 19 :
        print("미성년입니다.")
    else :
        print("성인입니다.")
except ValueError as e :
    print("숫자만 입력하세요.")
    print(e)
#2
try :
    age = int(input("나이를 입력하세요: "))
except ValueError as e :  #try 블럭에서 오류가 발생된 경우 실행되는 영역
    print("숫자만 입력하세요.")
    print(e)
else : #try 블럭에서 오류가 발생되지 않은 경우 실행되는 영역
    if age < 19 :
        print("미성년입니다.")
    else :
        print("성인입니다.")

# raise : 예외 강제 발생
try :
    print(1)
    raise ValueError #ValueError 예외 발생
    print(2)
except ValueError :
    print("ValueError 강제 발생")
    
# pass : 블럭내부에 실행 될 문장이 없는 경우
n=11

if n > 10 :
    pass
else :
        print("n의 값은 10 이하입니다.")

try :
    age = int(input("나이를 입력하세요: "))
    if age < 19 :
        print("미성년입니다.")
    else :
        print("성인입니다.")
except ValueError :
    pass #오류가 발생시 무시
    
    
    
#############################################################
# 클래스 : 사용자가 정의한 자료형
#           구조체 + 함수
#           변수 + 함수의 모임
#           파이썬은 불완전 객체지향 언어.
#   상속 : 다중 상속 가능
#   self : 자기참조변수. 인스턴스함수(메서드)의 매개변수로 설정되어야함.
#   생성자 : def __init__(self) : 
##############################################################

class Car : #생성자가 구현되지 않은 경우 기본생성자 구현됨.
    '''
    기본생성자의 형태
    def __init__(self) :
        pass
    '''
    color="" #멤버변수
    speed=0  #멤버변수
    def upSpeed(self, value) : #멤버함수(메서드)
        self.speed += value
        
    def downSpeed(self, value) : #멤버함수(메서드)
        self.speed -= value

car1 = Car() #객체화
car1.color = "빨강"
car1.speed = 10
car2 = Car() #객체화
car2.color = "파랑"
car2.speed = 0
car3 = Car() #객체화
car3.color = "노랑"
car3.speed = 0

car1.upSpeed(30)
print("자동차 1의 색상은 %s 이며, 현재 속도는 %dkm 입니다." % (car1.color, car1.speed))
car2.upSpeed(60)
print("자동차 2의 색상은 %s 이며, 현재 속도는 %dkm 입니다." % (car2.color, car2.speed))
car3.upSpeed(10)
print("자동차 3의 색상은 %s 이며, 현재 속도는 %dkm 입니다." % (car3.color, car3.speed))

#생성자 구현하기
class Car :
    color="" #멤버변수
    speed=0  #멤버변수
    def __init__(self, v1, v2) : #생성자. 인스턴스메서드이므로 self 변수 필요
        self.color = v1
        self.speed = v2
    def upSpeed(self, value) : #멤버함수(메서드)
        self.speed += value
        
    def downSpeed(self, value) : #멤버함수(메서드)
        self.speed -= value

car1 = Car("빨강",10)
car2 = Car("파랑",0)
car3 = Car("노랑",0)

car1.upSpeed(30)
print("자동차 1의 색상은 %s 이며, 현재 속도는 %dkm 입니다." % (car1.color, car1.speed))
car2.upSpeed(60)
print("자동차 2의 색상은 %s 이며, 현재 속도는 %dkm 입니다." % (car2.color, car2.speed))
car3.upSpeed(10)
print("자동차 3의 색상은 %s 이며, 현재 속도는 %dkm 입니다." % (car3.color, car3.speed))

# 인스턴스변수 : 객체별로 할당된 변수. self.변수명으로 호출
# 클래스변수 : 모든 객체의 공통변수. 클래스명.변수명으로 호출

class Car :
    color="" #자동차색상
    speed=0  #자동차속도
    num=0    #자동차번호
    count=0  #현재까지 생산된 자동차의 갯수
    def __init__(self, v1="", v2=0) :
        self.color=v1 #인스턴스변수
        self.speed=v2 #인스턴스변수
        Car.count += 1 #클래스변수
        self.num = Car.count #인스턴스변수
    def printMessage(self) :
        print("색상:%s, 속도:%dkm, 번호:%d, 생산번호:%d" % \
              (self.color, self.speed, self.num, Car.count))
        
car1 = Car("빨강",10)
car1.printMessage()
car2 = Car("파랑")
car1.printMessage()
car2.printMessage()

# 문제 : Card 클래스 구현하기
#   멤버변수 : kind(카드종류), number(카드숫자), no(카드번호), count(현재까지 생성된 카드 갯수)
#       
#   멤버함수 : printCard()
#   

class Card :
    kind=""
    number=0
    no=0
    count=0
    def __init__(self, v1="Spade",v2=1) :
        self.kind = v1
        self.number = v2
        Card.count += 1
        self.no = Card.count
    def printCard(self) :
        print("kind:%s, number:%d, no:%d, count:%d" % \
              (self.kind, self.number, self.no, Card.count))


card1 = Card()
card1.printCard() #kind:Spade,number:1,no:1,count:1
card2 = Card("Heart")
card2.printCard() #kind:Heart,number:1,no:2,count:2
card3 = Card("Spade",10)
card1.printCard() #kind:Spade,number:1,no:1,count:3
card3.printCard() #kind:Spade,number:10,no:3,count:3
card3.printCard() #kind:Spade,number:10,no:3,count:3

# 상속 : 기존의 클래스를 이용하여 새로운 클래스 생성.
# class 클래스명 (부모클래스1, 부모클래스2, ...)
class Car :   #기본생성자 제공 클래스
    speed=0
    door=3
    def upSpeed(self, v) :
        self.speed += v
        print("현재 속도(부모클래스):%d" % self.speed)
        
# Sedan 클래스 : Car 클래스의 하위 클래스
# class Sedan extends Car {} : Java 방식
class Sedan(Car) :   #기본생성자 제공 클래스
    pass        #실행내용이 없음. Car 클래스의 멤버와 동일
    
# Truck 클래스 : Car 클래스의 하위 클래스
class Truck(Car) :  #기본생성자 제공 클래스
    def upSpeed(self, v) : #오버라이딩 : 부모클래스의 함수를 재정의
        self.speed += v
        if self.speed > 150 :
            self.speed = 150
        print("현재 속도(자손클래스):%d" % self.speed)

car1 = Car()
car1.upSpeed(200) #car1.speed = 200
car2 = Sedan()    #car2.speed = 200
car3 = Truck()    #car3.speed = 150
print("승용차: ", end="")
car2.upSpeed(200)   #Car클래스의 upSpeed() 함수 호출
print("트럭: ", end="")
car3.upSpeed(200)   #Truck클래스의 upSpeed() 함수 호출

3 함수와람다.pdf

0.14MB

5 예외처리.pdf

0.14MB

6 클래스와모듈.pdf

0.28MB