• Python学习 Part5:输入输出


    1. 格式化输出

    三种输出值的方法:

    • 表达式语句
    • print()函数
    • 使用文件对象的write()方法

    两种方式格式化输出:

    • 由自己处理整个字符串,通过使用字符串切割和连接操作创建任何想要的输出形式
    • 使用str.formate()方法

    将值转换为字符串的方法:

    • 将它传递给repr()函数
    • 将它传递给str()函数
    >>> s='Hello, world.'
    >>> str(s)
    'Hello, world.'
    >>> repr(s)
    "'Hello, world.'"
    >>> str(0.1)
    '0.1'
    >>> repr(0.1)
    '0.1'
    >>> 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...
    >>> hello='hello, world
    '
    >>> hellos=repr(hello)
    >>> print(hellos)
    'hello, world
    '
    >>> repr((x,y,('spam','eggs')))
    "(32.5, 40000, ('spam', 'eggs'))"
    >>> str((x,y,('spam','eggs')))
    "(32.5, 40000, ('spam', 'eggs'))"
    >>> 
    >>> for x in range(1,11):
        print(repr(x).rjust(10),repr(x*x).rjust(3),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(repr(x).rjust(2),repr(x*x).rjust(11),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
    101001000
    >>> for x in range(1,11):
        print('{0:2d}{1:10d}{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       1001000
    >>> 

    上面的示例演示了字符串对象的rjust()方法,它通过在字符串左侧填充指定宽度的空格以使其右对齐。还有两个类似的方法:ljust()和center()。如果输入的字符串过长,它们不会截断它,而是原样返回。
    还有另一个方法:zfill(),使用零在数字字符串左侧填充(到指定宽度)。它可以理解正负号

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


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

    >>> print('We are the {0} who say "{1}!"'.format('knights','Ni'))
    We are the knights who say "Ni!"
    >>> print('{0} and {1}'.format('spam','eggs'))
    spam and eggs
    >>> print('{1} and {0}'.format('spam','eggs'))
    eggs and spam
    >>> 
    >>> #使用关键字参数
    >>> print('This {food} is {adjective}.'.format(food='spam',adjective='absolutely horrible'))
    This spam is absolutely horrible.

    字段名称后面可以跟一个可选的':' 符号和格式化分类符。下面的示例将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))
    
        
    Dcab      ==>      7678
    Sjoerd    ==>      4127
    Jack      ==>      4098
    >>> 

    如果有一个不想分割的确实很长的字符串,使用名称替代位置来引用被格式化的变量将会更好:

    >>> print('Jack:{0[Jack]:d}; Sjoerd:{0[Sjoerd]:d};''Dcab:{0[Dcab]:d}'.format(table))
    Jack:4098; Sjoerd:4127;Dcab:76786736737383863


    2. 文件读写

    open()函数返回一个文件对象,并且它通常带有两个参数: open(filename,mode)

    >>> f=open('/software','w')

    第二个参数描述了文件使用的方式(是可选的,默认值是'r'):

    • 'r' 文件为只读
    • 'w' 文件为只写
    • 'a' 表示已追加方式打开文件,所有的数据都会被自动地添加到文件末尾
    • 'r+' 表示以读写方式打开文件

    文件对象的方法:

    • f.read(size)方法:读取一个文件的内容。如果没有指定size或者它为负数,就会读取并返回文件的全部内容。如果已经达到文件尾,f.read()将返回一个空字符串
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> f.read()
    'This is for testing.
    The second line.
    The third line.'
    >>> f.read()
    ''
    • f.readline()方法:从文件中读取单独一行内容
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> f.readline()
    'This is for testing.
    '
    >>> f.readline()
    'The second line.
    '
    >>> f.readline()
    'The third line.'
    >>> f.readline()
    ''
    • f.readlines()方法:返回一个包含文件所有数据行的列表
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> f.readlines()
    ['This is for testing.
    ', 'The second line.
    ', 'The third line.']
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> for line in f:
        print(line,end=' ')
    
        
    This is for testing.
     The second line.
     The third line.
    • f.write(string)方法:将string的内容写入文件,并返回写入字符的长度;如果想要写入其他非字符串内容,首先要将它转换为字符串
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> value=('the answer',42)
    >>> s=str(value)
    >>> f.write(s)
    18
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> f.readlines()
    ["('the answer', 42)"]
    • f.tell()方法:返回一个指代文件对象当前位置的整数,表示从文件开头到当前位置的字节数
    • f.seek(offset,from_what)方法:改变文件对象位置。新的位置通过将offset值与参考点相加得到,参考点是由参数from_what确定。如果from_what值为0则代表从文件头开始计算,值为1时代表从当前文件位置开始计算,值为2时代表从文件尾开始计算,省略时默认为0.
    >>> f=open('/Users/Administrator/Desktop/test.txt','r+')
    >>> f.write('0123456789abcdef')
    16
    >>> f.seek(5)
    5
    >>> f.read(1)
    '5'
    >>> f.seek(-3,2)
    Traceback (most recent call last):
      File "<pyshell#17>", line 1, in <module>
        f.seek(-3,2)
    io.UnsupportedOperation: can't do nonzero end-relative seeks
    >>> 

    在文本文件中,没有使用b模式选项打开的文件,只允许从文件头开始计算相对位置,从文件尾计算时就会引发异常。

    >>> f=open('/Users/Administrator/Desktop/test.txt','rb+')
    >>> f.write(b'0123456789abcdef')
    16
    >>> f.seek(-3,2)
    13
    >>> f.read(1)
    b'd'
    >>> 
    • f.close()方法:关闭文件并释放其占用的所有系统资源
    • 在处理文件对象时,使用with关键字是个好习惯。在文件一系列操作后它会被适当的关闭
    >>> with open('/Users/Administrator/Desktop/test.txt','r') as f:
        read_data=f.read()
    
        
    >>> read_data
    '0123456789abcdef'
    >>> f.closed
    True


    pickle模块:

    将任何Python对象转换为字符串表示形式,这个过程称为pickling(封装),从这个字符串表示形式中重建Python对象被称为unpickling(拆封)

    如果你有一个对象x和一个已经打开并等待写入的文件对象f,封装对象的最简单方法只需要一行代码:

    >>> pickle.dump(x,f)

    想要拆封这个对象,如果存在一个已经打开并等待读取的文件对象f,即可:

    >>> x=pickle.load(f)


     

  • 相关阅读:
    Linux_Rsync远程同步备份服务器
    Linux_Rsync远程同步备份服务器
    Linux_VMWare12 Install RHEL7
    Linux_VMWare12 Install RHEL7
    Linux_SquidProxyServer代理服务器
    Linux_SquidProxyServer代理服务器
    Linux_LAMP 最强大的动态网站解决方案
    Ozone Native ACL的应用
    Ozone Audit Log解析工具的应用
    Ozone数据探查服务Recon2.0设计
  • 原文地址:https://www.cnblogs.com/LilianChen/p/3382614.html
Copyright © 2020-2023  润新知