entrada y salida python3

python3 errores y excepciones: Siguiente

En los primeros capítulos, en realidad hemos tocado entrada de Python y la función de salida. En este capítulo vamos a introducir entrada específica Python y salida.

formato de salida embellecer

forma dos valores pitón de salida: declaraciones de expresión y la función de impresión ().

La tercera forma es utilizar el método del objeto de escritura de archivo (), el archivo de salida estándar se puede utilizar sys.stdout referencia.

Si desea dar salida en forma de más diversa, puede utilizar la función str.format () para dar formato al valor de salida.

Si desea convertirse en un valor de cadena de la salida, se puede utilizar la función str () repr () o para lograr.

str (): función devuelve una forma legible por el usuario de expresión.
repr (): genera una forma de expresión intérprete legible.

Por ejemplo

>>> 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'))"

Existen dos formas de dar salida a una cuadradas y cúbicas tablas:

>>> 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: En el primer ejemplo, se añadió el espacio entre cada columna por la impresión ().

Este ejemplo muestra el método rjust objeto de cadena (), que puede ser una cadena a la derecha, y llenar el espacio de la izquierda.

Hay métodos similares, como ljust () y el centro (). Estos métodos no escriben nada, sólo devuelven una nueva cadena.

Otro método zfill (), llenará en el dígito de la izquierda 0, de la siguiente manera:

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

str.format () El uso básico es el siguiente:

>>> print('{}网址： "{}!"'.format('本教程', 'www.w3big.com'))
本教程网址： "www.w3big.com!"

Y dentro de los caracteres de paréntesis (llamados campos de formato) serán reemplazados por el parámetro de formato () en.

Formato de la posición () en el número entre paréntesis se usa para señalar el objeto entrante, como sigue:

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

Si el argumento de palabra clave () en el formato, entonces su valor apuntará al nombre del parámetro.

>>> print('{name}网址： {site}'.format(name='本教程', site='www.w3big.com'))
本教程网址： www.w3big.com

Ubicación y palabras clave argumentos pueden ser cualquier combinación de:

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'w3big',
                                                       other='Taobao'))
站点列表 Google, w3big, 和 Taobao。

'! A' (utilizando el ascii ()), (utilizando str ()) y (Usando repr ()) se puede utilizar para dar formato a un valor antes de su transformación 'r' 's':

>>> import math
>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

Opciones ':' seguido por el nombre y el identificador de formato pueden campo. Esto permite un mejor formato de valores. El siguiente ejemplo se conservará el Pi a tres cifras decimales:

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

En ':' después de pasar un número entero, al menos puede asegurarse de que hay tantos ancho de dominio. Útil cuando se utiliza en forma de paisajismo.

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

Si usted tiene una cadena de formato largo, y no desea separarlos, a continuación, cuando se formatea por nombre de variable en lugar de ubicación sería una buena cosa.

La más sencilla es pasar en un diccionario y luego usar corchetes "[]" para acceder clave:

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

También puede utilizar la variable antes de la mesa '**' para lograr la misma funcionalidad:

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

formateo de cadenas de estilo antiguo

El operador% se puede alcanzar la cadena de formato. cadena del argumento formato a la izquierda, ya que es similar a sprintf () fórmula, y el derecho de sustitución, a continuación, la cadena con formato devuelto ejemplo:

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

Dado que la función str.format () es relativamente nuevo, la mayoría del código Python sigue utilizando el operador%. Sin embargo, ya que este formato antiguo, finalmente, será retirado de la lengua, se debe utilizar más str.format ().

Leer la entrada del teclado

Python proporciona la función de entrada () de la entrada está configurado para leer una línea de texto de la norma, la entrada estándar por defecto es el teclado.

de entrada puede recibir una expresión de Python como entrada y devuelve el resultado de la operación.

#!/usr/bin/python3

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

Esto produce los siguientes resultados correspondientes a la entrada:

请输入：本教程
你输入的内容是:  本教程

Leer y escribir archivos

open () devuelve un objeto de archivo, y la sintaxis básica es la siguiente:

open(filename, mode)

nombre de archivo: nombre del archivo es variable de una cadena que contiene el valor que desea acceder a un nombre de archivo.
Modo: Modo determina el archivo abierto: lectura, escritura, añadiendo. Ver la lista completa de todos los valores posibles de la siguiente manera. Este parámetro no obligatorio, el modo de acceso de archivos por defecto es (R) de sólo lectura.

Abra la lista completa de los diferentes modos de archivo:

modo	descripción
r	Abra el archivo en modo de sólo lectura. archivo de puntero se coloca al principio del archivo. Este es el modo por defecto.
rb	Abrir un archivo de sólo lectura en formato binario. Se presentar puntero al principio del archivo. Este es el modo por defecto.
r +	Abrir un archivo para lectura y escritura. Se presentar puntero al principio del archivo.
rb +	Abrir un archivo para leer y escribir en formato binario. Se presentar puntero al principio del archivo.
w	Abrir un archivo para sólo escritura. Si el archivo ya existe, se sobrescribe. Si no existe el archivo, crear un nuevo archivo.
wb	Abrir un archivo para escribir únicamente en formato binario. Si el archivo ya existe, se sobrescribe. Si no existe el archivo, crear un nuevo archivo.
w +	Abrir un archivo para lectura y escritura. Si el archivo ya existe, se sobrescribe. Si no existe el archivo, crear un nuevo archivo.
WB +	Abrir un archivo para leer y escribir en formato binario. Si el archivo ya existe, se sobrescribe. Si no existe el archivo, crear un nuevo archivo.
una	Abrir un archivo para anexar. Si el archivo ya existe, el puntero de archivo se coloca al final del archivo. En otras palabras, después de que el nuevo contenido se escribirán en el contenido existente. Si no existe el archivo, crear un nuevo archivo para escritura.
ab	Abrir un archivo de datos anexados en formato binario. Si el archivo ya existe, el puntero de archivo se coloca al final del archivo. En otras palabras, después de que el nuevo contenido se escribirán en el contenido existente. Si no existe el archivo, crear un nuevo archivo para escritura.
a +	Abrir un archivo para lectura y escritura. Si el archivo ya existe, el puntero de archivo se coloca al final del archivo. Es el modo que se abra el archivo anexará. Si no existe el archivo, crear un nuevo archivo para la lectura y la escritura.
ab +	Abrir un archivo de datos anexados en formato binario. Si el archivo ya existe, el puntero de archivo se coloca al final del archivo. Si no existe el archivo, crear un nuevo archivo para la lectura y la escritura.

Los siguientes ejemplos se escriben en el archivo de foo.txt en la cadena:

#!/usr/bin/python3

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

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

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

El primer parámetro es el nombre del archivo que desea abrir.
segundo parámetro carácter se describe cómo utilizar el archivo. modo puede ser 'r' Si el archivo es de sólo lectura, 'w' por sólo para escribir (si existe el archivo será borrado), y 'a' para el contenido del archivo adicionales; los datos grabados se añadirán automáticamente a la final . 'r +' para leer y escribir. argumento de modo es opcional; 'r' será el valor por defecto.

Abre el archivo foo.txt, aparece de la siguiente manera:

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

El método de objetos de archivo

En este ejemplo se supone que la sección restante ha creado un archivo llamado objeto de f.

f.read ()

Para leer el contenido de un archivo, llame f.read (tamaño), que leerá un cierto número de datos, y luego regresó como un objeto de cadena o bytes.

tamaño es un parámetro numérico opcional. Cuando el tamaño se ignora o es negativo, todo el contenido del archivo serán leídos y devueltos.

En el siguiente ejemplo se supone que existe la foo.txt archivo (en el ejemplo anterior se ha creado):

#!/usr/bin/python3

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

str = f.read()
print(str)

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