파이썬 기초 문법 1,2,3

parameter: 함수의 입력 값 인터페이스 

- def f(x)

argument: 실제 Parameter에 대입된 값
- print(f(2))

Command Line Interface
- Graphic User Interface(GUI)와 달리 Text를 사용하여 컴퓨터에 명령을 입력하는 인터페이스 체계

print formatting
(1) %string
>> print("%d %d %d" %(1,2,3))

(2) format 함수
>> print(" {} {} {}".format("a", "b", "c"))

(3) fstring 
>> print(f"value is {value})

padding
- 여유 공간을 지정하여 글자배열 + 소수점 자릿수를 맞추기

print("Product: %5s, Price per unit: %.5f." % ("Apple", 5.243))
print("Product: {0:5s}, Price per unit: {1:.5f}.".format("Apple", 5.243))
print("Product: %10s, Price per unit: %10.3f." % ("Apple", 5.243))
print("Product: {0:>10s}, Price per unit: {1:10.3f}.".format("Apple", 5.243))

Product: Apple, Price per unit: 5.24300.
Product: Apple, Price per unit: 5.24300.
Product:      Apple, Price per unit:      5.243.
Product:      Apple, Price per unit:      5.243.

 

 

naming

print("Product: %(name)10s, Price per unit: %(price)10.5f." %{"name":"Apple", "price":5.243})
print("Product: {name:>10s}, Price per unit:{price:10.5f}.".format(name="Apple", price=5.243))

Product:      Apple, Price per unit:    5.24300.
Product:      Apple, Price per unit:   5.24300.

 

debugging
- 코드의 오류를 발견하여 수정하는 과정
- 오류의 '원인'을 알고 '해결책'을 찾아야 함
- 문법적 에러를 찾기 위한 에러 메시지 분석
- 논리적 에러를 찾기 위한 테스트도 중요

string 함수
- len(a): 문자열의 문자 개수 반환
- a.upper(): 대문자로 변환
- a.lower(): 소문자로 변환
- a.capitalized(): 첫 문자를 대문자로 변환
- a.titile(): 제목 형태로 변환, 띄워쓰기 후 첫 글자만 대문자
- a.count('abc'): 문자열 a에 'abc'가 들어간 횟수 반환
- a.find('abc'), a.rfind('abc'): 문자열 a에 'abc'가 들어간 위치(오프셋) 반환
- a.startswith('abc'): 문자열 a는 'abc'로 시작하는 문자열 여부 반환
- a.endswith('abc'): 문자열 a는 'abc'로 끝나는 문자열 여부 반환
- a.strip(): 좌우 공백을 없앰
- a.rstrip(): 오른쪽 공백을 없앰
- a.lstrip(): 왼쪽 공백을 없앰
- a.split(): 공백을 기준으로 나눠 리스트로 반환
- a.isdigit(): 문자열이 숫자인지 여부 반환
- a.islower(): 문자열이 소문자인지 여부 반환
- a.isupper(): 문자열이 대문자인지 여부 반환

 

* 함수 호출 방식 개요
(1) Call by Value: 값에 의한 호출
- 함수에 인자를 넘길 때 값만 넘김
- 함수 내에 인자 값 변경 시, 호출자에게 영향을 주지 않음

(2) Call by Reference: 참조의 의한 호출
- 함수에 인자를 넘길 때 메모리 주소를 넘김
- 함수 내에 인자 값 변경 시, 호출자의 값도 변경됨

(3) Call by Object Reference
- 파이썬은 객체의 주소가 함수로 전달되는 방식
- 전달된 객체를 참조하여 변경 시 호출자에게 영향을 주나, 새로운 객체를 만들 경우 호출자에게 영향을 주지 않음

swap
- 함수를 통해 변수 간의 값을 교환하는 함수
- swap_offset: a 리스트의 전역 변수 값을 직접 변경
- swap_reference: a 리스트 객체의 주소 값을 받아 값을 변경 

 

Scoping rule: 변수의 범위
- 변수가 사용되는 범위 (함수 또는 메인 프로그램)
- 지역변수(local variable): 함수 내에서만 사용
- 전역변수(global variable): 프로그램 전체에서 사용
- 전역변수는 함수에서 사용 가능
- 그러나, 함수 내에 전역변수와 같은 이름의 변수를 선언하면 새로운 지역변수가 생긴다. 

docstring 
- 파이썬 함수에 대한 상세스펙을 사전에 작성 -> 함수 사용자의 이행도 UP
- 3개의 따옴표로 docstring 영역 표시 (함수명 아래)


함수 작성 가이드라인
- 함수는 가능하면 짧게 작성할 것 (줄 수를 줄일 것)
- 함수 이름에 함수의 역할, 의도를 명확히 드러낼 것
- 하나의 함수에는 유사한 역할을 하는 코드만 포함
- 인자로 받은 값 자체를 바꾸진 말 것 (임시변수 선언) 

함수는 언제 만드는가?
- 공통적으로 사용되는 코드는 함수로 변환
- 복잡한 수식 -> 식별 가능한 이름의 함수로 변환
- 복잡한 조건 -> 식별 가능한 이름의 함수로 변환 

파이썬 코딩 컨벤션: 사람의 이해를 돕기 위한 규칙
- 일관성이 중요하다. 

 

set: 집합
- 값을 순서없이 저장, 중복 불허하는 자료형
- set 객체 선언을 이용하여 객체 생성

dictionary: 사전
- 데이터를 저장할 때 구분 지을 수 있는 값을 함께 저장
- 구분을 위한 데이터 고유 값을 Identifier 또는 Key라고 한다. 
- Key값을 활용하여, 데이터 값(Value)를 관리한다. 

Command Analyzer
- Command: 사용자가 서버에 명령을 입력한 명령어 

collections
- list, tuple, dict에 대한 Python Built-In 확장 자료 구조(모듈)
- 편의성, 실행 효율 등을 사용자에게 제공함

from collections import deque
from collections import Counter
from collections import OrderedDict
from collections import defaultdict
from collections import namedtuple

 

 

OrderedDict
- Dict와 달리, 데이터를 입력한 순서대로 dict를 반환함
- 그러나 dict도 python 3.6부터 입력한 순서를 보장하여 출력한다. 
- dict type의 값을 value 또는 key 값으로 정렬할 때 사용 가능하다. 

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

 

defaultdict
- dict type의 값에 기본 값을 지정, 신규값 생성 시 사용하는 방법

from collections import defaultdict
d = defaultdict(object) # Default dictionary를 생성
d = defaultdict(lambda: 0) # Default 값을 0으로 설정합
print(d["first"])

Counter
- Sequence type의 data element들의 갯수를 dict 형태로 반환
- dict type, keyword parameter 등도 모두 처리 가능 
- set의 연산들을 지원함
- word counter 기능도 제공함

named tuple
- tuple 형태로 data 구조체를 저장하는 방법
- 저장되는 data의 variable을 사전에 지정해서 저장

 

split 함수
- string type의 값을 "기준값"으로 나눠서 list 형태로 변환

join 함수
- string으로 구성된 list를 합쳐 하나의 string으로 변환

''.join(variable)

list comprehension
- 기존 list를 사용하여 간단한 다른 list를 만드는 기법
- 포괄적인 list, 포함되는 리스트라는 의미로 사용
- 파이썬에서 가장 많이 사용되는 기법 중 하나
- 일반적으로 for + append보다 속도가 빠르다.

result = [i for i in range(10) if i % 2 == 0]
result = [i+j for i in case_1 for j in case_2 if not(i==j)]

 

enumerate & zip
- enumerate: list의 element를 추출할 때 인덱스 번호를 붙여서 추출 
- zip: 두 개의 list의 값을 병렬적으로 추출

alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']
for a, b in zip(alist, blist): # 병렬적으로 값을 추출
	print (a,b)

a1 b1
a2 b2
a3 b3

a,b,c =zip((1,2,3),(10,20,30),(100,200,300)) #각 tuple의 같은 index 끼리 묶음
# output: (1, 10, 100) (2, 20, 200) (3, 30, 300)

[sum(x) for x in zip((1,2,3), (10,20,30), (100,200,300))]

# 각 Tuple 같은 index를 묶어 합을 list로 변환
# output: [111, 222, 333]

 

lambda & map & reduce
- 함수 이름 없이, 함수처럼 쓸 수 있는 익명함수
- 수학의 람다 대수에서 유래

# general function
def f(x, y):
	return x + y
print(f(1, 4))

# lambda function
f = lambda x, y : x + y
print(f(1, 4)

 

map
- 2개 이상의 List에도 적용 가능함, if filter 사용 가능 

reduce
- map function과 달리 리스트에 똑같은 함수를 적용해서 통합

print(reduce(lambda x, y: x+y, [1,2,3,4,5]))

 

iterable object
- sequence형 자료형에서 데이터를 순서대로 추출하는 object

characteristics
- 내부적 구현으로 __iter__, __next__ 사용
- iter(), next() 함수로 iterable 객체를 iterator object로 사용

cities = ["Seoul", "Busan", "Jeju"]
iter_obj = iter(cities)
print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))
next(iter_obj)

 

generator
- iterable object를 특수한 형태로 사용해주는 함수
- element가 사용되는 시점에 값을 메모리에 반환
- yield를 사용해 한 번에 하나의 element만 반환함

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

 

generator comprehension
- list comprehension과 유사한 형태로 generator 형태의 list 생성
- generator expression이라는 이름으로도 부름
- [] 대신 ()를 사용하여 표현

gen_ex = (n*n for n in range(500))
print(type(g))

Why generator
- 일반적인 iterator는 generator에 비해 훨씬 큰 메모리 용량을 사용한다. 

from sys import getsizeof
gen_ex = (n*n for n in range(500))
print(getsizeof(gen_ex))
print(getsizeof(list(gen_ex)))
list_ex = [n*n for n in range(500)]
print(getsizeof(list_ex))

- 리스트 타입의 데이터를 반환해주는 함수는 generator로 만들기
- 읽기 쉬운 장점, 중간 과정에서 루프가 중단될 수 있을 때
- 큰 데이터를 처리할 때는 generator expression을 고려하기
- 데이터가 커도 처리의 어려움이 없음
- 파일 데이터를 처리할 때도 generator 사용 

 

function passing arguments
- 함수에 입력되는 arguments의 다양한 형태 

(1) Keyword arguments 
- 함수에 입력되는 파라미터의 변수명을 사용, arguments를 넘김

(2) Default arguments 
- 파라미터의 기본 값을 사용, 입력하지 않을 경우 기본값 출력

(3) Variable-length arguments 


Variable-length asterisk
가변인자(Variable-length)
- 개수가 정해지지 않은 변수를 함수의 파라미터로 사용하는 법
- Keyword arguments와 함께, argument 추가가 가능
- asterisk(*) 기호를 사용하여 함수의 파라미터를 표시
- 입력된 값은 tuple type으로 사용 가능
- 가변인자는 오직 한 개만 맨 마지막 파라미터 위치에 사용 가능 
- 가변인자는 일반적으로 *args를 변수명으로 사용
- 기존 파라미터 이후에 나오는 값을 tuple로 저장함

def asterisk_test(a, b, *args):
return a+b+sum(args)
print(asterisk_test(1,2,3,4,5))

 

 

키워드 가변인자(keyword variable-length)
- 파라미터 이름을 따로 지정하지 않고 입력하는 방법
- asterisk(*) 2개를 사용하여 함수의 파라미터를 표시함
- 입력된 값은 dict type으로 사용할 수 있음
- 가변인자는 오직 한 개만 기존 가변인자 다음에 사용

def kwargs_test_1(**kwargs):
    print(kwargs)

def kwargs_test_2(**kwargs):
    print(kwargs)
    print("First value is {first}".format(**kwargs))
    print("Second value is {second}".format(**kwargs))
    print("Third value is {third}".format(**kwargs))
def kwargs_test_3(one,two,*args,**kwargs):
    print(one+two+sum(args))
    print(kwargs)

kwargs_test_3(3,4,5,6,7,8,9, first=3, second=4, third=5)

 

 

asterisk

- * 의미

- 단순 곱셈, 제곱연산, 가변 인자 활용 등 다양하게 사용됨

 

asterisk - unpacking a container

- tuple, dict 등 자료형에 들어가 있는 값을 unpacking

- 함수의 입력값, zip 등에 유용하게 사용 가능 

def asterisk_test1(a, *args):
    print(a, args)
    print(type(args))

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

def asterisk_test2(a, args):
    print(a, *args)
    print(type(args))

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

#####################################

a,b,c = ([1,2],[3,4],[5,6])
print(a,b,c)

data = ([1,2],[3,4],[5,6])
print(*data)

def asterisk_test3(a,b,c,d):
    print(a,b,c,d)
data = {"b":1, "c":2,"d":3}
asterisk_test3(10, **data)

for data in zip(*([1,2],[3,4],[5,6])):
    print(data)

1 (2, 3, 4, 5, 6)
<class 'tuple'>
1 2 3 4 5 6
<class 'tuple'>
[1, 2] [3, 4] [5, 6]
[1, 2] [3, 4] [5, 6]
10 1 2 3
(1, 3, 5)
(2, 4, 6)