파이썬 중급, 고급 문법

Python Basics for AI¶

• 기초적인 파이썬 문법 및 개념
• 쌩기초 및 이미 아는 개념은 정리하지 않음

---

Collection 모듈 복습¶

deque¶

• rotate, reverse 등 Linked List의 특성을 지원해준다
• 그리고 기존 list 타입의 함수를 모두 지원해줌
• 기존의 list보다 효율적인 자료구조를 제공하기 때문에 사용한다.
• 효율적 메모리 구조로 처리 속도가 향상된다

In [1]:

from collections import deque

# deque 생성
deque_list = deque()
for i in range(5):
    deque_list.append(i)

# 맨 앞에 append
deque_list.appendleft(10)
deque_list

Out[1]:

deque([10, 0, 1, 2, 3, 4])

In [2]:

deque_list.append(100)
deque_list

Out[2]:

deque([10, 0, 1, 2, 3, 4, 100])

In [3]:

# 값의 위치를 한칸씩 옮김
deque_list.rotate(1)
deque_list

Out[3]:

deque([100, 10, 0, 1, 2, 3, 4])

OrderedDict¶

• 데이터를 입력한 순서대로 dict를 반환한다. (근데 python 3.6 버전 이상부터는 dict 타입도 입력한 순서를 보장하기 때문에 사실상 의미는 없다.)

In [6]:

from collections import OrderedDict

d = {}
d['x'] = 100
d['z'] = 300
d['y'] = 200

for k, v in OrderedDict(sorted(d.items(), key=lambda t: t[0])).items():
    print(k, v)

x 100
y 200
z 300

defaultDict¶

• Dict 타입 값에 기본 값을 지정할 수 있다.
• 신규값 생성시 사용하는 방법이다.

In [8]:

from collections import defaultdict

# default 값을 0으로 설정함
d = defaultdict(lambda : 0)
d

Out[8]:

defaultdict(<function __main__.<lambda>()>, {})

In [9]:

d['first']

Out[9]:

0

Counter¶

• 시퀀스 타입의 데이터 요소들의 갯수를 dict 타입으로 반환해준다.

In [11]:

from collections import Counter

bs = ['B','S','S','S','B','S','B']

c = Counter(bs)
c

Out[11]:

Counter({'B': 3, 'S': 4})

namedtuple¶

• 튜플 형태로 데이터 구조체를 저장하는 방법이다.
• 저장되는 데이터의 변수를 사전에 지정해서 사용함.

In [15]:

from collections import namedtuple

# 이 튜플의 이름은 Point이고, 이 안에는 x와 y값이 들어있다고 선언이 된 것
Point = namedtuple('Point', ['x','y'])
p = Point(11, y=22)
print(p[0], p[1])

# 이런식으로 불러와서 사용할 수 있다
x, y = p
print(x, y)
print(p.x, p.y)

11 22
11 22
11 22

---

Pythonic code¶

Split and Join¶

In [1]:

# split
items = 'zero one two'
items.split(' ')

# join
colors = ['red', 'blue', 'black']
"-".join(colors)

Out[1]:

['zero', 'one', 'two']

List Comprehension¶

In [3]:

result = [i for i in range(10)]
result

Out[3]:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [5]:

result = [i for i in range(10) if i % 2 == 0]
result

Out[5]:

[0, 2, 4, 6, 8]

In [8]:

case_1 = ['A','B','C']
case_2 = ['D','E','F']

# one_dimension
# 앞에서부터 순서대로 (일반적인 순서)
[i+j for i in case_1 for j in case_2]

Out[8]:

['AD', 'AE', 'AF', 'BD', 'BE', 'BF', 'CD', 'CE', 'CF']

In [9]:

# two_dimension
# 뒤에서부터 시작함
[[i+j for i in case_1] for j in case_2]

Out[9]:

[['AD', 'BD', 'CD'], ['AE', 'BE', 'CE'], ['AF', 'BF', 'CF']]

reduce function¶

In [11]:

from functools import reduce

# 대용량 데이터를 다룰 때 주로 사용함
# 처음 1과 2를 더하고(x+y) -> 더한 값이 다음 x가 된다.
print(reduce(lambda x, y : x+y, [1,2,3,4,5]))

15

Generator¶

1. iterable object를 특수한 형태로 사용해주는 함수
2. 메모리 측면에서 iter보다 훨씬 효율적임
3. 필요할 때 불러서 출력하자
4. yield를 사용해 한번에 하나의 element만 반환함
5. list comprehension처럼 사용할 수 있는데, generator expression라고 부른다. 대괄호 대신 소괄호()를 사용함

In [51]:

def geneartor_list(value):
    result = []
    for i in range(value):
        yield i
        
geneartor_list(5)

Out[51]:

<generator object geneartor_list at 0x000001A09AAB94C8>

In [50]:

gen_ex = (n*n for n in range(10))
print(type(gen_ex))

<class 'generator'>

unpacking container (asterisk 사용)¶

In [18]:

ex = ([1,2], [3,4], [5,6])
for value in zip(ex):
    print(value)

([1, 2],)
([3, 4],)
([5, 6],)

In [19]:

# 같은 인덱스끼리 나옴
ex = ([1,2], [3,4], [5,6])
for value in zip(*ex):
    print(value)

(1, 3, 5)
(2, 4, 6)

First class object¶

1. 변수나 데이터 구조에 할당이 가능한 객체
2. 함수 자체가 파라미터나 리턴 값으로 사용이 가능하다

In [27]:

def square(x):
    return x * x

def cube(x):
    return x*x*x

# method라는 함수 자체가 파라미터로 사용되고 있다
def formula(method, argument_list):
    return [method(value) for value in argument_list]

inner function¶

1. 일급 함수니까 inner function이 가능해짐

In [28]:

# 1. 함수 내에 또 다른 함수가 존재함
def print_msg(msg):
    def printer():
        print(msg)
    printer()
    
print_msg("Hello, Python")

Hello, Python

In [33]:

# 2. closures : inner function을 return값으로 변환
def print_msg(msg):
    def printer():
        print(msg)
    return printer

another = print_msg("Hello, Python")
another()

Hello, Python

In [35]:

# closure example
def tag_func(tag, text):
    text = text
    tag = tag
    
    def inner_func():
        return '<{0}>{1}<{0}>'.format(tag, text)
    
    return inner_func

h1_func = tag_func('title', "This is Python Class")
p_func = tag_func('p', "Data Academy")

Out[35]:

<function __main__.tag_func.<locals>.inner_func()>

decorator function¶

1. 복잡한 클로져 함수를 간단하게 만듦

In [38]:

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner

# printer라는 함수가 star함수의 파라미터로 넘어감
@star
def printer(msg):
    print(msg)

printer("Hello")

******************************
Hello
******************************

In [42]:

number_list[len(number_list)//2 = [6, 75, 79, 41, 38, 77, 1, 30, 69, 83]

In [47]:

number_list.sort()
if len(number_list) % 2 == 0:
    median = (number_list[len(number_list)//2] + number_list[len(number_list)//2 - 1]) / 2
else:
    median = number_list[len(number_list)//2]
median

Out[47]:

55.0