18-[模块]-random&os&sys

1、random模块

程序中有很多地方需要用到随机字符，比如登录网站的随机验证码，通过random模块可以很容易生成随机字符串

# randrange #返回1-3之间的一个随机数，不包含3

# randint #返回1-3之间的一个随机数，包含3

In [32]: random.randrange(1,3)

Out[32]: 2

In [33]: random.randrange(1,3)

Out[33]: 2

In [34]: random.randrange(1,3)

Out[34]: 1

In [35]: random.randrange(1,3)

Out[35]: 1

In [36]: random.randint(1,3)

Out[36]: 3

In [37]: random.randint(1,3)

Out[37]: 2

In [38]: random.randint(1,3)

Out[38]: 1

>>> random.randrange(0, 100, 2) #随机选取0到100间的偶数

# random 0-1直接的浮点数

In [39]: random.random()

Out[39]: 0.6654421359097369

In [40]: random.random()

Out[40]: 0.1015447178963047

>>> random.choice('abce3#$@1') #返回一个给定数据集合中的随机字符

'#'

>>> random.sample('abcdefghij',3)  #从多个字符中选取特定数量的字符

['a', 'd', 'b']

# 洗牌

In [51]: d = [i for i in range(12)]

In [52]: d

Out[52]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

In [53]: random.shuffle(d)

In [54]: d

Out[54]: [3, 10, 8, 1, 9, 2, 7, 11, 5, 6, 4, 0]

2.生成随机验证码：string模块

In [57]: string.digits   # 整数

Out[57]: ''

In [58]: string.ascii_letters  # 大小写字母

Out[58]: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

In [62]: string.punctuation    # 特殊字符

Out[62]: '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

In [59]: string.hexdigits  # 16进制数

Out[59]: '0123456789abcdefABCDEF'

In [60]: string.octdigits  # 8进制数

Out[60]: ''

# 随机验证码

In [61]: string.digits + string.ascii_letters

Out[61]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'    

In [63]: string.digits + string.ascii_letters + string.punctuation

Out[63]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

In [64]: s = string.digits + string.ascii_letters + string.punctuation

In [66]: ''.join(random.sample(s,4))

Out[66]: '_K{Y'

In [67]: ''.join(random.sample(s,4))

Out[67]: 'WIBN'

In [68]: ''.join(random.sample(s,4))

Out[68]: 'j,^~'

In [69]: ''.join(random.sample(s,4))

Out[69]: 'W)1"'

3、os 模块

os 模块提供了很多允许你的程序与操作系统直接交互的功能

os模块的主要功能：系统相关、目录及文件操作、执行命令和管理进程

在使用os模块的时候，如果出现了问题，会抛出OSError异常，表明无效的路径名或文件名，或者路径名(文件名)无法访问，或者当前操作系统不支持该操作。

>>> import os

>>> os.chdir("d:\11")

Traceback (most recent call last):

  File "<pyshell#2>", line 1, in <module>

    os.chdir("d:\11")

OSError: [WinError 123] 文件名、目录名或卷标语法不正确。: 'd:\t'

（1）系统相关

方法和变量	用途

os.name	查看当前操作系统的名称。windows平台下返回‘nt’，Linux则返回‘posix’。

os.environ	获取系统环境变量

os.sep	当前平台的路径分隔符。在windows下，为‘\’，在POSIX系统中，为‘/’。

os.altsep	可替代的路径分隔符，在Windows中为‘/’。

os.extsep	文件名和文件扩展名之间分隔的符号，在Windows下为‘.’。

os.pathsep	PATH环境变量中的分隔符，在POSIX系统中为‘:’，在Windows中为‘;’。

os.linesep	行结束符。在不同的系统中行尾的结束符是不同的，例如在Windows下为‘\r\n’。

os.devnull	在不同的系统上null设备的路径，在Windows下为‘nul’，在POSIX下为‘/dev/null’。

os.defpath	当使用exec函数族的时候，如果没有指定PATH环境变量，则默认会查找os.defpath中的值作为子进程PATH的值。

>>> import os

>>> os.name

'nt'

>>> os.environ

environ({'ALLUSERSPROFILE': 'C:\\ProgramData', 'APPDATA': 'C:\\Users\\Administrator\\AppData\\Roaming', 'ASL.LOG': 'Destination=file', ......

>>> os.sep

'\\'

>>> os.altsep

'/'

>>> os.extsep

'.'

>>> os.pathsep

';'

>>> os.linesep

'\r\n'

>>> os.devnull

'nul'

>>> os.defpath

'.;C:\\bin'

（2）文件和目录操作

方法和变量	用途

os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname")	改变当前脚本工作目录；相当于shell下cd

os.curdir	返回当前目录: ('.')

os.pardir	获取当前目录的父目录字符串名：('..')

os.makedirs('dir1/dir2')	可生成多层递归目录

os.removedirs(‘dirname1’)	递归删除空目录（要小心）

os.mkdir('dirname')	生成单级目录

os.rmdir('dirname')	删除单级空目录，若目录不为空则无法删除并报错

os.listdir('dirname')	列出指定目录下的所有文件和子目录，包括隐藏文件

os.remove('filename')	删除一个文件

os.rename("oldname","new")	重命名文件/目录

os.stat('path/filename')	获取文件/目录信息

os.path.abspath(path)	返回path规范化的绝对路径

os.path.split(path)	将path分割成目录和文件名二元组返回

os.path.dirname(path)	返回path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)	返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。

os.path.exists(path或者file)	如果path存在，返回True；如果path不存在，返回False

os.path.isabs(path)	如果path是绝对路径，返回True

os.path.isfile(path)	如果path是一个存在的文件，返回True。否则返回False

os.path.isdir(path)	如果path是一个存在的目录，则返回True。否则返回False

os.path.join(path1[, path2[, ...]])	将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.getatime(path)	返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间

os.path.getsize(filename)	返回文件包含的字符数量

　　在Python中，使用windows的文件路径时一定要小心，比如你要引用d盘下的1.txt文件，那么路径要以字符串的形式写成'd:\\1.txt'或者r'd:\1.txt。前面的方式是使用windwos的双斜杠作为路径分隔符，后者是使用原生字符串的形式，以r开始的字符串都被认为是原始字符串，表示字符串里所有的特殊符号都以本色出演，不进行转义，此时可以使用普通windows下的路径表示方式。这两种方法使用哪种都可以，但不可混用。

>>> os.getcwd()

'C:\\Python36'

>>> os.chdir("d:")

>>> os.getcwd()

'D:\\'

>>> os.curdir

'.'

>>> os.pardir

'..'

>>> os.makedirs("1\\2")

>>> os.removedirs("1\\2")

>>> os.listdir()

['$360Section', '$RECYCLE.BIN', '1.txt', 'MobileFile', 'pymysql_test.py', 'System Volume Information', '用户目录']

>>> os.mkdir("")

>>> os.listdir()

['$360Section', '$RECYCLE.BIN', '', '1.txt', 'MobileFile', 'pymysql_test.py', 'System Volume Information', '用户目录']

>>> os.rmdir("")

>>> os.rename('1.txt','2.txt')

>>> os.listdir()

['$360Section', '$RECYCLE.BIN', '2.txt', 'MobileFile', 'pymysql_test.py', 'System Volume Information', '用户目录']

>>> os.remove('1.txt')

Traceback (most recent call last):

  File "<pyshell#22>", line 1, in <module>

    os.remove('1.txt')

FileNotFoundError: [WinError 2] 系统找不到指定的文件。: '1.txt'

>>> os.remove('2.txt')

>>> os.stat()

Traceback (most recent call last):

  File "<pyshell#24>", line 1, in <module>

    os.stat()

TypeError: Required argument 'path' (pos 1) not found

>>> os.stat(os.getcwd())

os.stat_result(st_mode=16895, st_ino=1407374883553285, st_dev=2431137650, st_nlink=1, st_uid=0, st_gid=0, st_size=32768, st_atime=1505824872, st_mtime=1505824872, st_ctime=1445187376)

>>> import os

>>> os.chdir("d:")

>>> os.getcwd()

'D:\\'

>>> os.mkdir('test')

>>> os.listdir()

['$360Section', '$RECYCLE.BIN', 'MobileFile', 'pymysql_test.py', 'System Volume Information', 'test', '用户目录']

>>> os.chdir('test')

>>> os.getcwd()

'D:\\test'

>>> os.path.abspath(os.getcwd())

'D:\\test'

>>> os.path.split(os.getcwd())

('D:\\', 'test')

>>> cp = os.getcwd()

>>> os.path.dirname(cp)

'D:\\'

>>> os.path.basename(cp)

'test'

>>> os.path.exists(cp)

True

>>> os.path.exists("d:\\123\123")

False

>>> os.path.isabs(cp)

True

>>> os.path.isabs("11\\1.py")

False

>>> os.path.isfile(cp)

False

>>> os.path.isfile("d:\\1.txt")

False

>>> os.path.isdir(cp)

True

>>> os.path.join(cp, "test.py")

'D:\\test\\test.py'

>>> os.path.getatime(cp)

1505825113.4970243

>>> os.path.getmtime(cp)

1505825113.4970243

>>> os.path.getsize(cp)

0

（3）os.walk(top, topdown=True, onerror=None, followlinks=False)

walk方法是os模块中非常重要和强大的一个方法。可以帮助我们非常便捷地以递归方式自顶向下或者自底向上的方式遍历目录树，对每一个目录都返回一个三元元组(dirpath, dirnames, filenames)。

三元元组(dirpath，dirnames，filenames)：

dirpath - 遍历所在目录树的位置，是一个字符串对象

dirnames - 目录树中的子目录组成的列表，不包括("."和"..")

filenames - 目录树中的文件组成的列表

如果可选参数topdown = True或者没有指定，则采用自顶向下的方式进行目录遍历，也就是从父目录向子目录逐步深入遍历，如果topdown = False，则采用自底向上的方式遍历目录，也就是先打印子目录再打印父目录的方式。

如果可选参数onerror被指定，则onerror必须是一个函数，该函数有一个OSError实例的参数，这样可以允许在运行的时候即使出现错误的时候不会打断os.walk()的执行，或者抛出一个异常并终止os.walk()的运行。通俗的讲，就是定义这个参数用于指定当发生了错误时的处理方法。

默认情况下，os.walk()遍历的时候不会进入符号链接，如果设置了可选参数followlinks = True，则会进入符号链接。注意，这可能会出现遍历死循环，因为符号链接可能会出现自己链接自己的情况，而os.walk()没有那么高的智商，无法发现这一点。

下面的例子会将c:\python36目录中的所有文件和子目录打印出来。

import os

try:

    for root, dirs, files in os.walk(r"c:\python36"):

        print("\033[1;31m-"*8, "directory", "<%s>\033[0m" % root, "-"*10)

        for directory in dirs:

            print("\033[1;34m<DIR>    %s\033[0m" % directory)

        for file in files:

            print("\t\t%s" % file)

except OSError as ex:

    print(ex)

运行结果：

-------- directory <c:\python36> ----------

<DIR>    DLLs

<DIR>    Doc

<DIR>    include

<DIR>    Lib

<DIR>    libs

<DIR>    Scripts

<DIR>    share

<DIR>    tcl

<DIR>    Tools

        LICENSE.txt

        NEWS.txt

        python.exe

        python3.dll

        python36.dll

        pythonw.exe

        vcruntime140.dll

-------- directory <c:\python36\DLLs> ----------

        py.ico

        pyc.ico
...

下面的例子会统计c:/python36/Lib/email目录下所有子目录的大小，但是CVS目录除外。

import os

from os.path import join, getsize

for root, dirs, files in os.walk('c:/python36/Lib/email'):

    print(root, "consumes", end=" ")

    print(sum(getsize(join(root, name)) for name in files), end=" ")

    print("bytes in", len(files), "non-directory files")

    if 'CVS' in dirs:

        dirs.remove('CVS')  # 不遍历CVS目录

运行结果：

C:\Python36\python.exe F:/Python/pycharm/201705/1.py -

c:/python36/Lib/email consumes 377849 bytes in 21 non-directory files

c:/python36/Lib/email\mime consumes 12205 bytes in 9 non-directory files

c:/python36/Lib/email\mime\__pycache__ consumes 30289 bytes in 27 non-directory files

c:/python36/Lib/email\__pycache__ consumes 741924 bytes in 60 non-directory files

下面的例子会递归删除目录的所有内容，危险，请勿随意尝试！

import os

for root, dirs, files in os.walk(top, topdown=False):

    for name in files:

        os.remove(os.path.join(root, name))

    for name in dirs:

        os.rmdir(os.path.join(root, name))

(4) 执行命令

在早期的Python版本中，通常使用os模块的system或者popen等方法执行操作系统的命令。但是，最近Python官方逐渐弃用了这些命令，而是改用内置的subprocess模块执行操作系统相关命令。

由于目前还有很多人仍然在使用os的system和popen方法，在此简要介绍一下。

os.system(command)

运行操作系统命令，直接显示结果。但返回值是0或-1，不能获得显示在屏幕上的数据。 command是要执行的命令字符串

In [1]: import os

In [2]: ret = os.system("ifconfig")

eth0      Link encap:Ethernet  HWaddr 02:16:3e:31:ff:3b

          inet addr:176.17.230.109  Bcast:176.17.230.255  Mask:255.255.255.0

          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1

          RX packets:274674 errors:0 dropped:0 overruns:0 frame:0

          TX packets:260923 errors:0 dropped:0 overruns:0 carrier:0

          collisions:0 txqueuelen:1000

          RX bytes:62664341 (62.6 MB)  TX bytes:83842737 (83.8 MB)

lo        Link encap:Local Loopback

          inet addr:127.0.0.1  Mask:255.0.0.0

          UP LOOPBACK RUNNING  MTU:65536  Metric:1

          RX packets:244020 errors:0 dropped:0 overruns:0 frame:0

          TX packets:244020 errors:0 dropped:0 overruns:0 carrier:0

          collisions:0 txqueuelen:1

          RX bytes:376137873 (376.1 MB)  TX bytes:376137873 (376.1 MB)

In [3]: ret

Out[3]: 0

可以看到运行的返回值是0，而不是我们期望的输出信息。

如果我们是在windows环境下使用IDLE运行os.system('ipconfig /all')，你会发现命令终端界面一闪而过，根本啥都来不及看。这时候，你最好进入cmd环境使用python命令进入交互式界面才可以看到屏幕上的信息。

另外，请尝试在不同环境下执行os.system('python3')。

os.popen(command, [mode, [bufsize]])

开启一个子进程执行command参数指定的命令，在父进程和子进程之间建立一个管道pipe，用于在父子进程间通信。该方法返回一个文件对象，可以对这个文件对象进行读或写，取决于参数mode，如果mode指定了只读，那么只能对文件对象进行读，如果mode参数指定了只写，那么只能对文件对象进行写操作。

简而言之，popen也可以运行操作系统命令，并通过read()方法将命令的结果返回，不像system只能看不能存，这个能存！

>>> os.popen('ipconfig')

<os._wrap_close object at 0x0000000002BB8EF0>

>>> ret = os.popen('ipconfig')

>>> ret.read()

'\nWindows IP 配置\n\n\n以太网适配器 Bluetooth 网络连接 2:\n\n

媒体状态  . . . . . . . . . . . . : 媒体已断开\n

 连接特定的 DNS 后缀 . . . . . . . : \n\n无线局域网适配器 无线网络连接 2:\n\n   媒体状态  . . . . . . . . . . . . : 媒体已断开\n

  连接特定的 DNS 后缀 . . . . . . . : \n\n无线局域网适配器 无线网络连接:\n\n

连接特定的 DNS 后缀......

试试运行类似python3这种会进入交互式界面的命令看看，结果不是很理想，无法进入想要的交互式界面：

>>> ret = os.popen('python3')

>>> ret

<os._wrap_close object at 0x0000000002BB8E80>

>>> ret.read()

''

4.sys模块

sys模块主要是针对与Python解释器相关的变量和方法，不是主机操作系统。

属性及方法	使用说明

sys.argv	获取命令行参数列表，第一个元素是程序本身

sys.exit(n)	退出Python程序，exit(0)表示正常退出。当参数非0时，会引发一个SystemExit异常，可以在程序中捕获该异常

sys.version	获取Python解释程器的版本信息

sys.maxsize	最大的Int值，64位平台是2**63 - 1

sys.path	返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform	返回操作系统平台名称

sys.stdin	输入相关

sys.stdout	输出相关

sys.stderr	错误相关

sys.exc_info()	返回异常信息三元元组

sys.getdefaultencoding()	获取系统当前编码，默认为utf-8

sys.setdefaultencoding()	设置系统的默认编码

sys.getfilesystemencoding()	获取文件系统使用编码方式，默认是utf-8

sys.modules	以字典的形式返回所有当前Python环境中已经导入的模块

sys.builtin_module_names	返回一个列表，包含所有已经编译到Python解释器里的模块的名字

sys.copyright	当前Python的版权信息

sys.flags	命令行标识状态信息列表。只读。

sys.getrefcount(object)	返回对象的引用数量

sys.getrecursionlimit()	返回Python最大递归深度，默认1000

sys.getsizeof(object[, default])	返回对象的大小

sys.getswitchinterval()	返回线程切换时间间隔，默认0.005秒

sys.setswitchinterval(interval)	设置线程切换的时间间隔，单位秒

sys.getwindowsversion()	返回当前windwos系统的版本信息

sys.hash_info	返回Python默认的哈希方法的参数

sys.implementation	当前正在运行的Python解释器的具体实现，比如CPython

sys.thread_info	当前线程信息

（1）sys.argv

sys.argv是一个脚本执行参数列表，列表的第一个元素是脚本名称，从第二个元素开始才是真正的参数。

# test.py

import sys

for index, arg in enumerate(sys.argv):

    print("第%d个参数是： %s" % (index, arg))

　　

运行python test.py 1 2 3 4，结果：

第0个参数是： test.py

第1个参数是： 1

第2个参数是： 2

第3个参数是： 3

第4个参数是： 4

（2）sys.getrefcount(object)

我们都知道Python有自动的垃圾回收机制，让我们不用费力去进行内存管理。那么Python怎么知道一个对象可以被当做垃圾回收呢？Python使用‘引用计数’的方式，追踪每个对象的引用次数，每对这个对象的一次引用，这个计数就加一，每删除一个该对象的引用，这个计数就减一。当引用为0的时候，就表示没有任何变量指向这个对象，那么就可以回收这个对象，腾出它所占用的内存空间。

sys.getrefcount(object)这个方法可以返回一个对象被引用的次数。注意，这个次数默认从1开始，因为你在使用sys.getrefcount(object)方法的时候就已经引用了它一次（该引用是临时性的，调用结束后，自动解除引用。）。如果不好理解，可以简单地认为它自带被动光环：引用+1。

>>> a = "I like Python!"

>>> sys.getrefcount(a)

2

>>> b = a

>>> sys.getrefcount(a)

3

>>> c = a

>>> sys.getrefcount(a)

4

>>> del c

>>> sys.getrefcount(a)

3

>>> del b

>>> sys.getrefcount(a)

2

>>> sys.getrefcount(1)

902

>>> sys.getrefcount("a")

36

>>> sys.getrefcount(True)

581

>>> sys.getrefcount(None)

6918

注意实例中的1、"a"、True、None，Python内部环境运行过程中已经引用了它们很多次，None甚至被使用了6918次。

（3）sys.modules

sys.modules保存有当前Python环境中已经导入的模块记录，这是一个全局字典，当Python启动后就加载在内存中。每当导入新的模块，sys.modules将自动记录该模块，当第二次试图再次导入该模块时，Python会先到这个字典中查找是否曾经导入过该模块。是则忽略，否则导入，从而加快了程序运行的速度。同时，它拥有字典的基本方法。例如sys.modules.keys()查看字典的所有键，sys.modules.values()查看字典的所有值，sys.modules['sys']查看sys键对应的值。

>>> import sys

>>> sys.modules

{'builtins': <module 'builtins' (built-in)>, 'sys': <module 'sys' (built-in)>, '_frozen_importlib':

<module 'importlib._bootstrap' (frozen)>, '_imp': <module '_imp' (built-in)>, '_warnings':

<module '_warnings' (built-in)>, '_thread':

.......截取部分

>>> sys.modules.keys()

dict_keys(['builtins', 'sys', '_frozen_importlib', '_imp', '_warnings', '_thread', '_weakref', '_frozen_importlib_external', '_io',

'marshal', 'nt', 'winreg', 'zipimport', 'encodings', 'codecs', '_codecs', 'encodings.aliases',

...截取部分

>>> sys.modules.values()

dict_values([<module 'builtins' (built-in)>, <module 'sys' (built-in)>, <module 'importlib._bootstrap' (frozen)>,

 <module '_imp' (built-in)>, <module '_warnings' (built-in)>, <module '_thread' (built-in)>,

 <module '_weakref' module 'urllib.parse' from 'C:\\Python36\\lib\\urllib\\parse.py'>])

.......截取部分

>>> sys.modules['sys']

<module 'sys' (built-in)>

（4）sys.builtin_module_names

sys.builtin_module_names是一个字符串元组，包含了所有已经编译在Python解释器内的模块名称。

import sys

def find_module(module):

    if module in sys.builtin_module_names:

        print(module, " 内置于=> ", "__builtin__")

    else:

        print(module, "模块位于=> ", __import__(module).__file__)

find_module('os')

find_module('sys')

find_module('time')

find_module('zlib')

find_module('string')

#----------

运行结果：

os 模块位于=>  C:\Python36\lib\os.py

sys  内置于=>  __builtin__

time  内置于=>  __builtin__

zlib  内置于=>  __builtin__

string 模块位于=>  C:\Python36\lib\string.py

（5）sys.path

path是一个目录列表，供Python从中查找模块。在Python启动时，sys.path根据内建规则和PYTHONPATH变量进行初始化。sys.path的第一个元素通常是个空字符串，表示当前目录。

>>> sys.path

['', 'C:\\Python36\\Lib\\idlelib', 'C:\\Python36\\python36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib', 'C:\\Python36', 'C:\\Python36\\lib\\site-packages']

sys.path本质上是一个列表，可以进行append、insert、pop、remove等各种列表相关的操作，但通常都进行append操作，添加自己想要的查找路径。在做修改、删除类型的操作之前，请务必确认你的行为！

（5）sys.platform

获取当前执行环境的平台名称，不同的平台返回值如下表所示：

（6）sys.stdin、sys.stdout、sys.stderr

stdin用于所有的交互式输入（包括input()函数）。

stdout用于print()的打印输出或者input()函数的提示符。

stderr用于解释器自己的提示信息和错误信息。

简而言之，这三个属性就是操作系统的标准输入、输出和错误流，它们返回的都是一个“文件类型”对象，支持read()、write()和flush()等操作，就像用open()方法打开的文件对象那样！

>>> import sys

>>> s = sys.stdin.read()        # 使用ctrl+d结束输入

i like python

end

>>> s

'i like python\nend\n\n\n\n'

>>> sys.stdout.write(s)

i like python

end

sys.stdout 与 print()

当我们print(obj)的时候，事实上是调用了sys.stdout.write(obj+'\n')，将内容打印到控制台（默认是显示器），然后追加一个换行符。以下两行等价：

sys.stdout.write('hello'+'\n')

print('hello')

sys.stdin 与 input()

当我们用input('Please input something！')时，事实上是先输出提示信息，然后捕获输入。以下两组等价：

s = input('Please input something！')

print('Please input something！',)  # 逗号表示不换行

s = sys.stdin.readline()[:-1]  # -1 可以抛弃输入流中的'\n' 换行符，自己琢磨一下为什么。

从控制台重定向到文件

默认情况下sys.stdout指向控制台。如果把文件对象赋值给sys.stdout，那么print ()调用的就是文件对象的write()方法。

f_handler = open('out.log', 'w')

sys.stdout = f_handler

print('hello')

# 你无法在屏幕上看到“hello”

# 因为它被写到out.log文件里了

如果你还想同时在控制台打印的话，最好先将原始的控制台对象引用保存下来，向文件中打印之后再恢复 sys.stdout

__console__ = sys.stdout    # 保存控制台

# redirection start #       # 去干点别的，比如写到文件里

...

# redirection end           # 干完别的了，恢复原来的控制台

sys.stdout = __console__

（7）实例：带百分比的进度条

利用sys.stdout的功能，可以实现一个简易的进度条。

import sys

import time

def bar(num, total):

    rate = num / total

    rate_num = int(rate * 100)

    r = '\r[%s%s]%d%%' % ("="*num, " "*(100-num), rate_num, )

    sys.stdout.write(r)

    sys.stdout.flush()

if __name__ == '__main__':

    for i in range(0, 101):

        time.sleep(0.1)

        bar(i, 100)