람다 함수


 람다 함수는 한 줄의 문(statement)으로 정의하는 함수로 축약 함수라고도 합니다.


- 람다 함수


1) 구문(Syntax)
 lambda 콤마로 구분된 인수들 : 식

2) 특징
 - 함수처럼 기본 인수와 가변 인수를 가질 수 있음
 - 대부분 함수 이름을 정하지 않고, 일회성으로 사용

3) 람다 함수 사용
 아래 코드와 같이 람다 함수를 사용하면 보다 쉽게 정의 및 사용할 수 있습니다. 1부터 10까지의 수를 대입해 각각 다항식을 계산하는 코드입니다.
----------------------------------------------------------------------------------------
# -*- coding: utf-8 -*-

# 일반 함수 사용

def f1(x):
    return x*x + 3*x -10
def f2(x):
    return x*x*x
def g(func):
    return [func(x) for x in range(1,11)]

print g(f1)
print g(f2)

# 람다 함수 사용

def g2(func):
    return [func(x) for x in range(1,11)]
print g2(lambda x: x*x + 3*x -10)
print g2(lambda x: x*x*x)
----------------------------------------------------------------------------------------
(실행 결과)

[-6, 0, 8, 18, 30, 44, 60, 78, 98, 120]

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

[-6, 0, 8, 18, 30, 44, 60, 78, 98, 120]

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

----------------------------------------------------------------------------------------

- 람다 함수의 활용


 람다 함수를 활용하는 방법입니다. map(), filter(), reduce() 세 내장 함수를 같이 활용합니다. 세 내장 함수는 공통적인 인자를 가집니다.

 - 첫 번째 인자 : function(함수) → 일반적으로 람다 함수 활용

 - 두 번째 인자 : 시퀀스 자료형 → 문자열, 리스트, 튜플 활용

1) map() 내장 함수

 - 구문(Syntax)
map(function, seq) 
# 각 원소 값들에 대해 함수에 적용한 결과를 동일한 자료형으로 반환

 - 활용
----------------------------------------------------------------------------------------
X=[1,2,3,4,5]
Y=map(lambda x:x*x, X) # X가 리스트이므로 결과도 리스트로 반환
print Y
----------------------------------------------------------------------------------------
(실행 결과)
[1, 4, 9, 16, 25]
----------------------------------------------------------------------------------------

2) filter() 내장 함수

 - 구문(Syntax)
filter(function, seq) 
# 각 원소 값들에 대해 함수에 적용한 결과 중 참인 원소 값들만 동일한 자료형으로 반환

 - 활용
----------------------------------------------------------------------------------------
F='python study'
G=filter(lambda x: x>'o', F) # 알파벳 o 보다 큰 문자만 반환
print G
----------------------------------------------------------------------------------------
(실행 결과)
pytstuy
----------------------------------------------------------------------------------------

3) reduce() 내장 함수

 - 구문(Syntax)
filter(function, seq, (initial)) 
# 각 원소 값들에 대해 함수에 적용하면서 하나의 값으로 매핑
# 람다 함수 인자가 반드시 2개여야하며, initial(초기값)은 앞의 인자의 초기 값

 - 활용
----------------------------------------------------------------------------------------
print reduce(lambda x,y : x+y, range(1,6))
----------------------------------------------------------------------------------------
 initial 즉 초기 값을 설정하지 않으면 0이 들어가게 됩니다. 앞의 인자에 결과를 임시 누적하면서 계속 뒤에 인자와 연산을하고 최종적으로 계산된 결과를 출력합니다.


(실행 결과)
15
----------------------------------------------------------------------------------------

- 활용2
 문자열의 초기값으로 n을 주고 거꾸로 뒤집은 결과입니다.
----------------------------------------------------------------------------------------
print reduce(lambda x,y : y+x, 'ohtyP','n')
----------------------------------------------------------------------------------------
(실행 결과)
Python
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍




'언어 > Python' 카테고리의 다른 글

[파이썬] 함수  (0) 2017.03.06
[파이썬] 디렉토리 다루기  (0) 2017.02.25
[파이썬] 파일 다루기  (0) 2017.02.24
[파이썬] 파일 입·출력  (0) 2017.02.22
[파이썬] 사전  (0) 2017.02.19

함수


 앞에서 공부할 때 활용했던 함수에 대해 자세히 알아보겠습니다.


- 함수의 정의


1) 함수란?
 여러 개의 statement를 하나로 묶은 단위

2) 함수의 장점
 - 반복 수행 가능
 - 코드의 일정 부분을 논리적으로 독립화 가능

3) 함수 정의
 함수는 def 키워드를 사용해 정의하며, return 키워드로 반환 값을 지정할 수 있습니다. 아무런 내용을 쓰지 않을 때에는 pass 키워드를 사용해야 합니다. 인자를 사용하지 않아도 괄호( )를 사용해야 합니다. 또한 콜론(:)을 꼭 붙여줘야 합니다.
----------------------------------------------------------------------------------------
# 함수 정의
def test_func():
pass

def add(a,b):
return a+b
----------------------------------------------------------------------------------------

- 함수의 호출과 인수 값 전달


1) 함수 호출
 파이썬에서는 모든 것들이 객체입니다. 따라서, 함수 이름 자체는 함수 객체의 레퍼런스를 지닙니다. 아래와 같이 참조 값을 복사해서 사용할 수 있습니다. 함수 호출은 함수 이름(인자)의 형태로 사용합니다.
----------------------------------------------------------------------------------------
# F_change 함수 정의
def F_change(a):
    print '썹씨를 화씨로 변환합니다.'
    print a*1.8+32
# F_change 함수 호출
F_change(15)

# a변수에 F_change 함수 레퍼런스를 복사한 후에 a변수를 이용해 F_change 함수 호출
a=F_change
a(15)
----------------------------------------------------------------------------------------
(실행 결과)
썹씨를 화씨로 변환합니다.
59.0
썹씨를 화씨로 변환합니다.
59.0
----------------------------------------------------------------------------------------

2) 인수 값 전달 방법
 다른 프로그래밍 언어를 공부해보신 분들은 아시겠지만, 인수를 전달하는 방식에는 값 전달 방식(Call-by-Value) 참조에 의한 호출 방식(Call-by-Reference)이 있습니다. 파이썬에서는 기본적으로 값 전달 방식이지만, 실제로는 참조에 의한 호출의 형태입니다.

3) 반환문
 return문을 사용해서 값을 반환하는데, return문이 없는 함수도 none객체가 반환이 됩니다. 두 개 이상의 값을 반환할 때에는 튜플로 반환됩니다. 
----------------------------------------------------------------------------------------
# 리턴 값을 튜플의 형태로 사용했을 때
def swap(a,b):
    return (b,a)

print swap(10,20)

# 리턴 값을 콤마(,)로만 사용했을 때
def swap2(a,b):
    return b,a

print swap2(10,20)
----------------------------------------------------------------------------------------
# 튜플의 특성으로 괄호를 사용하지 않으면 기본적으로 튜플이 됨
(실행 결과)
(20, 10)
(20, 10)
----------------------------------------------------------------------------------------

 추가적으로 인자에 대한 자료형 결정은 호출을 할 때 자료형의 타입에 따라 자료형이 결정됩니다.

- 함수의 인수처리

 
1)  기본 인자
 함수를 호출할 때 인수를 넘겨주지 않아도 인수가 가지는 값으로 기본 인수 값이라고 합니다. 일반 인자와 기본 인자가 같이 있다면 기본 인자는 가장 뒤에 와야 합니다. 함수를 호출할 때 인자가 있다면 호출할 때 사용한 인자를 더 우선합니다.
----------------------------------------------------------------------------------------
def add_10(a,b=10):
    return a+b
print add_10(15)   # 인자를 입력하지 않으면 기본인자와 연산
print add_10(15,9) # 기본인자보다 입력한 인자 9를 더 우선
----------------------------------------------------------------------------------------
(실행 결과)
25
24
----------------------------------------------------------------------------------------

2) 키워드 인수
 키워드 인수는 인자 값 전달시에 이름과 값을 전달하는 방식입니다. 키워드 인수 역시 기본 인자처럼 가장 마지막에 와야 합니다.
----------------------------------------------------------------------------------------
def area(width, column):
    return width*column

print area(20,column=5) # 이름과 값 전달
----------------------------------------------------------------------------------------
(실행 결과)
100
----------------------------------------------------------------------------------------

3) 가변 인수 리스트
 가변 인수는 변수 이름 앞에 *를 붙여서 사용합니다. 튜플 형태로 반환되며, 호출할 때 여러 개의 인자를 사용해도 튜플 형태로 반환해줍니다.
----------------------------------------------------------------------------------------
def var(a,*arg):
    print a,arg
    
var(1)
var(1,2)
var(5,6,7,8,9)
----------------------------------------------------------------------------------------
(실행 결과)
1 ()
1 (2,)
5 (6, 7, 8, 9)
----------------------------------------------------------------------------------------

 가변 인수를 사용하면 C언어 printf 함수와 유사하게 출력이 가능합니다.
----------------------------------------------------------------------------------------
# -*- coding: utf-8 -*-

def printf(format, *args):
    print format % args

printf("파이썬을 %d시간 공부하고, 운동을 %d분 했다.",2,30)
----------------------------------------------------------------------------------------
(실행 결과)
파이썬을 2시간 공부하고, 운동을 30분 했다.
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍



'언어 > Python' 카테고리의 다른 글

[파이썬] 람다 함수  (1) 2017.03.08
[파이썬] 디렉토리 다루기  (0) 2017.02.25
[파이썬] 파일 다루기  (0) 2017.02.24
[파이썬] 파일 입·출력  (0) 2017.02.22
[파이썬] 사전  (0) 2017.02.19

디렉토리 다루기


 이번에는 디렉토리를 다루는 방법에 대해 알아보겠습니다. 리눅스를 써보신 분들은 함수이름이 리눅스 명령어와 상당히 비슷하다고 느껴져서 쉽게 사용 할 수 있을 것입니다.


- 디렉토리와 관련된 일반 작업


1) 현재 작업 디렉토리 알아보기
앞에서 공부할때 계속해서 사용했던 os모듈의 getcwd()함수입니다.

2) 작업 디렉토리 변경하기
os모듈의 chdir(경로명) 함수를 사용해서 작업하는 디렉토리를 바꿀 수 있습니다.
----------------------------------------------------------------------------------------
import os
print os.getcwd()
os.chdir('D:/PythonProject/Python/13')
print os.getcwd()
----------------------------------------------------------------------------------------
D:\PythonProject\Python\14
D:\PythonProject\Python\13
----------------------------------------------------------------------------------------

3) 디렉토리 만들기
 디렉토리는 os모듈의 mkdir() 함수로 만들 수 있고, 권한을 부여하면서도 만들 수 있습니다. 재귀적으로 여러개의 디렉토리를 만드는 함수는 makedirs() 함수 입니다.
----------------------------------------------------------------------------------------
import os

os.mkdir('temp')
os.mkdir('temp2',0700)
os.makedirs('make/test1/test2')

print os.listdir('.')
----------------------------------------------------------------------------------------
(실행 결과)
['dir.py', 'end.txt', 'file.py', 'inout.py', 'make', 'out2.py', 'pickle.py', 'pickle.pyc', 'pickle.txt', 't.txt', 'temp', 'temp2']
----------------------------------------------------------------------------------------

4) 디렉토리 삭제
 디렉토리 삭제하는 함수는 os모듈의 rmdir()함수로 디렉토리 안에 내용이 있으면 에러가 발생합니다. 아래 코드에서는 make가 빈 디렉토리가 아니므로 에러가 발생했습니다.
----------------------------------------------------------------------------------------
import os
os.rmdir('temp2')
os.rmdir('make')
----------------------------------------------------------------------------------------
(실행 결과)
Traceback (most recent call last):
  File "D:\PythonProject\Python\14\dir.py", line 15, in <module>
    os.rmdir('make')
WindowsError: [Error 145] : 'make'
----------------------------------------------------------------------------------------

5) 다단계 디렉토리 삭제
 다단계 디렉토리를 삭제하는 함수는 os모듈의 removedirs() 함수와 shutill.rmtree() 함수가 있습니다. removedirs()함수는 가장 안쪽 디렉토리부터 삭제하며, 디렉토리에 다른 파일이 있으면 삭제하지않고 중단하는 반면, rmtree()함수는 파일은 물론 하위 디렉토리까지 모두 한번에 삭제하므로 조심해서 사용할 필요가 있습니다.
----------------------------------------------------------------------------------------
os.removedirs(디렉토리)
shutil.rmtree(디렉토리)
----------------------------------------------------------------------------------------

6) 디렉토리 복사
 디렉토리 복사 역시 파일 복사와 마찬가지로 shutil모듈을 이용합니다. shutil 모듈의 copytree() 함수를 이용하면 디렉토리를 복사할 수 있습니다.
----------------------------------------------------------------------------------------
shutil.copytree(src_filepath, dest_filepath)
----------------------------------------------------------------------------------------

- 디렉토리(트리) 탐색


디렉토리 탐색은 os모듈의 walk(filepath)함수를 이용합니다. filepath 부터 시작해서 재귀적으로 모든 하위 디렉토리까지 탐색합니다. 탐색 시 발견하는 모든 파일에 대해 아래와 같은 튜플을 반환합니다.
----------------------------------------------------------------------------------------
(dirpath, dirnames, filenames)
- dirpath : 탐색하고 있는 디렉토리 경로
- dirnames : dirpath안에 존재하는 서브 디렉토리의 리스트
- filenames : dirpath안에 존재하는 파일 리스트
----------------------------------------------------------------------------------------

 아래 코드는 for-in 문을 이용해서 현재 작업중인 경로를 탐색해서 경로, 디렉토리 이름, 파일이름 순으로 출력을 해보는 코드입니다.
----------------------------------------------------------------------------------------
import os

for dirpath, dirname, filename in os.walk(os.getcwd()):
    print dirpath,dirname,filename
----------------------------------------------------------------------------------------
(실행 결과)
D:\PythonProject\Python\14 ['make', 'temp'] ['dir.py', 'end.txt', 'file.py', 'inout.py', 'out2.py', 'pickle.py', 'pickle.pyc', 'pickle.txt', 't.txt']
D:\PythonProject\Python\14\make ['test1'] []
D:\PythonProject\Python\14\make\test1 ['test2'] []
D:\PythonProject\Python\14\make\test1\test2 [] []
D:\PythonProject\Python\14\temp ['test1'] []
D:\PythonProject\Python\14\temp\test1 ['test2'] []
D:\PythonProject\Python\14\temp\test1\test2 [] []
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍




'언어 > Python' 카테고리의 다른 글

[파이썬] 람다 함수  (1) 2017.03.08
[파이썬] 함수  (0) 2017.03.06
[파이썬] 파일 다루기  (0) 2017.02.24
[파이썬] 파일 입·출력  (0) 2017.02.22
[파이썬] 사전  (0) 2017.02.19

파일 다루기


 지난번에 공부했던 파일을 다루는 방법에대해 알아보겠습니다.

- 파일 목록 얻기


 앞에서는 os모듈의 getcwd() 함수를 이용해서 현재 작업중인 경로를 확인할 수 있었습니다. 이번에는 디렉토리에 존재하는 전체 내용을 list로 반환하는 함수에 대해 알아보겠습니다. os모듈의 listdir() 함수를 이용하면 현재 디렉토리에 존재하는 전체 내용을 리스트로 반환해줍니다.
----------------------------------------------------------------------------------------
import os

print os.listdir('.') # 현재 디렉토리 전체 -> .

print os.listdir('../') # 상위 디렉토리 전체 -> ../

----------------------------------------------------------------------------------------

(실행 결과)

['end.txt', 'file.py', 'inout.py', 'out2.py', 'pickle.py', 'pickle.pyc', 'pickle.txt', 't.txt']

['.project', '.pydevproject', '.settings', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13', '14']
----------------------------------------------------------------------------------------


- 파일 종류 알아보기


 파일의 종류를 알아보는 방법은 os.path 모듈의 세 가지 함수를 이용하는 것입니다. 각각 파일, 디렉토리, 링크파일(윈도우에서는 바로가기, 리눅스/유닉스에서는 심볼링링크 파일) 이면 True를 반환합니다.

----------------------------------------------------------------------------------------

def filetype(fpath): # 세 함수를 사용해서

    print fpath,':',

    if os.path.isfile(fpath): # 파일이면 True

        print "File"

    if os.path.isdir(fpath): # 디렉토리면 True

        print "Directory"

    if os.path.islink(fpath): # 링크파일이면 True

        print "Link File"  

        

list=os.listdir('.') # 현재 경로에있는 모든 파일을 탐색

for fname in list:

    filetype(fname)

----------------------------------------------------------------------------------------

(실행 결과)

end.txt : File

file.py : File

inout - 바로 가기.lnk : File # 왜 링크파일이 아니라 그냥 File로 출력되는 지 모르겠습니다.

inout.py : File

out2.py : File

pickle.py : File

pickle.pyc : File

pickle.txt : File

t.txt : File

----------------------------------------------------------------------------------------


- 파일의 허가권


 리눅스를 공부해본신 분들은 아시겠지만 파일이나 디렉토리에는 읽기, 쓰기, 실행 권한이 있습니다. 이러한 권한을 변경하는 함수가 있습니다. 역시 os 모듈의 chmod() 함수입니다. 리눅스에서 사용하는 chmod와 동일합니다. chmod(파일명,권한)의 형식으로 사용하며, 기본 권한은 755 (rwx-r-x-r-x)입니다. 허가 권은을 알아보는 함수는 access() 함수 입니다. 세부 내용은 아래와 같습니다.
----------------------------------------------------------------------------------------
os.access(filepath,mode)
# mode
- os.F_OK : 파일 자체가 존재하는 지 확인
- os.R_OK : 읽기 권한이 있는 지 확인
- os.W_OK : 쓰기 권한이 있는 지 확인
- os.R_OK : 실행 권한이 있는 지 확인

----------------------------------------------------------------------------------------


 리눅스 처럼 rwx를 출력하는 코드를 짜봤습니다. 함수를 정의 할때에는 줄을 띄어쓰지 않도록 주의해야 합니다.

----------------------------------------------------------------------------------------

import os


def fileaccess(fpath): # 권한을 알아보는 함수 정의

    print fpath,':',

    if os.access(fpath,os.R_OK): # 읽기 권한이 있으면 r출력

        print 'r',

    if os.access(fpath,os.W_OK): # 쓰기 권한이 있으면 w출력

        print 'w',

    if os.access(fpath,os.X_OK): # 실행 권한이 있으면 x출력

        print 'x',

    print

    

flist=os.listdir('.')

for fname in flist:

    fileaccess(fname)

----------------------------------------------------------------------------------------

(실행 결과)

end.txt : r w x

file.py : r w x

inout - 바로 가기.lnk : r w x

inout.py : r w x

out2.py : r w x

pickle.py : r w x

pickle.pyc : r w x

pickle.txt : r w x

t.txt : r w x

----------------------------------------------------------------------------------------


 위의 결과를 보면 전부 기본 권한인 777권한인데요 chmod 함수로 권한을 한번 바꿔보겠습니다. 위의 코드에서 chmod를 사용 한 뒤에 다시 출력을 했을때의 결과입니다.

----------------------------------------------------------------------------------------

os.chmod('t.txt',0555) # r=1, w=2, x=4 

flist=os.listdir('.')

for fname in flist:

    fileaccess(fname)

----------------------------------------------------------------------------------------

t.txt : r x # 권한이 바뀐 걸 확인할 수 있습니다.

----------------------------------------------------------------------------------------


- 파일 조작


1) 파일 이름 변경/이동
 os 모듈의 rename()함수를 이용해 파일 이름을 변경하거나, 이동할 수있습니다.
----------------------------------------------------------------------------------------
os.rename(old_filepath,new_filepath)
old_filepath 에는 경로 뿐만아니라 파일 이름자체를 넣어도 됩니다.

new_filepath 에 새 파일 이름을 넣으면 파일 이름이 변경되고,
    새 파일 이름 앞에 경로까지 넣어주면 파일 이동이 됩니다.
----------------------------------------------------------------------------------------

2) 파일 복사하기
 파일 복사는 shutil 모듈을 활용합니다. shutil 모듈의 copyfile()함수를 이용하면 파일을 복사 할 수 있습니다.
----------------------------------------------------------------------------------------
shutil.copyfile(src_filepath, dest_filepath)
----------------------------------------------------------------------------------------

- 파일 이름 다루기


----------------------------------------------------------------------------------------

1) 상대 경로를 절대 경로로 변환하기

os.path.abspath(상대경로)

# 실제 파일 존재와는 무관하게 절대경로로 변경됨


2) 주어진 경로의 파일이 존재하는지 확인

os.path.exists(filapath)


3) 현재/부모 디렉토리를 가리키는 이름 얻기

os.curdir # 현재 디렉토리

os.pardir # 부모 디렉토리


4) 디렉토리 분리 문자 얻기

os.sep # 이클립스에서는 슬래시(/)

----------------------------------------------------------------------------------------


- 경로명 분리하기


1) 경로와 파일명으로 분리하기

 os.path 모듈의 basename() 함수와 dirname()함수를 이용합니다. 파일의 존재 유무와는 상관이 없습니다.

----------------------------------------------------------------------------------------

import os

f='D:/PythonProject/Python/14/test.py' # test.py는 존재하지 않음

print os.path.basename(f) # 파일명

print os.path.dirname(f) # 디렉토리 경로

----------------------------------------------------------------------------------------

(실행 결과)

test.py

D:/PythonProject/Python/14

----------------------------------------------------------------------------------------


2) 경로명과 파일명을 한번에 분리하기

 os.path 모듈의 split() 함수를 이용하며, 튜플의 형태로 반환됩니다.

----------------------------------------------------------------------------------------

import os

f='D:/PythonProject/Python/14/test.py' # test.py는 존재하지 않음

print os.path.split(f)

----------------------------------------------------------------------------------------

(실행 결과)

('D:/PythonProject/Python/14', 'test.py')

----------------------------------------------------------------------------------------

3) 확장자 분리

 os.path 모듈의 splitext() 함수를 이용하며, 튜플의 형태로 반환됩니다.

----------------------------------------------------------------------------------------
import os

f='D:/PythonProject/Python/14/test.py' # test.py는 존재하지 않음

print os.path.splitext(f)
----------------------------------------------------------------------------------------
('D:/PythonProject/Python/14/test', '.py')
----------------------------------------------------------------------------------------


출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍


'언어 > Python' 카테고리의 다른 글

[파이썬] 함수  (0) 2017.03.06
[파이썬] 디렉토리 다루기  (0) 2017.02.25
[파이썬] 파일 입·출력  (0) 2017.02.22
[파이썬] 사전  (0) 2017.02.19
[파이썬] 튜플과 집합자료형  (0) 2017.02.14

파일 입·출력


 지금까지 공부하면서 짰던 코드들은 프로그램이 종료되면 그대로 종료됩니다. 출력하는 내용이나 코드를 파일로 저장하고 읽어오면 다시 사용할 수 있겠죠? 파일 입·력은 파일을 열어서 쓰고 덧붙이는 방법으로, 다른 프로그래밍 언어와 유사한 형태로 사용합니다. 

- open() 내장 함수


 파일 입출력은 open()이라는 내장함수를 이용하고, 사용이 끝나면 close() 함수로 종료를 해줘야 합니다. close() 쓰지않아도 자동으로 자원을 반납하지만, 코드의 가독성을 위해서라도 써주는게 좋다고합니다. 

 아래 내용은 open() 내장 함수의 세부적인 내용입니다.
----------------------------------------------------------------------------------------

- open("filename",'mode')


- open()함수의 모드

1. 'r'(read) : 생략을 하면 기본적으로 사용되는 모드로, 읽기 전용모드, 파일 포인터를 처음위치에 놓음

2. 'w'(write) : 쓰기모드로 존재하지 않는 파일은 생성하고, 존재하는 파일내용을 모두 지우고 파일포인터를 처음위치에 놓음

3. 'a'(append) : 이미 존재하는 파일 뒤쪽에 내용을 추가, 파일 포인터를 파일의 마지막 위치에 놓음


- 이진 파일로 저장하기 위한 모드

1. rb

2. wb

3. ab

----------------------------------------------------------------------------------------


- 파일 쓰기


 파일을 쓰기에 앞서 현재 작업중인 디렉토리를 알아보는 명령을 알아보겠습니다. os모듈을 임포트하고 getcwd() 함수를 이용하면 현재 작업중인 디렉토리를 확인할 수 있습니다. 파일 쓰게되면 같은 경로에 파일이 생기게됩니다.

----------------------------------------------------------------------------------------

import os

print os.getcwd() # 현재 작업중인 디렉토리를 알아보는 함수

----------------------------------------------------------------------------------------
(실행 결과)

D:\PythonProject\Python\13

----------------------------------------------------------------------------------------


 open() 내장 함수를 이용해 파일 쓰기를 해 보겠습니다. 파일에 쓰기위해서는 write()메소드를 활용 합니다.
----------------------------------------------------------------------------------------
s='''애써 미안한 표정 하지마
싫어진 거잖아 이제 널 떠나줄게
비겁해지는 널 보는 게 아파
내가 갈게 널 보내줄게
-권진아 끝 中에서- '''

f=open('end.txt','w') # 'end.txt' 쓰기모드로 열기
f.write(s) # s 문자열을 파일에 써줌
f.close() # 자원 반납
----------------------------------------------------------------------------------------
 위 코드를 실행하면, 이클립스 콘솔창에는 아무런 내용이 출력되지 않습니다. 작업중인 코드의 경로에 가면 텍스트 파일이 하나 생성되어 있습니다. 


- 파일 읽기


이번에는 이클립스에서 텍스트 파일을 읽어보겠습니다. 파일을 읽을때에는 read()메소드를 이용합니다.

----------------------------------------------------------------------------------------
f=open('end.txt') # 모드 생략 시 읽기 모드
s2=f.read()
print s2
----------------------------------------------------------------------------------------
(실행 결과)
애써 미안한 표정 하지마
싫어진 거잖아 이제 널 떠나줄게
비겁해지는 널 보는 게 아파
내가 갈게 널 보내줄게
-권진아 끝 中에서- 
----------------------------------------------------------------------------------------


- 라인단위로 파일 읽기/쓰기


 파일을 읽을때 라인단위로 읽을 수가 있습니다. 라인 단위로 읽는 방법은 총 4가지가 있습니다.


1. 객체 반복자 사용

 아래와 같이 for-in 문을 이용해서 라인 단위로 출력이 가능합니다. 파일을 라인단위로 읽을때 가장 효율적인 방법이라고 합니다.

----------------------------------------------------------------------------------------
f=open('end.txt')

i=1

for line in f:

    print i,":",line,

    i+=1

f.close()

----------------------------------------------------------------------------------------
(실행 결과)
1 : 애써 미안한 표정 하지마
2 : 싫어진 거잖아 이제 널 떠나줄게
3 : 비겁해지는 널 보는 게 아파
4 : 내가 갈게 널 보내줄게
5 : -권진아 끝 中에서- 
----------------------------------------------------------------------------------------

2. readline() 사용
 readline()을 사용할때에는 while문을 이용합니다. 현재의 파일포인터에서 개행문자까지 읽어줍니다. 아래코드에서는 줄바꿈을 개행문자로 인지합니다. 실행 결과는 위와 동일합니다.
----------------------------------------------------------------------------------------
f=open('end.txt')
line=f.readline()
i=1
while line:
    print i,":",line,
    line=f.readline() # 파일 포인터가 개행문자 다음의 가장 처음에 위치합니다.
    i+=1
f.close()
----------------------------------------------------------------------------------------


3. readlines() 사용

 각 라인을 모두 읽어서 메모리에 리스트 형태로 저장합니다. 라인이 100줄 1000줄이면 메모리를 굉장히 비효율적으로 사용하게 됩니다. 한글이여서 아스키코드로 변화해서 저장되는걸 확인 할 수 있습니다.

----------------------------------------------------------------------------------------
f=open('end.txt')

print f.readlines() # 리스트로 저장

print # 한줄 개행


f.seek(0) # 파일포인터를 처음으로 되돌려줌

i=1


for line in f:

    print i,":",line,

    i+=1

f.close()

----------------------------------------------------------------------------------------
(실행 결과)
['\xec\x95\xa0\xec\x8d\xa8 \xeb\xaf\xb8\xec\x95\x88\xed\x95\x9c \xed\x91\x9c\xec\xa0\x95 \xed\x95\x98\xec\xa7\x80\xeb\xa7\x88\n', '\xec\x8b\xab\xec\x96\xb4\xec\xa7\x84 \xea\xb1\xb0\xec\x9e\x96\xec\x95\x84 \xec\x9d\xb4\xec\xa0\x9c \xeb\x84\x90 \xeb\x96\xa0\xeb\x82\x98\xec\xa4\x84\xea\xb2\x8c\n', '\xeb\xb9\x84\xea\xb2\x81\xed\x95\xb4\xec\xa7\x80\xeb\x8a\x94 \xeb\x84\x90 \xeb\xb3\xb4\xeb\x8a\x94 \xea\xb2\x8c \xec\x95\x84\xed\x8c\x8c\n', '\xeb\x82\xb4\xea\xb0\x80 \xea\xb0\x88\xea\xb2\x8c \xeb\x84\x90 \xeb\xb3\xb4\xeb\x82\xb4\xec\xa4\x84\xea\xb2\x8c\n', '-\xea\xb6\x8c\xec\xa7\x84\xec\x95\x84 \xeb\x81\x9d \xe4\xb8\xad\xec\x97\x90\xec\x84\x9c- ']

1 : 애써 미안한 표정 하지마
2 : 싫어진 거잖아 이제 널 떠나줄게
3 : 비겁해지는 널 보는 게 아파
4 : 내가 갈게 널 보내줄게
5 : -권진아 끝 中에서- 
----------------------------------------------------------------------------------------

4. xreadlines() 사용

 위의 readlines()의 메모리 비효율성을 개선할 수 있는 함수입니다. 리스트가 반환되지 않고, 파일 객체 내용이 찍힙니다. 사용과 실행 결과는 위와 동일합니다.



 그렇다면, 반대로 라인단위로 파일 쓰는건 어떻게 할까요? 이미 위에서 사용했던 write() 함수와 wrtielines() 함수가 있습니다. 라인단위로 파일을 쓸때에는개행문자(\n)를 꼭 써줘야 합니다.

----------------------------------------------------------------------------------------

f=open("end.txt",'a') # 기존 파일에 내용 추가

f.writelines('\n\n')

f.writelines('오늘은 2월 22일 \n')

f.writelines('하루종일 날씨가 흐리다.\n')

f.writelines('얼른 봄이 왔으면 좋겠다.\n')

f.close()


f=open('end.txt')

print f.read()

----------------------------------------------------------------------------------------

(실행 결과)

애써 미안한 표정 하지마

싫어진 거잖아 이제 널 떠나줄게

비겁해지는 널 보는 게 아파

내가 갈게 널 보내줄게

-권진아 끝 中에서- 


오늘은 2월 22일 

하루종일 날씨가 흐리다.

얼른 봄이 왔으면 좋겠다.

----------------------------------------------------------------------------------------


- 파일 내 임의 위치로 접근


 위에서 몇번 언급한 파일포인터는 파일 내에서 현재 위치를 가리키고 있습니다. 이때 seek(5)를 하면 문자열의 5번째 인덱스를 가리키게 됩니다.

 tell()을 사용하면 현재 위치를 돌려주고, read(1)을 사용하게되면 현재 위치에서 문자하나를 읽고나서 파일포인터를 하나 이동합니다.


- 표준 출력 방향 전환


 일반적으로 print 함수를 사용하게되면 문자열을 화면(콘솔)에 출력하게됩니다. sys 모듈의 sys.stdout의 표준출력이 정해져있기 때문인데, 이를 바꿔주면 print함수를 사용하면 바꿔준 형태로 실행이 됩니다.

 아래 코드는 표준출력을 파일에 저장하는것으로 바꾸고 실행 후 다시 되돌리는 코드입니다.

----------------------------------------------------------------------------------------

# -*- coding: utf-8 -*-


import sys

f=open('t.txt','w')

stdout=sys.stdout # 표준출력 저장(백업 개념)

sys.stdout=f


print '테스트 메시지1'

print '테스트 메시지2'

print '테스트 메시지3'


f.close()

sys.stdout=stdout # 다시 원상태로 되돌려줌

----------------------------------------------------------------------------------------

 아래와같이 화면(콘솔)에 출력되는것이 아니라 't.txt'파일에 문자열이 써집니다.


 이밖에도 sys모듈에는 sys.stderr(표준 에러출력)과 sys.stdin(표준 입력)이 있습니다. stderr을 변경하면, 에러메시지 처럼 콘솔창에 빨간색 글씨로 출력이 됩니다.


- StringIO 모듈 사용

 StringIO 모듈의 StringIO 클래스 객체는 사용하면, 파일 객체처럼 입출력 가능한  문자열 객체로, StringIO에 지원되는 메소드는 파일 객체가 지원하는 메소드와 거의 유사합니다. 메소드중에서 getvalue() 메소드가 있는데 현재까지 담아 놓은 전체 내용을 반환하는 메소드입니다.

----------------------------------------------------------------------------------------

import StringIO


f=StringIO.StringIO()

f.write('abc')

f.seek(0)

s=f.read()

print s


f.write('def')

s2=f.getvalue()

print s2

----------------------------------------------------------------------------------------

(실행 결과)

abc

abcdef

----------------------------------------------------------------------------------------


- 파일로의 지속 모듈


- 지속성 : 프로그램 내에 생성된 각종 객체들을 해당 프로그램 종료이후에도 존재하게 만들고, 그것들을 동일한 또는 다른 프로그램에서 사용하는 기능

- 지속성 기능을 지원하는 모듈

DBM 관련 모듈 : anydbm, dbm, gdbm, dbhash, dumbdbm

pickling 모듈 : 파이썬의 객체를 저장하는 일반화된 지속성 모듈


 pickling 모듈이 좀 더 일반적으로 사용한다고해서 pickle모듈만 사용해 봤습니다. 이클립스에서는 에러가 발생해서 Enthought Canopy로 실습을 진행했습니다.

----------------------------------------------------------------------------------------

import pickle


color={'r':'red','g':'green','b':'blue'}

fruits=['banana','apple','grape']

Tuple=(color,fruits)


f=open('pickle.txt','w')


pickle.dump(Tuple,f) # 저장하고자 하는 Tuple을 f에 넣어서 얼림

f.close()


####################################


f=open('pickle.txt')


x,y=pickle.load(f) # dump()와 반대

print x

print y

----------------------------------------------------------------------------------------




출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍




'언어 > Python' 카테고리의 다른 글

[파이썬] 디렉토리 다루기  (0) 2017.02.25
[파이썬] 파일 다루기  (0) 2017.02.24
[파이썬] 사전  (0) 2017.02.19
[파이썬] 튜플과 집합자료형  (0) 2017.02.14
[파이썬] 리스트 활용  (4) 2017.02.07

사전


 앞에서 공부할때 이미 여러번 사용했던 사전은, 리스트나 튜플만큼 많이 사용하는 자료구조입니다. 사전에 대해 자세히 알아보겠습니다. 사전은 키를 이용하여 값을 저장하는 구조로, 순서를 정하지 않는 매핑형 자료구조 입니다.

- 사전의 특징과 활용

----------------------------------------------------------------------------------------

1. 키(key)와 값(value)

- 키는 변경 불가능한 자료만 사용 가능 -> 리스트와 사전은 사용 불가

- 값은 변경 가능한 자료도 사용이 가능하며, 키와 값을 묶어서 아이템(item)이라고 부르며 콤마(,) 단위로 구분

- 아이템의 수 : 사전 원소 개수

2. 사전의 새로운 원소 추가/변경 및 삭제

- 추가 : 사전이름['추가할 키 이름']=값

- 변경 : 사전이름['변경할 키 이름']=값

- 삭제 : del 사전이름[키]

# 내장함수

3. dict() 내장 함수를 이용한 사전생성

- dict() : 비어있는 사전 생성

- dict(키1=값1, 키2=값2)

4. zip() 내장 함수 : 두 개의 자료를 순서대로 쌍으로 묶은 튜플들의 리스트를 반환

----------------------------------------------------------------------------------------


- 사전 메소드

----------------------------------------------------------------------------------------

1. D.keys() : 키들을 리스트로 반환
2. D.values() : 값들을 리스트로 반환
3. D.items() : 각 아이템을 튜플형태로 가져와 리스트로 반환
4. D.copy() : 사전을 복사(별도의 객체)
 이때, copy는 shallow copy로 정수나 리스트는 복사하지만, 리스트 원소를 가리키는 레퍼런스는 공유
5. D.get(키) : 키 값에 대한 값 검색, 키가 없다면 none반환
  사전이름[키] 형태로도 검색이 가능함(키가 없다면 에러발생)
6. D.pop(키) : 해당하는 아이템을 꺼냄
7. D.poptiem() : 임의의 아이템을 꺼냄
8. D.update(복사할 사전이름) : 복사할 사전의 아이템을 사전 D에 전부 넣어줌
9. D.clear() : 사전 전체의 내용을 지움
----------------------------------------------------------------------------------------

- 루프를 이용한 사전 내용 참조

 사전 내용 참조는 for in 문을 이용합니다. 

# 순차적으로 참조
----------------------------------------------------------------------------------------
dc=dict({'two':2,'three':3,'one':1})

for key in dc:
    print key,dc[key]
----------------------------------------------------------------------------------------
(실행 결과)
three 3
two 2
one 1

----------------------------------------------------------------------------------------


# 키, 값 동시 참조 - items()메소드 이용
----------------------------------------------------------------------------------------
dc=dict({'two':2,'three':3,'one':1})

for key,value in dc.items():
    print key,value
----------------------------------------------------------------------------------------
(실행 결과)
three 3
two 2
one 1
----------------------------------------------------------------------------------------

# 정렬 - sort()메소드 이용
----------------------------------------------------------------------------------------
dc=dict({'b':2,'c':3,'a':1})
    
items=dc.items()
print items

items.sort() # 정렬
print items

for k,v in items:
    print k,v
----------------------------------------------------------------------------------------
[('a', 1), ('c', 3), ('b', 2)]
[('a', 1), ('b', 2), ('c', 3)]
a 1
b 2
c 3
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍


'언어 > Python' 카테고리의 다른 글

[파이썬] 파일 다루기  (0) 2017.02.24
[파이썬] 파일 입·출력  (0) 2017.02.22
[파이썬] 튜플과 집합자료형  (0) 2017.02.14
[파이썬] 리스트 활용  (4) 2017.02.07
[파이썬] 리스트와 리스트 메소드  (0) 2017.02.05

튜플과 집합


 이번에는 리스트와 같은 시퀀스 자료형인 튜플과 set을 이용한 새로운 자료형인 집합 자료형에대해 알아보겠습니다.

- 튜플

 
 튜플은 시퀀스 자료형으로 아래와 같은 특징들이 있습니다.

----------------------------------------------------------------------------------------

# 튜플의 특징

- 순서 있는 임의의 객체 모음

- 인덱싱, 슬라이싱, 연결, 반복, 멤버십 테스트 연산 가능

- 리스트와는 다르게 변경이 불가능

- 괄호를 생략가능 

   t=1,2,3 과 같이 생성하면 t는 자동적으로 튜플이 됨

- 자료가 하나인 경우 콤마(,)를 사용해야함

   t2=(1,) 또는 t2=1,

   t=(1)과같 이사용하면 튜플이 아니라 int형이 됨

- 연산을 할 경우 변경이 되지않고 새로운 튜플을 반환하는 개념

- 변수의 값 치환가능

- 리스트와는 다르게 메소드를 가지지않음


# 튜플의 사용 용도

- 함수가 두개 이상의 값을 리턴하는 경우

- 문자열 포멧팅

- 고정된 값을 쌍으로 표현하는 경우

  {'one':1,'two':2}과 같은 사전이 있을 경우 [('two',2),('one',1)] 과같이 표현됨

----------------------------------------------------------------------------------------


- 패킹, 언패킹


 위의 튜플들의 특징을 이용해 패킹과 언패킹을 수행 할 수있습니다. 리스트로도 패킹, 언패킹이 가능하지만, 보통 튜플을 이용합니다.


- 패킹 : 하나의 튜플 안에 여러 데이터를 넣는작업

- 언패킹 : 하나의 튜플에서 여러개의 데이터를 꺼내와 각각 변수에 할당하는 작업

----------------------------------------------------------------------------------------

# -*- coding: utf-8 -*-


# 패킹

p=1,2,'abc'

print p


# 언패킹

x,y,z=p

print x,y,z

----------------------------------------------------------------------------------------

(실행 결과)

(1, 2, 'abc')

1 2 abc

----------------------------------------------------------------------------------------

 추가적으로, 튜플과 리스트는 각각 list(), tuple() 내장 함수로 상호 변환이 가능합니다. 아래 코드는 상호 변환을 통해 튜플의 값을 변환 한 코드입니다.
----------------------------------------------------------------------------------------
T=1,2,3,4,5
L=list(T)
print L
L[0]=6
T=tuple(L)
print T
----------------------------------------------------------------------------------------
(실행 결과)
[1, 2, 3, 4, 5]
(6, 2, 3, 4, 5)
----------------------------------------------------------------------------------------

- 집합 자료형


 집합 자료형은 set() 내장 함수를 사용하는 자료형으로 변경이 가능하고, 각 원소간에 순서가 없어서 중복이 불가능한 자료형입니다. 따라서, 시퀀스 자료형 처럼 인덱싱이나 슬라이싱이 불가능합니다.
 set()내장함수의 인자로는 리스트, 튜플, 사전, 문자열이 사용 가능하며, 문자열은 'abc'일경우 a,b,c 각각 저장됩니다.
 사전의 경우 key값만 저장되며 value만을 저장하고 싶을때는 .vlaues() 메소드를 사용합니다. 집합 자료형의 생성은 아래와 같습니다.
----------------------------------------------------------------------------------------
# 집합 자료형 생성
a=set([(1,2,3)])
print type(a)
print a

b=set('abc')
print type(b)
print b

c=set({'one':1,'two':2})
print type(c)
print c

# 빈 set 객체 생성
d=set()
print d
----------------------------------------------------------------------------------------
(실행 결과)
<type 'set'>
set([(1, 2, 3)])
<type 'set'>
set(['a', 'c', 'b'])
<type 'set'>
set(['two', 'one'])
set([])
----------------------------------------------------------------------------------------

- set의 기본연산과 메소드


 set을 이용해 할 수 있는 연산은 len()을 이용해 집합의 원소의 수를 알수있는 것과, 멤버십 테스트(in, not in) 연산이 있습니다.

 set의 주요 메소드는 다음과 같습니다. 수학시간에 배운 집합을 생각하시면 편합니다. 새로운 집합을 반환하는 메소드와 기존 집합을 변경하는 메소드로 나뉩니다.
----------------------------------------------------------------------------------------
# 새로운 집합을 반환하는 메소드
1. issubset() : 부분집합인지 알아보는 메소드
   s<=t
2. issuperset() : 슈퍼집합인지(포함 하는지) 알아보는 메소드
   s>=t
3. uion() : 새로운 집합과 합집합을 반환하는 메소드
   s|t
4. intersection() : 새로운 집합과 교집합을 반환하는 메소드
   s&t
5. difference() : 새로운 집합과 기존집합의 차집합을 반환하는 메소드
   s-t
6. symmetric_difference() : 새로운 집합과 기존집합의 배타집합( st - s∩t)을 반환하는 메소드
   s^t
7. copy() : 집합을 복사하는 메소드로 값은 같지만 같은 집합은 아님
  D=A.copy()
  D==A # True
  D is A # False

# 기존 집합을 변경하는 메소드
1. update() : 집합을 변경하는 메소드
 - s.update(t) : s와 t의 합집합을 s에 저장
   s |= t
 - s.intersection_update(t) : s와 t의 교집합을 s에 저장
   s &= t
 - s.difference_update(t) : s와 t의 차집합을 s에 저장
   s -= t
 - s.symmetric_difference_update(t) : s와 t의 배타집합을 s에 저장
   s ^= t
2. s.add(x) : 원소 x를 집합 s에 추가하는 메소드
3. s.remove(x) : 원소 x를 집합 s에서 제거하는 메소드로 원소 x가 없으면 에러발생
4. s.discard(x) : 원소 x를 집합 s에서 제거하는 메소드로 원소 x가 없어도 에러가 발생하지 않음
5. s.pop() : 임의의 원소 x를 집합 s에서 제거하는 메소드로, s가 공집합이면 에러 발생
6. s.clear() : 집합 s의 모든 원소를 제거하는 메소드
----------------------------------------------------------------------------------------

 위의 메소드를 모두 실행 하기에는 무리가 있어 간단하게 사용해 봤습니다.
----------------------------------------------------------------------------------------
A=set([1,2,3,4,5])
B=set([3,4,5,6,7])
A.update(B)
print A

A.add(10)
print A

A.pop()
print A
----------------------------------------------------------------------------------------
(실행 결과)
set([1, 2, 3, 4, 5, 6, 7])
set([1, 2, 3, 4, 5, 6, 7, 10])
set([2, 3, 4, 5, 6, 7, 10])
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍



'언어 > Python' 카테고리의 다른 글

[파이썬] 파일 입·출력  (0) 2017.02.22
[파이썬] 사전  (0) 2017.02.19
[파이썬] 리스트 활용  (4) 2017.02.07
[파이썬] 리스트와 리스트 메소드  (0) 2017.02.05
[파이썬] 문자열 메소드와 포멧팅  (2) 2017.02.03

리스트 활용


 지난번에 공부한 리스트에대해 좀 더 자세히 알아보겠습니다. for in 문을 이용해서 리스트를 생성하는 코드는 다음과 같습니다.

----------------------------------------------------------------------------------------

L=[]

for k in range(10):

L.append(k)

print L

----------------------------------------------------------------------------------------


- 리스트 내포


 리스트 내포를 이용하면 위 3줄의 코드를 한줄로 만들 수 있습니다. 리스트 내포의 리터럴(문법)은 다음과 같습니다.

----------------------------------------------------------------------------------------

[expression(식) for expr1 in sequence1:

   for expr2 in sequence2:


   for exprN in sequenceN:

         if condition] # 조건

# expression에는 반드시 한개의 원소가 들어가야 됩니다. x,y를 쓰고싶은경우 튜플의 형태 (x,y)로 사용해야 합니다.

----------------------------------------------------------------------------------------

 위에서 만든 리스트를 리스트 내포를 이용해서 만드는 코드는 다음과 같습니다.

----------------------------------------------------------------------------------------

L2=[k for k in range(10)]

print L2

----------------------------------------------------------------------------------------


 그렇다면, 조건은 어떻게 활용 할까요? 아래 코드는 k%2를 조건으로 줘서 2의 배수이면 거짓이되서 2의배수가 아닌 수의 제곱만 출력하는 코드입니다.

---------------------------------------------------------------------------------------- 

L3=[k*k for k in range(10) if k%2]

print L3

----------------------------------------------------------------------------------------
(실행 결과)
[1, 9, 25, 49, 81]
----------------------------------------------------------------------------------------

- 정렬

 
 sort() 메소드는 리턴값 없이 리스트를 정렬해서 변경하는 메소드였습니다. sort()메소드와 함께 활용하면 좋은 메소드에대해 알아보겠습니다.

- cmp(a,b) : 동일한 형의 인자 a,b를 비교해서 값을 리턴
a<b인 경우 -1, a>b인 경우 1, a=b인 경우 0 리턴
- sorted() 내장 함수 : 정렬해서 새로운 리스트를 반환, 원래 리스트는 변경하지 않음
- reverse() : 앞뒤를 바꿔서 원래 리스트를 변경
두번 호출하면 값이 변경되었더라도 원래 리스트로 변경
- reversed() 내장 함수 : reverse()메소드와 같은 기능이지만 새로운 리스트를 반환
 
 cmp()메소드를 활용해서 역순으로 정렬하는 코드입니다.
----------------------------------------------------------------------------------------
def mycmp(a1,a2):
    return cmp(a2,a1)    
L=[2,5,1,3,8,7]
L.sort(mycmp)
print L
----------------------------------------------------------------------------------------
(실행 결과)
[8, 7, 5, 3, 2, 1]
----------------------------------------------------------------------------------------

 sort()메소드의 인자에는 key와 reverse가 있습니다. key를 이용하면 원하는 자료형으로 정렬이 가능하고, reverse를 이용하면 역순으로 정렬할 수 있습니다.
----------------------------------------------------------------------------------------
L=['123','45','6','780']
L.sort() # 기본 정렬 - 맨 앞문자의 사전순으로 정렬
print L
L.sort(key=int) # int형으로 정렬
print L
L.sort(reverse=True) # 역순으로 정렬
print L
----------------------------------------------------------------------------------------
(실행 결과)
['123', '45', '6', '780'] 
['6', '45', '123', '780']
['780', '6', '45', '123']
----------------------------------------------------------------------------------------

 마지막으로, sorted() 내장 함수를 사용해 보겠습니다.
----------------------------------------------------------------------------------------
L=[1,5,8,3,4,7]
newL=sorted(L) # 새로운 리스트를 newL에 저장
print 'newL : ',newL
print 'L    : ',L
----------------------------------------------------------------------------------------
(실행 결과)
newL :  [1, 3, 4, 5, 7, 8]
L      :  [1, 5, 8, 3, 4, 7] # L의 리스트는 변화없음
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍



리스트와 리스트 메소드



- 리스트

 앞에서 공부하면서 사용했던 리스트에 대해 알아보겠습니다. 리스트는 문자형처럼 시퀀스 자료형이지만 문자열과는 다르게 변경이 가능한 자료형입니다. 인덱싱, 슬라이싱, 연결, 반복, 멤버십 테스트 연산이 가능합니다.

 다음은 리스트의 추가, 삭제 예시입니다.

----------------------------------------------------------------------------------------

l1=range(10) # 0부터 9까지의 리스트 생성
print l1

del l1[2] # 2번째 인덱스 삭제
print l1

Sun,Mon,Tue,Wed,Thu,Fri,Sat=range(7) # 여러 변수에 한번에 리스트 생성 가능
print Sun,Mon,Tue,Wed,Thu,Fri,Sat
----------------------------------------------------------------------------------------
(실행 결과)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 3, 4, 5, 6, 7, 8, 9]
0 1 2 3 4 5 6
----------------------------------------------------------------------------------------

- 중첩 리스트
 중첩 리스트는 리스트를 인자로 가지는 리스트를 말합니다. 다음과 같이 사용합니다.
----------------------------------------------------------------------------------------
s=[2,3,4]
t=[1,s,5] # 리스트 s를 인자로 사용
print t
print t[1][1] # t리스트의 1번째 인덱스의 1번째 인덱스
----------------------------------------------------------------------------------------
(실행 결과)
[1, [2, 3, 4], 5]
3
----------------------------------------------------------------------------------------

- 리스트가 지원하는 메소드

 리스트가 지원하는 메소드는 아래와 같습니다. java와 메소드 이름이 비슷한 것 같습니다. 

1. append() : 리스트 마지막에 원소를 추가
문자열, 튜플, 사전도 추가가능
2. insert(위치,값) : 해당하는 인덱스의 위치에 원하는 값 추가
3. index(위치) : 해당하는 원소의 인덱스가 몇인지 반환
4. count(값) : 해당하는 값이 몇개가 존재하는지 반환
5. reverse() : 리스트의 순서를 뒤바꿔 줌(값 변경)
6. sort() : 리스트의 값을 정렬해서 값을 변경
7. remove(값) : 해당하는 값을 삭제하는데, 값이 여러개일 경우 첫 번째 값 삭제
8. extend(값) : 기존의 리스트에 값 자체를 추가(병합)

----------------------------------------------------------------------------------------
# append()
ap=[1,2,3,4]
ap.append(10) # 가장 뒤에 10 추가
print ap
print '*'*50

# insert()
ins=[1,2,4,5]
ins.insert(2,3) # 2번째 자리에 3 추가
print ins
print '*'*50

# index()
ind=[1,2,3,4,5,6]
print ind.index(3) # 3에 해당하는 인덱스 값 
print '*'*50

# count()
co=[1,2,3,2,2,2,7]
print co.count(2) # 2가 몇개인지
print '*'*50

# reverse()
re=[1,2,3,4]
re.reverse() # 순서를 거꾸로
print re
print '*'*50

# sort()
so=[11,-3,4,-50]
so.sort() # 정렬
print so
print '*'*50

# remove()
rem=[11,-3,4,-50,-3]
rem.remove(-3) # -3을 제거
print rem
print '*'*50

# extend()
s=[1,2,3,4]
t=[5,6,7]
s.extend(t) # s리스트에 t리스트를 추가(병합)
print s
# extend()와 append() 비교
s2=s.append(t) # append는 리스트 자체를 추가
print s2

----------------------------------------------------------------------------------------
(실행 결과)
[1, 2, 3, 4, 10]
**************************************************
[1, 2, 3, 4, 5]
**************************************************
2
**************************************************
4
**************************************************
[4, 3, 2, 1]
**************************************************
[-50, -3, 4, 11]
**************************************************
[11, 4, -50, -3]
**************************************************
[1, 2, 3, 4, 5, 6, 7]
----------------------------------------------------------------------------------------

- 리스트를 스택, 큐로 이용

 스택은 후입선출 구조, 큐는 선입선출 구조를 가집니다. 리스트의 메소드를 이용해서 스택과 큐처럼 사용할 수 있습니다. append()메소드와 pop()메소드를 이용합니다. pop()메소드는 기본적으로 마지막 원소를 꺼내고, 인자안에 인덱스를 적어주면 해당하는 인덱스의 값을 꺼냅니다.
----------------------------------------------------------------------------------------
# stack
s=[10,20,30,40,50]
s.append(60)
print s
print s.pop()
print s
print s.pop()
print s
print '*'*50

# queue
q=[10,20,30,40,50]
q.append(60)
print q
print q.pop(0)
print q
print q.pop(0)
print q
----------------------------------------------------------------------------------------
(실행 결과)
[10, 20, 30, 40, 50, 60]
60 # 가장 마지막 원소인 60을 꺼냄
[10, 20, 30, 40, 50]
50 # 가장 마지막 원소인 50을 꺼냄
[10, 20, 30, 40]
**************************************************
[10, 20, 30, 40, 50, 60]
10 # 가장 앞의 원소인 10을 꺼냄
[20, 30, 40, 50, 60]
20 #가장 앞의 원소인 20을 꺼냄
[30, 40, 50, 60]
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍



문자열 메소드와 포멧팅


- 문자열 메소드

 메소드란 기존의 프로그래밍 언어에서의 함수와 대응되는 개념으로, 객체의 상태 및 속성 변경과 같이 객체에 대해 수행할 수 있는 작업을 말합니다. 문자열 관련 메소드를 알아보겠습니다.


- 대·소문자 관련 메소드

1. upper() : 해당 문자들을 모두 대문자로 변환

2. lower() : 해당 문자들을 모두 소문자로 변환

3. swapcase() : 해당 문자들을 대문자는 소문자, 소문자는 대문자로 변환

4. capitalize() : 첫 문자만 대문자로 변환

5. tilte() : 문장의 각 단어의 첫문자를 대문자로 변환

----------------------------------------------------------------------------------------

a='i lovE socceR'
print a.upper()
print a.lower()
print a.swapcase()
print a.capitalize()
print a.title()
print a
----------------------------------------------------------------------------------------
(실행 결과)

I LOVE SOCCER # 모두 대문자로 변환됨

i love soccer     # 모두 소문자로 변환됨

I LOVe SOCCEr  # 대·소문자가 반전됨

I love soccer     # 첫문자 i만 대문자로 변환하고 나머지는 소문자 변환

I Love Soccer    # 각 단어의 첫문자는 대문자로 변환하고, 나머지는 소문자로 변환

i lovE socceR    # 문자열은 변경되지 않으므로 처음 a가 출력됨

----------------------------------------------------------------------------------------


- 문자열 관련 메소드

1. count() : 몇번 등장하는 지 반환
2. find() : 찾은 문자의 첫인덱스가 몇번째인지 반환
  찾는 문자가 없는 경우 -1 반환
3. startswith()/endswith() : 해당 문자로 시작하는 지 / 끝나는 지 확인해서 True/False 반환

4. strip() : 좌우 공백을 제거해서 반환

   - rstrip()/lstrip() : 각각 오른쪽/왼쪽 공백을 제거하고 반환

   - ()안에 문자를 넣으면 해당문자도 제거하며, 탭문자(\t)나 널문자(\n)도 공백으로 인정해서 제거

5. replace(a,b) : 첫번째 인자 a를 두번째 인자인 b로 대체

6. split() : 공백을 기준으로 분리해서 리스트로 반환하며, 기준을 넣으면 기준으로 분리

7. splitlines() : 라인 기준으로 분리하여 리스트로 반환

8. join() : 리스트의 인자들을 연결

9. zfill() : 인자만큼의 길이로 만들어지고 빈 공간을 0으로 채워서 반환


----------------------------------------------------------------------------------------

# count

a2="blue red sky blue red"

print a2.count('blue') # blue 문자의 수를 반환

print '*'*50


# find()

print a2.find("red") # red가 몇번째 인덱스에 존재하는지

print a2.find('red',6) # 6번째 인덱스 이후의 red가 몇번째 인덱스에 존재하는 지

print '*'*50


# stratswith/endswith

print a2.startswith("blue") # blue라는 문자로 시작하는지

print a2.endswith("blue") #  blue라는 문자로 끝나는지

print '*'*50


# strip()

b="  \t 보고싶다.    "

print b.strip() # 좌·우 공백 제거(문자와 문자 사이 공백은 제거하지 않음)

print b.rstrip() # 오른쪽 공백 제거

print b.lstrip() # 왼쪽  공백 제거

print '*'*50


# replace()

b=b.replace('\t','너무') # b의 탭문자를 너무로 변환하고 재할당해서

print b.replace("다.","은데 볼 수가 없다.") # 다시한번 문자를 변환해서 출력

print '*'*50


# split()

c="a b c"

print c.split() # 공백 기준으로 분리해서 리스트로 반환

c2="I \n Love \n You"

print c2.splitlines() # 개행 기준으로 분리해서 리스트로 반환

print '*'*50


# join()

l1=["red","blue","green"]

print ('-').join(l1) # 리스트의 원소들을 '-'문자로 연결

print '*'*50


# zfill()

e='abc'

print e.zfill(5)

----------------------------------------------------------------------------------------

(실행 결과)

2

**************************************************

5

18

**************************************************

True

False

**************************************************

보고싶다.

  보고싶다.

보고싶다.    

**************************************************

  너무 보고싶은데 볼 수가 없다.    

**************************************************

['a', 'b', 'c']

['I ', ' Love ', ' You']

**************************************************

red-blue-green

**************************************************

00abc

----------------------------------------------------------------------------------------


- 정렬

1. center() : 문자열을 해당하는 만큼의 공간을 확보하고 가운데 정렬

2. rjust()/ljust() : 문자열을 해당하는 만큼의 공간을 확보하고 오른쪽/왼쪽 정렬

----------------------------------------------------------------------------------------

d='warten'

print d.center(50)

print d.rjust(50)

print d.ljust(50)

----------------------------------------------------------------------------------------

(실행 결과)

                      warten                      

                                            warten

warten                                            

----------------------------------------------------------------------------------------

- 확인하는 메소드
 메소드의 이름을 보면 어느정도 추측이 가능한 메소드 들입니다. True/False를 반환합니다.
1. isdigit() : 숫자로만 쓰였는지 확인
2. isalpha() : 영문자로만 쓰였는지 확인
3. isalnum() : 영문자 또는 숫자로 쓰였는지 확인
4. islower() : 모두 소문자로만 쓰였는지 확인
5. isupper() : 모두 대문자로만 쓰였는지 확인
6. isspace() "모두 공백 문자인지 확인
7. istitle() : 각 첫단어들이 대문자인지 확인



- 문자열 포멧팅

 문자열 포멧팅은 C언어에서 %s,%c등을 사용하는것과 유사하게 사용합니다. 임의의 객체를 문자열로 변환하기위해 %를 사용합니다. 튜플과 사전을 이용하며, 다음과 같은 형태로 사용 합니다.
----------------------------------------------------------------------------------------
# -*- coding: utf-8 -*-

letter = u'''
안녕하세요 %s님
오늘 너무나도 보고싶은 날이네요
기다리고 있을게요
'''

name=u'홍길동'
print letter % name
print '*' * 50
    
names=(u'철수',u'영희') # 튜플을 이용
for name in names:
    print letter % name
    print '*' * 50

----------------------------------------------------------------------------------------
(실행 결과)
안녕하세요 홍길동님
오늘 너무나도 보고싶은 날이네요
기다리고 있을게요

**************************************************

안녕하세요 철수님
오늘 너무나도 보고싶은 날이네요
기다리고 있을게요

**************************************************

안녕하세요 영희님
오늘 너무나도 보고싶은 날이네요
기다리고 있을게요

**************************************************
----------------------------------------------------------------------------------------

 사전을 이용하는 방법도 동일하고, 사전형태는 순서가 바껴도 올바르게 상관이 없습니다.
----------------------------------------------------------------------------------------
print '%(이름)s -- %(나이)s' %{'이름':'홍길동','나이':10}
print '%(이름)s -- %(나이)s' %{'나이':50,'이름':'철수'}
----------------------------------------------------------------------------------------
(실행 결과)
홍길동 -- 10
철수 -- 50
----------------------------------------------------------------------------------------

출처 한국기술교육대학교 온라인평생교육원 파이썬프로그래밍




'언어 > Python' 카테고리의 다른 글

[파이썬] 리스트 활용  (4) 2017.02.07
[파이썬] 리스트와 리스트 메소드  (0) 2017.02.05
[파이썬] 문자열 정의 및 기초연산  (0) 2017.02.01
[파이썬] 제어문과 함수  (0) 2017.01.25
[파이썬] 각종 연산자  (0) 2017.01.21

+ Recent posts