• Syntax errors : 문법 상의 오류로 파이썬이 가지고 있는 프로그램 작성 규칙을 벗어난 사례이다. 예를 들어 한글이름을 변수명으로 사용한 경우나 한글은 문자열로 따옴표 속에 기술해야 하는데 한쪽 따옴표를 빼먹은 경우 등을 들 수 있다. 문법 오류는 파이썬에서 명백히 뭐가 문제라고 지적해 주므로 고치는것이 어렵지 않은 편이다.
• Runtime errors : 문법적으로 문제가 없으나 실행중에 발생하는 것으로 Exception으로 불리기도 한다.
• Semantic errors : 오류가 발생하지 않고 컴퓨터 입장에서는 문제없이 수행했으나, 원하는 결과를 얻지 못한 경우이다.

# -*- coding: cp949 -*-
va=1
print type(va)
va='국어'
print type(va)
>>> ================================ RESTART ================================
>>>
<type 'int'>
<type 'str'>
>>>

* 변수 이름 작성 규칙

• 영문자(대소문자를 구분한다. true, True, TRUE 모두 다르다)나 _(underscore)로 시작한다
• 첫자리이후에는 영문자와 숫자를 모두 사용할 수 있다
• 키워드를(예약어, reserved word) 사용하지 않는다. 파이썬 내부에서 문법적 의미가 있는 것이기 때문에 변수명을 사용할 수 없다.

아래는 파이썬2.7.3의 키워드를 알아보는 방법이다. 각 키워드를 외우기 보다 어떤 기능을 하는지 알게되면 자연스럽게 키워드를 변수로 사용하는 실수는 줄어들 것이다.

>>> import keyword
>>> keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

• 모듈명, 클래스명, 내장 함수명을 피한다. 문법 오류는 발생하지 않더라도 예상치 않은 결과로 추후에 디버깅이 어려울 수 있다.
• 특수 용도 변수를 구분한다.

_ 도 하나의 변수로 직전 수행 결과를 나타낸다.
_로 시작하는 변수는 모듈이나 클래스 내부 변수(private)를 지칭하고
__로 시작하는 변수는 인터프리터 내장 변수를 나타내므로 주의한다.(예, __name__, __debug__)

>>> 'abcd'.upper()
'ABCD'
>>> print _
ABCD
>>> print __name__
__main__
>>> print __debug__
True

* 변수 및 오브젝트 삭제 하기

• 스칼라(Scalar) : 숫자, 스트링등 가장 기본적인 타입
• 배열(Array) : 숫자(Index)로 원소를 참조할 수 있는 리스트
• 사전(Dictionary) : 이름(Label)으로 원소를 참조할 수 있는 리스트

* 스칼라 타입 - 숫자(Numbers)

• int : 정수형, 0으로 시작하면 8진수, 0x로 시작하면 16진수, 0b로 시작하면 2진수를 나타낸다.

>>> 10 - 33
-23
>>> 0Xff - 1 #ff=255
254
>>> 070 + 1 #70=56
57
>>> 0b1010 + 10 #1010=10

• long : 긴정수형으로 값 뒤에 L을 붙인다. C언어와는 달리 길이 제한이 없다.

>>> 2**32
4294967296L

• float : 부동소숫점 표현으로 8바이트에 정보를 저장하며 영문 E 다음에 지수부를 기술한다.

>>> 0.0000023
2.3e-06

• complex : 복소수 표현을 지원하며 끝에 J를 붙인다.

• =  대입, 치환으로 좌측에는 변수가 와야한다.
• +  덧셈
• -  뺄셈, a = -a의 방식으로 곱하기 -1의 결과를 얻을 수 있다.
• * 곱셈
• / 나누기
• ** 지수 연산으로 a**b는 a의 b승 결과를 얻는다. pow(a, b)와 동일 효과
• % 나머지 연산으로 a%b는 a나누기 b의 나머지 값을 얻는다
• & 비트 AND 연산
• | 비트 OR 연산
• ^ 비트 XOR 연산
• << 비트 left shift 연산
• >> 비트 right shft 연산
• +=  덧셈 치환 a=a+b를 a+=b형태로 기술할 수 있다. -=, *=, /=, %=, **=, &=, |=, ^=, <<=, >>= 등도 같은 방식이다.
• abs(x) x의 절대값
• int(x) x를 정수로 변환한다. int와 마찬가지로  long, float, bool등의 타입명()의 형태로 타입을 변환할 수 있다
• round(n) n을 반올림한다. round (n, p)하면 소숫점 p자리까지 반올림 한다. round(2.534, 2)는 2.53이다
• cmp(a,b) a와 b를 비교해서 a가 크면 1, 같으면 0, 작으면 -1을 리턴한다
• hex(n), oct(n), bin(n) n을 16진수, 8진수, 2진수로 변환한다.
• +=  덧셈 치환 a=a+b를 a+=b형태로 기술할 수 있다. -=, *=, /=, %=, **=, &=, |=, ^=, <<=, >>= 등도 같은 방식이다.

* 스칼라 타입 - 스트링(String)

# -*- coding: cp949 -*-
va='국어'
print va
va='Mother\'s egg'
print va
va="""국어를 사랑하자
그러자. 안녕!"""
print va
va="철수가 \"안녕\"이라고 말했다"
print va

>>> ================================ RESTART ================================
>>>
국어
Mother's egg
국어를 사랑하자
그러자. 안녕!
철수가 "안녕"이라고 말했다

• a+b 스트링 a뒤에 b를 연결한다(Concatenates). += 연산자도 사용할 수 있다.

>>> 'aaa'+"bbb"
'aaabbb'

• a*i 스트링 a를 i회 반복한다. *= 연산자도 사용할 수 있다.

>>> 'abc' * 3
'abcabcabc'

>>> 'abcde'[0:5:1]
'abcde'
>>> 'abcde'[0:5:2]
'ace'
>>> 'abcde'[-1:-6:-1]
'edcba'
>>> 'abcde'[-1:-6:-2]
'eca'

• a[::-1] 스트링 a를 거꾸로 뒤집는다. 위의 예에서  'abcde'[-1:-6:-1]과 동일한 효과를 간단하게 사용하는 방법이다.
• a.split('sep') 스트링 a를 sep 기준으로 분리한 리스트를 리턴한다. 'sep'를 생략하면 White space를 제외한 단어들만으로 리스트를 생성한다.

>>> ' I am tom    !'.split(' ')
['', 'I', 'am', 'tom', '', '', '', '!']
>>> ' I am tom    !'.split('  ')
[' I am tom', '', '!']

위의 예를 보면 첫번째는 공백 1개, 두번째는 공백 2개로 split를 수행했는데 tom다음에 공백4개가 있는 것을 감안해 보면 분리자 sep 한개를 기준으로 원소가 분리됨을 확인할 수 있다.

>>> 'aBBcc'.capitalize()
'Abbcc'

• a.count(‘sub’) 스트링 a중에서 sub 가 몇번 나오는지 개수를 리턴한다.

>>> 'Go go go Fighting!'.count('go')
2
>>> 'Go go go Fighting!'.count('g')
4

• a.replace(‘sub1’,’sub2’,n) 스트링 a에서 sub1을 찾아 sub2로 대치시킨다. n이 없으면 모든 sub1을 sub2로 바꾸고, n을 지정하면 n번만 바꾼다

>>> 'Go go go Fighting!'.replace('go', 'Go')
'Go Go Go Fighting!'
>>> 'Go go go Fighting!'.replace('go', 'Go', 1)
'Go Go go Fighting!'

* 스칼라 타입 - 논리(Boolean)

>>> 7 == 7
True
>>> 7 == 8
False
>>> a = 7==7
>>> type (a)
<type 'bool'>
>>> print a
True

>>> 1 < 3 <= 7
True
>>> 3 < 3 <= 7
False
>>> 1 < 3 <= 7 < 9
True

• !=, <> 양쪽이 다르면 True. 파이썬에서는 두가지를 모두 사용할 수 있다.

>>> 1 != 3
True
>>> 1 != 1
False
>>> 1 <> 1
False

>>> a = 10
>>> a is 10
True
>>> a = 'aaa'
>>> a is 'aaa'
True
>>> a = (1,2,3)
>>> a is (1,2,3)
False
>>> b = a
>>> b
(1, 2, 3)
>>> b is a
True

>>> if 0 : print "true"
else : print "false"

false
>>> if "0" : print "true"
else : print "false"

true
>>> if 1 : print "true"
else : print "false"

true
>>> if "" : print "true"
else : print "false"

false

* 배열(Array)

• list [1, 2, 3] 형태로 정의하며 각 원소를 수정할 수 있다. []는 빈 list를 의미한다.

>>> b = [1,"aa",3,4,5]
>>> type (b)
<type 'list'>

• tuple (1, 2, 3) 형태로 정의하며 한번 정의한 원소를 수정할 수 없다. 튜플원소에 대한 수정 작업은 "TypeError: 'tuple' object does not support item assignment" 같은 오류를 발생시킨다. 원소 추가/삭제도 불가하다. ()는 빈 tuple을 의미한다. 원소를 교체하거나 추가 하는 등의 작업은 새로운 튜플을 생성하는 방법으로만 가능하다. 아래의 예에서는 첫원소를 대문자 'A'바꾼 새로운 배열로 교체했다.

원소가 하나만 있는 tuple은 괄호와 구분이 되지 않기 때문에 ('A',)와 같이 기술하면 tuple임을 명시할 수 있다.

>>> b = ( 1, "aa", [3, 4, 5], 6, 7)
>>> type (b)
<type 'tuple'>
>>> t = ('a', 'b', 'c', 'd', 'e')
>>> t = ('A',) + t[1:]
>>> t
('A', 'b', 'c', 'd', 'e')

>>> print b
(1, 'aa', [3, 4, 5], 6, 7)
>>> print b[2]
[3, 4, 5]
>>> print b[2][0]
3 
>>> a = [3, b, 'aaa']
>>> print a
[3, (1, 'aa', [3, 4, 5], 6, 7), 'aaa']
>>> b[2][0] = 'test'
>>> print a
[3, (1, 'aa', ['test', 4, 5], 6, 7), 'aaa']

• A.append(obj) 배열 맨 원소로 obj를 추가한다. None type.
• A + B 배열 A와 B를 연결하여 새로운 배열을 리턴한다. 단 A/B가 동일한 list 또는 tuple 타입이어야 한다 += 연산자도 사용할 수 있다.
• A * i 배열 A를 i회 반복하여 새로운 배열을 리턴한다. *= 연산자도 사용할 수 있다.
• A.extend(list) list로 입력한 리스트를 배열 맨뒤에 붙인다. 파라미터는 리스트만 허용. None type.
• A.insert(index,obj) index로 지정한 위치에 새로운 원소로 obj를 삽입하고 나머지는 우측으로 이동시킨다. None type.
• del A[index] index로 지정한 위치의 원소를 제거하고 나머지를 좌측으로 이동시킨다. del A[i:j]와 같이  범위 지정으로 삭제도 가능하다.
• A.pop(index) index로 지정한 위치의 원소를 리턴 및 제거하고 나머지를 좌측으로 이동시킨다

>>> a
[1, 2, 3, 4, 9, 8, 7]
>>> print a.pop(3)
4
>>> a
[1, 2, 3, 9, 8, 7]
>>> a.remove(9)
>>> a
[1, 2, 3, 8, 7]

>>> a = ('a','b','c')
>>> ''.join(a)
'abc'
>>> '=='.join(a)
'a==b==c'

>>> print divmod(10,3)
(3, 1)
>>> type(divmod(10,3))
<type 'tuple'>

• zip(A, B,...) 인수로 지정된 배열 또는 스트링(문자가 개별 항목으로 취급됨)의 각 원소들을 원소개수가 가장 작은 것을 기준으로 동일 인덱스로 묶어 새로운 배열을 리턴한다.

>>> zip([1,2,3],('a','b','c'),['qqq','rrr'],"222222")
[(1, 'a', 'qqq', '2'), (2, 'b', 'rrr', '2')]

* 사전(Dictionary)

>>> a={"a":"kor", 'b':'eng', 10:'jpn'}
>>> a
{'a': 'kor', 10: 'jpn', 'b': 'eng'}
>>> a = dict([["a","kor"], ['b','eng'], [10,'jpn']])
>>> a
{'a': 'kor', 10: 'jpn', 'b': 'eng'}
>>> a = dict(zip(["a",'b',10], ["kor", 'eng', 'jpn']))
>>> a
{'a': 'kor', 10: 'jpn', 'b': 'eng'}
>>>dice = { (1,1): "snake eyes", (6,6): "box cars" }
>>>dice
{(1, 1): 'snake eyes', (6, 6): 'box cars'}
>>>dice[(1,1)]
'snake eyes'

>>> a['a']
'kor'
>>> a['c']

Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    a['c']
KeyError: 'c'
>>> a.get('a')
'kor'
>>> a.get('c')
>>> a.get('c', "c is not key!")
'c is not key!'

>>> a
{'a': 'kor', 10: 'jpn', 'b': 'eng'}
>>> a[100]='ddd'
>>> a
{'a': 'kor', 10: 'jpn', 'b': 'eng', 100: 'ddd'}

>>> b
{'a': 'kor', 'b': 'eng', 100: 'ddd', 10: 'xxx', 'x': None, 'z': 'qqq'}
>>> a
{'a': 'kor', 10: 'jpn', 'b': 'eng', 100: 'ddd'}
>>> a.update(b)
>>> a
{'a': 'kor', 'b': 'eng', 100: 'ddd', 10: 'xxx', 'x': None, 'z': 'qqq'}