8. 입출력

표준 입출력

1. 출력

1) print()

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Print objects to the text stream file, separated by sep and followed by end.  sep, end and file, if present, must be given as keyword arguments.

All non-keyword arguments are converted to strings like str() does and written to the stream, separated by sep and followed by end. Both sep and endmust be strings; they can also be None, which means to use the default values. If no objects are given, print() will just write end.

The file argument must be an object with a write(string) method; if it is not present or None, sys.stdout will be used. Since printed arguments are converted to text strings, print() cannot be used with binary mode file objects. For these, use file.write(...) instead.

Whether output is buffered is usually determined by file, but if the flushkeyword argument is true, the stream is forcibly flushed.

Changed in version 3.3: Added the flush keyword argument.

- print() 함수의 인자는 몇 개가 들어가거나 어떤 변수가 들어가도 상관없음

print(1)

print('hi', 'guys')

a = 'hello\n'

print(a)

x = 0.2

print(x)

str(x)

print(str(x))

a = repr('hello\n')

print(a)

1

hi guys

hello

0.2

0.2

'hello\n'

- repr()함수

repr(object)

Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a __repr__() method.

- print() 함수에 입력 인자가 여러 개 들어가게 되면 공백으로 구분해서 출력

- string의 +연산자를 이용해서 공백없이 출력 가능

x = 0.2

print(x, 'test')

print(a + 'this is test')

0.2 test

'hello\n'this is test

- 입력인자로 구분자(sep), 끝라인(end), 출력(file)을 지정 가능

- 입력인자가 생략될 경우 sep의 기본값은 공백(" "), end의 기본값은 줄바꿈( "\n"), file의 기본 값은 표준출력(sys.stdout) 

- file을 이용해서 출력을 표준 오류(standard error)로 변경

import sys

print("welcome to","python", sep='-', end="|", file=sys.stderr)

welcome to-python|

- 파일로 출력 테스트 (결과는 직접 확인)

# 파일로 출력 테스트 

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

print("file write", file=f)

f.close()

- print()함수를 쓰지 않고 sys.stdout을 이용하여 화면 출력가능

import sys

sys.stdout.write('test')

test

2) 줄 맞춰 출력하거나 정렬하는 방법

for x in range(1, 6):

    print(x, '*', x, '=', x*x)

1 * 1 = 1

2 * 2 = 4

3 * 3 = 9

4 * 4 = 16

5 * 5 = 25

a. 오른쪽으로 정렬 - string.rjust()

- rjust()메서드의 입력인자는 정렬할 전체 길이

for x in range(1, 6):

    print(x, '*', x, '=', str(x*x).rjust(3))

1 * 1 =   1

2 * 2 =   4

3 * 3 =   9

4 * 4 =  16

5 * 5 =  25

- 전체 길이가 문자열 보자 작으면 무시

print('right'.rjust(10))

print('right'.rjust(1))

     right

right

b. 왼쪽으로 정렬 - string.ljust()

for x in range(1, 6):

    print(x, '*', x, '=', str(x*x).ljust(5))

1 * 1 = 1    

2 * 2 = 4    

3 * 3 = 9    

4 * 4 = 16   

5 * 5 = 25

c. 가운데 정렬 - string.center()

for x in range(1, 6):

    print(x, '*', x, '=', str(x*x).center(5))

1 * 1 =   1  

2 * 2 =   4  

3 * 3 =   9  

4 * 4 =   16 

5 * 5 =   25 

d. 공백대신 0(zero)으로 출력 - zfill()

for x in range(1, 6):

    print(x, '*', x, '=', str(x*x).zfill(3))

1 * 1 = 001

2 * 2 = 004

3 * 3 = 009

4 * 4 = 016

5 * 5 = 025

2. 포맷팅

- 문자열 내에서 어떤 값이 들어가길 원하는 곳은 {}로 표시

1) {} 안의 값들은 숫자로 표현, format 인자들의 인덱스를 사용

print("{0} is {1}".format("apple", "red"))

print("{0} is {1} or {2}".format("apple", "red", "green"))

apple is red

apple is red or green

2) format의 인자로 키(key), 값(value)을 주어 {} 안의 값을 지정

print("{item} is {color}".format(item="apple", color="red"))

apple is red

3) 사전을 입력으로 받음

- 0[item]은 dic[item]을 의미, 0[color]은 dic[color]를 의미

dic = {"item":"apple", "color":"red"}

print("{0[item]} is {0[color]}".format(dic))

apple is red

4) 현재 지역변수를 사전 형태로 반환하는 locals()함수를 이용한 format

item = "apple"

color = "red"

print("{0[item]} is {0[color]}".format(locals()))

apple is red

5) ** 기호 사용

- 사전을 입력 받는 것으로 판단하고 인자를 하나만 받음, 불필요한 인덱스 생략 가능

print("{item} is {color}".format(**locals()))

apple is red

print("{item} is {color}".format(**dic))

apple is red

6) ! 기호를 사용한 문자열 변환

- !s = str(), !r = repr(), !a = ascii()

print("{item!s} is {color!s}".format(**dic))

apple is red

print("{item!r} is {color!r}".format(**dic))

'apple' is 'red'

print("{item!a} is {color!a}".format(**dic))

'apple' is 'red'

7) 변수 인덱스 사용

numbers = [5, 4, 3, 2, 1]

print("{numbers}".format(**vars()))

[5, 4, 3, 2, 1]

print("{numbers[0]}".format(**vars()))

5

class foo:

    var = 0.14

f = foo()

print("{f.var}".format(**vars()))

print("vars(foo):", vars(foo))

0.14

vars(foo): {'__module__': '__main__', 'var': 0.14, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'foo' objects>, '__dict__': <attribute '__dict__' of 'foo' objects>}

- vars()

vars([object])

Return the __dict__ attribute for a module, class, instance, or any other object with a __dict__ attribute.

Objects such as modules and instances have an updateable __dict__ attribute; however, other objects may have write restrictions on their __dict__ attributes (for example, classes use a dictproxy to prevent direct dictionary updates).

Without an argument, vars() acts like locals(). Note, the locals dictionary is only useful for reads since updates to the locals dictionary are ignored.

8) str(), repr()

eval(expression, globals=None, locals=None)

The arguments are a string and optional globals and locals. If provided, globalsmust be a dictionary. If provided, locals can be any mapping object.

The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is present and lacks ‘__builtins__’, the current globals are copied into globals before expression is parsed. This means that expression normally has full access to the standard builtins module and restricted environments are propagated. If the localsdictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment where eval() is called. The return value is the result of the evaluated expression. Syntax errors are reported as exceptions. Example:

>>>

>>> x = 1
>>> eval('x+1')
2

This function can also be used to execute arbitrary code objects (such as those created by compile()). In this case pass a code object instead of a string. If the code object has been compiled with 'exec' as the mode argument, eval()‘s return value will be None.

Hints: dynamic execution of statements is supported by the exec() function. The globals() and locals() functions returns the current global and local dictionary, respectively, which may be useful to pass around for use by eval()or exec().

See ast.literal_eval() for a function that can safely evaluate strings with expressions containing only literals.

print(eval(repr('test')))

test

print(eval(str('test')))

welcome to-python|Traceback (most recent call last):

  File "/Users/eunguru/Source/Python/InOut/src/InOut.py", line 76, in <module>

    print(eval(str('test')))

  File "<string>", line 1, in <module>

NameError: name 'test' is not defined

9) ascii(), repr()

- 아스키 문자열에 대해서는 동일한 값을 반환

- 아스키 이외의 값에 대해서는 백슬레쉬를 사용한 유니코드 값을 반환

print(repr('파이썬test'))

'파이썬test'

print(ascii('파이썬test'))

'\ud30c\uc774\uc36ctest'

print(eval(repr('파이썬test')))

파이썬test

print(eval(ascii('파이썬test'))

파이썬test

10) : 기호를 이용한 정렬, 폭, 부호, 공백처리, 소수점, 타입 지정

print("{0:$>5}".format(10))

$$$10

- {0:$>5}의 해석

0: 첫번째 인자, 10

$: 공백을 채우는 문자

>: 오른쪽 기준 정렬

5: 전체 자리수

- 정렬에 사용되는 기호: >(오른쪽 기준 정렬), <(왼쪽 기준 정렬), ^(가운데 정렬), =(부호표시, 공백 문자 앞에 부호가 표시)

- =를 사용하지 않으면 공백 문자들 뒤, 즉 숫자 앞에 부호가 표시 됨

print("{0:$=+5}".format(10))

+$$10

print("{0:$>+5}".format(10))

$$+10

- 부호를 나타내는 기호: +(플러스 부호 표시), -(마이너스 값만 마이너스 부호 표시), " "(마이너스 값에는 마이너스 부호를 나타내고 플러스 일때는 공백을 표시)

print("{0:$>+5}".format(10))

$$+10

print("{0:$>+5}".format(-10))

$$-10

print("{0:$>-5}".format(10))

$$$10

print("{0:$>-5}".format(-10))

$$-10

print("{0:$> 5}".format(10))

$$ 10

print("{0:$> 5}".format(-10))

$$-10

11) 진수 변환 출력

- b(2진수), d(10진수), x(16진수), o(8진수), c(문자열)

print("{0:x}".format(10))

a

print("{0:b}".format(10))

1010

print("{0:o}".format(10))

12

print("{0:d}".format(10))

10

print("{0:c}".format(65))

A

- # 사용: #x(16진수), #o(8진수), #b(2진수)

print("{0:#x}, {0:#o}, {0:#b}".format(10))

0xa, 0o12, 0b1010

12) 실수 변환 표현

- e(지수 표현), f(실수 표현), %(퍼센트 표현)

print("{0:e}".format(4 / 3))

1.333333e+00

print("{0:f}".format(4 / 3))

1.333333

print("{0:%}".format(4 / 3))

133.333333%

- 소수점 이하 자리 표현 지정

print("{0:.3f}".format(4 / 3))

1.333

2. 입력

- input(): 입력 인자로 화면에 출력할 프롬프트(생략가능), 결과값으로 문자열 객체를 반환

value = input('insert any keys : ')

print("value:", value)

insert any keys : test

value: test

파일 입출력

1. print() 함수의 file압력 인자를 이용

- 파일로 출력 테스트 (결과는 직접 확인)

# 파일로 출력 테스트 

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

print("file write", file=f)

f.close()

2. open()함수를 이용하여 파일을 연 후 작업 하는 방법(일반적인 방법)

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised.

file is either a string or bytes object giving the pathname (absolute or relative to 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 exclusive creation 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.getpreferredencoding(False) 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'	open for exclusive creation, failing if the file already exists
'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)
'U'	universal newlines mode (deprecated)

The default mode is 'r' (open for reading text, synonym of 'rt'). For binary read-write access, the mode 'w+b' opens and truncates the file to 0 bytes. 'r+b' opens the file without truncation.

As mentioned in the Overview, Python distinguishes between binary and text I/O. Files opened in binary mode (including 'b' in the mode argument) return contents as bytes objects without any decoding. In text mode (the default, or when 't' is included in the mode argument), the contents of the file are returned as str, the bytes having been first decoded using a platform-dependent encoding or using the specified encoding if given.

Note

 

Python doesn’t depend on the underlying operating system’s notion of text files; all the processing is done by Python itself, and is therefore platform-independent.

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 in bytes 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 (whatever locale.getpreferredencoding() returns), but any encoding supported by Python can be used. See the codecs module for the list of supported encodings.

errors is an optional string that specifies how encoding and decoding errors are to be handled–this cannot be used in binary mode. A variety of standard error handlers are available, though any error handling name that has been registered with codecs.register_error() is also valid. The standard names are:

• 'strict' to raise a ValueError exception if there is an encoding error. The default value of None has the same effect.
• 'ignore' ignores errors. Note that ignoring encoding errors can lead to data loss.
• 'replace' causes a replacement marker (such as '?') to be inserted where there is malformed data.
• 'surrogateescape' will represent any incorrect bytes as code points in the Unicode Private Use Area ranging from U+DC80 to U+DCFF. These private code points will then be turned back into the same bytes when the surrogateescape error handler is used when writing data. This is useful for processing files in an unknown encoding.
• 'xmlcharrefreplace' is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference &#nnn;.
• 'backslashreplace' (also only supported when writing) replaces unsupported characters with Python’s backslashed escape sequences.

newline controls how universal newlines mode works (it only applies to text mode). It can be None, '', '\n', '\r', and '\r\n'. It works as follows:

• When reading input from the stream, 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 newlines 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.
• When writing output to the stream, 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 and a file descriptor rather than a filename was given, the underlying file descriptor will be kept open when the file is closed. If a filename is given closefd has no effect and must be True (the default).

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 openerresults in functionality similar to passing None).

The newly created file is non-inheritable.

The following example uses the dir_fd parameter of the os.open() function to open a file relative to a given directory:

>>>

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

The type of file object returned by the open() function depends on the mode. When open() is used to open a file in a text mode ('w', 'r', 'wt', 'rt', etc.), it returns a subclass of io.TextIOBase (specifically io.TextIOWrapper). When used to open a file in a binary mode with buffering, the returned class is a subclass of io.BufferedIOBase. The exact class varies: in read binary mode, it returns a io.BufferedReader; in write binary and append binary modes, it returns a io.BufferedWriter, and in read/write mode, it returns a io.BufferedRandom. When buffering is disabled, the raw stream, a subclass of io.RawIOBase, io.FileIO, is returned.

See also the file handling modules, such as, fileinput, io (where open() is declared), os, os.path, tempfile, and shutil.

Changed in version 3.3: The opener parameter was added. The 'x' mode was added. IOError used to be raised, it is now an alias of OSError.FileExistsError is now raised if the file opened in exclusive creation mode ('x') already exists.

Changed in version 3.4: The file is now non-inheritable.

Deprecated since version 3.4, will be removed in version 4.0.

The 'U' mode.

1) read(), write(), close() 함수

- write(): 파일에 문자열을 씀, 몇바이트를 썼는지 정수로 반환

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

print(f.write('plow deep\nwhile sluggards sleep'))

31

f.close()

<test1.txt 내용>

plow deep

while sluggards sleep

- read(): 파일로 부터 데이터를 읽음, open()함수에서 mode를 주지 않으면 텍스트 읽기 모드로 열림

f = open('test1.txt')

print(f.read())

plow deep

while sluggards sleep

print("f.closed:", f.closed)

f.closed: False

f.close()

print("f.closed:", f.closed)

f.closed: True

- close(): 파일 객체를 닫음

- closed: 현재 해당 파일이 닫혀 있는지에 대한 부울 값을 나타냄 (True: 파일이 닫혀 있음, False: 파일이 닫혀있지 않음)

2) 바이너리 모드(binary mode)

- 텍스트 모드에서는 일반 문자열과 같이 encoding이 적용

a. 바이너리 데이터를 텍스트 모드로 처리하는 경우 인코딩 문제가 발생

f = open('intro2.mp3', 'w')

print(f.write(open('intro.mp3', 'r').read()))

Traceback (most recent call last):

  File "/Users/eunguru/Source/Python/InOut/src/InOut.py", line 128, in <module>

    print(f.write(open('intro.mp3', 'r').read()))

  File "/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/encodings/ascii.py", line 26, in decode

    return codecs.ascii_decode(input, self.errors)[0]

UnicodeDecodeError: 'ascii' codec can't decode byte 0x92 in position 221: ordinal not in range(128)

b. 바이너리 모드로 처리

f = open('intro2.mp3', 'wb')

print(f.write(open('intro.mp3', 'rb').read()))

239226

f.close()

3) readline(), readlines(), seek(), tell() 함수

- readline(): 한 줄씩 읽은 문자열을 반환

- readlines(): 파일의 모든 내용을 줄 단위로 잘라서 리스트를 반환

- seek(): 사용자가 원하는 위치로 파일 포인터를 이동

- tell(): 현재 파일에서 어디까지 읽고 썼는지 위치를 반환

f = open('test1.txt')

print(f.read())

plow deep

while sluggards sleep

print(f.read())

print(f.tell())

31

print(f.seek(0))

0

print(f.read())

plow deep

while sluggards sleep

print(f.seek(0))

0

print(f.readline())

plow deep

print(f.readline())

while sluggards sleep

print(f.readline())

print(f.seek(0))

0

print(f.readlines())

['plow deep\n', 'while sluggards sleep']

print(f.readlines())

[]

f.close()

4) with 구문

- with 구문을 사용해서 파일을 열고 코드 블록을 벗어나면 자동으로 파일이 닫힘

- as: 파일 핸들을 명시

- with 구문 안에서는 파일 핸들을 통해서 파일에 접근할 수 있음

with open('test1.txt') as f:

    print(f.readlines())

['plow deep\n', 'while sluggards sleep']

    print("f.closed:", f.closed)

f.closed: False

print("f.closed:", f.closed)

f.closed: True

3. pickle 모듈

- 리스트나 클래스등을 저장할 때 사용

- pickle로 저장할 수 있는 대상은 파이썬 객체라면 거의 모두 가능

1) dump() 함수: 파일에 객체 저장

colors = ['red', 'green', 'black']

print("colors:", colors)

colors: ['red', 'green', 'black']

import pickle

f = open('colors', 'wb')

pickle.dump(colors, f)

f.close()

2) load() 함수: 파일로 부터 객체를 읽음

del colors

print("colors:", colors)

Traceback (most recent call last):

  File "/Users/eunguru/Source/Python/InOut/src/InOut.py", line 161, in <module>

    print("colors:", colors)

NameError: name 'colors' is not defined

f = open('colors', 'rb')

colors = pickle.load(f)

f.close()

print("colors:", colors)

colors: ['red', 'green', 'black']

* pickle로 파일에 쓰거나 읽을때는 반드시 바이너리 모드로 파일을 열어야 함

f = open('colors', 'w')

pickle.dump(colors, f)

Traceback (most recent call last):

  File "/Users/eunguru/Source/Python/InOut/src/InOut.py", line 157, in <module>

    pickle.dump(colors, f)

TypeError: must be str, not bytes

3) 기본 자료형, 사용자 정의 클래스 객체로 저장 가능

class test:

    var = None

import pickle

a = test()

a.var = 'Test'

f = open('test', 'wb')

pickle.dump(a, f)

f.close()

f = open('test', 'rb')

b = pickle.load(f)

f.close()

print("b:", b)

b: <__main__.test object at 0x102102208>

print("b.var:", b.var)

b.var: Test

* 클래스가 정의 되지 않은 상태에서는 load할 수 없음

del test

f = open('test', 'rb')

b = pickle.load(f)

Traceback (most recent call last):

  File "/Users/eunguru/Source/Python/InOut/src/InOut.py", line 183, in <module>

    b = pickle.load(f)

AttributeError: Can't get attribute 'test' on <module '__main__' from '/Users/eunguru/Source/Python/InOut/src/InOut.py'>