python有多種輸出方式：屏幕打印數據，或者寫入文件。

格式化輸出

我們有兩種大相徑庭地輸出值方法：表達式語句* 和 print() 函數(第三種方法使用文件對象的write()方法，標準文件輸出可以參考sys.stdout)。

通常需要對輸出做更多的格式控制，而不是簡單的打印空格分隔值。有兩種方法可以格式化你的輸出：第一種方法是由你自己處理整個字符串，通過使用字符串切片和連接操作可以創建任何你想要的輸出形式。string 類型包含一些將字符串填充到指定列寬度的有用操作。第二種方法是使用 str.format() 方法。

標準模塊 string 的Template 類可以替換字符串的值。(python標準模塊介紹-string:文本常量和模板)

Python 有辦法將任意值轉為字符串： repr() 或 str() 函數。

函數 str() 用于將值轉化為適于人閱讀的形式，而 repr() 轉化為供解釋器讀取的形式（如果沒有相關語法，則會發生 SyntaxError 異常，沒有str() 會返回與 repr() 等同的值。很多類型，諸如數值或列表、字典這樣的結構，兩者解讀方式相同。字符串和浮點數則不同。

下面有些例子:

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... 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), end=' ')
...     # Note use of 'end' on previous line
...     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  729
10 100 1000

(注意第一個例子，print() 在每列之間加了一個空格，默認在參數間加入空格。)

以上是一個 str.rjust() 方法的演示，它把字符串輸出到一列，并通過向左側填充空格來使其右對齊。類似的方法還有 str.ljust() 和 str.center()。如果輸出的字符串太長，它們也不會截斷它，而是原樣輸出，這會使你的輸出格式變得混亂(如果你確實需要截斷它，可以使用切割操作，例如：x.ljust(n)[:n] ）。

str.zfill() 用于向數值的字符串表達左側填充 0。該函數可以正確識別正負號:

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

方法 str.format() 的基本用法如下:

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

大括號和其中的字符會被替換成傳入 str.format() 的參數。大括號中的數值指明使用傳入 str.format() 方法的對象中的哪一個:

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

如果在 str.format() 使用關鍵字參數，可以通過參數名來引用值:

>>> print('This {food} is {adjective}.'.format(
...       food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

位置參數和關鍵字參數可以隨意組合:

>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
                                                       other='Georg'))
The story of Bill, Manfred, and Georg.

'!a' (應用 ascii())，'!s' （應用 str() ）和 '!r' （應用 repr() ）可在格式化之前轉換值:

>>> contents = 'eels'
>>> print('My hovercraft is full of {}.'.format(contents))
My hovercraft is full of eels.
>>> print('My hovercraft is full of {!r}.'.format(contents))
My hovercraft is full of 'eels'.

字段名后允許可選的 ':' 和格式指令。這允許對值的格式化更多的控制。下例將 Pi 轉為三位精度。

>>> import math
>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))
The value of PI is approximately 3.142.

在字段后的 ':' 后面的整數會限定該字段的最小寬度，這在美化表格時很有用:

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, phone))
...
Jack       ==>       4098
Dcab       ==>       7678
Sjoerd     ==>       4127

很長的格式化字符串又不想分割，可以傳入一個字典，用中括號( '[]' )訪問它的鍵:

>>> 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

也可以用 ‘**’ 標志將這個字典以關鍵字參數的方式傳入:

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

這種方式與新的內置函數 vars() 組合使用非常有效。該函數返回包含所有局部變量的字典。

要進一步了解字符串格式化方法 str.format()，參見 格式字符串語法。

• 舊式的字符串格式化

操作符 % 也可以用于字符串格式化。它以類似 sprintf()-style 的方式解析左參數，將右參數應用于此，得到格式化操作生成的字符串，例如:

>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.

更多的信息可以參見 printf-style String Formatting 。

文件讀寫

函數 open() 返回 文件對象，通常的用法需要兩個參數：open(filename, mode)。

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

第一個參數是文件名。第二個參數也是字符串，含有描述如何使用該文件的幾個字符。mode為'r' 時表示只是讀取文件；'w' 表示只是寫入文件（已經存在的同名文件將被刪掉）； 'a'表示打開文件進行追加，寫入到文件中的任何數據將自動添加到末尾。 'r+' 表示打開文件進行讀取和寫入。mode參數是可選的，默認為'r' 。

通常，文件以text模式打開，這意味著，你從文件讀出和向文件寫入的字符串會被特定的編碼方式(類Linux默認是UTF-8,windows經常為gbk，容易導致一些IO問題)編碼。模式后面的'b'以二進制模式打開文件：數據會以字節對象的形式讀出和寫入。這種模式應該用于所有不包含文本的文件。

在文本模式下，讀取時默認會將平臺有關的行結束符（Unix上是 \n , Windows上是 \r\n）轉換為 \n。在文本模式下寫入時，默認會將出現的 \n 轉換成平臺有關的行結束符。這種暗地里的修改對 ASCII 文本文件沒有問題，但會損壞 JPEG 或 EXE 這樣的二進制文件中的數據。使用二進制模式讀寫此類文件時要特別小心。

用關鍵字 with 處理文件對象是個好習慣。它的好處在于文件用完后會自動關閉，就算發生異常也沒關系，且比try-finally更簡潔:

>>> with open('workfile') as f:
...     read_data = f.read()
>>> f.closed
True

不用with關鍵字則應該調用 f.close() 來關閉文件，并立即釋放它使用的系統資源。 如果沒有明確地關閉文件，Python的垃圾回收器最終會銷毀這個對象并為你關閉這個打開的文件，但是這個文件可能會保持打開一段時間。 另一個風險是不同的Python實現會在不同的時間進行這種清理。

在關閉文件對象之后，可以通過with語句或通過調用f.close()來嘗試使用文件對象將自動失敗。

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file

文件對象方法

本節中的示例都默認文件對象f已經創建。

要讀取文件內容，需要調用f.read(size)，該方法讀取數據并以字符串或字節對象形式返回，size 是可選的數值，指定字符串長度。如果沒有指定size 或者指定為負數，就會讀取并返回整個文件。當文件大小為當前機器內存兩倍時，就會產生問題。反之，會盡可能按比較大size讀取和返回數據。如果到了文件末尾，f.read()會返回一個空字符串 ('')。

>>> f.read()
'This is the entire file.\n'
>>> f.read()

f.readline()從文件中讀取單行，字符串結尾會自動加上換行符(\n) ，只有當文件最后一行沒有以換行符結尾時，這一操作才會被忽略。這樣返回值就不會有混淆，如果f.readline() 返回空字符串，那就表示到達了文件末尾，如果是空行，就會描述為 '\n'

>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''

你可以循環遍歷文件對象來讀取文件中的每一行。這是一種內存高效、快速，并且代碼簡潔的方式:

>>> for line in f:
...     print(line, end='')
...
This is the first line of the file.
Second line of the file
''

如果你想把文件中的所有行讀到一個列表中，你也可以使用list(f)或者f.readlines()。

f.write(string)方法將string的內容寫入文件，并返回寫入字符的長度:

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

想要寫入其他非字符串內容，首先要將它轉換為字符串:

>>> value = ('the answer', 42)
>>> s = str(value)  # convert the tuple to string
>>> f.write(s)
18

f.tell() 返回一個整數，代表文件對象在文件中的指針位置，該數值計量了自文件開頭到指針處的比特數。

需要改變文件對象指針話話，使用 f.seek(offset, from_what)。指針在該操作中從指定的引用位置移動offset比特，引用位置由 from_what參數指定。from_what 值為 0 表示自文件起始處開始，1 表示自當前文件指針位置開始，2 表示自文件末尾開始。from_what 可以忽略，其默認值為0，此時從文件頭開始:

>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)      # Go to the 6th byte in the file
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2)  # Go to the 3rd byte before the end
13
>>> f.read(1)
b'd'

在文本文件(沒有以 b 模式打開），只允許從文件頭開始尋找（有個例外是用seek(0, 2)跳到末尾處）而且合法的offset 值只能是 f.tell()返回的值或者是零。其它任何offset值都會產生不可預料的行為。

文件對象還有一些不太常用的附加方法，比如 isatty() 和 truncate() 在庫參考手冊中有文件對象的完整指南。

使用 json 存儲結構化數據

從文件中讀寫字符串很容易。數值就要多費點兒周折，因為read()方法只會返回字符串，應將其傳入 int() 這樣的函數，就可以將'123'這樣的字符串轉換為對應的數值 123。當你想要保存更為復雜的數據類型，例如嵌套的列表和字典，手工解析和序列化它們將變得更復雜。

Python 允許你使用常用的數據交換格式 JSON（JavaScript Object Notation）。標準模塊 json 可以接受 Python 數據結構，并將它們轉換為字符串表示形式；此過程稱為序列化。從字符串表示形式重新構建數據結構稱為反序列化。序列化和反序列化的過程中，表示該對象的字符串可以存儲在文件或數據中，也可以通過網絡連接傳送給遠程的機器。

注意：JSON 格式經常用于現代應用程序中進行數據交換。許多程序員都已經熟悉。

如果你有一個對象 x，你可以用簡單的一行代碼查看其 JSON 字符串表示形式:

>>> import json
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'

dumps() 函數的變種 dump()，直接將對象序列化到文件對象

json.dump(x, f)

解碼對象，如果f是為讀取而打開的 文件對象:

x = json.load(f)

這種簡單的序列化技術可以處理列表和字典，但序列化任意類實例為 JSON 需要額外的努力。 json 模塊的手冊對此有詳細的描述。

 

其他

pickle - pickle 模塊

與 JSON 不同，pickle 是協議，它允許任意復雜的 Python 對象的序列化。因此，它只能用于 Python 而不能用來與其他語言編寫的應用程序進行通信。默認情況下它也是不安全的：如果數據由熟練的攻擊者精心設計， 反序列化來自不受信任源的 pickle 數據可以執行任意代碼。

json格式轉換實例

現有 人臉標注的海量數據，部分參見：data

要求輸出：
1，files.txt

image_1515229323784.ir
image_1515235832391.ir
image_1515208991161.ir
image_1515207265358.ir
image_1521802748625.ir
image_1515387191011.ir
...

2, 坐標信息 poses.txt
文件名、left, top, right, buttom，width，height

image_1515229323784.ir,4,227,234,497,230,270
image_1515235832391.ir,154,89,302,240,148,151
image_1515208991161.ir,76,369,309,576,233,207
image_1515207265358.ir,44,261,340,546,296,285
...

3，比對文件：

首先：# 后面的為序列號，從1開始遞增
3 640 480 1及后面3行暫時視為固定。后面一行1 后面為4個坐標left, top, right, buttom。

# 1
image_1515229323784.ir
3 640 480 1
0
1
1 4 227 234 497 
# 2
image_1515235832391.ir
3 640 480 1
0
1
1 154 89 302 240
# 3
...

參考代碼：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import shutil
import os
import glob
import json
import pprint
import json

import data_common

directory = 'data'
files = data_common.find_files_by_type(directory,'json')

i = 1
file_list = []
results = []
poses = []
for filename in files:
    d = json.load(open(filename))
    name = d['image']['rawFilename'].strip('.jpg')
    pos = d['objects']['face'][0]['position']
    num = len(d['objects']['face'])
    if num > 1:
        print(filename)
        print(name)
        pprint.pprint(d['objects']['face'])
    out = "# {}\n{}\n3 640 480 1\n0\n{}\n".format(i, name, num)
    for face in d['objects']['face']:
        pos = face['position']
        top = round(pos['top'])
        bottom = round(pos['bottom'])
        left = round(pos['left'])
        right = round(pos['right'])
        out = out + "1 {} {} {} {}\n".format(left, top, right, bottom)
        poses.append("{},{},{},{},{},{},{}".format(name, 
            left, top, right, bottom, right - left, bottom -top))
    i = i + 1
    #print(out)
    file_list.append(name)
    results.append(out.rstrip('\n'))

data_common.output_file("files.txt",file_list)
data_common.output_file("results.txt",results)
data_common.output_file("poses.txt",poses)

詳細代碼地址

習題

1，有關python文件讀取，哪些描述是錯誤的。

A.f.read(-1)返回整個文件
B.with中打開的文件用完之后要調用close()。
C.如果到了文件末尾，f.read()會返回一個空字符串 ('')
D.f.readline()從文件中讀取單行，字符串結尾會自動加上換行符(\r\n)

參考答案： B D

2, open()的模式哪些是錯誤的？

A. r B. r+ C. d D.w+ E.a

參考答案： C D