file)과 텍스트(text)os 모듈../data/zen.txt/Users/seokbumko/Learning/with-huckjae/, Windows에서는 \(파이썬 string에서는 \\로 이스케이핑 필요)/로 표시C:\~로 표시하고, 해당 환경변수는 HOME 임, 보통 /Users/username임USERPROFIlE 환경 변수를 사용, 보통 C:\Users\username임파이썬 os 모듈에 현재 파일시스템과 관련된 정보와 파일시스템을 다루는 다양한 함수들이 들어 있다.
import os
print("시스템 플랫폼 이름: ", os.name)
print("현재 디렉터리를 표시하는 문자열: ", os.curdir)
print("부모 디렉터리를 표시하는 문자열: ", os.pardir)
print("경로에서 디렉터리, 파일 구분하는 문자: ", os.sep)
print("파일이름에서 확장자를 표시하는 문자: ", os.extsep)
print(f"텍스트 파일에서 행을 구분하는 문자열: {os.linesep!r}")
print(f"PATH 환경변수에서 경로를 구분하는 문자: {os.pathsep!r}")시스템 플랫폼 이름: posix
현재 디렉터리를 표시하는 문자열: .
부모 디렉터리를 표시하는 문자열: ..
경로에서 디렉터리, 파일 구분하는 문자: /
파일이름에서 확장자를 표시하는 문자: .
텍스트 파일에서 행을 구분하는 문자열: '\n'
PATH 환경변수에서 경로를 구분하는 문자: ':'PATH 환경변수(environment variable)(GitHub Copilot)path와 환경변수 PATH는 다른 개념이다.The environment variable PATH is a crucial component in operating systems like Unix, Linux, and Windows. It specifies a set of directories where executable programs are located. When you type a command in the terminal or command prompt, the system searches through these directories to find the executable file associated with that command.
PATHPATH variable to find the executable file.PATH:).
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin;).
C:\Windows\System32;C:\Windows;C:\Program Files\Python39PATHYou can view and modify the PATH environment variable using the terminal or command prompt.
PATHUnix-like Systems:
echo $PATHWindows Systems:
echo %PATH%PATHUnix-like Systems:
# Temporarily add a directory to PATH
export PATH=$PATH:/new/directory
# Permanently add a directory to PATH (add to ~/.bashrc or ~/.bash_profile)
echo 'export PATH=$PATH:/new/directory' >> ~/.bashrc
source ~/.bashrcWindows Systems:
# Temporarily add a directory to PATH
set PATH=%PATH%;C:\new\directory
# Permanently add a directory to PATH (through System Properties)You can access and modify the PATH environment variable in Python using the os module.
PATHimport os
# Get the PATH environment variable
path = os.getenv('PATH')
print(path)/Applications/Positron.app/Contents/Resources/app/extensions/positron-python/python_files/deactivate/zsh:/Users/seokbumko/Learning/Education/cds-python/.venv/bin:/opt/anaconda3/bin:/opt/anaconda3/condabin:/opt/homebrew/opt/sqlite/bin:/Applications/Positron.app/Contents/Resources/app/extensions/positron-python/python_files/deactivate/zsh:/Users/seokbumko/Learning/Education/cds-python/.venv/bin:.:/Applications/quarto/bin:/Library/Frameworks/Python.framework/Versions/3.12/bin:/Library/Frameworks/Python.framework/Versions/3.11/bin:/Library/Frameworks/Python.framework/Versions/3.10/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/opt/X11/bin:/Library/Apple/usr/bin:/Library/TeX/texbin:/usr/local/go/bin:/Applications/Postgres.app/Contents/Versions/latest/bin:/Applications/quarto/bin:/Users/seokbumko/.cargo/bin:/Applications/Positron.app/Contents/Resources/app/extensions/positron-python/python_files/deactivate/zsh:/Users/seokbumko/Learning/Education/cds-python/.venv/bin:/Users/seokbumko/.positron/extensions/ms-python.debugpy-2025.6.0-darwin-arm64/bundled/scripts/noConfigScripts:/Users/seokbumko/.lmstudio/binPATHimport os
# Add a new directory to PATH
new_directory = "/new/directory"
os.environ['PATH'] += os.pathsep + new_directory
# Verify the modification
print(os.getenv('PATH'))/Applications/Positron.app/Contents/Resources/app/extensions/positron-python/python_files/deactivate/zsh:/Users/seokbumko/Learning/Education/cds-python/.venv/bin:/opt/anaconda3/bin:/opt/anaconda3/condabin:/opt/homebrew/opt/sqlite/bin:/Applications/Positron.app/Contents/Resources/app/extensions/positron-python/python_files/deactivate/zsh:/Users/seokbumko/Learning/Education/cds-python/.venv/bin:.:/Applications/quarto/bin:/Library/Frameworks/Python.framework/Versions/3.12/bin:/Library/Frameworks/Python.framework/Versions/3.11/bin:/Library/Frameworks/Python.framework/Versions/3.10/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/opt/X11/bin:/Library/Apple/usr/bin:/Library/TeX/texbin:/usr/local/go/bin:/Applications/Postgres.app/Contents/Versions/latest/bin:/Applications/quarto/bin:/Users/seokbumko/.cargo/bin:/Applications/Positron.app/Contents/Resources/app/extensions/positron-python/python_files/deactivate/zsh:/Users/seokbumko/Learning/Education/cds-python/.venv/bin:/Users/seokbumko/.positron/extensions/ms-python.debugpy-2025.6.0-darwin-arm64/bundled/scripts/noConfigScripts:/Users/seokbumko/.lmstudio/bin:/new/directoryPATH Environment Variable: Specifies directories where executable programs are located.:) on Unix-like systems and semicolons (;) on Windows.Understanding and managing the PATH environment variable is essential for configuring your system to run programs and scripts efficiently.
os.path 모듈과 pathlib 모듈이전에는 파일시스템을 다룰 때 os 모듈의 서브 모듈인 os.path을 많이 사용했었는데, 이제는 파일시스템에 관한 객체 지향형 접근법을 적용한 pathlib 모듈을 더 선호하는 경향이 있다. 그래서 pathlib 모듈을 중심으로 공부하면서 부가적으로 os.path를 사용할 때는 어떻게 하는지 정리하고자 한다.
파일 경로가 문자열로 되어 있기 때문에 문자열 그대로 사용하면 안 될까하는 의문을 가질 수도 있는 데, 여러 가지 문제가 있을 수 있다. 무엇보다 파일 경로를 표시하는 방법이 윈도우와 Unix 계열 시스템이 서로 다른 점이 큰 문제다. 따라서 문자열을 이용하는 경우, 윈도우 시스템에서 작성한 코드가 맥오에스에서는 작동하지 않을 수 있다. 어느 플랫폼에서든 사용할 수 있는 인터페이스를 가지면서, 플랫폼에 따라서 필요한 내용들을 자동적으로 맞춰주는 도구가 필요하다. 그리고 파일 경로를 문자열 다루는 방식으로 처리하다가 보면 에러가 발생할 확률이 높아지고, 가독성도 떨어진다.
pathlib.Path 클래스pathlib은 파일시스템에 대한 객체 지향형 접근법을 취하는데, 가장 중요한 역할을 하는 것이 pathlib.Path 클래스이다. 다음 예를 보자.
from pathlib import Path
cwd = Path.cwd() # absolute, cwd
cwd2 = Path(".") # relative, cwd
home = Path.home()
cwd, cwd2, home(PosixPath('/Users/seokbumko/Learning/Education/cds-python'),
PosixPath('.'),
PosixPath('/Users/seokbumko'))Path.cwd()는 현재 워킹 디렉터리를 의미하는 Path 객체를 반환하는 클래스 메서드이고, Path.home()은 홈 디렉터리를 의미하는 Path 객체를 반환하는 클래스 메서드이다.
이렇게 특정 역할을 하는 디렉터리 대신 임의의 파일에 대한 경로를 나타내는 문자열을 가지고도 Path 객체를 만들 수 있다. 다음은 현재 디렉터리에 있는 data 서브디렉터리에 들어 있는 zen.txt 파일을 가리키는 Path 객체를 만들어 본 예이다.
my_file = "./data/zen.txt"
my_file_path = Path(my_file)
my_file_pathPosixPath('data/zen.txt')pathlib 모듈은 디렉터리를 조작을 편리하게 해 주는 /라는 연산자를 제공한다. 이 연산자를 사용하여 다음과 같이 해서 위 my_file_path와 동일한 경로를 만들 수 있다.
my_file_path2 = Path("data") / "zen.txt"
my_file_path2PosixPath('data/zen.txt')또는 Path() 클래스 호출을 할 때, 경로를 이루는 요소들을 개별 인자로 줘서 경로를 만들 수 있다.
my_file_path3 = Path("data", "zen.txt")
my_file_path3PosixPath('data/zen.txt')위 my_file_path 등은 모두 상대 경로이다. Path 객체에 is_absolute() 메서드를 적용하여 절대 경로인지 아닌지 물어볼 수 있다.
my_file_path.is_absolute(), my_file_path2.is_absolute(), my_file_path3.is_absolute()(False, False, False)이것을 절대 경로로 바꾸고자 할 때는 “현재 디렉터리”를 의미하는 Path.cwd() 클래스 메서드를 앞에 붙여 계산함할 수 있다.
new_path = Path.cwd() / my_file_path
print(new_path)
print(new_path.is_absolute())/Users/seokbumko/Learning/Education/cds-python/data/zen.txt
True다음과 같은 파일에 대한 경로가 Path 객체로 정의되었다고 가정해 보자.
from pathlib import Path
my_path = Path.cwd() / "data" / "zen.txt"
print(my_path)/Users/seokbumko/Learning/Education/cds-python/data/zen.txt다음과 같은 Path 객체의 속성값을 사용하여 경로의 부분을 알아낼 수 있다.
print(my_path.anchor)
print(my_path.parent)
print(my_path.name)
print(my_path.stem)
print(my_path.suffix)/
/Users/seokbumko/Learning/Education/cds-python/data
zen.txt
zen
.txtos.path 모듈의 basename() 메서드는 Path 객체의 name 속성과 같은 값인 파일 이름을 반환한다.
import os
os.path.basename(my_path)'zen.txt'os.path 모듈로 확장자를 확인할 때는 os.path.splitext()(철자 주의: t가 하나이다)를 사용하는데, 이 함수는 튜틀을 반환하고, 첫 번째 아이템은 확장자 이전의 값들, 두 번째 아이템이 확장자이다.
os.path.splitext(my_path)('/Users/seokbumko/Learning/Education/cds-python/data/zen', '.txt')디렉터리에는 파일, (서브) 디렉터리가 들어 있다. 그 이름들을 알 필요가 있는 경우가 종종 발생한다.
iterdir() 메서드는 디렉터리 콘텐트를 yield 할 수 있는 iterator를 반환한다.os 모듈의 listdir() 메서드는 디렉터리 콘텐츠를 모아서 하나의 파이썬 리스트로 반환한다. 물론 위 iterdir()로 반환되는 iterator를 list() 함수로 보내도 같은 결과를 얻는다.for f in Path(".").iterdir():
print(f)function.qmd
jupyter.qmd
.Rhistory
sequence.qmd
grouping.qmd
_quarto.yml
with-ai.qmd
sequence.html
jupyter.quarto_ipynb
_publish.yml
file-text.qmd
list-tuple.html
index.html
.DS_Store
matplotlib.qmd
_language-ko.yml
iterator-generator.qmd
jupyter.html
date-time.qmd
intro.quarto_ipynb
intro.qmd
file-text.quarto_ipynb
images
references.bib
python-setting.html
module-package.qmd
python-core.html
class.qmd
plotly.qmd
stats-vis.qmd
torch-basic.qmd
with-ai.html
loop-condition.html
match-object.qmd
mapping.quarto_ipynb
ipython_display_example.py
pandas.qmd
pytorch.quarto_ipynb
jupyter_cache
site_libs
mapping.html
object.html
__pycache__
torch-basic.quarto_ipynb
python-core.qmd
index.qmd
regex.qmd
string.html
intro.html
generator.qmd
loop-condition.qmd
_extensions
cds-python.Rproj
pytorch.qmd
.gitignore
object.quarto_ipynb
lookaround.qmd
sequence.quarto_ipynb
.venv
setting.qmd
cover.png
list-tuple.qmd
_book
python-setting.qmd
ai-assistants.qmd
fundamentals.qmd
.ipynb_checkpoints
setting.html
module.py
plotnine.qmd
references.qmd
python-setting_cache
seaborn.qmd
object.qmd
.git
function.quarto_ipynb
numpy.qmd
list-tuple.quarto_ipynb
data
string.qmd
.Rproj.user
.quarto
function.html
mapping.qmd
string.quarto_ipynbimport os
os.listdir(".")
# list(Path(".").iterdir()_['function.qmd',
'jupyter.qmd',
'.Rhistory',
'sequence.qmd',
'grouping.qmd',
'_quarto.yml',
'with-ai.qmd',
'sequence.html',
'jupyter.quarto_ipynb',
'_publish.yml',
'file-text.qmd',
'list-tuple.html',
'index.html',
'.DS_Store',
'matplotlib.qmd',
'_language-ko.yml',
'iterator-generator.qmd',
'jupyter.html',
'date-time.qmd',
'intro.quarto_ipynb',
'intro.qmd',
'file-text.quarto_ipynb',
'images',
'references.bib',
'python-setting.html',
'module-package.qmd',
'python-core.html',
'class.qmd',
'plotly.qmd',
'stats-vis.qmd',
'torch-basic.qmd',
'with-ai.html',
'loop-condition.html',
'match-object.qmd',
'mapping.quarto_ipynb',
'ipython_display_example.py',
'pandas.qmd',
'pytorch.quarto_ipynb',
'jupyter_cache',
'site_libs',
'mapping.html',
'object.html',
'__pycache__',
'torch-basic.quarto_ipynb',
'python-core.qmd',
'index.qmd',
'regex.qmd',
'string.html',
'intro.html',
'generator.qmd',
'loop-condition.qmd',
'_extensions',
'cds-python.Rproj',
'pytorch.qmd',
'.gitignore',
'object.quarto_ipynb',
'lookaround.qmd',
'sequence.quarto_ipynb',
'.venv',
'setting.qmd',
'cover.png',
'list-tuple.qmd',
'_book',
'python-setting.qmd',
'ai-assistants.qmd',
'fundamentals.qmd',
'.ipynb_checkpoints',
'setting.html',
'module.py',
'plotnine.qmd',
'references.qmd',
'python-setting_cache',
'seaborn.qmd',
'object.qmd',
'.git',
'function.quarto_ipynb',
'numpy.qmd',
'list-tuple.quarto_ipynb',
'data',
'string.qmd',
'.Rproj.user',
'.quarto',
'function.html',
'mapping.qmd',
'string.quarto_ipynb']앞의 pahtlib.Path.iterdir() 함수는 디렉터리의 모든 콘텐츠를 보여 주는데, 어떤 경우는 특정 이름이나 확장자를 가진 파일만 가지고 올 필요가 있다. 이 경우 사용할 수 있는 메서드가 .glob()이다. 이 메서드 안에서 터미널에서 사용하는 globbing 패턴을 사용할 수 있다. 흔히 사용되는 글로빙 패턴은 다음과 같다.
*): 0개 또는 그 이상의 문자?): 하나의 문자[]): 이 안에 포함된 문자들 가운데 하나. file[1-3]은 file1, file2, file3와 매칭할 수 있다.for f in Path(".").glob("*.qmd"): # 확장자가 .qmd인 파일들
print(f)function.qmd
jupyter.qmd
sequence.qmd
grouping.qmd
with-ai.qmd
file-text.qmd
matplotlib.qmd
iterator-generator.qmd
date-time.qmd
intro.qmd
module-package.qmd
class.qmd
plotly.qmd
stats-vis.qmd
torch-basic.qmd
match-object.qmd
pandas.qmd
python-core.qmd
index.qmd
regex.qmd
generator.qmd
loop-condition.qmd
pytorch.qmd
lookaround.qmd
setting.qmd
list-tuple.qmd
python-setting.qmd
ai-assistants.qmd
fundamentals.qmd
plotnine.qmd
references.qmd
seaborn.qmd
object.qmd
numpy.qmd
string.qmd
mapping.qmdfor f in Path(".").glob("s*.*"): # s로 시작하는 파일
print(f)sequence.qmd
sequence.html
stats-vis.qmd
string.html
sequence.quarto_ipynb
setting.qmd
setting.html
seaborn.qmd
string.qmd
string.quarto_ipynbfor f in Path(".").glob("*.?m?"): # 3 글자로 된 확장자를 가지면서 가운데가 m인 파일
print(f)function.qmd
jupyter.qmd
sequence.qmd
grouping.qmd
_quarto.yml
with-ai.qmd
_publish.yml
file-text.qmd
matplotlib.qmd
_language-ko.yml
iterator-generator.qmd
date-time.qmd
intro.qmd
module-package.qmd
class.qmd
plotly.qmd
stats-vis.qmd
torch-basic.qmd
match-object.qmd
pandas.qmd
python-core.qmd
index.qmd
regex.qmd
generator.qmd
loop-condition.qmd
pytorch.qmd
lookaround.qmd
setting.qmd
list-tuple.qmd
python-setting.qmd
ai-assistants.qmd
fundamentals.qmd
plotnine.qmd
references.qmd
seaborn.qmd
object.qmd
numpy.qmd
string.qmd
mapping.qmd경로의 존재 여부는 .exists() 메서드로 확인하고, 그것이 파일인지는 .is_file(), 디렉터리인지는 .is_dir() 메서드로 확인할 수 있다.
from pathlib import Path
# Define the path
path = Path("/Users/seokbumko/Learning/with-huckjae/file-text.qmd")
# Check if the path exists
if path.exists():
print(f"The path {path} exists.")
# Check if it is a file
if path.is_file():
print(f"The path {path} is a file.")
# Check if it is a directory
elif path.is_dir():
print(f"The path {path} is a directory.")
else:
print(f"The path {path} does not exist.")The path /Users/seokbumko/Learning/with-huckjae/file-text.qmd does not exist.다음은 open() 함수를 사용하여, data/zen.txt이라는 텍스트 파일을 읽는 코드이다. 이 코드 패턴은 암기하는 것이 좋다.
with open('data/zen.txt', 'rt') as file:
line = file.readline()
while line:
print(line, end='')
line = file.readline()The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!위 코드는 몇 줄 안 되지만 이야깃거리가 많다. 먼저 open() 함수부터 살펴보자.
open() 함수open() 함수의 도움말을 이해하기 위해서는 사전 지식이 많이 필요하다. 하나씩 배워가면서 open() 함수의 도움말을 자주 읽어보면 좋다.
help(open)Help on function open in module _io:
open(
file,
mode='r',
buffering=-1,
encoding=None,
errors=None,
newline=None,
closefd=True,
opener=None
)
Open file and return a stream. Raise OSError upon failure.
file is either a text or byte string giving the name (and the path
if the file isn't in the current working directory) of the file to
be opened or an integer file descriptor of the file to be
wrapped. (If a file descriptor is given, it is closed when the
returned I/O object is closed, unless closefd is set to False.)
mode is an optional string that specifies the mode in which the file
is opened. It defaults to 'r' which means open for reading in text
mode. Other common values are 'w' for writing (truncating the file if
it already exists), 'x' for creating and writing to a new file, and
'a' for appending (which on some Unix systems, means that all writes
append to the end of the file regardless of the current seek position).
In text mode, if encoding is not specified the encoding used is platform
dependent: locale.getencoding() is called to get the current locale encoding.
(For reading and writing raw bytes use binary mode and leave encoding
unspecified.) The available modes are:
========= ===============================================================
Character Meaning
--------- ---------------------------------------------------------------
'r' open for reading (default)
'w' open for writing, truncating the file first
'x' create a new file and open it for writing
'a' open for writing, appending to the end of the file if it exists
'b' binary mode
't' text mode (default)
'+' open a disk file for updating (reading and writing)
========= ===============================================================
The default mode is 'rt' (open for reading text). For binary random
access, the mode 'w+b' opens and truncates the file to 0 bytes, while
'r+b' opens the file without truncation. The 'x' mode implies 'w' and
raises an `FileExistsError` if the file already exists.
Python distinguishes between files opened in binary and text modes,
even when the underlying operating system doesn't. Files opened in
binary mode (appending 'b' to the mode argument) return contents as
bytes objects without any decoding. In text mode (the default, or when
't' is appended to the mode argument), the contents of the file are
returned as strings, the bytes having been first decoded using a
platform-dependent encoding or using the specified encoding if given.
buffering is an optional integer used to set the buffering policy.
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
line buffering (only usable in text mode), and an integer > 1 to indicate
the size of a fixed-size chunk buffer. When no buffering argument is
given, the default buffering policy works as follows:
* Binary files are buffered in fixed-size chunks; the size of the buffer
is chosen using a heuristic trying to determine the underlying device's
"block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
On many systems, the buffer will typically be 4096 or 8192 bytes long.
* "Interactive" text files (files for which isatty() returns True)
use line buffering. Other text files use the policy described above
for binary files.
encoding is the name of the encoding used to decode or encode the
file. This should only be used in text mode. The default encoding is
platform dependent, but any encoding supported by Python can be
passed. See the codecs module for the list of supported encodings.
errors is an optional string that specifies how encoding errors are to
be handled---this argument should not be used in binary mode. Pass
'strict' to raise a ValueError exception if there is an encoding error
(the default of None has the same effect), or pass 'ignore' to ignore
errors. (Note that ignoring encoding errors can lead to data loss.)
See the documentation for codecs.register or run 'help(codecs.Codec)'
for a list of the permitted encoding error strings.
newline controls how universal newlines works (it only applies to text
mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
follows:
* On input, if newline is None, universal newlines mode is
enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
these are translated into '\n' before being returned to the
caller. If it is '', universal newline mode is enabled, but line
endings are returned to the caller untranslated. If it has any of
the other legal values, input lines are only terminated by the given
string, and the line ending is returned to the caller untranslated.
* On output, if newline is None, any '\n' characters written are
translated to the system default line separator, os.linesep. If
newline is '' or '\n', no translation takes place. If newline is any
of the other legal values, any '\n' characters written are translated
to the given string.
If closefd is False, the underlying file descriptor will be kept open
when the file is closed. This does not work when a file name is given
and must be True in that case.
A custom opener can be used by passing a callable as *opener*. The
underlying file descriptor for the file object is then obtained by
calling *opener* with (*file*, *flags*). *opener* must return an open
file descriptor (passing os.open as *opener* results in functionality
similar to passing None).
open() returns a file object whose type depends on the mode, and
through which the standard file operations such as reading and writing
are performed. When open() is used to open a file in a text mode ('w',
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
a file in a binary mode, the returned class varies: in read binary
mode, it returns a BufferedReader; in write binary and append binary
modes, it returns a BufferedWriter, and in read/write mode, it returns
a BufferedRandom.
It is also possible to use a string or bytearray as a file for both
reading and writing. For strings StringIO can be used like a file
opened in a text mode, and for bytes a BytesIO can be used like a file
opened in a binary mode.
여기서 논하는 파일 객체는, 즉 파이썬 언어가 말하는 파일 객체(file object)는 실제 컴퓨터에 이미 저장된 파일이라기 보다는 그것을 대리하는 파이썬 객체라는 것을 알 필요가 있다. 파일의 종류가 다양하듯이 그것을 대리하는 파일 객체의 타입도 다양하다.
파이썬은 파일의 콘텐츠가 text인지, raw data인 bytes인지를 명확히 구분한다(사용자도 반드시 명확히 구분해서 사용해야 한다).
open() 함수는 파일 객체(file object)를 반환한다. 그런데 사용자가 지정하는 파라미터의 조합에 따라 (겉으로 보이진 않지만) 서로 다른 클래스를 가진 파일 객체를 반환한다. 여기서 open() 함수는 일종의 factory function이다.
위 코드 with open('data/zen.txt', 'rt') as file: 행은 zen.txt이라는 실제 파일을 텍스트 읽기(rt) 모드로 열고 그 파일을 대리하는 파일 객체를 file이라는 이름의 별칭으로 대치한다. 그리고 파이썬은 io 모듈을 통해 파일을 다루는 기본 기능을 제공한다(이 모듈을 직접 import 하는 경우는 드물지만 뒤에서는 이 모듈이 작동하고 있음을 알고 있는 것이 좋다). 핵심적인 역할을 하는 open() 함수 역시 실제로는 io.open() 함수의 별칭이다.
다음은 data/zen.txt 텍스트 파일과 dat/python-logo.png라는 바이너리 파일을 열고, 그것을 대리하는 file 객체의 attributes를 확인해 본 예이다(일단 파일 안의 콘텐츠는 무시했다).
with open('data/zen.txt', 'rt') as file:
print(type(file))
print(file.mode)
print(file.name)
print(file.encoding)<class '_io.TextIOWrapper'>
rt
data/zen.txt
UTF-8with open('data/python-logo.png', 'rb') as file:
print(type(file))
print(file.mode)
print(file.name)<class '_io.BufferedReader'>
rb
data/python-logo.pngopen() 파일의 mode 파라미터는 파일을 여는 방법을 결정한다. r은 reading을 의미한다. t는 콘텐츠가 text임을 의미하고, b는 콘텐츠가 bytes임을 의미한다. file 객체는 이 경우 텍스트인 경우 TextIOWrapper, 바이너리인 경우 BufferedReader 타입이다. 그리고 파일 객체는 mode, name, 텍스트 모드인 경우 encoding이라는 속성을 가지고 있음을 볼 수 있다.
텍스트 읽기 모드(mode='rt')인 파라미터를 사용하여 반환되는 파일 객체는 다음과 같은 읽기용 메서드를 제공한다.
f.read(): 다른 파라미터를 사용하지 않는 경우, 콘텐츠를 하나의 문자열로 반환f.readline(): 파라미터를 사용하지 않는 경우, 다음 한 줄을 반환(newline 포함)f.readlines(): 텍스트 콘텐츠 첫 행에서 끝 행까지로 이뤄진, 하나의 파이썬 리스트를 반환. 하나의 행이 리스트의 하나의 아이템이 됨. f