AI교육과정 - Python.3

• 변수 x, y에 대해 x값이 정해지면 그에 따라 y값을 결정하는 것
• 반복적으로 사용되는 가치있는 부분을 묶어서 하나의 집합으로 만듬
• 코드를 재활용하기 위한 목적
• 함수 저장 시 파이썬이 종료되기 전까지 메모리에 남아있어서 무분별한 사용은 지양하는 편이 좋음

1. 이름만 있는 함수

   def 함수명():
       함수가 호출되면 실행할 문장
       ...
   함수명() #호출

2. 매개변수가 있는 함수

   def 함수명(변수1, 변수2, ...):
       함수가 호출되면 실행할 문장
       ...
   함수명(값1, 값2, ...) # 호출

3. 리턴값이 있는 함수

   def 함수명(변수1, 변수2, ...):
       함수가 호출되면 실행할 문장
       ...
       return 값
   변수 = 함수명(값1, 값2, ...) #호출

4. 디폴트 매개변수

   • 호출 시 값이 비어있으면 선언할 때 설정된 값으로 진행

   def 함수명(변수1=값1, 변수2=값2, ...):
       함수가 호출되면 실행할 문장
       ...
       return 값
   변수 = 함수명(값1, 값2, ...) #호출
   변수 = 함수명() # 호출

5. 매개변수의 개수가 가변적인 함수

   • 매개변수는 함수 안에서 튜플 형태로 사용

   def 함수명(*변수):
       함수가 호출되면 실행할 문장
       ...
       return 값
   변수 = 함수명(값1, 값2, ...) #호출
   변수 = 함수명() # 호출

   def func7(*args):
   	  result = 0
   	  print(args) # (10,30,20,70,50)
   	  for i in args:
   		    result += i
   	  return result # 180
   print(func7(10,30,20,70,50))

6. 매개변수를 딕셔너리 구조로 전달받는 함수

   def 함수명(**변수):
       함수가 호출되면 실행할 문장
       ...
       return 값
   변수 = 함수명(변수1=값1,변수2=값2,...) #호출

   def func8(**args):
   	  print(args) # {'userid': 'apple', 'name': '김사과', 'age': 20}
   	  for i in args:
   		    if i== 'userid':
   			      id = args[i]
   	  return id # apple
   user = func8(userid='apple', name='김사과', age=20)

7. 리턴값이 여러개인 함수

   def 함수명(변수1, 변수2, ...):
       함수가 호출되면 실행할 문장
       ...
       return 값1, 값2
   변수1, 변수2, ... = 함수명(변수1, 변수2, ...) # 호출

   • 원하는 리턴 값만 받고 싶을 경우 받지않을 값에 _ 표시

   def func9(num1, num2):
      return num1+num2, num1-num2, num1*num2, num1/num2
   result1, result2, result3, result4 = func9(10, 3)
   # 13 7 30 3.3333333333333335
   _, _, result3, _ = func9(10,3) # 30

콜백함수(Callback function)

• 직접 호출하는 것이 아닌 다른 함수에 의해 호출되는 함수

def callback_func(func):
  for i in range(2):
    func(i)

def print_hello(num):
  print('안녕하세요! 파이썬!', num)
callback_func(print_hello)
# 안녕하세요! 파이썬! 0
# 안녕하세요! 파이썬! 1

람다 함수(lambda function)

• 단일문으로 표현되는 익명 함수
• 코드 상에 한번만 사용되는 기능이 있을 때, 굳이 함수를 만들지 않고 일회성으로 만들어 사용 (함수는 클래스를 통해 생성된 객체)
• return 형

square = lambda x: x ** 2
 print(square(4)) # 16
 (lambda x: x**2)(4) # 16

 data = ['watermelon   ', '      apple     ', '          banana     ', '           melon12345']
 # strip([chars]) : 인자로 전달된 문자를 String의 왼쪽과 오른쪽에서 제거(괄호만 쓰면 공백 제거)
 print(sorted(data, key=lambda string: len(string.strip())))
 #['      apple     ', '          banana     ', 'watermelon   ', '           melon12345']
 # data를 공백 제거한 후의 길이 순으로 배열

filter 함수

• 람다가 유용하게 사용되는 대표적인 함수
• 특정 조건을 만족하는 요소만 남기고 필터링 시킴

num = [1,2,3,4,6,9,10,14,15,18,20]
 num = list(filter(lambda n: n % 2 == 0, num))
 # [2, 4, 6, 10, 14, 18, 20]

map함수

• 각 원소를 주어진 수식에 따라 변형하여 새로운 값을 반환

num = [1,2,3,4,6,9,10,14,15,18,20]
 per = list(map(lambda n : n * 0.01, num))
 # [0.01, 0.02, 0.03, 0.04, 0.06, 0.09, 0.1, 0.14, 0.15, 0.18, 0.2]

scope

• 변수의 접근할 수 있는 범위
• local: 가장 가까운 함수 안의 범위
• global: 함수 바깥의 변수 또는 import된 module

1. locals(): 로컬 변수를 확인하는 함수
2. globals(): 글로벌 변수를 확인하는 함수

num1 = 10 # 글로벌 변수
def func1():
	num2 = 20 # 로컬 변수
	print('num1 로컬 변수: ', 'num1' in locals()) # false
	print('num2 로컬 변수: ', 'num2' in locals()) # true
	print('num1  글로벌 변수: ', 'num1' in globals()) # true

global 키워드

• 함수 내부에서 로컬변수가 아닌 글로벌 변수로 사용하게 함

num1 = 10 # 글로벌 변수
def func4():
	  print(num1)
def func5(num):
	  global num1
	  num1 = num # 로컬 변수

func4() # 10
print(num1) # 5

• 문제를 여러개의 객체 단위로 나눠 작업하는 방식
• 클래스를 이용해 연관있는 처리 부분과 데이터 부분을 하나로 묶어 객체를 생성해 사용함

1. 클래스와 객체

   • 건축 설계도가 클래스라면, 실제로 지어진 집은 객체로 비유
   • 객체는 클래스로 생성되어 구체화된 인스턴스
   • 실제로 클래스가 인스턴스화 되어 메모리에 상주하는 상태를 객체라고 부름
   • 파이썬의 모든 변수는 객체를 저장

2. 클래스 만들기

   class 클래스명:
       def __init__(slef):
           self.필드명1 = 값1
           self.필드명2 = 값2
           ...
   
       def 메소드명(변수1, 변수2, ...):
           메소드가 호출되면 실행할 문장
           ...

   • 생성자는 클래스를 객체화 시킬 때 가장 먼저 실행되는 함수
   • 클래스를 통해 호출되는 변수를 필드라고 부름
   • 클래스를 통해 호출되는 함수를 메소드라고 부름

   🎗 pass

   class Dog:
     pass # 내용이 없는 블록을 만들 때 사용
   def func1():
     pass

   1. 클래스를 통해 객체를 생성

      (객체를 출력할 때 주소값이 찍히는 이유는 toString을 상속받기 때문)

      Rucy = Dog()
      print(Rucy, type(Rucy))
      # <__main__.Dog object at 0x7f2681bafb80> <class '__main__.Dog'>

      • 리스트를 그대로 찍을 경우 toString이 이미 요소를 찍게 재구현되었기 때문에 주소값이 아닌 요소가 출력됨

      li1 = list([1, 2])
      print(li1, type(li1))
      # [1, 2] <class 'list'>

3. 생성자

   • 클래스 인스턴스가 생성될 때 자동으로 호출됨
   • init self(self, 변수1, 변수2, ...)
   • self 매개변수는 항상 첫 번째 오며, 자기 자신의 객체를 가리킴
   • 이름이 꼭 self일 필요는 없지만 관례적으로 self 를 사용
   • 생성자에서는 해당 클래스가 다루는 데이터를 정의하고 초기화함

   class Dog:
     def __init__(self):
       print(self, 'init 호출')
   Rucy = Dog() # <__main__.Dog object at 0x7f2681baf430> init 호출
   print(Rucy) # <__main__.Dog object at 0x7f2681baf430>

   1. 필드값 수정

      class Dog:
        def __init__(self, name, family = '치와와'):
          self.name = name
          self.age = 0
          self.family = family
      budle = Dog('버들이')
      budle.age = 15
      print(budle.name) # 버들이
      print(budle.age) # 15
      print(budle.family) # 치와와

4. 메소드 정의하기

   • 해당 클래스의 객체에서만 호출 가능한 함수
   • 해당 객체의 속성에 대한 연산을 행함
   • 객체이름.메소드명() 형태로 호출됨

   class Counter:
   	  def __init__(self):
   		    self.num = 0
   	  def increment(self):
   		    self.num += 1
   	  def current_value(self):
   		    return self.num
   
   KBbank = Counter()
   print(KBbank.num) # 0
   KBbank.increment()
   
   print(KBbank.num) # 1
   print(KBbank.current_value()) # 1

5. 메소드 타입

   • instance method: 객체 형태로 호출되기 때문에 해당 메소드를 호출한 객체에만 영향을 미침
   • class method: class로 호출(함수 선언 위에 @staticmethod라고 표기)
     • 객체를 생성하지 않기 때문에 메소드 매개변수에 self를 넣지 않음

   class Math:
   	  @staticmethod
   	  def add(x, y):
   		    return x + y
   	  @staticmethod
   	  def multifly(x, y):
   		    return x * y
   
   #math = Math(): 생성자가 필요없음
   result1 = Math.add(10,3) # 13
   result2 = Math.multifly(10,3) # 30

상속

• 기존의 정의해둔 클래스의 기능을 그대로 물려받음
• 기존 클래스에 기능 일부를 추가하거나, 변경하여 새로운 클래스를 정의함
• 코드를 재사용하여 안정적이고 유지보수에 용이하도록 함
• 상속을 받고자 하는 대상인 기존 클래스를 부모, parent, super, base 클래스라고 부름
• 상속을 받는 새로운 클래스는 자식, child, sub 클래스라고 부름

생성자 선언 시 : 자식클래스명(부모클래스명)

# self를 붙이지 않는 경우 단순한 local 변수로 취급됨
class Animal:
	  def __init__(self,name,age):
		    self.name = name
		    self.age = age
	  def eat(self, food):
		    print('{}는(은) {}를 먹습니다.'.format(self.name, food))
class Dog(Animal): # Animal 클래스를 상속받음
	  pass
Rucy = Dog('루시', 13)
Rucy.eat('사료') # 루시는(은) 사료를 먹습니다.

메소드 오버라이딩

• 부모 클래스의 method를 재정의
• 자식 클래스의 인스턴스로 호출 시, 재정의된 메소드가 호출됨

class Animal:
	  def __init__(self,name,age):
		    self.name = name
		    self.age = age
	  def eat(self, food):
		    print('{}는(은) {}를 먹습니다.'.format(self.name, food))
class Dog(Animal):
  def eat(self, food):# 메소드 오버라이딩
    print('{}는(은) {}를 아주 좋아합니다.'.format(self.name, food))
Rucy = Dog('루시', 13)
Rucy.eat('사료') # 루시는(은) 사료를 아주 좋아합니다.

다중 상속

• 파이썬에서는 여러 개의 부모클래스로부터 상속을 받을 수 있음

class Human:
	  def __init__(self,name,age):
		    self.name = name
		    self.age = age
	  def study(self, hour):
		    print('{}는(은) {}시간 동안 공부합니다.'.format(self.name, hour))
class KimApple(Animal, Human):
	  pass
kim = KimApple('김사과', 20)
kim.eat('밥') # 김사과는(은) 밥를 먹습니다
kim.study(4) # 김사과는(은) 4시간 동안 공부합니다.