#keywords minzkn,hwport,programming,development,python,string,list,tuple,set,dictionary,number,integer,파이썬
#title 파이썬(Python)언어
[wiki:Home 대문] / [wiki:CategoryProgramming 프로그래밍] / [wiki:LanguagePython 파이썬(Python) 언어]
----
== [wiki:LanguagePython 파이썬(Python)언어] ==
 * 작성자
  조재혁([mailto:minzkn@minzkn.com])

 * 고친과정
  2018년 2월 23일 : 처음씀[[br]]
  2018년 3월 5일 : 자료형 정리[[br]]
  2018년 3월 7일 : 조건문, 제어문 정리[[br]]

 [attachment:python-logo-master-v3-TM.png Python Logo]

[[TableOfContents]]
=== 파이썬(Python)이란? ===
 파이썬(Python)은 1991년 네덜란드 CWI의 "'''귀도 반 로섬(Guido van Rossum)'''"이 발표한 고급 프로그래밍 언어입니다.
  [[attachment:Guido_van_Rossum_OSCON_2006-m.png 귀도 반 로섬(Guido van Rossum)]]
  * 파이썬이라는 이름을 자신이 좋아하던 코미디 쇼인 "몬티 파이썬의 날아다니는 서커스(Monty Python's Flying Circus)"에서 따왔다고 합니다.
  * 파이썬은 1980년대 말 고안되어 귀도 반 로섬이 1989년 12월 구현하기 시작하였습니다.
  * 반 로섬은 파이썬의 주저자로 계속 중심적 역할을 맡아 파이썬의 방향을 결정하여, 파이썬 공동체로부터 '자선 종신 이사'의 칭호를 부여받았습니다.

 '''특징'''으로는 다음과 같습니다.
  * 플랫폼 독립적
   * 많은 플랫폼을 지원합니다.
  * 기본적으로 해석기(인터프리터)에 의한 방식
   * 사용자가 모르는 사이에 스스로 파이썬(Python) 소스 코드를 컴파일하여 바이트 코드(Byte code)를 만들어 냄으로써 다음에 수행할 때에는 빠른 속도를 보여 줍니다.
   * 대화형 언어
  * 객체지향적
   * 객체의 멤버에 무제한으로 접근할 수 있습니다. (속성이나 전용의 메서드 훅을 만들어 제한 가능)
  * 동적 타이핑(dynamically typed)
   * 실행 시간에 자료형을 검사합니다.
   * '''[^https://en.wikipedia.org/wiki/Duck_typing 덕 타이핑(Duck typing)]''' : 객체의 변수 및 메소드의 집합이 객체의 타입을 결정하는 것
    * 클래스 상속이나 인터페이스 구현으로 타입을 구분하는 대신, 덕 타이핑은 객체가 어떤 타입에 걸맞은 변수와 메소드를 지니면 객체를 해당 타입에 속하는 것으로 간주하는 것
     {{{#!plain
만약 어떤 새가 오리처럼 걷고, 헤엄치고, 꽥꽥거리는 소리를 낸다면 나는 그 새를 오리라고 부를 것이다.
}}}
  * '''들여쓰기를 사용해서 블록을 구분하는 독특한 문법'''
   * 가독성 향상에 크게 도움
   * 공백(Space) 또는 탭(Tab) 문자로 들여쓰기를 합니다.
   * 첫 들여쓰기 문자의 갯수에 제한은 없으나 두번째 이후의 들여쓰기가 같은 레벨이 되려면 첫 들여쓰기시의 들여쓰기 문자의 갯수와 같아야 합니다. (즉, '''들여쓰기 구간의 들여쓰기 문자 수는 동일해야 함''')
   * 보통 공백(Space)은 4개를 권장하고 있습니다.
   * 모든 구문에서 들여쓰기 이전줄에서 콜론(':') 문자로 끝나는 구문을 볼 수 있습니다. (매우 간결한 1줄 정도만이 있다면 들여쓰기하지 않을 수 있는 방법도 제공됨)
  * 접착(glue) 언어라고 부를 정도로 다른 언어와 잘 어울려서 결합되어 사용 가능
   * 빠른 속도가 필요한 부분만 골라서 C 언어 등으로 모듈화 가능
   * ctypes, SWIG, SIP 등의 래퍼 생성 프로그램들 이용 가능
  * Pyrex, Psyco, NumPy 등을 이용하면 수치를 빠르게 연산할 수 있기 때문에 과학, 공학 분야에서도 많이 이용

 파이썬(Python)을 해석하는 소프트웨어는 여러가지가 있습니다.
  * C파이썬(CPython, C로 작성된 인터프리터)
   * Reference 구현이며 사실상 표준입니다.
   * 오픈 소스 소프트웨어입니다.
    * 개방형, 공동체 기반 개발 모델을 가지고 있습니다.
    * 비영리의 "[^https://www.python.org/psf/ 파이썬 소프트웨어 재단(Python Software Foundation)]"이 관리합니다.
  * 스택리스 파이썬
   * C 스택을 사용하지 않는 인터프리터.
  * 자이썬
   * 자바 가상 머신 용 인터프리터. 과거에는 제이파이썬(JPython)이라고 불렸다.
  * IronPython
   * .NET 플랫폼 용 인터프리터.
  * PyPy
   * 파이썬으로 작성된 파이썬 인터프리터.
  * Brython
   * JavaScript로 구현, JavaScript를 대신하여 웹 스크립트 형태로 Python을 실행할 목적

 '''파이썬(Python)의 핵심 철학'''은 다음과 같습니다. (참고: [^https://www.python.org/dev/peps/pep-0020/ PEP 20 -- The Zen of Python])
  * "아름다운게 추한 것보다 낫다." (Beautiful is better than ugly)
  * "명시적인 것이 암시적인 것 보다 낫다." (Explicit is better than implicit)
  * "단순함이 복잡함보다 낫다." (Simple is better than complex)
  * "복잡함이 난해한 것보다 낫다." (Complex is better than complicated)
  * "가독성은 중요하다." (Readability counts)

 파이썬(Python)의 빠른 개발 속도와 생산성을 두고 유행처럼 퍼진 말도 있습니다. 그만큼 생산성 부문에서 강한 언어라고 할 수 있겠습니다.
  * "인생은 너무 짧다. 그래서 파이썬이 필요하다." ("Life is too short, You need Python.")
=== 개발환경 준비 ===
 "[^https://www.python.org/downloads/]" 에서 자신의 OS환경과 맞는 버젼을 다운로드 받아 설치합니다.

  [[attachment:python-download-page.png Python download page]]

 윈도우의 경우는 설치파일 실행 후에 설치준비단계에서 "'''Add Python X.Y.Z to PATH'''" 라는 의미의 옵션을 꼭 체크하여야 명령줄 사용하는데 불편함이 없습니다.

 리눅스의 경우는 대부분 설치되어 있는 경우가 많습니다.

 직접 Unix/Linux/BSD 등의 OS환경에서 소스를 받아서 설치하고자 하는 경우 다음과 같이 합니다.
  1. 먼저 소스를 다운로드 받습니다.
  1. 다운로드 받은 소스를 압축해제합니다.
   {{{#!plain
# tar -xvzf Python-X.Y.Z.tgz
}}}
  1. 압축해제된 디렉토리로 이동합니다.
   {{{#!plain
# cd Python-X.Y.Z
}}}
  1. configure 를 실행합니다. 자신의 입맛에 맞도록 구성하기 위해서 추가적인 옵션을 선택할 수 있습니다.
   {{{#!plain
# ./configure --help
# ./configure
}}}
  1. 문제없이 configure가 진행되었다면 Makefile 이 만들어졌을겁니다. 이제 make 합니다.
   {{{#!plain
# make
}}}
  1. root권한계정을 통해서 설치를 진행합니다.
   {{{#!plain
# su -
# make install

또는

# sudo make install
}}}

 편집기는 일반적인 '''텍스트(Text) 편집이 가능한 것이면 모두 사용가능'''합니다.
  * 파이참(PyCharm)
   * [^http://www.jetbrains.com/pycharm/]
  * 에디트 플러스
   * [^http://www.editplus.com/kr/]
  * 노트패트++(notepad++)
   * [^https://notepad-plus-plus.org/]
  * 서브라임 텍스트 3
   * [^http://www.sublimetext.com/]
  * Visual Studio Code
   * [^https://code.visualstudio.com/]
  * VIM(vi editor)
   * [^http://www.vim.org/]
  * EMACS
   * [^https://www.gnu.org/software/emacs/]
  * Eclipse
   * [^https://www.eclipse.org/]

 '''파이썬(Python)에서 인지하는 환경변수(Python Environment Variables)'''
  |환경변수|<bgcolor="gray">  환경변수(Environment Variable)  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{PYTHONPATH}}}  ||파이썬 인터프리터에게 프로그램으로 가져온 모듈 파일의 위치를 알려줍니다. 파이썬 소스 라이브러리 디렉토리와 파이썬 소스 코드가 들어있는 디렉토리를 포함해야합니다. PYTHONPATH는 때때로 Python 설치 프로그램에 의해 미리 설정됩니다.  ||
  ||<bgcolor="yellow">{{{PYTHONSTARTUP}}}  ||파이썬 소스 코드를 포함하는 초기화 파일의 경로를 포함합니다. 인터프리터를 시작할 때마다 실행됩니다. Unix에서는 .pythonrc.py라는 이름으로 유틸리티를로드하거나 PYTHONPATH를 수정하는 명령이 들어 있습니다.  ||
  ||<bgcolor="yellow">{{{PYTHONCASEOK}}}  ||Windows에서 Python이 import 문에서 대소 문자를 구분하지 않는 첫 번째 일치를 찾도록 지시하는 데 사용됩니다. 이 변수를 활성화하려면 값을 설정하십시오.  ||
  ||<bgcolor="yellow">{{{PYTHONHOME}}}  ||대체 모듈 검색 경로입니다. 일반적으로 PYTHONSTARTUP 또는 PYTHONPATH 디렉토리에 포함되어 스위칭 모듈 라이브러리를 쉽게 만들 수 있습니다.  ||
=== 기초사항과 실습 ===
 '''파이썬(Python) CLI 명령어("python" 또는 "python.exe")의 주요 옵션(Options)'''
  |명령행 옵션|<bgcolor="gray">  옵션(Option)  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">아무 인자 없이 실행하는 경우  ||기본 대화형 인터프리터로 실행됩니다.  ||
  ||<bgcolor="yellow">{{{-d}}}  ||디버그 출력을 제공합니다.  ||
  ||<bgcolor="yellow">{{{-O}}}  ||최적화 된 바이트 코드 (.pyo 파일을 생성)를 생성합니다.  ||
  ||<bgcolor="yellow">{{{-S}}}  ||시작시 Python 경로를 찾기 위해 "import site"를 실행하지 않도록 합니다.  ||
  ||<bgcolor="yellow">{{{-v}}}  ||자세한 출력 (import 문의 세부 추적시 유용)  ||
  ||<bgcolor="yellow">{{{-c <cmd>}}}  ||cmd 문자열로 전송 된 Python script를 실행합니다.  ||
  ||<bgcolor="yellow">{{{<file>}}}  ||주어진 파일에서 Python script를 실행합니다.  ||

 대화형 인터프리터 실행은 CLI상에서 "python"을 입력하여 진입합니다.
  {{{#!plain
$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 
}}}

 인터프리터의 프롬프트 (">>>") 상태에서 종료하려면 다음과 같은 방법 중 편한방법을 선택하여 종료할 수 있습니다.
  * Ctrl + Z (Windows 인 경우) 를 눌러 종료
  * Ctrl + D (Unix 계열인 경우) 를 눌러 종료
  * "quit()" 을 프롬프트상에 입력하고 Enter키를 눌러 종료
   {{{#!enscript python
$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> quit()
$
}}}
  * "exit()" 을 프롬프트상에 입력하고 Enter키를 눌러 종료
   {{{#!enscript python
$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.exit()
$
}}}

 대화형 인터프리터에서의 간단한 명령 실행 (명령을 입력하다 보면 특정 명령의 경우는 들여쓰기 구문을 추가적으로 필요로 하는 경우가 있는데 이 때는 프롬프트가 "..."으로 바뀌며 들여쓰기 후 추가적인 명령을 입력하거나 그냥 빈줄에서 Enter를 눌러 들여쓰기를 종료하는 식으로 입력할 수 있습니다.)
  {{{#!enscript python
$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+2
3
>>> 3/2.4
1.25
>>> 3*9
27
>>> a=1
>>> b=2
>>> c=a+b
>>> d="Python test"
>>> e=2+3j # 복소수를 표현하는 j객체 사용
>>> f=3
>>> a+b
3
>>> c
3
>>> d
'Python test'
>>> e*f # 복소수 연산 결과
(6+9j)
>>> print("Hello world : %d + %d = %d (%s)"%(a,b,c,d))
Hello world : 1 + 2 = 3 (Python test)
>>> if (a+b) > 1:
...     print("a is greater than 1") # print 앞에 들여쓰기를 위해서 공백(space 또는 tab) 문자를 입력해야 합니다.
...
a is greater than 1
>>> for v in [1,2,3]:
...     print("loop in %d"%(v)) # for 반복문 테스트 - 변수 v 에 차례대로 대입되어 수행
...
loop in 1
loop in 2
loop in 3
>>> i=0
>>> while i < 3:
...     i = i + 1
...     print("while loop in %d"%(i))
...
while loop in 1
while loop in 2
while loop in 3
>>> def mysum(a,b):
...     return a + b
...
>>> print("mysum func call result : %d"%(mysum(3,4)))
mysum func call result : 7
>>> quit()
$
}}}

 '''주석문''' : 프로그램의 수행과 관계없으며 설명문을 넣기 위해 사용합니다.
  * 샵 문자(''#'') 로 시작하는 문장은 그 줄 끝까지가 주석문입니다.
   * 프로그램의 수행에는 영향을 주지 않지만 편집기나 해석기에게 무언가 의미를 전달하기 위해서도 사용됩니다.
  * 큰 따옴표(''"'') 3번 연속으로 사용한 {{{"""}}} 를 양쪽에 두고 그 사이도 주석문입니다.
  * 작은 따옴표(') 3번 연속으로 사용한 {{{'''}}} 를 양쪽에 두고 그 사이도 주석문입니다.

 아래와 같이 "hello.py" 를 편집기로 작성하여 첫 파이썬(Python) 프로그램을 만듭니다.
  {{{#!enscript python
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# vim: set fileencoding=UTF-8 :

"""
사이의 내용은 모두 주석문입니다.
"""

print("Hello world")           # print 구문은 인자로 주어진 문자열을 출력해줍니다.


'''
이것도 주석문입니다.
'''
}}}
  * 첫 줄의 "#!/usr/bin/python"은 기본 해석기를 지정
   * 가장 첫줄이 "#!"로 시작하는 경우 뒤에 명시된 명령줄은 이 텍스트(Text)파일을 해석할 수 있는 해석기로 인지할 수 있습니다.
   * 즉, 이 경우 본래는 다음과 같이 실행하게 되지만
    {{{#!plain
$ /usr/bin/python hello.py
}}}
   * 첫줄의 해석기 명시가 있다면 실행퍼미션만 주고 다음과 같이 실행할 수 있게 됩니다.
    {{{#!plain
$ ./hello.py
}}}
   * Windows 에서는 확장자 ".py" 가 어떠한 해석기를 사용하게 될지를 결정합니다.
  * 첫번째 또는 두번째 줄의 "'''# -*- coding: UTF-8 -*-'''"은 해석기에게 이 프로그램의 인코딩(Encoding) 방식을 알리는 문구 ([^https://www.python.org/dev/peps/pep-0263/ 참고링크])
   * Windows 환경에서는 보통 UTF-8 또는 CP949로 많이 작성됩니다.
   * 대부분의 환경에서는 대부분 UTF-8로 작성되는게 좋습니다.
   * 되도록이면 문서의 해석기 지정을 위한 첫줄을 제외한 최 상단에 명시하도록 합니다.
  * 세번째 줄의 "# vim: set fileencoding=UTF-8 :"은 VIM편집이에게 파일의 인코딩 방식을 알리는 문구 (선택사항)

 '''구문이 너무 긴 경우 여러줄에 걸쳐서 작성'''
  * 일반적으로 Escape sequence 구문({{{'\'}}}을 입력 후 새로운 줄에서 이어서 작성) 을 통해서 여러줄에 걸쳐서 구분을 작성할 수 있습니다.
   {{{#!enscript python
>>> a = 1 + \
... 2 + \
... 3
>>> a
6
>>>
}}}
  * {{{[]}}}, {{{{}}}}, {{{()}}} 으로 둘러 쌓여있는 구문은 Escape sequence 구문이 필요없이 줄바꿈 하여 작성 가능합니다.
   {{{#!enscript python
>>> a = ['1', 'two',
... '3', 'four',
... 'five'
... ]
>>> a
['1', 'two', '3', 'four', 'five']
>>>
}}}

 '''구문이 간결한 경우 여러구문을 한줄로 작성'''
  * 세미콜론(';')을 줄바꿈 대신에 사용하여 여러구문을 한줄에 작성할 수 있습니다.
   {{{#!enscript python
>>> import sys; x = 'foo'; sys.stdout.write(x + '\n')
}}}

 '''식별자(Identifiers)''' : 변수(Variable), 함수(Function), 클래스(Class), 모듈(Module), 그 밖의 객체(Object)를 식별하기 위한 이름
  * 허용되는 문자 : 'A' ~ 'Z', 'a' ~ 'z', '_', '0' ~ '9'
   * 대소문자는 엄격히 구분합니다.
   * Python 3.x 부터 유니코드의 한글도 허용됩니다.
  * 통상적인 이름규칙
   * Class 이름으로는 대문자로 시작합니다. 그 밖의 경우는 소문자로 시작합니다.
   * 밑줄('_')로 시작하는 경우는 내부적(Private)인 사용용도인 경우에 사용합니다.
    * 밑줄('_')이 2회 연속으로 시작하는 경우는 좀더 내부적인 용도에서 사용합니다.
    * 밑불('_')이 2회 연속으로 끝에 사용되면 언어에 특화된 특수 경우입니다.

 '''파이썬(Python)의 예약어''' (총 30개 정도의 소문자로 이루어진 예약어는 변수나 식별자의 이름으로 사용할 수 없습니다., 참고: [^https://www.tutorialspoint.com/python/python_basic_syntax.htm Reserved Words])
  * and, 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

 '''연산자 우선순위 (Operators Precedence)''' : 위 부터 우선순쉬가 높은 순 (단, 괄호로 묶은 연산이 우선순위가 높습니다., 참고: [^https://www.tutorialspoint.com/python/python_basic_operators.htm Python Operators Precedence])
  |연산자 우선순위|<bgcolor="gray">  연산자(Operator)  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{**}}}  ||지수 제곱  ||
  ||<bgcolor="yellow">{{{~, +, ,-}}}  ||단항 연산  ||
  ||<bgcolor="yellow">{{{*, /, %, //}}}  ||산술 연산 곱하기, 나누기, 나머지, 몫  ||
  ||<bgcolor="yellow">{{{+, -}}}  ||산술 연산 덧셈, 뺄셈  ||
  ||<bgcolor="yellow">{{{>>, <<}}}  ||비트 쉬프트  ||
  ||<bgcolor="yellow">{{{&}}}  ||비트논리 AND  ||
  ||<bgcolor="yellow">{{{^, |}}}  ||비트논리 XOR, OR  ||
  ||<bgcolor="yellow">{{{<=, <, >, >=}}}  ||비교 연산  ||
  ||<bgcolor="yellow">{{{<>, ==, !=}}}  ||평등 연산  ||
  ||<bgcolor="yellow">{{{=, %=, /=, //=, -=, +=, *=, **=}}}  ||할당 연산  ||
  ||<bgcolor="yellow">{{{is, is not}}}  ||식별 연산  ||
  ||<bgcolor="yellow">{{{in, not in}}}  ||멤버 연산  ||
  ||<bgcolor="yellow">{{{not, or, and}}}  ||논리 연산  ||

 파이썬(Python) '''2.x대 버전 과 3.x대 버젼간의 차이''' (처음 파이썬을 배우는 분들은 3.x이상의 버젼을 기준으로 학습할 것을 권고하고 있습니다.)
  * 구문내에서 '''버젼을 확인'''하려면
   {{{#!enscript python
>>> import sys
>>> sys.version
'2.7.6 (default, Oct 26 2016, 20:30:19) \n[GCC 4.8.4]' # 2.X 의 경우
'3.4.3 (default, Nov 17 2016, 01:08:31) \n[GCC 4.8.4]' # 3.X 의 경우
>>> sys.version_info
sys.version_info(major=2, minor=7, micro=6, releaselevel='final', serial=0) # 2.X 의 경우
sys.version_info(major=3, minor=4, micro=3, releaselevel='final', serial=0) # 3.X 의 경우
}}}
  * 사전형과 문자열형과 같은 내장자료형의 내부적인 변화 및 일부 구형의 구성 요소 제거
  * 표준 라이브러리 재배치
  * 향상된 유니코드 지원 (2.x 에서는 유니코드를 표현하기 위해 u"문자열" 처럼 유니코드 리터럴을 사용했지만 3.0 부터는 모든 문자열이 유니코드이기 때문에 "문자열" 처럼 표현하면 된다.)
  * 한글 변수 사용 가능
  * print 명령문이 print() 함수로 바뀜
   * 버젼간 print 구문 사용에 강력한 주의가 필요
    {{{#!enscript python
>>> print "<문자열>" # 2.7 이하에서만 사용 가능 (3.X 이상에서는 오류)
>>> print "<문자열>", # 줄바꿈 제거 기능으로 2.7 이하에서만 사용 가능 (3.X 이상에서는 오류)
>>> print("<문자열>") # 2.7 이상부터만 사용 가능 (2.7 미만에서는 오류)
>>> print("<문자열>",end="<줄바꿈 대체문자열>") # 줄바꿈 제거 또는 대체가 가능한 기능이며 3.X 이상부터만 사용 가능 (2.X 이하에서는 오류)
}}}
   * '''줄바꿈을 제거하여 출력하려면 버젼에 따른 호환성 문제가 고민'''되어야 합니다.
    {{{#!enscript python
>>> items=["Hello", "World", "Testing"]
>>> for temp in items:
...     print "%s"%temp,"_",     # 뒤에 콤마(',')로 print 구문이 끝나면 줄바꿈이 일어나지 않습니다. (Python 2.X 방식이며 3.X에서는 잘못된 구문으로 오류가 발생합니다.)
...
Hello _ World _ Testing _
>>> items=["Hello", "World", "Testing"]
>>> for temp in items:
...     print("%s"%temp,end="_") # 마지막 인자로 end="<줄바꿈 대신에 대체될 문자 또는 빈 공백>" 을 넣어서 줄바꿈이 일어나지 않게 할 수 있습니다. (Python 3.X 방식이며 2.X에서는 잘못된 구문으로 오류가 발생합니다.)
...
Hello_World_Testing_>>> # 줄바꿈이 "_"로 대체되어 프롬프트가 출력문자열 뒤에 표시되었습니다. (Python 3.X 에서는...)
>>>
}}}
=== 자료형 ===
 '''기본 자료형''':
  * 정수(Integer)형
  * 긴 정수(Long Integer)형
   * 메모리가 허락하는 한 무제한의 자릿수로 정수를 계산 가능. (파이썬 3 버전에서는 사라지고, 대신 정수형의 범위가 무제한으로 늘어남)
  * 부동 소수점수(Floating-point)형
  * 복소수(Complex-number)형
  * 문자(String)형
  * 유니코드(Unicode) 문자(String)형
  * 함수(Function)형
  * 논리형(boolean)

 '''집합형 자료형''':
  * 리스트(List)형 - 내부의 값을 나중에 바꿀 수 있음
  * 튜플(Tuple)형 - 한 번 값을 정하면 내부의 값을 바꿀 수 없음
  * 사전(Dictionary)형 - 내부의 값을 나중에 바꿀 수 있음
  * 집합(Set)형 - 중복을 허락하지 않으며 변경 가능하게도, 변경 불가능하게도 만들 수 있음

 '''NoneType 형'''
  유일한 객체 None은 C/C++, Java의 null(NULL) 과 같으며 파이썬의 None 은 False도 아니고 0도 아닌 또 다른 형입니다. 객체가 존재하지 않는 다는 것을 표현할 때 주로 사용합니다.
   {{{#!enscript python
>>> type(None)
<class 'NoneType'>
>>>
}}}

 '''[^https://en.wikipedia.org/wiki/Immutable_object 불변객체(Immutable Object)]'''
  * 생성 후 그 상태를 바꿀 수 없는 객체
  * 외부에서 그 필드를 변경하는 방법이 존재하지 않고 가변적인 필드접근도 가지고 있지 않는 객체

 '''[^https://en.wikipedia.org/wiki/Immutable_object 가변객체(Mutable Object)]'''
  * 생성 후에도 상태를 변경할 수 있는 객체

 '''파이썬(Python) 3.x 의 내장 자료형''' 요약 (참고: [^https://www.tutorialspoint.com/python/python_variable_types.htm Data Type Conversion])
  |내장 자료형|<bgcolor="gray">  종류(Type)  ||<bgcolor="gray">  객체의 종류  ||<bgcolor="gray">  설명(Description)  ||<bgcolor="gray">  문법 예(Syntax example)  ||
  ||<bgcolor="yellow">bool  ||  불변객체  ||참/거짓 값(Boolean value)  ||True, False  ||
  ||<bgcolor="yellow">bytearray  ||  가변객체  ||순차 바이트열(Sequence of bytes)  ||{{{bytearray(b'Some ASCII')}}}, {{{bytearray(b"Some ASCII")}}}, {{{bytearray([119, 105, 107, 105])}}}  ||
  ||<bgcolor="yellow">bytes  ||  불변객체  ||순차 바이트열(Sequence of bytes)  ||{{{b'Some ASCII'}}}, {{{b"Some ASCII"}}}, {{{bytes([119, 105, 107, 105])}}}   ||
  ||<bgcolor="yellow">complex  ||  불변객체  ||복소수 (실수와 허수)  ||{{{3+2.7j}}}  ||
  ||<bgcolor="yellow">dict  ||  가변객체  ||연관 배열의 키와 값 쌍  ||{{{{'key1': 1.0, 3: False}}}}  ||
  ||<bgcolor="yellow">ellipsis  ||  -  ||NumPy 배열에서 색인으로 사용되는 줄임표 자리 표시 자  ||...  ||
  ||<bgcolor="yellow">float  ||  불변객체  ||부동소수점 수 (시스템 정의 정밀도)  ||3.1415927  ||
  ||<bgcolor="yellow">frozenset  ||  불변객체  ||순서가없는 집합이며 중복 된 내용이 없고 해시 가능한 경우 혼합 유형을 포함 할 수 있음  ||{{{frozenset([4.0, 'string', True])}}}  ||
  ||<bgcolor="yellow">int  ||  불변객체  ||정수로서 크기는 무제한  ||42  ||
  ||<bgcolor="yellow">list  ||  가변객체  ||혼합 형태를 포함가능  ||{{{[4.0, 'string', True]}}}  ||
  ||<bgcolor="yellow">set  ||  가변객체  ||순서가없는 집합이며 중복 된 내용이 없고 해시 가능한 경우 혼합 유형을 포함 할 수 있음  ||{{{{4.0, 'string', True}}}}  ||
  ||<bgcolor="yellow">str  ||  불변객체  ||일련의 유니코드(Unicode) 코드포인트(codepoints)  ||'MyString', "MyString"  ||
  ||<bgcolor="yellow">tuple  ||  불변객체  ||혼합 형태를 포함가능  ||{{{(4.0, 'string', True)}}}  ||
==== 숫자(Number)형 ====
 |숫자(Number)형의 종류|<bgcolor="gray">  항목  ||<bgcolor="gray">  예  ||<bgcolor="gray">  비고  ||
 ||<bgcolor="yellow">정수(Integer)  ||123, -345, 0  ||양의 정수, 음의 정수, 0(Zero)  ||
 ||<bgcolor="yellow">실수(Floating-point)  ||123.45, -1234.5, 3.4e10, 4.24E10, 4.24E-10  ||컴퓨터식 지수 표현 방식, e 또는 E 둘다 사용가능, E10은 10의 10승을 의미  ||
 ||<bgcolor="yellow">복소수(Complex-number)  ||1+2j, -3j  ||j 또는 J 둘다 사용가능, 복소수의 실수부-허수부-켤레복소수-절대값 등을 다룰 수 있습니다.  ||
 ||<bgcolor="yellow">8진수(Octal)  ||0o34, 0o25, 0o177  ||숫자 0 다음에 알파벳 O(소문자 또는 대문자 사용가능)으로 시작  ||
 ||<bgcolor="yellow">16진수(Hexa-decimal)  ||0x2A, 0xFF, 0xab, 0xABC  ||숫자 0 다음에 알파벳 X(소문자 또는 대문자 사용가능)으로 시작  ||

 * 컴퓨터식 지수 표현 방식
  * 4.24e10 => 4.2 * 10의 10승 => 4.2 * 10 ** 10 => 42000000000.0
  * 4.24e-10 => 4.2 * 10의 -10승 => 4.2 * 10 ** -10
 * 8진수 (숫자 0 다음에 알파벳 소문자 o 또는 알파벳 대문자 O 로 시작하는 숫자)
  * 0o177 => 십진수 127
 * 16진수 (숫자 0 다음에 알파벳 소문자 x 또는 알파벳 대문자 X 로 시작하는 숫자)
  * 0xff => 십진수 255
 * 복소수
  * 1+2j 의 실수부 => (1+2j).real => 1.0
  * 1+2j 의 허수부 => (1+2j).imag => 2.0
  * 1+2j 의 켤레복소수 => (1+2j).conjugate() => (1-2j)
  * 1+2j 의 절대값 => abs(1+2j) => 2.23606797749979
 * 연산자
  * '+' : 덧셈
  * '-' : 뺄셈
  * '*' : 곱셈
  * '/' : 나눗셈
   * '''python 2.7 에서는 정수끼리의 나눗셈은 정수로만 반환'''됨에 유의
    * 3/2 => 1
    * 3//2 => 1
   * python 3 에서는 정수끼리 나눗셈은 소수점이 있는 결과를 정상적으로 반환 (정수끼리의 나눗셈이 python3에서부터는 실수로 반환됩니다.)
    * 3/2 => 1.5
    * 3//2 => 1.0
   * python 2.7과 3 관계없이 호환하려면 1.0을 피연산자에 곱하는 등의 조치를 하여 실수형 반환을 유도하도록 하는 고려가 필요 (호환성 유의)
    * 3/(2*1.0) => 1.5
    * 3//(2*1.0) => 1.0
  * '%' : 나눗셈 후 나머지
  * '//' : 나눗셈 후 소수점 아랫자리를 버리는 연산
  * '**' : 거듭제곱 => x ** y => x의 y제곱
  * '<<' : 왼쪽(MSB방향)으로 shift
  * '>>' : 오른쪽(LSB방향)으로 shift
  * '|' : OR 연산
  * '&' : AND 연산
  * '^' : XOR 연산
  * '~' : 1의 보수 연산 (2의 보수는 숫자형 앞에 '-'를 붙입니다.)
==== 문자(String)열 자료형 ====
 큰따옴표({{{"}}}), 작은따옴표({{{'}}}), 큰따옴표3개연속({{{"""}}}), 작은따옴표3개연속({{{'''}}}) 중에서 하나를 선택하여 양쪽으로 둘러싼 사이의 내용이 문자열입니다.
  ||{{{"Hello world"}}}  ||
  ||{{{'Hello world'}}}  ||
  ||{{{"""Hello world"""}}}  ||
  ||{{{'''Hello world'''}}}  ||

 문자열을 감싸는 방법에 따라서 해당 감싸는 문자기호를 제외한 나머지 문자는 특별한 처리를 하지 않아도 정상적인 문자열로 인식합니다.
  ||{{{"Python's Hello world"}}}  ||
  ||{{{'Python quite "Hello world"'}}}  ||
  ||{{{"""Python string triple '''"""}}}  ||
  ||{{{'''Python string triple """'''}}}  ||


 만약 문자열을 감싸는 문자기호가 문자열 내에 표시해야 하는 경우는 백슬래시({{{'\'}}})를 사용하여 Escape sequence 처리할 수 있습니다.
  ||{{{'Python\'s Hello world'}}}  ||
  ||{{{"Python quite \"Hello world\""}}}  ||
  ||{{{'''Python string triple \'\'\''''}}}  ||
  ||{{{'''Python string triple ''\''''}}}  ||
  ||{{{"""Python string triple \"\"\""""}}}  ||
  ||{{{"""Python string triple ""\""""}}}  ||

 특수문자등의 입력에 있어서 미리 정해진 Escape code 입력은 다음과 같습니다. (참고: [^https://www.tutorialspoint.com/python/python_strings.htm Escape Characters])
  |문자열 Escape code|<bgcolor="gray">  코드  ||<bgcolor="gray">  설명  ||
  ||<bgcolor="yellow">{{{\\ }}}  ||역슬래시({{{\ }}}) 그 자체  ||
  ||<bgcolor="yellow">{{{\n}}}  ||줄 바꿈 문자(New line, 다음줄의 첫 컬럼으로 이동)  ||
  ||<bgcolor="yellow">{{{\t}}}  ||탭(Tab) 문자  ||
  ||<bgcolor="yellow">{{{\r}}}  ||캐리지 리턴 문자(Carriage return, 커서를 현재 줄의 첫 컬럼으로 이동)  ||
  ||<bgcolor="yellow">{{{\f}}}  ||폼 피드(Form feed, 커서를 다음줄의 현 컬럼으로 이동)  ||
  ||<bgcolor="yellow">{{{\a}}}  ||벨 소리(PC speaker에 beep음을 울리게 함)  ||
  ||<bgcolor="yellow">{{{\s}}}  ||공백(Space) 문자  ||
  ||<bgcolor="yellow">{{{\b}}}  ||백 스페이스 문자  ||
  ||<bgcolor="yellow">{{{\v}}}  ||수직탭(Vertical tab) 문자  ||
  ||<bgcolor="yellow">{{{\cx}}}  ||Ctrl + X  ||
  ||<bgcolor="yellow">{{{\C-x}}}  ||Ctrl + X  ||
  ||<bgcolor="yellow">{{{\M-\C-x}}}  ||Meta + Ctrl + X  ||
  ||<bgcolor="yellow">{{{\e}}}  ||Escape 문자  ||
  ||<bgcolor="yellow">{{{\000}}} 또는 {{{\x00}}}  ||Nul terminator 문자  ||
  ||<bgcolor="yellow">{{{\aaa}}} 또는 {{{\xbb}}}  ||ASCII code 문자 (aaa 는 8진수 code, bb 는 16진수 code)  ||
  ||<bgcolor="yellow">{{{\<문자>}}}  ||<문자> 그 자체 (단, 위 Escape code가 아닌 경우만 <문자> 그 자체로 처리될 수 있음)  ||

 문자열은 더하기('+') 연산을 통해서 서로 연결되어 하나의 문자열이 될 수 있습니다.
  {{{#!enscript python
>>> head="Hello"
>>> tail="world"
>>> head + " " + tail
'Hello world'
>>>
}}}

 '''주의!''' 문자열과 숫자를 더하기('+') 연산하기 위해서는 문자열에 대한 더하기 인지 숫자에 대한 더하기 인지를 명확히 하도록 규정되어 있어 캐스팅(Casting)이 필요합니다.
  {{{#!enscript python
>>> a="1"
>>> b=2
>>> a+b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>> a+str(b)
'12'
>>> int(a)+b
3
>>>
}}}

 문자열은 곱하기("*") 연산을 통해서 반복된 문자열이 될 수 있습니다.
  {{{#!enscript python
>>> head_char="=+"
>>> head_line=head_char*50
>>> print(head_line)
=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
>>> i = 0
>>> while i < 10:
...     i = i + 1
...     print(head_char * i)
...
=+
=+=+
=+=+=+
=+=+=+=+
=+=+=+=+=+
=+=+=+=+=+=+
=+=+=+=+=+=+=+
=+=+=+=+=+=+=+=+
=+=+=+=+=+=+=+=+=+
=+=+=+=+=+=+=+=+=+=+
>>>
}}}

 '''문자열의 Methods''' (참고: [^https://www.tutorialspoint.com/python/python_strings.htm Built-in String Methods])
  |Built-in String Methods|<bgcolor="gray">  Method  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{capitalize()}}}  ||문자열의 첫 글자를 대문자로 표시  ||
  ||<bgcolor="yellow">{{{center(width, fillchar)}}}  ||총 너비 열의 가운데에 원래 문자열이있는 채워진 문자열을 반환  ||
  ||<bgcolor="yellow">{{{count(str, beg= 0,end=len(string))}}}  ||시작 인덱스 beg와 끝 인덱스 종료가 주어진 경우 문자열 또는 문자열의 하위 문자열에서 str이 몇 번 발생하는지 계산  ||
  ||<bgcolor="yellow">{{{decode(encoding='UTF-8',errors='strict')}}}  ||인코딩 용으로 등록 된 코덱을 사용하여 문자열을 디코딩 (인코딩 기본값은 기본 문자열 인코딩)  ||
  ||<bgcolor="yellow">{{{encode(encoding='UTF-8',errors='strict')}}}  ||문자열의 인코딩 된 문자열 버전을 반환 (오류시 기본값은 'ignore'또는 'replace'로 오류가 표시되지 않는 한 ValueError를 발생)  ||
  ||<bgcolor="yellow">{{{endswith(suffix, beg=0, end=len(string))}}}  ||문자열의 인코딩 된 버전이 반환 (오류 메시지가 'ignore'또는 'replace'오류가 표시되면 ValueError가 발생)  ||
  ||<bgcolor="yellow">{{{expandtabs(tabsize=8)}}}  ||문자열의 탭을 여러 공백으로 확장 (탭 크기가 제공되지 않으면 탭당 8 공백이 기본값)  ||
  ||<bgcolor="yellow">{{{find(str, beg=0 end=len(string))}}}  ||문자열 시작 또는 끝 인덱스 지정이 주어진 경우 str이 문자열에서 또는 문자열의 부분 문자열에서 발생하는지 확인 (그렇지 않으면 -1을 반환)  ||
  ||<bgcolor="yellow">{{{index(str, beg=0, end=len(string))}}}  ||{{{find()}}}와 동일하지만, str가 발견되지 않으면 예외가 발생  ||
  ||<bgcolor="yellow">{{{isalnum()}}}  ||문자열이 1 문자 이상이고 모든 문자가 영숫자의 경우는 true, 그렇지 않은 경우는 false  ||
  ||<bgcolor="yellow">{{{isalpha()}}}  ||문자열이 1 문자 이상이고 모든 문자가 영문자이면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{isdigit()}}}  ||문자열에 숫자 만 들어 있으면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{islower()}}}  ||문자열에 적어도 하나의 대소 문자가 있고 대소 문자가 모두 소문자이면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{isnumeric()}}}  ||유니 코드 문자열에 숫자 문자 만 포함되어 있으면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{isspace()}}}  ||문자열에 공백 문자 만 포함되어 있으면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{istitle()}}}  ||문자열이 적절히 "titlecased"이면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{isupper()}}}  ||문자열에 적어도 하나의 대소 문자가 있고 대소 문자가 모두 대문자이면 true를 반환하고 그렇지 않으면 false  ||
  ||<bgcolor="yellow">{{{join(seq)}}}  ||문자열 seq에있는 요소의 문자열 표현을 구분 기호 문자열과 병합(연결)  ||
  ||<bgcolor="yellow">{{{len(string)}}}  ||문자열의 길이를 반환  ||
  ||<bgcolor="yellow">{{{ljust(width[, fillchar])}}}  ||총 너비 열에 왼쪽 정렬 된 원래 문자열을 사용하여 공백으로 채워진 문자열을 반환  ||
  ||<bgcolor="yellow">{{{lower()}}}  ||문자열의 모든 대문자를 소문자로 변환  ||
  ||<bgcolor="yellow">{{{lstrip()}}}  ||문자열의 앞에있는 공백을 모두 제거  ||
  ||<bgcolor="yellow">{{{maketrans()}}}  ||translate 함수에서 사용할 변환 테이블을 반환  ||
  ||<bgcolor="yellow">{{{max(str)}}}  ||문자열 str에서 최대 알파벳 문자를 반환  ||
  ||<bgcolor="yellow">{{{min(str)}}}  ||문자열 str에서 최소 알파벳 문자를 반환  ||
  ||<bgcolor="yellow">{{{replace(old, new [, max])}}}  ||문자열에서 old의 모든 항목을 새 항목 또는 최대 항목으로 교체  ||
  ||<bgcolor="yellow">{{{rfind(str, beg=0,end=len(string))}}}  ||{{{find()}}}와 동일하지만 문자열에서 뒤로 검색  ||
  ||<bgcolor="yellow">{{{rindex( str, beg=0, end=len(string))}}}  ||{{{index()}}}와 같지만 문자열에서 뒤로 검색  ||
  ||<bgcolor="yellow">{{{rjust(width,[, fillchar])}}}  ||총 너비 열로 오른쪽 정렬 된 원래 문자열로 공백으로 채워진 문자열을 반환  ||
  ||<bgcolor="yellow">{{{rstrip()}}}  ||문자열의 뒤에있는 공백을 모두 제거  ||
  ||<bgcolor="yellow">{{{split(str="", num=string.count(str))}}}  ||구분 기호 str (제공되지 않은 경우 공백)에 따라 문자열을 분할하고 하위 문자열 목록을 반환 (주어진 경우 최대 num 하위 문자열로 분할)  ||
  ||<bgcolor="yellow">{{{splitlines( num=string.count('\n'))}}}  ||문자열을 모두 (또는 num) 줄바꿈 문자기준으로 분할하고 줄바꿈 문자는 제거 된 각 행의 목록을 반환  ||
  ||<bgcolor="yellow">{{{startswith(str, beg=0,end=len(string))}}}  ||문자열의 문자열 또는 부분 문자열(시작 색인 beg 및 종료 색인 끝이 주어진 경우)이 부분 문자열 str로 시작하는지 확인하여 있으면 true를 반환하고 그렇지 않으면 false를 반환  ||
  ||<bgcolor="yellow">{{{strip([chars])}}}  ||문자열에서 앞/뒤 공백을 제거 (문자열에 대해 {{{lstrip()}}} 및 {{{rstrip()}}}을 수행) ||
  ||<bgcolor="yellow">{{{swapcase()}}}  ||문자열의 모든 대/소문자를 반전  ||
  ||<bgcolor="yellow">{{{title()}}}  ||문자열의 "제목"버전을 반환 (즉, 모든 단어는 대문자로 시작하고 나머지는 소문자)  ||
  ||<bgcolor="yellow">{{{translate(table, deletechars="")}}}  ||문자열을 변환 테이블 str (256 문자)에 따라 변환하고 deletechars의 문자를 제거합니다.  ||
  ||<bgcolor="yellow">{{{upper()}}}  ||문자열의 소문자를 대문자로 변환  ||
  ||<bgcolor="yellow">{{{zfill(width)}}}  ||총 너비 문자에 0으로 왼쪽 패딩 된 원래 문자열을 반환  ||
  ||<bgcolor="yellow">{{{isdecimal()}}}  ||유니 코드 문자열에 숫자 문자 만 들어 있으면 true를 반환하고 그렇지 않으면 false를 반환  ||

 문자열의 길이 (len 함수를 통해서 문자열의 길이를 확인, len은 문자열의 문자요소의 개수를 반환)
  {{{#!enscript python
>>> a="Hello world"
>>> len(a)
11
>>>
}}}

 문자열의 인덱싱 (Index번호는 0부터 시작, 문자열 인덱싱에서 문자열의 끝은 nul-terminate 문자를 가르키지 않음, 음수는 문자열의 끝부터 지정하며 -1부터 시작)
  {{{#!enscript python
>>> a="Hello world"
>>> a[3]
'l'
>>> a[0]
'H'
>>> a[10]
'd'
>>> a[11]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> a[-1]
'd'
>>> a[len(a)-1]
'd'
>>> a[-11]
'H'
>>> a[-12]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> a[-0]
'H'
>>>
}}}

 문자열 슬라이싱(Slicing, 콜론문자를 구분자로 하여 시작과 끝의 인덱스를 통해서 범위를 뽑아내는 기능, 끝의 인덱스는 포함하지 않음에 유의 {{{시작 <= i < 끝}}}, 시작이 생략되면 0으로 간주, 끝이 생략되면 문자열의 길이인 {{{len(문자열)}}}로 간주)
  {{{#!enscript python
>>> a="Hello world" # 인덱스 번호는 0 ~ 10, 총 11글자
>>> a[0:len(a)]
'Hello world'
>>> a[0:5] # 인덱스 번호 0 부터 5-1(4) 까지 총 5글자를 뽑아냄
'Hello'
>>> a[5:] # 인덱스 번호 5부터 끝까지(11-1) 총 6글자를 뽑아냄
' world'
>>> a[:5] # 첫 인덱스 0부터 5-1(4) 까지 총 5글자를 뽑아냄
'Hello'
>>> a[5:-1] # 인덱스 번호 5부터 -1-1(-2=10-1=9) 까지 총 5글자를 뽑아냄
' worl'
}}}

 '''문자열 포매팅(Formatting)''' - 숫자는 {{{'%d'}}}, 문자열은 {{{'%s'}}}로 대응합니다. 문자열의 뒤에 {{{'%'}}} 기호 다음에 대응하는 인자를 넣어주며 2개 이상인 경우 괄호로 묶고 콤마({{{','}}})로 구분하여 넣어줍니다. (참고: [^https://www.tutorialspoint.com/python/python_strings.htm String Formatting Operator], C언어의 printf와 거의 유사)
  |String Formatting Operator|<bgcolor="gray">  코드  ||<bgcolor="gray">  설명  ||
  ||<bgcolor="yellow">  {{{%c}}}  ||문자 1개(Character)  ||
  ||<bgcolor="yellow">  {{{%s}}}  ||문자열(String)  ||
  ||<bgcolor="yellow">  {{{%i}}}  ||부호 있는 정수(Integer)  ||
  ||<bgcolor="yellow">  {{{%d}}}  ||부호 있는 정수(Integer)  ||
  ||<bgcolor="yellow">  {{{%u}}}  ||부호 없는 정수(Integer)  ||
  ||<bgcolor="yellow">  {{{%o}}}  ||8진수(Octal)  ||
  ||<bgcolor="yellow">  {{{%x}}}  ||16진수(Hexa-decimal) 소문자  ||
  ||<bgcolor="yellow">  {{{%X}}}  ||16진수(Hexa-decimal) 대문자  ||
  ||<bgcolor="yellow">  {{{%e}}}  ||지수(Exponential) 소문자  ||
  ||<bgcolor="yellow">  {{{%E}}}  ||지수(Exponential) 대문자  ||
  ||<bgcolor="yellow">  {{{%f}}}  ||부동소수점(Floating-point) 수 ||
  ||<bgcolor="yellow">  {{{%g}}}  ||{{{%f}}}와 {{{%e}}}중에서 짧은 표기  ||
  ||<bgcolor="yellow">  {{{%G}}}  ||{{{%f}}}와 {{{%E}}}중에서 짧은 표기  ||
  ||<bgcolor="yellow">  {{{%%}}}  ||Literal 문자 % 자체  ||
  {{{#!enscript python
>>> number=3
>>> string="three"
>>> "I like number is %d"%number # '%d'는 정수를 표시합니다. number는 정수형 이어야 합니다.
'I like number is 3'
>>> "I like number is %s"%string # '%s'는 문자열을 표시합니다. %string은 어떤 형태이든 알아서 문자열형으로 변환하여 표시해줍니다.
'I like number is three'
>>> "I like number is %d(%s)"%(number,string) # 여러개의 포매팅 인자가 사용되는 경우 괄호로 감싸줍니다.
'I like number is 3(three)'
>>> "I like char is %c"%string[0] # '%c'는 문자 1개(character)를 표시합니다.
'I like char is t'
>>> "I like char is %f"%number # '%f'는 부동소수점(floating-point)로 표시합니다.
'I like char is 3.000000'
>>> "I like number is %o(octal)"%127 # '%x'는 8진수(octal)로 표시합니다.
'I like number is 177(octal)'
>>> "I like number is %x(hexa-decimal)"%127 # '%x'는 16진수(hexa-decimal)로 표시합니다.
'I like number is 7f(hexa-decimal)'
>>> "%d%% percent"%100 # '%%' 는 '%' 문자 그 자체를 의미합니다.
'100% percent'
>>> "%10s"%"Hello" # 10자리를 확보하고 오른쪽 정렬합니다.
'     Hello'
>>> "%-10s"%"Hello" # 10자리를 확보하고 왼쪽 정렬합니다.
'Hello     '
>>> "%.4f"%3.1234567678 # 소숫점 이하 4자리까지만 표시
'3.1235'
>>> "%0.4f"%3.1234567678 # 소숫점 이하 4자리까지만 표시
'3.1235'
>>> "%10.4f"%3.1234567678 # 소숫점 이하 4자리까지만 표시하고 전체 10자리를 확보하며 오른쪽 정렬 표시
'    3.1235'
>>>
}}}

 '''고급 문자열 포매팅(Formatting)''' (참고: [^https://docs.python.org/3.4/library/string.html])
  * 기본 '{' 와 '}' 사이에 사용되는 구문 형태
   {{{#!plain
replacement_field ::=  "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name        ::=  arg_name ("." attribute_name | "[" element_index "]")*
arg_name          ::=  [identifier | integer]
attribute_name    ::=  identifier
element_index     ::=  integer | index_string
index_string      ::=  <any source character except "]"> +
conversion        ::=  "r" | "s" | "a"
format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
fill        ::=  <any character>
align       ::=  "<" | ">" | "=" | "^"
                 "<" : 왼쪽 정렬
                 ">" : 오른쪽 정렬
                 "=" : 부호(sign)와 숫자(digits) 사이에 패딩
                 "^" : 가운데 정렬
sign        ::=  "+" | "-" | " "
                 "+" : 양수인 경우 '+', 음수인 경우 '-' 기호 표시
                 "-" : 음수인 경우만 '-' 기호 표시
                 " " : 양수인 경우 공백(' '), 음수인 경우 '-' 기호 표시
width       ::=  integer
precision   ::=  integer
type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
                 "b" : Binary format. Outputs the number in base 2
                 "c" : Character. Converts the integer to the corresponding unicode character before printing.
                 "d" : Decimal Integer. Outputs the number in base 10.
                 "o" : Octal format. Outputs the number in base 8.
                 "x" : Hex format. Outputs the number in base 16, using lower- case letters for the digits above 9.
                 "X" : Hex format. Outputs the number in base 16, using upper- case letters for the digits above 9.
                 "n" : Number. This is the same as 'd', except that it uses the current locale setting to insert the appropriate number separator characters.
                 None : The same as 'd'.
                 => Floating-point 인 경우
                 "e" : Exponent notation. Prints the number in scientific notation using the letter ‘e’ to indicate the exponent. The default precision is 6.
                 "E" : Exponent notation. Same as 'e' except it uses an upper case ‘E’ as the separator character.
                 "f" : Fixed point. Displays the number as a fixed-point number. The default precision is 6.
                 "F" : Fixed point. Same as 'f', but converts nan to NAN and inf to INF.
                 "g" : General format. For a given precision p >= 1, this rounds the number to p significant digits and then formats the result in either fixed-point format or in scientific notation, depending on its magnitude.
                 "G" : General format. Same as 'g' except switches to 'E' if the number gets too large. The representations of infinity and NaN are uppercased, too.
                 "n" : Number. This is the same as 'g', except that it uses the current locale setting to insert the appropriate number separator characters.
                 "%" : Percentage. Multiplies the number by 100 and displays in fixed ('f') format, followed by a percent sign.
                 None : Similar to 'g', except that fixed-point notation, when used, has at least one digit past the decimal point.
}}}
  {{{#!enscript python
>>> number=3
>>> string="three"
>>> "I like number is {0}".format(number)
'I like number is 3'
>>> "I like number is {0}".format(string)
'I like number is three'
>>> "I like number is {0}({1})".format(number,string) # {0}은 .format의 첫번째 인자, {1}은 .format의 두번째 인자에 대응
'I like number is 3(three)'
>>> "{vn} is {vd}".format(vd="Hello",vn="World") # label을 지정하여 인자를 대응
'World is Hello'
>>> "{vn} is {0}".format("Hello",vn="World") # 인덱스와 label을 함께 혼용하여 대응
'World is Hello'
>>> "I like char is {0}".format(string[0])
'I like char is t'
>>> "I like number is {0:f}".format(number)
'I like number is 3.000000'
>>> "I like number is {0:o}(octal)".format(127)
'I like number is 177(octal)'
>>> "I like number is {0:x}(hexa-decimal)".format(127)
'I like number is 7f(hexa-decimal)'
>>> "{0}%".format(100)
'100%'
>>> "{0:>10}".format("Hello")
'     Hello'
>>> "{0:<10}".format("Hello")
'Hello     '
>>> "{0:^10}".format("Hello") # 10자리를 확보하고 가운데 정렬 (공백으로 채움)
'  Hello   '
>>> "{0:=^10}".format("Hello") # 10자리를 확보하고 가운데 정렬 ('='로 채움)
'==Hello==='
>>> "{0:!^10}".format("Hello") # 10자리를 확보하고 가운데 정렬 ('!'로 채움)
'!!Hello!!!'
>>> "{0:.4f}".format(3.1234567678)
'3.1235'
>>> "{0:0.4f}".format(3.1234567678)
'3.1235'
>>> "{0:10.4f}".format(3.1234567678)
'    3.1235'
>>> "{{0}} is {0}".format(1234) # '{', '}' 기호 자체를 표현하려면 연속으로 2회 사용
'{0} is 1234'
>>> i=0
>>> while i < 10:
...     i = i+1
...     print("{0:^10}".format("=+"*i))
...
    =+
   =+=+
  =+=+=+
 =+=+=+=+
=+=+=+=+=+
=+=+=+=+=+=+
=+=+=+=+=+=+=+
=+=+=+=+=+=+=+=+
=+=+=+=+=+=+=+=+=+
=+=+=+=+=+=+=+=+=+=+
>>>
}}}

 문자열에서 문자 갯수 세기 (count)
  {{{#!enscript python
>>> a="Hello world"
>>> a.count('l')
3
>>> a.count('k')
0
>>>
}}}

 문자의 위치 확인 (find, index)
  {{{#!enscript python
>>> a="Hello world"
>>> a.find('l')
2
>>> a.find('k')
-1
>>> a.index('l')
2
>>> a.index('k') # index 함수는 존재하지 않는 문자의 경우 오류가 발생하게 됨
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>
}}}

 문자열의 삽입 (join)
  {{{#!enscript python
>>> a=", "
>>> a.join("This")
'T, h, i, s'
>>>
}}}

 문자열 대소문자 변환 (upper, lower)
  {{{#!enscript python
>>> a="hi"
>>> a.upper()
'HI'
>>> a="HI"
>>> a.lower()
'hi'
>>>
}}}

 문자열내의 공백 지우기 (lstrip, rstrip, strip)
  {{{#!enscript python
>>> a="    hi    "
>>> a.lstrip()
'hi    '
>>> a.rstrip()
'    hi'
>>> a.strip()
'hi'
>>>
}}}

 문자열의 치환 (replace)
  {{{#!enscript python
>>> a="Life is too short"
>>> a.replace("Life", "Your leg")
'Your leg is too short'
>>>
}}}

 문자열 나누기 (split)
  {{{#!enscript python
>>> a="Life is too short"
>>> a.split() # 함수 인자가 비어 있으면 white space (공백, 탭, 줄 바꿈) 를 기준으로 나눕니다.
['Life', 'is', 'too', 'short']
>>> a="alpha:beta:tree:four"
>>> a.split(":")
['alpha', 'beta', 'tree', 'four']
>>>
}}}
==== 리스트(List, 목록) 자료형 ====
 어떤 요소값의 모음을 표현하기 위한 자료형을 리스트(List) 자료형이라고 합니다. 요소값은 숫자형, 문자열형, 리스트형등 어떠한 자료형이든 모두 혼용하여 가질 수 있습니다.
  {{{#!plain
>>> <리스트명>=[<요소1>,<요소2>,<요소3>, ...] # '[', ']'으로 감싸주고 콤마(',') 문자로 구분하는 요소는 어떠한 자료형이든 가능

또는 list() 함수를 사용하여

>>> <리스트명>=list([<요소1>,<요소2>,<요소3>, ...])

또는 비어있는 리스트를 생성하기 위해서

>>> <리스트명>=[]
>>> <리스트명>=list()
}}}

 리스트(List)의 형태 예시
  {{{#!enscript python
>>> a=[]
>>> b=[1,2,3]
>>> c=['a', 'b', 'c']
>>> d=["Life", "is", "too", "short"]
>>> e=[1,2,"Life","is"]
>>> f=[1,2,["Life","is"]]
>>> g=list()
>>> h=list([1,2,3])
}}}

 '''리스트(List, 목록)의 Function & Methods''' (참고: [^https://www.tutorialspoint.com/python/python_lists.htm Built-in List Functions & Methods])
  |Built-in List Functions & Methods|<bgcolor="gray">  Function & Method  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{cmp(list1, list2)}}}  ||두 목록의 요소를 비교  ||
  ||<bgcolor="yellow">{{{len(list)}}}  ||목록(List)의 전체 길이  ||
  ||<bgcolor="yellow">{{{max(list)}}}  ||목록(List)에서 최대값 항목을 반환  ||
  ||<bgcolor="yellow">{{{min(list)}}}  ||목록(List)에서 최소값 항목을 반환  ||
  ||<bgcolor="yellow">{{{list(seq)}}}  ||목록(Tuple)을 목록(List)으로 변환  ||
  ||<bgcolor="yellow">{{{list.append(obj)}}}  ||목록(List)에 obj 객체를 추가  ||
  ||<bgcolor="yellow">{{{list.count(obj)}}}  ||목록(List)에 있는 obj의 개수를 반환  ||
  ||<bgcolor="yellow">{{{list.extend(seq)}}}  ||목록(List)에 seq 목록(List)을 추가  ||
  ||<bgcolor="yellow">{{{list.index(obj)}}}  ||리스트(List) 내에 있는 obj의 가장 작은 인덱스를 반환  ||
  ||<bgcolor="yellow">{{{list.insert(index, obj)}}}  ||객체 obj를 목록(List) index에 삽입  ||
  ||<bgcolor="yellow">{{{list.pop(obj=list[-1])}}}  ||목록(List)에서 마지막 객체 또는 obj를 제거하여 반환  ||
  ||<bgcolor="yellow">{{{list.remove(obj)}}}  ||목록(List)에서 obj를 삭제  ||
  ||<bgcolor="yellow">{{{list.reverse()}}}  ||목록(List)의 순서를 역순으로 재배치  ||
  ||<bgcolor="yellow">{{{list.sort([func])}}}  ||목록(List)의 객체를 정렬 (func이 주어지는 경우 정렬에 사용되는 비교루틴을 대체)  ||

 리스트(List) 인덱싱(Indexing)과 슬라이싱(Slicing)
  {{{#!enscript python
>>> a=[1,2,3]
>>> len(a) # a의 요소 갯수
3
>>> a[0] # 첫 번째 요소값
1
>>> a[-1] # 마지막 요소값
3
>>> a[len(a)-1] # 마지막 요소값
3
>>> a[1:3] # 인덱스 1부터 3-1(2) 까지 요소값
[2, 3]
>>> a[1:] # 인덱스 1부터 마지막 요소값
[2, 3]
>>> a[:2] # 인덱스 0부터 2-1(1)까지 요소값
[1, 2]
>>> a[-0] # a[0]과 같음
1
>>> a=[1,2,3,['a','b','c']]
>>> a[-1][1] # a의 1차 요소중 마지막 요소에서 인덱스 1인 요소
'b'
>>>
}}}

 리스트(List)의 덧셈
  {{{#!enscript python
>>> a=[1,2,3]
>>> b=['a', 'b', 'c']
>>> a+b
[1, 2, 3, 'a', 'b', 'c']
>>> b+a
['a', 'b', 'c', 1, 2, 3]
>>>
}}}

 리스트(List)의 곱셈
  {{{#!enscript python
>>> a=[1,2,'a']
>>> a*3
[1, 2, 'a', 1, 2, 'a', 1, 2, 'a']
>>>
}}}

 리스트(List)의 값 수정하기
  {{{#!enscript python
>>> a=[1,2,3]
>>> a[2]=4
>>> a
[1, 2, 4]
>>> a[1:2] # 범위 수정 (아래 지정 인덱스 수정과 전혀 다른 결과임에 유의)
[2]
>>> a[1:2]=['a', 'b', 'c']
>>> a
[1, 'a', 'b', 'c', 4]
>>> a[1]=['d', 'e', 'f'] # 지정 인덱스 수정 (위 범위 수정과 전혀 다른 결과임에 유의)
>>> a
[1, ['d', 'e', 'f'], 'b', 'c', 4]
>>>
}}}

 리스트(List)의 부분 삭제 또는 전체 삭제
  {{{#!enscript python
>>> a=[1,2,3,4,5,6,7,8,9,0]
>>> a[1:3]=[]
>>> a
[1, 4, 5, 6, 7, 8, 9, 0]
>>> del a[1]
>>> a
[1, 5, 6, 7, 8, 9, 0]
>>> a=[]
>>> a
[]
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>>
}}}

 리스트(List)에 요소 추가 (append)
  {{{#!enscript python
>>> a=[1,2,3]
>>> a.append("Hello")
>>> a
[1, 2, 3, 'Hello']
>>> a.append([4,5])
>>> a
[1, 2, 3, 'Hello', [4, 5]]
>>>
}}}

 리스트(List) 정렬 (sort)
  {{{#!enscript python
>>> a=[4,1,2,3]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a=['Zebra', 'Apple', 'Beta', 'Three']
>>> a.sort()
>>> a
['Apple', 'Beta', 'Three', 'Zebra']
>>>
}}}

 리스트(List) 순서 바꾸기 (reverse) - 정렬이 아니고 단순히 요소의 순서만 거꾸로 뒤집는 것임에 유의
  {{{#!enscript python
>>> a=['Zebra', 'Apple', 'Beta', 'Three']
>>> a.reverse()
>>> a
['Three', 'Beta', 'Apple', 'Zebra']
>>>
}}}

 리스트(List)에서의 위치 반환 (index)
  {{{#!enscript python
>>> a=['Zebra', 'Apple', 'Beta', 'Three']
>>> a.index("Beta")
2
>>> a=[1,2,3]
>>> a.index(3)
2
>>> a.index(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 4 is not in list
>>>
}}}

 리스트(List)에서 특정 인덱스의 앞에 요소를 삽입 (insert)
  {{{#!enscript python
>>> a=[1,2,3]
>>> a.insert(0, 4) # 인덱스 0인 a[0] 앞에 값 4를 삽입
>>> a
[4, 1, 2, 3]
>>>
}}}

 리스트(List)에서 지정한 요소값 첫 번째를 삭제 (remove)
  {{{#!enscript python
>>> a=[1,2,3,1,2,3,1,2,3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 3, 1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 1, 2]
>>> a.remove(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
}}}

 리스트(List)에서 지정한 인덱스 요소 빼내기 (pop)
  {{{#!enscript python
>>> a=[1,2,3]
>>> a.pop() # 마지막 요소를 빼냄
3
>>> a
[1, 2]
>>> a=[1,2,3]
>>> a.pop(1) # 인덱스 1인 a[1]=2를 빼냄
2
>>> a
[1, 3]
>>>
}}}

 리스트(List)에서 지정한 요소값 개수 세기 (count)
  {{{#!enscript python
>>> a=[1,2,3,1]
>>> a.count(1)
2
>>>
}}}

 리스트(List)에 지정한 리스트를 더하기 (extend)
  {{{#!enscript python
>>> a=[1,2,3]
>>> a.extend([4,5])
>>> a
[1, 2, 3, 4, 5]
>>> a=[1,2,3]
>>> a+=[4,5]
>>> a
[1, 2, 3, 4, 5]
>>>
}}}
==== 튜플(Tuple, 목록) 자료형 ====
 리스트(List)와 유사하지만 '{{{[}}}', '{{{]}}}' 가 아닌 '{{{(}}}', '{{{)}}}'으로 둘러싸여 사용하며 튜플(Tuple)은 그 값을 바꿀 수 없습니다.

 튜플(Tuple)의 형태 예시
  {{{#!enscript python
>>> a=()
>>> b=(1,) # 1개의 요소만 가질 때는 요소 뒤에 콤마(',')를 반드시 붙여야 합니다. 그렇지 않으면 정수 1로 인지합니다.
>>> c=(1, 2, 3)
>>> d=1,2,3 # 튜플(Tuple)은 괄호를 생략해도 됩니다.
>>> e=1, # 1개의 요소만 가질 때 괄호를 생략하는 경우도 콤마(',')를 붙여야 합니다.
>>> f=(1,2,"Life","is")
>>> g=(1,2,("Life",))
>>> h=tuple()
>>> i=tuple((1,2,3))
}}}

 튜플(Tuple) 자료형은 리스트(List)와 거의 동일하며 연산방법이나 인덱싱, 슬라이싱등이 모두 동일한 방법으로 사용될 수 있으며 단지 그 값을 수정하지 못한다는 점입니다.

 '''튜플(Tuple)의 Function''' (참고: [^https://www.tutorialspoint.com/python/python_tuples.htm Built-in Tuple Functions])
  |Built-in Tuple Functions|<bgcolor="gray">  Function & Method  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{cmp(tuple1, tuple2)}}}  ||두 목록(Tuple)의 요소를 비교  ||
  ||<bgcolor="yellow">{{{len(tuple)}}}  ||목록(Tuple)의 전체 길이  ||
  ||<bgcolor="yellow">{{{max(tuple)}}}  ||목록(Tuple)에서 최대값 항목을 반환  ||
  ||<bgcolor="yellow">{{{min(tuple)}}}  ||목록(Tuple)에서 최소값 항목을 반환  ||
  ||<bgcolor="yellow">{{{tuple(seq)}}}  ||목록(List)을 목록(Tuple)으로 변환  ||
==== 사전(Dictionary) 자료형 ====
 사전(딕셔너리)형 자료형은 리스트(List)나 튜플(Tuple)처럼 순차적인(Sequential) 접근법에 의해서 요소값을 구하지 않고 Key를 통해서 Value를 얻는게 특징입니다.
  {{{#!plain
{<Key1>:<Value1>,<Key2>:<Value2>,<Key3>:<Value3>, ...} # Key는 변하지 않는 값이며 Value는 변하지 않는 값과 변하는 값 모두 사용 가능
}}}

 사전(Dictionary)의 형태 예시
  {{{#!enscript python
>>> a={1:"Hi"}
>>> a={'a':[1,2,3]}
}}}

 '''사전(Dictionary)의 Function & Methods''' (참고: [^https://www.tutorialspoint.com/python/python_dictionary.htm Built-in Dictionary Functions & Methods])
  |Built-in Dictionary Functions & Methods|<bgcolor="gray">  Function & Method  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{cmp(dict1, dict2)}}}  ||두 사전(Dictionary)의 요소를 비교  ||
  ||<bgcolor="yellow">{{{len(dict)}}}  ||사전(Dictionary)의 전체 길이 (요소의 개수)  ||
  ||<bgcolor="yellow">{{{str(dict)}}}  ||사전(Dictionary)의 인쇄 가능한 문자열 표현을 생성  ||
  ||<bgcolor="yellow">{{{type(variable)}}}  ||전달 된 변수의 유형을 반환 (전달 된 변수가 사전이면 사전 유형을 반환)  ||
  ||<bgcolor="yellow">{{{dict.clear()}}}  ||사전(Dictionary) 사전의 모든 요소를 제거  ||
  ||<bgcolor="yellow">{{{dict.copy()}}}  ||사전(Dictionary) dict의 얕은(shallow) 복사본을 반환  ||
  ||<bgcolor="yellow">{{{dict.fromkeys()}}}  ||seq 및 값이 value로 설정된 Key를 사용하여 새 사전(Dictionary)을 생성  ||
  ||<bgcolor="yellow">{{{dict.get(key, default=None)}}}  ||사전(Dictionary)에서 Key를 찾아 그 값을 반환 (default가 주어지는 경우 Key가 없을 때 default를 반환)  ||
  ||<bgcolor="yellow">{{{dict.has_key(key)}}}  ||사전 dict에서 key가 있으면 true를 반환하고 그렇지 않으면 false를 반환  ||
  ||<bgcolor="yellow">{{{dict.items()}}}  ||dict (Key, Value) 튜플(Tuple) 쌍의 목록(List)을 반환  ||
  ||<bgcolor="yellow">{{{dict.keys()}}}  ||dict 사전(Dictionary)의 Key 목록(List)을 반환  ||
  ||<bgcolor="yellow">{{{dict.setdefault(key, default=None)}}}  ||{{{get()}}}과 유사하지만 key가 dict에없는 경우 {{{dict[key] = default}}}로 설정  ||
  ||<bgcolor="yellow">{{{dict.update(dict2)}}}  ||사전(Dictionary) dict2의 Key과 Value 쌍을 dict에 추가  ||
  ||<bgcolor="yellow">{{{dict.values()}}}  ||dict 사전(Dictionary)의 Value 목록(List)을 반환  ||

 사전(Dictionary)의 쌍 추가 및 삭제
  {{{#!enscript python
>>> a={1:'a'}
>>> a[2]='b';
>>> a
{1: 'a', 2: 'b'}
>>> a["name"]="jhcho"
>>> a
{1: 'a', 2: 'b', 'name': 'jhcho'}
>>> a[3]=[1,2,3]
>>> a
{1: 'a', 2: 'b', 3: [1, 2, 3], 'name': 'jhcho'}
>>> del a[2]
>>> a
{1: 'a', 3: [1, 2, 3], 'name': 'jhcho'}
>>> a={2:'a', "2":'b'} # Key가 2인 것과 "2"인 것은 다름에 유의!
>>> a
{2: 'a', '2': 'b'}
>>>
}}}

 사전(Dictionary)의 요소값 얻는 방법은 Key를 사용해서 Value를 얻는 방법 뿐!
  {{{#!enscript python
>>> a={1: 'a', 3: [1, 2, 3], 'name': 'jhcho'}
>>> a["name"]
'jhcho'
>>> a[1]
'a'
>>> a[3]
[1, 2, 3]
>>> a[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Key
}}}

 사전(Dictionary)에서 Key가 중복되는 것은 유의해야 함. 중복된 Key 사용시 어떤게 무시될 지 정의되지 않음
  {{{#!enscript python
>>> a={1:'a', 1:'b'}
>>> a
{1: 'b'}
>>>
}}}

 사전(Dictionary)의 Key로는 리스트(List)는 사용할 수 없으나 튜플(Tuple)은 사용가능
  {{{#!enscript python
>>> a={[1,2]:"Hi"}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> a={(1,2):"Hi"}
>>> a
{(1, 2): 'Hi'}
>>> a[(1,2)]
'Hi'
>>>
}}}

 사전(Dictionary)의 Key 리스트 만들기 (keys)
  {{{#!enscript python
>>> a={"name":"jhcho","phone":"010-0000-0000","age":"10","birth":"20000101"}
>>> a
{'phone': '010-0000-0000', 'age': '10', 'name': 'jhcho', 'birth': '20000101'}
>>> a.keys() # python 2.7까지는 리스트를 그대로 만들어 줍니다.
['phone', 'age', 'name', 'birth']
>>> a.keys() # python3 부터는 메모리 낭비를 줄이고자 dict_keys 객체를 반환합니다.
dict_keys(['age', 'name', 'phone', 'birth'])
>>> list(a.keys()) # python 버젼에 관계없이 리스트형으로 만들려면 다음과 같이 list 함수를 통해서 호환할 수 있습니다.
['age', 'name', 'phone', 'birth']
>>> for k in a.keys():
...     print(k)
...
phone
age
name
birth
>>>
}}}

 사전(Dictionary)의 Value 리스트 만들기 (values)
  {{{#!enscript python
>>> a={"name":"jhcho","phone":"010-0000-0000","age":"10","birth":"20000101"}
>>> a
{'phone': '010-0000-0000', 'age': '10', 'name': 'jhcho', 'birth': '20000101'}
>>> a.values() # python 2.7까지는 리스트를 그대로 만들어 줍니다.
['010-0000-0000', '10', 'jhcho', '20000101']
>>> a.values() # python3 부터는 메모리 낭비를 줄이고자 dict_keys 객체를 반환합니다.
dict_values(['10', 'jhcho', '010-0000-0000', '20000101'])
>>> list(a.values()) # python 버젼에 관계없이 리스트형으로 만들려면 다음과 같이 list 함수를 통해서 호환할 수 있습니다.
['10', 'jhcho', '010-0000-0000', '20000101']
>>> for v in a.values():
...     print(v)
...
10
jhcho
010-0000-0000
20000101
>>>
}}}

 사전(Dictionary)의 Key와 Value 모두 지우기 (clear)
  {{{#!enscript python
>>> a.clear()
>>> a
{}
>>>
}}}

 사전(Dictionary)의 Key로 Value 얻기 (get)
  {{{#!enscript python
>>> a={"name":"jhcho","phone":"010-0000-0000","age":"10","birth":"20000101"}
>>> a.get("name")
'jhcho'
>>> a["name"]
'jhcho'
>>> a.get("phone")
'010-0000-0000'
>>> a["phone"]
'010-0000-0000'
>>> a.get("age")
'10'
>>> a["age"]
'10'
>>> a.get("birth")
'20000101'
>>> a["birth"]
'20000101'
>>> a.get("nokey") # 없는 Key를 얻으려 하면 None을 반환
>>> a["nokey"] # 없는 Key를 얻으려 하면 오류
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'nokey'
>>> a.get("nokey", "Unknown key value") # .get의 두번째 인자로 Key를 찾지 못한 경우 대체될 기본 요소값을 처리할 수도 있음. (매우 유용한 기능)
'Unknown key value'
>>> "name" in a # Key가 존재하는지 검사하여 있는 경우 True 반환
True
>>> "nokey" in a # Key가 존재하는지 검사하여 있는 없는 경우 False 반환
False
>>> "name" in a.keys()
True
>>> "nokey" in a.keys()
False
>>> "jhcho" in a.values()
True
>>> "jhcho2" in a.values()
False
>>>
}}}
==== 집합(Set) 자료형 ====
 순서에 상관없이 중복된 값을 제거하는 특징을 갖는 집합(Set) 자료형은 교집합, 차집합, 합집합등을 구하기 위해서 유용한 자료형입니다.
  {{{#!plain
<집합자료명>=set(<자료형>)
}}}

 집합(Set)의 형태 예시
  {{{#!enscript python
>>> s1=set([1,2,3,4,1,2,3,4])
>>> s1
set([1, 2, 3, 4])
>>> s2=set("Hello world")
>>> s2
set([' ', 'e', 'd', 'H', 'l', 'o', 'r', 'w'])
>>>
}}}

 집합(Set)의 인덱싱 접근 (집합 자료형은 직접적으로 인덱싱을 할 수 없으며 list함수를 통해서 리스트로 변환 후 접근해야 합니다.)
  {{{#!enscript python
>>> s2=set("Hello world")
>>> s2[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
>>> list(s2)[1]
'e'
>>>
}}}

 교집합 구하기({{{&}}})
  {{{#!enscript python
>>> s1=set([1,2,3,4,5,6])
>>> s2=set([4,5,6,7,8,9])
>>> s1&s2
set([4, 5, 6])
>>> s1.intersection(s2)
set([4, 5, 6])
>>>
}}}

 합집합 구하기(|)
  {{{#!enscript python
>>> s1=set([1,2,3,4,5,6])
>>> s2=set([4,5,6,7,8,9])
>>> s1|s2
set([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> s1.union(s2)
set([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>
}}}

 차집합 구하기({{{-}}})
  {{{#!enscript python
>>> s1=set([1,2,3,4,5,6])
>>> s2=set([4,5,6,7,8,9])
>>> s1-s2
set([1, 2, 3])
>>> s2-s1
set([8, 9, 7])
>>> s1.difference(s2)
set([1, 2, 3])
>>> s2.difference(s1)
set([8, 9, 7])
>>>
}}}

 집합(Set)에서 추가/삭제 (add, update, remove)
  {{{#!enscript python
>>> s1=set([1,2,3])
>>> s1.add(4)
>>> s1
set([1, 2, 3, 4])
>>> s1.update([5,6,7])
>>> s1
set([1, 2, 3, 4, 5, 6, 7])
>>> s1.remove(2)
>>> s1
set([1, 3, 4, 5, 6, 7])
>>>
}}}
==== 자료형의 참과 거짓(Boolean) ====
 부울(bool) 자료형은 참(True)과 거짓(False)을 나타내는 자료형입니다.
  * 부울(bool) 자료형은 다음의 2가지 값 중 하나만을 가실 수 있습니다.
   * True : 참
   * False : 거짓
  * 주의: True나 False는 파이썬(Python)의 예약어로 true, false처럼 사용하지 말고 첫 문자를 대문자로 사용하도록 합니다.

 자료형에는 그 값에 따라서 참과 거짓을 구분하는 묵시적 기준이 있습니다. 이는 조건문/제어문에서 판단하는 기준으로써 매우 중요한 특성입니다.
  |자료형의 참(True)과 거짓(False) 기준|<bgcolor="gray">  자료형  ||<bgcolor="gray">  값  ||<bgcolor="gray">  참 또는 거짓  ||
  ||<bgcolor="yellow">문자열(String)  ||"python"  ||  참(True)  ||
  ||<bgcolor="yellow">문자열(String)  ||""  ||  거짓(False)  ||
  ||<bgcolor="yellow">리스트(List)  ||{{{[1,2,3]}}}  ||  참(True)  ||
  ||<bgcolor="yellow">리스트(List)  ||{{{[]}}}  ||  거짓(False)  ||
  ||<bgcolor="yellow">튜플(Tuple)  ||()  ||  거짓(False)  ||
  ||<bgcolor="yellow">사전(Dictionary)  ||{}  ||  거짓(False)  ||
  ||<bgcolor="yellow">숫자(Number)  ||0이 아닌 숫자  ||  참(True)  ||
  ||<bgcolor="yellow">숫자(Number)  ||0  ||  거짓(False)  ||
  ||<bgcolor="yellow">NoneType  ||None  ||  거짓(False)  ||

 부울(bool) 연산
  {{{#!enscript python
>>> bool([1,2,3])
True
>>> bool([])
False
>>> bool(0)
False
>>> bool(3)
True
>>> bool('')
False
>>> bool("python")
True
>>>
}}}

 결국 문자열, 리스트, 튜플, 사전의 경우 비어있으면 거짓(False)이고 비어있지 않으면 참(True)가 됩니다. 숫자는 0인 경우 거짓(False), 0이 아닌 경우 참(True)가 됩니다. 아무것도 아닌 미정의 자료는 None으로 거짓(False)이 됩니다.
==== 자료형간의 변환(Casting, Data Type Conversion) ====
 정수(Integer)와 정수(Integer)간의 연산 결과는 정수(Integer)입니다. 단, 그 결과가 실수(Floating-point)인 경우(예를 들면 정수로 나누어 떨어지지 않는 나눗셈)는 결과가 실수(Floating-point)가 될 수 있습니다.

 실수(Floating-point)와 실수(Floating-point)간 연산 결과는 실수(Floating-point)입니다.

 문자열(String)과 문자열(String)간의 연산 결과는 문자열(String)입니다.

 정수(Integer)와 실수(Floating-point)간 연산 결과는 실수(Floating-point)입니다.

 정수(Integer) 또는 실수(Floating-point)와 문자열(String)간의 연산은 오류입니다.
  {{{#!enscript python
>>> a=1
>>> b=2.0
>>> c="3"
>>> a+b+c
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'float' and 'str'
>>> a+b+int(c)
6.0
>>> str(a+b)+c
'3.03'
>>> str(a)+str(b)+c
'12.03'
>>>
}}}

 각 자료형의 혼합형태에서 도출할 결과에 대한 오묘함을 회피하고 의도한 자료형으로 도출하기 위해서는 적절한 변환을 해야 합니다. 입력변수가 의도한 자료형이 아닐 수 있다면 명시적으로 변환을 하는게 좋습니다.
  |자료형의 변환함수|<bgcolor="gray">  함수(Function)  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{int(<값>[,<진수>])}}}  ||정수(Integer)로 변환  ||
  ||<bgcolor="yellow">{{{long(<값>[,<진수>])}}}  ||큰 정수(Long Integer)로 변환  ||
  ||<bgcolor="yellow">{{{float(<값>)}}}  ||실수(Floating-point)로 변환  ||
  ||<bgcolor="yellow">{{{complex(<real>[,<imag>])}}}  ||복소수(Complex-number) 객체 생성  ||
  ||<bgcolor="yellow">{{{str(<값>)}}}  ||문자열(String)로 변환  ||
  ||<bgcolor="yellow">{{{repr(<객체>)}}}  ||객체를 표현식 문자열로 변환  ||
  ||<bgcolor="yellow">{{{eval(<string>)}}}  ||문자열을 평가하여 객체로 반환  ||
  ||<bgcolor="yellow">{{{tuple(<집합형 값>)}}}  ||튜플(Tuple)로 변환  ||
  ||<bgcolor="yellow">{{{list(<집합형 값>)}}}  ||리스트(List)로 변환  ||
  ||<bgcolor="yellow">{{{set(<집합형 값>)}}}  ||집합(Set)으로 변환  ||
  ||<bgcolor="yellow">{{{dict(<Key와 Value의 쌍으로 이루어진 튜플>)}}}  ||사전(Dictionary)객체 생성  ||
  ||<bgcolor="yellow">{{{frozenset(<집합형 값>)}}}  ||frozen 집합(Set)으로 변환  ||
  ||<bgcolor="yellow">{{{chr(<값>)}}}  ||정수(Integer)를 문자(Character)로 변환  ||
  ||<bgcolor="yellow">{{{unichr(<값>)}}}  ||정수(Integer)를 유니코드(Unicode) 문자로 변환  ||
  ||<bgcolor="yellow">{{{ord(<값>)}}}  ||하나의 문자(Character)를 정수(Integer)로 변환  ||
  ||<bgcolor="yellow">{{{hex(<값>)}}}  ||정수(Integer)를 16진수 문자열로 변환  ||
  ||<bgcolor="yellow">{{{oct(<값>)}}}  ||정수(Integer)를 8진수 문자열로 변환  ||
  ||<bgcolor="yellow">{{{bool(<값>)}}}  ||값을 평가하여 참/거짓으로 반환  ||
==== 자료형의 값을 저장하는 공간, 변수 ====
 자료형의 종류 확인 (정확히는 type 함수는 그 객체의 종류를 알려줍니다. 즉, 숫자 1도 객체로 다룹니다.)
  {{{#!enscript python
>>> a=1
>>> type(a)
<type 'int'>
>>> a="H"
>>> type(a)
<type 'str'>
>>> a='h'
>>> type(a)
<type 'str'>
>>> a=[]
>>> type(a)
<type 'list'>
>>> a=()
>>> type(a)
<type 'tuple'>
>>> a=(1)
>>> type(a)
<type 'int'>
>>> a=(1,)
>>> type(a)
<type 'tuple'>
>>> a={}
>>> type(a)
<type 'dict'>
>>> a=set([1,2,3])
>>> type(a)
<type 'set'>
>>> a=None
>>> type(a)
<class 'NoneType'>
>>>
}}}

 '''변수''' : 객체를 가르키거나 저장하는 공간. 객체를 가르키는 것을 레퍼런스(Reference)라고 합니다. 변수는 객체를 가르키는 것이라고도 할 수 있으며 모두 값의 참조(Reference)입니다.
  {{{#!plain
<변수명>=<변수에 저장할 값>
}}}

 '''객체''' : 파이썬에서 사용하는 모든 것은 객체라고 할 수 있습니다.

 객체를 가르키는 레퍼런스(Reference) 개수를 확인. 이 값이 0이 될 때 메모리에서 해당 객체는 사라집니다. ('''Garbage collection 조건''')
  {{{#!enscript python
>>> import sys
>>> sys.getrefcount(3)
28
>>> a=3
>>> sys.getrefcount(3)
29
>>> a=3
>>> sys.getrefcount(3)
29
>>> b=3
>>> sys.getrefcount(3)
30
>>> c=3
>>> sys.getrefcount(3)
31
>>> del c
>>> sys.getrefcount(3)
30
>>>
}}}

 변수를 만드는 여러가지 방법
  {{{#!enscript python
>>> a,b=("python","life") # 튜플 대입
>>> a
'python'
>>> b
'life'
>>> (a,b)
('python', 'life')
>>> (a,b)="python","life" # 튜플 대입
>>> a
'python'
>>> b
'life'
>>> (a,b)
('python', 'life')
>>> a,b="python","life" # 튜플 대입 (괄호 생략)
>>> a,b
('python', 'life')
>>> a
'python'
>>> b
'life'
>>> [a,b]=["python","life"] # 리스트 대입
>>> a
'python'
>>> b
'life'
>>> a,b
('python', 'life')
>>> [a,b]
['python', 'life']
>>> a=b="python" # a, b를 동일한 값으로 대입
>>> a
'python'
>>> b
'python'
>>> a=3
>>> b=5
>>> a,b=b,a # a와 b를 swap
>>> a
5
>>> b
3
>>>
}}}

 '''복사(Copy)와 참조(Reference)에 유의'''할 점.
  {{{#!enscript python
>>> a=[1,2,3]
>>> b=a # 복사가 아니고 레퍼런스(Reference,참조)임에 유의
>>> a[1]=4 # a만 바꾸려던 의도였으나 사실상 b는 a를 가르키고 있음에 의도한바인지 체크!
>>> a
[1, 4, 3]
>>> b
[1, 4, 3]
>>> a=[1,2,3]
>>> b=a[:] # 이렇게 전체 범위를 슬라이싱(Slicing)하여 대입하면 참조가 아닌 복사가 일어납니다.
>>> a[1]=4 # a와 b는 전혀 다른 복사된 객체이므로 a만 수정하게 됩니다.
>>> a
[1, 4, 3]
>>> b
[1, 2, 3]
>>> from copy import copy # copy 모듈 사용 선언
>>> a=[1,2,3]
>>> b=copy(a) # copy 모듈을 이용한 객체 복사
>>> a[1]=4
>>> a
[1, 4, 3]
>>> b
[1, 2, 3]
>>> a is b # 복사된 객체라면 False이고 참조된 객체라면 True
False
>>>
}}}
=== 제어문 ===
 제어문에는 조건문인 "'''if'''"와 Loop 제어문인 "'''while'''" 및 "'''for'''" 가 있습니다.

 제어문의 '''제어범위에 포함되려면 그에 해당하는 블록이 명확해야'''되는데 '''보통 들여쓰기로 이를 구분'''합니다. (간결한 블록의 경우는 들여쓰기 없이 제어문 바로 뒤에 작성되기도 합니다.)
  {{{#!plain
<제어문> <조건>:
    <수행할 구문 #1>
    <수행할 구문 #2>
    <수행할 구문 #3>
[<추가 관계 제어문>[ <조건>]:
    <수행할 구문 #1>
    <수행할 구문 #2>
    <수행할 구문 #3>
[<추가 관계 제어문...>]
]

# 또는

<제어문> <조건>: <수행할 간결한 구문 #1> [; <수행할 간결한 구문 #n> [; ...]]
[<추가 관계 제어문>[ <조건>]: <수행할 간결한 구문 #1> [; <수행할 간결한 구문 #n> [; ...]]
[<추가 관계 제어문...>]
]
}}}

 {{{<조건>}}}은 '''어떠한 것이든 참(True)/거짓(False)를 판단할 수 있는 결과이거나 암묵적 판단이 가능한 것이면 어느것이든 조건'''이 될 수 있습니다.
  * 2개 이상의 조건이 하나의 제어문에서 사용되는 경우 and, or 등의 연산자도 사용될 수 있습니다.
   * {{{<조건1> or <조건2>}}} : 조건1과 조건2 중에서 어느것이든 하나만 참(True)이면 이 결과는 참(True)입니다.
   * {{{<조건1> and <조건2>}}} : 조건1과 조건2 모두 참(True)이면 이 결과는 참(True)입니다.
  * 조건의 부정을 조건으로 할 수도 있습니다.
   * {{{not <조건>}}} : 조건이 거짓(False)이면 이 결과는 참(True)입니다.
  * 어떤 집합(List, Tuple, Set, Dictionary, String)에서 어떤 요소가 있는지 유무를 조건으로 할 수도 있습니다.
   * {{{<요소> in <집합>}}} : 집합내에 요소가 있는 경우 참(True)입니다.
   * {{{<요소> not in <집합>}}} : 집합내에 요소가 없는 경우 참(True)입니다.

 제어를 위해서 수행구문 블록내에 사용되는 '''break, continue, pass''' 가 있습니다.
  |제어문|<bgcolor="gray">  제어문(Control Statements)  ||<bgcolor="gray">  설명(Description)  ||
  ||<bgcolor="yellow">{{{break}}}  ||루프(Loop) 문을 종료하고 루프 바로 다음 명령문으로 실행문맥을 이동합니다.  ||
  ||<bgcolor="yellow">{{{continue}}}  ||루프(Loop)범위의 나머지 부분을 건너 뛰고 다시 반복하기 전에 즉시 조건을 다시 테스트하도록 문맥을 이동합니다.  ||
  ||<bgcolor="yellow">{{{pass}}}  ||수행구문이 필요하지만 실행할 코드가 없는 경우가 있을 수 있는데 이 경우 아무것도 하지 않는다는 의미로 사용합니다.  ||
==== if 문 (조건문) ====
 '''CASE''': 주어진 조건이 참(True)이면 A를 수행합니다.
  [[attachment:파이썬(Python)_if_조건문_개요.png if 조건문]]
  * 형식
   {{{#!enscript python
if <조건>:
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> money=2000 # 돈이 2000원 있음.
>>> have_money=money>0 # 돈이 좀 있는가?
>>> if have_money: # 조건 비교
...     print("Have money %d won"%money) # 참(True) 인 경우
...
Have money 2000 won
>>>
}}}

 '''CASE''': 주어진 조건이 참(True)이면 A를 수행하고 아니면 B를 수행합니다.
  [[attachment:파이썬(Python)_if_및_else_조건문_개요.png if else 조건문]]
  * 형식
   {{{#!plain
if <조건1>:
    <수행할 구문1-1>
    <수행할 구문1-2>
    <수행할 구문1-3>
    <...>
else:
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> money=0 # 돈이 없음.
>>> have_money=money>0 # 돈이 좀 있는가?
>>> if have_money: # 조건 비교
...     print("Have money %d won"%money) # 참(True) 인 경우
... else:
...     print("No money") # 거짓(False) 인 경우
...
No money
>>> if "":
...     print("Not empty")
... else:
...     print("Empty")
...
Empty
>>> a=""
>>> if a == "":
...     print("Empty")
... else:
...     print("Not empty")
...
Empty
>>> if 0:
...     print("Not zero")
... else:
...     print("Zero")
...
Zero
>>> a=0
>>> if a == 0:
...     print("Zero")
... else:
...     print("Not zero")
...
Zero
>>> money=2000 # 돈 2000원을 가지고 있습니다.
>>> if money <= 0: # 돈이 없다면
...     pass # 아무것도 할게 없습니다. (No operation)
... else:
...     print("Have money %d won"%money)
...
Have money 2000 won
>>>
}}}

 '''CASE''': 주어진 조건1이 참(True)이면 A를 수행하고 아니면 조건2가 참이면 B를 수행하여 그것도 아니면 C를 수행합니다.
  [[attachment:파이썬(Python)_if_및_elif_조건문_개요의_사본.png if elif 조건문]]
  * 형식
   {{{#!plain
if <조건1>:
    <수행할 구문1-1>
    <수행할 구문1-2>
    <수행할 구문1-3>
    <...>
elif <조건2>:
    <수행할 구문2-1>
    <수행할 구문2-2>
    <수행할 구문2-3>
    <...>
elif <조건n>:
    <수행할 구문n-1>
    <수행할 구문n-2>
    <수행할 구문n-3>
    <...>
else:
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> money=2000 # 돈이 2000원 있음.
>>> if money <= 0: # 돈이 없는가?
...     print("No money")
... elif money <=1000: # 1000원 미만인가?
...     print("껌하나 사먹을 수 있어요.")
... elif money > 2000: # 2000원 보다 많은가?
...     print("부자시네요.")
... else: # 그 외에 1000원 보다 많고 2000원 미만인가?
...     print("과자를 골라드세요.")
...
과자를 골라드세요.
>>>
}}}

 '''CASE''': 비교적 짧은 구문의 경우 '''들여쓰기 없이 작성될 수''' 있으며 여러 수행구문은 이 경우 '''세미콜론(';')으로 구분'''할 수 있습니다.
  * 형식
  {{{#!plain
if <조건>: <수행할 구문1>[;<수행할 구문n>]
elif: <수행할 구문1>[;<수행할 구문n>]
else: <수행할 구문1>[;<수행할 구문n>]
}}}
  * 예시
   {{{#!enscript python
>>> money=1000
>>> if money <= 0: print("No money")
... elif money <= 1000: print("껌하나 사먹을 수 있어요.");print("껌은 %d원으로 살수 있을거예요."%money)
... elif money > 2000: print("부자시네요.");print("%d원으로는 사먹을게 많아요."%money)
... else: print("과자를 골라드세요.");print("2000원 이하의 과자만 고르세요.")
...
껌하나 사먹을 수 있어요.
껌은 1000원으로 살수 있을거예요.
>>>
}}}

 '''CASE''': 간결한 조건부 검사 수행을 위해서 '''조건부 표현식(Conditional Expression)을 활용'''할 수 있습니다. (보통은 대입할때 한줄로 표기할 수 있어 가독성 향상에 도움이 될 수 있습니다.)
  * 형식
  {{{#!plain
<참(True)일 때 구문> if <조건> else <거짓(False)일 때 구문>
}}}
  * 예시
   {{{#!enscript python
>>> money=2000
>>> message="Have money %d won"%money if money > 0 else "No money"
>>> print("%s"%message)
Have money 2000 won
>>>
}}}
==== while 문 (Loop 제어문) ====
 '''CASE''': 주어진 조건이 참(True)인 동안 A를 '''반복해서 수행'''합니다.
  [[attachment:파이썬(Python)_while_loop_문_개요.png while loop 문]]
  * 형식
   {{{#!plain
while <조건>:
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> i=0
>>> while i < 10: # i가 10이 되면 거짓(False)이 되어 while 구문을 벗어나게 됩니다.
...     i += 1 # 1 증가
...     print("loop %d"%i) # i값의 증가가 먼저 수행되었으므로 1부터 출력
...
loop 1    # <= i가 0일 때 진입하여 증가 후 출력되므로 1이 됨
loop 2
loop 3
loop 4
loop 5
loop 6
loop 7
loop 8
loop 9
loop 10  # <= i가 9일 때 진입하여 증가 후 출력되므로 10이 됨
>>> items=[1,0,3,4,"Hello","World"]
>>> i=0
>>> while i < len(items):
...     print("This loop value: %s"%items[i])
...     i+=1
...
This loop value: 1
This loop value: 0
This loop value: 3
This loop value: 4
This loop value: Hello
This loop value: World
>>> items={"a":"a1", "b":"b1", "c":"c1"}
>>> keys=items.keys() # items의 key 목록(List)을 얻습니다.
>>> i=0
>>> while i < len(keys):
...     print("This dict is %s:%s"%(keys[i],items.get(keys[i])))
...     i+=1
...
This dict is a:a1
This dict is c:c1
This dict is b:b1
>>>
}}}

 '''CASE''': 주어진 조건a가 참(True)인 동안 A를 반복수행하는데 수행구문 중간에 조건i일 때 loop를 '''벗어납니다'''.
  [[attachment:파이썬(Python)_while_loop_문과_break_개요.png while loop break]]
  * 형식
   {{{#!plain
while <조건a>:
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
    if <조건i>:
        break;
    <수행할 구문4>
    <수행할 구문5>
    <수행할 구문6>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> items=[4,3,2,5,6,7,8,100,105]
>>> i=0
>>> while i < len(items):
...     print("%d 번째 items를 확인하겠습니다."%i)
...     if items[i] == 7:
...         print("%d 번째 items에서 행운의 7을 찾았습니다."%i)
...         break
...     print("%d 번째 items는 %d 이며 행운의 7은 아닙니다."%(i,items[i]))
...     i+=1
...
0 번째 items를 확인하겠습니다.
0 번째 items는 4 이며 행운의 7은 아닙니다.
1 번째 items를 확인하겠습니다.
1 번째 items는 3 이며 행운의 7은 아닙니다.
2 번째 items를 확인하겠습니다.
2 번째 items는 2 이며 행운의 7은 아닙니다.
3 번째 items를 확인하겠습니다.
3 번째 items는 5 이며 행운의 7은 아닙니다.
4 번째 items를 확인하겠습니다.
4 번째 items는 6 이며 행운의 7은 아닙니다.
5 번째 items를 확인하겠습니다.
5 번째 items에서 행운의 7을 찾았습니다.
>>>
}}}

 '''CASE''': 주어진 조건a가 참(True)인 동안 A를 반복수행하는데 수행구문 중간에 조건i일 때 loop조건부에서 '''다시 조건을 검사'''합니다.
  [[attachment:파이썬(Python)_while_loop_문과_continue_개요.png while loop continue]]
  * 형식
   {{{#!plain
while <조건a>:
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
    if <조건i>:
        continue;
    <수행할 구문4>
    <수행할 구문5>
    <수행할 구문6>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> i=0
>>> while i < 10:
...     i+=1
...     if int(i % 2) == 0:
...         continue
...     print("1부터 10사이에 홀수 %d가 있습니다."%i)
...
1부터 10사이에 홀수 1가 있습니다.
1부터 10사이에 홀수 3가 있습니다.
1부터 10사이에 홀수 5가 있습니다.
1부터 10사이에 홀수 7가 있습니다.
1부터 10사이에 홀수 9가 있습니다.
>>>
}}}

 '''CASE''': 끝나지 않는 무한의 loop
  * 예시
   {{{#!enscript python
>>> while True: # 조건이 항상 참(True)이기 때문에 break 구문이 없는 이상 이 loop는 무한합니다.
...     pass
...     # 빠져나올려면 Ctrl+C 키를 누르는 등의 방법을 사용해야 합니다.
...
}}}
==== for 문 (Loop 제어문) ==== 
 '''CASE''': 주어진 제어조건을 한번씩 순회하며 각각에 대하여 수행합니다. ('''while loop 문에서의 break와 continue 제어문을 for loop에서도 동일한 의미로 사용 가능'''합니다.)
  * 형식
   {{{#!plain
for <하나의 요소값을 가질 변수명> in <목록(List 또는 Tuple 또는 문자열)>
    <수행할 구문1>
    <수행할 구문2>
    <수행할 구문3>
    <...>
    if <조건b>:
        break;
    if <조건c>:
        continue;
    <수행할 구문4>
    <수행할 구문5>
    <수행할 구문6>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> items=[3, 40, 20, "Hello", "World"]
>>> for temp in items:
...     print("item중에 %s가 있습니다."%temp)
...
item중에 3가 있습니다.
item중에 40가 있습니다.
item중에 20가 있습니다.
item중에 Hello가 있습니다.
item중에 World가 있습니다.
>>> items={3:"a", 6:"b", 78:"c"}
>>> for temp in items:
...     print("item중에 %s가 있습니다."%temp)
...
item중에 3가 있습니다.
item중에 78가 있습니다.
item중에 6가 있습니다.
>>> items={3:"a", 6:"b", 78:"c"}
>>> for temp in items.keys():
...     print("item중에 %s가 있습니다."%temp)
...
item중에 3가 있습니다.
item중에 78가 있습니다.
item중에 6가 있습니다.
>>> items={3:"a", 6:"b", 78:"c"}
>>> for temp in items.values():
...     print("item중에 %s가 있습니다."%temp)
...
item중에 a가 있습니다.
item중에 c가 있습니다.
item중에 b가 있습니다.
>>>
}}}

 '''CASE''': for loop 문과 함께 어떤 범위의 숫자를 수행하기 위해서 모든 숫자를 리스트로 만들기 번거롭기 때문에 함수 "{{{[range(<시작 숫자>,]<끝 숫자 + 1>)}}}" 와 함께 이를 해소가능합니다.
  * 예시
   {{{#!enscript python
>>> for temp in range(1,11):
...     print("%d"%temp)
...
1
2
3
4
5
6
7
8
9
10
>>> items=["Hello", "World", "Hi", "Good"]
>>> for temp in range(len(items)):
...     print("%d 번째는 %s입니다."%(temp,items[temp]))
...
0 번째는 Hello입니다.
1 번째는 World입니다.
2 번째는 Hi입니다.
3 번째는 Good입니다.
}}}

 '''CASE''': 간결한 표현식으로 '''for문을 리스트(List)에 내포(List comprehension)'''할 수 있습니다. (규칙이 간결한 리스트 요소를 만들어 내는데 편리합니다.)
  * 형식
  {{{#!plain
[<수행할 구문> for <하나의 요소값을 가질 변수명> in <목록(List 또는 Tuple 또는 문자열)> {if <조건>} {중첩된 for...}]
}}}
  * 예시
   {{{#!enscript python
>>> items=["data",1,'a',[3,2,1],5,"Hello"]
>>> dup_items=[temp for temp in items]
>>> dup_items
['data', 1, 'a', [3, 2, 1], 5, 'Hello']
>>> items=(3,4,"a","b",[100,200,300])
>>> dup_items=[temp for temp in items]
>>> dup_items
[3, 4, 'a', 'b', [100, 200, 300]]
>>> gugudan=[x*y for x in range(2,10) for y in range(1,10)] # 중첩된 for 구문으로 구구단 목록 리스트 작성
>>> gugudan
[2, 4, 6, 8, 10, 12, 14, 16, 18, 3, 6, 9, 12, 15, 18, 21, 24, 27, 4, 8, 12, 16, 20, 24, 28, 32, 36, 5, 10, 15, 20, 25, 30, 35, 40, 45, 6, 12, 18, 24, 30, 36, 42, 48, 54, 7, 14, 21, 28, 35, 42, 49, 56, 63, 8, 16, 24, 32, 40, 48, 56, 64, 72, 9, 18, 27, 36, 45, 54, 63, 72, 81]
>>> gugudan=[x*y for x in range(2,10) if x >= 2 and x <= 3 for y in range(1,10)]
>>> gugudan
[2, 4, 6, 8, 10, 12, 14, 16, 18, 3, 6, 9, 12, 15, 18, 21, 24, 27] # 중첩된 for 구문 사이에 x가 2에서 3까지만 내포된 for 진입하도록 하는 경우
>>>
}}}

 결국 while과 for loop문은 '''사용하는 방식의 편리성이 서로 다를 뿐이며 상호간 변환해서 구현이 가능'''합니다. 어느것을 사용하던 상관없으나 편리함의 특성에 따라서 상황에 맞는 방법을 찾아줄 것입니다.

 '''생각해볼 문제''' : for loop문 내에서 list를 순회하면서 삭제하는 경우 어떻게 동작할까 알아두어야 할 사항이 있습니다. 아래 예시는 분명 의도와 다르다는 것을 경험하게 합니다.
   {{{#!enscript python
>>> 
>>> """ 아래의 의도는 주어진 list를 순회하면서 각 요소를 삭제하여 결과적으로 list 요소를 모두 삭제하려고 하였습니다. 그런데... """
>>>
>>> data = list(range(10))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for i in data:
...     data.remove(i)
...
>>> data
[1, 3, 5, 7, 9]
>>>
>>>
>>> """ 그럼 이번에는 for 구문 말고 인덱스 접근으로 while loop 를 사용해볼까요? 결과가 역시 의도와 다르지만 왜 그런지 조금은... """
>>>
>>> data = list(range(10))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> i = 0
>>> c = len(data)
>>> while i < c:
...     data.remove(data[i])
...     c -= 1
...     i += 1
...
>>> data
[1, 3, 5, 7, 9]
>>>
>>>
>>> """ 이제 이 문제를 다음과 같이 복제된 list를 순회하면서 원본을 삭제하는 것으로 바꿔보면 의도한대로 동작합니다. """
>>>
>>> data = list(range(10))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for i in data[:]:
...     data.remove(i)
...
>>> data
[]
}}}
=== 함수(Function) ===
 반복적으로 사용되는 구문을 하나의 함수로 작성하고 반복사용하던 부분에서 함수를 사용하는 것으로 반복적인 구문을 줄이고 흐름을 깔끔하게 정리하는 방법

 '''CASE''': 특정 구문을 하나의 함수로 수행
  * 형식
   {{{#!plain
def <함수명>():
    <수행할 구문1>
    <수행할 구문2>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> def print_hello():
...     print("Hello world")
...
>>> for i in range(3):
...     print_hello()
...
Hello world
Hello world
Hello world
>>>   
}}}

 '''CASE''': 함수에 인자를 주어 함수에 변화를 주는 수행
  * 형식
   {{{#!plain
def <함수명>([<인자1>[,<인자n>[...]]]):
    <수행할 구문1>
    <수행할 구문2>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> def sum_odd(a, b):
...     value = a + b
...     if value % 2: print("홀수%d"%value)
...     else: print("짝수%d"%value)
...
>>> for i in range(10):
...     sum_odd(i, 1)
...
홀수1
짝수2
홀수3
짝수4
홀수5
짝수6
홀수7
짝수8
홀수9
짝수10
>>>
}}}

 '''CASE''': 함수의 결과값을 통해서 수행하는 경우
  * 형식
   {{{#!plain
def <함수명>([<인자1>[,<인자n>[...]]]): # 인자가 필요 한 경우만 인자를 사용
    <수행할 구문1>
    <수행할 구문2>
    <...>
    return <결과값> # return 구문은 결과값이 있는 경우만 사용
}}}
  * 예시
   {{{#!enscript python
>>> def sum(a, b):
...     return a + b
...
>>> sum(3, 5)
8
>>> def print_sum():
...     print(sum(3,5))
...
>>> print_sum()
8
>>> def sum_and_mul(a, b):
...     return a+b, a*b       # 콤마(',')로 구분하여 2개 이상의 결과를 튜플형으로 반환할 수 있습니다.
...
>>> print(sum_and_mul(2, 3))
(5, 6)
>>>
}}}

 '''CASE''': 가변인자를 튜플인자로 취하는 경우
  * 형식
   {{{#!plain
def <함수명>([<인자>,]*<가변인자명>):
    <수행할 구문1>
    <수행할 구문2>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> def print_args(*args):
...     print(args)
...
>>> print_args(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> def sum_args(*values):
...     sum = 0
...     for i in values:
...             sum = sum + i
...     return sum
...
>>> print(sum_args(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
55
>>>
}}}

 '''CASE''': 가변인자를 딕셔너리 자료로 취하는 경우
  * 형식
   {{{#!plain
def <함수명>([<인자>,]**<가변인자명>):
    <수행할 구문1>
    <수행할 구문2>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> def print_args(**args):
...     print(args)
...
>>> print_args(a=1,b=2,c=3)
{'a': 1, 'c': 3, 'b': 2}
>>>
}}}

 '''CASE''': 초기값을 가진 인자의 사용 (오른쪽 인자부터 초기값을 줄 수 있습니다.)
  * 형식
   {{{#!plain
def <함수명>(<인자1>, <인자n-1>=<초기값>, <인자n>=<초기값>):
    <수행할 구문1>
    <수행할 구문2>
    <...>
}}}
  * 예시
   {{{#!enscript python
>>> def print_args(a, b=2, c=3):    # 인자의 오른쪽(마지막) 인자부터 초기값을 명시할 수 있습니다. 초기값이 주어진 인자는 함수 호출 시 해당 인자를 생략하면 초기값으로 간주하게 됩니다.
...     print(a, b, c)
...
>>> print_args(1)
1 2 3
>>> print_args(1,4)
1 4 3
>>> print_args(1,4,5)
1 4 5
>>>
}}}

 '''CASE''': 함수내 변수의 유효범위
  * 함수내의 변수는 기본적으로 그 함수를 벗어나면 그 유효성이 상실되며 함수내의 변수는 그 밖의 변수와 이름이 같더라도 서로 다른 변수입니다.
   {{{#!enscript python
>>> a = 1
>>> def my_value(a):
...     a = a + 100
...
>>> my_value(a)
>>> print(a)
1
>>>
}}}
  * 함부 밖의 변수를 함수내에서 접근하려면 global 키워드를 사용할 수 있습니다. (가급적이면 이 방법은 함수의 재진입 특성을 제한하기 때문에 권장하지 않습니다.)
   {{{#!enscript python
>>> a = 1
>>> def my_value_is_global():
...     global a
...     a = a + 100
...
>>> my_value_is_global()
>>> print(a)
101
>>>
}}} 

 '''CASE''': 함수를 문자열로 호출하기
  *
   {{{#!enscript python
>>> """ 다음과 같이 어떤 함수 myfunc 이 선언되어 있다고 하죠 """
>>> def myfunc():
...     print("Hello world\n")
...
>>>
>>> """ 그냥 myfunc() 으로 호출해도 되지만 """
>>> myfunc()
Hello world

>>> """ locals()를 이용하여 문자열 "myfunc" 을 사용하여 함수를 호출할 수 있습니다. (이렇게 되면 외부로부터 입력된 문자열을 통하여 가변적인 호출 흐름을 만드는데 용이한 경우가 있을겁니다.) """
>>> locals().get("myfunc")()
Hello world

>>> """ 만약 존재하지 않은 함수를 문자열 호출하려고 할 때 해당 함수가 존재하지 않는다면 기본 호출 함수를 myfunc 으로 호출되도록 할 수도 있겠죠. """
>>> locals().get("not_exist_myfunc", myfunc)()
Hello world

}}}
=== 입/출력(I/O) ===
=== 클래스(Class) ===
=== 모듈(Module) ===
=== 패키지(Package) ===
=== 예외처리(Exception) ===
=== 내장함수 ===
=== 외장함수 ===
=== 접합언어로써의 구현 ===
==== Python/C ====
=== 참고자료 ===
 * [^https://www.python.org/]
 * [^https://www.tutorialspoint.com/python/index.htm Python - Tutorial]
  * [^https://www.tutorialspoint.com/python/python_quick_guide.htm Python Quick Guide]
 * [^http://www.scipy.org/]
 * [^https://jobtensor.com/Python-Introduction]
 * [^http://www.fantascienza.net/leonardo/ar/python_best_practices.html]
 * [^https://en.wikipedia.org/wiki/Python_(programming_language)]
 * [^https://gvanrossum.github.io/ Guido van Rossum - Personal Home Page]
 * [^https://www.python.org/dev/peps/pep-0263/ PEP 263 -- Defining Python Source Code Encodings]
 * [^https://wikidocs.net/book/1 점프 투 파이썬 (책) - 지은이 박응용]
  * [[ISBN(9791163030911,K,noimg)]]
 * [^https://wikidocs.net/book/122 Python 3.4 공부 좀 해볼까? - 지은이 용진]
 * [^https://en.wikipedia.org/wiki/Type_system]
 * [^https://www.json.org/json-ko.html JSON (JavaScript Object Notation)]
 * [^https://ddanggle.gitbooks.io/interpy-kr/content/ch21-Targeting-python.html Targeting Python 2+3]
 * [^https://woolbro.tistory.com/m/33?fbclid=IwAR272F_7HP_OOpIb53YQcNTPpLNsxyPubRo1QcEmnA9BvmiJdq_ZSygIqMs]
 * [^https://docs.python.org/3/c-api/index.html]
 * [^https://www.datacamp.com/courses-all DataCamp courses]
  * [^https://www.datacamp.com/courses/intro-to-python-for-data-science Introduction to Python]
  * [^https://www.datacamp.com/courses/introduction-to-sql Introduction to SQL]
  * [^https://www.datacamp.com/courses/free-introduction-to-r Introduction to R]
  * [^https://www.datacamp.com/courses/machine-learning-for-everyone Machine Learning for Everyone]
  * [^https://www.datacamp.com/courses/data-science-for-everyone Data Science for Everyone]
  * [^https://www.datacamp.com/courses/data-engineering-for-everyone Data Engineering for Everyone]