Input dan output Python3


Dalam bab sebelum ini, kita sebenarnya telah didedahkan kepada fungsi input dan output Python. Dalam bab ini kami akan memperkenalkan input dan output Python secara terperinci.

Pengendahan format output

Python mempunyai dua cara untuk mengeluarkan nilai: pernyataan ekspresi dan fungsi print().

Cara ketiga ialah menggunakan kaedah write() bagi objek fail Fail output standard boleh dirujuk dengan sys.stdout.


Jika anda mahu output menjadi lebih pelbagai, anda boleh menggunakan fungsi str.format() untuk memformat nilai output.

Jika anda ingin menukar nilai output kepada rentetan, anda boleh menggunakan fungsi repr() atau str() untuk mencapai ini.

  • str(): Fungsi mengembalikan ungkapan yang boleh dibaca pengguna.

  • repr(): Hasilkan representasi yang boleh dibaca oleh jurubahasa.

Sebagai contoh, 

>>> s = 'Hello, php'
>>> str(s)
'Hello, php'
>>> repr(s)
"'Hello, php'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为： ' + repr(x) + ',  y 的值为：' + repr(y) + '...'
>>> print(s)
x 的值为： 32.5,  y 的值为：40000...
>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, php\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, php\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'php')))
"(32.5, 40000, ('Google', 'php'))"

Terdapat dua cara untuk mengeluarkan jadual segi empat sama dan kubus: 

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # 注意前一行 'end' 的使用
...     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

Nota: adalah dalam Bab 1 Dalam satu contoh, ruang antara setiap lajur ditambah dengan print().

Contoh ini menunjukkan kaedah rjust() bagi objek rentetan, yang boleh mengimbangi rentetan ke kanan dan ruang pad di sebelah kiri.

Terdapat juga kaedah yang serupa, seperti ljust() dan center(). Kaedah ini tidak menulis apa-apa, ia hanya mengembalikan rentetan baru.

Kaedah lain zfill(), yang akan mengisi nombor dengan sifar di sebelah kiri seperti yang ditunjukkan di bawah: 

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

Penggunaan asas str.format() adalah seperti berikut: 

>>> print('{}网址： "{}!"'.format('php中文网', 'www.php.cn'))
php中文网网址： "www.php.cn!"

Tanda kurung dan aksara di dalamnya (dipanggil medan format) akan digantikan dengan parameter dalam format().

Nombor dalam kurungan digunakan untuk menunjuk ke kedudukan objek masuk dalam format(), seperti berikut: 

>>> print('{0} 和 {1}'.format('Google', 'php'))
Google 和 php
>>> print('{1} 和 {0}'.format('Google', 'php'))
php 和 Google

Jika hujah kata kunci digunakan dalam format(), maka mereka Nilai akan menunjuk ke parameter menggunakan nama itu. 

>>> print('{name}网址： {site}'.format(name='php中文网', site='www.php.cn'))
php中文网网址： www.php.cn

Argumen kedudukan dan kata kunci boleh digabungkan dalam apa jua cara: 

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'php',
                                                       other='Taobao'))
站点列表 Google, php, 和 Taobao。
'!a' (menggunakan ascii()), '!s' (menggunakan str()) dan '!r' (menggunakan repr ()) boleh digunakan untuk mengubah nilai sebelum memformatnya:
>>> import math
>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

Pilihan ':' dan pengecam format boleh mengikut nama medan. Ini membolehkan pemformatan nilai yang lebih baik. Contoh berikut mengekalkan Pi kepada tiga tempat perpuluhan: 

>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
常量 PI 的值近似为 3.142。

Melalui integer selepas ':' memastikan bahawa medan mempunyai sekurang-kurangnya lebar sebanyak ini. Berguna untuk mencantikkan meja. 

>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))
...
php     ==>          2
Taobao     ==>          3
Google     ==>          1

Jika anda mempunyai rentetan format yang panjang dan anda tidak mahu memisahkannya, lebih baik untuk memformat dengan nama pembolehubah dan bukannya kedudukan.

Perkara paling mudah ialah lulus dalam kamus, dan kemudian gunakan tanda kurung segi empat sama '[]' untuk mengakses nilai kunci:

>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> print('php: {0[php]:d}; Google: {0[Google]:d}; '
          'Taobao: {0[Taobao]:d}'.format(table))
php: 2; Google: 1; Taobao: 3

Anda juga boleh mencapai perkara yang sama dengan menggunakan '** ' sebelum pembolehubah jadual Fungsi: 

>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> print('php: {php:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
php: 2; Google: 1; Taobao: 3

Pemformatan rentetan gaya lama

% pengendali juga boleh melaksanakan pemformatan rentetan. Ia mengambil parameter kiri sebagai rentetan terformat serupa dengan sprintf(), menggantikan parameter yang betul dan mengembalikan rentetan terformat Contohnya: 

>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

Oleh kerana str.format() ialah fungsi yang agak baharu, kebanyakan kod Python masih menggunakan operator %. Tetapi memandangkan pemformatan gaya lama ini akhirnya akan dialih keluar daripada bahasa, str.format() harus digunakan lebih kerap.

Membaca input papan kekunci

Python menyediakan Input() fungsi membaca baris teks daripada input standard Input standard lalai ialah papan kekunci.

input boleh menerima ungkapan Python sebagai input dan mengembalikan hasil operasi. 

#!/usr/bin/python3

str = input("请输入：");
print ("你输入的内容是: ", str)

Ini akan menghasilkan keputusan berikut sepadan dengan input: 

请输入：php中文网
你输入的内容是:  php中文网

Membaca dan menulis fail

open() akan mengembalikan objek fail, sintaks asas format adalah seperti berikut: 

open(filename, mode)

  • nama fail: Pembolehubah nama fail ialah nilai rentetan yang mengandungi nama fail yang anda ingin akses.

  • mod: mod menentukan mod membuka fail: baca sahaja, tulis, tambah, dsb. Lihat senarai lengkap semua nilai yang mungkin di bawah. Parameter ini adalah pilihan dan mod akses fail lalai ialah baca-sahaja (r).

Senarai penuh fail dibuka dalam mod berbeza:

模式描述
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

Contoh berikut menulis rentetan pada fail foo.txt: 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

  • Parameter pertama ialah nama fail yang akan dibuka.

  • Parameter kedua menerangkan cara fail menggunakan aksara. mod boleh menjadi 'r' jika fail adalah baca sahaja, 'w' untuk menulis sahaja (fail dengan nama yang sama akan dipadamkan jika ia wujud), dan 'a' untuk menambahkan kandungan fail akan menjadi; ditambah secara automatik pada hujung . 'r+' digunakan untuk membaca dan menulis. Parameter mod adalah pilihan; 'r' akan menjadi lalai.

Buka fail foo.txt pada masa ini, dan ia akan dipaparkan seperti berikut: 

$ cat /tmp/foo.txt 
Python 是一个非常好的语言。
是的，的确非常好!!

Kaedah objek fail

Contoh selebihnya dalam bahagian ini Andaikan bahawa objek fail dipanggil f telah dicipta.

f.read()

Untuk membaca kandungan fail, panggil f.read(size), yang akan membaca jumlah data tertentu, kemudian sebagai rentetan atau bait objek kembali .

saiz ialah parameter angka pilihan. Apabila saiz ditinggalkan atau negatif, maka keseluruhan kandungan fail akan dibaca dan dikembalikan.

Contoh berikut menganggap bahawa fail foo.txt sudah wujud (dicipta dalam contoh di atas): 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.read()
print(str)

# 关闭打开的文件
f.close()

Laksanakan atur cara di atas, hasil keluarannya ialah: 

Python 是一个非常好的语言。
是的，的确非常好!!

f.readline()

f.readline() akan membaca satu baris daripada fail. Watak baris baharu ialah 'n'. Jika f.readline() mengembalikan rentetan kosong, ini bermakna baris terakhir telah dibaca. 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.readline()
print(str)

# 关闭打开的文件
f.close()

Laksanakan atur cara di atas, hasil output ialah: 

Python 是一个非常好的语言。

f.readlines()

f.readlines() akan mengembalikan semua baris yang terkandung dalam fail.

Jika petunjuk saiz parameter pilihan ditetapkan, bait panjang yang ditentukan dibaca dan dibahagikan kepada baris. 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.readlines()
print(str)

# 关闭打开的文件
f.close()

Laksanakan atur cara di atas, hasil keluarannya ialah:

['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

Cara lain ialah dengan melelaran objek fail dan membaca setiap baris:

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

for line in f:
    print(line, end='')

# 关闭打开的文件
f.close()

Laksanakan atur cara di atas, keluaran hasilnya Untuk: 

Python 是一个非常好的语言。
是的，的确非常好!!

Kaedah ini mudah, tetapi tidak memberikan kawalan yang baik. Oleh kerana kedua-dua mekanisme pemprosesan adalah berbeza, lebih baik tidak mencampurkannya.

f.write()

f.write(string) menulis rentetan pada fail dan mengembalikan bilangan aksara yang ditulis. 

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "w")

num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
# 关闭打开的文件
f.close()

Laksanakan atur cara di atas, hasil output ialah:

29

Jika anda ingin menulis sesuatu yang bukan rentetan, anda perlu menukarnya terlebih dahulu:

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo1.txt", "w")

value = ('www.php.cn', 14)
s = str(value)
f.write(s)

# 关闭打开的文件
f.close()

Laksanakan atur cara di atas , buka fail foo1.txt: 

$ cat /tmp/foo1.txt 
('www.php.cn', 14)

f.tell()

f.tell() mengembalikan kedudukan semasa objek fail, iaitu bait yang dikira dari awal nombor fail.

f.seek()

Jika anda ingin menukar kedudukan semasa fail, anda boleh menggunakan fungsi f.seek(offset, from_what). Nilai

dari_apa, jika 0, ia bermakna permulaan, jika 1, ia bermakna kedudukan semasa, dan 2 bermaksud penghujung fail, contohnya:


  • seek(x,0): Alihkan x aksara dari kedudukan permulaan, iaitu aksara pertama baris pertama fail

  • seek(x,1): Menunjukkan bergerak ke belakang dari kedudukan semasa x aksara

  • seek(-x,2): bermaksud menggerakkan x aksara ke hadapan dari hujung fail

dari_apa nilai lalai ialah 0, iaitu permulaan fail. Contoh lengkap diberikan di bawah: 

>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'


f.close()

Dalam fail teks (yang tanpa b dalam mod membuka fail), ia hanya akan diletakkan secara relatif kepada kedudukan permulaan fail.


Apabila anda selesai memproses fail, panggil f.close() untuk menutup fail dan melepaskan sumber sistem Jika anda cuba memanggil fail itu semula, pengecualian akan dilemparkan. 

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
<pre>
<p>
当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:</p>
<pre>
>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

Objek fail mempunyai kaedah lain, seperti isatty() dan trucate(), tetapi ini biasanya kurang berguna.

modul jeruk

Modul jeruk Python melaksanakan jujukan data asas dan penyahserikatan.

Melalui operasi bersiri modul jeruk, kami boleh menyimpan maklumat objek yang berjalan dalam program ke fail dan menyimpannya secara kekal.

Melalui operasi penyahserialisasian modul jeruk, kita boleh mencipta objek yang disimpan oleh atur cara terakhir daripada fail.

Antara muka asas: 

pickle.dump(obj, file, [,protocol])

Dengan objek jeruk, fail boleh dibuka untuk dibaca: 

x = pickle.load(file)

Nota: Dari fail Membaca rentetan daripada Python dan membina semula ia menjadi objek Python asal.

fail: Objek seperti fail dengan antara muka read() dan readline().

Instance 1: 

#!/usr/bin/python3
import pickle

# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()

Instance 2: 

#!/usr/bin/python3
import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)

pkl_file.close()