Python 문법정리

출처 : http://turing.cafe24.com/

자료정리 : 홍 지 영

 

I. 개발 환경 사용법

1. 인터프리터 모드

1.1 IDLE(Python GUI) 실행 : 인터프리터 모드로 실행된다.

- python Shell 이라는 창이 뜨며 여기서 인터프리터 모드로 작업할 수 있다.

- 인터프리터 모드에서는 한줄씩 실행된다.

- 디폴트 프롬프트는 ‘>>>’ 이다.

- 변수명을 치면 변수의 내용을 볼 수 있다.

- 함수, 제어문 등 여러 줄로 써야 하는 명령어를 쓰는 경우 프롬프트가 나오지 않고 indentation 된 상태에서 다음 입력을 기다린다. 입력이 끝나면 <엔터>를 한번 더 치면 프롬프트가 뜬다.

- 기존에 입력한 함수나 제어문을 다시 편집하려면 해당 함수 위치에 가서 더블클릭한다. 그러면 입력된 함수 전체가 창 하단에 다시 출력되고 커서가 그 안에 위치한다.

- Copy, Cut, Paste 가 가능하다. 단 indentation 에 주의해야 한다.

 

1.2 Python(Command Line ) 실행

- DOS 창 CommandLine에서 실행된다.

- 인터프리터 모드에서 실행된다.

 

2. 텍스트 파일의 편집과 실행

2.1 텍스트 파일의 편집

- 메모장과 같은 텍스트 편집기를 사용할 수 있다.

- python shell에서 기존 텍스트 파일을 open 하거나 New window를 선택하여 자체 편집기를 사용할 수도 있다.

- 편집이 완료되면 확장자를 'py' 로 하여 저장한다. (xxxx.py)

2.2 텍스트 파일의 실행

- 도스창에서 파이선 설치 디렉토리 (C:\python) 로 이동한 뒤 python <파일명> 으로 실행한다.

2.3 실행 파일로 컴파일

- py2exe 라는 툴을 사용해야만 컴파일 할 수 있다. (별도로 다운로드 해야 함.)

 

기본 문법

* 주석 입력 : ‘#’ 이후의 문장은 주석으로 인식

* 대소문자를 구별한다.

 

연산자

x**2 : x 의 제곱

x % 2 : x 를 2로 나눈 나머지

a == b : a는 b 와 같다

+ : 산술연산자, 문자열 결합 연산자

 

자료형

 

* 자료형 : 수치형(numbers), 순서형(sequence), 매핑형(mapping)

1. 수치형(numbers)

1) int : -21억 ~ +21 억 (32bit)

2) long int : +-922경(9.2*10^18,64bit) , 표기 : 접미사 L (예: 216800L)

3) float : 부동소숫점 수

2. 순서형(sequence) :

1) 문자열(string) : 홑따옴표와 겹따옴표를 모두 사용 가능

특수문자, 따옴표는 / 와 함께 입력 (예: /n 줄바꿈, /“ 따옴표 표시)

2) 리스트(list) : 대괄호([]) 사용, 엔티티의 집합.

예) a=[1,2,3,4,5]

3) 튜플(tuple) : 소괄호({}) 사용, 순서있는 집합(?) 예:(a,b)=(1,2) a와 b 각각 1,2 들어감

예) a=(1,2,3,4,5)

4) 사용자 정의 클래스

3. 매핑형(mapping)

1) 사전(dictionary) : 키(key) 와 내용의 쌍의 집합. 해쉬(키 탐색) 기능 있음.

2) 클래스 인스턴스

3) C 확장형

 

* 자료형의 확인 : Type 함수

>>> type('A') ==> <type 'string'> 문자열

>>> type(6) ==> <type 'int'>

>>> type(2.8) ==> <type 'float'>

>>> type(3+4j) ==> <type 'complex'> 복소수

>>> type([1, 2, 3, 4]) ==> <type 'list'>

 

* 자료형 변환

숫자형 => 스트링 : str()

>>>str(1)+str(2)

12

 

제어문

* 제어문은 조건식 뒤에 ‘:’을 붙여야 시작된다.

* 입력이 끝나는 지점은 indentation 을 한 단계 앞으로 줌으로써 확인된다.

 

<While>

num = 1

while num <= 100:

print num

num = num + 1

 

<IF>

>>> if c > d:

... print 'c > d'

... elif c == d:

... print 'c == d'

... else:

... print 'c < d'

...

 

 

<FOR>

for x in family: # family라는 리스트의 각각의 원소 x에 대하여:

print x, len(x) # x와 x의 길이를 출력하라.

for i in range(4,8): (4이상 8미만)

print i

 

함수

1. 일반 함수

def <함수명>(<매개변수1>,<매개변수2>,...) :

<Function:함수>

def function(x):

... a = 3

... b = 5

... y = a*x + b

... return y

: 정의 완료시 한줄 뗌, return 문을 만나면 함수 탈출

: 함수 정의는 호출 뒤에 해도 됨,

: 함수의 정의와 선언이 한꺼번에 이루어짐.

2. 인라인(?) 함수

labmda <값1>,<값2>...:<수행할 식> (<입력값1>,<입력값2>)

>>>(lambda x,y: x+y)(10, 20)

30

 

3. map 함수 : lambda 함수에 리스트를 적용

<map(함수,리스트)> : 함수에 리스트를 적용 리스트로 리턴

map(lambda x: x**2, range(5))

[0, 1, 4, 9, 16]

 

4. reduce 함수 : lamda 함수에 리스트를 적용하여 누적 결과 표시

<reduce(함수, 순서형 자료)> : 누적적용 수 리턴

>>> reduce(lambda x,y: x+y, [0,1,2,3,4])

10

>>> reduce(lambda x,y: y+x, 'abcde')

'edcba'

 

4. filter 함수 : 리스트를 입력으로 받아 조건식에 의해 filtering

<filter(함수, 리스트)> : 범위내만 리스트

>>> filter(lambda x: x<5, range(10))

[0, 1, 2, 3, 4]

>>> filter(lambda x: x%2, range(10)) # 홀수만돌려주기

[1, 3, 5, 7, 9]

 

 

문자열 처리

======= 문자열 처리 ==========

기본적으로 list 사용법에 준함

<부분문자열 표시>

>>> x="abcdef"

>>> x

'abcdef'

>>> x[0]

'a'

>>> x[1]

'b'

>>> x[1:3] #1번이상 3번‘미만’

'bc'

>>> x[:3] #처음부터 3번‘미만’까지

'abc'

>>> x[3:] #3번‘이후’부터 끝까지

'def'

 

<문자열 변경> banana => nanana

>>> x = 'n' + x[1:] # ‘n' + 1번 이후까지

>>> x

'nanana'

 

리스트 처리

* 정의하기 : a = ['a', 'b', 'c', 'd'] / a=[] 빈 리스트

* 요소의 개수 : len(a)

* 요소 출력 : a[2] : 3 번째 요소('c') 출력 (인덱스는 0부터 시작한다.)

* 요소 수정

a=[1,3,5,7] 일때

a[1] =9 ==> [1,9,5,7]

* 범위에 의한 리스트 생성 : range (n1이상,n2미만)

a=range(2,7) ==> [2, 3, 4, 5, 6]

a=range(5) ==> [0,1,2,3,4]

* 요소 추가 : append 메소드, 맨뒤에 추가

a=[1,3,5,7]

a.append(2) ==> [1, 3, 5, 7, 2]

* 특정 요소 삭제 : a.remove('a') => [‘b','c','d']

* 위치에 따른 요소 삭제 : del 명령

a=[1,3,5,7] 일때

del a[2] ==> [1, 3, 7]

* 소트 : sort() 메소드

a=[2,1,5,3] 일때 a.sort() ==> [1,2,3,5] # prime을 원소 크기 순으로 정렬

 

* 다차원 리스트

>>> orders = ['potato', ['pizza', 'Coke', 'salad'], 'hamburger']

>>> orders[1]

['pizza', 'Coke', 'salad']

>>> orders[1][2]

'salad'

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

 

* 문자열을 리스트로 변경

>>> list=[]

>>> string = 'Be happy!'

>>> for x in string:

list.append(x)

>>> print list

['B', 'e', ' ', 'h', 'a', 'p', 'p', 'y', '!']

 

튜플(Tuple) : '한 벌 이란 뜻‘

* 여러 개의 연속 수 나열의 대응관계를 지정(?)

<여러 변수 동시 지정>

(a,b)=(1,2) ==> a=1<엔터>b=2 와 같다.

<SWAP하기>

>>> c = 10

>>> d = 20

>>> c, d = d, c # 컴마만 있어도 튜플로 인식된다.

>>> print c,d

20 10

 

>>> def multi_print(x, y, *rest): # 마구찍어 함수 * 는 optional 한 입력을 뜻함

... print x, y, rest

...

>>> multi_print(1,2,3,5,6,7,9,10)

1 2 (3, 5, 6, 7, 9, 10)

 

==> (3...10) 은 튜플

 

>>> a = ('a', 'b', 'c')

>>> a = () ==> 원소가 없는 튜플

>>> a = 5, ==> 원소가 하나인 튜플 (컴마를 찍어야 튜플로 인식)

 

<수정>

>>> p = (1,2,3)

>>> q = p[:1] + (5,) + p[2:] ==> (1, 5, 3)

 

<튜플과 리스트를 상호전환>

>>> p = (1, 2, 3)

>>> q = list(p) # 튜플 p로 리스트 q를 만듦

[1, 2, 3]

>>> r = tuple(q) # 리스트 q로 튜플 r을 만듦

(1, 2, 3)

 

사전(Dictionary)

사전 자료형은 키 : 값의 쌍, 중괄호를 이용

>>> a={} # 빈 dictionary 정의

>>> a['dog']='bark' # dog 키에 bark 값 입력

>>> a['cat']='cat'

>>> a

{'dog': 'bark', 'cat': 'cat'} # 출력 형태

>>> a['dog'] # 키에 의한 값 찾기

'bark'

>>> a['cat']

'cat'

 

* 축약형 dictionary

>>> a = {'dog' : 'bark', 'cat' : 'meow'}

>>> a['dog'] # 포켓용 사전아, ‘python’이 뭐니??

'snake'

 

* 요소쌍 삭제

>>> del a['dog']

{'cat': 'meow'}

 

* key , value를 각각 리스트로 저장

>>> family = {'boy':'David', 'girl':'Eliza', 'baby':'Erasmus'}

>>> family # 값을 넣는 순서대로 저장되지는 않음.

{'baby': 'Erasmus', 'boy': 'David', 'girl': 'Eliza'}

 

>>> family.keys() # 사전 family의 key들을 새로운 리스트에 담는다.

['baby', 'boy', 'girl']

>>> family.values() # 사전 family의 값들을 새로운 리스트에 담는다.

['Erasmus', 'David', 'Eliza']

 

* key 검색 has_key : 사전에 어떤 키가 있는지? 있으면 1, 없으면 0

>>> family.has_key('boy') ==> 1

>>> family.has_key('sister') ==> 0

 

 

 

======= Stack ==========

<푸시:append>

>>> list=[]

>>> for i in range(5):

... list.append(i)

...

>>> list

[0, 1, 2, 3, 4]

<제거:pop>

>>> list.pop()

4

>>> list

[0, 1, 2, 3]

 

 

====== Queue ======

>>> list=['1', 'Python', 'Hahaha', 'Queue']

>>> list.pop(0)

'1'

>>> list

['Python', 'Hahaha', 'Queue']

 

 

===== DOS 창에서 입력받기 ========

c = raw_input() '숫자입력받기

 

 

======= 모듈 ========

>>> import math # math 모듈을 불러온다

>>> math.pi # math 모듈의 변수 pi의 값은?

3.1415926535897931

 

<달력>

>>> import calendar

>>> calendar.prmonth(2001, 6)

 

<GUI>

from Tkinter import *

widget = Label(None, text='I love Python!')

widget.pack()

 

<모듈의 위치>

Lib/calendar.py

<모듈 내 함수 호출>

>>>calendar.isleap(2000) # calendar 모듈의 isleap 함수를 호출

1

<모듈 사용>

import 모듈이름 ==> 모듈 전체 , 사용시 모듈명.함수명 형태로 써야 함.

from 모듈 import 변수나 함수 ==> 일부, 사용시 함수명만 사용가능

 

>>> import Tkinter

>>> Tkinter.widget = Tkinter.Label(None, text='I love Python!')

>>> Tkinter.widget.pack()

 

>>> from Tkinter import *

>>> widget = Label(None, text='I love Python!')

>>> widget.pack()

 

<모듈 제거>

del 모듈

<불러온 모듈 다시 불러오기>

reload(모듈)

 

<모듈 모음>

sys.ps1 : 프롬프트

sys.exit() : 끝내기

os.getcwd() # 현재 작업 디렉토리? =>'C:\CJKPython23'

os.listdir('c:\CJKPython23') # 현재 디렉토리의 파일 목록?

['LICENSE.txt', 'README.txt', 'NEWS.txt', 'py.ico'

>>> os.rename('README.txt', 'readme.txt') # README.txt를 readme.txt로 바

 

꿈

None

>>> import string

>>> string.capitalize('python') # 첫 글자를 대문자로

'Python'

>>> string.replace('simple', 'i', 'a') #‘simple’의 ‘i’를 ‘a’로

 

바꿈

'sample'

>>> string.split('break into words') # 문자열을 분리한 리스트 구함

['break', 'into', 'words']

 

< re(regular expression : 정규 표현식)모듈>

현재 디렉토리에서 p 다음에 n이 나오는 이름을 갖고 있는 파일들

마침표(.)는 문자 아무거나 한 개 별표(*)는 한 개 이상의 문자

 

>>> import re, glob

>>> p = re.compile('.*p.*n.*')

>>> for i in glob.glob('*'):

... m = p.match(i)

... if m:

... print m.group()

...

pycon.ico

python.exe

pythonw.exe

w9xpopen.exe

 

<webbrowser>

>>> import webbrowser

>>> url ='http://home.hanmir.com/~johnsonj/'

>>> webbrowser.open(url)

 

<Random>

>>> import random

>>> random.random()

0.90389642027948769

<randrange() >

>>> random.randrange(1, 7) # 1이상 7미만의 난수

6

<shuffle()> : 순서형 자료(sequence)를 섞어놓는 함수

>>> abc = ['a', 'b', 'c', 'd', 'e']

>>> random.shuffle(abc)

>>> abc

['a', 'd', 'e', 'b', 'c']

 

<choice() : 리스트에서 아무 원소나 하나 뽑아줌>

>>> abc=['e', 'd', 'a', 'c', 'b']

>>> random.choice(abc)

'a'

 

======== 파일 처리 ========

<Read> : Close 안해도됨

>>> f = open('c:/python21/exam/python.txt') # 파일을 열고

>>> f.read() # 읽어랑~

'Programming is fun.\nVery fun!\n\nYou have to do it yourself...'

>>> print buffer

Programming is fun.

Very fun!

 

<Write> Close 해야함

>>> f = open('c:\python21\exam\letter.txt', 'w') # 새 파일을 열고

>>> f.write('Dear Father,') # 아버님 전상서

>>> f.close() # 닫아준다

 

<Append>

>>> f = open('c:\python21\exam\letter.txt', 'a+')

 

<한줄씩>

>>> f = open('c:/python21/readme.txt')

>>> f.readline() # 한 줄 읽어~

'This is Python version 2.1\n'

>>> f.readline() # 한 줄 더 읽어~

'==========================\n'

>>> f = open('c:/python21/readme.txt')

 

<반복문 이용 컴마(,) 를 사용한것은 개행문자 중복때문>

>>> for x in range(5):

... line = f.readline()

... print line,

...

This is Python version 2.1.1

============================

 

<여러줄 한꺼번에>

>>> f=open('d:/python21/readme.txt')

>>> lines = f.readlines()

>>> import sys

>>> sys.stdout.writelines(lines[:5])

 

리스트에서 끝 원소의 인덱스는 -1

 

 

<pickle> 어떤 자료형이든 저장

>>> users = {'kim':'3kid9', 'sun80':'393948', 'ljm':'py90390'}

>>> f = open('d:/python21/exam/users.txt', 'w')

>>> import pickle

>>> pickle.dump(users, f)

>>> f.close()

 

>>> f = open('d:/python21/exam/users.txt')

>>> a = pickle.load(f)

>>> print a

{'sun80': '393948', 'kim': '3kid9', 'ljm': 'py90390'}

 

<glob> 파일 목록 기능

>>> import glob

>>> glob.glob('*.*')

['INSTALL.LOG', 'LICENSE.txt', 'NEWS.txt', 'py.ico', 'pyc.ico', 'pycon.ico',

 

'py

thon.exe', 'pythonw.exe', 'readme.txt', 'UNWISE.EXE', 'w9xpopen.exe']

>>> glob.glob('*.txt')

['LICENSE.txt', 'NEWS.txt', 'readme.txt']

 

<os.path 예제>

>>> import os.path

 

>>> files = glob.glob('*')

>>> for x in files:

... print x,

... if os.path.isdir(x): # 디렉토리인가?

... print '<DIR>'

... else:

... print ''