1.1. 파이썬(Python)이란?


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

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

파이썬(Python)을 해석하는 소프트웨어는 여러가지가 있습니다.
  • C파이썬(CPython, C로 작성된 인터프리터)
  • 스택리스 파이썬
    • C 스택을 사용하지 않는 인터프리터.
  • 자이썬
    • 자바 가상 머신 용 인터프리터. 과거에는 제이파이썬(JPython)이라고 불렸다.
  • IronPython
    • .NET 플랫폼 용 인터프리터.
  • PyPy
    • 파이썬으로 작성된 파이썬 인터프리터.
  • Brython
    • JavaScript로 구현, JavaScript를 대신하여 웹 스크립트 형태로 Python을 실행할 목적

파이썬(Python)의 핵심 철학은 다음과 같습니다. (참고: [https]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.")

1.2. 개발환경 준비

"[https]https://www.python.org/downloads/[]" 에서 자신의 OS환경과 맞는 버젼을 다운로드 받아 설치합니다.

Python download page
[PNG image (113.04 KB)]


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

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

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


편집기는 일반적인 텍스트(Text) 편집이 가능한 것이면 모두 사용가능합니다. 파이썬(Python)에서 인지하는 환경변수(Python Environment Variables)
환경변수
환경변수(Environment Variable) 설명(Description)
PYTHONPATH 파이썬 인터프리터에게 프로그램으로 가져온 모듈 파일의 위치를 알려줍니다. 파이썬 소스 라이브러리 디렉토리와 파이썬 소스 코드가 들어있는 디렉토리를 포함해야합니다. PYTHONPATH는 때때로 Python 설치 프로그램에 의해 미리 설정됩니다.
PYTHONSTARTUP 파이썬 소스 코드를 포함하는 초기화 파일의 경로를 포함합니다. 인터프리터를 시작할 때마다 실행됩니다. Unix에서는 .pythonrc.py라는 이름으로 유틸리티를로드하거나 PYTHONPATH를 수정하는 명령이 들어 있습니다.
PYTHONCASEOK Windows에서 Python이 import 문에서 대소 문자를 구분하지 않는 첫 번째 일치를 찾도록 지시하는 데 사용됩니다. 이 변수를 활성화하려면 값을 설정하십시오.
PYTHONHOME 대체 모듈 검색 경로입니다. 일반적으로 PYTHONSTARTUP 또는 PYTHONPATH 디렉토리에 포함되어 스위칭 모듈 라이브러리를 쉽게 만들 수 있습니다.

1.3. 기초사항과 실습


파이썬(Python) CLI 명령어("python" 또는 "python.exe")의 주요 옵션(Options)
명령행 옵션
옵션(Option) 설명(Description)
아무 인자 없이 실행하는 경우 기본 대화형 인터프리터로 실행됩니다.
-d 디버그 출력을 제공합니다.
-O 최적화 된 바이트 코드 (.pyo 파일을 생성)를 생성합니다.
-S 시작시 Python 경로를 찾기 위해 "import site"를 실행하지 않도록 합니다.
-v 자세한 출력 (import 문의 세부 추적시 유용)
-c <cmd> cmd 문자열로 전송 된 Python script를 실행합니다.
<file> 주어진 파일에서 Python script를 실행합니다.

대화형 인터프리터 실행은 CLI상에서 "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.
>>> 


인터프리터의 프롬프트 (">>>") 상태에서 종료하려면 다음과 같은 방법 중 편한방법을 선택하여 종료할 수 있습니다.
  • Ctrl + Z (Windows 인 경우) 를 눌러 종료
  • Ctrl + D (Unix 계열인 경우) 를 눌러 종료
  • "quit()" 을 프롬프트상에 입력하고 Enter키를 눌러 종료
    $ 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키를 눌러 종료
    $ 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를 눌러 들여쓰기를 종료하는 식으로 입력할 수 있습니다.)
$ 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) 프로그램을 만듭니다.
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# vim: set fileencoding=UTF-8 :

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

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


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

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


구문이 간결한 경우 여러구문을 한줄로 작성
  • 세미콜론(';')을 줄바꿈 대신에 사용하여 여러구문을 한줄에 작성할 수 있습니다.
    >>> 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]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]Python Operators Precedence[])
연산자 우선순위
연산자(Operator) 설명(Description)
** 지수 제곱
~, +, ,- 단항 연산
*, /, %, // 산술 연산 곱하기, 나누기, 나머지, 몫
+, - 산술 연산 덧셈, 뺄셈
>>, << 비트 쉬프트
& 비트논리 AND
^, } 비트논리 XOR, OR
<=, <, >, >= 비교 연산
<>, ==, != 평등 연산
=, %=, /=, //=, -=, +=, *=, **= 할당 연산
is, is not 식별 연산
in, not in 멤버 연산
not, or, and 논리 연산

파이썬(Python) 2.x대 버전 과 3.x대 버젼간의 차이 (처음 파이썬을 배우는 분들은 3.x이상의 버젼을 기준으로 학습할 것을 권고하고 있습니다.)
  • 구문내에서 버젼을 확인하려면
    >>> 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 구문 사용에 강력한 주의가 필요
      >>> print "<문자열>" # 2.7 이하에서만 사용 가능 (3.X 이상에서는 오류)
      >>> print "<문자열>", # 줄바꿈 제거 기능으로 2.7 이하에서만 사용 가능 (3.X 이상에서는 오류)
      >>> print("<문자열>") # 2.7 이상부터만 사용 가능 (2.7 미만에서는 오류)
      >>> print("<문자열>",end="<줄바꿈 대체문자열>") # 줄바꿈 제거 또는 대체가 가능한 기능이며 3.X 이상부터만 사용 가능 (2.X 이하에서는 오류)
      
    • 줄바꿈을 제거하여 출력하려면 버젼에 따른 호환성 문제가 고민되어야 합니다.
      >>> 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 에서는...)
      >>>
      


1.4. 자료형


기본 자료형:
  • 정수(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도 아닌 또 다른 형입니다. 객체가 존재하지 않는 다는 것을 표현할 때 주로 사용합니다.
>>> type(None)
<class 'NoneType'>
>>>


[https]불변객체(Immutable Object)[]
  • 생성 후 그 상태를 바꿀 수 없는 객체
  • 외부에서 그 필드를 변경하는 방법이 존재하지 않고 가변적인 필드접근도 가지고 있지 않는 객체

[https]가변객체(Mutable Object)[]
  • 생성 후에도 상태를 변경할 수 있는 객체

파이썬(Python) 3.x 의 내장 자료형 요약 (참고: [https]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)


1.4.1. 숫자(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의 보수는 숫자형 앞에 '-'를 붙입니다.)

1.4.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]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가 아닌 경우만 <문자> 그 자체로 처리될 수 있음)

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


주의! 문자열과 숫자를 더하기('+') 연산하기 위해서는 문자열에 대한 더하기 인지 숫자에 대한 더하기 인지를 명확히 하도록 규정되어 있어 캐스팅(Casting)이 필요합니다.
>>> 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
>>>


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


문자열의 Methods (참고: [https]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은 문자열의 문자요소의 개수를 반환)
>>> a="Hello world"
>>> len(a)
11
>>>


문자열의 인덱싱 (Index번호는 0부터 시작, 문자열 인덱싱에서 문자열의 끝은 nul-terminate 문자를 가르키지 않음, 음수는 문자열의 끝부터 지정하며 -1부터 시작)
>>> 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(문자열)로 간주)
>>> 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]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 문자 % 자체
>>> 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]https://docs.python.org/3.4/library/string.html[])
  • 기본 '{' 와 '}' 사이에 사용되는 구문 형태
    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.
    
  • >>> 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)
>>> a="Hello world"
>>> a.count('l')
3
>>> a.count('k')
0
>>>


문자의 위치 확인 (find, index)
>>> 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)
>>> a=", "
>>> a.join("This")
'T, h, i, s'
>>>


문자열 대소문자 변환 (upper, lower)
>>> a="hi"
>>> a.upper()
'HI'
>>> a="HI"
>>> a.lower()
'hi'
>>>


문자열내의 공백 지우기 (lstrip, rstrip, strip)
>>> a="    hi    "
>>> a.lstrip()
'hi    '
>>> a.rstrip()
'    hi'
>>> a.strip()
'hi'
>>>


문자열의 치환 (replace)
>>> a="Life is too short"
>>> a.replace("Life", "Your leg")
'Your leg is too short'
>>>


문자열 나누기 (split)
>>> a="Life is too short"
>>> a.split() # 함수 인자가 비어 있으면 white space (공백, 탭, 줄 바꿈) 를 기준으로 나눕니다.
['Life', 'is', 'too', 'short']
>>> a="alpha:beta:tree:four"
>>> a.split(":")
['alpha', 'beta', 'tree', 'four']
>>>


1.4.3. 리스트(List, 목록) 자료형


어떤 요소값의 모음을 표현하기 위한 자료형을 리스트(List) 자료형이라고 합니다. 요소값은 숫자형, 문자열형, 리스트형등 어떠한 자료형이든 모두 혼용하여 가질 수 있습니다.
>>> <리스트명>=[<요소1>,<요소2>,<요소3>, ...] # '[', ']'으로 감싸주고 콤마(',') 문자로 구분하는 요소는 어떠한 자료형이든 가능

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

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

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

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


리스트(List)의 형태 예시
>>> 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]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)
>>> 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)의 덧셈
>>> 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)의 곱셈
>>> a=[1,2,'a']
>>> a*3
[1, 2, 'a', 1, 2, 'a', 1, 2, 'a']
>>>


리스트(List)의 값 수정하기
>>> 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)의 부분 삭제 또는 전체 삭제
>>> 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)
>>> 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)
>>> 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) - 정렬이 아니고 단순히 요소의 순서만 거꾸로 뒤집는 것임에 유의
>>> a=['Zebra', 'Apple', 'Beta', 'Three']
>>> a.reverse()
>>> a
['Three', 'Beta', 'Apple', 'Zebra']
>>>


리스트(List)에서의 위치 반환 (index)
>>> 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)
>>> a=[1,2,3]
>>> a.insert(0, 4) # 인덱스 0인 a[0] 앞에 값 4를 삽입
>>> a
[4, 1, 2, 3]
>>>


리스트(List)에서 지정한 요소값 첫 번째를 삭제 (remove)
>>> 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)
>>> 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)
>>> a=[1,2,3,1]
>>> a.count(1)
2
>>>


리스트(List)에 지정한 리스트를 더하기 (extend)
>>> 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]
>>>


1.4.4. 튜플(Tuple, 목록) 자료형


리스트(List)와 유사하지만 '[', ']' 가 아닌 '(', ')}'으로 둘러싸여 사용하며 튜플(Tuple)은 그 값을 바꿀 수 없습니다.

튜플(Tuple)의 형태 예시
>>> 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]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)으로 변환

1.4.5. 사전(Dictionary) 자료형


사전(딕셔너리)형 자료형은 리스트(List)나 튜플(Tuple)처럼 순차적인(Sequential) 접근법에 의해서 요소값을 구하지 않고 Key를 통해서 Value를 얻는게 특징입니다.
{<Key1>:<Value1>,<Key2>:<Value2>,<Key3>:<Value3>, ...} # Key는 변하지 않는 값이며 Value는 변하지 않는 값과 변하는 값 모두 사용 가능


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


사전(Dictionary)의 Function & Methods (참고: [https]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)의 쌍 추가 및 삭제
>>> 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를 얻는 방법 뿐!
>>> 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 사용시 어떤게 무시될 지 정의되지 않음
>>> a={1:'a', 1:'b'}
>>> a
{1: 'b'}
>>>


사전(Dictionary)의 Key로는 리스트(List)는 사용할 수 없으나 튜플(Tuple)은 사용가능
>>> 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)
>>> 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)
>>> 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)
>>> a.clear()
>>> a
{}
>>>


사전(Dictionary)의 Key로 Value 얻기 (get)
>>> 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
>>>


1.4.6. 집합(Set) 자료형


순서에 상관없이 중복된 값을 제거하는 특징을 갖는 집합(Set) 자료형은 교집합, 차집합, 합집합등을 구하기 위해서 유용한 자료형입니다.
<집합자료명>=set(<자료형>)


집합(Set)의 형태 예시
>>> 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함수를 통해서 리스트로 변환 후 접근해야 합니다.)
>>> 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'
>>>


교집합 구하기(&)
>>> 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])
>>>


합집합 구하기(|)
>>> 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])
>>>


차집합 구하기(-)
>>> 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)
>>> 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])
>>>


1.4.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) 연산
>>> 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)이 됩니다.

1.4.8. 자료형간의 변환(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)간의 연산은 오류입니다.
>>> 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'
>>>


각 자료형의 혼합형태에서 도출할 결과에 대한 오묘함을 회피하고 의도한 자료형으로 도출하기 위해서는 적절한 변환을 해야 합니다. 입력변수가 의도한 자료형이 아닐 수 있다면 명시적으로 변환을 하는게 좋습니다.
자료형의 변환함수
함수(Function) 설명(Description)
int(<값>[,<진수>]) 정수(Integer)로 변환
long(<값>[,<진수>]) 큰 정수(Long Integer)로 변환
float(<값>) 실수(Floating-point)로 변환
complex(<real>[,<imag>]) 복소수(Complex-number) 객체 생성
str(<값>) 문자열(String)로 변환
repr(<객체>) 객체를 표현식 문자열로 변환
eval(<string>) 문자열을 평가하여 객체로 반환
tuple(<집합형 값>) 튜플(Tuple)로 변환
list(<집합형 값>) 리스트(List)로 변환
set(<집합형 값>) 집합(Set)으로 변환
dict(<Key와 Value의 쌍으로 이루어진 튜플>) 사전(Dictionary)객체 생성
frozenset(<집합형 값>) frozen 집합(Set)으로 변환
chr(<값>) 정수(Integer)를 문자(Character)로 변환
unichr(<값>) 정수(Integer)를 유니코드(Unicode) 문자로 변환
ord(<값>) 하나의 문자(Character)를 정수(Integer)로 변환
hex(<값>) 정수(Integer)를 16진수 문자열로 변환
oct(<값>) 정수(Integer)를 8진수 문자열로 변환
bool(<값>) 값을 평가하여 참/거짓으로 반환

1.4.9. 자료형의 값을 저장하는 공간, 변수


자료형의 종류 확인 (정확히는 type 함수는 그 객체의 종류를 알려줍니다. 즉, 숫자 1도 객체로 다룹니다.)
>>> 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)입니다.
<변수명>=<변수에 저장할 값>


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

객체를 가르키는 레퍼런스(Reference) 개수를 확인. 이 값이 0이 될 때 메모리에서 해당 객체는 사라집니다. (Garbage collection 조건)
>>> 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
>>>


변수를 만드는 여러가지 방법
>>> 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)에 유의할 점.
>>> 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
>>>


1.5. 제어문


제어문에는 조건문인 "if"와 Loop 제어문인 "while" 및 "for" 가 있습니다.

제어문의 제어범위에 포함되려면 그에 해당하는 블록이 명확해야되는데 보통 들여쓰기로 이를 구분합니다. (간결한 블록의 경우는 들여쓰기 없이 제어문 바로 뒤에 작성되기도 합니다.)
<제어문> <조건>:
    <수행할 구문 #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)
break 루프(Loop) 문을 종료하고 루프 바로 다음 명령문으로 실행문맥을 이동합니다.
continue 루프(Loop)범위의 나머지 부분을 건너 뛰고 다시 반복하기 전에 즉시 조건을 다시 테스트하도록 문맥을 이동합니다.
pass 수행구문이 필요하지만 실행할 코드가 없는 경우가 있을 수 있는데 이 경우 아무것도 하지 않는다는 의미로 사용합니다.

1.5.1. if 문 (조건문)


CASE: 주어진 조건이 참(True)이면 A를 수행합니다.
if 조건문
[PNG image (13.93 KB)]
  • 형식
    if <조건>:
        <수행할 구문1>
        <수행할 구문2>
        <수행할 구문3>
        <...>
    
  • 예시
    >>> 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를 수행합니다.
if else 조건문
[PNG image (18.01 KB)]
  • 형식
    if <조건1>:
        <수행할 구문1-1>
        <수행할 구문1-2>
        <수행할 구문1-3>
        <...>
    else:
        <수행할 구문1>
        <수행할 구문2>
        <수행할 구문3>
        <...>
    
  • 예시
    >>> 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를 수행합니다.
if elif 조건문
[PNG image (29.54 KB)]
  • 형식
    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>
        <...>
    
  • 예시
    >>> money=2000 # 돈이 2000원 있음.
    >>> if money <= 0: # 돈이 없는가?
    ...     print("No money")
    ... elif money <=1000: # 1000원 미만인가?
    ...     print("껌하나 사먹을 수 있어요.")
    ... elif money > 2000: # 2000원 보다 많은가?
    ...     print("부자시네요.")
    ... else: # 그 외에 1000원 보다 많고 2000원 미만인가?
    ...     print("과자를 골라드세요.")
    ...
    과자를 골라드세요.
    >>>
    


CASE: 비교적 짧은 구문의 경우 들여쓰기 없이 작성될 수 있으며 여러 수행구문은 이 경우 세미콜론(';')으로 구분할 수 있습니다.
  • 형식
    if <조건>: <수행할 구문1>[;<수행할 구문n>]
    elif: <수행할 구문1>[;<수행할 구문n>]
    else: <수행할 구문1>[;<수행할 구문n>]
    
  • 예시
    >>> 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)을 활용할 수 있습니다. (보통은 대입할때 한줄로 표기할 수 있어 가독성 향상에 도움이 될 수 있습니다.)
  • 형식
    <참(True)일 때 구문> if <조건> else <거짓(False)일 때 구문>
    
  • 예시
    >>> money=2000
    >>> message="Have money %d won"%money if money > 0 else "No money"
    >>> print("%s"%message)
    Have money 2000 won
    >>>
    


1.5.2. while 문 (Loop 제어문)


CASE: 주어진 조건이 참(True)인 동안 A를 반복해서 수행합니다.
while loop 문
[PNG image (16.77 KB)]
  • 형식
    while <조건>:
        <수행할 구문1>
        <수행할 구문2>
        <수행할 구문3>
        <...>
    
  • 예시
    >>> 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를 벗어납니다.
while loop break
[PNG image (29.34 KB)]
  • 형식
    while <조건a>:
        <수행할 구문1>
        <수행할 구문2>
        <수행할 구문3>
        <...>
        if <조건i>:
            break;
        <수행할 구문4>
        <수행할 구문5>
        <수행할 구문6>
        <...>
    
  • 예시
    >>> 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조건부에서 다시 조건을 검사합니다.
while loop continue
[PNG image (29.95 KB)]
  • 형식
    while <조건a>:
        <수행할 구문1>
        <수행할 구문2>
        <수행할 구문3>
        <...>
        if <조건i>:
            continue;
        <수행할 구문4>
        <수행할 구문5>
        <수행할 구문6>
        <...>
    
  • 예시
    >>> 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
  • 예시
    >>> while True: # 조건이 항상 참(True)이기 때문에 break 구문이 없는 이상 이 loop는 무한합니다.
    ...     pass
    ...     # 빠져나올려면 Ctrl+C 키를 누르는 등의 방법을 사용해야 합니다.
    ...
    


1.5.3. for 문 (Loop 제어문)


CASE: 주어진 제어조건을 한번씩 순회하며 각각에 대하여 수행합니다. (while loop 문에서의 break와 continue 제어문을 for loop에서도 동일한 의미로 사용 가능합니다.)
  • 형식
    for <하나의 요소값을 가질 변수명> in <목록(List 또는 Tuple 또는 문자열)>
        <수행할 구문1>
        <수행할 구문2>
        <수행할 구문3>
        <...>
        if <조건b>:
            break;
        if <조건c>:
            continue;
        <수행할 구문4>
        <수행할 구문5>
        <수행할 구문6>
        <...>
    
  • 예시
    >>> 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>)" 와 함께 이를 해소가능합니다.
  • 예시
    >>> 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)할 수 있습니다. (규칙이 간결한 리스트 요소를 만들어 내는데 편리합니다.)
  • 형식
    [<수행할 구문> for <하나의 요소값을 가질 변수명> in <목록(List 또는 Tuple 또는 문자열)> {if <조건>} {중첩된 for...}]
    
  • 예시
    >>> 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문은 사용하는 방식의 편리성이 서로 다를 뿐이며 상호간 변환해서 구현이 가능합니다. 어느것을 사용하던 상관없으나 편리함의 특성에 따라서 상황에 맞는 방법을 찾아줄 것입니다.

1.6. 함수(Function)


반복적으로 사용되는 구문을 하나의 함수로 작성하고 반복사용하던 부분에서 함수를 사용하는 것으로 반복적인 구문을 줄이고 흐름을 깔끔하게 정리하는 방법

CASE: 특정 구문을 하나의 함수로 수행
  • 형식
    def <함수명>():
        <수행할 구문1>
        <수행할 구문2>
        <...>
    
  • 예시
    >>> def print_hello():
    ...     print("Hello world")
    ...
    >>> for i in range(3):
    ...     print_hello()
    ...
    Hello world
    Hello world
    Hello world
    >>>   
    


CASE: 함수에 인자를 주어 함수에 변화를 주는 수행
  • 형식
    def <함수명>([<인자1>[,<인자n>[...]]]):
        <수행할 구문1>
        <수행할 구문2>
        <...>
    
  • 예시
    >>> 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: 함수의 결과값을 통해서 수행하는 경우
  • 형식
    def <함수명>([<인자1>[,<인자n>[...]]]): # 인자가 필요 한 경우만 인자를 사용
        <수행할 구문1>
        <수행할 구문2>
        <...>
        return <결과값> # return 구문은 결과값이 있는 경우만 사용
    
  • 예시
    >>> 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: 가변인자를 튜플인자로 취하는 경우
  • 형식
    def <함수명>([<인자>,]*<가변인자명>):
        <수행할 구문1>
        <수행할 구문2>
        <...>
    
  • 예시
    >>> 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: 가변인자를 딕셔너리 자료로 취하는 경우
  • 형식
    def <함수명>([<인자>,]**<가변인자명>):
        <수행할 구문1>
        <수행할 구문2>
        <...>
    
  • 예시
    >>> def print_args(**args):
    ...     print(args)
    ...
    >>> print_args(a=1,b=2,c=3)
    {'a': 1, 'c': 3, 'b': 2}
    >>>
    


CASE: 초기값을 가진 인자의 사용 (오른쪽 인자부터 초기값을 줄 수 있습니다.)
  • 형식
    def <함수명>(<인자1>, <인자n-1>=<초기값>, <인자n>=<초기값>):
        <수행할 구문1>
        <수행할 구문2>
        <...>
    
  • 예시
    >>> 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: 함수내 변수의 유효범위
  • 함수내의 변수는 기본적으로 그 함수를 벗어나면 그 유효성이 상실되며 함수내의 변수는 그 밖의 변수와 이름이 같더라도 서로 다른 변수입니다.
    >>> a = 1
    >>> def my_value(a):
    ...     a = a + 100
    ...
    >>> my_value(a)
    >>> print(a)
    1
    >>>
    
  • 함부 밖의 변수를 함수내에서 접근하려면 global 키워드를 사용할 수 있습니다. (가급적이면 이 방법은 함수의 재진입 특성을 제한하기 때문에 권장하지 않습니다.)
    >>> a = 1
    >>> def my_value_is_global():
    ...     global a
    ...     a = a + 100
    ...
    >>> my_value_is_global()
    >>> print(a)
    101
    >>>
    


1.7. 입/출력(I/O)


1.8. 클래스(Class)


1.9. 모듈(Module)


1.10. 패키지(Package)


1.11. 예외처리(Exception)


1.12. 내장함수


1.13. 외장함수





/*

[ FrontPage | PrintView | RawView | RSS ]

Copyright ⓒ MINZKN.COM
All Rights Reserved.

MINZKN

----

*/