Python 基础实战

1. 概述

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

• 函数
• 面向对象

• 采用面向对象的程序设计方法对数据建模

• 异常处理

• 使用异常处理和文件相关的错误，例如文件不存在

• 模块

• 程序由多个源文件构成，每个源文件实现一个功能模块

• os 模块

• 需要使用 os 模块提供的方法

• sys 模块

• 需要使用 os 模块提供的方法

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

2. 程序功能

2.1 概述

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

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

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

2.2 测试文件 test.txt

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

www
5axxw
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
5axxw
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. 程序框架

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

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 命令的功能

• 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’]

• 假设用户输入命令是 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 方法执行命令
• 如果命令是 exit，调用 sys 模块的 exit 方法退出程序
• 如果命令是 cat，使用 cat 模块中定义的类 CatCommand 实例化一个命令对象
• 如果命令是 ls，使用 ls 模块中定义的类 LsCommand 实例化一个命令对象
• 如果命令是 cp，使用 cp 模块中定义的类 CpCommand 实例化一个命令对象
• 如果命令是 rm，使用 rm 模块中定义的类 RmCommand 实例化一个命令对象
• 如果不是以上命令，使用 help 模块中定义的类 HelpCommand 实例化一个命令对象

while True:
    try:
        readAndExecute()
    except IOError as error:
        print(error)

• 在第 1 行，定义循环，循环反复执行函数 readAndExecute()
• 执行函数 readAndExecute 时，可能会出现 IOError

• 在 try 语句中执行 readAndExecute
• 使用 except 语句捕获执行过程中的 IOError，并打印 error

• 注意，当 readAndExecute 出现异常时，仅仅终止 readAndExecute，而不是终止程序
• 在 try 语句中执行 readAndExecute
• 使用 except 语句捕获执行过程中的 IOError，并打印 error

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 方法
• __init__ 方法，使用参数数组 args 构造一个命令
• 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 方法删除文件