ingresso e uscita python3
Nei primi capitoli, abbiamo davvero toccato ingresso Python e funzione d'uscita. In questo capitolo saranno presentati ingresso specifico Python e di uscita.
Formato di uscita abbellire
Python modo due valori di uscita: le espressioni e la funzione di stampa ().
Il terzo modo è quello di utilizzare il metodo write () dell'oggetto file, il file di output standard può essere utilizzato sys.stdout riferimento.
Se si vuole l'uscita sotto forma di più vario, è possibile utilizzare la funzione str.format () per formattare il valore di uscita.
Se si vuole trasformare in un valore di stringa dell'uscita, è possibile utilizzare la funzione str () repr () o di raggiungere.
- str (): restituisce una forma leggibile utente di espressione.
- repr (): genera una forma di espressione interprete leggibile.
Es
>>> s = 'Hello, w3big'
>>> str(s)
'Hello, w3big'
>>> repr(s)
"'Hello, w3big'"
>>> 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, w3big\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, w3big\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'w3big')))
"(32.5, 40000, ('Google', 'w3big'))"
Ci sono due modi per produrre un quadrate e cubiche tabelle:
>>> 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: Nel primo esempio, lo spazio tra ogni colonna è stata aggiunta dalla stampa ().
Questo esempio mostra metodo rjust oggetto stringa (), che può essere una stringa a destra, e riempire lo spazio sulla sinistra.
Ci sono metodi simili, come ljust () e il centro (). Questi metodi non scrivere nulla, ma restituisce una nuova stringa.
Un altro metodo zfill (), si riempirà la cifra sinistra 0, come segue:
>>> '12'.zfill(5) '00012' >>> '-3.14'.zfill(7) '-003.14' >>> '3.14159265359'.zfill(5) '3.14159265359'
str.format () L'utilizzo di base è il seguente:
>>> print('{}网址： "{}!"'.format('本教程', 'www.w3big.com'))
本教程网址： "www.w3big.com!"
E dentro i caratteri parentesi (chiamati campi di formato) saranno sostituiti con il parametro format () in.
formato posizione () nel numero in parentesi viene utilizzato per puntare l'oggetto in entrata, come segue:
>>> print('{0} 和 {1}'.format('Google', 'w3big'))
Google 和 w3big
>>> print('{1} 和 {0}'.format('Google', 'w3big'))
w3big 和 Google
Se la parola argomento () nel formato, quindi il loro valore punterà al nome del parametro.
>>> print('{name}网址： {site}'.format(name='本教程', site='www.w3big.com'))
本教程网址： www.w3big.com
Posizione e parole chiave argomenti possono essere una qualsiasi combinazione di:
>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'w3big',
other='Taobao'))
站点列表 Google, w3big, 和 Taobao。
'! A' (utilizzando il ascii ()), (usando str ()) e (utilizzando repr ()) può essere utilizzato per formattare un valore prima della sua trasformazione 'r!' 'S!':
>>> import math
>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
Opzioni ':' seguito dal nome e il formato di identificazione possono schierare. Questo permette una migliore formato del valore. L'esempio seguente manterrà il Pi con tre cifre decimali:
>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
常量 PI 的值近似为 3.142。
In ':' dopo il superamento di un intero, si può almeno garantire che ci sono così tanti larghezza dominio. Utile quando utilizzato in forma del paesaggio.
>>> table = {'Google': 1, 'w3big': 2, 'Taobao': 3}
>>> for name, number in table.items():
... print('{0:10} ==> {1:10d}'.format(name, number))
...
w3big ==> 2
Taobao ==> 3
Google ==> 1
Se si dispone di una stringa di formato lungo, e non si vuole separarli, poi, quando la formattazione in base al nome variabile piuttosto che posizione sarebbe una buona cosa.
Il più semplice è quello di passare in un dizionario e quindi utilizzare le parentesi quadre '[]' per accedere chiave:
>>> table = {'Google': 1, 'w3big': 2, 'Taobao': 3}
>>> print('w3big: {0[w3big]:d}; Google: {0[Google]:d}; '
'Taobao: {0[Taobao]:d}'.format(table))
w3big: 2; Google: 1; Taobao: 3
È inoltre possibile utilizzare la variabile prima della tabella '**' per ottenere la stessa funzionalità:
>>> table = {'Google': 1, 'w3big': 2, 'Taobao': 3}
>>> print('w3big: {w3big:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
w3big: 2; Google: 1; Taobao: 3
formattazione di stringhe vecchio stile
L'operatore% può essere raggiunto formattazione di stringhe. Formato stringa argomento a sinistra in quanto è simile a sprintf () formula, e il diritto di sostituzione, quindi l'esempio stringa formattata restituita:
>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。
Poiché la funzione str.format () è relativamente nuovo, la maggior parte del codice Python utilizza ancora l'operatore%. Tuttavia, poiché questo vecchio formato finirà per essere rimosso dalla lingua, si dovrebbe usare più str.format ().
Ingresso Leggi tastiera
Python fornisce la funzione di ingresso () del l'ingresso è impostato per leggere una riga di testo dallo standard, lo standard input di default è la tastiera.
ingresso può ricevere un'espressione Python come input e restituisce il risultato dell'operazione.
#!/usr/bin/python3
str = input("请输入：");
print ("你输入的内容是: ", str)
Questo produce i seguenti risultati corrispondenti all'ingresso:
请输入：本教程 你输入的内容是: 本教程
Leggere e scrivere file
open () restituisce un oggetto file, e sintassi di base è la seguente:
open(filename, mode)
- filename: variabile nomefile è una stringa contenente il valore che si desidera accedere a un nome di file.
- Modalità: Modalità determina il file aperto: lettura, scrittura, aggiungendo. Vedere la lista completa di tutti i possibili valori come segue. Questo parametro non obbligatoria, la modalità di accesso ai file di default è di sola lettura (r).
Aprire l'elenco completo delle diverse modalità di file:
| modo | descrizione |
|---|---|
| R | Aprire il file in modalità di sola lettura. file di puntatore sarà collocato all'inizio del file. Questa è la modalità predefinita. |
| RB | Aprire un file per la sola lettura in formato binario. Archivierà puntatore all'inizio del file. Questa è la modalità predefinita. |
| r + | Aprire un file per la lettura e la scrittura. Archivierà puntatore all'inizio del file. |
| rb + | Aprire un file per la lettura e la scrittura in formato binario. Archivierà puntatore all'inizio del file. |
| w | Aprire un file in sola scrittura. Se il file esiste già verrà sovrascritto. Se il file non esiste, creare un nuovo file. |
| wb | Aprire un file per la scrittura solo in formato binario. Se il file esiste già verrà sovrascritto. Se il file non esiste, creare un nuovo file. |
| w + | Aprire un file per la lettura e la scrittura. Se il file esiste già verrà sovrascritto. Se il file non esiste, creare un nuovo file. |
| wb + | Aprire un file per la lettura e la scrittura in formato binario. Se il file esiste già verrà sovrascritto. Se il file non esiste, creare un nuovo file. |
| un | Aprire un file per l'aggiunta. Se il file esiste già, il puntatore file verrà posizionato alla fine del file. In altre parole, dopo che il nuovo contenuto sarà scritto al contenuto esistente. Se il file non esiste, creare un nuovo file per la scrittura. |
| ab | Aprire un file per l'accodamento in formato binario. Se il file esiste già, il puntatore file verrà posizionato alla fine del file. In altre parole, dopo che il nuovo contenuto sarà scritto al contenuto esistente. Se il file non esiste, creare un nuovo file per la scrittura. |
| a + | Aprire un file per la lettura e la scrittura. Se il file esiste già, il puntatore file verrà posizionato alla fine del file. Sarà modalità il file viene aperto accodamento. Se il file non esiste, creare un nuovo file per la lettura e la scrittura. |
| ab + | Aprire un file per l'accodamento in formato binario. Se il file esiste già, il puntatore file verrà posizionato alla fine del file. Se il file non esiste, creare un nuovo file per la lettura e la scrittura. |
Gli esempi che seguono saranno scritti nel file foo.txt nella stringa:
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()
- Il primo parametro è il nome del file che si desidera aprire.
- Carattere secondo parametro descrive come utilizzare il file. modalità può essere 'r' Se il file è di sola lettura, 'w' per la sola scrittura (se il file esiste esso verrà cancellato), e 'a' per il contenuto dei file aggiuntivi, tutti i dati scritti verranno aggiunti automaticamente alla fine . 'r +' sia per leggere e scrivere. argomento modo è facoltativo; 'r' sarà il valore di default.
Apre il file foo.txt, appare come segue:
$ cat /tmp/foo.txt Python 是一个非常好的语言。 是的，的确非常好!!
Il metodo di oggetti file
Questo esempio presuppone che la sezione rimanente ha creato un oggetto file chiamato f.
f.read ()
Per leggere il contenuto di un file, chiamate f.read (dimensione), che leggerà un certo numero di dati, e poi restituito come oggetto stringa o byte.
dimensione è un parametro numerico facoltativo. Quando la dimensione è ignorato o è negativo, l'intero contenuto del file verrà letto e restituito.
Il seguente esempio presuppone che il file esiste foo.txt (nell'esempio di cui sopra è stato creato):
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
# 关闭打开的文件
f.close()
Il programma precedente, l'uscita è:
Python 是一个非常好的语言。 是的，的确非常好!!
f.readline ()
f.readline () si legge una sola riga dal file. carattere di nuova linea '\ n'. f.readline () restituisce una stringa vuota se, ha spiegato che era stato letto l'ultima riga.
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
# 关闭打开的文件
f.close()
Il programma precedente, l'uscita è:
Python 是一个非常好的语言。
f.readlines ()
f.readlines () restituirà tutte le righe contenute nel file.
Se i parametri opzionali sizehint, quindi leggere i byte di lunghezza specificati, e questi byte divisi per riga.
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str)
# 关闭打开的文件
f.close()
Il programma precedente, l'uscita è:
['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']
Un altro modo è quello di iterare un oggetto file e quindi legge ogni riga:
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
for line in f:
print(line, end='')
# 关闭打开的文件
f.close()
Il programma precedente, l'uscita è:
Python 是一个非常好的语言。 是的，的确非常好!!
Questo metodo è molto semplice, ma non fornisce un buon controllo. Sia a causa del diverso meccanismo di elaborazione, è meglio non mescolare.
f.write ()
f.write (stringa) La stringa scritto nel file, e restituisce il numero di caratteri scritti.
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
# 关闭打开的文件
f.close()
Il programma precedente, l'uscita è:
29
Se si desidera scrivere alcune delle cose che non è una stringa, è necessario da convertire:
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo1.txt", "w")
value = ('www.w3big.com', 14)
s = str(value)
f.write(s)
# 关闭打开的文件
f.close()
Il programma di cui sopra, il file foo1.txt aperto:
$ cat /tmp/foo1.txt
('www.w3big.com', 14)
f.tell ()
f.tell () restituisce la posizione di un oggetto file si trova attualmente, è il numero di byte dall'inizio del conteggio file.
f.seek ()
Se si vuole cambiare la posizione corrente del file, è possibile utilizzare f.seek (offset, da_cosa) la funzione.
Valore da_cosa, se è l'inizio di 0 indica, se è la fine del 1 indica la posizione corrente, 2 per il file, ad esempio:
- seek (x, 0): Dalla posizione di partenza, che è la prima linea del primo carattere del file comincia a muoversi caratteri x
- cercare (x, 1): indica caratteri movimento x all'indietro dalla posizione corrente
- seek (-x, 2): mostra un mobile caratteri x dalla estremità anteriore del file
valore predefinito da_cosa è 0, cioè l'inizio del file. Ecco un esempio completo:
>>> 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 ()
Nel file di testo (non b quelli modalità file aperto) soltanto rispetto all'inizio del file da individuare.Quando hai finito con un file, chiamata f.close () per chiudere il file e liberare le risorse di sistema, se si tenta di recuperare il file, viene generata un'eccezione.
>>> 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
oggetto File ci sono altri metodi, come ad esempio isatty () e trucate (), ma questi sono di solito meno.
modulo pickle
Il modulo python pickle implementa la sequenza di dati di base e deserializzazione.
Siamo stati in grado di salvare il programma di destinazione modulo pickle operazione di serializzazione in esecuzione le informazioni in un file di memorizzazione permanente.
Con modulo pickle deserializzazione, siamo in grado di creare un programma per salvare l'oggetto dal file.
Interfaccia di base:
pickle.dump(obj, file, [,protocol])
Con questo oggetto salamoia, per essere in grado di aprire il file come lettura:
x = pickle.load(file)
Nota: Leggere una stringa dal file, e la ricostruzione dei suoi oggetti Python originali.
File: oggetto simile a file con read () e readline) Interfaccia (.
Esempio 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()
Esempio 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()