14 Jan 2019 • on python, container, oop

파이썬 기본 문법 복습

아래 포스트는 python 공식 api reference를 참고하였습니다.

Python Container

dir([object])
- argument 없음 : list of names in the current local space
- argument 있음 : list of valid attributes for that object

문자열 : immutable sequences of Unicode code points.

예약어들

예약어	기능
capitalize	첫번째 char만 대문자로
title	공백과 ‘ 뒤의 단어의 첫번째 char를 대문자로
upper	문자열 전부 대문자로
swapcase	대문자와 소문자를 반대로
strip([chars])	Return a copy of the string with the leading and trailing characters removed

replace(old, ne mutablew, count)

find(sub,start,end)와 index(sub,start,end)의 차이는 ValueError.

split(sep=None,maxsplit=-1) : Return a list of the words in the string, using sep as the delimiter string. if maxsplit is given, at most maxsplit splits are done.

r prefix는 대부분의 escape sequence processing을 억제함.

Escape Sequence	Meaning	Notes
`\newline`	Backslash and newline ignored
`\\`	Backslash (`\`)
`\'`	Single quote (`'`)
`\"`	Double quote (`"`)
`\a`	ASCII Bell (BEL)
`\b`	ASCII Backspace (BS)
`\f`	ASCII Formfeed (FF)
`\n`	ASCII Linefeed (LF)
`\r`	ASCII Carriage Return (CR)
`\t`	ASCII Horizontal Tab (TAB)
`\v`	ASCII Vertical Tab (VT)
`\ooo`	Character with octal value ooo	(1,3)
`\xhh`	Character with hex value hh	(2,3)

비슷하게 bytes 클래스는 immutable sequences of bytes를 담당한다.
그외 Text Processing Services 도 나중에 참고하면 좋을듯!

리스트 : mutable sequences

예약어	기능
a.append(x)	a[len(a):] = [x]
a.extend(iterable)	a[len(a):] = iterable
a.insert(i,x)	i번째 위치에 x를 삽입 a.append(x) = a.insert(len(a),x)
a.remove(x)	x와 동일한 first item 제거, 없으면 ValueError
a.pop(i)	인덱스 기준으로 제거하고 그 값을 리턴
a.clear()	del a[:]와 동일
a.index(x,start,end)	a[start:end] 에서 x의 위치(a리스트 기준)를 반환
a.sort(key,reverse=False)	key : 인자가 하나인 함수, < 연산자를 통해서 순서정함 sorted(iterable,key,reverse)와 달리 리턴값 없음
a.reverse()	a를 바꿔준다. Return None

list(zip(*doubled_list)) : transposed와 동일함.

Tuple : immutable sequences

보통 comma를 통해서 변수들을 선언하면 튜플이 되며, 많이 쓰이는 튜플로는 enumerate함수가 있다.
Set : Unordered collection of distinct hashable objects.
- hashable : if it has a hash value which never changes during its lifetime
  
  (쉽게 말하면 모든 element가 immutable(= atomic immutable)이어야 한다는 뜻이다.
  
  튜플은 (1,2,[1,2])와 같이 선언가능하므로 hashable이 아님. 대표적으로 딕셔너리가 hashable이며, 이는 hash map을 꼬이지 않게 할 수 있다는 장점이 있다.)
- Operation
  1. intersection, union, difference(*others)
  2. < 연산 : 부분집합이냐?
- Methods
  
  update(*others) : 겹치지 않는 원소를 업데이트함
  
  ㅌintersection_update(*others) : *others와 교집합한 결과를 업데이트함.
  
  이외에 기본적으로 list에 주어지는 메소드들 대부분이 가능함.
- 참고로 set은 mutable이며, immutable type의 set으로는 frozenset이 있다. 그러나 안쓰임.

Dictionary : mapping object maps hashable values to arbitary objects. Mappings are mutable objects.

즉, key들은 hashable이므로 mutable인 자료형이 key가 될 수는 없지만,

자료형 자체는 mutable이므로 mapping이 변화되어도 새로운 주소를 받지는 않는 것이다.

c = {1:"a",2:"b",3:"c"}
c[[1,2]] = 3

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-48-90e64ca08758> in <module>()
      1 c = {1:"a",2:"b",3:"c"}
      2 
----> 3 c[[1,2]] = 3
   
TypeError: unhashable type: 'list'

특이하게도 딕셔너리를 zip을 이용해서 쉽게 선언할 수도 있다.

c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))

메소드들

메소드	기능
iter(d)	dictionary의 key에 대한 iterator를 만든다.
d[key]	key가 map에 없다면, KeyError를 반환함.
get(key)	key가 map에 없다면 None을 반환함.
d.items()	(key,value) pair에 대한 iterator(view object)를 만든다.
keys() / values()	각각 key,value에 대한 iterator(view object)를 만든다.
update([other])	key,value pair들을 업데이트한다. (튜플같은거 줘도 됨)
pop(key)	key를 제거하고 반환한다. 없으면 Key

View object : 딕셔너리의 변화에 대해서 동적으로 변화하는 object이다.

missing 이라는 special method를 통해서 KeyError를 없앨 수 있다.

class Counter(dict):
     def __missing__(self, key):
         return 0

객체 복사

mutable 자료형과 immutable 자료형의 차이
- mutable : a=b라고 할 때, 변수 a와 b는 같은 주소를 공유함.
  
  그리고, a의 값을 바꾸면 주소가 재할당되는게 아니라 그대로이므로 b도 변화됨.
- immutable : a의 값을 바꾸면 변수가 새로 생성되면서 재할당되므로 a와 b는 다른 주소를 가지게됨.(신기하게 다시 원래 b의 값으로 a의 값을 변경하면 주소가 같아짐)
- 이중리스트 같은 경우도 리스트 안에 리스트가 있는게 아니라, 리스트 안에 다른 리스트를 가리키는 주소가 저장되어있는것임.
  
  copy.deepcopy를 사용하지 않으면 이런 이중리스트를 완벽하게 복사하기는 힘듬.
- ==와 is의 차이 : ==는 값이 같음을 판단하지만 is는 주소가 같음까지 판단함.
map, zip, fillter

map : iterable한 객체 각각에 함수 실행 -> iterable한 map_object형태로 반환

filter : iterable한 객체 각각에 함수 실행 -> 참인 원소만 되돌려줌.

zip : 복수 iterable한 객체를 모음 -> 튜플 형태의 zip object로 반환

(최소 길이에 맞춘 zip object 생성)
error and exceptions

try except으로 에러처리가능
- 복수 에러를 except (Error1, Error2)같이 처리가능
- 이 경우, 에러는 먼저 발생한 순서대로 처리함.
- raise를 통해서 에러를 발생가능 (ex: raise ZeroDivisionError)
- assert는 try except 문법과 독립적으로 발생하며, 어떤 조건문이 거짓일 때 에러메시지를 반환가능
  
  (ex : assert 조건문 “에러임” -> AssertionError 에러임)

OOP

OOP : (컴퓨터 프로그램 = 객체들의 모임)으로 생각하는 관점

기본 구성요소 : 클래스(사용자 정의 데이터형), 인스턴스(클래스가 메모리에 할당된 존재) , 메서드(클래스의 객체에 담긴 함수)

주어.동사의 형태로 작동한다고 생각하면 됨.

[용어] attritube : 집단에 속하는 속성 (= 멤버변수)

[용어] behavior : 집단에 명령하는 행위 (= 메서드)
클래스 객체
```
class ClassName:   
```
선언과 동시에 (클래스 객체) 생성

클래스 객체 안에 함수(메서드)와 변수(멤버 변수) 정의 가능함 (지역 스코프)
인스턴스 객체
```
instance = ClassName()
```
클래스의 생성자를 호출함으로써 선언된다.

메서드를 실행할 때, 멤버변수 -> 클래스 변수 -> 전역변수 순으로 탐색한다.

type 함수

[상황] Person 클래스를 선언하고, 그 인스턴스 iu를 선언한 상태.

print(type("1"))
print(type(Person))
print(type(str))
print(type(iu))
print(Person)
print(iu)

<class 'str'>
# "1"은 str 클래스의 인스턴스중 하나이다.
<class 'type'>
<class 'type'>
# 신기하게 type으로 출력된다.
<class '__main__.Person'>
<class '__main__.Person'>
# iu의 타입은 Person 클래스
<__main__.Person object at 0x0000007EE7FE1E10>

type API reference 의 설명에 따르면,

type(name, bases, dict)

name만 적은 경우 : object의 타입을 출력함.

보통 object.__class__ 의 결과값을 출력해줌.
name, bases, dict 3개를 적은 경우

dynamic form object of the class statement

(lambda가 익명함수를 생성하듯이 type는 클래스를 생성하는게 아닐까?)
- name(string) -> __name__ attribute (= 클래스 이름)
- bases(tuple) -> __bases__ attribute (= 상속의 주가 되는 super 클래스 이름)
- dict(dict) -> __dict__attribute (= class body에 포함된 namespace들)

from pprint import pprint as pp
class Person:
    def __init__(self,won,name):
        self.won = won
        self.name = name
        self.pocket = {}
        self.pocket.update(돈=self.won)
    def greeting(self):
        print(f"Hi! i am {self.name}")
        print(f"i having {self.pocket}")
    def in_my_pocket(self,**params):
        self.pocket.update(params)
           
class SSAFY(Person):
    def greeting(self):
        print("나는 자랑스러운 ssafy인이다.")
           
           
print(Person.__bases__)
print(SSAFY.__bases__)
pp(Person.__dict__)
pp(SSAFY.__dict__)

(<class 'object'>,)
(<class '__main__.Person'>,)
   
mappingproxy({'__dict__': <attribute '__dict__' of 'Person' objects>,
              '__doc__': None,
              '__init__': <function Person.__init__ at 0x0000002258ABFE18>,
              '__module__': '__main__',
              '__weakref__': <attribute '__weakref__' of 'Person' objects>,
              'greeting': <function Person.greeting at 0x0000002258ABFEA0>,
              'in_my_pocket': <function Person.in_my_pocket at 0x0000002258ABFF28>})
mappingproxy({'__doc__': None,
              '__module__': '__main__',
              'greeting': <function SSAFY.greeting at 0x0000002258BF4400>})

알 수 있는점

모든 클래스는 object라는 클래스에 상속받는것 같다.
type 함수는 overwritting된 클래스 생성자인가?? (파이썬엔 이런게 없는거로 아는데..)
__ 형식의 이상한 메서드를 선언함으로써 다양한 기능을 할 수 있는것같다.

__ 형식의 이상한 메서드들(special method)
- __repr__(self) : compute the “official” string representation of an object, 즉 객체의 공식적인 설명을 달아준다는 것임.
  
  이걸 따로 설정해주면 object를 출력할 때 repr의 string이 출력됨.
- __str__(self) : built-in functions format() and print() to compute the “informal” or nicely printable string representation of an object.
  
  이건 공식적인 설명이 아니라, format()이나 print() 함수를 통해서 비격식적인 string을 출력시켜주게 하는 기능인듯합니다.
```
class Person:
    #추가함
    def __repr__(self):
        return f'<Person object: {self.name}>'
       
    def __str__(self):
        return f'Person\n 이름 : {self.name}'
   
print(iu)
iu
```
```
Person
 이름 : 아이유
# __str__의 표현이 출력됨
<Person object: 아이유>
# __repr__의 표현이 출력됨
```
클래스 변수(Static variable)
```
class MyClass:
     i = 3
   
>>> MyClass.i
3 
```
인스턴스에 종속되지 않는 변수이므로, 클래스의 멤버변수로써 활용가능하다.

자바의 static variable과 비슷한 개념인듯

비슷하게, static method도 있는데, @staticmethod 라는 decorator를 위에 선언함으로써 만들 수 있고, 이는 클래스의 멤버변수를 로드할 필요가 없기 때문에 실행시간 측면에서 효율적이라고 한다.
isinstance(object, classinfo)

말그대로 object가 class의 instance인지 확인하는 함수.

물론, 상속받은 클래스의 object의 객체여도 True가 출력된다.
```
s1 = SSAFY(0,"dongchan")
isinstance(s1,Person)
>>> True
```

self : 인스턴스 객체 자기자신

일종의 신분증이라고 봐도 된다. self를 달지 않으면 클래스 안에서 통용되지 않는다.

name = '아이유'
class Hong:
    name = '홍길동'
    def __init__(self):
        self.name = "동찬"
    def greeting(self):
        print(f'{name}')
        print(f'{Hong.name}')
       	print(f'{self.name}')
iu = Hong()
iu.greeting()
   
>>> 아이유
>>> 홍길동
>>> 동찬

클래스의 생성과 소멸

__new__(cls[,...]): cls의 새로운 인스턴스를 생성하는 static method. 인자로는 class 이름과 constructor의 나머지 argument가 필요하다.

new method가 사용됨 -> new instance 생성됨 -> init method가 인스턴스 초기화를 위해서 자동으로 실행됨. 그런데 굳이 이거를 정의하지는 않음.
```
'5'.__new__(str,"a")
>>> 'a'
str.__new__(str,"a")
>>> 'a'
```
__init__(self[,...]) : 인스턴스가 생성되고 난 뒤에 실행되는 메서드

상속) 만약 부모클래스가 init 메서드를 갖고있다면 그걸 그대로 사용하고, 보통은 bass class의 초기화를 이용해서 정확히 표현한다 (ex:super().__init__([args...]))

반드시 리턴값이 없어야하며, 만약 init 메서드에 리턴값을 넣는다면 에러가 발생한다.
```
class Person:
    def __init__(self, name):   
        self.name = name 
        return 1
Person('dongchan')
```
```
--------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-24-32d28f282891> in <module>()
----> 1 Person('dongchan')
   
TypeError: __init__() should return None, not 'int'
```
__del__(self): 클래스를 소멸되고 난 뒤에 자동으로 호출되는 메서드임.
Private Variables : object 내부를 제외하고는 접근할 수 없는 멤버변수를 뜻함.

__spam 과 같이 two leading underscore를 붙임으로써 사용할 수 있음.

연산자 오버라이딩 : 특정 매직 메서드는 연산자를 재정의하는데 쓰임.

+  __add__   
-  __sub__
*  __mul__
<  __lt__
<= __le__
== __eq__
!= __ne__
>= __ge__
>  __gt__

=> 두개의 서로 다른 인스턴스에 대해 연산자를 재정의가능.

이런식으로 연산자 재정의를 통해서 문자열의 덧셈도 정의할 수 있는것이다.

1 + 2
>>> 3
"1" + "2"
>>> "12"

파이썬 set 자료구조의 장점

iterable을 set자료구조로 바꾸는 것은 실제로 내부적으로는 딕셔너리처럼 key값을 맵핑하는것을 뜻한다. 그래서 이런 딕셔너리를 참조하는것은 O(1)이 되기 때문에 멤버십체크가 훨씬 빨라진다.

(실제로 iterable을 set으로 바꾸는데 O(n)만큼 들지는 않는다고함)