跳到主要内容

Python 基础实战

1. 概述

本节实现一个文件管理程序,该程序会使用到如下知识点:

  • 函数
  • 面向对象
    • 采用面向对象的程序设计方法对数据建模
  • 异常处理
    • 使用异常处理和文件相关的错误,例如文件不存在
  • 模块
    • 程序由多个源文件构成,每个源文件实现一个功能模块
  • os 模块
    • 需要使用 os 模块提供的方法
  • sys 模块
    • 需要使用 os 模块提供的方法
  • 文件访问

2. 程序功能

2.1 概述

文件管理程序提供了如下功能:

  • 列出目录下的文件名
  • 打印文件内容
  • 复制文件
  • 删除文件

文件管理程序是一个命令行程序,读取用户输入命令,然后执行返回命令执行结果。文件管理程序支持如下命令:

命令功能
ls dir列出目录 dir 下的文件
cat file打印文件 file 的内容
cp src dst复制源文件 src 到目标文件 dst
rm file删除文件 file
exit退出程序

2.2 测试文件 test.txt

本节需要使用一个用于测试的文本文件 test.txt,内容如下:

www
imooc
com

2.3 示例

下面的命令演示了文件管理程序的用法:

2.3.1 启动程序

C:\> python main.py
>

  • 在第 1 行,程序的主文件是 main.py,启动程序
  • 在第 2 行,程序启动后,打印提示符 >,等待用户输入命令

2.3.2 输入命令 help

> help
exit - exit program
cat file - print file
ls - list file in current dir
ls dir - list file in dir
cp src dst - copy file
rm file - remove file

  • 在第 1 行,输入命令 help,功能是打印各个命令的用法

2.3.3 输入命令 cat

> cat test.txt
www
imooc
com

  • 在第 1 行,输入命令 cat test.txt,功能是打印文件 test.txt 的内容

2.3.4 输入命令 ls

> ls
main.py
test.txt

  • 在第 1 行,输入命令 ls,功能是列出当前目录下的文件
> ls C:\
Documents and Settings
Program Files
Program Files (x86)
ProgramData
System Volume Information
Users
Windows

  • 在第 1 行,输入命令 ls C:\,功能是列出 C 盘根目录下的文件

2.3.5 输入命令 cp

> cp test.txt test.bak
> ls
main.py
test.txt
test.bak

  • 在第 1 行,输入命令 cp test.txt test.bak,功能是将文件 test.txt 复制到 test.bak
  • 在第 2 行,输入命令 ls,列出当前目录下的文件,发现新增了一个文件 test.bak

2.3.6 输入命令 rm

> rm test.bak
> ls
main.py
test.txt

  • 在第 1 行,输入命令 rm test.bak,功能是删除文件 test.bak
  • 在第 2 行,输入命令 ls,列出当前目录下的文件,发现文件 test.bak 被删除了

2.3.6 输入命令 exit

> exit
C:\>

  • 在第 1 行,输入命令 exit,功能是退出程序
  • 在第 2 行,返回到 DOS 命令行模式

2.4 错误处理

文件管理程序提供了错误处理功能,如果执行某条命令时发生了错误,例如文件不存在,仅仅终止该命令,而不是终止程序。

> cat non-exist-file
[Errno 2] No such file or directory: 'non-exisit-file'
>

  • 在第 1 行,打印文件 non-exist-file,该文件并不存在,cat 命令运行会出错
  • 在第 2 行,cat 命令执行中止,打印错误提示信息
  • 在第 3 行,cat 命令中止后,打印命令提示符,等待用户输入新的命令

3. 程序框架

文件管理程序由多个源文件构成,它们的功能如下:

源文件功能
main.py主控程序,读取用户的命令并执行
command.py定义类 Command,定义了命令的接口
help.py定义类 HelpCommand,实现 help 命令的功能
ls.py定义类 LsCommand,实现 ls 命令的功能
cat.py定义类 CatCommand,实现 cat 命令的功能
cp.py定义类 CpCommand,实现 cp 命令的功能
rm.py定义类 RmCommand,实现 rm 命令的功能

4. 实现主控程序

编写文件 main.py,读取用户的命令并执行:

import sys
import cat
import ls
import cp
import rm
import help

  • 在第 1 行导入 Python 内置的 sys 模块
  • 在第 2 行到第 6 行导入用户自定义的 5 个模块
    • cat 模块中定义了类 CatCommand,实现 cat 命令的功能
    • ls 模块中定义了类 LsCommand,实现 ls 命令的功能
    • cp 模块中定义了类 CpCommand,实现 cp 命令的功能
    • rm 模块中定义了类 RmCommand,实现 rm 命令的功能
    • help 模块中定义了类 HelpCommand,实现 help 命令的功能
def readAndExecute():
print('> ', end = '')
line = input()
args = line.split()
if len(args) == 0:
return

  • 在第 1 行,定义函数 readAndExecute(), 读取用户输入的命令并执行
  • 在第 2 行,打印提示符 >
  • 在第 3 行,读取用户输入的命令
  • 在第 4 行,将用户输入的命令分割为多个单词
    • 假设用户输入命令是 cp test.txt test.bak
    • 经过 split() 后,args = [‘cp’, ‘test.txt’, ‘test.bak’]
    arg0 = args[0]
if arg0 == 'exit':
sys.exit()
elif arg0 == 'cat':
command = cat.CatCommand(args)
elif arg0 == 'ls':
command = ls.LsCommand(args)
elif arg0 == 'cp':
command = cp.CpCommand(args)
elif arg0 == 'rm':
command = rm.RmCommand(args)
else:
command = help.HelpCommand(args)

command.execute()

  • 第 0 个参数是命令的名称,根据命令的名称构造相应的命令对象
    • 如果命令是 exit,调用 sys 模块的 exit 方法退出程序
    • 如果命令是 cat,使用 cat 模块中定义的类 CatCommand 实例化一个命令对象
    • 如果命令是 ls,使用 ls 模块中定义的类 LsCommand 实例化一个命令对象
    • 如果命令是 cp,使用 cp 模块中定义的类 CpCommand 实例化一个命令对象
    • 如果命令是 rm,使用 rm 模块中定义的类 RmCommand 实例化一个命令对象
    • 如果不是以上命令,使用 help 模块中定义的类 HelpCommand 实例化一个命令对象
  • 在最后,调用命令对象 command 的 execute 方法执行命令
while True:
try:
readAndExecute()
except IOError as error:
print(error)

  • 在第 1 行,定义循环,循环反复执行函数 readAndExecute()
  • 执行函数 readAndExecute 时,可能会出现 IOError
    • 在 try 语句中执行 readAndExecute
    • 使用 except 语句捕获执行过程中的 IOError,并打印 error
  • 注意,当 readAndExecute 出现异常时,仅仅终止 readAndExecute,而不是终止程序

5. 实现命令接口

编写文件 command.py 实现命令的接口:

class Command:
def \_\_init\_\_(self, args):
self.args = args

def execute(self):
print('Command.execute')

  • 在第 1 行,定义类 Command,描述了一个命令的接口
    • __init__ 方法,使用参数数组 args 构造一个命令
    • execute 方法,执行命令的功能,这里只提供了一个接口
  • 具体的命令如 LsCommand 继承类 Command,实现 execute 方法

6. 实现 help 命令

编写文件 help.py 实现 help 命令:

from command import Command

class HelpCommand(Command):
def \_\_init\_\_(self, args):
Command.__init__(self, args)

def execute(self):
print('exit - exit program')
print('cat file - print file')
print('ls - list file in current dir')
print('ls dir - list file in dir')
print('cp src dst - copy file')
print('rm file - remove file')

  • 在第 1 行,从 command 模块中导入类 Command
  • 在第 3 行,定义类 HelpCommand,继承于类 Command
  • 在第 5 行,调用父类的构造函数
  • 在第 7 行,定义 execute 方法,打印各个命令的功能

7. 实现 ls 命令

编写文件ls.py 实现 ls 命令:

from command import Command
import os

class LsCommand(Command):
def \_\_init\_\_(self, args):
Command.__init__(self, args)

def usage(self):
print('ls - list file in current dir')
print('ls dir - list file in dir')

  • 在第 1 行,从 command 模块中导入类 Command
  • 在第 3 行,定义类 HelpCommand,继承于类 Command
  • 在第 5 行,调用父类的构造函数
  • 在第 7 行,定义方法 usage 打印 ls 命令的功能
    def execute(self):
if len(self.args) == 1:
path = '.'
elif len(self.args) == 2:
path = self.args[1]
else:
self.usage()
return

  • 如果执行的命令是 ls,则设置 path 为 ‘.’,列出当前目录下的文件
  • 如果执行的命令是 ls dir,则设置 path 为 args[1],列出指定目录下的文件
        entries = os.listdir(path)
for entry in entries:
print(entry)

  • 调用 os 模块的 listdir 方法,列出目录 path 下的文件

8. 实现 cat 命令

编写文件 cat.py,定义类 CatCommand 用于实现 cat 命令的功能:

from command import Command

class CatCommand(Command):
def \_\_init\_\_(self, args):
Command.__init__(self, args)

def usage(self):
print('cat file - print file')

  • 在第 1 行,从 command 模块中导入类 Command
  • 在第 3 行,定义类 HelpCommand,继承于类 Command
  • 在第 5 行,调用父类的构造函数
  • 在第 7 行,定义方法 usage 打印 cat 命令的功能
    def execute(self):
if len(self.args) != 2:
self.usage()
return

path = self.args[1]

  • 如果命令为 cat file,则设置 path 为 args[1]
        file = open(path)
for line in file:
print(line, end = '')
file.close()

  • 使用 for 循环遍历文件的每一行,并输出

9. 实现 cp 命令

编写文件 cp.py,定义类 CpCommand 用于实现 cp 命令的功能

from command import Command

class CpCommand(Command):
def \_\_init\_\_(self, args):
Command.__init__(self, args)

def usage(self):
print('cp src dst - copy file')

  • 在第 1 行,从 command 模块中导入类 Command
  • 在第 3 行,定义类 CpCommand,继承于类 Command
  • 在第 5 行,调用父类的构造函数
  • 在第 7 行,定义方法 usage 打印 cp 命令的功能
    def execute(self):
if len(self.args) != 3:
self.usage()
return

src_path = self.args[1]
dst_path = self.args[2]

  • 设置 src_path 为 args[1]
  • 设置 dst_path 为 args[2]
        src_file = open(src_path, 'r')
dst_file = open(dst_path, 'w')
for line in src_file:
dst_file.write(line)
src_file.close()
dst_file.close()

  • 以只读方式打开 src_path,以只写方式打开 dst_path
  • 遍历源文件 src_file 的每一行,将其写入到 dst_file 中

10. 实现 rm 命令

编写文件 rm.py,定义类 RmCommand 用于实现 rm 命令的功能

from command import Command
import os

class RmCommand(Command):
def \_\_init\_\_(self, args):
Command.__init__(self, args)

def usage(self):
print('rm file - remove file')

  • 在第 1 行,从 command 模块中导入类 Command
  • 在第 3 行,定义类 RmCommand,继承于类 Command
  • 在第 5 行,调用父类的构造函数
  • 在第 7 行,定义方法 usage 打印 rm 命令的功能
    def execute(self):
if len(self.args) != 2:
self.usage()
return

path = self.args[1]
os.remove(path)

  • 调用 os 模块的 remove 方法删除文件