📘

Introducing Python - Bill Lubanovic

1. Data: Type, Value, Variable, Name

가. 파이썬 데이터의 정체

나. 기본연산

3. 자료형

가. 자료구조별 시간복잡도 분석

나. List vs Dictionary

1. Data: Type, Value, Variable, Name

가. 파이썬 데이터의 정체

1) Data is Object

•

기본 내장 데이터는 Object로 Wrapping되어 메모리에 저장됨

→ 기본 내장 데이터란 정수, 문자열, 함수 등이 해당됨

→ Object란 속성(attribute)과 메소드(method)로 구성되어 있는 커스텀 자료구조

•

기본 내장 데이터가 담기는 Object는 다음의 네 가지 속성을 포함함

→ 타입: 데이터의 사용반경 제한

→ ID: 객체의 유일성 표현

→ 값: 내용물

→ 참조횟수: 변수를 통해 특정 객체가 지정된 횟수

2) Type

•

가변성(Mutable)

→ 가변성이 있는 타입의 데이터는 객체 내 값의 변경이 가능함

→ 파이썬 내장 데이터 중 가변성 타입의 데이터는 리스트, 딕셔너리, 바이트 배열, 셋으로 한정됨

•

Strong Type Language

→ 가변 데이터 타입의 경우에도 타입 변경은 불가능

3) Name

•

변수에 데이터를 할당하는 것 == 변수에 이름을 붙이는 것

→ 변수에 데이터를 할당함으로써 해당 데이터를 참조하는 이름을 생성하는 것

→ 변수 할당은 데이터 내 값을 변수에 복사한다는 것을 의미하지 않는다

→ 변수에 데이터를 할당하면 데이터 내 참조횟수가 증가한다

•

(예시) 변수 할당 프로세스

→ 익명 정수 객체 생성(값은 5)

→ 변수 y가 익명 정수 객체 참조

→ 정수 객체 내 참조횟수 증가

→ 익명 정수 객체 생성(값은 12)

→ 값이 12인 익명 정수 객체의 값과 y가 가리키는 정수 객체의 값을 뺌

→ 값 7은 익명 정수 객체에 할당됨

→ 변수 x가 익명 정수 객체 참조(값 7)

→ 값이 7인 객체의 참조횟수 증가

→ x가 가리키는 정수 객체의 값 출력

# introducing python 2.7 chapter 예제
>>> y = 5
>>> x = 12 - y
>>> x
7
Python
복사

4) 가변 데이터와 이름 재할당

•

불변 타입의 데이터에 값 변경은 이름을 재할당하는 것

→ 불변 타입의 데이터에 이름이 할당된 경우, 이름에 다른 값을 재할당하는 것은 이전 데이터의 값을 변경하는 것이 아님

•

(예시) 이름 재할당

→ 값이 5인 정수 객체 생성

→ 변수 x가 값이 5인 정수 객체 참조

→ 값이 5인 정수 객체의 참조횟수 증가

→ 값이 6인 정수 객체 생성

→ 변수 x가 값이 6인 정수 객체 참조

→ 값이 5인 정수 객체의 참조횟수 감소

→ 값이 6인 정수 객체의 참조횟수 증가

>>> x = 5
>>> x = 6
Python
복사

•

가변 타입의 데이터에 복수의 이름을 지정했다면 하나의 이름을 통해 데이터 변경 시, 다른 이름 참조를 통해 변경된 데이터의 값을 확인할 수 있음

•

(예시) 가변 데이터 이름 재할당

x = [1, 2, 3]
y = x

y[0] = 4

print(x) # [4, 2, 3]
print(y) # [4, 2, 3]
Python
복사

나. 기본연산

1) bool 값과 논리연산

•

숫자 0을 제외한 모든 수 - true

•

빈 딕셔너리, 빈 리스트를 제외한 모든 딕셔너리, 리스트 - true

•

아무 값도 없다는 의미인 None - false

•

빈문자열을 제외한 모든 문자열 - true

2) is vs ==

•

is: 변수가 참조하는 객체 itself 비교

•

==: 변수가 참조하는 객체 내 값 비교

list1 = [1, 2, 3]
list2 = [1, 2, 3]

if list1 == list2:
    print("list1과 list2의 값은 같습니다.")
if list1 is list2:
    print("하지만 list1과 list2는 다른 객체입니다.")
Python
복사

3) for in range vs enumerate

•

for in range

rainbow=["빨","주","노","초","파","남","보"]
for i in range(len(rainbow)):
    color = rainbow[i]
    print('{}번째 색은 {}'.format(i+1,color))
Python
복사

4) enumerate

•

enumerate: for in range의 len 활용 및 color 변수 선언을 축약한 형태

rainbow=["빨","주","노","초","파","남","보"]
for i,color in enumerate(rainbow):
    print('{}번째 색은 {}'.format(i+1,color))
Python
복사

3. 자료형

가. 자료구조별 시간복잡도 분석

1) Set

•

적합한 사용법

→ 각각의 구성요소에 대한 조회가 필요 없는 경우

→ 자료구조 내 구성요소가 유일한 값일 경우(중복값이 허용되지 않을 경우)

→ 각각의 구성요소에 대한 포함여부 확인 및 삽입이 필요한 경우

•

포함여부 확인

→ in or not in: O(1)

→ Set은 hashable 객체이므로 해쉬값과 내부 구성요소 간의 lookup table이 생성되고, 이를 활용하여 포함여부를 조회하면 O(1) 결과 도출

→ 단, Set의 __hash__가 정의되지 않아서 모든 구성요소의 해쉬값이 동일하다면 lookup 테이블을 활용할 수 없으므로 포함여부의 시간복잡도는 O(n)이 될 수 있다

•

삽입삭제

→ add, remove: O(1)

2) List

•

적합한 사용법

→ 각 구성요소에 대해 인덱스 조회가 필요한 경우

→ 자료구조 내 구성요소가 중복될 수 있는 경우

•

인덱스 조회 

→ list[x]: O(1)

•

포함여부 확인

→ in or not in: O(n)

•

삽입삭제

→ insert, delete: O(n)

→ append, pop: O(1)

3) Dict

•

적합한 사용법

→ 자료구조 내 구성요소가 key-value의 쌍으로 관리될 필요가 있는 경우

→ 구성요소의 조회 및 갱신 작업이 필요한 경우

•

인덱스 조회 

→ dict[’key’]: O(1)

•

포함여부 확인

→ in or not in: O(1)

•

삽입삭제

→ del, store: O(1)

나. List vs Dictionary

1) 공통점

Show All

공통점

List

Dictionary

생성

list = [ 1, 2 ,3 ]

Open

dict = { 'one':1, 'two':2 }

호출

list[ 0 ]

Open

dict[ 'one' ]

삭제

인덱스로 삭제: del( list[ 0 ] )

Open

del( dict[ 'one' ] )

개수 확인

len( list )

Open

len( dict )

값 확인

2 in list

Open

'two' in dict.keys( )

전부 삭제

list.clear( )

Open

dict.clear( )

값 추가

list.append(3)

Open

dict['three'] = 3

값으로 삭제

list.remove(값)

Open

2) 차이점

Show All

차이점

List

Dictionary

순서

삭제 시 순서가 바뀌기 때문에 인덱스에 대한 값이 바뀐다

Open

key로 값을 가져오기 때문에 삭제 여부와 상관없다

결합

list1 + list2

Open

dict1.update( dict2 )

3) Dictionary에서 None 처리

•

Dictionary에서 Key 값으로 Value 검색하는 방법

→ dict[’one’]: key값이 존재하지 않으면 오류 발생

→ dict.get(’one’): key값이 존재하지 않으면 None 반환

4) List comprehension

•

[ 계산식 for문 ]

→ [ i*i for i in range(1,11) ]

•

 [ 계산식 for문 조건문 ]

→ [ i*i for i in range(1,11) if i % 2 == 0 ]

•

[ 계산식 for문 for문 ]

→ [ ( x, y ) for x in range(15) for y in range(15) ]

5) Dictionary comprehension

•

{ 형식 for문 }

students = ["태연", "진우", "정현", "하늘", "성진"]

# {'2번': '정현', '0번': '태연', '1번': '진우', '4번': '성진', '3번': '하늘'}
{"{}번".format(number):name for number, name in enumerate(students)}
Python
복사

•

{키:값 for in zip}

students = ["태연", "진우", "정현", "하늘", "성진"]
scores = [85, 92, 78, 90, 100]

# {'성진': 100, '진우': 92, '하늘': 90, '태연': 85, '정현': 78}
result = {x : y for x, y in zip(students, scores)}
Python
복사

6) List Slicing

•

조회

list1 = list(range(20))

# new_list 5, 8, 11, 14
new_list = list1[5:15:3]

# reverse_list 17, 13, 9, 5
reverse_list = list1[17:4:-4]
Python
복사

•

갱신

list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = [11, 22, 33] # list1 = [0, 11, 22, 33, 4, 5]

list2 = [0, 1, 2, 3, 4, 5]
del list2[1:4] # list2 = [0, 4, 5]가 되어야 합니다.
Python
복사

7) packing, unpacking

•

packing: 하나의 변수에 여러개의 값을 넣는 것

•

unpacking: 패킹된 변수에서 여러개의 값을 꺼내오는 것

c = (3, 4)
d, e = c    # c의 값을 언패킹하여 d, e에 값을 넣었다
f = d, e    # 변수 d와 e를 f에 패킹
Python
복사

다. 문자열

1) 검색

•

String 인덱스 접근

>>> s = 'abcdef'
>>> s[3]
'd'
Python
복사

•

전방일치: startwith()

•

후방일치: endwith()

•

부분일치: not in, in

•

완전일치: ==, !=

→ is의 경우 객체수준의 일치여부 확인

2) 특정 문자 제거

•

문자열에서 대괄호 제거

→ strip의 경우 양쪽에서 한 번씩 해당 문자열을 제거한다

target_string = "['pig', 'cow'], ['pig', 'cow']"
refined_string = target_string.strip("[" "]")
print(refined_string) # 'pig', 'cow'], ['pig', 'cow'
Python
복사

3) 특정 문자 치환

•

중복 존재하는 특정 문자를 문자열에서 모두 제거

target_string = "['pig', 'cow'], ['pig', 'cow']"
refined_string = target_string.replace("[", "")
refined_string = refined_string.replace("]", "")
print(refined_string) # 'pig', 'cow', 'pig', 'cow'
Python
복사

4) 특정 문자 기준 문자열 → 리스트 변경

•

쉼표기준 문자열 내 문자를 요소로하는 리스트 생성

target_string = "[pig,cow],[pig,cow]"
refined_string = target_string.replace("[", "")
refined_string = refined_string.replace("]", "")
changed_list = refined_string.split(",")
print(changed_list) # ['pig', 'cow', 'pig', 'cow']
Python
복사

4. 함수

가. 매개변수

1) *args

•

매개변수의 개수가 정해지지 않았을 때 사용

•

튜플 형태로 전달됨

def print_param(*args): 
	print args for p in args: 
		print p 

print_param('a', 'b', 'c', 'd') 
#('a', 'b', 'c', 'd') 
#a 
#b 
#c 
#d

출처: https://jhproject.tistory.com/109 [JH PROJECT]
Python
복사

2) **kwargs

•

매개변수 명 함께 전달 가능

•

딕셔너리 형태로 전달 

def print_param2(**kwargs): 
	print kwargs 
	print kwargs.keys() 
	print kwargs.values() 

	for name, value in kwargs.items(): 
		print "%s : %s" % (name, value) 

print_param2(first = 'a', second = 'b', third = 'c', fourth = 'd') 
#{'second': 'b', 'fourth': 'd', 'third': 'c', 'first': 'a'} 
#['second', 'fourth', 'third', 'first'] 
#['b', 'd', 'c', 'a'] 
#second : b 
#fourth : d 
#third : c 
#first : a

출처: https://jhproject.tistory.com/109 [JH PROJECT]
Python
복사

5. 객체와 클래스

가. 간단한 객체

•

클래스 예제 

class Human():
    
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight
    
    def __str__(self):
        return "{} (몸무게 {}kg)".format(self.name, self.weight)
    
    def eat(self):
        self.weight += 0.1
        print("{}가 먹어서 {}kg이 되었습니다.".format(self.name, self.weight))
    
    def walk(self):
        self.weight -= 0.1
        print("{}가 걸어서 {}kg이 되었습니다.".format(self.name, self.weight))

person = Human("MJ", 85)
person.walk() # MJ가 걸어서 84.9kg이 되었습니다.
person.walk() # MJ가 걸어서 84.80000000000001kg이 되었습니다.
person.eat() # MJ가 먹어서 84.9kg이 되었습니다.

print(person) # MJ (몸무게 84.9kg)
Python
복사

1) 속성

•

클래스의 속성은 속성값과 메소드로 구성됨

•

속성값은 데이터이고 메소드는 함수임

2) 메서드

•

첫번째 매개변수로 self를 사용하여 객체 인스턴스 자체를 가리킴

class Car():
    def run(self):
        print("{}가 달립니다.".format(self.name))

taxi = Car()
taxi.name = "택시"
taxi.run()
Python
복사

•

static method: 클래스나 인스턴스의 속성에 의존하지 않는 데이터로 함수 정의할 때 사용

→ staticmethod 장식자를 붙여야 인스턴스 객체에서 static method 호출 가능

class Human():
    
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight
    
		@staticmethod
		def say_hello():
			print("hello")
Python
복사

3) 매직 메서드

•

_ _init_ _: 클래스의 초기값 설정 

→ Java의 toString 개념

•

_ _str_ _: 클래스에 대한 default 문자열 설정

•

_ _doc_ _: 클래스 전반에 대해 명시한 주석을 확인할 수 있음 

4) namespace

•

정의: 개체를 구분할 수 있는 범위

→ __dict__ 메소드를 통해 객체의 namespace를 확인할 수 있음

•

클래스 객체와 인스턴스 객체에 대한 namespace 확인

•

메모리 효율을 위해 인스턴스 객체의 namespace에는 인스턴스 객체의 속성값만을 정의함

→ 인스턴스 메소드 및 클래스 속성은 모두 클래스 namespace에 정의됨

→ 인스턴스 메소드를 호출할 때, 인스턴스 객체의 namespace에 없는 것을 확인하고, 클래스 객체의 namesplace를 확인하여 인스턴스 객체의 메소드를 확인하여 실행하는 프로세스임

→ 위와 같이 동적인 실행순서를 갖고 있으므로 파이썬을 동적인 언어로 표현함

person.__dict__
{'name': 'MJ', 'weight': 84.9}

Human.__dict__
mappingproxy({'__module__': '__main__', '__init__': <function Human.__init__ at 0x1025b10d0>, '__str__': <function Human.__str__ at 0x1025b11f0>, 'eat': <function Human.eat at 0x1025b1310>, 'walk': <function Human.walk at 0x1025b13a0>, '__dict__': <attribute '__dict__' of 'Human' objects>, '__weakref__': <attribute '__weakref__' of 'Human' objects>, '__doc__': None})
Python
복사

5) self vs cls

•

self 변수는 인스턴스 객체 그 자체

→ self의 id값과 인스턴스의 id값이 동일

•

cls 변수는 클래스 객체 그 자체

6) composition

•

상위 객체 자체를 상속 받지 않고 일부 메소드만 상속 받고 싶을 경우 활용

class A(object):
    def __init__(self, a):
        self.a = a

    def do_work(self, a):
        print(f'{a} do_work')

class C:
    def __init__(self, a):
        self.a = a
        self.A = A(a)

    def do_work(self, h):
        print(h)
        return self.A.do_work(self.a)

c = C("k")
c.do_work("t")
# t
# k do_work
Python
복사

7) 접근제어자

•

파이썬 인터프리터에서 공식적으로 지원하는 접근제어자는 public과 private만 존재함

→ public: 속성에 대한 모든 접근을 허용

→ private: 속성이 private으로 정의된 class 내부에서만 접근 허용

→ 하위 클래스에서도 private으로 정의된 속성 접근 불가

•

파이썬 커뮤니티에서 언더바 하나를 protected 접근제어자로 사용하자는 일부의 합의 존재

→ protected: 속성이 protected로 정의된 class를 상속 받으면 하위 클래스에서 접근 가능하지만, class 외부에서는 접근 불가

→ 단, 파이썬 인터프리터는 공식적으로 protected를 지원하지 않기때문에 언더바 하나로 정의된 속성은 class 외부에서 접근 가능

→ 커뮤니티 일부에서는 언더바 하나를 임시 변수로 보자는 합의도 존재함

•

접근제어자 예시

class A:
    def __init__(self, a, b):
        self.a = a
				self.__b = b

		def _test_protected(self, c):
				print(f'{self.a}, {c}')

class B(A):
		def __init__(self, a, b, d):
				super().__init__(a, b)
				self._d = d

		def __test_private(self):
				print(f'{self.a}')
		
i_a = A(1, 2)
i_b = B(3, 4, 5)

print(i_a.a) # 2
print(i_a._test_protected('hello')) # 1, hello
print(i_b.a) # 3
print(i_b._d) # 5
print(i_b.__test_private('hello')) # AttributeError: 'B' object has no attribute '__test_private'
Python
복사

나. 상속

1) Super()

•

자식 객체에서 부모객체의 메소드 사용

•

super에 상위 클래스 객체를 매개변수로 전달하면 해당 상위 클래스의 메소드를 사용함

→ 지정한 상위 클래스의 상위 클래스가 존재하지 않는다면 AttributeError 발생

class A(object):
    def do_work(self):
        print('A의 do_work')

class B(A):
    def do_work(self):
        print('B의 do_work')
        super(B, self).do_work()

class C(B):
    def do_work(self):
        print(1)
        super(C, self).do_work()
        print(2)
        super(B, self).do_work()
        print(3)
        super(A, self).do_work

# C 인스턴스 생성
c = C()
c.do_work()

-- 결과 -- 

1
B의 do_work
A의 do_work
2
A의 do_work
3
AttributeError: 'super' object has no attribute 'do_work'
Python
복사
example code from https://sirzzang.github.io/dev/Dev-python-super/

•

super에 상위 클래스 객체를 매개변수로 전달하지 않으면 모든 상위 클래스의 메소드를 사용함

class A(object):
    def do_work(self):
        print('A의 do_work')

class B(A):
    def do_work(self):
        print('B의 do_work')
        super().do_work()

class C(B):
    def do_work(self):
        print(1)
        super().do_work()
        print(2)
        super().do_work()
        print(3)
        super().do_work

# C 인스턴스 생성
c = C()
c.do_work()

-- 결과
1
B의 do_work
A의 do_work
2
B의 do_work
A의 do_work
3
B의 do_work
A의 do_work
Plain Text
복사
example code from https://sirzzang.github.io/dev/Dev-python-super/

다. Self

1) 정의

•

인스턴스 객체 자신에 대한 참조변수

→ 인스턴스 메소드의 첫번째 매개변수로 self 전달해야 함

2) 동작원리

•

a_car.exclaim() 호출에 따른 self의 동작원리

→ a_car 인스턴스 객체를 생성한 클래스 객체 탐색

→ a_car 인스턴스 객체를 Car 클래스 객체의 메서드의 self 변수에 할당

→ 결과적으로 a_car.exclaim() == Car.exclaim(a_car)

class Car:
	def exclaim(self):
		print("I'am a Car")


a_car = Car()
a_car.exclaim() # I'am a Car
Python
복사

라. Method Type

1) 인스턴스 메서드

•

특정 인스턴스 객체에만 영향을 주는 메서드

•

메서드의 첫번째 매개변수로 self(인스턴스 객체 자신을 참조하는 변수)를 전달함

2) 클래스 메서드

•

클래스 객체 자체에 영향을 주는 메서드

→ 해당 클래스를 통해 생성된 모든 인스턴스 객체에 영향을 주는 메서드

•

@classmethod라는 decoration이 붙고 첫번재 매개변수로 cls(클래스 객체 자신을 참조하는 변수)를 전달함

>>> class A():
...     count = 0
...     def __init__(self):
...             A.count += 1
...     @classmethod
...     def class_kids(cls):
...             print(cls.count)
...     def instance_increase(self):
...             self.count += 1
...     def instance_kids(self):
...             print(self.count) 
... 
>>> first_a = A()
>>> second_a = A()
>>> first_a.instance_increase()
>>> A.class_kids()
2
>>> first_a.instance_kids()
3
Python
복사

3) 정적 메서드

•

클래스나 인스턴스에 영향을 주지 않지만 편리성을 위해 사용하는 메서드

•

클래스나 인스턴스 객체를 생성하지 않고 정적 메서드 호출 가능

•

@staticmethod라는 decoration이 붙음

>>> class Weapon():
...     @staticmethod
...     def commercial():
...             print("Weapon! Wow!")
... 
>>> Weapon.commercial()
Weapon! Wow!
Python
복사

마. Mixin

1) 정의

•

일련의 속성과 메소드의 집합

→ 같은 base class를 상속하지 않는 객체 간에 특정 속성과 메소드를 상속받아 사용할 수 있음

2) 예시

•

Cow, Bull, Ox 클래스는 모두 Cattle이라는 base class를 상속받음

•

Bull, Ox는 수소이므로 두 객체에만 사용되는 속성과 메소드가 존재함

→ 속성(정액번호), 메소드(정액채취)가 Mixin으로 정의되어 Bull과 Ox 클래스가 상속받을 수 있음

class Cattle(object):
	def __init__(self, birth_date):
		self.birth_date = birth_date

	def get_age_in_days():
		return today() - self.birth_date


class MaleMixin(object):
	def __init__(self, seed_id):
		self.seed_id = seed_id

	def get_seed_id():
		return self.seed_id


class Cow(Cattle):
	pass

class Bull(Cattle, MaleMixin):
	pass

class Ox(Cattle, MaleMixin):
	pass
Python
복사

바. Hash

1) Object Hash

•

특정 객체를 Hashable하게 만들기 위해 __hash__와 __eq__ 메소드를 정의해야함

•

객체의 

2) Hash 사용처

•

Set과 Dict의 구성요소의 값과 해쉬값을 가지고 lookup table을 구성하여 자료구조의 기본기능(조회, 비교 등)에 활용됨

→ 해쉬값은 lookup table에서 키로 사용되므로 해쉬값이 중간에 바뀌는 경우 여러 부작용을 초래할 수 있음

→ 특정 객체에서 해쉬 값 생성에 토대가 되는 값은 해당 객체의 lifecycle체서 불변의 값이어야 함

→ 같은 맥락에서 python 기본 자료형 중 immutable 객체(tuple, string)는 hashable하지만 mutable한 객체는 unhashable할 수 밖에 없다

6. 모듈과 패키지

가. Decorator

1) Decorator 개요

•

데코레이터는 함수 내부를 수정하지 않고 기능을 추가할 때 사용함

•

동작방식

→ 데코레이터를 붙여서 정의한 함수는 데코레이터 정의부 내 매개변수로 전달됨

→ 매개변수로 전달된 함수는 wrapper 함수 내 지정된 위치에서 실행됨

•

데코레이터 기본형태 정의

# 데코레이터 정의
def decorator_function(function):
	def wrapper():
		print("start test")
		function()
		print("end test")
	return wrapper

# 데코레이터 붙인 함수 정의
@decorator_function
def test_decorator():
	print("hello")

# 데코레이터 붙인 함수 실행
test_decorator()
Python
복사

•

예시 코드 실행 및 출력

•

데코레이터가 생략한 로직

→ 데코레이터의 매개변수로 전달할 함수의 정의부에 데코레이터 함수를 장식자로 표시하면, 본문에서 데코레이터 함수의 선언 부분을 생략할 수 있음

# 데코레이터 정의
def decorator_function(function):
	def wrapper():
		print("start test")
		function()
		print("end test")
	return wrapper

def test_decorator():
	print("hello")

test_decorator = decorator_function(test_decorator)
test_decorator()
Python
복사

2) 매개변수와 반환값 처리

•

데코레이터 붙인 함수에 매개변수를 전달하여 실행할 경우, 데코레이터 정의 부분의 wrapper 함수에 매개변수를 포함하여 정의해야 함

•

데코레이터 붙인 함수에 매개변수를 전달할 경우

# 데코레이터 정의
def decorator_function(function):
	def wrapper(sid, pw, name):
		print("start: ", function.__name__)
		function(sid, pw, name)
		print("end: ", function.__name__)
	return wrapper

# 데코레이터 붙인 함수 정의
@decorator_function
def test_decorator_with_params(sid, pw, name):
	print(f'hello: {name}, sid: {sid}, passward: {pw}')

# 데코레이터 붙인 함수 실행
test_decorator_with_params(name="MJ", sid=123, pw=456)
Python
복사

•

예시 코드 실행 및 출력

3) 데코레이터 클래스

•

클래스 형태로 데코레이터 정의

# 데코레이터 정의
class decorator_class:
	def __init__(self, function):
		self.function = function

	def __call__(self, *args, **kargs):
			print("start: ", self.function.__name__)
			self.function(*args, **kargs)
			print("end: ", self.function.__name__)

# 데코레이터 붙인 함수 정의
@decorator_class
def test_decorator_with_params(sid, pw, name):
	print(f'hello: {name}, sid: {sid}, passward: {pw}')

# 데코레이터 붙인 함수 실행
test_decorator_with_params(name="MJ", sid=123, pw=456)
Python
복사

•

예시 코드 실행 및 출력

나. init

1) 용도

•

디렉토리 이하의 모듈(.py)을 패키지로 관리

2) 사용법 비교

•

디렉토리 구조

Project
ㅣ-- a_package
ㅣ     ㅣ-- __init__.py
ㅣ     ㅣ-- feature_a.py
ㅣ     ㅣ-- feature_b.py
ㅣ-- main.py
Plain Text
복사

•

empty __init__.py  in a_package

# main.py
import a_package.feature_a
import a_package.feature_b

a_package.feature_a.furnction_a()
a_package.feature_b.furnction_b()
Python
복사

•

non empty __init__.py in a_package

# __init__.py
from .feature_a import furnction_a
from .feature_b import furnction_b
Python
복사

# main.py
import a_package

a_package.feature_a.furnction_a()
a_package.feature_b.furnction_b()
Python
복사

다. Path

1) path 함수

•

파일의 경로 확인

import sys
from pathlib import Path

path = Path(__file__).resolve().__str__()
print(f'path: {path}')
Python
복사

•

file이 위치한 디렉토리 경로를 python path 추가

→ 파일의 경로: Path(__file__).resolve()

→ 파일의 부모(디렉토리)의 경로: Path(__file__).resolve().parent

import sys
from pathlib import Path

path = Path(__file__).resolve().parent.__str__()
sys.path.append(path) # python path에 파일의 부모 경로 추가
Python
복사

2) package importing issue

•

상황

→ manager-api/FA/urls.py에서 update_farms_from_grpc method 호출

from grpc_client.gclient import update_farms_from_grpc

update_farms_from_grpc()
Python
복사

→ manager-api/grpc_client/farm_pb2 경로의 farm_pb2 모듈을 못찾는 이슈 발생

import farm_pb2

def update_farms_from_grpc():
    with grpc.insecure_channel(GRPC_URL) as channel:
        stub = farm_pb2_grpc.FarmControllerStub(channel)
Python
복사

→ 에러 로그

File "/Users/maxwell/PycharmProjects/manager-api/FA/urls.py", line 10, in <module>
    from grpc_client.gclient import update_farms_from_grpc
File "/Users/maxwell/PycharmProjects/manager-api/grpc_client/gclient.py", line 9, in <module>
  import farm_pb2
Plain Text
복사

•

원인: python path에 manager-api/grpc_client 경로가 존재하지 않으므로 import farm_pb2 만으로 해당 모듈을 경로 상 찾을 수 없음

•

해결: python path에 manager-api/grpc_client 경로를 추가하여 import farm_pb2 만으로 해당 모듈을 경로에서 찾을 수 있도록 수정

import sys
from pathlib import Path
path = Path(__file__).resolve().parent.__str__()
sys.path.append(path)

import farm_pb2

def update_farms_from_grpc():
    with grpc.insecure_channel(GRPC_URL) as channel:
        stub = farm_pb2_grpc.FarmControllerStub(channel)
Python
복사

7. 데이터 길들이기

가. with

1) 객체의 컨텍스트 관리

•

활용: 특정 객체의 생애주기(컨텍스트)가 호출에 따라 값을 반환하고 끝난다면, with 구문으로 감싸는 것은 메모리 관리면에서 효과적 

→ 예시 코드

async with session.get(url) as response:
        html = await response.text()
        soup = BeautifulSoup(html, "html.parser")
        cont_thumb = soup.find_all("div", "cont_thumb")
        for cont in cont_thumb:
            title = cont.find("p", "txt_thumb")
            if title is not None:
                print(title.text)
Python
복사

•

with 구문

with EXPR as VAR:
    BLOCK
Python
복사
code from https://peps.python.org/pep-0343/

•

with 구문 풀이

mgr = (EXPR)
exit = type(mgr).__exit__  # Not calling it yet
value = type(mgr).__enter__(mgr)
exc = True
try:
    try:
        VAR = value  # Only if "as VAR" is present
        BLOCK
    except:
        # The exceptional case is handled here
        exc = False
        if not exit(mgr, *sys.exc_info()):
            raise
        # The exception is swallowed if exit() returns true
finally:
    # The normal and non-local-goto cases are handled here
    if exc:
        exit(mgr, None, None, None)
Python
복사
code from code from https://peps.python.org/pep-0343/

2) File 처리

•

with 구문은 특정 메소드나 클래스 내 선언된 자원 해제 기능을 자동으로 호출하여 자원의 생성, 사용, 소멸 과정을 손쉽게 처리할 수 있음

•

file stream 처리할 때, 자동으로 close 메소드를 자동으로 호출함

# fp-test.json 파일을 열고 json.dump 메소드 호출 뒤 close 메소드 호출
with open('fp-test.json', 'w') as f:
    json.dump(fp_dict, f, ensure_ascii=False)
Python
복사

나. JSON 처리

1) JSON과 Python의 호환

•

 JSON(JavaScript Object Notation)은 Python과의 데이터 호환에 적합함

→ JavaScript와 Python은 같은 C-family 프로그래밍 언어이므로 상호 데이터호환에 적합함

•

인코딩(or 직렬화), 디코딩(or 역직렬화) 간 데이터 호환 참고

2) 직렬화(Python → JSON)

•

json.dump(): 디스크

•

json.dumps(): 메모리 

3) 역직렬화(JSON → Python)

•

json.load(): 디스크

•

json.loads(): 메모리

8. 날짜와 시간

가. datetime

1) 기본 사용

•

특정 조건 이후의 날짜와 시간 계산

addtime = datetime.timedelta(days = 10)
datetime.datetime.now() + addtime    # 10일 후
datetime.datetime.now() - addtime    # 10일 전

thedate = datetime.datetime.now().replace(hour = 10, minute=0, second = 0) + datetime.timedelta(days = 3)       # 3일 후 10시 정각
Python
복사

2) str to datetime

•

문자열을 datetime으로 변환

→ JSON으로 받은 date를 datetime 타입으로 변경 후 날짜 계산시 필요

from datetime import datetime

datetime.strptime("2018-01-31", "%Y-%m-%d")
Plain Text
복사

나. date

1) today

•

datetime의 now()와 유사한 기능

from datetime import date

date.today() - obj.latest_work_date
Plain Text
복사

2) days

•

datetime.date 타입 간 연산 결과를 정수로 받는데 사용

(date.today() - obj.next_work_date)
"exceeded_days": "-86400.0"

(date.today() - obj.next_work_date).days
"exceeded_days": -1
Plain Text
복사

3) str to date

•

문자열을 date type으로 변환

•

datetime.strptime에서 date() 추가호출하여 변환

datetime.strptime(str, '%Y-%m-%d').date()
Python
복사

4) date to str

•

date 타입을 string으로 변환

from datetime import date

test_date = date.today()
test_date_str = test_date.strptime('%Y-%m-%d')
Python
복사

5) 두 날짜 사이의 날짜 생성

•

timedelta를 활용

def _generate_dates(date__gte, date__lte):
    start_date = datetime.strptime(date__gte, "%Y-%m-%d").date()
    end_date = datetime.strptime(date__lte, "%Y-%m-%d").date()
    delta = end_date - start_date
    dates = [start_date + timedelta(days=i) for i in range(delta.days + 1)]
    
    return dates
Python
복사

9. Collections

가. Counter

1) 가장 빈번한 요소 찾기

•

n개의 가장 빈번한 요소 찾기: Counter().most_common(n)

Counter('abracadabra').most_common(3)
[('a', 5), ('b', 2), ('r', 2)]
Python
복사

def mostCommonWord(self, paragraph: str, banned: Llst[str]) -> str: 
	words = [word for word In re.sub(r'[^Xw]', ' ', paragraph).lower().split()
								if word not in banned]
	counts = collections.Counter(words)
	return counts.most_common(1)[0][0]
Python
복사

나. defaultdict

존재하지 않는 key를 삽입할 때 발생하는 에러를 방지하기 위해 key 존재여부를 확인하는 절차를 생략할 때, defaultdict를 사용하면 좋다

1) difaultdict(int)

•

key:value 쌍에서 지정하지 않은 키의 value를 조회하면 기본값이 0이 된다.

int_dict = collections.defaultdict(int)
print(int_idct[key_1]) // 0
Python
복사

2) difaultdict(list)

•

key:value 상에서 value의 기본값이 빈 리스트가 된다.

list_dict = collections.defaultdict(list)
print(list_dict[key_1]) // []
Python
복사

3) difaultdict(set)

list_dict = collections.defaultdict(set)
print(list_dict[key_1]) // set()
Python
복사

Reference

•

Introducing Python 2nd Edit, Bill Lubanovic

•

파이썬 입문, 프로그래머스, https://programmers.co.kr/learn/courses/2#introduction

•

함수-매개변수, https://jhproject.tistory.com/109

•

Super, https://sirzzang.github.io/dev/Dev-python-super/

•

File stream, https://devpouch.tistory.com/79

•

Json 데이터 처리, https://rfriend.tistory.com/474

•

GIL, https://realpython.com/python-gil/

•

decorator, https://dojang.io/mod/page/view.php?id=2454, https://wikidocs.net/6723

•

Mixin, https://riptutorial.com/python/example/15228/mixin

•

자료구조별 시간복잡도, https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt

•

vscode ide 설정, https://earth-95.tistory.com/85

•

collections.Counter, https://docs.python.org/3/library/collections.html#collections.Counter