문법

* AI기술 자연어 처리 전문가 양성 과정의 강의를 듣고 정리

변수

• 값을 저장하는 공간
• 변수는 메모리 주소를 가르킨다. (포인터)
• 알파벳, 숫자, _로 선언한다

비트 연산자

연산자	설명
~	비트 부정
|	비트합
&	비트곱
^	배타적비트합
<< >>	비트시프트

비교 연산자

x == y	x와 y가 같다
x is y	x와 y의 주소가 같다
x != y	x와 y가 다르다
x is not y	x와 y의 주소가 다르다

Type Checking

isinstance(variable, type)

List

• List Slicing: seq[start: end: step] 형태로 list자름

>>> a = [1, 2, 3, 4]
>>> b = [5, 6, 7, 8]
>>> a + b
[1, 2, 3, 4, 5, 6, 7, 8]
>>> a[0] = 10
>>> a * 2
[10, 2, 3, 4, 10, 2, 3, 4]
>>> 10 in a
True

>>> seq = [1, 2, 3, 4]
>>> len(seq)
4

>>> seq.append("Hello")
>>> seq
[1, 2, 3, 4, "Hello"]

>>>seq.extend([5, 6])   #맨 뒤에 리스트 추가 => seq += [5, 6]
>>> seq.insert(1, 1.5)  # idx 1에 1.5 삽입
>>> seq
[1, 1.5, 2, 3, 4, "Hello", 5, 6]
>>> del seq[1]          #1번째 원소 삭제
>>> seq.remove("Hello") #원하는 값 삭제

예약어 vs 내장함수 vs 메소드

예약어	내장함수	메소드
- 일종의 문법적인 요소 - 괄호를 사용하지 않음 - 재정의 불가능	- 기본 정의된 함수 - 별개의 함수 사용 - 재정의 가능 - 편의성 향상	- 객체 내의 정의된 함수 - .method()으로 접근 - Overriding - 해당 객체를 다룸

Tuple

 불변 타입의 리스트(Immutable List)

>>> t = (1, 2, 3, 4)
>>> t = 1, 2, 3, 4     #괄호 생략 가능!
>>> t
(1, 2, 3, 4)

>>> len(t)
4
>>> t * 2
(1, 2, 3, 4, 1, 2, 3, 4)

>>> t[3] = 5
Error!

• Tuple은 불변 타입이지만 Tuple안의 요소는 가변 타입일 수 있음

• >>> a = (1, 2, [5, 6, 7])
  >>> a[2].append(8)
  >>> a
  (1, 2, [5, 6, 7, 8])

Packing and Unpacking

>>> t =[1, 2, 3, 4, 5]
#Unpacking
>>> a, b, c, _, _ = t
>>> c
3
>>> a, *b, c = t
>>> a, b, c
(1, [2, 3, 4], 5)

Dictionary

매핑을 위한 데이터 구조

• Key -> Value형태로 구현
• Key는 중복이 불가능

#key는 불변 타입이어야 함
#list는 사용할 수 없음
>>> dic = {1: "something", (1, 2.5): 1.5, 'test': 2}
>>> dic[1]
'something'

>>> dic['test']
2
>>> dic[1, 2.5]
1.5

>>> dic = {1: 'A', 2: 'B', 3: 'C'}
>>> dic
dic = {1: 'A', 2: 'B', 3: 'C'}
>>> dic.items()
dict_items([(1, 'A'), (2, 'B'), (3, 'C')])

>>> dic.keys()
dic_keys([1, 2, 3])

>>> dic.value()
dict_values(['A', 'B', 'C'])

Set

Dictionary의 Key만 모여 있는 형태(집합형)

 >>> s = set([1, 2, 3, 'hello']) #<=> list타입으로 안 해도 괜찮음
 >>> s 
 {1, 2, 3, 'hello'}
 
 >>> s.add(5)
 >>> s.add('hello')
 {1, 2, 3, 5, 'hello')
 >>> s.remove(5)
 >>> s.discard(99)              #set안의 값이 없는 값을 지울 때는 discard -> 없을 경우 무시
 >>> s
 {1, 2, 3, 'hello'}
 >>> s.update([1, 99, None])    #여러 요소를 추가 하고 싶을 경우
 
 >>> s.clear()                  #set비우기

set 연산자

>>> s1 = set([1, 2, 3, 4])
>>> s2 = set([3, 4, 5, 6])

#교집합
>>> s1 & s2
{3, 4}

#합집합
>>> s1 | s2
{1, 2, 3, 4, 5, 6}

#차집합
>>> s1 - s2
{1, 2}

#XOR 배타적 합집합
>>> s1 ^ s2
{1, 2, 5, 6}

frozenset

set의 불변 타입

Condition & Loop

Condition

If - elif - else

삼항 연산자

[value1] if [condition] else [value2]

>>> value = 32
>>> "odd" if value % 2 else "even"
'even'

"", 0, None, [] 는 False임

>>> for key in {'a': 1, 'b': 2}:
         print(key)
         
a
b

>>> for key in {'a': 1, 'b': 2}.items():
         print(key)
         
('a', 1)
('b', 2)

Function

• 함수: 명령을 수행하는 일종의 기능 단위
  • 코드를 논리적으로 분리, 캡슐화 용도
  • 필요한 경우 반복적으로 호출
  • Return 명령어가 없는 경우 None을 반환
• ****! 인자로 받은 것을 바로 수정하는 것은 권장하지 않음!!!
• 상위에 정의된 변수는 언제나 읽기 가능
• 함수 내 정의된 변수 이름은 그 함수 내에서만 유효함

Variable Scope

• Global
  • 최상위에 선언
  • 다른 파일에서 접근 가능
• Local 
  • 함수 안에 선언
  • 상위 함수에서는 접근 불가능

Global & Nonlocal

• 상위 변수 수정 선언
• 함수 맨 앞에 선언함
  • global: 최상위 변수
  • nonlocal: 바로 상위 변수
• 스파게티 코드의 주 원인 -> 사용하지 않는 것을 권장

var = 1
def main():
   var = 10
   def function1():
       global var
       var += 1
   def function2():
       nonlocal var
       var + 1
       
   function1()
   function2()
   print(var)
main()
print(var)

Variable Capture 불가

var = 1
def function():
    print(var)
var += 1
function = 1


=> 결과는 2

• 함수형 언어에서 쓰이는 Capture와 다름
• 상위 값이 바뀌면 하위 값이 바뀜
• 프로그램을 스파게티로 만드는 주요 원인
  • 상위 객체엔 가능하면 접근하지 않기
  • 최대한 파라미터로 받기
  • 최상위 선언도 가급적 지양하기

Closure

• 같은 arugment를 받았을 때 같은 결과를 보임

Closure 만들기

print_closure의 function 자체를 보내기 때문에 변수를 넣어서 return해주지 않음!

 

 

Decorator

• 함수 하나를 인자로 받아 같은 형태의 함수를 반환하는 함수
• @을 사용하여 함수를 꾸미는데 사용 가능

def print_closure_factory(function):
    def print_closure(var):
        print("Input: ", var)
        out = function(var)
        print("Output: ", out)
        return out
    return print_closure
    
def add(var):
    return var + 2
print_add = print_closure_factory(add)
print_add(10)

def print_closure_factory(function):
    def print_closure(var):
        print("Input: ", var)
        out = function(var)
        print("Output: ", out)
        return out
    return print_closure
    
@print_decorator
def add(var):
    return var + 2
add(10)

Decorator에 인자를 추가하기 위해서는 함수를 한번 더 wrapping 필요하다

def times_decorator_factory(times):
    def times_decorator(function):
        def closure(var):
             for _ in range(times):
                 var = function(var)
            return var
        return closure
    return times_decorator
@times_decorator_factory(5)
def add(number):
	return number + 2
print(add(5))

Appropriate Decorating

• 함수에 warpping하기 때문에 기존 함수에 접근 불가함
  • Docstring, 함수 이름 등 기존 함수의 특성을 가져올 필요가 있음
  • functools library의 wraps decorator를 사용

def print_decorator(function):
  def print_closure(var):
    print("Input: ", var)
    out = function9var)
    print("Output: ", out)
  return print_closure
    
@print_decorator
def add(var):
  return var + 2
print(add.__name__)

from functools import wraps
def print_decorator(function):
  @wraps(function)
  def print_closure(var):
  	print("Input: ", var)
    out = function(var)
    print("Output: ", out)
  return print_closure
  
@print_decorator
def add(var):
  return var + 2
    
print(add.__name__)

Recursive Function

• 자기 자신을 호출하여 반복적으로 수행

Fuction Parameters

• 인자를 명시적으로 대입 가능
• 인자를 기본값으로 설정 가능
• 기본값이 설정된 인자는 맨 뒤에 붙여서 써야 함

Variable Length Parameter

• 인자의 개수가 정해져 있지 않을 경우 사용
• *(Asterisk)를 사용하여 남은 여러 인자를 packing가능
• 가변인자는 맨 마지막에 단 한 개만 위치 가능

def add_all(a, b, *args):
    print(args)
    sum = 0
    for elem in args:
        sum += elem
    return a + b + sum
    
print(add_all(1, 2, 3, 4, 5))     # 15

Keyword variable Length Parmater

• 명시적으로 지정된 파라미터가 남을 경우 키워드 가변인자 사용
• **(Double asterisk)를 사용하여 남는 키워들 변수를 packing할 것
• list로 묶여야 하는 것은 *로 사용
• dictionary로 묶여야 되는 것은 **로 사용

def func(a, ** kwargs):
    print(kwargs)
    
func(a=1, c=3)   # {'c':3}

• 파라미터 순서: 일반인자 -> 기본값 인자 -> 가변 인자 -> 키워드 가변인자

def function(var1, var2=10, *args, **kwargs):
    print(var1, var2, args, kwargs)
    
function(1, 2, 3, var3=10) #1, 2, (3,) {'var3': 10}

Parameter Unpacking

• sequence에 *를 붙이면 unpacking
  • 리스트, 튜플에 적용가능

def function(a, b, c):
    print(a, b, c)
l = [1, 2, 3]
function(*l)            #1 2 3

• Dictionary에 ** 를 붙이면 keyword unpacking

def function(var1, var2, **kwargs):
    print(var1, var2, kwargs)
    
    
d = {'var1': 10, 'var2': 20, 'var3': 30}
function(**d)    #10 20 {'var3':30}

Type hints

• 함수에 타입 힌트 제공이 가능

Pythonic Programming

Comprehension

result = [i * 2 for i in range(10)]
result = {str(i): i for i in rnage(10)}

Generator

• range함수의 경우 숫자를 하나씩 생성하여 반환하는데 이러한 요소를 하나씩 생성하여 반환하는 객체를 Generator라고 한다.
  • function에 yield를 사용할 경우 Generator가 된다
  • function에 return이 없음
  • yield 하는 위치에서 값을 반환함
  • 다시 값을 요청 받을 때 yield 다음 줄부터 실행
  • return 될 시 반복을 멈춘다.
    • StopIteration Exception 발생
  • Sequence 전체를 생성하는 것이 아니므로 메모리 효율적
    • 매우 큰 데이터셋을 처리할 때 Generator 사용 권장
  • 괄호로 Generator Comprehension 형태로 선언 가능
    • Function 등으로 이미 괄호가 쳐져 있다면 괄호 생략 가능

def my_range(stop):
    number = 0
    while number < stop:
        yield number
        number += 1
        
        
for i in my_range(5):
    print(i)

 

even_generator = (i * 2 for i in range(100))

소괄호를 쳐줬기 때문에 generator형태로 반환됨

Built-in Functions

• sum
• any: 하나라도 참이면 참
• all: 모두다 참이여야 함
• max, min
• zip
  
  • unpacking을 사용하기 때문에 2차원 리스트의 열 단위 접근 역시 가능
  • generator의 경우 list로 묶어야 값을 확인할 수 있음!

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

for col in zip(*arr):
    print(col)

• map: 각 요소에 function 함수를 적용하여 반환  map([function], [iterable])
• filter: 각 요소에 function 함수를 적용하여 참이 나오는 것만 반환 filter([function], [iterable])

Lambda Function

• 함수의 이름 없이 빠르게 만들어 쓸 수 있는 익명 함수