Python 2.7 기본 튜토리얼: 입력 및 출력

.. _tut-io:

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

입력과 출력

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

프로그램의 출력을 표시하는 방법에는 여러 가지가 있습니다.

사람이 읽을 수 있는 형식으로 인쇄하거나 이 장에서는

몇 가지 가능성에 대해 설명합니다.

프로그램 출력을 표현하는 방법에는 여러 가지가 있습니다. 사람이 읽을 수 있는 형식으로 인쇄하거나 기록할 수 있습니다. 나중에 사용할 수 있는 파일입니다. 이 장에서는 몇 가지 대체 방법에 대해 설명합니다.

.. _tut-formatting:

더 멋진 출력 형식

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

지금까지 우리는 값을 쓰는 두 가지 방법, 즉 *표현문*과

:keyword:`print` 문. (세 번째 방법은 파일 개체의 :meth:`write` 메서드를 사용하는 것

표준 출력 파일은 ``sys.stdout``으로 참조할 수 있습니다.

이에 대한 자세한 내용은 라이브러리 참조를 참조하세요.)

값을 출력하는 두 가지 매우 다른 방법이 있습니다: *expression 문* 및 :keyword:`print` 문 . (

접근의 세 번째 유형은 파일 객체의 :meth:`write` 메소드를 사용하는 것입니다. 표준 파일 출력은

``sys.stdout``을 참조하세요. 자세한 내용은 라이브러리 참조 매뉴얼을 참조하세요. )

.. index:: module: string

종종 단순히

공백으로 구분된 값을 인쇄하는 방법은 두 가지가 있습니다.

첫 번째 방법은 문자열 슬라이싱과

모든 문자열 처리를 직접 수행하는 것입니다.

표준 모듈 :mod:`string`에는

주어진 열 너비에 문자열을 추가하는 데 유용한 작업이 포함되어 있습니다. 이에 대해서는 곧 설명하겠습니다.

: meth:`str.format` 방법을 사용하는 방법이 있습니다.

단순히 공백 구분 기호를 인쇄하는 것보다 출력 형식을 더 복잡하게 제어하고 싶을 수도 있습니다. 출력 형식을 지정하는 방법에는

두 가지가 있습니다. 첫 번째는 전체 문자열을 제어하고 문자 자르기 및 연결 작업을 사용하여 원하는 출력 형식을 만드는 것입니다. 표준 모듈 :mod:`string`에는 주어진 열에 문자열을 채울 때 유용한 여러 작업이 포함되어 있습니다. 이에 대해서는 나중에 논의하겠습니다.

두 번째 방법은 :meth:`str.format` 방법을 사용하는 것입니다.

물론 한 가지 질문이 남습니다. 값을 문자열로 어떻게 변환합니까? 다행히도

Python에는 모든 값을 문자열로 변환하는 방법이 있습니다. 이를 :func:`에 전달합니다. repr`

또는 :func:`str` 함수.

물론, 값을 문자열로 변환하는 방법에 대한 또 다른 질문이 있습니다. 다행히 Python에는

값을 문자열로 변환하는 방법이 있습니다. 해당 값을 :func:`repr` 또는 :func:`str` 함수에 전달하세요.

:func:`str` 함수는

사람이 읽을 수 있는 값의 표현을 반환하기 위한 반면, :func:`repr`은 표현을 생성하기 위한 것입니다

인터프리터가 읽을 수 있습니다(또는

동등한 구문이 없는 경우 :exc:`SyntaxError`가 발생합니다).

인간 소비를 위한 표현, :func:`str`은

:func:`repr`과 동일한 값을 반환합니다. 숫자나 목록 및

사전과 같은 구조와 같은 많은 값을 반환합니다. 문자열과

부동 소수점 숫자는 특히 두 가지 서로 다른 표현을 사용합니다.

함수:func:`str`은 값을 인간으로 변환하는 데 사용됩니다. 읽을 수 있는 형식이며 :func:`repr`은 인터프리터가

을 읽을 수 있는 형식으로 변환됩니다(동등한 구문이 없으면 :exc:`SyntaxError` 예외가 발생합니다). 적합

사람이 읽을 수 있는 형식에서 :func:`str`은 :func:`repr`과 동일한 값을 반환합니다. 숫자값이나 연결리스트, 사전과 같은

구조 등 많은 유형은 각 기능에 대해 통일된 해석 방법을 가지고 있습니다. 문자열과

부동 소수점 숫자에는 고유한 해석 방법이 있습니다.

몇 가지 예:

다음은 몇 가지 예입니다.:

>>> s = 'Hello, world.'

> > > str(s)

'Hello, world.'

>>> repr(s)

"'Hello, world.'" >>> s = 'x의 값은 '+repr(x)+'이고, y는 '+repr(y)+'...'

>>> print s

x의 값은 32.5이고 y는 40000입니다...

>>> ) 문자열에 문자열 따옴표와 백슬래시를 추가합니다.

   ... hello = 'hello, world/n'

   >>> hellos = 담당자(안녕하세요)

   >>> hellos 인쇄

   'hello, world/n'

   >>> # repr()에 대한 인수는 Python 객체일 수 있습니다:

   ... repr((x, y, ('spam', 'eggs')))

   "(32.5, 40000, ('spam', 'eggs'))"

정사각형과 정육면체로 구성된 표를 작성하는 두 가지 방법은 다음과 같습니다.

有两种方式可以写平方和立方表 ::

   >>> for x in range(1, 11):

   ...     print repr(x).rjust(2), repr(x*x).rjust(3),

   .. .     # 이전 줄의 후행 쉼표에 주의하세요

   ...     print repr(x*x*x).rjust(4)

   ...

    1   1    1

    2   4    8

    3   9   27

    4  16   64

    5  25  125

    6  36  216

7  49  343

    8  64  512

    9  81  729

   10 100 1000

   >>> for x in range(1,11):

   ...     print '{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x* x)

   ...

    1   1    1

    2   4    8

    3   9   27

    4  16   64

    5  25  125

    6  36  216

    7  49  343

    8  64  512

    9  81 72 9

   10 100 1000

(첫 번째 예에서는

:keyword:`print` 방식으로 각 열 사이에 공백 하나를 추가했습니다. 이는 항상 인수 사이에 공백을 추가합니다.)

（注意第一个例子， :keyword:`print` 在每列之间加了一个空格，它总是在参

数间加入空格。)

이 예는 문자열 객체의 :meth:`rjust` 메서드를 보여줍니다. 이 메서드는

주어진 너비의 필드에서 왼쪽에 공백을 채워

문자열을 오른쪽 정렬합니다.  비슷한 방법인 :meth:`ljust`와 :meth:`center`가 있습니다.  이러한

메서드는 아무 것도 쓰지 않고 새 문자열만 반환합니다.  입력

문자열이 너무 길면 자르지 않고 그대로 반환합니다. 이는

열 레이아웃을 엉망으로 만들지만 일반적으로 값에 대해 거짓말을 하는 대안

보다는 낫습니다.  (절단을 정말로 원한다면

항상 ``x.ljust(n)[:n]``처럼 슬라이스 작업을 추가할 수 있습니다.)

以上是一个 :meth: `rjust` j 的 演示 演示, 它 把 字符串 字符串 字符串 到 到 一 列 列 列 列 列 列 列 列 列 列 向 向 向 左

侧 侧 填充 空格 空格 空格 来 使 使 其 右 对齐 对齐。 类似 的 的 还 有 有 : 메트 :`ljust` 和 :`meth :` 센터`

.而是样输출，这会使你的输格式变得混乱, 不过总强过另一种选择（截

断字符串）,因为那样会产生错误的输流值. （如果你确实需要截断它，可以使

사용切割操작,例如： ``x.ljust(n)[:n]`` .)

숫자를 채우는 또 다른 방법인 :meth:`zfill`이 있습니다. 왼쪽

문자열은 0입니다.  더하기 및 빼기 기호를 이해합니다.

还有另一个方法， :meth:`zfill` 它用于向数值的字符串表达左侧填充 0。该

函数可以正确理解正负号 ::

   >>> '12'.zfill(5)

   '00012'

   >>> '-3.14'.zfill(7)

   '-003.14'

   >>> '3.14159265359'.zfill(5)

   '3.14159265359'

:meth:`str.format` 메서드의 기본 사용법은 다음과 같습니다.

방법 :meth: `str.format` 的基本사용법如下 ::

   >>> print '우리는 "{}!"라고 말하는 {}입니다'.format('knights', 'Ni')

   우리는 "Ni!"라고 말하는 기사입니다

괄호 그 안의 문자(형식 필드라고 함)는

:meth:`~str.format` 메소드에 전달된 객체로 대체됩니다.  

괄호 안의 숫자는

:meth:`~str.format` 메서드에 전달된 개체의 위치를 ​​나타냅니다. :

大括号和其中的字符会被替换成传入 :meth:`~str.format` 的参数。大括号中

的数值指明使用传入 :meth:` ~str.format` 방법적 对象中的哪一个 ::

>>> '{0} 및 {1}'.format('spam', 'eggs')

스팸 및 계란

>>> ; '{1} 및 {0}'.format('spam', 'eggs')

계란 및 스팸

키워드 인수가 :meth:`~str에 사용되는 경우 인쇄 .format` 메서드에서 해당 값은

인수 이름을 사용하여 참조됩니다. :

:meth:`~str.format` 호출 시 키워드 인수를 사용하면 다음과 같은 작업을 수행할 수 있습니다. 매개변수 이름으로

값 참조::

>>> print '이 {음식}은 {형용사}입니다.'.format(

... food='spam', adjective='완전히 끔찍함')

이 스팸은 정말 끔찍합니다.

위치 및 키워드 인수는 임의로 조합할 수 있습니다.

위치 및 키워드 인수 매개변수는 다음과 같이 조합하여 사용할 수 있습니다:

>>> print '{0}, {1} 및 {other}의 이야기.'.format('Bill', 'Manfred',

... other='Georg')

Bill, Manfred, Georg의 이야기.

``'!s'`` (적용:func: `str`) 및 ``'!r'``(apply:func:`repr`)을 사용하여

형식을 지정하기 전에 값을 변환할 수 있습니다. :

``' !s '`` ( :func:`str` 적용) 및 ``'!r'`` ( :func:`repr` 적용)은 서식을 지정하기 전에

값을 변환할 수 있습니다. ::

>>> import math

>>> print 'PI 값은 대략 {}.'.format(math.pi)

PI 값은 대략 3.14159265359입니다.

>>> print 'PI 값은 대략 {!r}.'.format(math.pi)

PI 값은 대략 3.141592653589793입니다.

선택적인 ``':'`` 및 형식 지정자가 필드 이름 뒤에 올 수 있습니다. 이를 통해

값 형식을 더 효과적으로 제어할 수 있습니다. 다음 예에서는

Pi를 소수점 이하 세 자리로 자릅니다.

필드 이름 뒤에 선택적인 ``':'`` 및 형식 지시문을 허용합니다. 이를 통해

값의 형식을 더욱 세밀하게 제어할 수 있습니다. 다음 예에서는 Pi를 세 자리 정밀도로 변환합니다. ::

>>> import math

>>> print 'PI 값은 대략 {0:.3f}입니다.'.format(math.pi )

PI 값은 약 3.142입니다.

``':'`` 뒤에 정수를 전달하면 해당 필드의 문자 수가 최소

가 됩니다. 이 기능은 테이블을 예쁘게 만드는 데 유용합니다. :

필드 뒤의 ``':'`` 뒤에 정수를 추가하면 필드의 최소 너비가 제한되므로 테이블을 아름답게 꾸밀 때 유용합니다.

매우 유용합니다. ::

>>> 테이블 = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}

>>> table.items()의 전화:

... 인쇄 '{0:10} ==> {1:10d}'.format(이름, 전화)

...

Jack ==> 4098

Dcab ==> 7678

Sjoerd ==> 4127

형식이 매우 긴 경우 분할하고 싶지 않은 경우

위치 대신 이름

으로 형식이 지정되는 변수를 참조할 수 있다면 좋을 것입니다. dict를 사용하고

대괄호 ``'[]'``를 사용하여 키에 액세스합니다.

매우 긴 형식 문자열이 있고 이를 분할하고 싶지 않은 경우.

형식의 변수를 위치 대신 이름으로 참조할 수 있으면 좋을 것 같습니다.

대괄호::

>>> table = {'Sjoerd': 4127, 'Jack': 4098을 사용하여 사전을 전달하고 해당 키에 액세스하는 간단한 방법이 있습니다. , 'Dcab': 8637678}

>>> print ('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '

... 'Dcab: {0[Dcab]:d}'.format(table))

Jack: 4098; Sjoerd: 4127; Dcab: 8637678

이 작업도 수행할 수 있습니다. '**'

표기법을 사용하여 테이블을 키워드 인수로 전달합니다. ::

>>> 테이블 = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}

>>> : {Jack:d}; Dcab: {Dcab:d}'.format(**table)

Sjoerd: 4127

이 기능은 새로 내장된 :func:`vars`와 함께 사용하면 특히 유용합니다

모든 지역 변수가 포함된 사전을 반환하는 함수.

이 접근 방식은 새로운 내장 함수인 :func:`vars`와 함께 사용하면 매우 효과적입니다. 이 함수는 모든 지역

변수를 포함하는 사전을 반환합니다.

:meth:`str.format`을 사용한 문자열 형식 지정에 대한 전체 개요는

:ref:`formatstrings`를 참조하세요.

문자열 형식 지정에 대해 자세히 알아보려면 :meth:`str.format`,

:ref:`formatstrings`를 참조하세요.

이전 문자열 형식 이전 문자열 형식

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

``%`` 연산자는 문자열 형식 지정에도 사용할 수 있습니다. 이 연산자는

왼쪽 인수를 :cfunc :`sprintf`/처럼 해석합니다. 스타일 형식 문자열을 오른쪽 인수에

적용하고 이 형식

작업의 결과 문자열을 반환합니다. 예:

연산자 ``%``도 가능합니다. 문자열 형식화에 사용됩니다. :cfunc:`sprintf`

와 유사한 방식으로 왼쪽 매개변수를 구문 분석하고, 여기에 오른쪽 매개변수를 적용하고, 형식 지정 작업으로 생성된 문자열을 가져옵니다(예::

). >> > import math

>>> print 'PI 값은 약 %5.3f입니다.' % math.pi

PI 값은 약 3.142입니다. .

:meth:`str.format`은 꽤 새로운 것이기 때문에 많은 Python 코드는 여전히 ``%``

연산자를 사용합니다. 결국에는

언어에서 제거되므로 일반적으로 :meth:`str.format`을 사용해야 합니다.

:meth:`str.format`은 여전히 ​​매우 새롭고 많은 Python에서 사용되기 때문입니다. 코드는 여전히 ``연산자를 사용하고 있습니다.

그러나 이전 형식 지정 방법은 결국 언어에서 제거되므로

　:meth:`str.format`을 가능한 한 사용해야 합니다.

추가 정보는 :ref:`string-formatting` 섹션에서 확인할 수 있습니다.

추가 정보는 :ref:`string-formatting` 섹션에서 확인할 수 있습니다.

.. _tut-files:

파일 읽기 및 쓰기 파일 읽기 및 쓰기

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

.. index::

내장: open

객체: 파일

:func:`open`은 파일 객체를 반환하며 가장 일반적으로 두 가지

인수와 함께 사용됩니다: ``open(filename, mode)`` .

함수:func:`open`은 파일 객체를 반환합니다. 일반적인 사용에는

``open(filename, mode)``라는 두 개의 매개변수가 필요합니다.

::

>>> f = open('/tmp/workfile', 'w')

>>> 🎜>

첫 번째 인수는 파일 이름을 포함하는 문자열입니다.

또 다른 인수입니다. 파일이

사용되는 방식을 설명하는 몇 개의 문자가 포함된 문자열입니다. *mode*는 파일을 읽기만 하는 경우 ``'r'``일 수 있으며, ``'w'``

쓰기 전용이며(동일한 이름의 기존 파일은 삭제됨)

``'a'``는 파일에 기록된 모든 데이터를 추가하기 위해 파일을 엽니다.

``'r+'``는 읽기 및 쓰기용으로 파일을 엽니다.

*mode* 인수는 선택 사항입니다.

생략된 경우

첫 번째 매개변수는 파일 이름을 식별하는 문자열입니다. 두 번째 매개변수는 제한된 수의 문자로 구성된

문자열로, 파일 사용 방법을 설명합니다. 선택적인 *모드*는 다음과 같습니다: ``'r'``, 이 옵션은 파일을 읽기 전용으로 만듭니다.

``'w'``, 이 옵션은 파일을 쓰기 전용으로 만듭니다( 동일한 이름, 이 작업은 원본 파일을 덮어씁니다.),

이 옵션은 파일을 추가 모드로 엽니다. 읽기 및 쓰기 모드에서

*mode* 매개변수는 선택사항입니다. 지정하지 않으면 기본값은 ``'r'`` 모드입니다.

Windows에서는 모드 뒤에 ``'b'``를 붙이면 바이너리 모드로 파일이 열리므로

``'rb'``, ``' wb'`` 및 ``'r+b'``. Windows의 Python은

텍스트 파일에서 줄 끝 문자를 구분합니다. 데이터를 읽거나 쓸 때 자동으로 약간 변경됩니다.

파일 데이터에 대한 이러한 배후 수정은 ASCII 텍스트 파일에는 괜찮지만

이러한 바이너리 데이터는 손상됩니다. :file:`JPEG` 또는 :file:`EXE` 파일.

유닉스에서는

이러한 파일을 읽고 쓸 때 바이너리 모드를 사용하는 것이 좋습니다. 모드에 ``'b'``를 추가하면

모든 바이너리 파일에 대해 플랫폼 독립적으로 사용할 수 있습니다.

Windows 플랫폼에서는 ``'b'`` mode는 파일을 바이너리 모드로 열므로

``'rb'``, ``'wb'``, ``'r+b'`` 등과 유사한 모드 조합이 있을 수 있습니다. . Windows 플랫폼에서는 텍스트 파일과 바이너리 파일 간에 차이가 있습니다. 텍스트 파일을 읽고 쓸 때 줄 종결자가 자동으로 줄 끝에 추가됩니다. 이런 백스테이지 씨발

ASCII 텍스트 파일에는 문제가 없으나, JPEG, .EXE 등 바이너리

파일을 실행할 경우 손상이 발생할 수 있습니다. 이러한 파일을 작동할 때는 반드시 바이너리 모드로 열어야 합니다.

Unix에서는 ``'b'`` 모드를 추가하는 것도 무해하므로 모든 바이너리 파일 처리에 플랫폼 독립적으로 사용할 수 있습니다.

.. _tut-filemethods:

파일 객체의 메서드 파일 객체 메서드

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

이 섹션의 나머지 예제에서는

`이라는 파일 객체를 가정합니다. `f`는 이미 생성되었습니다.

이 섹션의 예에서는 모두 파일 개체 ``f``가 이미 생성되었다고 가정합니다.

파일 내용을 읽으려면 ``f.read(size)``를 호출하세요. 이 호출은

일정량의 데이터를 읽고 문자열로 반환합니다. *size*는 선택적 숫자입니다. 인수입니다.

*size*가 생략되거나 음수인 경우 파일의 전체 내용을 읽고

파일이 컴퓨터의 두 배라면 문제가 됩니다.

메모리. 그렇지 않으면 최대 *size* 바이트를 읽고

파일의 끝에 도달하면 ``f.read()``는 빈 문자열( ``""``).

파일 내용을 읽으려면 ``f.read(size)``를 호출해야 합니다. 이 메서드는 일정량의 데이터를 읽어서 단어로 씁니다

내용을 문자열 형식으로 반환합니다. *size*는 문자열 길이를 지정하는 선택적 값입니다.

size를 지정하지 않거나 음수로 지정하면 파일 전체를 읽어서 반환합니다. 파일 크기가 현재 시스템 메모리의 두 배

배인 경우 문제가 발생합니다. 반대로 데이터는 가능한 한 크게 읽어서 반환됩니다.

파일 끝에 도달하면 f.read()는 빈 문자열("")을 반환합니다.

::

>>> f.read()

'전체 파일입니다./n'

>> ;> f.read()

''

``f.readline()``은 파일에서 줄바꿈 문자(``/n``)를 한 줄 읽습니다.

은 문자열 끝에 남고, 파일이 개행 문자로 끝나지 않는 경우

파일의 마지막 줄에서만 생략됩니다.

명확합니다. ``f.readline()``이 빈 문자열을 반환하면

빈 줄은 ``'/n''으로 표시됩니다. ` `, 단일 줄 바꿈만 포함하는 문자열

``f.readline()``은 파일에서 한 줄을 읽고 줄 바꿈 문자가 자동으로 끝에 추가됩니다. 문자열

( ``/n`` )의 경우 파일의 마지막 줄이 개행 문자로 끝나지 않는 경우에만 이 작업이 무시됩니다.

이렇게 하면 반환 값에 대한 혼동이 없습니다. ``f.readline()``이 빈 문자열을 반환하면

파일 끝에 도달했다는 의미입니다. . A 빈 줄은 개행 문자만 포함하는 문자열인 ``'/n``으로 설명됩니다. ::

>>> f.readline()

'파일의 첫 번째 줄입니다./n'

>>> f.readline()

'파일의 두 번째 줄/n'

>>> f.readline()

''

``f.readlines()``는 파일에 있는 모든 데이터 라인을 포함하는 목록을 반환합니다.

선택적 매개변수 *sizehint*가 주어지면

파일과 한 줄을 완성하기에 충분한 양을 더한 다음 그 줄을 반환합니다.

이것은

대용량 파일을 한 줄씩 효율적으로 읽을 수 있도록 하는 데 자주 사용되지만

전체 줄만 반환됩니다.

f.readlines()는 파일의 모든 데이터 줄이 포함된 목록을 반환합니다.

*sizehint* 매개변수가 제공되면 두 줄 이상의 비트를 읽고 여러 줄의 텍스트가 반환됩니다. 이 함수

는 일반적으로 전체 파일을 메모리로 읽을 필요 없이 큰 줄의 파일을 효율적으로 읽는 데 사용됩니다. 이 작업은 전체

행만 반환합니다. ::

>>> f.readlines()

['파일의 첫 번째 줄입니다./n', '파일의 두 번째 줄/n']

줄 읽기의 또 다른 접근 방식은 파일 개체를 반복하는 것입니다. 이는

메모리 효율적이고 빠르며 코드가 더 간단해집니다

줄바꿈이 있습니다. -line reading 좋은 방법은 파일 객체를 반복하는 것입니다. 이것은 기억하기 쉽고 빠르며 코드가 더 간단합니다::

>>> for line in f:

print line,

이것이 첫 번째입니다.

파일의 두 번째 줄

대체 접근 방식은 더 간단하지만

두 가지 접근 방식이 라인 버퍼링을 관리하므로 세밀한 제어를 제공하지 않습니다.

혼합해서는 안 됩니다.

이 방법은 매우 간단하지만 동작을 완전히 제어할 수는 없습니다. 두 메소드는 버퍼

를 관리하는 방식이 다르기 때문에 혼합할 수 없습니다.

``f.write(string)``는 *string*의 내용을 파일에 쓰고

``None``을 반환합니다.  

``f.write(string)`` 将 *string* 的内容写入文件，返回 ``None`` 。 ::

   >>> f.write('This is a test/n')

문자열이 아닌 다른 것을 쓰려면 문자열로 변환해야 합니다

먼저:

如果需要写入字符串以externative数据，就要先把这些数据转换为字符串。 ::

   >>> value = ('답변', 42)

   >>> s = str(값)

   >>> f.write(s)

``f.tell()``은 파일 시작 부분부터 바이트 단위로 측정된

파일 내 파일 객체의 현재 위치를 제공하는 정수를 반환합니다.  파일

객체의 위치를 ​​변경하려면 ``f.seek(offset, from_what)``을 사용하세요.  위치는

기준점에 *오프셋*을 추가하여 계산됩니다. 참조점은

*from_what* 인수에 의해 선택됩니다.  *from_what* 값 0은 파일의 처음부터

측정하고, 1은 현재 파일 위치를 사용하고, 2는 파일 끝을

참조 지점으로 사용합니다.  *from_what*은 생략할 수 있으며

파일의 시작 부분을 참조점으로 사용하여 기본값은 0입니다. 

``f.tell()`` 返回一个整数 ，代表文件对象在文件中的指针位置，该数值计weight了自文

件开头到指针处的比特数。需要改变文件对象指针话话，使用

``f.seek(offset,from_what)`` .指针在该操作中从指定的引用位置移动 *offset*

특히,引用位置由 *from_what* 参数指定。 *from_what* 值为 0 表示自文件

起始处开始，1 表示自当前文件指针位置开始，2表示自文件末尾开始。 *from_what* 可以

忽略，其默认值为零，此时从文件头开始。 ::

   >>> f = open('/tmp/workfile', 'r+')

   >>> f.write('0123456789abcdef')

   >>> f.seek(5)     # 파일의 6번째 바이트로 이동

   >>> f.read(1)

   '5'

   >>> f.seek(-3, 2) # 끝 전 3번째 바이트로 이동

   >>> f.read(1)

   'd'

파일 작업이 끝나면 ``f.close()``를 호출하여 파일을 닫고 파일을 비우세요

열린 파일이 차지하는 시스템 리소스입니다.  ``f.close()``를 호출한 후

파일 객체를 사용하려는 시도는 자동으로 실패합니다. 

文件使用完后，调用 ``f.close()`` 可以关闭文件，释放打开文件后表 系统资源。

调用 ``f.close()``之后，再调用文件对象会自动引发错误。 ::

   >>> f.close()

   >>> f.read()

   역추적(가장 최근 호출 마지막):

     파일 "", 1행, ?

   ValueError: I/O 작업 닫힌 파일

파일

객체를 다룰 때는 :keyword:`with` 키워드를 사용하는 것이 좋습니다.  이는 도중에 예외가 발생하더라도

제품군이 완료된 후 파일이 제대로 닫히는 장점이 있습니다.  또한

같은 내용을 작성하는 것보다 훨씬 짧습니다:keyword:`try`/ -/ :keyword:`finally` 블록

용关键字 :keyword:`with` 处理文件对象是个好习惯。它的先进之处在于文件

用完后会自动关闭，就算发生异常也没关系。它是 :keyword:`try`/ -/

:keyword :`드디어 ` 块的简写。 ::

    >>> open('/tmp/workfile', 'r')을 f:

    ...     read_data = f.read()

    >>> f.closed

    참

파일 객체에는 :meth:`~file.isatty` 및

:meth:`~file.truncate`와 같은 몇 가지 추가 메서드가 있습니다. 덜 자주 사용되는 것; 파일 객체에 대한 전체 가이드는 라이브러리

참조를 참조하세요.

文件对象还有一些不太常用的附加方法，比如 :meth:`~file.isatty` and :meth: `~file.truncate` 在库参

考手册中有文件对象的完整指南。

.. _tut-pickle:

:mod:`pickle` 모듈   :mod:`pickle` 模块

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

.. index:: module: pickle

문자열은 파일에서 쉽게 쓰고 읽을 수 있습니다. 숫자는 조금 더

노력이 필요합니다. :meth:`read` 메서드는 문자열만 반환하므로

:func:`int`와 같은 함수에 전달되어야 합니다. ``'123'``

과 같은 문자열을 가져와서 숫자 값 123을 반환합니다.  그러나 더 복잡한 내용을 저장하려는 경우

목록, 사전, 클래스 인스턴스와 같은 데이터 유형은 상황이 훨씬 더 복잡해집니다

복잡해집니다.

파일에서 문자열을 쉽게 읽고 쓸 수 있습니다. :meth:`read`

메소드는 문자열만 반환하고 :func:`int`와 같은 메소드에 전달해야 하기 때문에 숫자 값은 조금 더 문제가 필요합니다. 그런 다음

``'123'``과 같은 문자는 해당 값 123으로 변환됩니다. 그러나 목록, 사전, 클래스 인스턴스 등 더 복잡한

데이터 유형을 저장해야 하면 상황이 더 복잡해집니다.

복잡한 데이터 유형을 저장하기 위해

사용자가 끊임없이 코드를 작성하고 디버깅하도록 하는 대신 Python은 :mod:`pickle`이라는 표준 모듈을 제공합니다.

이것은 거의 모든 Python 객체(심지어

Python 코드의 일부 형식까지!)를 가져와 문자열 표현으로 변환할 수 있는 놀라운 모듈입니다.

이 프로세스를 :dfn:`pickling`이라고 합니다. 문자열

표현에서 객체를 재구성하는 것을 :dfn:`unpickling`이라고 합니다. 피클링과 언피클링 사이에

객체를 나타내는 문자열이 파일이나 데이터에 저장되었을 수 있습니다. 🎜>

네트워크 연결을 통해 멀리 있는 시스템으로 전송됩니다.

다행히도 사용자는 복잡한 데이터 유형을 저장하기 위해 코드를 직접 작성하고 디버깅할 필요가 없습니다. Python은

:mod:`pickle`이라는 표준 모듈을 제공합니다. 이것은 거의 모든

Python 객체(심지어 일부 Python 코드 조각도!)를 문자열로 표현할 수 있는 놀라운 모듈입니다. 이 프로세스를

캡슐화( :dfn:`pickling` )라고 합니다. 문자열 표현식에서 객체를 재구성하는 것을 unpacking

( :dfn:`unpickling` )이라고 합니다. 캡슐화된 상태의 개체는 파일이나 개체에 저장될 수 있으며, 네트워크를 통해 원격 시스템 간에 전송될 수도 있습니다.

객체 ``x``와 쓰기를 위해 열린 파일 객체 ``f``가 있는 경우

객체를 피클하는 가장 간단한 방법은 한 줄만 사용하면 됩니다. code

객체 ``x``, 파일 객체 ``f``가 쓰기 모드로 열린 경우 객체를 캡슐화하는 가장 간단한

방법은 한 줄의 코드만 있으면 됩니다. : :

pickle.dump(x, f)

``f``가 읽기 위해 열린 파일 객체인 경우

객체를 다시 unpickle하려면

``f``가 읽기 모드에서 열린 파일 객체인 경우 객체를 다시 로드하고 압축을 풀 수 있습니다::

x = pickle.load(f)

(많은 객체를 피클링할 때 또는

피클된 데이터를 파일에 쓰고 싶지 않을 때 사용되는 다른 변형이 있습니다. :mod에 대한 전체

문서를 참조하세요. ` Python 라이브러리 참조의 pickle`을 참조하세요.)

(패킹된 데이터를 파일에 쓰고 싶지 않은 경우 사용 가능한 다른 변형이 있습니다. 전체

:mod:`pickle ` 문서는 Python 라이브러리 참조 매뉴얼을 참조하세요).

:mod:`pickle`은 저장하고

다른 프로그램이나 향후 동일한 프로그램 호출을 통해 재사용할 수 있는 Python 객체를 만드는 표준 방법입니다.

이에 대한 기술적인 용어는 :dfn:`persist` 객체입니다. :mod:`pickle`은

매우 널리 사용되기 때문에 Python 확장을 작성하는 많은 작성자는

행렬과 같은 새로운 데이터 유형은 적절하게 피클되거나 피클되지 않을 수 있습니다.

:mod:`pickle`은 나중에 다른 프로그램이나 자체에서 사용할 수 있도록 Python 객체를 저장하는 표준 방법입니다.

이 기술 세트를 제공하는 것은 :dfn:`percious` 객체입니다. :mod:`pickle`이 널리 사용되기 때문에 많은 Python 확장 작성자는 행렬과 같은 새로운 데이터 유형이 패키징 및 언패킹에 적합한지 여부에 큰 관심을 기울입니다.

위 내용은 Python 2.7의 기본 튜토리얼: 입출력 내용입니다. 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!