#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]]
'''이 페이지의 내용은 [[HTML(Python Complete Guide)]] 으로 내용을 이어갑니다.'''
=== 파이썬(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)'''
|환경변수| 환경변수(Environment Variable) || 설명(Description) ||
||{{{PYTHONPATH}}} ||파이썬 인터프리터에게 프로그램으로 가져온 모듈 파일의 위치를 알려줍니다. 파이썬 소스 라이브러리 디렉토리와 파이썬 소스 코드가 들어있는 디렉토리를 포함해야합니다. PYTHONPATH는 때때로 Python 설치 프로그램에 의해 미리 설정됩니다. ||
||{{{PYTHONSTARTUP}}} ||파이썬 소스 코드를 포함하는 초기화 파일의 경로를 포함합니다. 인터프리터를 시작할 때마다 실행됩니다. Unix에서는 .pythonrc.py라는 이름으로 유틸리티를로드하거나 PYTHONPATH를 수정하는 명령이 들어 있습니다. ||
||{{{PYTHONCASEOK}}} ||Windows에서 Python이 import 문에서 대소 문자를 구분하지 않는 첫 번째 일치를 찾도록 지시하는 데 사용됩니다. 이 변수를 활성화하려면 값을 설정하십시오. ||
||{{{PYTHONHOME}}} ||대체 모듈 검색 경로입니다. 일반적으로 PYTHONSTARTUP 또는 PYTHONPATH 디렉토리에 포함되어 스위칭 모듈 라이브러리를 쉽게 만들 수 있습니다. ||
=== 기초사항과 실습 ===
'''파이썬(Python) CLI 명령어("python" 또는 "python.exe")의 주요 옵션(Options)'''
|명령행 옵션| 옵션(Option) || 설명(Description) ||
||아무 인자 없이 실행하는 경우 ||기본 대화형 인터프리터로 실행됩니다. ||
||{{{-d}}} ||디버그 출력을 제공합니다. ||
||{{{-O}}} ||최적화 된 바이트 코드 (.pyo 파일을 생성)를 생성합니다. ||
||{{{-S}}} ||시작시 Python 경로를 찾기 위해 "import site"를 실행하지 않도록 합니다. ||
||{{{-v}}} ||자세한 출력 (import 문의 세부 추적시 유용) ||
||{{{-c }}} ||cmd 문자열로 전송 된 Python script를 실행합니다. ||
||{{{}}} ||주어진 파일에서 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])
|연산자 우선순위| 연산자(Operator) || 설명(Description) ||
||{{{**}}} ||지수 제곱 ||
||{{{~, +, ,-}}} ||단항 연산 ||
||{{{*, /, %, //}}} ||산술 연산 곱하기, 나누기, 나머지, 몫 ||
||{{{+, -}}} ||산술 연산 덧셈, 뺄셈 ||
||{{{>>, <<}}} ||비트 쉬프트 ||
||{{{&}}} ||비트논리 AND ||
||{{{^, |}}} ||비트논리 XOR, OR ||
||{{{<=, <, >, >=}}} ||비교 연산 ||
||{{{<>, ==, !=}}} ||평등 연산 ||
||{{{=, %=, /=, //=, -=, +=, *=, **=}}} ||할당 연산 ||
||{{{is, is not}}} ||식별 연산 ||
||{{{in, not in}}} ||멤버 연산 ||
||{{{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)
>>>
}}}
'''[^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])
|내장 자료형| 종류(Type) || 객체의 종류 || 설명(Description) || 문법 예(Syntax example) ||
||bool || 불변객체 ||참/거짓 값(Boolean value) ||True, False ||
||bytearray || 가변객체 ||순차 바이트열(Sequence of bytes) ||{{{bytearray(b'Some ASCII')}}}, {{{bytearray(b"Some ASCII")}}}, {{{bytearray([119, 105, 107, 105])}}} ||
||bytes || 불변객체 ||순차 바이트열(Sequence of bytes) ||{{{b'Some ASCII'}}}, {{{b"Some ASCII"}}}, {{{bytes([119, 105, 107, 105])}}} ||
||complex || 불변객체 ||복소수 (실수와 허수) ||{{{3+2.7j}}} ||
||dict || 가변객체 ||연관 배열의 키와 값 쌍 ||{{{{'key1': 1.0, 3: False}}}} ||
||ellipsis || - ||NumPy 배열에서 색인으로 사용되는 줄임표 자리 표시 자 ||... ||
||float || 불변객체 ||부동소수점 수 (시스템 정의 정밀도) ||3.1415927 ||
||frozenset || 불변객체 ||순서가없는 집합이며 중복 된 내용이 없고 해시 가능한 경우 혼합 유형을 포함 할 수 있음 ||{{{frozenset([4.0, 'string', True])}}} ||
||int || 불변객체 ||정수로서 크기는 무제한 ||42 ||
||list || 가변객체 ||혼합 형태를 포함가능 ||{{{[4.0, 'string', True]}}} ||
||set || 가변객체 ||순서가없는 집합이며 중복 된 내용이 없고 해시 가능한 경우 혼합 유형을 포함 할 수 있음 ||{{{{4.0, 'string', True}}}} ||
||str || 불변객체 ||일련의 유니코드(Unicode) 코드포인트(codepoints) ||'MyString', "MyString" ||
||tuple || 불변객체 ||혼합 형태를 포함가능 ||{{{(4.0, 'string', True)}}} ||
==== 숫자(Number)형 ====
|숫자(Number)형의 종류| 항목 || 예 || 비고 ||
||정수(Integer) ||123, -345, 0 ||양의 정수, 음의 정수, 0(Zero) ||
||실수(Floating-point) ||123.45, -1234.5, 3.4e10, 4.24E10, 4.24E-10 ||컴퓨터식 지수 표현 방식, e 또는 E 둘다 사용가능, E10은 10의 10승을 의미 ||
||복소수(Complex-number) ||1+2j, -3j ||j 또는 J 둘다 사용가능, 복소수의 실수부-허수부-켤레복소수-절대값 등을 다룰 수 있습니다. ||
||8진수(Octal) ||0o34, 0o25, 0o177 ||숫자 0 다음에 알파벳 O(소문자 또는 대문자 사용가능)으로 시작 ||
||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| 코드 || 설명 ||
||{{{\\ }}} ||역슬래시({{{\ }}}) 그 자체 ||
||{{{\n}}} ||줄 바꿈 문자(New line, 다음줄의 첫 컬럼으로 이동) ||
||{{{\t}}} ||탭(Tab) 문자 ||
||{{{\r}}} ||캐리지 리턴 문자(Carriage return, 커서를 현재 줄의 첫 컬럼으로 이동) ||
||{{{\f}}} ||폼 피드(Form feed, 커서를 다음줄의 현 컬럼으로 이동) ||
||{{{\a}}} ||벨 소리(PC speaker에 beep음을 울리게 함) ||
||{{{\s}}} ||공백(Space) 문자 ||
||{{{\b}}} ||백 스페이스 문자 ||
||{{{\v}}} ||수직탭(Vertical tab) 문자 ||
||{{{\cx}}} ||Ctrl + X ||
||{{{\C-x}}} ||Ctrl + X ||
||{{{\M-\C-x}}} ||Meta + Ctrl + X ||
||{{{\e}}} ||Escape 문자 ||
||{{{\000}}} 또는 {{{\x00}}} ||Nul terminator 문자 ||
||{{{\aaa}}} 또는 {{{\xbb}}} ||ASCII code 문자 (aaa 는 8진수 code, bb 는 16진수 code) ||
||{{{\<문자>}}} ||<문자> 그 자체 (단, 위 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 "", line 1, in
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| Method || 설명(Description) ||
||{{{capitalize()}}} ||문자열의 첫 글자를 대문자로 표시 ||
||{{{center(width, fillchar)}}} ||총 너비 열의 가운데에 원래 문자열이있는 채워진 문자열을 반환 ||
||{{{count(str, beg= 0,end=len(string))}}} ||시작 인덱스 beg와 끝 인덱스 종료가 주어진 경우 문자열 또는 문자열의 하위 문자열에서 str이 몇 번 발생하는지 계산 ||
||{{{decode(encoding='UTF-8',errors='strict')}}} ||인코딩 용으로 등록 된 코덱을 사용하여 문자열을 디코딩 (인코딩 기본값은 기본 문자열 인코딩) ||
||{{{encode(encoding='UTF-8',errors='strict')}}} ||문자열의 인코딩 된 문자열 버전을 반환 (오류시 기본값은 'ignore'또는 'replace'로 오류가 표시되지 않는 한 ValueError를 발생) ||
||{{{endswith(suffix, beg=0, end=len(string))}}} ||문자열의 인코딩 된 버전이 반환 (오류 메시지가 'ignore'또는 'replace'오류가 표시되면 ValueError가 발생) ||
||{{{expandtabs(tabsize=8)}}} ||문자열의 탭을 여러 공백으로 확장 (탭 크기가 제공되지 않으면 탭당 8 공백이 기본값) ||
||{{{find(str, beg=0 end=len(string))}}} ||문자열 시작 또는 끝 인덱스 지정이 주어진 경우 str이 문자열에서 또는 문자열의 부분 문자열에서 발생하는지 확인 (그렇지 않으면 -1을 반환) ||
||{{{index(str, beg=0, end=len(string))}}} ||{{{find()}}}와 동일하지만, str가 발견되지 않으면 예외가 발생 ||
||{{{isalnum()}}} ||문자열이 1 문자 이상이고 모든 문자가 영숫자의 경우는 true, 그렇지 않은 경우는 false ||
||{{{isalpha()}}} ||문자열이 1 문자 이상이고 모든 문자가 영문자이면 true를 반환하고 그렇지 않으면 false ||
||{{{isdigit()}}} ||문자열에 숫자 만 들어 있으면 true를 반환하고 그렇지 않으면 false ||
||{{{islower()}}} ||문자열에 적어도 하나의 대소 문자가 있고 대소 문자가 모두 소문자이면 true를 반환하고 그렇지 않으면 false ||
||{{{isnumeric()}}} ||유니 코드 문자열에 숫자 문자 만 포함되어 있으면 true를 반환하고 그렇지 않으면 false ||
||{{{isspace()}}} ||문자열에 공백 문자 만 포함되어 있으면 true를 반환하고 그렇지 않으면 false ||
||{{{istitle()}}} ||문자열이 적절히 "titlecased"이면 true를 반환하고 그렇지 않으면 false ||
||{{{isupper()}}} ||문자열에 적어도 하나의 대소 문자가 있고 대소 문자가 모두 대문자이면 true를 반환하고 그렇지 않으면 false ||
||{{{join(seq)}}} ||문자열 seq에있는 요소의 문자열 표현을 구분 기호 문자열과 병합(연결) ||
||{{{len(string)}}} ||문자열의 길이를 반환 ||
||{{{ljust(width[, fillchar])}}} ||총 너비 열에 왼쪽 정렬 된 원래 문자열을 사용하여 공백으로 채워진 문자열을 반환 ||
||{{{lower()}}} ||문자열의 모든 대문자를 소문자로 변환 ||
||{{{lstrip()}}} ||문자열의 앞에있는 공백을 모두 제거 ||
||{{{maketrans()}}} ||translate 함수에서 사용할 변환 테이블을 반환 ||
||{{{max(str)}}} ||문자열 str에서 최대 알파벳 문자를 반환 ||
||{{{min(str)}}} ||문자열 str에서 최소 알파벳 문자를 반환 ||
||{{{replace(old, new [, max])}}} ||문자열에서 old의 모든 항목을 새 항목 또는 최대 항목으로 교체 ||
||{{{rfind(str, beg=0,end=len(string))}}} ||{{{find()}}}와 동일하지만 문자열에서 뒤로 검색 ||
||{{{rindex( str, beg=0, end=len(string))}}} ||{{{index()}}}와 같지만 문자열에서 뒤로 검색 ||
||{{{rjust(width,[, fillchar])}}} ||총 너비 열로 오른쪽 정렬 된 원래 문자열로 공백으로 채워진 문자열을 반환 ||
||{{{rstrip()}}} ||문자열의 뒤에있는 공백을 모두 제거 ||
||{{{split(str="", num=string.count(str))}}} ||구분 기호 str (제공되지 않은 경우 공백)에 따라 문자열을 분할하고 하위 문자열 목록을 반환 (주어진 경우 최대 num 하위 문자열로 분할) ||
||{{{splitlines( num=string.count('\n'))}}} ||문자열을 모두 (또는 num) 줄바꿈 문자기준으로 분할하고 줄바꿈 문자는 제거 된 각 행의 목록을 반환 ||
||{{{startswith(str, beg=0,end=len(string))}}} ||문자열의 문자열 또는 부분 문자열(시작 색인 beg 및 종료 색인 끝이 주어진 경우)이 부분 문자열 str로 시작하는지 확인하여 있으면 true를 반환하고 그렇지 않으면 false를 반환 ||
||{{{strip([chars])}}} ||문자열에서 앞/뒤 공백을 제거 (문자열에 대해 {{{lstrip()}}} 및 {{{rstrip()}}}을 수행) ||
||{{{swapcase()}}} ||문자열의 모든 대/소문자를 반전 ||
||{{{title()}}} ||문자열의 "제목"버전을 반환 (즉, 모든 단어는 대문자로 시작하고 나머지는 소문자) ||
||{{{translate(table, deletechars="")}}} ||문자열을 변환 테이블 str (256 문자)에 따라 변환하고 deletechars의 문자를 제거합니다. ||
||{{{upper()}}} ||문자열의 소문자를 대문자로 변환 ||
||{{{zfill(width)}}} ||총 너비 문자에 0으로 왼쪽 패딩 된 원래 문자열을 반환 ||
||{{{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 "", line 1, in
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 "", line 1, in
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| 코드 || 설명 ||
|| {{{%c}}} ||문자 1개(Character) ||
|| {{{%s}}} ||문자열(String) ||
|| {{{%i}}} ||부호 있는 정수(Integer) ||
|| {{{%d}}} ||부호 있는 정수(Integer) ||
|| {{{%u}}} ||부호 없는 정수(Integer) ||
|| {{{%o}}} ||8진수(Octal) ||
|| {{{%x}}} ||16진수(Hexa-decimal) 소문자 ||
|| {{{%X}}} ||16진수(Hexa-decimal) 대문자 ||
|| {{{%e}}} ||지수(Exponential) 소문자 ||
|| {{{%E}}} ||지수(Exponential) 대문자 ||
|| {{{%f}}} ||부동소수점(Floating-point) 수 ||
|| {{{%g}}} ||{{{%f}}}와 {{{%e}}}중에서 짧은 표기 ||
|| {{{%G}}} ||{{{%f}}}와 {{{%E}}}중에서 짧은 표기 ||
|| {{{%%}}} ||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 ::= +
conversion ::= "r" | "s" | "a"
format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
fill ::=
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 "", line 1, in
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| Function & Method || 설명(Description) ||
||{{{cmp(list1, list2)}}} ||두 목록의 요소를 비교 ||
||{{{len(list)}}} ||목록(List)의 전체 길이 ||
||{{{max(list)}}} ||목록(List)에서 최대값 항목을 반환 ||
||{{{min(list)}}} ||목록(List)에서 최소값 항목을 반환 ||
||{{{list(seq)}}} ||목록(Tuple)을 목록(List)으로 변환 ||
||{{{list.append(obj)}}} ||목록(List)에 obj 객체를 추가 ||
||{{{list.count(obj)}}} ||목록(List)에 있는 obj의 개수를 반환 ||
||{{{list.extend(seq)}}} ||목록(List)에 seq 목록(List)을 추가 ||
||{{{list.index(obj)}}} ||리스트(List) 내에 있는 obj의 가장 작은 인덱스를 반환 ||
||{{{list.insert(index, obj)}}} ||객체 obj를 목록(List) index에 삽입 ||
||{{{list.pop(obj=list[-1])}}} ||목록(List)에서 마지막 객체 또는 obj를 제거하여 반환 ||
||{{{list.remove(obj)}}} ||목록(List)에서 obj를 삭제 ||
||{{{list.reverse()}}} ||목록(List)의 순서를 역순으로 재배치 ||
||{{{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 "", line 1, in
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 "", line 1, in
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 "", line 1, in
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| Function & Method || 설명(Description) ||
||{{{cmp(tuple1, tuple2)}}} ||두 목록(Tuple)의 요소를 비교 ||
||{{{len(tuple)}}} ||목록(Tuple)의 전체 길이 ||
||{{{max(tuple)}}} ||목록(Tuple)에서 최대값 항목을 반환 ||
||{{{min(tuple)}}} ||목록(Tuple)에서 최소값 항목을 반환 ||
||{{{tuple(seq)}}} ||목록(List)을 목록(Tuple)으로 변환 ||
==== 사전(Dictionary) 자료형 ====
사전(딕셔너리)형 자료형은 리스트(List)나 튜플(Tuple)처럼 순차적인(Sequential) 접근법에 의해서 요소값을 구하지 않고 Key를 통해서 Value를 얻는게 특징입니다.
{{{#!plain
{:,:,:, ...} # 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| Function & Method || 설명(Description) ||
||{{{cmp(dict1, dict2)}}} ||두 사전(Dictionary)의 요소를 비교 ||
||{{{len(dict)}}} ||사전(Dictionary)의 전체 길이 (요소의 개수) ||
||{{{str(dict)}}} ||사전(Dictionary)의 인쇄 가능한 문자열 표현을 생성 ||
||{{{type(variable)}}} ||전달 된 변수의 유형을 반환 (전달 된 변수가 사전이면 사전 유형을 반환) ||
||{{{dict.clear()}}} ||사전(Dictionary) 사전의 모든 요소를 제거 ||
||{{{dict.copy()}}} ||사전(Dictionary) dict의 얕은(shallow) 복사본을 반환 ||
||{{{dict.fromkeys()}}} ||seq 및 값이 value로 설정된 Key를 사용하여 새 사전(Dictionary)을 생성 ||
||{{{dict.get(key, default=None)}}} ||사전(Dictionary)에서 Key를 찾아 그 값을 반환 (default가 주어지는 경우 Key가 없을 때 default를 반환) ||
||{{{dict.has_key(key)}}} ||사전 dict에서 key가 있으면 true를 반환하고 그렇지 않으면 false를 반환 ||
||{{{dict.items()}}} ||dict (Key, Value) 튜플(Tuple) 쌍의 목록(List)을 반환 ||
||{{{dict.keys()}}} ||dict 사전(Dictionary)의 Key 목록(List)을 반환 ||
||{{{dict.setdefault(key, default=None)}}} ||{{{get()}}}과 유사하지만 key가 dict에없는 경우 {{{dict[key] = default}}}로 설정 ||
||{{{dict.update(dict2)}}} ||사전(Dictionary) dict2의 Key과 Value 쌍을 dict에 추가 ||
||{{{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 "", line 1, in
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 "", line 1, in
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 "", line 1, in
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 "", line 1, in
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) 기준| 자료형 || 값 || 참 또는 거짓 ||
||문자열(String) ||"python" || 참(True) ||
||문자열(String) ||"" || 거짓(False) ||
||리스트(List) ||{{{[1,2,3]}}} || 참(True) ||
||리스트(List) ||{{{[]}}} || 거짓(False) ||
||튜플(Tuple) ||() || 거짓(False) ||
||사전(Dictionary) ||{} || 거짓(False) ||
||숫자(Number) ||0이 아닌 숫자 || 참(True) ||
||숫자(Number) ||0 || 거짓(False) ||
||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 "", line 1, in
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'
>>>
}}}
각 자료형의 혼합형태에서 도출할 결과에 대한 오묘함을 회피하고 의도한 자료형으로 도출하기 위해서는 적절한 변환을 해야 합니다. 입력변수가 의도한 자료형이 아닐 수 있다면 명시적으로 변환을 하는게 좋습니다.
|자료형의 변환함수| 함수(Function) || 설명(Description) ||
||{{{int(<값>[,<진수>])}}} ||정수(Integer)로 변환 ||
||{{{long(<값>[,<진수>])}}} ||큰 정수(Long Integer)로 변환 ||
||{{{float(<값>)}}} ||실수(Floating-point)로 변환 ||
||{{{complex([,])}}} ||복소수(Complex-number) 객체 생성 ||
||{{{str(<값>)}}} ||문자열(String)로 변환 ||
||{{{repr(<객체>)}}} ||객체를 표현식 문자열로 변환 ||
||{{{eval()}}} ||문자열을 평가하여 객체로 반환 ||
||{{{tuple(<집합형 값>)}}} ||튜플(Tuple)로 변환 ||
||{{{list(<집합형 값>)}}} ||리스트(List)로 변환 ||
||{{{set(<집합형 값>)}}} ||집합(Set)으로 변환 ||
||{{{dict()}}} ||사전(Dictionary)객체 생성 ||
||{{{frozenset(<집합형 값>)}}} ||frozen 집합(Set)으로 변환 ||
||{{{chr(<값>)}}} ||정수(Integer)를 문자(Character)로 변환 ||
||{{{unichr(<값>)}}} ||정수(Integer)를 유니코드(Unicode) 문자로 변환 ||
||{{{ord(<값>)}}} ||하나의 문자(Character)를 정수(Integer)로 변환 ||
||{{{hex(<값>)}}} ||정수(Integer)를 16진수 문자열로 변환 ||
||{{{oct(<값>)}}} ||정수(Integer)를 8진수 문자열로 변환 ||
||{{{bool(<값>)}}} ||값을 평가하여 참/거짓으로 반환 ||
==== 자료형의 값을 저장하는 공간, 변수 ====
자료형의 종류 확인 (정확히는 type 함수는 그 객체의 종류를 알려줍니다. 즉, 숫자 1도 객체로 다룹니다.)
{{{#!enscript python
>>> a=1
>>> type(a)
>>> a="H"
>>> type(a)
>>> a='h'
>>> type(a)
>>> a=[]
>>> type(a)
>>> a=()
>>> type(a)
>>> a=(1)
>>> type(a)
>>> a=(1,)
>>> type(a)
>>> a={}
>>> type(a)
>>> a=set([1,2,3])
>>> type(a)
>>> a=None
>>> type(a)
>>>
}}}
'''변수''' : 객체를 가르키거나 저장하는 공간. 객체를 가르키는 것을 레퍼런스(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''' 가 있습니다.
|제어문| 제어문(Control Statements) || 설명(Description) ||
||