35、Python数据持久化与命令行工具开发

Python数据持久化与命令行工具开发

1. 数据持久化工具

在数据持久化方面，有两个重要的工具值得关注，分别是Storm和SQLAlchemy ORM。

1.1 Storm库的使用

Storm库可以用来操作数据库。即使记录不是使用Storm库插入的，也能正确显示。例如：

# 执行查询操作
jmjones@dinkgutsy:~/code$ python storm_retrieve_os.py 
1 Linux 2.0.34 kernel

若先运行添加脚本，再运行查询脚本，会显示数据库中已有的旧条目和新插入的条目：

jmjones@dinkgutsy:~/code$ python storm_add_os.py 
jmjones@dinkgutsy:~/code$ python storm_retrieve_os.py 
1 Linux 2.0.34 kernel
2 Windows 3.1.1

如果要对数据进行过滤，比如只查看以“Lin”开头的操作系统条目，可以使用以下代码：

import storm.locals
import storm_model
import os
db = storm.locals.create_database('sqlite:///%s' % os.path.join(os.getcwd(), 
  'inventory.db'))
store = storm.locals.Store(db)
for o in store.find(storm_model.OperatingSystem, 
  storm_model.OperatingSystem.name.like(u'Lin%')):
    print o.id, o.name, o.description

运行该代码后，输出结果如下：

jmjones@dinkgutsy:~/code$ python storm_retrieve_os_filter.py 
1 Linux 2.0.34 kernel

数据库中虽然有“Windows 3.1.1”条目，但由于“Windows”不以“Lin”开头，所以被过滤掉了。

1.2 SQLAlchemy ORM的使用

目前，SQLAlchemy似乎是Python中占主导地位的ORM。下面是 inventory_operatingsystem 表的定义和对象定义代码：

#!/usr/bin/env python
import os
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, Text, VARCHAR, MetaData
from sqlalchemy.orm import mapper
from sqlalchemy.orm import sessionmaker
engine = create_engine('sqlite:///%s' % os.path.join(os.getcwd(), 
        'inventory.db'))
metadata = MetaData()
os_table = Table('inventory_operatingsystem', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', VARCHAR(50)),
    Column('description', Text()),
)
class OperatingSystem(object):
    def __init__(self, name, description):
        self.name = name
        self.description = description
    def __repr__(self):
       return "<OperatingSystem('%s','%s')>" % (self.name, self.description)
mapper(OperatingSystem, os_table) 
Session = sessionmaker(bind=engine, autoflush=True, transactional=True)
session = Session()

与Storm示例的表定义代码相比，SQLAlchemy使用了一个额外的类，并将两者进行映射。

查询表中所有记录的代码如下：

#!/usr/bin/env python
from sqlalchemy_inventory_definition import session, OperatingSystem
for os in session.query(OperatingSystem):
    print os

运行该代码后，输出结果如下：

$ python sqlalchemy_inventory_query_all.py <OperatingSystem('Linux','2.0.34 kernel')>
<OperatingSystem('Windows','3.1.1')>
</OperatingSystem></OperatingSystem>

如果要创建新记录，可以通过实例化 OperatingSystem 对象并将其添加到会话中：

#!/usr/bin/env python
from sqlalchemy_inventory_definition import session, OperatingSystem
ubuntu_710 = OperatingSystem(name='Linux', description='2.6.22-14 kernel')
session.save(ubuntu_710)
session.commit()

再次运行查询所有记录的脚本，输出结果如下：

$ python sqlalchemy_inventory_query_all.py
<OperatingSystem('Linux','2.0.34 kernel')>
<OperatingSystem('Windows','3.1.1')>
<OperatingSystem('Linux','2.6.22-14 kernel')>

在SQLAlchemy中过滤结果也很简单。例如，要过滤出所有名称以“Lin”开头的 OperatingSystem ，可以使用以下脚本：

#!/usr/bin/env python
from sqlalchemy_inventory_definition import session, OperatingSystem
for os in session.query(OperatingSystem).filter(OperatingSystem.name.like('Lin%')):
    print os

运行该脚本后，输出结果如下：

$ python sqlalchemy_inventory_query_filter.py
<OperatingSystem('Linux','2.0.34 kernel')>
<OperatingSystem('Linux','2.6.22-14 kernel')>

2. 命令行工具开发

命令行对于系统管理员来说至关重要，掌握命令行工具的创建是成为系统管理大师的关键。

2.1 基本标准输入使用

创建命令行工具最简单的方法是使用 sys 模块的 sys.argv 来处理命令行参数。以下是一个简单的命令行工具示例：

#!/usr/bin/env python
import sys
print sys.argv

执行不同的命令，输出结果如下：

./sysargv.py
['./sysargv.py']
./sysargv.py foo
['./sysargv.py', 'test']
./sysargv.py foo bad for you
['./sysargv.py', 'foo', 'bad', 'for', 'you']

稍微修改代码，统计命令行参数的数量：

#!/usr/bin/env python
import sys
#Python indexes start at Zero, so let's not count the command itself which is
#sys.argv[0]
num_arguments = len(sys.argv) - 1
print sys.argv, "You typed in ", num_arguments, "arguments"

如果命令行没有传递参数，可以发送错误消息到标准输出：

#!/usr/bin/env python
import sys
num_arguments = len(sys.argv) - 1
#If there are no arguments to the command, send a message to standard error.
if num_arguments == 0:
        sys.stderr.write('Hey, type in an option silly\n')
else:
        print sys.argv, "You typed in ", num_arguments, "arguments"

不过，使用 sys.argv 创建命令行工具虽然简单，但往往不是最佳选择。Python标准库中的 optparse 模块可以处理创建高质量命令行工具时的各种复杂情况。

2.2 Optparse模块介绍

即使是小脚本，使用 optparse 处理选项也能带来很多好处。以下是一个“Hello World”示例：

#!/usr/bin/env python
import optparse
def main():
    p = optparse.OptionParser()
    p.add_option('--sysadmin', '-s', default="BOFH")
    options, arguments = p.parse_args()
    print 'Hello, %s' % options.sysadmin
if __name__ == '__main__':
    main()

运行该脚本，不同的输入会有不同的输出：

$ python hello_world_optparse.py 
Hello, BOFH
$ python hello_world_optparse.py --sysadmin Noah
Hello, Noah
$ python hello_world_optparse.py --s Jeremy     
Hello, Jeremy
$ python hello_world_optparse.py --infinity Noah
Usage: hello_world_optparse.py [options]

hello_world_optparse.py: error: no such option: --infinity

在这个小脚本中，可以设置短选项 -s 和长选项 --sysadmin ，以及默认值。同时， optparse 还提供了强大的内置错误处理功能。

2.3 Optparse的简单使用模式

• 无选项使用模式 ：即使不使用选项， optparse 也能发挥作用。以下是一个模仿 ls 命令的示例：

#!/usr/bin/env python
import optparse
import os
def main():
    p = optparse.OptionParser(description="Python  'ls' command clone",
                                prog="pyls",
                                version="0.1a",
                                usage="%prog [directory]")
    options, arguments = p.parse_args()
    if len(arguments) == 1:
        path = arguments[0]
        for filename in os.listdir(path):
            print filename
    else:
        p.print_help()
if __name__ == '__main__':
    main()

运行该脚本，不同的输入会有不同的输出：

$ python no_options.py .
.svn
hello_world_optparse.py
no_options.py
$ python no_options.py  
Usage: pyls [directory]

Python 'ls' command clone

Options:
--version   show program's version number and exit
-h, --help  show this help message and exit
$ python no_options.py --version
0.1a

• 布尔值使用模式 ：使用选项设置程序中的布尔值语句非常有用。例如，设置 --verbose 选项来触发额外输出， --quiet 选项来抑制所有标准输出：

#!/usr/bin/env python
import optparse
import os
def main():
    p = optparse.OptionParser(description="Python 'ls' command clone",
                                prog="pyls",
                                version="0.1a",
                                usage="%prog [directory]")
    p.add_option("--verbose", "-v", action="store_true",
                help="Enables Verbose Output",default=False)
    options, arguments = p.parse_args()
    if len(arguments) == 1:
        if options.verbose:
            print "Verbose Mode Enabled"
        path = arguments[0]
        for filename in os.listdir(path):
            if options.verbose:
                print "Filename: %s " % filename
            elif options.quiet:
                pass
            else:
                print filename
    else:
        p.print_help()
if __name__ == '__main__':
    main()

运行该脚本，不同的输入会有不同的输出：

$ python true_false.py /tmp
.aksusb
alm.log
amt.log
authTokenData
FLEXnet
helloworld
hsperfdata_ngift
ics10003
ics12158
ics13342
icssuis501
MobileSync.lock.f9e26440fe5adbb6bc42d7bf8f87c1e5fc61a7fe
summary.txt
$ python true_false.py --verbose /tmp
Verbose Mode Enabled
Filename: .aksusb 
Filename: alm.log 
Filename: amt.log 
Filename: authTokenData 
Filename: FLEXnet 
Filename: helloworld 
Filename: hsperfdata_ngift 
Filename: ics10003 
Filename: ics12158 
Filename: ics13342 
Filename: icssuis501 
Filename: MobileSync.lock.f9e26440fe5adbb6bc42d7bf8f87c1e5fc61a7fe 
Filename: summary.txt

在脚本中，设置 default=False 和 action="store_true" ，意味着默认情况下选项值为 False ，但如果用户指定了该选项，则将选项值设置为 True 。

• 计数选项使用模式 ：在典型的Unix命令行工具中，多次指定同一个选项可以增加输出的详细程度。使用 optparse 也可以实现相同的功能：

#!/usr/bin/env python
import optparse
import os
def main():
    p = optparse.OptionParser(description="Python 'ls' command clone",
                                prog="pyls",
                                version="0.1a",
                                usage="%prog [directory]")
    p.add_option("-v", action="count", dest="verbose")
    options, arguments = p.parse_args()
    if len(arguments) == 1:
        if options.verbose:
            print "Verbose Mode Enabled at Level: %s" % options.verbose
        path = arguments[0]
        for filename in os.listdir(path):
            if options.verbose == 1:
                print "Filename: %s " % filename
            elif options.verbose ==2 :
                fullpath = os.path.join(path,filename)
                print "Filename: %s | Byte Size: %s" % (filename,
                                    os.path.getsize(fullpath))
            else:
                print filename
    else:
        p.print_help()
if __name__ == '__main__':
    main()

运行该脚本，指定 -vv 选项的输出结果如下：

$ python verbosity_levels_count.py -vv /tmp
Verbose Mode Enabled at Level: 2
Filename: .aksusb | Byte Size: 0
Filename: alm.log | Byte Size: 1403
Filename: amt.log | Byte Size: 3038
Filename: authTokenData | Byte Size: 32
Filename: FLEXnet | Byte Size: 170
Filename: helloworld | Byte Size: 170
Filename: hsperfdata_ngift | Byte Size: 102
Filename: ics10003 | Byte Size: 0
Filename: ics12158 | Byte Size: 0
Filename: ics13342 | Byte Size: 0
Filename: ics14183 | Byte Size: 0
Filename: icssuis501 | Byte Size: 0
Filename: MobileSync.lock.f9e26440fe5adbb6bc42d7bf8f87c1e5fc61a7fe | Byte Size: 0
Filename: summary.txt | Byte Size: 382

• 选择选项使用模式 ：有时候，为选项提供几个选择会更方便。例如，将 --verbose 和 --quiet 选项合并为 --chatty 选项：

#!/usr/bin/env python
import optparse
import os
def main():
    p = optparse.OptionParser(description="Python 'ls' command clone",
                                prog="pyls",
                                version="0.1a",
                                usage="%prog [directory]")
    p.add_option("--chatty", "-c", action="store", type="choice",
                    dest="chatty",
                    choices=["normal", "verbose", "quiet"],
                    default="normal")
    options, arguments = p.parse_args()
    print options
    if len(arguments) == 1:
        if options.chatty == "verbose":
            print "Verbose Mode Enabled"
        path = arguments[0]
        for filename in os.listdir(path):
            if options.chatty == "verbose":
                print "Filename: %s " % filename
            elif options.chatty == "quiet":
                pass
            else:
                print filename
    else:
        p.print_help()
if __name__ == '__main__':
    main()

运行该脚本，不同的输入会有不同的输出：

$ python choices.py --chatty     
Usage: pyls [directory]

pyls: error: --chatty option requires an argument
$ python choices.py --chatty=nuclear /tmp
Usage: pyls [directory]

pyls: error: option --chatty: invalid choice: 'nuclear' (choose from 'normal', 
  'verbose', 'quiet')
$ python choices.py --chatty=verbose /tmp
{'chatty': 'verbose'}
Verbose Mode Enabled
Filename: .aksusb 
Filename: alm.log 
Filename: amt.log 
Filename: authTokenData 
Filename: FLEXnet 
Filename: helloworld 
Filename: hsperfdata_ngift 
Filename: ics10003 
Filename: ics12158 
Filename: ics13342 
Filename: ics14183 
Filename: icssuis501 
Filename: MobileSync.lock.f9e26440fe5adbb6bc42d7bf8f87c1e5fc61a7fe 
Filename: summary.txt
$ python choices.py --chatty=quiet /tmp  
{'chatty': 'quiet'}

使用选择选项的好处是可以防止用户输入错误的参数，用户只能从预定义的选项中进行选择。

综上所述，Python提供了丰富的工具和库来进行数据持久化和命令行工具开发。在数据持久化方面，Storm和SQLAlchemy ORM都有各自的优势；在命令行工具开发方面， optparse 模块可以帮助我们创建高质量的命令行工具。通过合理使用这些工具和库，我们可以更高效地完成各种任务。

Python数据持久化与命令行工具开发

3. 数据持久化工具对比

为了更清晰地了解Storm和SQLAlchemy ORM的特点，我们可以从多个方面对它们进行对比，以下是详细对比表格：
| 对比项 | Storm | SQLAlchemy ORM |
| — | — | — |
| 流行程度 | 正在获得关注并构建社区，但目前不如SQLAlchemy | 当前Python中占主导地位的ORM |
| 表定义方式 | 相对简洁直接 | 使用额外的类并进行映射，稍显复杂 |
| 查询功能 | 支持基本查询和过滤，如 store.find() 并可传入搜索条件 | 支持丰富的查询和过滤功能，如 session.query().filter() |
| 代码示例复杂度 | 过滤数据示例代码相对简洁 | 表定义和操作代码相对较多，结构更复杂 |

从这个对比表格可以看出，如果你追求简洁和快速开发简单的数据库操作，Storm可能是一个不错的选择；如果你需要处理复杂的数据库关系和更强大的查询功能，SQLAlchemy ORM会更合适。

4. 命令行工具开发总结与拓展

4.1 不同使用模式总结

在命令行工具开发中， optparse 模块提供了多种使用模式，每种模式都有其独特的应用场景，总结如下：
- 无选项使用模式 ：适用于只需要处理参数，不需要额外选项的简单命令行工具。它可以利用 optparse 的内置帮助信息，方便用户了解工具的使用方法。
- 布尔值使用模式 ：常用于控制程序的不同输出级别，如详细输出或静默输出。通过设置布尔选项，可以根据用户的选择调整程序的行为。
- 计数选项使用模式 ：当需要根据用户指定选项的次数来调整输出的详细程度时，这种模式非常有用。例如，多次使用 -v 选项可以逐步增加输出的详细信息。
- 选择选项使用模式 ：为用户提供预定义的选项选择，避免用户输入错误的参数，增强了命令行工具的健壮性。

4.2 命令行工具开发流程

以下是使用 optparse 开发命令行工具的一般流程的mermaid流程图：

graph TD;
    A[开始] --> B[导入optparse模块];
    B --> C[创建OptionParser对象];
    C --> D[添加选项和设置默认值];
    D --> E[解析命令行参数];
    E --> F{参数是否符合要求};
    F -- 是 --> G[执行相应操作];
    F -- 否 --> H[显示帮助信息];
    G --> I[结束];
    H --> I[结束];

具体步骤如下：
1. 导入模块 ：在Python脚本中导入 optparse 模块。
2. 创建对象 ：使用 optparse.OptionParser() 创建一个选项解析器对象。
3. 添加选项 ：通过 add_option() 方法添加各种选项，设置选项的短名称、长名称、默认值、帮助信息等。
4. 解析参数 ：使用 parse_args() 方法解析命令行参数，得到选项和参数的对象。
5. 检查参数 ：根据业务需求检查解析得到的参数是否符合要求。
6. 执行操作 ：如果参数符合要求，执行相应的操作；否则，显示帮助信息。

4.3 拓展建议

• 结合其他模块 ：可以将 optparse 与其他Python标准库或第三方库结合使用，如 os 、 sys 、 re 等，以实现更复杂的功能。例如，结合 os 模块可以进行文件操作，结合 re 模块可以进行正则表达式匹配。
• 错误处理优化 ：在命令行工具中，除了使用 optparse 的内置错误处理功能外，还可以添加自定义的错误处理逻辑，以提供更友好的错误提示信息。
• 用户交互增强 ：可以考虑添加更多的用户交互功能，如提示用户输入信息、确认操作等，以提高工具的易用性。

通过以上对数据持久化工具和命令行工具开发的介绍，我们可以看到Python在这两个领域都提供了丰富的工具和灵活的开发方式。无论是处理数据存储还是创建命令行工具，Python都能帮助我们高效地完成任务。希望这些内容能对你有所帮助，让你在Python开发中更加得心应手。