1. 【输入】input()函数
1.1 语法参考
input()函数可以提示并接收用户的输入，将所有的输入 按照字符串进行处理，并返回一个字符串，input()函数的基本用法如下：
input([prompt])
参数说明：
- prompt：可选参数，表示提示信息。
示例：接收用户输入的内容，并保存到变量中，代码如下：
name = input("Please enter your name:") #提示请输入你的名字
print(name) #输出名字
在Python 3.x中，无论输入的是数字还是字符都将被作为字符串读取。如果想要接收数值，需要把接收到的字符串进行类型转换。
示例：使用input()函数提示输入内容，将输入的成绩转换为整型保存到列表中并输出，代码如下：
# 提示输入数学、英语、语文成绩
score1 = int(input("请输入数学成绩：")) # 转换为整型
score2 = int(input("请输入英语成绩："))
score3 = int(input("请输入语文成绩："))
list = [score1,score2,score3] # 将变量内容存入列表
print(list) # 输出列表内容
提示：input()函数返回的值是字符串类型的，如果要让输入的数字变为整型，可以使用int()函数将数字或字符串转换为整数。
示例：实现根据输入的字符，利用ord()函数将字符转换为对应的ASCII数值，代码如下：
n =input("输入一个字符：") # 输入字母或数字，不能输入汉字
value=ord(n) # 用ord()函数将字符转换为对应的ASCII数值
print(n + "的ASCII码为：", value) # 显示字符对应的ASCII码值
1.2 实战技巧
锦囊01 常用输入
使用input()输入信息时，提示信息参数可以为空（不提示任何信息），也可以和转义字符结合（如提示信息后加“\n”，表示在提示信息后换行）。常见应用代码如下：
name = input("") # 无提示型输入，不换行
name1 = input("name:") # 简洁型输入
name2 = input("请输入您的姓名：") # 提示型输入，不换行
name3 = input("姓名:\n") # 提示型输入，换行
也可以将多条输入语句放到列表、元组或字典中。例如，放到列表中，将实现把输入结果保存到列表中，代码如下：
data=[input('姓名：'),input('电话：'),input('学校：')]
print(data )
锦囊02 去除输入的非法字符
输入数据时，有时可能会输入空格等非法字符，这时可以使用字符串的strip()、lstrip()或rstrip()方法去除。例如下面的代码：
name =input("请输入您的姓名:").strip(' ') # 去除输入数据两端的空格
age1 =input("请输入您的年龄:").lstrip(' ') # 去除输入数据左侧的空格
age2 =input("请输入您的年龄:").rstrip(' ') # 去除输入数据左侧的空格
锦囊03 多数据输入
input()函数支持多个数据输入，输入的时候通常使用字符串的split()方法进行分割，如同时输入某一地点的坐标值等。示例代码如下：
# 一行输入两个不限定类型的值
x,y=input("请输入出发地点的横、纵坐标值，用英文逗号分隔:").split(',')
name,age,height=input('请输入你的姓名、年龄和身高，用英文逗号分隔：\n').split(',')
# 一行输入两个限定类型为int的值
a,b=map(int,input('请输入两个数，用空格分隔：\n').split())
说明：如果不按指定规则输入将输出“ValueError: not enough values to unpack”异常。
通过循环语句也可以实现多数据输入，也需要使用字符串的split()方法对输入的数据进行分割。如：
sum = 0
for x in input('请输入多个加数，中间用空格分隔：').split(' '):
sum = sum+int(x)
print(sum)
输出结果为：
请输入多个加数，中间用空格分隔：
1 2 3 4 5 6 7 8
36
锦囊04 强制转换输入
用户通过input()函数输入的数据都是字符串类型的，有时程序要求输入的数据为某种特定数据类型，如整型、浮点型或日期型等，这时就需要在输入后进行强制转换。例如，使用int()函数将用户输入的字符格式的数据转换为整型数据。代码如下：
age = int(input('age：'))
print(age)
print(type(age))
有时对输入的字符是有一定要求的，如首字母大写、输入全部为小写等，这时可以使用字符串的lower()、upper()、capitalize()或title()等方法对输入的字符串进行强制转换。如：
password= input('请输入您的密码：').upper() # 将输入的字符串转换为全部大写
name= input('请输入您的姓名：').capitalize() # 将输入的字符串转换为首字母大写
school= input('请输入您的学校：').title() # 将输入的单词全部转换为首字母大写
print(password,name,school) # 输出以上转换后的内容
锦囊05 对输入数据进行验证
在Python中，提供了一些对字符串进行验证的方法，通过它们可以非常方便地判断输入内容是大写字母、小写字母、数字或是空白字符等。主要方法如下：
-
isalnum()：所有字符都是数字或者字母；
-
isalpha()：所有字符都是字母；
-
isdigit()：所有字符都是数字；
-
islower()：所有字符都是小写；
-
isupper()：所有字符都是大写；
-
istitle()：所有单词都是首字母大写，类似标题；
-
isspace()：所有字符都是空白字符、\t、\n、\r。
使用字符串的isdigit()方法可以验证输入是否为数字。例如，需要输入为纯数字方可进入系统，否则退出系统，代码如下：
if input('请输入数字验证码：').isdigit():
print('正在登录草根之家商务系统！')
else:
print('输入非法，将退出系统！')
1.3 应用场景
场景一：对输入的用户名和密码进行验证
对输入的用户名和密码进行验证，假设用户的用户名为“joe”，密码为“123456”。如果用户输入正确，则提示用户“稍后，正在进入账户！”；如果输入用户名u，则提示用户“用户名或密码输入错误，请重新输入！”，让用户重新输入；如果用户名和密码输入错误超过三次，则提示“用户或密码输入错误超过三个，将退出程序！”，然后退出程序。实现代码如下：
for i in range(0,3):
user = input('请输入用户名：')
if user == 'joe':
password = input('请输入密码：')
if password == '123456':
print('稍后，正在进入账户！',end = '')
break
else:
print('密码输入错误，请重新输入！！')
else:
print('用户名输入错误，请重新输入！！')
if user=='joe'and password == '123456':
print('稍后，正在进入账户！',end = '')
else:
print('用户或密码输入错误超过三个，将退出程序！！')
场景二：输入三角形的三边长来判断是怎样的三角形
如果要一次转换多个输入数据的值，可以使用map()函数。map()函数可以接收一个函数和列表，并通过函数依次作用到列表的每个元素，返回一个新的列表。本例输入三角形三个边的边长要一次输入，需要使用map()、input()和int()函数。具体用法为：a,b,c=map(int,input().split(’ '))，split()函数通过空格分解字符串为列表，int()函数将分解的字符串转换为数字，实现代码如下：
a, b, c = map(int, input("请输入三角形的三条边长,用空格间隔:").split()) # 分解输入的边长
if a > 0 and b > 0 and c > 0: # 判断输入的边长是否大于0
if a + b > c and b + c > a and a + c > b: # 判断输入的边长是否构成三角形
ans = "可以构成三角形"
if a == b and b == c and a == c: # 判断是否构成等边三角形
ans = "可以构成等边三角形"
else:
if a == b or b == c or a == c: # 判断是否构成等腰三角形
ans = "可以构成等腰三角形"
# 判断是否构成等腰直角三角形
if a ** 2 == b ** 2 + c ** 2 or b ** 2 == a ** 2 + c ** 2 or c ** 2 == a ** 2 + b ** 2:
ans = "可以构成等腰直角三角形"
else:
ans = "不能构成三角形"
else:
ans = "边长必须大于0！！"
print(ans)
场景三：通过键盘控制DOS下主程序菜单的选择
在DOS或命令提示符下运行的程序主功能菜单，通常是通过菜单列表前面的数字进行程序功能选择的。是否可以通过键盘的上下键进行选择呢？当然是可以的，通过正则表达式对输入的数字或者移动的方向键进行判断，就可以通过数字键和方向键对菜单的选择。代码如下：
import re
print('''
Microsoft MS-DOS 10 Startup Menu
=============================================
1.ghost 11.2
2.ghost 8.3
3.DOS TOOLS
4.PGMAGIC
5.DOS
0.退出系统
=============================================
说明：通过数字键选择菜单
''')
option_str = input('请通过数字键或者↑↓方向键选择功能：')
option = re.sub(r'\D','',option_str) # 去除字符串中的非数字字符
if int(option) == 1: # 选择数字键1执行的菜单
print('将运行ghost 11.2系统')
if int(option) == 2: # 选择数字键2执行的菜单
print('将运行ghost 8.3系统')
if int(option) == 3: # 选择数字键3执行的菜单
print('将运行DOS 工具箱')
if int(option) == 4: # 选择数字键4执行的菜单
print('将运行系统魔法设置')
if int(option) == 5: # 选择数字键5执行的菜单
print('将进入DOS系统')
if int(option) == 0: # 选择数字键0，退出系统
print('将退出系统')
2. 【打开文件并返回文件对象】open()函数
2.1 语法参考
open()函数的语法格式如下：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明：
- file：必需参数，文件路径，表示需要打开文件的相对路径（相对于程序所在路径，例如，要创建或打开程序所在路径下的“mr.txt”文件，则可以直接写成相对路径“mr.txt”，如果是程序所在路径下的“soft”子路径下的“mr.txt”文件，则可写成“soft/mr.txt”）或者绝对路径（需要输入包含盘符的完整文件路径，如’D:/mr.txt’）。文件路径注意需要使用单引号或双引号括起来。
注意：在指定文件路径时，也可以在表示路径的字符串前面加上字母r（或R），那么该字符串将原样输出，这时路径中的分隔符就不需要再转义了。例如，路径’D:/mr.txt’也可以写作r’D:/mr.txt’。
- mode：可选参数，用于指定文件的打开模式。常见的打开模式有r（以只读模式打开）、w（以只写模式打开）、a（以追加模式打开），默认的打开模式为只读（即r）。实际调用的时候可以根据情况进行组合。
| 值 | 说明 | 注意 |
| r | 以只读模式打开文件（默认模式）。文件的指针将会放在文件的开头 | 文件必须存在 |
| rb | 以二进制格式打开文件，并且采用只读模式。文件的指针将会放在文件的开头。一般用于非文本文件，如图片、声音等 | |
| r+ | 打开文件后，可以读取文件内容，也可以写入新的内容覆盖原有内容（从文件开头进行覆盖） | |
| rb+ | 以二进制格式打开文件，并且采用读写模式。文件的指针将会放在文件的开头。一般用于非文本文件，如图片、声音等 | |
| w | 以只写模式打开文件。如果文件存在，则将其覆盖；如果文件不存在，则创建新文件 | 必须要保证文件所在目录存在，文件可以不存在 |
| wb | 以二进制格式打开文件，并且采用只写模式。一般用于非文本文件，如图片、声音等 | |
| w+ | 打开文件后，先清空原有内容，使其变为一个空的文件，对这个空文件有读写权限 | |
| wb+ | 以二进制格式打开文件，并且采用读写模式。一般用于非文本文件，如图片、声音等 | |
| a | 以追加模式打开文件。如果文件存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），如果文件不存在，则创建新文件用于写入 | |
| ab | 以二进制格式打开文件，并且采用追加模式。如果该文件已经存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），否则，创建新文件用于写入 | |
| a+ | 以读写模式打开文件。如果该文件已经存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），否则，创建新文件用于读写 | |
| ab+ | 以二进制格式打开文件，并且采用追加模式。如果该文件已经存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），否则，创建新文件用于读写 |
-
buffering：可选参数，用于指定读写文件的缓冲模式，值为0表示不缓存；值为1表示缓存（默认为缓存模式）；如果大于1，则表示缓冲区的大小。
-
encoding：表示读写文件时所使用的文件编码格式，一般使用UTF-8；
-
errors：表示读写文件时碰到错误的报错级别。常见的报错级别有：
— ‘strict’：严格级别，字符编码有报错即抛出异常，默认级别，errors参数值传入None即按此级别处理。
— ‘ignore’：忽略级别，字符编码有错，忽略掉。
— ‘replace’：替换级别，字符编码有错的，替换成？。 -
newline：表示用于区分换行符(只对文本模式有效，可以取的值有None、‘\n’、‘\r’、‘\r\n’)
-
closefd：表示传入的file参数类型（缺省为True），传入文件路径时一定为True，传入文件句柄则为False。
2.2 文件操作的常用方法
打开文件后对文件读取操作通常有三种方法：read()方法表示读取全部内容；readline()方法表示逐行读取；readlines()方法表示读取所有行内容。下面分别进行介绍。
- read()方法，读取文件的全部或部分内容，对于连续的面向行的读取，则不使用该方法。语法如下：
fp.read([size])
其中，size为可选参数，用于指定要读取文件内容的字符数（所有字符均按一个计算，包括汉字，如“name：无”的字符数为6），如read(8)，表示读取前8个字符。如果省略，则返回整个文件的内容。
注意：使用read()方法读取文件内容时，如果文件大于可用内存，则不能实现文件的读取，而是返回空字符串。
- readline()方法，返回文件中一行的内容，具体语法为：
file.readline([size])
其中，size为可选参数，用于指定读取一行内容的范围，如readline(8)，表示指读取一行中前8个字符的内容。如果省略，则返回整行的内容。
- readlines()方法，返回一个列表，列表中每个元素为文件中的一行数据，语法如下：
file.readlines()
除了对文件读取操作，还可以对文件进行写入、获取文件指针位置和关闭文件等操作。具体方法如下：
- write()方法，将内容写入文件。其中，obj为要写入的内容，语法如下，：
f.write(obj)
- tell()方法，返回一个整数，表示文件指针的当前位置，即在二进制模式下距离文件头的字节数，语法如下：
f.tell()
说明：使用tell()方法返回的位置与为read()方法指定的size参数不同。tell()方法返回的不是字符的个数，而是字节数，其中汉字所占的字节数根据其采用的编码有所不同，如果采用GBK编码，则一个汉字按两个字符计算；如果采用UTF-8编码，则一个汉字按3个字符计算。
- seek()方法，将文件的指针移动到新的位置，位置通过字节数进行指定。这里的数值与tell()方法返回的数值的计算方法一致。语法如下：
file.seek(offset[,whence])
参数说明：
file：表示已经打开的文件对象；
offset：用于指定移动的字符个数，其具体位置与whence有关；
whence：用于指定从什么位置开始计算。值为0表示从文件头开始计算，1表示从当前位置开始计算，2表示从文件尾开始计算，默认为0。
- close()方法，关闭打开的文件，语法如下：
f. close ()
2.3 实战技巧
锦囊01 常用文件读取操作
打开文件后对文件读取操作通常有三种方法：read()表示读取全部内容；read(8)表示读取前8个字符；readline()表示逐行读取；readline(8)表示读取行的前8个字符；readlines()表示读取所有行内容，可以通过括号内的数字限制读取内容的范围。
- 一次读取文件的全部内容
打开文件后，如果要一次读取文件的全部内容，可以使用read()方法。代码如下：
f = open('D:/lift.txt') # 以只写模式打开文件
f.read()
使用readline()方法也可以实现文件全部内容的读取，但括号中读取的字符数要设置足够大，实现代码如下：
f = open('D:/lift.txt') # 以只写模式打开文件
lines = f.readline(20000) # 设置读取的字符足够大
print(lines) # 输出读取到的文件内容
f.close() # 关闭文件
- 读取文件或者每行的前几个字符
如果要读取文件内容中的前几个字符，可以直接在Read()方法的括号里面输入要读取的字符数。如读取文件的前8个字符，实现代码如下：
f = open('D:/lift.txt') # 以只写模式打开文件
f.read(8)
如果要一次读取每行内容的前几个字符，可以使用readline()方法，设置读取的字符个数即可，实现代码如下：
f = open('D:/lift.txt') # 以只写模式打开文件
while True:
line = f.readline(5) # 一次读取一行中的5个字符
print(line) # 输出读取的内容
if line == '': # 如果读取的内容为空
break # 跳出循环
f.close() # 关闭文件
- 逐行读取文件内容，可以使用while语句和readline()方法，实现代码如下：
f = open('D:/lift.txt') # 以只写模式打开文件
line = f.readline() # 读取一行
while line:
print(line) # 输出读取的一行内容
line = f.readline() # 读取一行
f.close() # 关闭文件
或
f = open('D:/lift.txt') # 以只写模式打开文件
while True:
line = f.readline() # 读取一行
print(line) # 输出读取的一行内容
if line == '': # 如果读取的内容为空
break # 跳出循环
f.close() # 关闭文件
逐行读取文件内容，也可以使用for语句和readline()方法，实现代码如下：
for line in open('D:/lift.txt'):
print(line) # 输出一行内容
锦囊02 使用with open语句打开文件
在Python中，使用with open语句可以用指定的模式打开一个文件对象。使用该方式打开文件，并对文件操作完成后，无需通过close()方法关闭文件，文件会自动关闭。下面是一次读取整个文件内容的代码：
with open('D:/lift.txt', 'r' ) as f: # 以只读方式打开文件
print(f.read()) # 读取全部文件内容并输出
使用with open语句打开文件后，也可以按行读取文件内容，代码如下：
with open('D:/lift.txt', 'r') as f: # 以只写模式打开文件
lines=f.readlines() # 读取全部内容
for line in lines: # 遍历每行内容
print(line.rstrip()) # 输出每行中去掉右侧空白字符的内容
锦囊03 在相对路径下创建或写入文件
编写程序经常要用到绝对路径和相对路径，绝对路径是指从根目录开始直到文件所在位置的路径，通常是从盘符开始的路径，如“C:\mingribook\python”；相对路径是程序或文件所在目录到指定文件位置的路径，如“/test”。使用相对路径会使程序处理文件时非常灵活、方便。建议用户在编写程序时尽量使用相对路径，除非特殊要求。本实例调用open()函数以写方式打开程序所在路径下的lift.txt文件，然后向该文件内写入信息，示例代码如下：
with open('lift.txt', 'w') as f: # 以只写模式打开文件
f.write('生命美妙之处， 就在于你的勇气会成就更美的你。')
锦囊04 读取操作文件时去除空格，空行等
读取文件后，针对文件内容，有时需要做相应的处理，如去除空格、空行、回车符（\n）、制表符（\t）等。下面是数据去除的典型应用。
with open('lift.txt', 'r') as f: # 以只读模式打开文件
for line in f.readlines():
print( line.strip() ) # 去除空格
print( line.strip('\n') ) # 去除换行符
print( line.strip('\t') ) # 去除制表符
锦囊05 读取非UTF-8编码的文件
要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：
with open('D:/lift.txt', 'r',encoding='gbk') as f: # 以只读模式打开文件
print( f.readlines() ) # 读取全部内容
说明：在指定encoding参数时，指定的编码一定是文件采用的编码，否则将抛出异常。
读取有些编码不规范的文件，可能会出现UnicodeDecodeError错误，遇到这种情况，通过open()函数接收errors参数，在遇到编码错误时，可以直接忽略错误，如：
with open('D:/lift.txt', 'r',encoding='gbk', errors='ignore') as f: # 以只读模式打开文件
print( f.readlines() ) # 读取全部内容
锦囊06 在指定目录（绝对路径）下生成TXT文件
调用open()函数在D盘根目录下创建一个名为lift.txt的文件，并且向该文件中写入指定内容，示例代码如下：
with open('D:/lift.txt', 'w') as fp: # 以只写模式打开文件
fp.write(' *'*10+'生命之美妙'+' *'*10)
fp.write('\n 生命美妙之处， 就在于你的勇气会成就更美的你。')
锦囊07 以二进制方式打开图片文件
在D盘目录下放置一个名称为python.jpg的图片文件，如图3示，使用open()函数以二进制方式打开该文件，并输出创建的对象，示例代码如下：
file = open('D:/python.jpg','rb') # 以二进制方式打开图片文件
print(file) # 需要结合第三方模块显示图片
运行上面的代码，结果如下：
<_io.BufferedReader name='D:/python.png'>
锦囊08 多个文件的读取操作
有时需要同时读取多个文件的数据，如mr1.txt、mr2.txt、mr3.txt中的文件格式是一样的，现在要分别从三个文件中读取一行数据并输出，实现代码如下：
f1 = open('mr1.txt', 'r') # 打开一个文件，命名为f1
f2 = open('mr2.txt', 'r') # 打开一个文件，命名为f2
f3 = open('mr3.txt', 'r') # 打开一个文件，命名为f3
i = f1.readline() # 读取一行
j = f2.readline() # 读取一行
k = f3.readline() # 读取一行
print(i, j, k) # 输出读取到的数据
其实有更简单的方法，使用zip()函数，代码如下：
f1 = open('mr1.txt', 'r') # 打开一个文件，命名为f1
f2 = open('mr2.txt', 'r') # 打开一个文件，命名为f2
f3 = open('mr3.txt', 'r') # 打开一个文件，命名为f3
for i, j, k in zip(f1, f2, f3): # 读取每个文件的内容
print(i, j, k)
锦囊09 读取一个文件夹下所有文件
如果要读取一个路径下所有文件（不包含子文件夹下的文件），并将读取的内容保存到一个列表进行输出。需要遍历该目录下所有文件，然后循环读取每个文件的内容到列表，最后将每个文件的内容添加到列表，实现代码如下：
import os # 导入文件与系统操作模块
path = 'temp/mr' # 待读取文件的文件夹相对地址
names = os.listdir(path) # 获得目录下所有文件的名称列表
all = [] # 保存文件信息的列表
for item in names: # 读取每一个文件
f = open(path+'/'+item) # 打开文件
new = [] # 保存单个文件内容的列表
for i in f: # 按行读取文件内容
new.append(i)
all.append(new) #将new添加到列表中
for i in all: # 遍历并输出列表
print(i)
锦囊10 将文件的写入和读取写入类
自定义文件操作类operatxt，实现文件的写入和读取操作。示例代码如下：
class operatxt(): # 定义操作文件类
def __init__(self,encoding):
self.enc = encoding
def WriteTxt(self,s): # 写入文件的方法
with open("test.txt","a+",encoding=self.enc) as fileInfo:
fileInfo.write(s) # 写入内容
def ReadTxt(self): # 读取文件的方法
with open("test.txt","r",encoding=self.enc) as fileInfo:
s= fileInfo.read() # 读取全部文件内容
return s
# 接收用户输入，将输入内容写入到文件，同时询问用户是读取文件还是继续写入文件
# 当用户选择读取文件时，将前面已经写入的内容读取出来并输出给用户，然后结束用户输入
while True:
content=input("请输入要写入到文件的内容：")
ot=operatxt("utf-8") # 创建操作文件类的对象，指定编码为UTF-8
ot.WriteTxt(content) # 写入文件内容
yn = input("内容已写入文件，是否要读取？输入y则读取文件，继续写入请输入n：")
if yn=='y':
s=ot.ReadTxt() # 读取文件
print("文件内容为：",s) # 输出文件内容
break # 退出出循环
2.4 应用场景
场景一：逐行显示蚂蚁庄园的动态
在蚂蚁庄园的动态栏目中记录着庄园里的新鲜事，现在可以通过读取文件的方式显示庄园里的动态信息。首先应用open()函数以只读方式打开一个记录动态信息的文件，然后应用while语句创建一个循环，在该循环中调用readline()方法读取一条动态信息并输出，另外还需要判断内容是否已经读取完毕，如果读取完毕应用break语句跳出循环，示例代码如下：
print("\n","="*35,"蚂蚁庄园动态","="*35,"\n")
with open('message.txt','r') as file: # 打开保存蚂蚁庄园动态信息的文件
number = 0 # 记录行号
while True:
number += 1
line = file.readline()
if line =='':
break # 跳出循环
print(number,line,end= "\n") # 输出一行内容
print("\n","="*39,"over","="*39,"\n")
场景二：读取两层文件夹的文件内容
如果要读取多层文件夹的所有文件内容，需要循环读取各个文件夹的文件内容。读取时，需要判断读取的是文件还是文件夹，如果是文件，先将文件的路径和文件名称保存到列表，然后读取文件所有内容到列表；如果是文件夹，则循环读取文件夹下的文件和文件夹，然后判断是文件还是文件夹，如果是文件，仍然是先将文件的路径和文件名称保存到列表，然后读取文件所有内容到列表。本实例只实现二级目录的文件内容读取，实现代码如下：
import os
list=[] # 保存文件内容的列表
path = "user" # 读取文件的目录
files = os.listdir(path) # 目录下所有文件和文件夹列表
for file in files: # 遍历目录下所有文件与文件夹
pathfile =path+"/"+file # 带完整路径的文件或文件夹
if not os.path.isdir(pathfile): # 如果是文件（不是文件夹）
with open(pathfile,'r') as fp: # 只读方式打开文件
list.append(pathfile) # 添加文件路径与名称到列表
list.append(fp.readlines()) # 将文件内容添加到列表
else:
newpath = path+"/"+file # 指定下级目录
files1 = os.listdir(newpath) # 下级目录下所有文件和文件夹列表
for file1 in files1: # file1和files1不能写成上层的file和files
pathfile = newpath + "/" + file1 # 带完整路径的下层文件或文件夹
if not os.path.isdir(pathfile): # 如果是文件（不是文件夹）
with open(pathfile, 'r') as fp: # 只读方式打开文件
list.append(pathfile) # 添加文件路径与名称到列表
list.append(fp.readlines()) # 将文件内容添加到列表
for item in list: # 遍历列表
print(item)
3. 【打印输出】print()函数
3.1 语法参考
print()函数的语法格式如下：
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
参数说明：
-
value：表示要输出的值；可以是数字、字符串、各种类型的变量等；
-
…：值列表，表示可以一次性打印多个值；输出多个值时，需要使用“,”（英文半角的逗号）分隔，打印出来各个值之间默认用空格隔开；
-
sep：表示打印值时，各个值之间的间隔符，默认值是一个空格，可以设置为其他的分隔符；
-
end：表示打印完最后一个值需要添加的字符串，用来设定输出语句以什么结尾，默认是换行符“\n”，即打印完会跳到新行，可以换成其他字符串，如end=‘\t’ 或end=’ '等，以实现不换行输出；
提示：sep和end的参数必须是字符串；或者为None，为None时意味着使用其默认值。
-
file：表示输出的目标对象，可以是文件也可以是数据流，默认是sys.stdout。可以设置“file = 文件储存对象”，把内容存到该文件中；
-
flush：表示是否立刻将输出语句输出到目标对象，flush值为False或者True，默认flush=False，表示输出值会保存在缓存中；当flush=True时，输出值强制写入文件。
注意：sep、end、file、flush都必须以命名参数方式传参，否则会被当作需要输出的对象。
提示：如果print()函数不传递任何参数，将会输出end参数的默认值，即打印一个空行。
3.2 实战技巧
锦囊01 输出字符串
字符串可以直接输出，也可以和数字、运算符等形成表达式进行输出。示例代码如下：
print() # 输出一个空行
print('') # 输出一个空行
#使用三引号可多行输出字符，如三行输出的服务器登录界面
print(''' 登录服务器
管理员：___________
密 码：___________ ''' ) # 字符最前和最后用三引号
print("没有伟大的愿望，就没有伟大的天才!") # 使用双引号将字符串括起来
运行结果如下：没有伟大的愿望，就没有伟大的天才!
print('go big or go home') # 使用单引号将字符串括起来
运行结果如下：go big or go home
print('go','big','or','go','home') # 字符之间用','间隔，则字符串用空格连接
运行结果如下：go big or go home
print('go' 'big' 'or' 'go' 'home') # 字符之间不用','间隔，则字符串无空格连接
运行结果如下：Gobigorgohome
print('go'+ 'big'+ 'or'+'go'+'home') # 用加号“+” 连接输出字符串
运行结果如下：Gobigorgohome
print('www','mingrisoft','com',sep='.') # 设置间隔符,字符之间用'.'间隔
运行结果如下：www.mingrisoft.com
print('2020','7','24',sep='-') # 设置间隔符,字符之间用'-'间隔
运行结果如下：2020-7-24
print(50 * '= ') # 一次输出多个字符，使用数字、运算符和字符串
运行结果如下：===================================================================
# 使用chr()函数，根据字符的ASCII值，输出字符
print(chr(65)) # 大写字母的ASCII值为65~90
运行结果如下：A
print(chr(97)) # 小写字母的ASCII值为97~122
运行结果如下：a
print(chr(8544),chr(8545),chr(8546),chr(8547))
运行结果如下：Ⅰ Ⅱ Ⅲ Ⅳ
# 使用ord()函数将字符转换为对应的整数
print(ord('生'),ord('化'),ord('危'),ord('机'))
运行结果如下：29983 21270 21361 26426
锦囊02 输出数值
数值类型可以直接输出，但使用“+”连接数值和其他数据类型时，系统会默认为是加法计算，会报错。可以使用“,”连接，或者将数值作为字符串来处理，两端加单引号或双引号。示例代码如下：
print(1314) # 直接输出整数，可不带双引号或单引号。输出结果：1314
print(12.22) # 直接输出浮点数。输出结果：12.22
print(10 / 3) # 可以包含算术表达式，输出运算结果为：3.3333333333333335
print(100 * 3.13 + 60) # 可以包含算术表达式，输出运算结果为：373
print(2, 0, 2, 0) # 使用“,”连接要输出的数值，中间用空格连接。输出结果：2 0 2 0
print(192, 168, 1, 1, sep='.') # 使用“.”连接输出数值，数值间用“.”间隔。输出结果：192.168.1.1
print("广州恒大" + 43) # 不能直接使用“+”连接字符串和数值，会报错。异常信息为：
# TypeError: can only concatenate str (not "int") to str
print("广州恒大" + str(43)) # 使用“+”连接字符串和数值时，数值要转换为字符串。输出结果：广州恒大43
print("广州恒大", 43) # 使用“,”连接字符串和数值，字符串和数值用空格分隔。输出结果：广州恒大 43
print("%e" % 120563332111098) # 使用操作符"%e"%格式化数值为科学记数法。输出结果：1.205633e+14
锦囊03 输出变量
字符串、数值型、布尔型、列表、字典等各种变量都可以直接输出。示例代码如下：
stra= 'go big or go home' # 定义一个字符串变量stra
print(stra) # 输出变量stra的值
运行结果如下：go big or go home
num = 27 # 定义一个数值型变量num
print(num) # 输出变量num的值
运行结果如下：27
stra= '你若盛开' # 定义字符串变量stra
strb= '蝴蝶自来' # 定义字符串变量strb
print(stra,strb) # 使用“，”连接变量stra和strb，中间用空格分隔
print(stra +'\n' + strb) # 使用'\n'连接变量stra和strb，换行分隔
print(stra + strb) # 使用“+”连接变量stra和strb，直接连接无空格
运行结果如下：
你若盛开 蝴蝶自来
你若盛开
蝴蝶自来
你若盛开蝴蝶自来
print(stra +'\n' , strb) # 添加'\n'换行后，使用“，”连接的字符串前面仍然有一个空格
运行结果如下：
你若盛开
蝴蝶自来
name = ['杨过','临安','1224','小龙女']
print(name)
print('--'.join(name)) # 使用“--”连接列表内数据
print(' '.join(name)) # 使用空格“ ”连接列表内数据
print(''.join(name)) # 直接连接列表内数据
运行结果如下：
['杨过', '临安', '1224', '小龙女']
杨过--临安--1224--小龙女
杨过 临安 1224 小龙女
杨过临安1224小龙女
word = '世界那么大，'
name= '黄蓉'
how= '想出去看看！！'
print(word, name, how) # 用“，”连接变量，中间用空格分隔
print(word, name, how,sep='.') # 设置间隔符为“，”
print(word, name, how,sep='****') # 设置间隔符为“****”
运行结果如下：
世界那么大， 黄蓉 想出去看看！！
世界那么大，.黄蓉.想出去看看！！
世界那么大，****黄蓉****想出去看看！！
word = ["南京","苏州","上海","杭州","宁波"]
for item in word: # 遍历列表
print(item) # 输出每个列表元素
运行结果如下：
南京
苏州
上海
杭州
宁波
for item in word: # 输出列表变量的数据到一行
print(item + ">>",end="") # 元素之间用“>>”连接
运行结果如下：
南京>>苏州>>上海>>杭州>>宁波>>
team="广州恒大"
points=63
print (team,points) # 使用“,”可以直接连接字符串变量和数字变量
print (team + str(points)) # 使用“+”连接字符串变量和数值变量前，必须先格式化数字变量为字符串
运行结果如下：
广州恒大 63
广州恒大63
锦囊04 特殊文字、符号、标志输出
在IDLE中，利用表情包输入特殊符号，代码如下：
按win+R键，输入“charmap”，调出字符映射表。单击想要插入到程序中的特殊字符，特殊符号将放大显示。记住放大符号旁边的字符码。如要输入，它的字符码为0x43，在0x和43之间加入f0(零)，即0xf043，然后就可以通过chr函数进行输出。代码如下：
print(chr(0xf043)) #0xf043是16进制数
for i in range(0xf035,0xf045): #设置字符集编码的区间，输出多个特殊符号
print(chr(i),end=",")
如果知道十进制字符编码的值也可以很方便的输入特殊字符。如要输入“←”，只要知道该符号的十进制字符编码“8592”，编写代码：
print(chr(8592))
print([chr(i) for i in range(8710,8719)]) # 输出多个特殊字符
锦囊05 将多次输出内容到一行
Python中，print()函数默认输出结束后以换行结束，即end的默认值是换行符“\n”，打印完会跳到新行。如果打印完成不换行，只需将end设置成其他字符串，如end=‘\t’ 、end=’ '或“《”等字符。下面是将数字0~9输出到一行显示，代码如下：
for x in range(0, 10): # 设置输出内容区间为0~9
print(x, end=' ') # 输出数字用空格间隔输出到一行
锦囊06 指定位数编号输出
zfill()函数可按指定位数输出固定位数的数据编号，如将输入的数字格式化为5位编号输出，代码如下：
instr=input('请输入一个数字：')
print (instr.zfill(5)) # 输出5位数字编号
如果要循环输出固定位数的数字编号，该怎么输出呢？只需使用循环语句，即可方便的输出，代码如下：
for i in range(1,20): # 设置输出区间为1~19
n=str(i) # 将数字转为字符串
s = n.zfill(3) # 将格式化的编号赋值给s
print (s) # 输出s
除了zfill()函数，format()函数也可以实现强大的格式化输出，如：
x=112
instr=input('请输入一个数字：')
print (format(instr,'0>5')) # 输出5位数字编号
print (format(instr,'*>5')) # 输出5位字符串，空位用*填充
print (format(instr,'>5')) # 输出5位字符串，空位用空格填充
锦囊07 进制输出
输出进制数可以采用操作符、进制转换函数和格式化函数format()来实现。
x=112
print("%o"%x) # 使用操作符输出八进制数
print("%x"%x) # 使用操作符输出十六进制数
# 输出十六进制、十进制、八进制数
print("nHex = %x,nDec = %d,nOct = %o" %(x,x,x))
print(bin(x)) # 使用bin()函数输出二进制数
print(oct(x)) # 使用oct()函数输出八进制数
print(hex(x)) # 使用hex()函数输出十六进制数
x = 112
print("{0:d}".format(x)) # 使用format函数输出十进制数
print("{0:x}".format(x)) # 使用format函数输出十六进制数
print("{0:o}".format(x)) # 使用format函数输出八进制数
print("{0:b}".format(x)) # 使用format函数输出二进制数
#综合输出进制数
print("int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(x))
# 综合输出带符号的各进制数
print("二进制: {0:#b}; 八进制: {0:#o} ;十进制: {0:#d}; 十六进制: {0:#x}".format(x))
锦囊08 输出彩色文字或背景
在PyCharm下要输出要输出彩色，可以在输出前设置显示方式，格式为：'\033[显示方式;前景色;背景色m '。显示方式，前景色，背景色是可选参数，可以只写其中的某一个。
print('\033[1;31m Stay hungry,Stay foolish!\033[0m') # 红色前景色输出名言
print('\033[1;32;45m 求知若饥,虚心若愚!\033[0m') # 绿色前景色输出名言，背景色为紫色
print('go big or go\033[1;35m home \033[0m!') # 设置文字中home 紫色前景色显示
# 设置文字中home绿色前景色，黄色背景色显示
print('go big or go\033[1;32;43m home \033[0m!')
print('\033[1;31;44mgo big or go home \033[0m') # 设置文字红色前景色，蓝色背景色显示
锦囊09 对齐输出数据
对齐数据可以使用rjust、ljust和center来实现。也可以使用格式化函数format()实现。
team="格林兰岛"
print(team.ljust(10)) #左对齐字符串，用空格号占位
print(team.ljust(10,'*')) #左对齐字符串，用*号占位
print(team.rjust(10,'*')) #右对齐字符串，用*号占位
print(team.rjust(10)) #右对齐字符串，用空格号占位
print(team.center(10)) #中间对齐字符串，用空格号占位
print(team.center(10,'*')) #中间对齐字符串，用*号占位
s="多特蒙德"
print(format(s,'*>20')) # 右对齐字符串，“*”为号占位符，“>”为右对齐符号，20宽度
print(format(s,'#<20')) # 左对齐字符串，“#”为号占位符，“<”为左对齐符号，20宽度
print(format(s,' ^20')) # 中间对齐字符串，空格“ ”为占位符，“^”对齐符号，20宽度
car=[ [1,"奔驰",489163],[2,"宝马",455051] ,[3,"奥迪",445300]]
for item in car: # 循环读取列表数据
tup='{0:0>3}\t{1:*^12}\t{2:$>12.2f}' # 设置对其格式和占位符
print(tup.format(item[0],item[1],float(item[2]))) # 输出数据未设置格式
锦囊10 输出内容到文件
设置参数file为目标文件名称，即可输出需要输出的内容到文件。代码如下：
fp = open('mingrisoft.txt','a+') # 'a+'以读写模式打开文件
text="go big or go home"
print(text,file=fp) # 输出到文件中
fp.close()
3.3 应用场景
场景一：输出嵌套列表的数据
对于复杂嵌套列表，如何格式化输出对应的数据呢？可以利用for循环读取数据，然后进行格式化处理，即可实现嵌套列表的格式化输出。代码如下：
college=['1,哈佛大学,Harvard University,美国,100','2,斯坦福大学,Stanford University,美国,76.5','3,剑桥大学,University of Cambridge,英国,70.9','4,麻省理工学院,Massachusetts Institute of Technology,美国,70.4','5,加州大学-伯克利,University of California Berkeley,美国,69.1']
print("{0:<3}\t{1:<12}\t{2:<31}\t{3:<4}\t{4:<6}".format('排名','中文名称','英文名称','国家','分数'))
for item in college:
line=item.split(',')
tupl = '{0:0>3}\t{1:<12}\t{2:<38}\t{3:<4}\t{4:>6.2f}'
print(tupl.format(line[0],line[1],line[2],line[3],float(line[4])))
排名 中文名称 英文名称 国家 分数
001 哈佛大学 Harvard University 美国 100.00
002 斯坦福大学 Stanford University 美国 76.50
003 剑桥大学 University of Cambridge 英国 70.90
004 麻省理工学院 Massachusetts Institute of Technology 美国 70.40
005 加州大学-伯克利 University of California Berkeley 美国 69.10
场景二：中英文多列对齐输出
中英文多列对齐输出德国、法国、英国2018年汽车销量数据。读取多个列表的数据，对数据输出时，如果进行格式化处理，输出不对齐，影响输出效果。代码如下：
gem=[["大众",643518],["奔驰",319163],["宝马",265051],["福特",252323],["雪铁龙",227967],["奥迪",255300]]
fra=[["雪铁龙", 698985],["雷诺",547704],["大众",259268],["福特",82633],["宝马",84931],["奔驰",73254]]
eng=[["福特",254082],["大众",203150],["雪铁龙",177298],["奔驰",172238],["宝马",172048],["奥迪",143739]]
for item1,item2,item3 in zip(gem,fra,eng):
print(item1[0],item1[1]," ",item2[0],item2[1]," ",item3[0],item3[1])
大众 643518 雪铁龙 698985 福特 254082
奔驰 319163 雷诺 547704 大众 203150
宝马 265051 大众 259268 雪铁龙 177298
福特 252323 福特 82633 奔驰 172238
雪铁龙 227967 宝马 84931 宝马 172048
奥迪 255300 奔驰 73254 奥迪 143739
如果数据中包含中文，则输出的列数据无法排列整齐。使用对齐函数ljust()对数据进行居左对齐显示，也无法对齐数据。因为中文占据的字符长度与英文不同，此时可以使用制表符’\t’来进行对齐输出。代码如下：
for item1,item2,item3 in zip(gem,fra,eng):
item11 = item1[0].ljust(8)
item12 = str(item1[1]).ljust(8)
item21 = item2[0].ljust(8)
item22 = str(item2[1]).ljust(8)
item31 = item1[0].ljust(8)
item32 = str(item3[1]).ljust(8)
print(item11 +"\t",item12+"\t"," ",item21+"\t",item22+"\t"," ",item31+"\t",item32)
场景三：实现程序主界面
利用print函数，可以输出程序界面，代码如下：
print("""\033[1;35m
****************************************************************
企业编码生成系统
****************************************************************
1.生成6位数字防伪编码 （213563型）
2.生成9位系列产品数字防伪编码(879-335439型)
3.生成25位混合产品序列号(B2R12-N7TE8-9IET2-FE35O-DW2K4型)
4.生成含数据分析功能的防伪编码(5A61M0583D2)
5.半智能防伪码自动生成(按指定样式数量自动生成)
6.企业粉丝防伪码抽奖
0.退出系统
================================================================
说明：通过数字键选择菜单
================================================================
\033[0m""")
4. 【实现标准输入】sys.stdin对象
4.1 语法参考
sys.stdin是一个标准化输入对象，可以连续输入或读入文件所有内容，不结束，不能直接使用。输入完成后，再对输入数据进行处理，这是sys.stdin的强大之处。sys.stdin.readline()方法和sys.stdin.readlines()方法是经常用到的方法，sys.stdin.readline()方法输入一行，输完成后自动添加’\n’。sys.stdin.readlines()可以连续输入数据，此时可以将输入的数据作为一个整体进行使用。sys.stdin.readline()的基本用法如下：
sys.stdin.readline()
使用sys.stdin.readline()与input()方法都可以实现标准化输入，但两者有以下区别：
-
sys.stdin.readline()方法不能填写提示输入信息的说明文字，但input()方法在括号内可以直接填写输入信息相关的说明文字，如input(‘请输入您的名字：’)。
-
sys.stdin.readline()方法会在输入新后加“\n”换行符，而input()方法在输入完成后不会添加任何内容。要想取消sys.stdin.readline()方法添加的换行符“\n”，可以使用strip(‘\n’) 去除换行符。
下面代码获取用户输入内容的长度，可以比较一下sys.stdin.readline()和input()输入内容的区别。代码如下：
import sys
line1 = sys.stdin.readline() # 包含换行符"\n"
line2 = sys.stdin.readline().strip('\n') # 去掉换行符"\n"
line3 = input("") # 不包含换行符"\n"
print(len(line1), len(line2), len(line3))
要输入多行数据，使用sys.stdin.readlines()方法是最有效的，该方法可以连续输入多行，输入完成时，需要回车到空行，然后按ctrl+D输出结果。
import sys
message = sys.stdin.readlines()
print(message)
4.2 实战技巧
锦囊1：常规输入相关内容
sys.stdin.readline()方法不能添加输入提示说明文字，如果要添加提示说明文字，需要使用print()方法进行输入信息提示，代码如下：
import sys
print('请输入您的名字: ')
name = sys.stdin.readline()
print('您输入的名字为: ', name)
锦囊2：将输入作为整体进行处理
在批量输入数据的时候，经常需要输完数据后在对数据做统一处理，如对数据统一编号、格式处理等，sys.stdin.readlines可以直接将输入的数据作为整体，输入完成后再做数据处理，如将用户输入的姓名前统一加上3位数字编号，输入完成时一定要回车，然后按“ctrl +D”输出程序运行结果。程序代码如下：
import sys
index=0 # 初始化编号
for line in sys.stdin.readlines(): # 按行读取输入的数据
line = line.strip() # 去掉空格和换行符
index=index+1 # 编号递进加1
if line: # 如果行输入不为空
txt=str(index).zfill(3)+" "+ line # 将输入的数据前加上3位编号
print (txt)
锦囊3：根据两点坐标计算直线的斜率
在勘探、地理探测工作中，有时需要根据输入空间的位置计算两点（x1,y1）(x2,y2)形成直线的斜率，斜率的计算公式为：(y2 - y1) / (x2 - x1)，下面编写一个程序，根据用户输入的两点坐标计算直线斜率k。代码如下：
import sys
print('请输入两点的4个坐标值，形式为x1 y1 x2 y2,用空格间隔！！')
while True:
line = sys.stdin.readline()
if line == '\n': break
x1, y1, x2, y2 = (float(x) for x in line.split())
k = abs(y2 - y1) / abs(x2 - x1)
print('两点坐标的斜率为：',format(k,'.2f'))
也可以直接使用sys.stdin对象输入数据，然后循环读取sys.stdin对象的数据。下面使用sys.stdin对象根据两点坐标计算直线的斜率，代码如下：
import sys
print('请输入两点的4个坐标值，形式为x1 y1 x2 y2,用空格间隔！！')
for line in sys.stdin:
if line == '\n': break
x1, y1, x2, y2 = (float(x) for x in line.split())
k = abs(y2 - y1) / abs(x2 - x1)
print( format(k,'.2f'))
锦囊4：利用sys.stdin读取文件信息
sys.stdin是一个普通文件对象，除了从标准输入读取内容以外，也可以使用sys.stdin调用读取文件信息。如读取文件”gjqh.txt”的所有国家区号，然后调用readlines函数将前3位为“* 8”的区号输出出来，实现代码如下：
import sys
fileName='gjqh.txt'
def readfile(file,ord): # 定义查询电话区号的函数readfile
with open(file) as txt: # 将国际区号信息文件赋值给变量txt
sys.stdin = txt # 将变量txt的数据赋值给sys.stdin对象
for line in sys.stdin.readlines(): # 按行读取sys.stdin对象的数据
line=line.strip() # 去除空格
if line [0:3]==ord: # 按每行数据的前3个字符查询
print(line) # 输出查询结果
readfile(fileName,'* 8') # 调用readfile()，查询国际区号前三个字符是 '* 8'的国家或地区
5. 【标准输出打印】sys.stdout.write()方法
5.1 语法参考
Sys.Stdout是sys模块中的标准输出对象，可以实现将数据向屏幕、文件等进行输出。Sys.Stdout通过write 方法实现数据的标准输出。Sys.Stdout.write()方法的基本用法如下：
sys.stdout .write(obj)
- obj：输出的内容或文件
事实上，使用print()方法进行打印输出时，其实是将内容传递给sys.stdout标准输出，然后通过sys.stdout.write()方法进行输出，Sys.Stdout.write() 输出完光标会停留在输出内容的最后位置。而print()方法输出后光标回跳到下一行行首，所以要实现等同效果，需要在Sys.Stdout.write()输出时追加一个换行符，如代码：
print('hello')
等同于：
import sys # 调用sys模块
sys.stdout.write('hello' + '\n')
5.2 实战技巧
锦囊1：常规输出内容到屏幕
sys.stdout.write()方法可以直接进行输出，配合转义字符可以进行换行、对齐等操作，在使用前一定先调用sys模块，下面举例一些常规的输出，代码如下：
import sys # 调用sys模块
sys.stdout.write('用户名称：') # 正常输出，光标在最后一个字符后面
sys.stdout.write('张三丰') # 在上一个光标处输出
sys.stdout.write('\n用户密码：') # 先换行输出，光标在最后一个字符后面
sys.stdout.write('********\n') # 在上一个光标处输出，输出完内容后换行到下一行行首
sys.stdout.write('确认密码：')
sys.stdout.write('********\n') # 输出完内容后换行到下一行行首
sys.stdout.write('商品名称\t') # 输出完内容后增加一个制表符距离
sys.stdout.write('商品价格\t') # 输出完内容后增加一个制表符距离
sys.stdout.write('采购数量\t') # 输出完内容后增加一个制表符距离
sys.stdout.write('商品金额')
锦囊2：在一行输出连续延时文字
在编写程序时，有时需要动态输出一些提示性文字，如程序加载、连网、或杀毒时，如果需要用户等待一点时间，可以输出提示用户并显示进度。下面代码实现在提示文字后动态输出程序加载进度：
import sys
import time
sys.stdout.write('程序正在安装，请稍后')
sys.stdout.write("\n")
for i in range(20):
sys.stdout.write('#')
如果动态输出的文字希望在原始位置跑马灯似的循环输出，需要将开始文字先定位到行首，然后输出并刷新。转移字符"\r"可以使光标回到行首，如代码：
sys.stdout.write("\r")
刷新输出使用flush()方法，如：
sys.stdout.flush()
下面代码实现动态跑马灯输出效果，每次循环输出1到6个状态，往复进行。代码如下：
import sys # 调用sys模块
import time
sys.stdout.write('动态输出跑马灯文字\n')
for i in range(20):
for j in range(6):
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(0.3)
sys.stdout.write("\r")
锦囊3：原位置动态输出文字或图标
在某些程序开发中，经常需要在某位置动态重复输出一些内容，如杀毒软件、计数程序、倒计时程序等。下面代码输出杀毒软件杀毒时提示用户杀毒时间的的动态模拟显示，代码如下：
import sys # 调用sys模块
import time
sys.stdout.write('杀毒程序正在全盘检查，请稍后\n')
for i in range(20):
sys.stdout.write("\r")
sys.stdout.write(r"\\")
time.sleep(0.3)
sys.stdout.write("\r")
sys.stdout.write(r"/")
time.sleep(0.3)
sys.stdout.write("\r")
sys.stdout.write(r"--")
time.sleep(0.3)
如果是计算程序，需要在原位置动态进行计数，如进行30个数的计数，代码如下：
import sys # 调用sys模块
import time
sys.stdout.write("\n")
sys.stdout.write('计数程序\n')
i=0
while i<30:
i=i+1
sys.stdout.write("\r")
sys.stdout.write(str(i))
sys.stdout.flush()
time.sleep(0.5)
倒数程序是在输入一个倒数数字后，按照输入的数字倒数的程序。倒数的数字需要动态在原始位置输出，如进行简单的60个数的倒数程序，代码如下：
import sys # 调用sys模块
import time
sys.stdout.write("\n")
sys.stdout.write('倒数程序\n')
i=int(input('请输入倒数的数字：'))
while i>0:
i=i-1
sys.stdout.write("\r")
sys.stdout.write(str(i))
sys.stdout.flush()
time.sleep(1)
5.3 应用场景
场景一：输出程序安装的进度条
安装程序时，通常都会有安装进度显示，以便让用户了解安装进度和时间。安装进度一般要用刻度显示安装进度情况，用百分比显示安装比例，如下程序，通过“|”格数显示安装进度，用百分比显示安装比例，设置batch参数数值可以控制安装格数和进度。代码如下：
import sys # 调入系统模块
import time # 调入时间模块
batch=1 # 控制安装的进度格
for i in range(int(100/batch)): # 100/batch 进度次数
sys.stdout.write("\r") # 回到行首
# 输出进度和百分比
sys.stdout.write('|'*i*batch + str(i*batch)+'%')
sys.stdout.flush() # 刷新输出
time.sleep(1) # 1秒暂停再执行
场景二：动态输出当前时间
在程序运行时，如果要动态显示当前的时间，程序运行的时间，该怎么实现呢？同样，使用sys.stdout流，结合时间模块，可以很容易实现，代码如下：
import sys # 调入系统模块
import time # 调入时间模块
sys.stdout.write('动态输出时间\n')
i=50
while i>0:
sys.stdout.write("\r")
sys.stdout.flush()
sys.stdout.write(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime() ))
time.sleep(0.5)
场景三：输出内容到文本文件
使用sys.stdout流不但可以将内容输出到屏幕，还可以输出到文件，代码如下：
import sys # 调入系统模块
with open('mingri.txt','w') as f:
sys.stdout=f
print('hello world') # 底层调用的 sys.stdout
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
