🤍

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/23

- 해시테이블 (hashtable) 

해시테이블은 작은 리소스로 많은 데이터를 효율적으로 관리한다. 

해시 테이블은 key와 value를 기반으로 데이터를 저장한다. 

*** Hash값을 확인 함으로써 중복이 허용되는지 안되는지 알 수 있음 . 

# Hash 값 확인  ---> 중복이 허용되는지 안되는지 , 
t1 = (10, 20, (30, 40, 50))
t2 = (10, 20, [30, 40, 50])

print('EX1-2 - ', hash(t1))
# print('EX1-3 - ', hash(t2))  #---> 리스트가 포함되어 있기 때문에 해쉬 쓸 수 없음 

- 지능형 딕셔너리 (Comprehending Dict) 

(예제) 국가코드 csv 파일 -> tuple 변환 -> Dictionary 변환 

(1) csv 파일 불러와서 tuple로 변환하기 ( 파일: 패캠 제공 ) 

import csv
from os import kill
from typing import Counter 

# 외부 CSV TO List of tuple  
with open('./resources/test1.csv', 'r', encoding='UTF-8') as f:
    temp = csv.reader(f)
    # Header Skip
    next(temp)
    print()
    # 변환 
    NA_CODES = [tuple(x) for x in temp]

print('EX2-1 - ')
print(NA_CODES)

두줄까지만 캡쳐. 최종적으로 나라 코드 튜플이 들어간 리스트를 만들었다. 

(2) Dictionary 로 변환 (지능형 Dictionary 사용) 

n_code1 = {country: code for country, code in NA_CODES}
n_code2 = {country.upper() : code for country, code in NA_CODES}

n_code2는 key값을 대문자로 바꿔주기까지 한 것. 

- Dict Setdefault  

source = (('k1', 'val1'),
            ('k1', 'val2'),
            ('k2', 'val3'),
            ('k2', 'val4'),
            ('k2', 'val5'))

new_dict1 = {}
new_dict2 = {}

(1) No use setdefault 

for k, v in source:
    if k in new_dict1:
        new_dict1[k].append(v)
    else:
        new_dict1[k] = [v]

print('EX3-1 - ', new_dict1)

중복되는 key가 있으면, 리스트에 append해서 dict를 만드는 코드이다. 

(2) Use setdefault ( 이것의 성능이 더 좋다고 한다. ) 

for k, v in source:
    new_dict2.setdefault(k, []).append(v)

print('EX3-2 - ', new_dict2)

setdefault를 사용하면 if문을 사용하지 않고도 이렇게 간단하게 한줄로 구현할 수가 있다.

- 사용자 정의 dict 상속 

class UserDict(dict):
    def __missing__(self, key):
        print('Called : __missing__')
        if isinstance(key, str):
            raise KeyError(key)
        return self[str(key)]

    def get(self, key, default=None):
        print("Called : __getitem__")
        try:
            return self[key]
        except KeyError:
            return default

    def __contains__(self, key):
        print("Called : __contains__")
        return key in self.keys() or str(key) in self.keys()

dict를 상속받아서 클래스를 생성할 수 있다. 

user_dict1 = UserDict(one=1, two=2)
user_dict2 = UserDict({"one" : 1, "two" : 2})
user_dict3 = UserDict([('one', 1), ('two', 2)])

이렇게 딕셔너리 객체를 만들어 줄 수 있다. 

print('EX4-1 - ', user_dict1, user_dict2, user_dict3)
print('EX4-2 - ', user_dict2.get("two"))
print('EX4-3 - ', 'one' in user_dict3)
# print('EX4-4 - ', user_dict3['three'])
print('EX4-5 - ', user_dict3.get('three'))
print('EX4-6 - ', 'three' in user_dict3)

주석처리한 EX4-4 를 실행하면 

__missing__ 이 호출되면서 위에서 정의했던 키에러가 발생하게 된다. 

- Immutable Dict 

from types import MappingProxyType

d = {'key1' : 'TEST1'}
# Read Only
d_frozen = MappingProxyType(d)

print('EX5-1 - ', d, id(d))
print('EX5-2 - ', d_frozen, id(d_frozen))
print('EX5-3 - ', d is d_frozen, d == d_frozen)

# d_frozen['key1'] = 'TEST2'  # ===> 바뀌지 않음 

# 원본은 수정 가능 
d['key2'] = 'TEST2'
print('EX5-4 - ', d)

d와 d_frozen 은 다른 객체 (다른 id) 이고, 값(내용)은 같다고 나오는 것을 볼 수 있다. 

d_frozen을 수정하려고 시도하면 에러가 난다. 읽기만 가능한 것이다. 

원본인 d는 수정(추가, 삭제, 변경)이 가능하다. 

- Set 

s1 = {'Apple', 'Orange', 'Apple', 'Orange', 'Kiwi'}
s2 = set(['Apple', 'Orange', 'Apple', 'Orange', 'Kiwi'])
s3 = {3}
s4 = set()  # Not {}
s5 = frozenset({'Apple', 'Orange', 'Apple', 'Orange', 'Kiwi'})

한가지 주의할 점은 비어있는 set객체를 만들 땐 set() 을 사용하여야 한다. {} 으로 생성하면 dict 객체가 생성된다. 

# 추가 
s1.add('Melon')

# 추가 불가 
# s5.add('Melon')

print('EX6-1 - ',  s1, type(s1))
print('EX6-2 - ',  s2, type(s2))
print('EX6-3 - ',  s3, type(s3))
print('EX6-4 - ',  s4, type(s4))
print('EX6-5 - ',  s5, type(s5))

Immutable Dict와 같이 frozenset으로 수정이 불가하게 만들 수 있다. 

- 선언 최적화 

a = {5}  # ---> 이게 더 빠르다. 
b = set([10])

 *** 증명 

from dis import dis 
print('EX6-5 - ')
print(dis('{10}'))

print('EX6-6 - ')
print(dis("set([10])"))

dis를 사용하면 실행되는 순서를 볼 수 있다. 

{10} 의 절차가 더 적다!

- 지능형 집합 (Comprehending Set) 

from unicodedata import name

print('EX7-1 - ')
print({name(chr(i), "") for i in range(0, 256)})

딕셔너리와 비슷하게 for문을 {}안에 넣어주어 지능형 집합을 생성할 수 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/22

• 컨테이너 (Container) : 서로 다른 자료형 포함 가능 

list, tuple, collections.deuqe  (ex) list --->[1, 3.0, 'hi']

• Flat : 한개의 자료형만을 포함 

str, bytes, bytearray, array.array, memoryview 

• 가변 

list, bytearray, array.array, memoryview, deque

• 불변 

tuple, str, bytes 

나름 파이썬을 배우는 전공자이지만 심화과정 강의를 들으며 아직 모르는 게 정말 많은 것 같다는 생각이 든다. 

위의 자료형들만 봐도! 

이번 포스팅에서는 지능형 리스트, 제너레이터, 튜플, 딕셔너리의 내용을 깊게 들어간다. 

- 지능형 리스트 (Comprehending Lists) 

*** None comprehending LIsts 

chars = '!@#$%^&*()_+'
codes1 = []

for s in chars:
    # 유니코드 변환
    codes1.append(ord(s))

지능형 리스트를 사용하지 않고 일반적으로 for문을 이용하여 리스트 안에 값을 넣어주는 예시이다. 

*** Comprehending Lists 

엄청 큰 영향을 끼치게 되는 것은 아니지만, 빅데이터 분야와 같이 데이터가 현저하게 많아지면 이 방법을 쓰는 것이 성능, 속도 면에서 더 유리하다고 한다. 

codes2 = [ord(s) for i in chasrs]

리스트 안에서 바로 for문을 사용하는 것이다. 

*** Comprehending LIst + Map, Filter

이 방법 역시 속도가 약간 우세함 . 

codes3 = [ord(s) for s in chars if ord(s) > 40]
codes4 = list(filter(lambda x : x > 40, map(ord, chars)))

결과적으로 codes3와 codes4 리스트 안의 값들을 같다. codes3는 for문과 if문을 사용 , codes4는 map함수로 chars의 값들에 ord함수를 적용 시킨 후 , lambda, filter를 사용하여 40보다 큰 값들만 나오게 만들어준다.

*** 출력해보기

print('EX1-1 - ', codes1)
print('EX1-2 - ', codes2)
print('EX1-3 - ', codes3)
print('EX1-4 - ', codes4)
print('EX1-5 - ', [chr(s) for s in codes1])
print('EX1-6 - ', [chr(s) for s in codes2])
print('EX1-7 - ', [chr(s) for s in codes3])
print('EX1-8 - ', [chr(s) for s in codes4])

EX1-5부터는 ord와 반대로 chr()를 이용하여 다시 바꾸어서 리스트에 넣어 주는 코드이다. 

*** 리스트 주의할 점 

marks1 = [['~'] * 3 for n in range(3)]
marks2 = [['~'] * 3] * 3

print("EX4-1 - ", marks1)
print("EX4-2 - ", marks2)

이 두가지를 출력하면 

결과는 같다. 

--> 값 하나 변경 

marks1[0][1] = 'X'
marks2[0][1] = 'X'

print('EX4-3 - ', marks1)
print('EX4-3 - ', marks2)

분명 형태는 같았는데, 0번째 리스트의 1번째 값을 변경하는 코드를 작성했지만, 두번째는 0, 1, 2번째의 1번쨰 값이 모두 바뀌었다. 

---> 증명 

print('EX4-5 - ', [id(i) for i in marks1])
print('EX4-6 - ', [id(i) for i in marks2])

위와 같이 marks1의 리스트 들은 모두 다른 객체이므로 id값이 다르지만, marks2의 리스트들은 같은 리스트를 3번 반복해 놓은 것과 같기 때문에 id값이 모두 같다. 같은 곳을 바라보고 있기 때문에 0번쨰 리스트의 값만 바꾸면 1, 2번째 리스트의 값도 함께 바뀌는 것이다. 

데이터 분석을 할 때 이런 실수를 한다고 생각하면 끔찍하다!

- 제너레이터 , Generator & Array 

(1) 제너레이터

제너레이터는 한 번에 한 개의 항목을 생성하므로 메모리를 유지하지 않는다. 메모리를 차지하지 않기 때문에 빅데이터를 쓸 때는 Generator가 훨씬 우세하다고 한다. 

tuple_g = (ord(s) for s in chars)  # 아직 메모리를 생성한 상태가 아님

이처럼 튜플 안에 for문을 써주면 제너레이터 객체가 생성된다. 아직 메모리를 생성한 상태가 아니라는 것! 

(2) Array 

import array 
array_g = array.array('I', (ord(s) for s in chars))

array를 import해준다. 처음 써보아서 문서를 찾아서 읽어보았다. 

<array.array 참고 문서>

https://docs.python.org/3/library/array.html

*** 출력, 사용해보기 

print('EX2-1 - ', tuple_g)  
print('EX2-2 - ', next(tuple_g))
print('EX2-3 - ', next(tuple_g))
print('EX3-4 - ', array_g)
print('EX3-4 - ', array_g.tolist())

제너레이터는 next 또는 for문을 이용하여 값을 꺼낼 수 있다. 

array를 리스트로 변환하고 싶다면 tolist()를 사용한다. 

*** 제너레이터 for문으로 사용하기 

print('EX3-1 - ', ('%s' % c + str(n) for c in ['A', 'B', 'C', 'D'] for n in range(1, 11)))

for s in ('%s' % c + str(n) for c in ['A', 'B', 'C', 'D'] for n in range(1, 11)):
    print('EX3-2 - ', s)

for문으로 제너레이터 객체에서 값들을 하나씩 꺼내주는 코드  . 

- Tuple Advanced

*** packing & unpacking

print('EX5-1 - ', divmod(100, 9))
print('EX5-2 - ', divmod(*(100, 9)))
print('EX5-3 - ', *(divmod(100, 9)))

divmod는 몫과 나머지를 튜플로 반환해주는 함수이다. 튜플 앞에 *을 붙이면 unpaking이 된다는 것 !

x, y, *rest = range(10)
print('EX5-4 - ', x, y, rest)
x, y, *rest = range(2)
print('EX5-5 - ', x, y, rest)
x, y, *rest = 1, 2, 3, 4, 5
print('EX5-6 - ', x, y, rest)

참고) ** ---> dictionary 를 받음 

(ex) def test(*args, **args):

- Mutable (가변) vs Immutable (불변) 

l = (10, 15, 20)
m = [10, 15, 20]

print('EX6-1 - ', l, m, id(l), id(m))

리스트와 튜플 객체를 각각 생성해준다. 

# 객체를 새로 생성 ---> 메모리를 더 잡아먹을 수도 있다는 것 
l = l * 2
m = m * 2 

print('EX6-2 - ', l, m, id(l), id(m))

# 자체에서 연산 
l *= 2 
m *= 2

print('EX6-3 - ', l, m, id(l), id(m))

l = l*2 와 같은 코드는 객체를 새로 생성한다는 것이다. 출력된 id값을 봐도 리스트와 튜플 모두 새로운 객체가 생성된 것을 알 수 있다. 

l *= 2 와 같이 자체에서 연산을 할 때는 가변형인 리스트는 객체를 새로 만들지 않고, 불변형인 튜플은 객체를 새로 만든다. 

-  sort vs sorted 

f_list = ['ornage', 'apple', 'mango', 'papaya', 'lemon', 'strawberry','coconut']

(1) sorted : 정렬 후 새로운 객체 반환

print('EX7-1 - ', sorted(f_list))
print('EX7-2 - ', sorted(f_list, reverse=True)) # 역순으로 정렬 
print('EX7-3 - ', sorted(f_list, key=len)) # 길이순서 
print('EX7-4 - ', sorted(f_list, key=lambda x: x[-1]))
print('EX7-5 - ', sorted(f_list, key=lambda x: x[-1], reverse=True))

print('EX7-6 - ', f_list)

sorted 의 인자에는 정렬할 리스트와 정렬할 조건을 넣어준다. 

객체를 새로 반환하기 때문에, 원본 리스트에는 변화가 없다. 

(2) sort : 정렬 후 객체 직접 변경 

a = f_list.sort()

print('EX7-7 - ', f_list.sort(), f_list)
print('EX7-8 - ', f_list.sort(reverse=True), f_list)
print('EX7-9 - ', f_list.sort(key=len), f_list)
print('EX7-10 - ', f_list.sort(key=lambda x: x[-1]), f_list)
print('EX7-11 - ', f_list.sort(key=lambda x: x[-1], reverse=True), f_list)

sort는 객체를 직접 변경하기 때문에, f_list.sort() 자체를 출력하면 None이 나온다. (None---> 반환값이 없다는 뜻) 그래서 원본인 f_list를 출력해주어야 변경된 리스트를 볼 수 있다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/21

<매직 메소드 관련 문서>

https://docs.python.org/3/reference/datamodel.html#special-method-names

https://www.tutorialsteacher.com/python/magic-methods-in-python

파이썬의 중요한 핵심 프레임 워크 : 시퀀스(Sequence), 반복(Iterator), 함수(Functions), 클래스(Class) 

- 매직메소드 

n = 100 
print(dir(n)) # 모든 속성 및 메소드 출력 

__xxx__ ----> 매직 메소드 

*** 사용 

print('EX1-1 - ', n + 200)
print('EX1-2 - ', n.__add__(200))
print('EX1-3 - ', n.__doc__)
print('EX1-4 - ', n.__bool__(), bool(n))
print('EX1-5 - ', n * 100, n.__mul__(100))

매직 메소드는 파이썬에서 이미 정의된 메서드라고 보면 된다. 이보다도 더 다양한 매직 메소드들이 있다. 

이러한 정수형 타입의 객체는 그냥 + , * 이러한 기호들로 사용할 수 있겠지만, 직접 클래스를 만들어 사용할 때는 직접 정의를 해서 유용하게 사용할 수 있다. 

- 클래스 매직 메소드 예제 

(1) 클래스 생성 

class Student:
    # 매직 메서드임. 파이썬에서 이미 정의된 멘서드 
    def __init__(self, name, height):
        self._name = name
        self._height = height

    def __str__(self):
        return 'Student Class Info : {}, {}'.format(self._name, self._height)

    def __ge__(self, x):
        print("Called >> __ge__ Method.")
        if self._height >= x._height:
            return True
        else:
            return False

    def __le__(self, x):
        print("Called >> __le__ Method")
        if self._height <= x._height:
            return True
        else:
            return False

    def __sub__(self, x):
        print('Called >> __sub__ Method.')
        return self._height - x._height

위의 문서에서 가져온 매직 메서드 의미 

__str__ ---> To get called by built-int str() method to return a string representation of a type.

__le__ ---> To get called on comparison using <= operator.

__ge__ ---> To get called on comparison using >= operator.

__sub__ ---> To get called on subtraction operation using - operator.

(2) 사용 

*** 인스턴스 생성 

s1 = Student('James', 181)
s2 = Student('Mie', 165)

Student 클래스의 인스턴스 생성!

*** 매직 메소드 출력 

print('EX2-1 - ', s1 >= s2)
print('EX2-2 - ', s1 <= s2)
print('EX2-3 - ', s1 - s2)
print('EX2-4 - ', s2 - s1)
print('EX2-5 - ', s1)
print('EX2-6 - ', s2)

클래스에 매직메소드를 정의하지 않았다면 객체와 객체간의 비교로 받아들이기 때문에 오류가 난다. 

클래스에서 직접 정의를 해놨으므로 오류가 나지 않고 정의한 대로 나온다. 

이와같이 매직메소드를 직접 정의하여 유용한 활용이 가능하다. 

- 클래스 메직메소드 사용 예제 2

(1) 클래스 생성 

class Vector(object):
    def __init__(self, *args):
        '''Create a vector, example : v = Vector(1, 2)'''
        if len(args) == 0:
            self._x, self._y = 0, 0
        else:
            self._x, self._y = args

    def __repr__(self):
        '''Returns the Vector information'''
        return 'Vector(%r, %r)' % (self._x, self._y)

    def __add__(self, other):
        '''Returns the vector addition of self and other'''
        return Vector(self._x + other._x, self._y + other._y)

    def __mul__(self, t):
        '''Returns the vector addition of self and other'''
        return Vector(self._x * t, self._y * t)

    def __bool__(self):
        return bool(max(self._x, self._y))

벡터를 생성해주는 클래스이다. 

__add__메소드는 벡터끼리 각 좌표에 대한 덧셈, __mul__메소드는 실수를 인자에 넣어주면 각 좌표에 곱해지는 것을 구현한 것이다. __bool__메소드는 x, y 좌표 중 큰 값이 0이 아니면 True를 반환하게 해준다. (정말 구현하고 싶은 대로 구현하면 된다!)

(2) 사용 

# Vector 인스턴스 생성
v1 = Vector(3, 5)
v2 = Vector(15, 20)
v3 = Vector()

# 매직 메소드 출력 
print("EX3-1 - ", Vector.__init__.__doc__)
print("EX3-2 - ", Vector.__repr__.__doc__)
print("EX3-3 - ", Vector.__add__.__doc__)
print("EX3-4 - ", v1, v2, v3)
print("EX3-5 - ", v1 + v2)
print("EX3-6 - ", v1 * 4)
print("EX3-7 - ", v2 * 10)
print('EX3-8 - ', bool(v1), bool(v2))
print('EX3-9 - ', bool(v3))

__doc__ 를 사용하면 위에서 작성했던 주석 설명이 출력된다. 나머지도 잘 실행되면 성공!

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/20

<데이터 모델 참고 문서> 

https://docs.python.org/3/reference/datamodel.html

[ 객체 (Objects)는 파이썬이 데이터(data)를 추상화한 것(abstraction)입니다. 파이썬 프로그램의 모든 데이터는 객체나 객체 간의 관계로 표현됩니다.

모든 객체는 아이덴티티(identity), 형(type), 값(value)을 갖습니다. 객체의 아이덴티티 는 한 번 만들어진 후에는 변경되지 않습니다. 메모리상에서의 객체의 주소로 생각해도 좋습니다. 〈is〉 연산자는 두 객체의 아이덴티티를 비교합니다. id() 함수는 아이덴티티를 정수로 표현한 값을 돌려줍니다. ]

위의 문서에서 나와있는 객체의 설명이다. 모든 객체는 id, type, value를 갖는다. 예를 들어 

a = 7 
print(id(a), type(a), dir(a))

이러한 a라는 변수도 객체라는 것이다. 따라서 id, type, value를 모두 갖고 있다는 것을 알 수 있다. 

- 네임트 튜플 

<두 점 사이의 거리를 구하는 예제>

(1) 일반적인 튜플 사용

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

from math import sqrt
from typing import ClassVar
line_leng1 = sqrt((pt2[0] - pt1[0]) ** 2 + (pt2[1] - pt1[1]) ** 2)
print('EX1-1 : ', line_leng1)

이렇게 인덱스를 이욯하여 구하게 된다. 이렇게 간단한 예제에서는 상관이 없긴 하지만 가독성이 떨어지는 것 같긴 하다. 조금 더 복잡한 수식이라면 실수하기 딱좋다! x값 끼리 빼주고 , y값 끼리 빼주는 것을 더 명시적으로 적어줄 수 있는 named tuple을 사용해 보자! 

(2) 네임드 튜플 사용 

*** named tuple 선언법 

from collections import namedtuple

Point1 = namedtuple('Point', ['x', 'y'])
Point2 = namedtuple('Point', 'x, y')
Point3 = namedtuple('Point', 'x y')
Point4 = namedtuple('Point', 'x y x class', rename=True) # Defalult=False

# 출력 
print('EX2-1 - ', Point1, Point2, Point3, Point4)

# Dict to Unpacking
temp_dict = {'x' : 75, 'y' : 55}

# 객체 생성 
print()
p1 = Point1(x=10, y=35)
p2 = Point2(20, 40)
p3 = Point3(45, y=20)
p4 = Point4(10, 20, 30, 40)
p5 = Point3(**temp_dict)



print('EX2-2 - ', p1, p2, p3, p4, p5)

collections의 namedtuple을 import해준다. 네임드 튜플은 클래스로 하기엔 너무 헤비하고, 튜플에 이름을 주고 싶을 때 사용한다. 

point4에서는 x가 중복으로 들어 가 있고, class도 변수명으로 사용할 수 없으므로 rename=True를 설정해 놓지 않는다면 오류가 날 것이다. 

rename=True를 설정해 놓으면 위와같이 알아서 변수명이 바뀌게 된다. 

*** 사용

print('EX3-1 - ', p1[0] + p2[1])  # Index Error 주의 
print('EX3-2 - ', p1.x + p2.y) # 클래스 변수 접근 방식

# Unpacking 
x, y = p3

print('EX3-3 - ', x + y)

기존 tuple과 같이 Unpacking도 가능하다. 

*** 네임드튜플의 메소드 

• _make() : 새로운 객체를 생성 (리스트 ---> 네임드튜플) 

p4 = Point1._make(temp)
print('EX4-1 - ', p4)

• _field : 필드  네임 확인 

print('EX4-2 - ', p1._fields, p2._fields, p3._fields)

• _asdict() : OrderDict 반환 

# _asdict() : OrderDict 반환 
print('EX4-3 - ', p1._asdict(), p1._asdict(), p3._asdict(), p4._asdict())

• _replace() : 수정된 '새로운' 객체 반환 

print('EX4-4 - ', p2._replace(y=100)) 

이렇게 필드에 대한 값을 변경해줄 수 있는데, 이는 리스트 처럼 값이 변경되는 것이 아니라 , 아예 새로운 객체를 반환해 주는 것이다. 

*** 예제

# 네임드 튜플 선언 
Point = namedtuple('Point', 'x y')

# 두 점 선언 
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)

# 두 점 사이의 거리 계산
line_leng2 = sqrt((pt2.x - pt1.x) ** 2 + (pt2.y - pt1.y) ** 2)

# 출력
print("EX1-2 - ", line_leng2)
print("EX1-3 - ", line_leng1 == line_leng2)

그래서 원래 하려했던 예제를 네임드 튜플을 사용하면 위와 같다. 네임드튜플을 사용하면 위와같이 더 명시적으로 수식을 작성해줄 수 있다. 

- 네임드 튜플 실습 

학생 그룹을 생성하는 예제, 4개의 반(A, B, C, D) 에서 각각 20명의 학생이 존재

(1) 네임드 튜플 선언 

Classes = namedtuple('Classed', ['rank', 'number'])

(2) 그룹 리스트 선언 (List Comprehension 사용)

# List Comprehension
numbers = [str(n) for n in range(1, 21)]
ranks = 'A B C D'.split()
print(ranks, numbers)

print()

# List Comprehension
students = [Classes(rank, number) for rank in ranks for number in numbers]

print('EX5-1 - ', len(students))
print('EX5-2 - ', students[4].rank)

number는 1~20의 문자를 담고있는 리스트, ranks는 A~B의 문자를 담고 있는 리스트이다. 

이제 네임드 튜플의 객체들을 list comprehension을 사용하여 생성해 준다. 총 20 * 4 = 80 개의 객체가 리스트 안에 생성될 것이다. 

*** 가독성이 떨어지지만 한번에 그룹리스트를 만드는법 

students2 = [Classes(rank, number) for rank in 'A B C D'.split() for number in [str(n) for n in range(1, 21)]]

print('EX6-1 - ', len(students2))
print('EX6-1 - ', students2)

리스트에 한번에 때려박아 주는 법이다. 뭐든지 과하면 독이 되는 것 같다. 가독성이 떨어지지만 이런 방법도 있다는 것을 알아두기. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/19

- 클래스 확장 

이번에는 클래스에 인스턴스 메소드, 클래스 메소드 , 스테이틱 메소드를 구현을 해 본다. 

class Student(object):
    """
    Student Class
    Author : Kim
    Date : 2021. 6. 28 
    Description : Class, Static, Instance Method
    """

    # Class Variable
    tuition_per = 1.0

    def __init__(self, id, first_name, last_name, email, grade, tuition, gpa):
        self._id = id
        self._first_name = first_name
        self._last_name = last_name
        self._email = email
        self._grade = grade
        self._tuition = tuition
        self._gpa = gpa

    # Instance Method 
    def full_name(self):
        return "{}, {}".format(self._first_name, self._last_name)
    
    # Instance Method
    def detail_info(self):
        return 'Student Detail Info : {}, {}, {}, {}, {}, {}'.format(self._id, self.full_name(), self._email, self._grade, self._tuition, self._gpa)

    # Instance Method
    def get_fee(self):
        return 'Beforoe Tuition -> Id : {}, fee : {}'.format(self._id, self._tuition)

    # Instance Method
    def get_fee_culc(self):
        return 'After tuition -> Id : {}, fee : {}'.format(self._id, self._tuition * Student.tuition_per) 
    
    # Instance Method
    def __str__(self):
        return 'Student Info -> name : {} grade : {} email : {}'.format(self.full_name(), self._grade, self._email)
        
    # Class Method
    @classmethod
    def raise_fee(cls, per):
        if per <= 1:
            print('Please Enter 1 or More')
            return 
        Student.tuition_per = per
        print('Succeed! tuition increased.')

    # Class Method
    @classmethod
    def student_const(cls, id, first_name, last_name, email, grade, tuition, gpa):
        return cls(id, first_name, last_name, email, grade, tuition * cls.tuition_per, gpa)

    # Static Method
    @staticmethod # ---> 요새는 잘 쓰진 않는다. 
    def is_scolarship_st(inst):
        if inst._gpa >= 4.3:
            return '{} is a scholarship recipient'.format(inst._last_name)
        return 'Sorry, Not a scholarship recipient'

Instance Method는 self의 접근자(개개인, 고유한 객체)를 이용하여 속성에 접근할 수 있다. 첫번째 인자에 self가 들어가는 것은 인스턴스 메소드라고 생각을 하면 된다. 

Class Method 첫번째 인자로 클래스를 받아주어야 한다. 대부분 cls라고 쓴다. 또 , 메소드를 작성하기 전에 데코레이터를 작성해 주어야 한다. (@classmethod) 클래스 자체로 접근할 수 있다. 

Static Method 일반 함수의 기능을 하는 메소드이다. 즉, 클래스 안에 굳이 넣지 않아도 되고 클래스 밖에서 생성해도 되는 메소드이다. 그래도 위에처럼 장학금 받는지에 대한 여부는 student클래스와 연관이 되어있으므로 안에 써주는 것이 더 보기 편할 것이다. 

- 인스턴스 생성 

student_1 = Student(1, 'Kim', "silver", 'student1@naver.com', '1', 400, 3.5)
student_2 = Student(2, 'Han', "golye", 'student2@daum.net', '2', 500, 4.3)

# 기본정보 
print(student_1)
print(student_2)

print()

# 전체 정보
print(student_1.detail_info())
print(student_2.detail_info())

- 등록금 

# 학비 정보 (등록금 인상 전)
print(student_1.get_fee())
print(student_2.get_fee())

* 학비 인상 (클래스 메소드 사용)

# 학비 인상 (클래스 메소드 미사용) ---> 이렇게 직접 접근하는 거 좋지 않다. 
# Student.tuition_per = 1.2

# 학비 인상 (클래스 메소드 사용) 
Student.raise_fee(1.2)

* 인상 시킨 후의 학비 정보 

print(student_1.get_fee_culc())
print(student_2.get_fee_culc())

- 클래스 메소드를 이용하여 인스턴스 생성하기 

student_3 = Student.student_const(3, 'Park', 'silver', 'Student3@gmail.com', '3', 550, 4.5)
student_4 = Student.student_const(4, 'Cho', 'golye', 'student4@gmail.com', '4', 600, 4.1)

Class Method로 생성해 놓았던 student_const를 이용하여 인스턴스를 생성할 수도 있다.  

*** 똑같이 실습 

# 전체 정보 
print(student_3.detail_info())
print(student_4.detail_info())
print()

# 학생 학비 변경 확인
print(student_3._tuition)
print(student_4._tuition)
print()

- Static Method 를 이용하여 장학금 혜택 여부 알아보기 

(1) static method 미사용 

def is_scholarship(inst):
    if inst._gpa >= 4.3:
        return '{} is a scholarship recipient'.format(inst._last_name)
    return 'Sorry, Not a scholarship recipient'

이처럼 클래스 안에 굳이 넣지 않아도 사용 가능하다. 

* 사용

print(is_scholarship(student_1))
print(is_scholarship(student_2))
print(is_scholarship(student_3))
print(is_scholarship(student_4))

이렇게 함수에 인스턴스를 넣어주면 장학금 대상 여부가 반환된다. 

(2) static method 사용 

Student 클래스 안에 구현해 놓은 static method에 접근하는 방법이다. 

print(Student.is_scolarship_st(student_1))
print(Student.is_scolarship_st(student_2))
print(Student.is_scolarship_st(student_3))
print(Student.is_scolarship_st(student_4))


print(student_1.is_scolarship_st(student_1))
print(student_2.is_scolarship_st(student_2))
print(student_3.is_scolarship_st(student_3))
print(student_4.is_scolarship_st(student_4))

Student 클래스 자체로 접근이 가능하고, 객체를 통한 접근 또한 가능하다. 

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

<이전 글>

https://silvercoding.tistory.com/18

클래스 확장 

Student 클래스에 클래스 변수와 인스턴스 변수를 생성하여 이에 대한 개념을 이해 해보자.

- 클래스 생성 

class Student():
    """
    Student Class
    Author : silver
    Date : 2021. 06. 30 
    """

    # 클래스 변수 
    student_count = 0 

    def __init__(self, name, number, grade, details, email=None):
        # 인스턴스 변수
        self._name = name
        self._number = number
        self._grade = grade
        self._details = details
        self._email = email

        Student.student_count += 1 

    def __str__(self):
        return 'str {}'.format(self._name)

    def __repr__(self):
        return 'repr {}'.format(self._name)

    def detail_info(self):
        print('Current Id : {}'.format(id(self)))
        print('Student Detail Info : {} {} {}'.format(self._name, self._email, self._details))

    def __del__(self):
        Student.student_count -= 1 

우선 클래스를 생성해 준다. 주석으로 클래스 변수와 인스턴스 변수를 구분해 놓았다. 

말그대로 클래스 변수는 클래스 자체에서 접근이 가능한 변수, 인스턴스 변수는 생성된 인스턴스로 접근이 가능한 변수이다. 따라서 클래스 안에 student_count 클래스 변수를 선언하고, 생성자 메서드에서 쓴 것과 같이 Student.student_count += 1 처럼 클래스로 접근하여 사용이 가능하다. 인스턴스 변수는 self가 붙어 있다. 객체를 통하여 접근이 가능하기 때문이다. 

- 객체 생성 

studt1 = Student('Cho', 2, 3, {'gender': 'Male', 'score1': 65, 'score2': 44})
studt2 = Student('chang', 4, 1, {'gender': 'Female', 'score1': 85, 'score2': 74}, "onestein@google.com")

 두 개의 객체를 생성해 준다. 

- id 확인 

print(id(studt1))
print(id(studt2))

*** == , is 의 차이 

== : 값을 비교 

print(studt1._name == studt2._name)

is : id 값을 비교 

print(studt1 is studt2)

- dir & __dict__ & __doc__

(1) 내장함수 dir 

https://wikidocs.net/10307

dir() 내장 함수는 어떤 객체를 인자로 넣어주면 해당 객체가 어떤 변수와 메소드(method)를 가지고 있는지 나열해 준다. 

print(dir(studt1))
print(dir(studt2))

따라서 Student의 객체 studt1, studt2를 dir 인자에 넣어서 변수와 메소드를 확인할 수 있다. 

인스턴스 변수와 클래스변수까지 모두 나오는 것을 볼 수 있다. 

(2) __dict__ 

https://wikidocs.net/1743

클래스 또는 인스턴스에 대한 네임스페이스를 확인한다. 

print(studt1.__dict__)
print(studt2.__dict__)

이렇게 dictionary 구조로 나오게 된다. 

(3) __doc__ 

print(Student.__doc__)

__doc__ 클래스 안에있는 설명 주석을 보여준다. 

- 메소드 실행해보기 

# 인스턴스로 접근 
studt1.detail_info()
studt2.detail_info()


# Student.detail_info() ---> 에러 남 


# 클래스로 접근
Student.detail_info(studt1)
Student.detail_info(studt2)

인스턴스로 접근하는 것이 일반적인 방법이고, 클래스로도 접근할 수 있다. 클래스로 접근하면 인자에 객체를 넣어주어야 한다. self를 채워주어야 하기 때문이다. 

- __class__ 

print(studt1.__class__, studt2.__class__)
print(id(studt1.__class__) == id(studt2.__class__))

Student 클래스를 반환한다. 객체는 각각 다른 id값을 가지지만, 클래스는 같은 id값을 가지고 있다는 것을 알 수 있다. (당연한 소리) 

- 인스턴스 변수와 클래스 변수의 접근 

(1) 인스턴스 변수 접근

print(studt1._name, studt2._name)
print(studt1._email, studt2._email)

이렇게 인스턴스를 통하여 접근할 수 있다. 

studt1._name = "Lee" 이런 식으로 직접 접근으로 값을 바꾸는 코드는 문법적으로 권장하지 않는다고 한다. 

(2) 클래스 변수 접근 

print(studt1.student_count)
print(studt2.student_count)
print(Student.student_count)

클래스 변수는 인스턴스로도 , 클래스 자체로도 접근이 가능하다. 인스턴스로 접근을 할 때에는 인스턴스 네임스페이스에 없으면 상위(클래스) 에서 검색한다. 인스턴스 검색 -> 상위 검색 (클래스, 부모 클래스) 순서이기 때문에 동일한 이름으로 변수 생성도 가능하다. 

- __del__ 호출

del studt2

print(studt1.student_count)
print(Student.student_count)

__del__ 메소드를 호출했을 때 student_count도 줄어들도록 만들었으므로 출력해 보면 1이 되어있다. 

코드 - 패캠 수업 코드 참고

1. 객체지향 vs 절차지향 간단한 비교

파이썬은 OOP (객체지향) 언어이다.  

객체지향과 절차지향은 때에 따라 장점과 단점이 있다. 

객체지향을 사용함으로써 코드의 재사용과 코드 중복을 방지할 수 있다. 

절차지향은 위에서부터 아래로 실행한다. 실행속도가 빠르지만 유지보수 , 개선시키는 작업이 어렵다. 그래서 순서가 바뀌면 에러가 발생하며, 디버깅도 어렵다는 단점이 있다. 

하지만 무조건 객체지향이 좋은 것은 아니다. 빠른 속도를 보장하기 때문에 단순하고 목적이 명확한 경우에는 절차지향이 유리하다고 한다. 

2.  객체지향 언어 파이썬 - 클래스 사용하기 

만약 학생의 정보를 저장하기 위한 코드를 짜야 한다고 했을 때, 번호, 학년을 포함한다고 하면 , 학생마다 따로 변수를 선언해주어야 한다. 이렇게 리스트 구조로 짠다면 반복되는 코드도 많아지고, 유지보수가 쉽지 않다. 따라서 class를 이용하여 생성을 해보도록 한다. 

class Student():
    def __init__(self, name, number, grade, details):
        self._name = name 
        self._number = number
        self._grade = grade
        self._details = details

    def __str__(self):  
        return 'str : {} - {}'.format(self._name, self._number)

    ### str 이 없을 떈 이것이 호출 됨 
    def __repr__(self):
        return 'repr : {} - {}'.format(self._name, self._number)

 Student 클래스의 객체를 생성할 때는 name, number, grade, details를 기입해 주어야 한다. 

__str__ 은 클래스 객체를 출력하면 호출이 되는 함수이다. __repr__ 은 비슷한데 , __str__이 없으면 이 함수가 호출된다. 

- 객체 생성 

student1 = Student('Kim', 1, 1, {'gender' : 'Male', 'score1' : 95, 'score2' : 88})
student2 = Student('Lee', 2, 2, {'gender' : 'Female', 'score1' : 77, 'score2' : 92})

학생 두명의 객체를 생성해 준다. 

- 객체의 정보를 딕셔너리 형태로 보기

print(student1.__dict__)
print(student2.__dict__)

- __str__, __repr__ 호출

students_list = []
students_list.append(student1)
students_list.append(student2)
students_list.append(student3)


for x in students_list:
    print(repr(x))
    print(x) # 지정한 str이 나옴 

한번에 출력하기 위해 객체를 리스트에 넣어주고, for문으로 출력해준다. 그냥 출력을 하면 str이 나오고, repr을 호출하고 싶다면 repr(객체)를 출력해주면 된다.