1. 동기(Synchronous)

동기적인 작업은 순차적으로 실행되며, 한 작업이 끝나야 다음 작업이 시작됩니다.

간단한 비유로 설명하자면, 일을 처리하는데 한 가지 작업이 끝나기를 기다리면서 그때까지 다른 작업을 처리하지 않는 것과 비슷합니다. 대표적으로 함수를 호출하면 해당 함수의 실행이 끝날 때까지 제어가 반환되지 않습니다.

 

def func1():

    print('1')
    print('2')
    print('3')


def main():
    func1()


main()

# 동기는 스택처럼 쌓임
# 호출 호출 호출 >> 맨 끝 함수부터 스택구조로 순차적으로 실행

 

import time

def nagging():
  time.sleep(1)     # 동기함수
  print('🐼')


def main():
  nagging()
  nagging()


print(f"start : {time.strftime('%X')}")
main()
print(f"end : {time.strftime('%X')}")
더보기
start : 13:16:04
🐼
🐼
end : 13:16:06

 

 

2. 비동기(Asynchronous)

비동기적인 작업은 한 작업이 시작되면 바로 다음 작업으로 넘어가며, 작업이 완료되기를 기다리지 않습니다.
이는 주로 이벤트 핸들링, 네트워크 호출, 파일 읽기/쓰기 등의 상황에서 유용합니다.
대표적인 예로 비동기 함수 호출이 있습니다.

# sleep이 동기함수 이므로 asyncio.sleep 비동기용 슬립함수를 사용


import time

import asyncio

# asycn def : 코루틴
async def nagging():        
    await asyncio.sleep(1)  # 비동기 함수
    print('🐼')


async def main():
    await asyncio.gather(
        nagging(),
        nagging()
    )

    
print(f"start : {time.strftime('%X')}")
asyncio.run(main())
print(f"end : {time.strftime('%X')}")

 

await (동기처럼 멈춰주는 역할)

await는 Python에서 비동기 프로그래밍을 할 때 사용되는 키워드로, 주로 async 함수 내에서 다른 비동기 함수의 실행을 기다리는 데에 쓰입니다. await 키워드를 사용하면 현재 실행 중인 코루틴(coroutine)이 다른 코루틴의 완료를 기다리면서 실행을 일시 중단할 수 있습니다. 비동기 함수를 정의할 때는 함수 선언 앞에 async 키워드를 붙이고, 그 안에서 다른 비동기 함수를 호출할 때는 await를 사용합니다. await는 오직 async 함수 내에서만 사용됩니다. 일반적인 동기 함수나 스크립트에서는 사용할 수 없습니다.

 

run()

asyncio.run은 Python의 asyncio 모듈에서 제공하는 함수로, Python 3.7 이후 버전에서 도입되었습니다. 이 함수는 asyncio 이벤트 루프를 생성하고 실행하는 역할을 합니다. 주로 콘솔 스크립트나 간단한 애플리케이션에서 사용됩니다.

asyncio.run(main(), debug=False)
# main(): 실행하고자 하는 비동기 함수입니다. 이 함수는 asyncio 이벤트 루프에서 실행됩니다.
# debug: 선택적 매개변수로, 디버그 모드를 설정합니다. 기본값은 False입니다.

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

20. 변수 타입 어노테이션  (0) 2023.12.13
19. 파이썬 모듈  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12

1. 변수 타입 어노테이션

변수 타입 어노테이션은 파이썬 3.5부터 도입된 기능으로, 변수의 예상 타입을 명시하는데 사용됩니다. 이는 주로 코드의 가독성을 높이고, 정적 타입 검사 도구(예: mypy)를 사용하여 타입 오류를 사전에 잡아내기 위한 목적으로 사용됩니다.

타입 어노테이션은 실제로 변수의 타입을 강제하는 것이 아니라, 개발자가 변수가 어떤 타입을 가져야  것으로 예상하는지 명시하는 것입니다.

 

2. 기본 타입 어노테이션

name : str = '푸바오'
age : int = 3
height : float = 120.5
is_lover : bool = True


print(name)
print(type(name))
더보기
푸바오
<class 'str'>

 

 

3. 리스트, 튜플, 딕셔너리, 세트

컬렉션 타입에 대한 어노테이션은 조금  복잡합니다. 이를 위해 List, Tuple, Dict, Set 등의 제네릭 타입을 사용하게 됩니다. 이러한 타입들은 typing 모듈에서 가져올  있습니다.

from typing import List, Tuple, Dict, Set

names : List[str] = ['푸바오', '루이바오', '후이바오']
age : Tuple[int, int] = (25, 20)
scores : Dict[str, float] = {'푸바오' : 50, '아이바오' : 100}
numbers : Set[int] = {1, 2, 3, 3, 4}


print(names)
print(age)
print(scores)
print(numbers)
더보기
['푸바오', '루이바오', '후이바오']
(25, 20)
{'푸바오': 50, '아이바오': 100}
{1, 2, 3, 4}

 

 

4. 함수

함수의 매개변수와 반환 타입에 대한 어노테이션은 다음과 같이 합니다.

def add(a: int, b: int) -> int: # a는 int, b는 int, 결과(리턴값)는 int 자료형으로 처리
    return a + b
    
print(add(10, 5))
print(add('10','삼'))

print(add.__annotations__) # 타입 어노테이션을 확인
더보기
15
10삼
{'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}

 

 

5. 클래스

클래스 또는 사용자 정의 타입에 대한 어노테이션도 가능합니다.

class Student:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    def __str__(self) -> str:
        return '이름:' + self.name + ', 나이:' + str(self.age)

def print_student(s: Student) -> None:
    print(f"이름:{s.name}, 나이:{s.age}")

student = Student('푸바오', 3)
print(student)
print_student(student)
더보기
이름:푸바오, 나이:3
이름:푸바오, 나이:3

 

 

6. 옵셔널

변수가 특정 타입이거나 None  있는 경우 Optional 사용합니다.

from typing import Optional

def find_score(name : str, scores : Dict[str, float]) -> Optional[float] :
    return scores.get(name)
    
print(find_score('푸바오', {'푸바오':80.5, '대나무':40.5, '아이바오':90.5}))
print(find_score('러바오', {'푸바오':80.5, '대나무':40.5, '아이바오':90.5}))
더보기
80.5
None

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

21. 파이썬 동기/비동기  (0) 2023.12.13
19. 파이썬 모듈  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12

1. 모듈

파이썬에서 모듈을 만들려면 간단히 .py 확장자를 가진 파일에 코드를 작성하면 됩니다. 모듈은 단순한 함수 뿐만 아니라 변수, 클래스 등도 포함할  있으며, 다른 스크립트에서 import 구문을 사용하여 가져올  있습니다.

 

 

 

 math_tools.py

# 변수

PI = 3.141592


# 함수

def add(a, b):
return a + b


def subtract(a, b):
return a - b


# 클래스
class Circle:
def __init__(self, radius):
self.radius = radius


def area(self):
return PI * self.radius * self.radius

.

 

구글 드라이브 마운트해서 사용하기

→ 구글드라이브에 math_tools.py 업로드 후 경로지정

path = '/content/drive/MyDrive/컴퓨터비전 시즌1/1.파이썬 기초/module/'

import sys
sys.path.append(path)
import math_tools
 

 

# 모듈 내의 변수
print(math_tools.PI)
더보기
3.141592653589793
# 모듈 내의 함수
print(math_tools.add(5,3))
print(math_tools.subtract(5,3))
# 모듈 내의 클래스
circle = math_tools.Circle(5)
print(circle.area())
더보기
78.53981633974483
# 필요한 속성, 클래스만 가져오기
from math_tools import PI, Circle

print(PI)
circle = Circle(5)
print(circle.area())
더보기
3.141592653589793
78.53981633974483
import math_tools as mt

# 모듈 내의 함수 사용
print(mt.add(5, 3))  # 8
print(mt.subtract(5, 3))  # 2

# 모듈 내의 클래스 사용
circle = mt.Circle(5)
print(circle.area())
더보기
8
2
78.53981633974483

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

21. 파이썬 동기/비동기  (0) 2023.12.13
20. 변수 타입 어노테이션  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12

1. 예외

예외(Exception) 프로그램 실행  발생할  있는 예상치 못한 문제 또는 오류 상황을 의미합니다. 예외가 발생하면 프로그램은 중단되기 때문에 이를 적절하게 처리하여 중단을 방지하거나 오류에 대한 정보를 사용자에게 제공해야 합니다.

 

2. 예외가 발생하는 경우

  • ValueError
    • 잘못된 값을 함수나 연산에 제공할 때 발생합니다.
    • 예) 숫자가 아닌 문자열을 int() 함수로 변환하려고 할 때 발생.
  • TypeError
    • 올바르지 않은 유형의 객체를 연산에 사용하려 할 때 발생합니다.
    • 예) 문자열과 숫자를 함께 더하려고 할 때 발생.
  • ZeroDivisionError
    • 숫자를 0으로 나누려고 할 때 발생합니다.
  • IndexError
    • 리스트, 튜플, 문자열 등의 시퀀스 유형에서 범위를 벗어난 인덱스에 접근하려 할 때 발생합니다.
    • 예) 길이가 3인 리스트에 대해 4번째 요소에 접근하려고 할 때 발생.
  • KeyError
    • 딕셔너리에서 존재하지 않는 키를 사용하여 값을 검색하려고 할 때 발생합니다.
  • AttributeError
    • 객체에 없는 속성이나 메서드에 접근하려고 할 때 발생합니다.
  • FileNotFoundError
    • 존재하지 않는 파일을 열려고 할 때 발생합니다.
  • ImportError
    • 존재하지 않는 모듈을 가져오려고 할 때 또는 모듈 내에 해당 속성/함수가 없을 때 발생합니다.
  • NameError
    • 정의되지 않은 변수나 함수를 사용하려고 할 때 발생합니다.
    • 예) 프로그램에서 정의되지 않은 변수 x를 사용하려고 할 때 발생.
  • OverflowError
    • 수치 연산 결과가 너무 커서 표현할 수 없을 때 발생합니다.
  • MemoryError
    • 프로그램이 사용 가능한 모든 메모리를 소진했을 때 발생합니다.

 

3. 예외 처리 기본 구조

try:
    # 예외가 발생할 가능성이 있는 코드
    
except ExceptionType1:  # 'ExceptionType1'에는 실제 예외 유형이 들어갑니다.
    # ExceptionType1 예외가 발생했을 때 실행될 코드
    
except ExceptionType2:  # 'ExceptionType2'에는 다른 예외 유형이 들어갑니다.
    # ExceptionType2 예외가 발생했을 때 실행될 코드
    
# 추가적인 except 블록을 계속 추가할 수 있습니다.

else:
    # try 블록에서 예외가 발생하지 않았을 때 실행될 코드
    
finally:
    # 예외 발생 여부와 관계없이 항상 실행될 코드

 

 

예시1)

# 에러코드 확인

print(10 / 3)
print(5 / 0)
print(4 / 2)



3.3333333333333335
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-1-9c5e3ff0ad94> in <cell line: 2>()
      1 print(10 / 3)
----> 2 print(5 / 0)
      3 print(4 / 2)

ZeroDivisionError: division by zero

 

 

# 특정 예외 처리

try:
    print(10 / 3)
    print(5 / 0)    #ZeroDivisionError: division by zero
    print(4 / 2)
except ZeroDivisionError :
    print('0으로 나눌 수 없습니다.')
print('프로그램 종료')
더보기
3.3333333333333335
0으로 나눌 수 없습니다.
프로그램 종료

 

# 모든 예외처리 

try:
    print(10 / 3)
    print(5 / 0)
    print(4 / 2)
except :
    print('0으로 나눌 수 없습니다.')
print('프로그램 종료')
더보기
3.3333333333333335
0으로 나눌 수 없습니다.
프로그램 종료

 

 

 

예시2)

# 에러 코드 확인

data = [10, 20, 30, 40, 50]
print(data[5])


---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-4-879de49a30d4> in <cell line: 2>()
      1 data = [10, 20, 30, 40, 50]
----> 2 print(data[5])

IndexError: list index out of range

 

# 모든 예외 처리

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except:
    print('인덱스 지정 잘못됨')
print('종료')
더보기
10
인덱스 지정 잘못됨
종료

# 특정 예외 처리

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except IndexError:
    print('인덱스 지정 잘못됨')
print('종료')
더보기
10
인덱스 지정 잘못됨
종료

 

 

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(int('일'))
    print(5/0)
    print(data[5])
    print()
    print(data[3]) #IndexError: list index out of range
except IndexError :
    print('인덱스 지정 잘못됨')
except ZeroDivisionError:
    print('0으로 나눌 수 없음')
except:                     # 전체예외처리는 마지막에 써야함
    print('오류처리')
print('종료')
더보기
10
오류처리
종료

 

  • except:만 사용: 하면 프로그램 종료나 키보드 중단과 같은 특수한 예외까지 처리할 수 있지만, 대부분의 상황에서 이렇게 예외 처리는 권장되지 않습니다.
  • except Exception as e:는 일반적인 예외만 처리하면서, 발생한 예외의 상세 정보에 접근할 수 있는 능력을 제공합니다. 이 형태를 사용하면 더 명시적이며 예외 처리가 더 예측 가능해집니다.

 

 

# 예외 에러 메세지 받기

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(5/0)
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except IndexError as e:
    print(e)
except ZeroDivisionError as e:
    print(e)
except Exception as e:                # 전체예외처리는 마지막에 써야함
    print(e)
print('종료')
더보기
output
10
division by zero
종료

# 예외가 발생하지 않았을 경우

try:
    data = [10, 20, 30, 40, 50]
    string = '오늘은 즐거운 예외처리 시간!'
    print(10 / 3)
    print(4 / 2)
except ZeroDivisionError as e:
    print('0으로 나눌 수 없습니다', e)
except IndexError as e:
    print('인덱스 지정이 올바르지 않습니다', e)
except TypeError as e:
    print('데이터 타입이 올바르지 않습니다', e)
else:
    print('정상적인 프로그램 진행')
print('프로그램을 종료합니다')
더보기
3.3333333333333335
2.0
정상적인 프로그램 진행
프로그램을 종료합니다

 

# 예외 발생 여부와 관계없이 실행하기

try:
    data = [10, 20, 30, 40, 50]
    print(data[0])
    print(5/0)
    print(data[5])
    print(data[3]) #IndexError: list index out of range
except IndexError as e:
    print(e)
except ZeroDivisionError as e:
    print(e)
except Exception as e:                # 전체예외처리는 마지막에 써야함
    print(e)
else:
    print('정상적인 프로그램 실행')
finally:
    print('오류에 관계없이 무조건 실행되는 문장')
print('종료')
더보기
10
division by zero
오류에 관계없이 무조건 실행되는 문장
종료

 

 

 

4. Exception 클래스

Exception 클래스는 파이썬의 내장 예외 계층 구조에서 거의 모든 내장 예외의 기본 클래스입니다. 이 클래스는 사용자 정의 예외를 만들거나 특정 예외 유형을 잡기 위한 기본적인 인터페이스를 제공합니다.

  1. 상속: 예외 유형은 Exception을 상속받아서 정의됩니다. 예를 들면 ValueError, TypeError, FileNotFoundError 등이 있습니다. 이 상속 구조 덕분에 except Exception 블록은 Exception을 상속받은 모든 예외를 캡처할 수 있습니다.
  2. 메시지: 예외가 생성될 때, 일반적으로 오류 메시지를 함께 전달할 수 있습니다. 이 메시지는 예외 객체의 args 속성을 통해 접근 가능하며, 예외를 문자열로 변환할 때(예: str(e)) 해당 메시지가 반환됩니다.

 

try:
    raise Exception('에러가 발생') # raise 에러를 내는 코드
except Exception as e:
    print(e)
def func1():
    n = int(input('짝수 입력 : '))
    if n % 2 != 0:
        raise Exception('짝수가 아닙니다.') # raise를 통해서 에러가 발생하게 만듬
    print(n)

try:
    func1()
except Exception as e:
    print('예외가 발생했습니다.')
더보기
짝수 입력 : 11
예외가 발생했습니다.
def func1():
    func2()

def func2():
    func3()

def func3():
    try:
        print('%d' % '문자열 출력')
    except TypeError:
        print('타입이 올바르지 않음')

func1()
# 리턴받기 전까지만 오류처리를 해주면됨
더보기
타입이 올바르지 않음

 

 

 

5. 사용자 정의 예외 클래스를 직접 만들고 활용하기

class AgeLimitError(Exception):
    def __init__(self, age, message ='원하는 나이 범위가 아님~'):
        self.age = age
        super().__init__(message) # 부모클래스 생성자에 메세지전달
        
def check_age(age):
    if age < 20:
        raise AgeLimitError(age, '어림')
    elif age > 40:
        raise AgeLimitError(age ,'늙음')
    else:
        return('적당')
        
ages = [17, 25, 43, 19]

for age in ages:
    try:
        print(check_age(age))
    except AgeLimitError as e:
        print(f"Error for age {e.age}: {e}")
더보기
Error for age 17: 어림
적당
Error for age 43: 늙음
Error for age 19: 어림

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

20. 변수 타입 어노테이션  (0) 2023.12.13
19. 파이썬 모듈  (0) 2023.12.13
17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11

1. 스페셜 메서드

파이썬의 스페셜 메서드 (또는 매직 메서드라고도 불림)는 더블 언더스코어(__)로 시작하고 끝나는 메서드 이름을 갖습니다. 이 메서드들은 특정 구문이나 내장 함수를 사용할 때 파이썬 인터프리터에 의해 자동으로 호출됩니다.

예를 들어, 객체에 대해 + 연산자를 사용하면 해당 객체의 __add__ 메서드가 호출됩니다. 또는 len() 함수를 사용하면 __len__ 메서드가 호출됩니다.

 

 

1. __init__ : 객체 초기화 메서드

2. __str__ : 객체를 문자열로 표현하는 메서드. print() 함수나 str() 함수를 사용할  호출됩니다.

class Book:
    def __init__(self, title):
        self.title = title

book = Book('파이썬')
print(book)
print(str(book))
더보기
<__main__.Book object at 0x7b6b4b2ecc10>
<__main__.Book object at 0x7b6b4b2ecc10>

 

class Book:
    def __init__(self, title):
        self.title = title

    def __str__(self):
        return self.title
        
book = Book('파이썬')
print(book)
print(str(book))
더보기
파이썬
파이썬

 

 

3. __add__ : + 연산자를 사용할  호출되는 메서드

class Calc:
    def __init__(self, value):
        self.value = value

    def __add__(self, other): # other : 다른객체
        return self.value + other.value

num1 = Calc(5)
num2 = Calc(10)
result = num1 + num2
print(result)
# 덧셈 오버라이딩

 

4. __len__ : len() 함수를 사용할  호출되는 메서드

class Queue:
    def __init__(self):
        self.items = [1, 2, 3, 4, 5]

    def __len__(self):
        return len(self.items) #len()
        
        
queue = Queue()
print(len(queue))

 

 

5. __getitem__ : 인덱싱을 사용할  호출되는 메서드

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            return -1

p1 = Point(3, 4)
print(p1[0], p1[1], p1[100])
더보기
3 4 -1

 

6. __call__ : 객체를 함수처럼 호출할  사용되는 메서드

class CallableObject:
    def __call__(self, *args, **kwargs):
        print(f"Called with arguments: {args} and keyword arguments: {kwargs}")

callable_obj = CallableObject()
callable_obj(1, 2, 3, a="A", b="B")
더보기
Called with arguments: (1, 2, 3) and keyword arguments: {'a': 'A', 'b': 'B'}

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

19. 파이썬 모듈  (0) 2023.12.13
18. 파이썬 예외처리  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11
14. 콜백함수와 람다함수  (1) 2023.12.11

1. 상속

파이썬에서 상속은  클래스의 속성과 메서드를 다른 클래스에 전달하는 기능을 의미합니다. 상속을 사용하면 기존의 코드를 재사용하고 확장할  있습니다. 기본적으로 파이썬의 모든 클래스는 object라는 기본 클래스로부터 상속받습니다.

 

기본 클래스 (또는 부모 클래스): 상속의 출발점이 되는 클래스입니다.

파생 클래스 (또는 자식 클래스): 상속을 통해 속성과 메서드를 받는 클래스입니다.

 

 

class Parent:
    pass

class Child(Parent):
    pass

 

 

class Animal:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def eat(self, food):
            print(f'{self.name}는 {food}를 먹습니다.')

        def sleep(self, hour):
            print(f'{self.name}는 {hour}시간 동안 잠을 잡니다.')


animal = Animal('푸바오', 10) #객체 생성
animal.eat('대나무')
animal.sleep(10)
더보기
animal = Animal('푸바오', 10) #객체 생성
animal.eat('대나무')
animal.sleep(10)
class Bear(Animal): # Animal 클래스를 상속
    pass
    
    
    
# Animal 클래스를 상속 받았기 때문에
# Animal 클래스의 생성자 매개변수(name, age)를 전달해야 한다.
#hui = Bear()

hui = Bear('후이바오', 1)
hui.eat('분유')
hui.sleep(10)
더보기
후이바오는 분유를 먹습니다.
후이바오는 10시간 동안 잠을 잡니다.

 

 

2. 클래스 상속 시 생성자 호출 순서

1. 자식 클래스(child class)의 생성자가 호출됩니다.
2. 자식 클래스의 생성자에서 부모 클래스(parent class)의 생성자를 호출해야 합니다. 이를 위해 super() 함수를 사용합니다. super() 함수는 현재 클래스의 부모 클래스를 참조하며, 부모 클래스의 생성자를 호출할 수 있습니다.
3. 부모 클래스의 생성자가 호출됩니다.
4. 부모 클래스의 생성자가 실행을 마치면 자식 클래스의 생성자로 돌아가 자식 클래스의 생성자 코드가 실행됩니다.

 

class Parent:
    def __init__(self):
        print('부모 클래스의 생성자 호출')

class Child(Parent):
    def __init__(self):
        print('Child 클래스 생성자 호출')
        super().__init__()              # super<-부모 클래스/ 부모 클래스의 생성자를 호출
        print('자식 클래스 생성자 호출')
        
        
child = Child()
더보기
Child 클래스 생성자 호출
부모 클래스의 생성자 호출
자식 클래스 생성자 호출

 

3. ※ Object 클래스

object는 파이썬의 모든 클래스의 기본 클래스입니다. object 클래스는 파이썬에서 모든 객체의 기본적인 동작과 특성을 정의합니다.

class MyClass:
    pass
# 위 클래스는 아래 클래스와 동일
class MyClass(object):
    pass

 

 

4. 메서드 오버라이딩

메서드 오버라이딩(Method Overriding)은 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 서브 클래스(자식 클래스)에서 슈퍼 클래스(부모 클래스)의 메서드를 재정의하는 것을 의미합니다. 오버라이딩을 사용하면, 서브 클래스에서 상속받은 메서드의 동작을 변경하거나 확장할 수 있습니다.

 

#부모 클래스
class Animal:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def eat(self, food):
            print(f'{self.name}는 {food}를 먹습니다.')

        def sleep(self, hour):
            print(f'{self.name}는 {hour}시간 동안 잠을 잡니다.')
            
#자식 클래스
class Bear(Animal):
    def run(self):
        print(f'{self.name}은/는 달립니다.')

    def eat(self, food):
        print(f'{self.name}은/는 {food}를 많이 먹습니다.')

    def superEat(self, food):
        super().eat(food)            
        
        
        
Fubao = Animal('Fubao', 3) #부모 클래스
Fubao.eat('대나무')		#부모 클래스 eat
Fubao.sleep(10)        	   #부모 클래스 sleep

Lebao = Bear('러바오', 13)
Lebao.eat('대나무') # 자식클래스의 eat이 출력
Lebao.run()			
Lebao.sleep(10)		 
Lebao.superEat('당근') #부모것을 호출
더보기
Fubao는 대나무를 먹습니다.
Fubao는 10시간 동안 잠을 잡니다.


러바오은/는 대나무를 많이 먹습니다.
러바오은/는 달립니다.
러바오는 10시간 동안 잠을 잡니다.
러바오는 당근를 먹습니다.
animal = Animal('판다', 10)
# 부모 클래스는 자식 클래스를 알 수 없음.
# 자식 클래스의 객체 메서드를 사용하지 못함
animal.eat('사과')
#animal.run() 
#AttributeError: 'Animal' object has no attribute 'run'

 

 

5. ※ super() 메소드

super()는 파이썬의 내장 함수로서, 상속과 관련된 작업을 수행할 때 사용됩니다. 특히, 자식 클래스에서 부모 클래스의 메서드를 호출할 때 사용됩니다. super()의 주요 목적은 자식 클래스에서 부모 클래스의 메서드를 오버라이드(재정의)하면서도 그 오버라이드된 메서드 내에서 부모 클래스의 원본 메서드를 호출하는 것입니다.

 

5-1. 기본적인 사용

class Parent:
    def hello(self):
        print('부모클래스의 hello 메서드')
        
class Child(Parent):
    def hello(self):
        super().hello()
        print('자식클래스의 hello 메서드')
        
        
c = Child() #자식객체 생성
c.hello()
더보기
부모클래스의 hello 메서드
자식클래스의 hello 메서드

 

 

5-2. __init__메서드의 사용

class Parent:
    def __init__(self, value):
        self.value = value
        
class Child(Parent):
    def __init__(self, value, child_value):
        super().__init__(value)
        self.child_value = child_value        
        

c = Child(10, 20)
print(c.value)      #10
print(c.child_value)#20

 

5-3. 다중상속의 문제

class Base:
    def hello(self):
        print('Base 클래스의 hello 메서드 호출')

class A(Base):
    def hello(self):
        super().hello()
        print('A클래스의 hello 메서드 호출')

class B(Base):
    def hello(self):
        super().hello()
        print('B클래스의 hello 메서드 호출')

class Child(A,B):
    def hello(self):
        super().hello()
        print('Child 클래스의 hello 메서드 호출')
Child.mro()
#Base가 최상
#왼쪽 A
#오른쪽 B
#맨아래 Child
더보기
[__main__.Child, __main__.A, __main__.B, __main__.Base, object]
c = Child()
c.hello()
더보기
Base 클래스의 hello 메서드 호출
B클래스의 hello 메서드 호출
A클래스의 hello 메서드 호출
Child 클래스의 hello 메서드 호출

 

순서 : Base → B →  A → Child

 

6. 다중 상속

다중 상속은 클래스가 둘 이상의 부모 클래스로부터 상속을 받는 기능을 의미합니다. 파이썬은 다른 많은 객체 지향 언어와 달리 다중 상속을 지원합니다. 다중 상속을 사용하면 코드의 재사용성을 향상시킬 수 있지만, 동시에 복잡성이 높아지기 때문에 주의해야 합니다.

 

#부모 클래스
class Animal:
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def eat(self, food):
            print(f'{self.name}는 {food}를 먹습니다.')

        def sleep(self, hour):
            print(f'{self.name}는 {hour}시간 동안 잠을 잡니다.')
            
class Human:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self, hour):
        print(f'{self.name}는 {hour}시간 동안 공부를 합니다.')
 
 
 
class Fubao(Animal, Human): # 두 클래스의 기능을 상속받아 두개의 기능을 사용가능
    pass 
    
    
Fu = Fubao('푸바오', 20)
Fu.eat('대나무')
Fu.study(2)

# 다이아몬드 문제 발생시 메서드가 실행되는 순서
Fubao.mro()

#[__main__.Fubao, > __main__.Animal,> __main__.Human,> object]
#Fubao가 다이아모양중 맨 아래
더보기
푸바오는 대나무를 먹습니다.
푸바오는 2시간 동안 공부를 합니다.
[__main__.Fubao, __main__.Animal, __main__.Human, object]

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

18. 파이썬 예외처리  (0) 2023.12.12
17. 스페셜 메서드  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11
14. 콜백함수와 람다함수  (1) 2023.12.11
13. 변수의 범위  (1) 2023.12.11

1. 객체지향 프로그래밍

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 소프트웨어를 설계하고 구현하는 데 사용되는 중요한 프로그래밍 패러다임 중 하나입니다. 이 패러다임은 프로그램을 "객체"라고 불리는 독립적인 개체로 나누고, 이러한 객체들 간의 상호작용을 통해 프로그램을 구성하는 개발 방법론입니다.

 

절차지향 프로그래밍

  • 절차지향프로그래밍은 프로그램을 작성할 때 일련의 절차 또는 단계에 따라 코드를 구성하는 방식입니다. 이러한 단계나 절차들은 주로 함수나 서브루틴으로 나누어져 있으며, 각각의 함수는 특정한 작업을 수행합니다. 주로 '입력 - 처리 - 출력'의 순차적인 절차를 따르며, 코드를 위에서부터 아래로 실행하면서 데이터를 처리하는 방식으로 동작합니다. C 언어와 같은 프로그래밍 언어는 주로 절차지향적인 스타일을 따릅니다.

함수형 프로그래밍

  • 함수형프로그래밍은 함수(function)를 가장 중요하게 취급하여 프로그램을 작성하는 패러다임입니다. 함수는 다른 함수에 전달되거나 반환될 수 있으며, 함수들 간의 조합을 통해 복잡한 작업을 수행합니다. 상태를 변경하지 않고 데이터를 처리하고, 부작용(side effect)을 최소화하려는 노력이 있습니다. 함수형 언어로는 Haskell, Lisp, Clojure 등이 있으며, 몇몇 다른 언어들도 함수형 프로그래밍을 지원합니다. 함수형 프로그래밍은 병렬처리와 상태 관리에 용이하며, 함수들을 조합하여 간결하고 안정적인 코드를 작성하는데 도움이 됩니다.

 

 

2. 클래스 만들기

class 클래스이름:
    # 클래스 속성(멤버 변수) 정의
    속성1 = 초기값1
    속성2 = 초기값2

    # 생성자 메서드 (생략 가능)
    def __init__(self, 매개변수1, 매개변수2, ...):
        # 인스턴스 속성 초기화
        self.속성1 = 매개변수1
        self.속성2 = 매개변수2

    # 메서드(멤버 함수) 정의
    def 메서드1(self, 매개변수1, 매개변수2, ...):
        # 메서드 동작 정의
        pass

    def 메서드2(self, 매개변수1, 매개변수2, ...):
        # 메서드 동작 정의
        pass

 

3. 객체(인스턴스) 생성

Rucy = Dog() # Rucy라는 강아지이름에 Dog()클래스 이름을 작성
print(Rucy)
print(type(Rucy))
PPomi = Dog()
print(PPomi)
print(type(PPomi))

 

 

4. 객체 속성 초기화

객체를 생성한 후에는 객체의 속성을 초기화할 수 있습니다. 이를 위해 . 연산자를 사용하여 객체의 속성에 접근하고 값을 할당합니다.

 

class Dog :
# 변수 초기화(기본값)
  name = ''
  age = 0
  family = ''

#메소드
#self는 자기자신을 나타내는 객체

  def eat(self) : # 첫 파라미터에는 self를 항상 넣어야함 // 파라미터가 없을때도 self를 넣어야함
      print('사료를 먹습니다.')
      
Rucy = Dog()
Rucy.name = '루시'
Rucy.age = 14
Rucy.family = '포메'


PPomi = Dog()
PPomi.name = '뽀미'
PPomi.age = 7
PPomi.family = '폼피츠'



print(Rucy.name)
print(Rucy.age)
print(Rucy.family)

print(PPomi.name)
print(PPomi.age)
print(PPomi.family)
더보기
루시
14
포메
뽀미
7
폼피츠

 

5. 객체 메서드 호출

객체의 메서드를 호출하려면 객체와 메서드를 . 연산자를 사용하여 호출합니다.

Rucy.eat()
PPomi.eat()
더보기
사료를 먹습니다.
사료를 먹습니다.

 

6. 생성자

파이썬에서 생성자(Constructor) 클래스의 인스턴스가 생성될  자동으로 호출되는 특별한 메서드입니다. 생성자는 객체의 초기화를 담당하며, 객체가 생성될  필요한 속성을 초기화하고 설정하는 역할을 합니다. 파이썬에서 생성자 메서드는 __init__라고 이름이 정해져 있습니다.

class 클래스이름:
    def __init__(self, 매개변수1, 매개변수2):
        self.속성1 = 매개변수1
        self.속성2 = 매개변수2

 

 

 

class Dog :
# 생성자 (메소드)
    def __init__(self): ## 첫 파라미터에는 self // self 자기자신
      print(self, 'init 호출!')
      
Rucy = Dog()
더보기
<__main__.Dog object at 0x7b56e7e651e0> init 호출!

 

 

 

class Dog:
  def __init__(self):
    self.name = ''
    self.age = 0
    #a = 10 # 일반 변수를 만들면 다른 메소드에서 가져다 쓸 수없다 
    # => self를 이용해 어디 출신의 속성인지 알기위해 사용
Rucy = Dog()
print(Rucy)
print(Rucy.name)
print(Rucy.age)
더보기
<__main__.Dog object at 0x7b56e7e65150>

0

 

 

 

 

class Dog:
  def __init__(self, name, age, family='족보 없음'): #생성자(self, 매개변수1, 매개변수2, ...)
    self.name = name
    self.age = age
    self.family = family
    
    
Rucy = Dog('루시', 14, '포메')
print(Rucy.name)
print(Rucy.age)
print(Rucy.family)    


PPomi = Dog('뽀미', 7)
print(PPomi.name)
print(PPomi.age)
print(PPomi.family)
더보기
루시
14
포메

뽀미
7
족보 없음

 

 

 

7. 메서드

메서드(Method)는 객체지향 프로그래밍(OOP)에서 사용되는 함수와 비슷한 개념이지만, 클래스 내부에 정의되어 특정 객체에 연결된 함수입니다. 메서드는 해당 클래스의 모든 객체에서 공유되며, 객체의 동작을 정의하거나 특정 작업을 수행하는 데 사용됩니다.

 

 

7-1. 메서드 정의

class Counter:
  # 생성자
  def __init__(self) :
    self.num = 0
  # 메서드
  def increment(self):
    self.num += 1
  def decrement(self):
    self.num -= 1
  def current_value(self):
    return self.num
  def reset(self):
    self.num = 0
# 현재 num의 값을 출력 (단 num 출력시 method로 출력)
# num의 값을 1증가
# num의 값을 1증가
# num의 값을 1증가
# num의 값을 1감소    #메소드 생성
# 현재 num의 값을 출력 #메소드 생성

KBbank = Counter()  # 현재 값 = 0

KBbank.increment()  # num 1증가
KBbank.increment()
KBbank.increment()
KBbank.decrement()  # num 1감소


print(f'현재 대기인원 : {KBbank.current_value()}') # 출력
더보기
현재 대기인원 : 2
HanaBank = Counter() # 현재 값
print(f'현재 대기인원 : {HanaBank.current_value()}')

HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.increment()  # num +1 증가
HanaBank.decrement()  # num -1 감소
print(f'현재 대기인원 : {HanaBank.current_value()}') #카운터 값 출력


HanaBank.reset() # 카운터값 리셋
print(f'현재 대기인원 : {HanaBank.current_value()}') # 출력 : 0
더보기
현재 대기인원 : 0
현재 대기인원 : 5
현재 대기인원 : 0

 

 

 

7-2. 메서드 타입

  • 인스턴스 메서드(Instance Method) : 객체의 상태를 조작하거나 객체에 특정 작업을 수행하는 메서드입니다. 대부분의 클래스 내부의 메서드는 인스턴스 메서드입니다. 위의 예제에서 보여진 _init_ 메서드도 인스턴스 메서드입니다.
  • 클래스 메서드(Class Method) : 클래스 레벨에서 동작하며, 모든 인스턴스가 공유하는 메서드입니다. 클래스 메서드는 @classmethod 데코레이터를 사용하여 정의하며, 첫 번째 매개변수로 cls를 사용합니다.
  • 정적 메서드(Static Method) : 특정 클래스나 인스턴스와 관련이 없는 메서드로, 클래스 내부에 정의되어 있지만 클래스나 인스턴스와 독립적으로 호출될 수 있습니다. 정적 메서드는 @staticmethod 데코레이터를 사용하여 정의합니다.

 

class Math:
  def add(self, x, y):
    return x + y
  def multiply(self, x, y):
    return x * y
    

math = Math()

result1 = math.add(10, 3)
print(result1)
result2 = math.multiply(10, 3)
print(result2)
더보기
13
30

 

 

class Calculater:

  num = 1 # 클래스 변수 (클래스 내부에 들어있음) : 객체를 생성하지 않아도 메모리에 올라감

  def add(self, x, y):
    return x + y

  @classmethod
  def subtract(cls, x, y):
    return x - y - cls.num  # cls : 클래스 변수(num)을 가져다가 씀

  @staticmethod       #인스턴스 메소드 -> 객체생성 해야함
  def multiply(x, y):
    return x * y
# 인스턴스 메서드
# 인스턴스 메서드는 객체를 생성해야만 사용가능
calc = Calculater()   #객체 생성
result1 = calc.add(5, 3)
print(result1)

# 클래스 메서드
# 객체를 생성할 필요가 없음
# 클래스명으로 호출
result2 = Calculater.subtract(10, 4) # 10 - 4 - cls.num(클래스변수)
print(result2)

# 정적 메서드
# 클래스 명으로 호출가능
# 클래스 명으로 불러올 수 있으나 주변속성을 갖다 쓸 수 없음(독립적임)
result3 = Calculater.multiply(5, 3)
print(result3)
더보기
8
5
15

 

8. ※ 클로저

클로저(Closure)는 프로그래밍 언어에서 중요한 개념 중 하나로, 함수와 그 함수가 참조하는 외부 변수(또는 자유 변수) 사이의 관계를 나타냅니다. 클로저는 함수의 내부에서 정의된 함수로, 내부 함수가 외부 함수의 변수에 접근할 수 있고, 외부 함수는 내부 함수를 반환할 수 있습니다. 이로 인해 함수와 그 함수가 참조하는 상태(변수)를 함께 저장하고 유지할 수 있습니다.

 

 

#함수가 함수를 리턴할 수 있다.

 

def mul2(n):
    return n * 2

print(mul2(10))
print(mul2(5))
더보기
20
10
def mul5(n):
    return n * 5

print(mul5(10))
print(mul5(5))
더보기
50
25

 

 

class Mul:
  def __init__(self, m):
    self.m = m
  def mul(self, n):
    return self.m * n
    
    
mul2 = Mul(2)
print(mul2.mul(10))
print(mul2.mul(5))
더보기
20
10

 

 

class Mul:
    def __init__(self, m):  # 객체를 생성할 때 자동으로 호출
        print('생성자 호출')
        self.m = m

    def __call__(self, n):  # 객체를 실행할 때 자동으로 호출
        print('call 호출')
        return self.m * n


mul2 = Mul(2)
mul2(10)
더보기
생성자 호출
call 호출
20

 

 

 

# 클로저 사용하기

#클로저 서용하기
def mul(m):       #외부함수
  def wrapper(n): #내부함수(클로저)
    return m * n
  return wrapper #함수안에 함수 바깥쪽 함수에 의해서 내부함수 리턴
  
  
mul2 = mul(2)   # m = 2인 wrapper 함수가 mul2에 저장
print(mul2(10)) # m = 2, n = 10인 wrapper 함수가 실행

mul5= mul(5)
print(mul5(10))
더보기
20
50

 

 

9. ※ 데코레이터

데코레이터(Decorator)는 파이썬에서 함수나 메서드의 동작을 수정하거나 확장하기 위한 강력한 도구입니다. 데코레이터는 함수나 메서드를 래핑하거나 감싸서 추가 기능을 제공하며, 코드 재사용성과 가독성을 향상시킵니다. 데코레이터는 @ 기호를 사용하여 함수나 메서드 위에 적용됩니다.

 

# 데코레이터 만들기
def func1(a,b):
    result = a + b
    return result

def func2(a, b):
    result = a * b
    return result

def elapsed(func):
    def wrapper(a, b):
          start = time.time()
          print('함수가 시작되었습니다.')

          result = func(a, b) # elapsed(func)에 전달 받은 함수의 결과를 전달

          end = time.time()
          print(f'함수 수행시간{end - start}')
          return result
    return wrapper    
    
    
deco1 = elapsed(func1)
result = deco1(10, 3)
print(result)


deco2 = elapsed(func2)
result = deco2(10, 3)
print(result)
더보기
함수가 시작되었습니다.
함수 수행시간8.082389831542969e-05
13
함수가 시작되었습니다.
함수 수행시간2.6702880859375e-05
30

 

@elapsed #클로저 이름
def func1(a,b):
    result = a + b
    return result

@elapsed
def func2(a, b):
    result = a * b
    return result
result = func1(10, 3)
print(result)

result = func2(10, 3)
print(result)
더보기
함수가 시작되었습니다.
함수 수행시간0.0002522468566894531
13
함수가 시작되었습니다.
함수 수행시간0.00047206878662109375
30

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

17. 스페셜 메서드  (0) 2023.12.12
16. 파이썬 상속  (0) 2023.12.12
14. 콜백함수와 람다함수  (1) 2023.12.11
13. 변수의 범위  (1) 2023.12.11
12. 사용자 정의 함수  (1) 2023.12.10

1. 콜백함수(callback function)

콜백 함수는 다른 함수에 인자로 전달되어, 어떤 이벤트나 특정 조건에서 실행되게 되는 함수를 말합니다. 콜백 함수는 주로 비동기 작업이나 특정 이벤트 발생 시점에 어떤 동작을 수행할 때 사용됩니다.

  • 이벤트 기반 프로그래밍: 많은 이벤트 기반 프로그래밍 환경에서는 이벤트 발생 시점에 콜백 함수를 실행하여 사용자에게 알리거나 특정 동작을 수행합니다.
  • 비동기 작업: 특히 비동기 처리를 할 때, 작업의 완료나 실패 시점에 콜백 함수를 실행하여 결과를 반환하거나 오류를 처리합니다.
  • 코드의 유연성: 콜백 함수를 사용하면 함수나 클래스의 코드를 변경하지 않고도 동작을 확장하거나 수정할 수 있습니다.

 

.

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

def print_hello():
    print('안녕!')
print_hello()
더보기
안녕!

 

 

callback_func(print_hello)
더보기
안녕!
안녕!
안녕!
안녕!
안녕!

 

 

def callback_func(func, num):
  for i in range(num):
    func(i)

def print_hello(num):
  print('푸바오', num)

def print_hi(num):
  print('대나무', num)

callback_func(print_hello , 5)
callback_func(print_hi, 3)
더보기
푸바오 0
푸바오 1
푸바오 2
푸바오 3
푸바오 4
대나무 0
대나무 1
대나무 2

 

 

2. 람다 함수(Lambda Function)

람다 함수는 파이썬에서 익명의 간단한 함수를 생성하기 위한 특별한 구문입니다. "익명의 함수"라는 것은 함수에 고유한 이름이 지정되지 않았음을 의미합니다. 람다 함수는 일반적인 함수(def 사용하여 정의)와는 달리,  줄로 표현되는 짧고 간결한 함수를 생성할  주로 사용됩니다.

lambda arguments: expression

arguments: 람다 함수에 전달되는 인자들입니다.

expression: 반환할 표현식입니다.  표현식의 값이 람다 함수가 호출될  반환됩니다.

 

간결성: 람다 함수는 간단한 연산이나 작은 기능을 가진 함수를 간결하게 표현하는 데 유용합니다.

익명성: 람다 함수에는 명시적인 이름이 부여되지 않습니다. 그러나 필요에 따라 변수에 할당할 수 있습니다.

일회성: 일반적으로 특정 작업을 위한 일회성 함수로 사용됩니다.

 

def square(x):
  return x**2

print(square(4))

 

 

squre = lambda x : x**2 # x : 표현 // ex) 4 : 4**2
print(square(4))
print(square(5))
print((lambda x: x ** 2)(4))
더보기
16
25
16

 

 

비교

def return_age(x):
    return x['age'] # x의 age를 꺼내서 입력
    
people = [{'name': '푸바오', 'age': 3}, {'name': '후이바오', 'age': 1}, {'name': '루이바오', 'age': 1}]
sorted_people = sorted(people, key=return_age)
print(sorted_people)
people = [{'name': '푸바오', 'age': 3}, {'name': '후이바오', 'age': 1}, {'name': '루이바오', 'age': 1}]
sorted_people = sorted(people, key=lambda x: x['age']) # age 오름차순
print(sorted_people) # 람다는 메모리에 저장되지 않음

 

 

3. 람다가 유용하게 사용되는 대표적인 함수

3-1. filter 함수

filter() 파이썬의 내장 함수로, 주어진 함수의 조건을 만족하는 항목만으로 이루어진 이터레이터를 반환합니다.  함수는 주로 리스트나 다른 순차적인 데이터 타입에서 특정 조건을 만족하는 항목들만을 필터링할  사용됩니다.

 

function: 각 항목에 적용되는 함수. 이 함수는 하나의 인자를 받아 참(True) 또는 거짓(False)을 반환합니다.

iterable: 필터링  이터러블 객체 (: 리스트, 튜플, 문자열 )

 

li = [2, 5, 7, 10, 15, 17, 20, 22, 25, 28]


def even(n):
    if n%2 == 0:
        return True
    else:
        return False
        
# filter(함수값, 데이터) True만 출력
result = list(filter(even, li)) #True일때만 필터에서 바깥으로 내보냄
print(result) # True값만 가진 요소만 라스트로 만들어냄

 

# 람다로 간결한 함수로 생성

li = [2, 5, 7, 10, 15, 17, 20, 22, 25, 28]
result2 = list(filter(lambda n : n%2==0, li)) #람다로 익명의 함수를 생성
print(result2)

 

3-2. map 함수

map(각각 어떻게 바꿀 것인가, [바꿀 입력 값])
  • map()는 파이썬의 내장 함수로, 주어진 함수를 이터러블의 모든 항목에 적용하여 결과를 반환하는 이터레이터를 생성
  • 이 함수는 주로 리스트나 다른 순차적인 데이터 타입의 항목 각각에 함수를 적용할 때 사용됩니다.
  • map() 함수는 여러 개의 이터러블을 동시에 처리할 수 있습니다.

function: 각 항목에 적용될 함수.

iterable: function 의해 처리될 이터러블 객체(: 리스트, 튜플, 문자열 ). map() 함수는 여러 개의 이터러블을 동시에 처리할  있습니다.

 

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(squared_numbers)
더보기
[1, 4, 9, 16, 25]

 

list1 = [1, 2, 3]
list2 = [4, 5, 6]
summed = list(map(lambda x, y : x + y, list1, list2)) #list1과 list2를 x y에 각각뽑아서 입력해줌
print(summed)
더보기
[5, 7, 9]

 

# map은 여러개의 이터러블을 동시에 처리
words = ["apple", "banana", "cherry"]
uppercase_words = list(map(str.upper, words)) # str.upper : 대문자 변환
print(uppercase_words)
더보기
['APPLE', 'BANANA', 'CHERRY']

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

16. 파이썬 상속  (0) 2023.12.12
15. 객체지향과 클래스  (1) 2023.12.11
13. 변수의 범위  (1) 2023.12.11
12. 사용자 정의 함수  (1) 2023.12.10
11. 컬렉션과 반복문  (1) 2023.12.10

1. 스코프(scope)

파이썬에서 변수의 범위(scope) 해당 변수가 프로그램 내에서 참조되고 변경될  있는 영역을 의미합니다. 파이썬의 변수 범위는 크게  가지로 분류됩니다.

 

 

1-1. Local(지역): Local scope 변수가 함수 내에서 정의될  해당 함수 내부를 의미합니다.

- 함수내에 저장된 변수

 

def local_example():
    local_var = "로컬 변수"
    print(local_var)

local_example()
더보기
로컬 변수

 

1-2. Enclosing(둘러싼 범위): Enclosing scope 내부 함수에서 외부 함수의 변수를 참조할  해당 외부 함수 범위를 의미합니다.

def outer_function():
    enclosing_var = "둘러싼 범위 변수"
    def inner_function():
        print(enclosing_var)
    
    inner_function()

outer_function()
더보기
둘러싼 범위 변수
#inner_function()
outer_function() # 외부함수는 내부함수를 부를 수 있음
더보기
둘러싼 범위 변수

 

1-3. Global(전역 범위): Global scope 변수가 스크립트의 최상위 수준에서 정의될  전체 스크립트 파일 내에서 해당 변수를 의미합니다.

global_var = '글로벌 변수'

def test_global_scope():
    print(global_var)

test_global_scope()
더보기
글로벌 변수

 

 

global_var = 10
def modify_global():
  global_var = 20     # 지역변수 우선
  print(global_var)

modify_global()   # 20
print(global_var) # 10
global_var = 10
def modify_global():
  global global_var # 글로벌변수를 수정하려면 global로 전역변수와 같은 변수를 불러옴
  global_var = 20   # 글로벌 값을 수정
  print(global_var)

modify_global()   # 20
print(global_var) # 20

 

 

 

1-4. Built-in(내장 범위):

Built-in scope 파이썬의 내장 함수와 모듈들이 속하는 범위입니다. 예를 들어, print(), len() 같은 함수들이 여기에 해당됩니다.

# 빌트인 함수
print(print)
print(len)
print(sum)
더보기
<built-in function print>
<built-in function len>
<built-in function sum>

 

 

2. 변수의 범위 탐색 순서

1. Local scope

2. Enclosing scope

3. Global scope

4. Built-in scope

따라서 지역 범위에 동일한 이름의 변수가 없으면 파이썬은 둘러싼 범위를 확인하고, 그 다음으로 전역 범위, 마지막으로 내장 범위를 확인합니다.

이렇게 변수의 범위를 이해하고 관리하는 것은 코드의 가독성과 유지 보수성을 높이고, 예기치 않은 오류를 방지하는  중요합니다.

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

15. 객체지향과 클래스  (1) 2023.12.11
14. 콜백함수와 람다함수  (1) 2023.12.11
12. 사용자 정의 함수  (1) 2023.12.10
11. 컬렉션과 반복문  (1) 2023.12.10
10. 제어문 - 반복문  (1) 2023.12.10

 

1. 사용자 정의 함수

사용자 정의 함수란 사용자가 특정 작업을 수행하기 위해 직접 작성한 함수를 의미합니다. 파이썬에는 많은 내장 함수들이 있지만, 때로는 우리의 요구사항에 맞게 동작하는 함수를 직접 만들어야 할 때가 있습니다. 이때 사용자 정의 함수를 작성하게 됩니다. 기본적인 구조는 아래와 같습니다.

def 함수명(매개변수1, 매개변수2, ...):
    # 함수 내용
    return 결과값

 

2. 매개변수와 반환 값이 없는 함수

def func1(): #함수만 불러주면 알아서 호출
    print('처음으로 만드는 함수')
func1() #메모리를 차지하고 있고 호출하면 불러올 수 있다.
더보기
처음으로 만드는 함수
for i in range(5):
  func1()
더보기
처음으로 만드는 함수
처음으로 만드는 함수
처음으로 만드는 함수
처음으로 만드는 함수
처음으로 만드는 함수

 

3. 매개변수가 있고 반환 값이 없는 함수

def func2(num):
  print(f'입력받은 숫자 {num}')
  
func2(10)
func2(5)
더보기
입력받은 숫자 10
입력받은 숫자 5

 

def func3(start, end):
  sum = 0
  for i in range(start, end + 1):
      sum = sum + i
  print(f'{start}부터 {end}까지의 합 : {sum}')
  
func3(1, 100)
더보기
1부터 100까지의 합 : 5050

 

 

 

4. 반환 값이 있는 함수

def func4():
  print('안녕') # return이 없기때문에 아무 값도 줄 수없어 변수에 아무것도 담기지 않음.

>> 출력 값 없음

 

a = func4()
print(f'a에 저장된 값: {a}')
더보기
안녕
a에 저장된 값: None

 

def func5():
 '★'
a= func5()
print(a)
더보기
None

 

def func5():
  return '★' # return을 이용해 변수에 값을 담음 func5()는 출력에만 사용하고 저장은 되지않음
star = func5()
print(f'star에 저장된 값 : {star}')
더보기
star에 저장된 값 : ★

 

def func6(num1, num2):
  sum = num1 + num2
  return sum #sum 값을 result에 담음
  
result = func6(10, 5)
print(result)

 

 

 

5. ※ None의 특징

  • None은 파이썬에서 특별한 값으로, 아무런 값이 없음을 표현하는 데 사용됩니다. 다른 언어에서의 null 또는 nil과 유사한 개념입니다.
  • None은 파이썬의 내장 상수이며, 그 자체로 데이터 타입이 NoneType입니다. 모든 None은 동일하므로, 두 개의 None 값을 비교할 때 항상 True를 반환합니다.

 

1. 기본 초기값 설정: 변수를 초기화할  아무런 값이 할당되지 않았음을 나타내기 위해 None 사용할  있습니다.

variable = None

 

2. 함수의 반환 값으로 사용: 함수에서 특정 조건에서 아무런 값도 반환하지 않아야   None 사용합니다. 사실, 함수에서 return 문이 생략되거나 없으면 기본적으로 None 반환합니다.

def my_function(x): # x값에 값이 들어가게 되면
  if x > 10 :       # 10과 비교해서
    return x        # 조건에 맞으면 반환값이 나옴
# x가 10 이하일 때는 아무런 값도 반환하지 않습니다. 
#실제로는 None이 반환됩니다.

my_function(11)
my_function(2)  # 리턴이 없어 반환값이 안나옴
# 처음 코드 수정
def my_function(x):
  if x > 10 :
    return x
  else:
    return None # 조건이 안맞을 경우의 리턴값도 만들어야 반환값이 나옴

 

a = my_function(15)
print(a)

a = my_function(1)
print(a)
더보기
15
None

 

 

3. 선택적 매개변수의 기본값: 함수의 매개변수에 기본값으로 None 할당하여 선택적으로 인자를 전달받을  있게 만들  있습니다.

# 선택적 매개변수의 기본값
def hello(message = None):
  if message is None:
    print('Hello') # None이면 Hello 출력
  else:
    print(message)
    
    
    
hello('안녕하세요')
hello()
더보기
안녕하세요
Hello

 

 

4. 값의 존재 여부 확인: None 사용하여 값의 존재 여부를 확인할  있습니다.

None 검사할 때는 == 대신 is 연산자를 사용하는 것이 좋습니다.

is 객체의 동일성을 검사하는 반면, == 객체의 동등성을 검사하기 때문입니다.

# 값의 존재 여부 확인: None을 사용하여 값의 존재 여부를 확인할 수 있습니다.
def get_data_from_database():
  pass                        # pass를 사용하면 나중에 이것을 채우던가 넘어가는 용도

data = get_data_from_database()
print(data)

if data is None :
  print('데이터 수신 못함')
else :
  print('데이터 수신 받음')
더보기
None
데이터 수신 못함

 

li1 = [1, 2, 3, 4, 5]
li2 = [1, 2, 3, 4, 5]
li3 = li1

# 서로 다른 개체(객체 비교).  is는 객체의 동일성을 검사
result1 = li1 is li2
print(result1)                  # False

result2 = li1 is li3            # True
print(result2)

# 값이 같은 객체(값 비교).  ==는 객체의 동등성을 검사
result3 = li1 == li2
print(result3)                  # True

 

 

6. 기본값이 설정된 매개변수

def func6(num1, num2):
  sum = num1 + num2
  return sum
  
print(func6(10, 3))

 

def func6(num1=1, num2=1):
  sum = num1 + num2
  return sum

 

print(func6())
#출력: 2

print(func6(10)) # num1에 10이 들어가고 , num2 = 1이 그대로 출력됨 
#출력: 11

print(func6(10, 3)) # num1에 10이 들어가고, num2에 3이 들어감
#출력: 13

print(func6(num2=10)) # num1을 비우고 num2에만 값을 넣고 싶을때
#출력: 11

 

7. 가변 매개변수

7-1 . 패킹과 언패킹

 

-  언패킹(Unpacking) : 값을 풀어서 적는것

def get_Total(number1, number2, number3):
     return number1 + number2 + number3

 

- 패킹(Packing) : 값을 묶어서 적는것

1. * 을 사용하면 get_total이 튜플형태로 한번에 들어간다. => 튜플 형태로 저장

2.  자동으로 여러개의 값을  받기 때문에 리스트로 받아짐 

3. 여러개의 값을 하나로 묶어서 전달하게 되면, packing으로 인해 첫번째 방에 통채로 들어가게 된다.
4. 즉, 결과는 다음과 같다 ([1, 2, 3, 4, 5],) 튜플 안 첫번째 방

def get_total(*numbers): # *이 있다면 패킹 : 여러개 선언해야 하는것을 한번에 묶어서 받음
    # 외부에서 전달받은 값들이 numbers(튜플)에 튜플형태로 저장된다.
    print(type(numbers))
    total = 0
    for number in numbers:
        total += number

    return total
    
    
# *을 사용하면 get_total이 튜플형태로 한번에 들어간다
numbers = [1, 2, 3, 4, 5]
total = get_total(numbers)
print(total) # TypeError: unsupported operand type(s) for +=: 'int' and 'list'

- 따라서 내부의 요소는 각각 전달하고 싶다면, 앞에 *을 작성해야한다.

- 데이터가 묶어서 왔을때 *을 사용

numbers = [1, 2, 3, 4, 5]
total = get_total(*numbers)# 데이터가 묶어서 왔을때 *을 사용
print(total)
# # 튜플로 한번에 값을 받음

- 함수를 호출할  * 사용하면 시퀀스(리스트, 튜플 ) 요소를 개별적인 위치 인자로 풀어서 전달할  있습니다.

# 함수 내부에서는 매개변수를 튜플로 처리
def func7(*args):	# *를 써서 데이터를 입력하면 튜플로 입력된다.
    result = 0
    # print(args)
    for i in args:
        result += i
    return result
    
print(func7())
print(func7(10, 30, 20, 70))
print(func7(10))
def add(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
print(add(*numbers))  # 출력: 6

 

- 반드시 받아야하는 매개변수는 패킹앞에 작성하기

# 국어 영어 수학 점수를 전달받은 뒤 총점을 출력하는 함수
packing으로 제작하기
def get_total(name, *scores): # 반드시 받아야하는 매개변수는 packing앞에 작성한다
    print(name + '님')
    total = 0
    for score in scores:
        total += score
    return total

scores= [100,40,50]
print(get_total('류니', 100, 40, 50))

 

kwargs (keyword arguments)

# # keyword arguments
#
# def introduce(**intro): #딕셔너리
#     print(type(intro))
#     print(f'name : {intro["name"]}')
#
#
# introduce(name="이정륜") # 딕셔너리로 보내려면 위에서 **kwargs
# introduce(**{'name':'이정륜'}) # 딕셔너리를 통채로 보내려면 딕셔너리 앞에 **

 

kwargs 예제 문제1) 

국어 영어 수학 점수의 평균 구하기
# kwargs로 선언


def score_av(**kwargs):
    all = sum(kwargs.values())
    av = all/3
    return av

print(score_av(**{'kor':80 , 'eng':90 , 'math': 70}))
def score_av(**kwargs):
    kor = kwargs['kor']
    eng = kwargs['eng']
    math = kwargs['math']
    return (kor+eng+math)/3

print(score_av(kor=80,eng=90,math=70))

 

kwargs 예제 문제 2)

 국어 영어 수학 점수의 평균 구하기
# 사용자가 원하는 자리수(round)에서 반올림해준다.
# 자리수를 받지 않았다면, 기본값을 리턴한다.
# 국어 영어 수학 점수의 평균 구하기
# kwargs로 선언

def average(**kwarg):
    if "round" in kwarg:
        kor, eng, math = kwarg.get('kor'), kwarg.get('eng'), kwarg.get('math')
        total = kor + eng + math
        ave = total/3
        if "round" in kwarg:
            return round(ave, kwarg['round'])
        return ave


print(average(kor=100, eng=30, math=22, round= 2))

8. 키워드 매개변수

def func8(id, name, age):
    print(f'아이디: {id}')
    print(f'이름: {name}')
    print(f'나이: {age}')
func8('Fubao', '푸바오', 3)
func8(id = 'apple', age=20, name='푸바오') # 값을 입력할때 변수 이름을 써주면 함수 호출순서가 달라도 됨
더보기
아이디 : Fubao
이름 : 푸바오
나이 : 3

아이디 : apple
이름 : 푸바오
나이 : 20
dic1 = {'id' : 'apple', 'name' : '푸바오', 'age' : 3}
func8(**dic1) # ** 값이 입력 // key값이 func8 함수의 데이터 입력값과 동일해야 값을 출력
func8(*dic1) # *를 key 입력
더보기
아이디 : apple
이름 : 푸바오
나이 : 3
아이디 : id
이름 : name
나이 : age

 

def func9(**args):
  #print(args)
  for i in args: # i에 키가 저장
    if i == 'id': # id값 뽑기
      userid = args[i]
  return userid
  
user = func9(id = 'apple', name = '푸바오', age = 20)
user
더보기
apple

 

9.여러개의 반환값

def func10(num1, num2):
  return num1 + num2
  
result1 = func10(10,3)
print(result1)
def func10(num1, num2):
  return num1 + num2, num1 - num2, num1 * num2, num1 / num2
result1, result2, result3, result4 = func10(10,3)
print(f'덧셈: {result1}, 뺄셈: {result2}, 곱셈: {result3}, 나눗셈: {result4}'
더보기
덧셈: 13, 뺄셈: 7, 곱셈: 30, 나눗셈: 3.3333333333333335
_, _, result3, _ = func10(10,3)  # 곱셈의 결과만 필요할때  '_' 이용하면 원하는 값만 출력
print(result3)

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

14. 콜백함수와 람다함수  (1) 2023.12.11
13. 변수의 범위  (1) 2023.12.11
11. 컬렉션과 반복문  (1) 2023.12.10
10. 제어문 - 반복문  (1) 2023.12.10
9. 제어문 - 조건문  (2) 2023.12.08