简明Python教程 10)编写 11)OO

第10章 解决问题--编写一个python脚本

结合所有内容编写一个脚本:

问题 要一个可以为所有重要文件创建备份的程序;

分析 哪些文件? 保存在哪? 怎样存储?

设计

1) 需要备份的文件和目录由一个列表指定;

2) 备份保存在主备份目录中;

3) 文件备份成zip文件;

4) zip存档的名称是当前的日期和时间;

5) 使用标准的zip命令, 通常默认由Linux提供; Windows用户可以使用Info-zip [或7z]; 可以使用任何的存档命令, 只需要有命令行界面就够了, 可以通过脚本中传递参数;

解决方案

Solution Implement:

version 1

import  os
import  time

# 1. The files and directories to be backed up are specified in a list.
source  =  [ '/home/swaroop/byte' ,  '/home/swaroop/bin' ]
# If you are using Windows, use source = [r'C:\Documents', r'D:\Work'] or something like that

# 2. The backup must be stored in a main backup directory
target_dir  =  '/mnt/e/backup/'  # Remember to change this to what you will be using

# 3. The files are backed up into a zip file.
# 4. The name of the zip archive is the current date and time
target  =  target_dir  +  time.strftime( '%Y%m%d%H%M%S' )  +  '.zip'

# 5. We use the zip command (in Unix/Linux) to put the files in a zip archive
zip_command  =  "zip -qr '%s' %s"  %  (target,  ' ' .join(source))

# Run the backup
if  os.system(zip_command)  = =  0 :
    print  ( 'Successful backup to' , target)
else :
    print  ( 'Backup FAILED' )

经过测试和调试, 消除程序中的错误bug;

>输入os和time模块, 在source列表中指定需要备份的文件和目录; zip归档的名称是当前的日期和时间: time.strftime(); strftime()需要使用定制: %Y会被无世纪的年份替代, m%会被01到12之间的一个十进制月份数替代, 其他依次类推; (详细内容见<Python参考手册>) 这些定制和print语句的定制(%后跟元组)类似;

>使用加法操作符来 级连 字符串, 把两个字符串连接在一起返回一个新字符串; 

zip命令: -q表示安静工作; -r表示对目录递归; 可以组合成 -qr; zip命令形式: zip -option target source;

os.system函数运行命令, 相当于在系统中运行命令, Linux对应的是shell--运行成功返回0, 失败则返回错误号;

Note Windows用户: 可以把source列表和target目录设置成任何文件和目录名, 但是Windows把反斜杠 \ 作为目录分隔符, 而python用反斜杠表示转义符; 所以要使用转义符表示反斜杠或使用自然字符串, e.g. C\\Documents 或 r'C:\Documents'; 不能直接使用'C:\Document', 这样会引入未知的转义序列\D;

[在python的string前加上r, 告诉解释器这个string是个raw string, 不要转义反斜杠backslash- \ ]

[Windows]

import  os
import  time

source  =  [ 'C:\\log.txt' ]  #如果字符串中有空格,需要使用双引号
target_dir  =  'D:\\Temp\\'
target  =  target_dir  +  time.strftime( '%Y%m%d%H%M%S' )  +  '.zip'
zip_command  =  "7z a %s %s"  %  (target, ''.join(source))
print (zip_command)
# Run the backup
if  os.system(zip_command)  = =  0 :
    print  ( 'Successful backup to' , target)
else :
    print  ( 'Backup FAILED' )

实施: 对于Linux用户, 可以把py文件作为可执行文件, 可以在任何时间地点运行备份;

version 2

维护 优化: 采用更好的文件名机制--使用时间作为文件名, 日期作为目录名; 这样备份会以等级结构存储, 容易管理, 文件名的长度也能缩短;

import  os
import  time

#The files and directories to be backed up are specified in a list.
source  =  [ 'C:\\log.txt' ]
target_dir  =  'D:\\Temp\\'
#The current day is the name of the subdirectory in the main directory
today  =  target_dir  +  time.strftime( '%Y%m%d' )
now  =  time.strftime( '%H%M%S' )
# Create the subdirectory if it isn't already there
if  not  os.path.exists(today):
    os.mkdir(today)
    print  ( 'Sucessfully created directory' , today)
target  =  today  +  os.sep  +  now  +  '.zip'
zip_command  =  "7z a %s %s"  %  (target, ''.join(source))
print (zip_command)
# Run the backup
if  os.system(zip_command)  = =  0 :
    print  ( 'Successful backup to' , target)
else :
    print  ( 'Backup FAILED' )

>os.exists函数检验在主备份目录中是否有以当前日期作为名称的目录; 使用os.mkdir创建目录;

>os.sep变量: 会根据操作系统给出目录分隔符, 在Linux下是'/'. Windows下是'\\', Mac OS下是':' ; 使用os.sep代替字符可以使得程序具备移植性;

version 3

version2在备份较多的时候还不错, 但是如果要区分每个备份是干什么的, 会十分困难; 要把改动历史与zip归档名称联系起来, 可以通过在zip归档名上附带用户注释来实现;

import  os
import  time

#The files and directories to be backed up are specified in a list.
source  =  [ 'C:\\log.txt' ]
target_dir  =  'D:\\Temp\\'
#The current day is the name of the subdirectory in the main directory
today  =  target_dir  +  time.strftime( '%Y%m%d' )
now  =  time.strftime( '%H%M%S' )
# Take a comment from the user to create the name of the zip file
comment  =  input ( 'Enter a comment-->' )
if  len (comment) = =  0 :
    target  =  today  +  os.sep  +  now  +  '.zip'
else :
    target  =  today  +  os.sep  +  now  +  '_'  +
        comment.replace( ' ' , '_' )  +  '.zip'

# Create the subdirectory if it isn't already there
if  not  os.path.exists(today):
    os.mkdir(today)
    print  ( 'Sucessfully created directory' , today)
#zip_command = "zip -qr {0} {1}".format(target, ' '.join(source))
zip_command  =  "7z a %s %s"  %  (target, ''.join(source))
print (zip_command)
# Run the backup
if  os.system(zip_command)  = =  0 :
    print  ( 'Successful backup to' , target)
else :
    print  ( 'Backup FAILED' )

>运行报错, 语法错误;

修订: 对于target = today + os.sep + now + '_' + 一行, 必须指定物理行尾的反斜杠 \ 来表示逻辑行在下一个物理行继续; 否则语法错误;

version 4

将报错的一行修改:

target  =  today  +  os.sep  +  now  +  '_'  +  \

>input[py2中是raw_input]函数得到用户的注释, 通过len得到输入的长度, 确认用户输入, 如果用户直接按了回车(惯例修改), 就按之前的流程继续操作; 如果提供了注释, 就附加到zip归档名, 把空格换成下划线, 有利于文件处理;

进一步优化

使用-v选项可以使程序更具交互性; 或者直接将文件和目录通过命令行传递给脚本: 通过sys.argv获取输入; list类提供了extend方法把输入加到source列表中;

使用tar代替zip, 这样在结合使用tar和gzip命令的时候, 备份更快更小; 对于Windows, Winzip也能处理.tar.gz文件; tar在大多数Linux中是默认的; Windwos用户也能使用: http://gnuwin32.sourceforge.net/

tar  =  'tar -cvzf %s %s -X /home/swaroop/excludes.txt'  %  (target,  ' ' .join(srcdir))

> -c 表示创建一个归档; -v 表示交互; -z 表四使用gzip滤波器; -f 表示强制创建归档, 如果有同名文件, 就替换; -X 表示旱灾指定文件名列表中的文件会被排除在备份之外; e.g. 在文件中指定*~, 将不会备份包括所有以~结尾的文件;

Note 理想的创建归档的方法是分别使用zipfile和tarfile; 他们是py标准库的一部分; 使用这些库可以避免使用os.system函数(不推荐使用的函数, 容易引发严重错误);

软件开发过程

1) 什么(分析) 2) 如何(设计) 3) 编写(实施) 4) 测试(测试和调试) 5) 使用(实施或开发) 6) 维护(优化)

Note 创建这个备份脚本的过程是编写程序的推荐方法--进行分析和设计; 从简单版本开始, 经过测试调试, 早增加特性, 根据需要重复 编写-测试-使用的周期; 软件是grow的, 不是build的;

第11章 面向对象的编程 

简介

目前为止, 例子中都是根据操作数据的函数或语句块来设计程序, 这称为 面向过程的 编程; 还有一种把数据和功能结合起来, 用对象包裹组织程序的方法, 称为 面向对象的 编程; 大多数时候可以使用过程性编程, 但是当编写大型程序或寻求更合适的解决方案的时候, 就需要使用面向对象的编程;

两个主要方面: 类 创建一个类型; 对象 是类的实例; e.g. int类型变量, 这个存储整数的变量是int类的实例;

Note To 静态语言程序员 整数也被作为对象(int类); 和C++/Java把整数纯粹作为类型[原生数据类型]是不同的; 参见help(int); C#和Java1.5中类似 封装和解封装 的概念;

对象可以使用普通的属于对象的变量存储数据; 属于一个对象或类的变量被称为域/字段; 对象也可以使用属于类的函数来具有功能, 这样的函数被称为类的方法; 域和方法可以合称为类的属性; 

域有两种--属于每个实例/对象的, 属于类本身的; 分别称为实例变量和类变量; [static的概念]

类使用class关键字创建, 类的域和方法被列在一个缩进块中;

self

类的方法与普通的函数有一个特别的区别: 必须有一个额外的第一个参数名称; 但是在调用这个方法的时候不用为这个参数赋值, python会提供这个值; 这个特别的变量指对象本身, 按照惯例他的名称是self; 

虽然这个参数可以给任何名称, 但是强烈建议使用self; 使用标准名称可以迅速识别, 有些IDE也能帮助识别;

Note To C++/Java/C# python中的self等价于this指针/引用;

Python如何给self赋值, e.g. MyClass类实例MyObject, 当调用MyObject.method(arg1, arg2)的时候, 会由python自动转为MyClass.method(MyObject, arg1, arg2), 这就是self的原理; 这意味着如果你有一个不需要参数的方法, 还是要给这个方法定义一个self参数;

类

class  Person:
    pass  # An empty block

p  =  Person()
print  (p)

>class加上类名来创建类; 缩进的语句块形成类体; pass表示空白块;

>类名加上圆括号创建对象/实例; 打印对象输出显示: __main__.Person instance at 0xf6fcb18c: 在main模块中有一个Person的实例; 存储对象的内存地址也会打印出来;

对象的方法

和普通函数/方法的区别是由一个额外的self变量/参数;

class  Person:
    def  sayHi( self ):
        print  ( 'Hello, how are you?' )

p  =  Person()
p.sayHi()
# This short example can also be written as Person().sayHi()

>sayHi没有参数, 但仍然要在函数定义时有self;

__init__方法

__init_-方法在类的一个对象被建立/初始化时, 马上运行, 这个方法可以用来对对象做 初始化; 

class  Person:
    def  __init__( self , name):
        self .name  =  name
    def  sayHi( self ):
        print ( '嗨，我的名字是' ,  self .name)

p  =  Person( 'Swaroop' )
p.sayHi()
# 这个小程序也可以写成 Person('Swaroop').sayHi()

>__init__方法定义一个参数name, 创建一个新的域称为name; 用self.name可以区分它们: 对象的域vs局部变量;

我们没有显式地调用__init__方法, 而是在创建实例的时候, 把参数传递给类;

Note To C++/Java/C# __init__方法类似构造constructor;

类与对象的变量

类的数据, 是与类和对象的名称空间绑定的变量;

两种类型: 类的变量和对象的变量;

类变量由类的所有对象/实例共享使用; 类变量只有一份, 所以当某个对象对类变量做了改动, 所有的实例都会随之改变;

对象的变量由每个实例拥有; 每个对象都有一份拷贝, 不共享; 在同一个类的不同实例中, 即使对象的变量名称相同, 也是相互没有关系的; 

class  Robot:
    '''表示人一机器人，有一个名字。'''

    # 一个类变量，数机器人的数量
    population  =  0

    def  __init__( self , name):
        '''初始化数据。'''
        self .name  =  name
        print ( '(初始化 {0})' . format ( self .name))

        # 当创建一个人时，机器人
        # 人口加1
        Robot.population  + =  1

    def  __del__( self ):
        '''我将要死了。'''
        print ( '{0} 正在被毁！' . format ( self .name))

        Robot.population  - =  1

        if  Robot.population  = =  0 :
            print ( '{0}是最后一个。' . format ( self .name))
        else :
            print ( '还有{0:d}机器人在工作。' . format (Robot.population))

    def  sayHi( self ):
        '''机器人问候。

        是的，它们能做作那个。'''
        print ( '你好，我的主人叫我' . format ( self .name))

    def  howMany():
        '''打印当前人口。'''
        print ( '我们有{0:d}个机器人。' . format (Robot.population))
    howMany  =  staticmethod (howMany)


droid1  =  Robot( 'R2-D2' )
droid1.sayHi()
Robot.howMany()

droid2  =  Robot( 'C-3PO' )
droid2.sayHi()
Robot.howMany()

print ( "\n机器人在这能做一些工作。\n" )

print ( "机器人已经完成了它们的工作，因此，让我们销毁它们。" )
del  droid1
del  droid2

Robot.howMany()

>population属于Robot, 是类的变量; name属于对象(self赋值), 是对象的变量; 因此使用的时候是 Robot.populaction, self.name;

Note 一个对象变量与一个类变量名字相同时, 类变量将被隐藏;

>howMany是一个类方法, 不是对象方法, 我们可以将其定义成classmethod或staticmethod, 这取决于是否知道是哪个类; 

Note 可以使用decorator(http://www.ibm.com/developerworks/linux/library/l-cpdecor.html)达到同样的目的:

@staticmethod
def  howMany():
    '''打印当前人口。'''
    print ( '我们有{0:d}个机器人。' . format (Robot.population))

[类似Java] 

修饰符可以被想象成一个调用显式声明的快捷方式;

>__init__方法使用一个名字初始化Robot实例; self.name的值是针对每一个对象的, 这是对象变量的特性;

Note 你必须使用self引用同一对象的变量和方法--属性引用;

>文档字符串docstring: 可以通过Robot.__doc__访问类的文档字符串, 通过Robot.sayHi.__doc__访问方法的文档字符串;

>和__init__方法类似, 有一个特殊的方法__del__, 当对象销毁时调用; 对象销毁则对象不再被使用, 并且释放它所占用的计算机内存;

Note 当对象不再被使用时, __del__方法会运行; 但是很难保证这个方法在确定的时间运行; 因此你想要明确地释放对象, 就要显式地调用del;

Note To C++/Java/C# python中所有的类成员(包括数据成员)都是公共的, 所有方法都是虚拟virtual的; 

只有一个例外, 如果你使用的数据成员名称以双下划线前缀, 例如__privatevar, python的名称管理体系会把它作为私有变量; 

命名惯例: 如果某个变量指向在类或对象内使用, 用单下划线前缀, 其他的名称作为公共的, 可以被其他类/对象使用; 这只是作为惯例, 和python强制执行的双下划线前缀不同;

__del__类似析构函数destructor;

继承

面向对象编程带来的好处之一是代码重用; 实现重用的方法之一就是继承; 子类类型可以被替换成父类, 子类对象可以被视为父类的实例--多态;

class  SchoolMember:
    '''代表任何学校成员。'''
    def  __init__( self , name, age):
        self .name  =  name
        self .age  =  age
        print ( '(初始化学校成员： {0})' . format ( self .name))

    def  tell( self ):
        '''告诉我细节。'''
        print ( 'Name:"{0}" Age:"{1}"' . format ( self .name,  self .age), end = " " )

class  Teacher(SchoolMember):
    '''代表老师。'''
    def  __init__( self , name, age, salary):
        SchoolMember.__init__( self , name, age)
        self .salary  =  salary
        print ( '(初始化老师： {0})' . format ( self .name))

    def  tell( self ):
        SchoolMember.tell( self )
        print ( 'Salary: "{0:d}"' . format ( self .salary))

class  Student(SchoolMember):
    '''代表学生。'''
    def  __init__( self , name, age, marks):
        SchoolMember.__init__( self , name, age)
        self .marks  =  marks
        print ( '(初始化学生： {0})' . format ( self .name))

    def  tell( self ):
        SchoolMember.tell( self )
        print ( 'Marks: "{0:d}"' . format ( self .marks))

t  =  Teacher( 'Mrs. Shrividya' ,  40 ,  30000 )
s  =  Student( 'Swaroop' ,  25 ,  75 )

print ()  # 打印一个空行

members  =  [t, s]
for  member  in  members:
    member.tell()  # Teachers和Students都可以

>使用继承, 在类定义中, 类的名称后的元组中指定基类名称, 显式地调用基类的__init__方法, 初始化基类;

Note python不会自动调用基类的构造函数, 必须显式地调用它;

>在方法之前调用类前缀, 用来调用基类方法; 可以将参数和self传递给它;

>子类调用了tell()方法, 而不是基类; python总是首先查找对应类型的方法, 如果在子类中找不到, 才会在类定义的元组中按顺序逐个在基类中查找;

Note 如果在继承元组中列出一个以上的类, 称为多重继承;

>tell()方法中的end参数是用来将换行变为在print()调用结束后的空格;

---TBC---YC