x ** y 연산자는 x의 y승 == pow(x, y)._: 마지막에 출력된 값을 의미.complex(real, imaginary) divmod(x, y) => (x // y, x % y) 이런 형태로 출력당함round(x, y): 숫자x에서 소수점 자리수를 y개수만 남김.\ 를 이용해 특수 문자를 입력 가능.\t, \n, \’ 등.\ 를 특수문자가 아닌 일반 문자로 표현.
>>> print('C:\some\name') # \n을 개행문자로 인식
C:\some
ame
>>> print(r'C:\some\name') # r을 앞에 붙인다
C:\some\name
+로 더하고, *로 반복할 수 있다. “““....””” 여러 줄을 허용하는 문자열“some” “thing” == “something”
>>> prefix = 'Py'
>>> prefix 'thon'
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
SyntaxError: invalid syntax
+---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1
[start:end:step]. start는 포함되며, end는 포함되지 않고, 각 항목은 생략 가능.word = 'Python' >>> word[0:2] 'Py' >>> word[:2] + word[2:] 'Python' >>> word[:2] 'Py' >>> word[-2:] 'on' >>> word[:] ‘Python’
len(s): string과 기타 등등의 원소의 개수를 반환>>> squares = [1, 4, 9, 16, 25] >>> squares [1, 4, 9, 16, 25]
[n]으로 index n에 해당하는 데이터에 접근len(): list와 기타 등등의 원소의 개수를 반환.>>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
a, b = b, a+b : 우변을 연산하고 좌변의 대응하는 위치에 맞추어서 대입한다. if (condition):, elif:, else:if 다음에 : 빼먹지 말자.
if x < 0:
…
elif x == 0:
…
else:
...
>>> # Measure some strings: ... words = ['cat', 'window', 'defenestrate'] >>> for w in words: ... print(w, len(w)) ... cat 3 window 6 defenestrate 12
range(start, stop[, step]) : start부터 stop전까지 step만큼 증가.>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): ... print(i, a[i]) ... 0 Mary 1 had 2 a 3 little 4 lamb
pass문은 어떠한 행동도 일으키지 않으며, 주로 비어있는 구문을 만들 때 사용된다.pass를 적어두고 나중에 채우기도 한다.# 오류 발생 while True:
# 오류가 발생하지 않음
while True:
pass
def function(args):
#statements
global statement를 이용해야 글로벌 변수에 값을 대입할 수 있다.>>> fib <function fib at 10042ed0> >>> f = fib >>> f(100) 0 1 1 2 3 5 8 13 21 34 55 89
return은 함수에서 값을 반환함. 없으면 None을 반환함. 함수 끝내기에 실패해도 None반환함object.methodname : 다른 타입의 오브젝트는 다른 타입의 함수를 만든다. 심지어 메소드 이름이 같을 지라도 다른 함수이다.
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
...
>>> i = 5 >>> def f(arg=i): … print(arg) >>> i = 6 >>> f() 5
>>> def f(a, L=[]): … L.append(a) ... return L >>> print(f(1)) [1] >>> print(f(2)) [1, 2] >>> print(f(3)) [1, 2, 3]
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
pass #구현부 생략
parrot(1000) # 1 positional argument
parrot(voltage=1000) # 1 keyword argument
parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump') # 3 positional arguments
parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword
>>> def concat(*args, sep="/"):
... return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'
*>>> list(range(3, 6)) # normal call with separate arguments [3, 4, 5] >>> args = [3, 6] >>> list(range(*args)) # call with arguments unpacked from a list [3, 4, 5]
**
>>> def parrot(voltage, state='a stiff', action='voom'):
... print("-- This parrot wouldn't", action, end=' ')
... print("if you put", voltage, "volts through it.", end=' ')
... print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
"""내용"""
def my_function():
"""Do nothing, but document it.
No, really, it doesn't do anything.
"""
pass
>>> print(my_function.__doc__)
Do nothing, but document it.
No, really, it doesn't do anything.
:로 parameter annotations로 정의한다.->은 return annotation를 나타남. 함수 이름 선언와 : 사이에 return annotation을 쓴다
>>> def f(ham: 42, eggs: int = 'spam') -> "Nothing to see here":
... print("Annotations:", f.__annotations__)
>>> f('wonderful')
Annotations: {'eggs': <class 'int'>, 'return': 'Nothing to see here', 'ham': 42}
list.append(x): 리스트 끝에 아이템을 추가함. list.extend(L): 리스트에 또다른 리스트 L을 추가한다.list.insert(index,value): index 바로 앞에 값을 추가한다list.remove(x): 값이 x인 첫 번째 아이템을 지움. 값을 못 찾으면 errorlist.pop(i) : 리스트에서 주어진 index의 값을 지운다. index가 없으면 마지막 아이템을 지운다.list.clear() : 리스트 값 전부 삭제. 리스트 남아있다.list.index(x) : x랑 같은 값을 가진 첫 번째 index를 돌려준다. 없으면 errorlist.count(x) : x의 갯수 세어줌. list.sort() : list의 item들을 정렬한다list.reverse() : 리스트의 item의 순서를 뒤집는다list.copy() : 리스트의 오브젝트 카피. object를 복사하는 것이 아닌 object reference를 복사한다. (얕은 복사)collections.deque를 쓰는 것이 좋다.
squares = []
for x in range(10):
squares.append(x**2)
squares = [x**2 for x in range(10)]
squares = list(map(lambda x: x**2, range(10)))
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> matrix = [ ... [1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12], ... ]
[[row[i] for row in matrix] for i in range(4)][[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]str() vs repr()str(): 사람이 읽기 위한 용도로 string으로 변환repr(): eval()을 사용하기 위한 용도로 string으로 변환>>> s = 'Hello, world.' >>> str(s) 'Hello, world.' >>> repr(s) "'Hello, world.'"
str.format() method를 이용하면 노가다를 뛰지 않고도 깔끔하게 출력이 가능
>>> for x in range(1, 3):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
>>> print('The story of {1}, {0}, and {other}.'.format('Manfred','Bill',
other='Georg'))
The story of Bill, Manfred, and Georg.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
vars()를 이용하면 local variables를 담은 dictionary를 얻을 수 있음. 위의 예제와 쓰면 궁합이 좋음.str.rjust(n), str.ljust(n), str.center(n): n사이즈에 맞게 정렬된 string을 반환. str이 이미 n보다 길면 무시.str.ljust(n)[:n] 같은 짓을 가능.str.zfill(n): n사이즈에 맞게 0이 삽입된 string을 반환.open(filename, mode): 파일 열기read(size)readline() / readlines()for line in f: print(line, end=’’)
write(string)seek(index,from) : tell()close()closedimport jsonjson.load(json file) 도 파일 읽기 시스템. 읽고 난 뒤에는 마지막으로 간다. 고로 여러번 읽을 수 없다.json.dumps(obj): obj를 json 형식으로 전환json.dump(obj, file) : file에 쓰기ZeroDivisionError, NameError, TypeError, 기타 등등(https://docs.python.org/3.4/library/exceptions.html#bltin-exceptions)try: x = 1 / 0 except ZeroDivisionError: print(“...”)
except (RuntimeError, TypeError, NameError): pass
as 키워드를 이용해서 객체 이용 가능
except OSError as err:
print("OS error: {0}".format(err))
except:와 같이 쓰면 모든 Error에 대해 처리. 단, 매우 신중하게 사용해야 하며, 다음처럼 메시지를 출력하고 다시 Error를 선언하는 식으로 쓸 수 있음.
except:
print("Unexpected error")
raise
else: 구문: try 구문에서 exception이 발생되지 않은 경우 실행instance.args 로 접근이 가능하며, __str__()은 이 .args를 출력해줌.
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print(type(inst))
... print(inst.args)
... print(inst)
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
raise 구문: 프로그래머가 원하는 Exception을 일으킨다.class className(Exception): 상속 방법__init__(), __str__()이 기본적으로 구현되어있으나, override 가능.finally: - try 문이 완전히 종료되기 직전에 반드시 실행되는 내용.
with open("myfile.txt") as f:
for line in f:
print(line, end="")
__exit__(), __enter__()가 구현되어 있는 class의 경우 with 구문을 사용 할 수 있으며, 다른 built-in class들도 구현이 되어 있음.
def scope_test():
def do_local():
spam = "local spam"
def do_nonlocal():
nonlocal spam
spam = "nonlocal spam"
def do_global():
global spam
spam = "global spam"
spam = "test spam"
do_local()
print("After local assignment:", spam)
do_nonlocal()
print("After nonlocal assignment:", spam)
do_global()
print("After global assignment:", spam)
scope_test()
print("In global scope:", spam)
After local assignment: test spam After nonlocal assignment: nonlocal spam After global assignment: nonlocal spam In global scope: global spam
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
MyClass.i, MyClass.f, MyClass.__doc__과 같이 선언된 class의 attribute에 접근.x= MyClass() 와 같은 문법으로 인스턴스화 가능.__init__(self) method가 자동으로 실행. 따라서 객체의 초기화를 진행할 수 있음.__init__(self, x, y)처럼 인자를 받을 수도 있음.x.f() == MyClass.f(x)x.f는 method object이기 때문에 다음과 같이 대입 후 사용 가능.xf = x.f xf()
class Dog:
kind = 'canine' # 클래스 변수
def __init__(self, name):
self.name = name # 인스턴스 변수
# Function defined outside the class
def f1(self, x, y):
return min(x, x+y)
class C:
f = f1
def g(self):
return 'hello world'
h = g
self.another_method() 식으로 호출.object.__class__를 동해 class를 확인할 수 있음.
class DerivedClassName(BaseClassName):
<statement>
...
isinstance() : 인스턴스인지 확인isinstance(obj, int) 는 Trueissubclass() : 상속을 확인issubclass(bool, int) 는 Trueissubclass(float, int) 는 Falseclass DerivedClassName(Base1, Base2, Base3):
_variable은 ‘밖에서 쓰이면 안된다는’ variable이라는 약속. 쓸 수는 있으나. 쓰지 말자.
class Mapping:
def __init__(self, iterable):
self.items_list = []
self.__update(iterable)
def update(self, iterable):
for item in iterable:
self.items_list.append(item)
__update = update # private copy of original update() method
class MappingSubclass(Mapping):
def update(self, keys, values):
# provides new signature for update()
# but does not break __init__()
for item in zip(keys, values):
self.items_list.append(item)
class Employee:
pass
john = Employee() # john 이라는 이름의 빈 Employee를 만듬
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000
raise Class == raise Class()raise Instance
class CustomException(Exception):
pass
for문은 실행시 object의 iter()를 호출해 나온 iterator object를 사용.StropIteration exception을 raise하는 __next__() method를 가지고 있음.__next__()은 next() built-in function을 통해서도 부를 수 있음.
>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
next(it)
StopIteration
class Reverse:
"""Iterator for looping over a sequence backwards."""
def __init__(self, data):
self.data = data
self.index = len(data)
def __iter__(self):
return self
def __next__(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]
>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
... print(char)
...
m
a
p
s
next() 가 호출될 때 마다 실행을 멈춘 자리에서 다시 작업을 수행.__iter__() 와 __next__() method가 자동으로 생성되서 코드가 간단해지고, 각 call 사이마다 local variables과 실행 상태를 저장하고, generator가 끝난 이후 자동으로 StropIteration이 raise되는 것이 특징. 따라서 일반적인 구현보다 쉬워짐.
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
>>> for char in reverse('golf'):
... print(char)
...
f
l
o
g
>>> sum(i*i for i in range(10)) # sum of squares 285 >>> xvec = [10, 20, 30] >>> yvec = [7, 5, 3] >>> sum(x*y for x,y in zip(xvec, yvec)) # dot product 260 >>> data = 'golf' >>> list(data[i] for i in range(len(data)-1, -1, -1)) ['f', 'l', 'o', 'g']
os : os 모듈은 os와 상호작용하는 함수를 제공os.getcwd() : 현재 디렉토리 리턴 cwd와 같음os.chdir(path) : 현재 디렉토리를 path로 변경os.system(command) : command를 시스템 쉘에서 실행shutil : os에 비해 더 상위 인터페이스를 제공shutil.copyfile(src, dst, *, follow_symlinks=True) : 파일 copyshutil.move(src, dst) : src를 dst로 이동시킴glob 모듈은 와일드카드(*, ?) 검색을 통한 파일 이름이 담긴 list를 반환하는 function을 가지고 있음.glob.glob(pathname) : 검색한 파일 리스트를 보여준다sys 모듈은 stdin, stdout, stderr 속성을 가지고 있으며, 파일이나 다른 output으로 redirection이 가능.sys.stderr.write('Warning, log file not found starting a new one\n')re 모듈은 정규표현식 (regular expression) 도구들을 제공.re.findall(pattern, string): 매칭되는 문자들을 list로 반환re.sub(pattern, repl, string): 매칭되는 문자들을 repl로 변환한 string을 반환math 모듈은 float에 대한 C라이브러리 함수에 접근 가능하다.math.cos(x) : cos(x)값을 반환math.log(x[, base]) : base를 밑으로 한 log값을 반환. base가 없을 시 밑은 e가 된다.random 모듈은 무작위 선택에 대한 함수를 제공한다.random.random : 무작위의 float을 반환random.randrange(number) : range(number) 에서 정수 하나 반납urllib.request 모듈은 인터넷 연결을 통한 작업들을 쉽게 할 수 있는 함수들이 있음.stmplib 모듈을 이용해서 메일을 보낼 수 있음datetime 모듈은 시간과 시간대를 다룸.datetime.date 클래스는 특정한 날짜를 저장 (2013, 4, 5)date.strftime을 이용하면 포멧을 이용해서 출력 가능.
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'
datetime.timedelta 클래스는 기간을 저장 date(2014, 2, 1) - date(2014, 1, 1) == datetime.timedelta(31)zlib.compress(byte) : byte을 압축zlib.decompress(byte): 압축한 byte을 압축하기 전으로 풀기type(b”saeou”) = <class 'bytes'>type(r”saeouha”) = <class 'str'>Timer(“code”, “code”, …).timeit() : 가장 왼쪽의 코드(str)를 실행 -> 삭제 -> 없을 때까지 루프Timer(“code”).timeit() 으로 무한 루프도 가능하다. 안 끝날 뿐.doctest모듈은 docstring안에 있는 테스트 코드를 실행시킴.
def average(values):
"""Computes the arithmetic mean of a list of numbers.
>>> print(average([20, 30, 70]))
40.0
"""
return sum(values) / len(values)
import doctest
doctest.testmod() # automatically validate the embedded tests
unittest 모듈은 doctest보다는 복잡하지만, 더 상세한 테스트를 진행할 수 있음.
import unittest
class TestStatisticalFunctions(unittest.TestCase):
def test_average(self):
self.assertEqual(average([20, 30, 70]), 40.0)
self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
with self.assertRaises(ZeroDivisionError):
average([])
with self.assertRaises(TypeError):
average(20, 30, 70)
unittest.main() # Calling from the command line invokes all tests
reprlib 모듈
>>> reprlib.repr(set('supercalifragilisticexpialidocious'))
"set(['a', 'c', 'd', 'e', 'f', 'g', ...])"
pprint 모듈textwrap모듈은 너비에 맞게 출력locale모듈은 특정한 지역의 출력 형식 데이터베이스에 접근, 해당 지역의 출력 형식에 맞게 출력을 할 수 있도록 한다.
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv() # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format_string("%s%.*f", (conv['currency_symbol'],
... conv['frac_digits'], x), grouping=True)
'$1,234,567.80'
string모듈의 Template class
from string import Template
t = Template('${village}folk send $$10 to $cause.')
t.substitute(village='Nottingham', cause='the ditch fund')
Result : 'Nottinghamfolk send $10 to the ditch fund.'t.safe_substitute()struct 모듈의 pack(), unpack() 함수를 이용하면 바이너리 파일의 헤더 부분과 을 쉽게 다룰 수 있음.
data = open(‘myfile.zip’, ‘rb’).read()
start = 14
fields = struct.unpack('<IIIHH', data[start:start+16])
crc32, comp_size, uncomp_size, filenamesize, extra_size = fields
threading 모듈에 있는 Thread class 를 통해 할 수 있음.run() 을 오버라이딩 한 다음start() 를 호출하는 방식.join() 메서드를 이용해서 해당 thread가 일이 끝날 때 까지 기다릴 수 있음.logging 모듈은 다양하고 유연한 로그 기능을 지원. 기본적으로 sys.strerr 으로 출력되며, info와 debug 메시지는 무시된다. 설정을 통해 email, sockets, HTTP server 등으로 보낼 수도 있으며, 메시지 수준에 따라 다른 곳으로 보낼 수도 있다.debug(), info(), warning(), error(), critical()gc module로 접근 가능) 을 이용해서 자동으로 메모리를 관리한다. 객체는 더 이상 참조가 되지 않을 경우 gc에 의해 자동으로 정리된다.weakref 모듈을 사용하면 weakref에 의해 참조가 될 경우에도 gc에 의해 자동으로 정리가 된다.>>> a = A(10) >>> d = weakref.WeakValueDictionary() >>> d['primary'] = a
array 모듈
>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
collection 모듈의 deque 오브젝트
>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print("Handling", d.popleft())
Handling task1
bisect(Array bisection algorithm) 모듈은 정렬된 list를 다루는 함수가 있음>>> import bisect >>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')] >>> bisect.insort(scores, (300, 'ruby')) >>> scores [(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
heapq 모듈은 list 형을 기반으로 heap 을 이용할 수 있도록 함.heapify(), heappush(), heappop() 함수 등이 있음.decimal 모듈, Decimal 클래스
>>> from decimal import *
>>> Decimal('1.0') % Decimal('.10')
Decimal('0.00')
>>> 1.0 % 0.1
0.09999999999999995
>>> [Decimal('0.1')]*10
[Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1'), Decimal('0.1')]
>>> sum([Decimal('0.1')]*10)
Decimal('1.0')
>>> [0.1]*10
[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
>>> sum([0.1]*10)
0.9999999999999999